job::internal Namespace Reference

Classes
struct	PrivateCtx

Typedefs
using	JobFn = void(*)(const PrivateCtx &ctx)

Functions
void	AssertHandler (const bool condition, const char *const filename, const int line_number, const char *const msg)
void	DispatchImpl (const char *const name, Counter *const counter, const QueueMode queue, const JobFn func, const std::size_t user_data_size, const std::size_t user_data_alignment, const void *const user_data, void(*InitUserData)(void *const user_data, const void *const in_user_data)) noexcept

Typedef Documentation

JobFn

using job::internal::JobFn = typedef void (*)(const PrivateCtx& ctx)

Definition at line 234 of file job_api.hpp.

Function Documentation

AssertHandler()

void job::internal::AssertHandler	(	const bool	condition,
		const char *const	filename,
		const int	line_number,
		const char *const	msg
	)

DispatchImpl()

void job::internal::DispatchImpl ( const char *const  name, Counter *const  counter, const QueueMode  queue, const JobFn  func, const std::size_t  user_data_size, const std::size_t  user_data_alignment, const void *const  user_data, void(*)(void *const user_data, const void *const in_user_data)  InitUserData  )

noexcept

Definition at line 947 of file job_system.cpp.

{
  const WorkerID               worker_id            = worker::GetCurrentID();
  job::ThreadLocalState* const worker               = system::GetWorker(worker_id);
  const std::uint32_t          max_tasks_per_worker = g_JobSystem->num_tasks_per_worker;
 
  // Try to ensure some tasks are free to allocate.
  {
    if (worker->num_allocated_tasks == max_tasks_per_worker)
    {
      worker::GarbageCollectAllocatedTasks(worker);
 
      if (worker->num_allocated_tasks == max_tasks_per_worker)
      {
        // While we cannot allocate do some work.
        system::WakeUpAllWorkers();
 
        while (worker->num_allocated_tasks == max_tasks_per_worker)
        {
          worker::TryRunTask(worker);
          worker::GarbageCollectAllocatedTasks(worker);
        }
      }
    }
  }
 
  Task* const        task     = task_pool::AllocateTask(&worker->task_allocator, name, func, counter);
  const TaskHandle   task_hdl = task_pool::TaskToIndex(worker->task_allocator, task);
  const job::TaskPtr task_ptr = {worker_id, task_pool::TaskToIndex(worker->task_allocator, task)};
 
  // Copy user data
  {
    const Byte* const    user_data_end    = task->user_data + sizeof(task->user_data);
    Byte* const          aligned_ptr      = static_cast<Byte*>(AlignPointer(task->user_data, user_data_alignment));
    const Byte* const    aligned_ptr_end  = aligned_ptr + user_data_size;
    const std::ptrdiff_t alignment_offset = aligned_ptr - task->user_data;
 
    JobAssert(aligned_ptr_end <= user_data_end, "Userdata could not be stored in task.");
    JobAssert(alignment_offset <= std::uint8_t(-1), "Alignment delta too large.");
 
    InitUserData(aligned_ptr, user_data);
    task->userdata_align = static_cast<std::uint8_t>(alignment_offset);
  }
 
  worker->allocated_tasks[worker->num_allocated_tasks++] = task_hdl;
 
  const WorkerID num_workers = NumWorkers();
 
  // If we only have one thread running using the worker queue is invalid.
  switch ((num_workers == 1u) ? QueueMode::Default : queue)
  {
    case QueueMode::Default:
    {
      task::SubmitQPushHelper(task_ptr, worker, &worker->normal_queue);
      break;
    }
    case QueueMode::WorkerOnly:
    {
      task::SubmitQPushHelper(task_ptr, worker, &worker->worker_queue);
      break;
    }
    default:
#if defined(__GNUC__)  // GCC, Clang, ICC
      __builtin_unreachable();
#elif defined(_MSC_VER)  // MSVC
      __assume(false);
#endif
      break;
  }
 
  const std::int32_t num_pending_jobs = g_JobSystem->num_available_jobs.fetch_add(1, std::memory_order_relaxed);
 
  if (num_pending_jobs >= num_workers)
  {
    system::WakeUpAllWorkers();
  }
  else
  {
    system::WakeUpOneWorker();
  }
}

References job::Default, g_JobSystem, JobAssert, job::JobSystemContext::num_available_jobs, job::JobSystemContext::num_tasks_per_worker, job::NumWorkers(), and job::WorkerOnly.

Referenced by job::Dispatch().