Namable(name),

_manager(manager),

_cvar(manager->_lock),

_tick_clock(false),

_timeslice_priority(false),

_num_threads(0),

_thread_priority(TP_normal),

_frame_budget(-1.0),

_frame_sync(false),

_num_busy_threads(0),

_num_tasks(0),

_num_awaiting_tasks(0),

_state(S_initial),

_current_sort(-INT_MAX),

_pickup_mode(false),

_needs_cleanup(false),

_current_frame(0),

_time_in_frame(0.0),

_block_till_next_frame(false),

_next_implicit_sort(0)

{

nassertv(num_threads >= 0);

if (task_cat.is_debug()) {

do_output(task_cat.debug());

task_cat.debug(false)

<< ": set_num_threads(" << num_threads << ")\n";

}

if (!Thread::is_threading_supported()) {

num_threads = 0;

}

MutexHolder holder(_manager->_lock);

if (_num_threads != num_threads) {

do_stop_threads();

_num_threads = num_threads;

if (_num_tasks != 0) {

do_start_threads();

}

}

MutexHolder holder(_manager->_lock);

if (_thread_priority != priority) {

do_stop_threads();

_thread_priority = priority;

if (_num_tasks != 0) {

do_start_threads();

}

}

if (_state == S_started || _state == S_interrupted) {

// Clean up all of the threads.

MutexHolder holder(_manager->_lock);

do_stop_threads();

}

if (_state == S_initial || _state == S_interrupted) {

MutexHolder holder(_manager->_lock);

do_start_threads();

}

MutexHolder holder(_manager->_lock);

if (task->_chain != this) {

nassertr(!do_has_task(task), false);

return false;

}

if (task->_state == AsyncTask::S_servicing_removed) {

return false;

}

// The task might not actually be in the active queue, since it might be

// being serviced right now. That's OK.

return true;

MutexHolder holder(_manager->_lock);

AsyncTaskCollection result = do_get_active_tasks();

result.add_tasks_from(do_get_sleeping_tasks());

return result;

nassertv(task->_chain == nullptr &&

task->_manager == nullptr &&

task->_chain_name == get_name() &&

task->_state == AsyncTask::S_inactive);

nassertv(!do_has_task(task));

do_start_threads();

task->_chain = this;

task->_manager = _manager;

double now = _manager->_clock->get_frame_time();

task->_start_time = now;

task->_start_frame = _manager->_clock->get_frame_count();

// Remember the order in which tasks were added to the chain.

task->_implicit_sort = _next_implicit_sort++;

_manager->add_task_by_name(task);

if (task->has_delay()) {

// This is a deferred task. Add it to the sleeping queue.

task->_wake_time = now + task->get_delay();

task->_start_time = task->_wake_time;

task->_state = AsyncTask::S_sleeping;

_sleeping.push_back(task);

push_heap(_sleeping.begin(), _sleeping.end(), AsyncTaskSortWakeTime());

} else {

// This is an active task. Add it to the active set.

task->_state = AsyncTask::S_active;

if (task_cat.is_spam()) {

task_cat.spam()

<< "Adding " << *task << " with sort " << task->get_sort()

<< " to chain " << get_name() << " with current_sort "

<< _current_sort << "\n";

}

if (task->get_sort() >= _current_sort) {

// It will run this frame.

_active.push_back(task);

push_heap(_active.begin(), _active.end(), AsyncTaskSortPriority());

} else {

// It will run next frame.

_next_active.push_back(task);

}

}

++_num_tasks;

++(_manager->_num_tasks);

_needs_cleanup = true;

_cvar.notify_all();

nassertr(task->_chain == this, false);

switch (task->_state) {

case AsyncTask::S_servicing:

// This task is being serviced. upon_death will be called afterwards.

task->_state = AsyncTask::S_servicing_removed;

return true;

case AsyncTask::S_servicing_removed:

// Being serviced, though it is already marked to be removed afterwards.

return false;

case AsyncTask::S_sleeping:

// Sleeping, easy.

{

int index = find_task_on_heap(_sleeping, task);

nassertr(index != -1, false);

PT(AsyncTask) hold_task = task;

_sleeping.erase(_sleeping.begin() + index);

make_heap(_sleeping.begin(), _sleeping.end(), AsyncTaskSortWakeTime());

cleanup_task(task, upon_death, false);

}

return true;

case AsyncTask::S_active:

{

// Active, but not being serviced, easy.

PT(AsyncTask) hold_task = task;

int index = find_task_on_heap(_active, task);

if (index != -1) {

_active.erase(_active.begin() + index);

make_heap(_active.begin(), _active.end(), AsyncTaskSortPriority());

} else {

index = find_task_on_heap(_next_active, task);

if (index != -1) {

_next_active.erase(_next_active.begin() + index);

} else {

index = find_task_on_heap(_this_active, task);

nassertr(index != -1, false);

}

}

cleanup_task(task, upon_death, false);

return true;

}

default:

break;

}

return false;

do_start_threads();

if (_threads.empty()) {

// Non-threaded case.

while (_num_tasks > 0) {

if (_state == S_shutdown || _state == S_interrupted) {

return;

}

do_poll();

}

} else {

// Threaded case.

while (_num_tasks > 0) {

if (_state == S_shutdown || _state == S_interrupted) {

return;

}

PStatTimer timer(_wait_pcollector);

_cvar.wait();

}

}

if (task_cat.is_spam()) {

do_output(task_cat.spam());

task_cat.spam(false)

<< ": do_cleanup()\n";

}

do_stop_threads();

_num_threads = 0;

// Don't call the upon_death functions while we clean up the tasks.

// Instead, store all the tasks in a list as we clean them up, and then call

// the upon_death functions all at once. We do this because calling

// upon_death wil release the lock, allowing the iterators to become

// invalid.

TaskHeap dead;

dead.reserve(_num_tasks);

_needs_cleanup = false;

TaskHeap::const_iterator ti;

for (ti = _active.begin(); ti != _active.end(); ++ti) {

AsyncTask *task = (*ti);

dead.push_back(task);

cleanup_task(task, false, false);

}

for (ti = _this_active.begin(); ti != _this_active.end(); ++ti) {

AsyncTask *task = (*ti);

dead.push_back(task);

cleanup_task(task, false, false);

}

for (ti = _next_active.begin(); ti != _next_active.end(); ++ti) {

AsyncTask *task = (*ti);

dead.push_back(task);

cleanup_task(task, false, false);

}

for (ti = _sleeping.begin(); ti != _sleeping.end(); ++ti) {

AsyncTask *task = (*ti);

dead.push_back(task);

cleanup_task(task, false, false);

}

// There might still be one task remaining: the currently-executing task.

nassertv(_num_tasks == 0 || _num_tasks == 1);

// Now go back and call the upon_death functions.

_manager->_lock.unlock();

for (ti = dead.begin(); ti != dead.end(); ++ti) {

(*ti)->upon_death(_manager, false);

}

_manager->_lock.lock();

if (task_cat.is_spam()) {

do_output(task_cat.spam());

task_cat.spam(false)

<< ": done do_cleanup()\n";

}

return (find_task_on_heap(_active, task) != -1 ||

find_task_on_heap(_next_active, task) != -1 ||

find_task_on_heap(_sleeping, task) != -1 ||

find_task_on_heap(_this_active, task) != -1);

for (int i = 0; i < (int)heap.size(); ++i) {

if (heap[i] == task) {

return i;

}

}

return -1;

if (!_active.empty()) {

PT(AsyncTask) task = _active.front();

pop_heap(_active.begin(), _active.end(), AsyncTaskSortPriority());

_active.pop_back();

if (thread != nullptr) {

thread->_servicing = task;

}

if (task_cat.is_spam()) {

task_cat.spam()

<< "Servicing " << *task << " in "

<< *Thread::get_current_thread() << "\n";

}

nassertv(task->get_sort() == _current_sort);

nassertv(task->_state == AsyncTask::S_active);

task->_state = AsyncTask::S_servicing;

task->_servicing_thread = thread;

AsyncTask::DoneStatus ds = task->unlock_and_do_task();

if (thread != nullptr) {

thread->_servicing = nullptr;

}

task->_servicing_thread = nullptr;

if (task->_chain == this) {

if (task->_state == AsyncTask::S_servicing_removed) {

// This task wants to kill itself.

cleanup_task(task, true, false);

} else if (task->_chain_name != get_name()) {

// The task wants to jump to a different chain.

PT(AsyncTask) hold_task = task;

cleanup_task(task, false, false);

task->jump_to_task_chain(_manager);

} else {

switch (ds) {

case AsyncTask::DS_cont:

// The task is still alive; put it on the next frame's active queue.

task->_state = AsyncTask::S_active;

_next_active.push_back(task);

_cvar.notify_all();

break;

case AsyncTask::DS_again:

// The task wants to sleep again.

{

double now = _manager->_clock->get_frame_time();

task->_wake_time = now + task->get_delay();

task->_start_time = task->_wake_time;

task->_state = AsyncTask::S_sleeping;

_sleeping.push_back(task);

push_heap(_sleeping.begin(), _sleeping.end(), AsyncTaskSortWakeTime());

if (task_cat.is_spam()) {

task_cat.spam()

<< "Sleeping " << *task << ", wake time at "

<< task->_wake_time - now << "\n";

}

_cvar.notify_all();

}

break;

case AsyncTask::DS_pickup:

// The task wants to run again this frame if possible.

task->_state = AsyncTask::S_active;

_this_active.push_back(task);

_cvar.notify_all();

break;

case AsyncTask::DS_interrupt:

// The task had an exception and wants to raise a big flag.

task->_state = AsyncTask::S_active;

_next_active.push_back(task);

if (_state == S_started) {

_state = S_interrupted;

_cvar.notify_all();

}

break;

case AsyncTask::DS_await:

// The task wants to wait for another one to finish.

task->_state = AsyncTask::S_awaiting;

_cvar.notify_all();

++_num_awaiting_tasks;

break;

default:

// The task has finished.

cleanup_task(task, true, true);

}

}

} else {

task_cat.error()

<< "Task is no longer on chain " << get_name()

<< ": " << *task << "\n";

}

if (task_cat.is_spam()) {

task_cat.spam()

<< "Done servicing " << *task << " in "

<< *Thread::get_current_thread() << "\n";

}

}

thread_consider_yield();

if (task_cat.is_spam()) {

do_output(task_cat.spam());

task_cat.spam(false)

<< ": cleanup_task(" << *task << ", " << upon_death << ", " << clean_exit

<< ")\n";

}

nassertv(task->_chain == this);

task->_state = AsyncTask::S_inactive;

task->_chain = nullptr;

--_num_tasks;

--(_manager->_num_tasks);

_manager->remove_task_by_name(task);

if (upon_death) {

_manager->_lock.unlock();

if (task->set_future_state(clean_exit ? AsyncFuture::FS_finished

: AsyncFuture::FS_cancelled)) {

task->notify_done(clean_exit);

}

task->upon_death(_manager, clean_exit);

_manager->_lock.lock();

}

task->_manager = nullptr;

nassertr(_num_busy_threads == 0, true);

if (!_threads.empty()) {

PStatClient::thread_tick(get_name());

}

if (!_active.empty()) {

// There are more tasks; just set the next sort value.

nassertr(_current_sort < _active.front()->get_sort(), true);

_current_sort = _active.front()->get_sort();

_cvar.notify_all();

return true;

}

// There are no more tasks in this epoch; advance to the next epoch.

if (!_this_active.empty() && _frame_budget >= 0.0) {

// Enter pickup mode. This is a special mode at the end of the epoch in

// which we are just re-running the tasks that think they can still run

// within the frame, in an attempt to use up our frame budget.

if (task_cat.is_spam()) {

do_output(task_cat.spam());

task_cat.spam(false)

<< ": next epoch (pickup mode)\n";

}

_pickup_mode = true;

_active.swap(_this_active);

} else {

// Not in pickup mode.

if (task_cat.is_spam()) {

do_output(task_cat.spam());

task_cat.spam(false)

<< ": next epoch\n";

}

_pickup_mode = false;

// Here, there's no difference between _this_active and _next_active.

// Combine them.

_next_active.insert(_next_active.end(), _this_active.begin(), _this_active.end());

_this_active.clear();

_active.swap(_next_active);

// We only tick the clock and wake sleepers in normal mode, the first time

// through the task list; not in pickup mode when we are re-running the

// stragglers just to use up our frame budget.

if (_tick_clock) {

if (task_cat.is_spam()) {

do_output(task_cat.spam());

task_cat.spam(false)

<< ": tick clock\n";

}

_manager->_clock->tick();

_manager->_frame_cvar.notify_all();

} else if (_frame_sync) {

// If we're a synced chain, we have to wait at the end of the epoch for

// someone else to tick the clock.

_block_till_next_frame = true;

}

// Check for any sleeping tasks that need to be woken.

double now = _manager->_clock->get_frame_time();

while (!_sleeping.empty() && _sleeping.front()->_wake_time <= now) {

PT(AsyncTask) task = _sleeping.front();

if (task_cat.is_spam()) {

task_cat.spam()

<< "Waking " << *task << ", wake time at "

<< task->_wake_time - now << "\n";

}

pop_heap(_sleeping.begin(), _sleeping.end(), AsyncTaskSortWakeTime());

_sleeping.pop_back();

task->_state = AsyncTask::S_active;

task->_start_frame = _manager->_clock->get_frame_count();

_active.push_back(task);

}

if (task_cat.is_spam()) {

if (_sleeping.empty()) {

task_cat.spam()

<< "No more tasks on sleeping queue.\n";

} else {

task_cat.spam()

<< "Next sleeper: " << *_sleeping.front() << ", wake time at "

<< _sleeping.front()->_wake_time - now << "\n";

}

}

// Any tasks that are on the active queue at the beginning of the epoch

// are deemed to have run one frame (or to be about to).

TaskHeap::const_iterator ti;

for (ti = _active.begin(); ti != _active.end(); ++ti) {

AsyncTask *task = (*ti);

++task->_num_frames;

}

}

if (_timeslice_priority) {

filter_timeslice_priority();

}

nassertr((size_t)_num_tasks == _active.size() + _this_active.size() + _next_active.size() + _sleeping.size() + (size_t)_num_awaiting_tasks, true);

make_heap(_active.begin(), _active.end(), AsyncTaskSortPriority());

_current_sort = -INT_MAX;

if (!_active.empty()) {

// Signal the threads to start executing the first task again.

_cvar.notify_all();

return true;

}

// There are no tasks to be had anywhere. Chill.

_pickup_mode = false;

nassertr(_this_active.empty(), false);

return false;

if (_active.empty()) {

return;

}

nassertv(_timeslice_priority);

// We must first sum up the average per-epoch runtime of each task.

double net_runtime = 0.0;

int net_priority = 0;

TaskHeap::iterator ti;

for (ti = _active.begin(); ti != _active.end(); ++ti) {

AsyncTask *task = (*ti);

double runtime = max(task->get_average_dt(), 0.0);

int priority = max(task->_priority, 1);

net_runtime += runtime;

net_priority += priority;

}

// That gives us a timeslice budget per priority value.

double average_budget = net_runtime / (double)net_priority;

TaskHeap keep, postpone;

for (ti = _active.begin(); ti != _active.end(); ++ti) {

AsyncTask *task = (*ti);

double runtime = max(task->get_average_dt(), 0.0);

int priority = max(task->_priority, 1);

double consumed = runtime / (double)priority;

// cerr << *task << " consumed " << consumed << " vs. " << average_budget

// << "\n";

if (consumed > average_budget) {

// Postpone. Run this task next epoch.

postpone.push_back(task);

} else {

// Keep, and run this task this epoch.

keep.push_back(task);

}

}

if (keep.empty()) {

// Hmm, nothing to keep. Grab the postponed task with the highest

// priority and keep that instead.

nassertv(!postpone.empty());

ti = postpone.begin();

TaskHeap::iterator max_ti = ti;

++ti;

while (ti != postpone.end()) {

if ((*ti)->_priority > (*max_ti)->_priority) {

max_ti = ti;

}

}

// cerr << "Nothing to keep, keeping " << *(*max_ti) << " instead\n";

keep.push_back(*max_ti);