Exemple #1
0
    void task_tracker::wait_outstanding_tasks()
    {
        for (int i = 0; i < _task_bucket_count; i++)
        {
            while (true)
            {
                trackable_task::owner_delete_state prepare_state;
                trackable_task *tcm;

                {
                    utils::auto_lock<::dsn::utils::ex_lock_nr_spin> l(_outstanding_tasks_lock[i]);
                    auto n = _outstanding_tasks[i].next();
                    if (n != &_outstanding_tasks[i])
                    {
                        tcm = CONTAINING_RECORD(n, trackable_task, _dl);
                        prepare_state = tcm->owner_delete_prepare();
                    }
                    else
                        break; // assuming nobody is putting tasks into it anymore
                }

                switch (prepare_state)
                {
                case trackable_task::OWNER_DELETE_NOT_LOCKED:
                    dsn_task_wait(tcm->_task);
                    tcm->owner_delete_commit();
                    break;
                case trackable_task::OWNER_DELETE_LOCKED:
                case trackable_task::OWNER_DELETE_FINISHED:
                    break;
                }
            }
        }
    }
Exemple #2
0
TEST(core, lpc)
{
    std::string result;
    auto t = dsn_task_create(LPC_TEST_HASH, on_lpc_test, (void*)&result, 1);
    dsn_task_add_ref(t);
    dsn_task_call(t, 0);
    dsn_task_wait(t);
    dsn_task_release_ref(t);

    EXPECT_TRUE(result.substr(0, result.length() - 2) == "client.THREAD_POOL_TEST_SERVER");
}
Exemple #3
0
    void task_tracker::wait_outstanding_tasks()
    {
        for (int i = 0; i < _task_bucket_count; i++)
        {
            while (true)
            {
                trackable_task::owner_delete_state prepare_state;
                trackable_task *tcm;

                {
                    utils::auto_lock< ::dsn::utils::ex_lock_nr_spin> l(_outstanding_tasks_lock[i]);
                    auto n = _outstanding_tasks[i].next();
                    if (n != &_outstanding_tasks[i])
                    {
                        tcm = CONTAINING_RECORD(n, trackable_task, _dl);

                        // try to get the lock
                        prepare_state = tcm->owner_delete_prepare();
                    }
                    else
                        break; // assuming nobody is putting tasks into it anymore
                }

                task* tsk;
                switch (prepare_state)
                {
                // tracker get the lock
                case trackable_task::OWNER_DELETE_NOT_LOCKED:
                    if (s_hack.under_emulation())
                    {
                        tsk = (task*)(tcm->_task);
                        tsk->add_ref();    // released after delete commit           
                        tcm->owner_delete_commit();

                        tsk->wait(); // wait outside the delete spin lock
                        tsk->release_ref(); // added before delete commit
                    }
                    else
                    {
                        dsn_task_wait(tcm->_task);
                        tcm->owner_delete_commit();
                    }
                    break;
                case trackable_task::OWNER_DELETE_LOCKED:
                case trackable_task::OWNER_DELETE_FINISHED:
                    break;
                }
            }
        }
    }