Namespaces
namespace	internal

Classes
struct	Counter
	The only syncronization mechanism. Allows you to wait on tasks you asssociated with this counter. More...

struct	Ctx

struct	InitializationLock

struct	JobSystemContext

struct	JobSystemCreateOptions
	The runtime configuration for the Job System. More...

struct	JobSystemMemoryRequirements
	The memory requirements for a given configuration `JobSystemCreateOptions`. More...

class	LockedQueue

class	MPMCQueue

struct	Splitter

class	SPMCDeque

class	SPSCQueue

struct	Task

union	TaskMemoryBlock

struct	TaskPool

struct	TaskPtr

struct	ThreadLocalState

Typedefs
using	WorkerID = std::uint16_t
	The id type of each worker thread. More...

using	TaskHandle = std::uint16_t

using	TaskHandleType = TaskHandle

using	AtomicTaskHandleType = std::atomic< TaskHandle >

using	WorkerIDType = WorkerID

using	AtomicInt32 = std::atomic_int32_t

using	Byte = unsigned char

using	AtomicTaskPtr = std::atomic< job::TaskPtr >

Enumerations
enum class	QueueMode : std::uint8_t { Default , WorkerOnly }
	Determines which threads the task will be allowed to run on. More...

enum class	SPMCDequeStatus { SUCCESS , FAILED_RACE , FAILED_SIZE }

Functions
std::size_t	NumSystemThreads () noexcept
	Makes system calls to grab the number threads / processors on the device. This function can be called by any thread concurrently. More...

void	Initialize (const JobSystemMemoryRequirements &memory_requirements={}, void *const memory=nullptr) noexcept
	Sets up the Job system and creates all the worker threads. The thread that calls 'job::Initialize' is considered the main thread. More...

const char *	ProcessorArchitectureName () noexcept
	An implementation defined name for the CPU architecture of the device. This function can be called by any thread concurrently. More...

std::uint16_t	NumWorkers () noexcept
	Returns the number of workers created by the system. This function can be called by any thread concurrently. More...

WorkerID	CurrentWorker () noexcept
	The current id of the current thread. This function can be called by any thread concurrently. More...

bool	IsMainThread () noexcept
	Allows for querying if we are currently executing in the main thread. More...

void	Shutdown () noexcept
	This will deallocate any memory used by the system and shutdown any threads created by 'bfjob::initialize'. More...

template<typename Closure >
void	Dispatch (const char const name, Counter const counter, const Closure &Callback, const QueueMode queue=QueueMode::Default) noexcept
	Main API entrypoint, Pushes a task onto the queue. More...

void	WaitOn (const Counter &counter) noexcept
	Blocks until all tasks associated with `counter` are done while This function will block but do work while being blocked. More...

void	PauseProcessor () noexcept
	CPU pause instruction to indicate when you are in a spin wait loop. More...

void	YieldTimeSlice () noexcept
	Asks the OS to yield this threads execution to another thread on the current cpu core. More...

template<typename F , typename S >
void	ParallelFor (const char const name, Counter const counter, const std::size_t start, const std::size_t count, S &&splitter, F &&fn, const QueueMode queue=QueueMode::Default)
	Parallel for algorithm, splits the work up recursively splitting based on the `splitter` passed in. More...

template<typename T , typename F , typename S >
void	ParallelFor (const char const name, Counter const counter, T *const data, const std::size_t count, S &&splitter, F &&fn, const QueueMode queue=QueueMode::Default)

template<typename... F>
void	ParallelInvoke (const char const name, Counter const counter, const QueueMode queue, F &&... fns)
	Invokes each passed in function object in parallel. More...

template<typename Splitter , typename Reducer >
void	ParallelReduce (const char const name, Counter const counter, const std::size_t start, const std::size_t count, Splitter &&splitter, Reducer &&reduce, const QueueMode queue=QueueMode::Default)

Variables
static constexpr std::size_t	k_FalseSharingPadSize = std::hardware_destructive_interference_size

static constexpr std::size_t	k_CachelineSize = 64u

static constexpr std::size_t	k_ExpectedTaskSize = std::max(std::size_t(128u), k_CachelineSize)

static constexpr TaskHandle	NullTaskHandle = std::numeric_limits<TaskHandle>::max()

Class Documentation

◆ job::Counter

struct job::Counter

The only syncronization mechanism. Allows you to wait on tasks you asssociated with this counter.

See also: job::WaitOn

Definition at line 48 of file job_api.hpp.

Class Members
atomic_uint64_t	unfinished_tasks

◆ job::InitializationLock

struct job::InitializationLock

Definition at line 175 of file job_system.cpp.

Class Members
mutex	init_mutex
condition_variable	init_cv
atomic_uint32_t	num_workers_ready

◆ job::JobSystemContext

struct job::JobSystemContext

Definition at line 182 of file job_system.cpp.

Class Members
ThreadLocalState *	workers
uint32_t	num_workers
atomic_uint32_t	num_user_threads_setup
uint32_t	num_tasks_per_worker
InitializationLock	init_lock
const char *	sys_arch_str
size_t	system_alloc_size
size_t	system_alloc_alignment
bool	needs_delete
atomic_bool	is_running
mutex	worker_sleep_mutex
condition_variable	worker_sleep_cv
atomic_uint32_t	num_available_jobs

◆ job::JobSystemCreateOptions

struct job::JobSystemCreateOptions

The runtime configuration for the Job System.

Definition at line 86 of file job_api.hpp.

Class Members
uint16_t	num_threads	Use 0 to indicate using the number of cores available on the system.
uint16_t	normal_queue_size	Number of tasks in each worker's `QueueType::Default` queue. (Must be power of two)
uint16_t	worker_queue_size	Number of tasks in each worker's `QueueType::WorkerOnly` queue. (Must be power of two)
uint64_t	job_steal_rng_seed	The RNG for work queue stealing will be seeded with this value.

◆ job::TaskMemoryBlock

union job::TaskMemoryBlock

Definition at line 150 of file job_system.cpp.

Class Members
TaskMemoryBlock *	next
unsigned char	storage[sizeof(Task)]

◆ job::TaskPool

struct job::TaskPool

Definition at line 157 of file job_system.cpp.

Class Members
TaskMemoryBlock *	memory
TaskMemoryBlock *	freelist

◆ job::ThreadLocalState

struct job::ThreadLocalState

Definition at line 163 of file job_system.cpp.

Class Members
SPMCDeque< TaskPtr >	normal_queue
SPMCDeque< TaskPtr >	worker_queue
TaskPool	task_allocator
TaskHandle *	allocated_tasks
TaskHandleType	num_allocated_tasks
ThreadLocalState *	last_stolen_worker
pcg_state_setseq_64	rng_state
thread	thread_id

Typedef Documentation

◆ WorkerID

using job::WorkerID = typedef std::uint16_t

The id type of each worker thread.

Definition at line 39 of file job_api.hpp.

◆ TaskHandle

using job::TaskHandle = typedef std::uint16_t

Definition at line 79 of file job_system.cpp.

◆ TaskHandleType

using job::TaskHandleType = typedef TaskHandle

Definition at line 80 of file job_system.cpp.

◆ AtomicTaskHandleType

using job::AtomicTaskHandleType = typedef std::atomic<TaskHandle>

Definition at line 81 of file job_system.cpp.

◆ WorkerIDType

using job::WorkerIDType = typedef WorkerID

Definition at line 82 of file job_system.cpp.

◆ AtomicInt32

using job::AtomicInt32 = typedef std::atomic_int32_t

Definition at line 83 of file job_system.cpp.

◆ Byte

using job::Byte = typedef unsigned char

Definition at line 84 of file job_system.cpp.

◆ AtomicTaskPtr

using job::AtomicTaskPtr = typedef std::atomic<job::TaskPtr>

Definition at line 112 of file job_system.cpp.

Enumeration Type Documentation

◆ QueueMode

enum class job::QueueMode : std::uint8_t

strong

Determines which threads the task will be allowed to run on.

Enumerator
Default	Tasks in this queue will run on either the main or worker threads.
WorkerOnly	Tasks in this queue will never run on the main thread.

Definition at line 64 of file job_api.hpp.

  {
    Default,     
    WorkerOnly,  
  };

◆ SPMCDequeStatus

enum class job::SPMCDequeStatus

strong

Enumerator
SUCCESS	Returned from Push, Pop and Steal.
FAILED_RACE	Returned from Pop and Steal.
FAILED_SIZE	Returned from Push, Pop and Steal.

Definition at line 228 of file job_queue.hpp.

  {
    SUCCESS,      
    FAILED_RACE,  
    FAILED_SIZE,  
  };

Function Documentation

◆ NumSystemThreads()

std::size_t job::NumSystemThreads ( )

noexcept

Makes system calls to grab the number threads / processors on the device. This function can be called by any thread concurrently.

Can be called even if the job system has not been initialized.

Returns: std::size_t The number threads / processors on the computer.

Definition at line 811 of file job_system.cpp.

{
#if IS_SINGLE_THREADED
  return 1;
#else
  const auto n = std::thread::hardware_concurrency();
  return n != 0 ? n : 1;
#endif
 
#if 0
 
#if IS_WINDOWS
    SYSTEM_INFO sysinfo;
    GetSystemInfo(&sysinfo);
    return sysinfo.dwNumberOfProcessors;
#elif IS_POSIX
    return sysconf(_SC_NPROCESSORS_ONLN) /* * 2*/;
#elif 0  // FreeBSD, MacOS X, NetBSD, OpenBSD
    nt          mib[4];
    int         numCPU;
    std::size_t len = sizeof(numCPU);
 
    /* set the mib for hw.ncpu */
    mib[0] = CTL_HW;
    mib[1] = HW_AVAILCPU;  // alternatively, try HW_NCPU;
 
    /* get the number of CPUs from the system */
    sysctl(mib, 2, &numCPU, &len, NULL, 0);
 
    if (numCPU < 1)
    {
      mib[1] = HW_NCPU;
      sysctl(mib, 2, &numCPU, &len, NULL, 0);
      if (numCPU < 1)
        numCPU = 1;
    }
 
    return numCPU;
#elif 0  // HPUX
    return mpctl(MPC_GETNUMSPUS, NULL, NULL);
#elif 0  // IRIX
    return sysconf(_SC_NPROC_ONLN);
#elif 0  // Objective-C (Mac OS X >=10.5 or iOS)
    NSUInteger a = [[NSProcessInfo processInfo] processorCount];
    NSUInteger b = [[NSProcessInfo processInfo] activeProcessorCount];
 
    return a;
#endif
 
#endif
}

◆ Initialize()

void job::Initialize	(	const JobSystemMemoryRequirements &	memory_requirements = `{}`,
		void *const	memory = `nullptr`
	)

noexcept

Sets up the Job system and creates all the worker threads. The thread that calls 'job::Initialize' is considered the main thread.

Parameters

memory_requirements	The customization parameters to initialize the system with. To be gotten from `job::MemRequirementsForConfig`.
memory	Must be `memory_requirements.byte_size` in size and with alignment `memory_requirements.alignment`. If nullptr then the system heap will be used.

Definition at line 703 of file job_system.cpp.

{
  JobAssert(g_JobSystem == nullptr, "Already initialized.");
 
  const bool needs_delete = memory == nullptr;
 
  if (!memory)
  {
    memory = ::operator new[](memory_requirements.byte_size, std::align_val_t{memory_requirements.alignment});
  }
 
  JobAssert(memory != nullptr, "memory must be a valid pointer.");
  JobAssert(IsPointerAligned(memory, memory_requirements.alignment), "memory must be a aligned to `memory_requirements.alignment`.");
 
  const JobSystemCreateOptions& options              = memory_requirements.options;
  const std::uint64_t           rng_seed             = options.job_steal_rng_seed;
  const WorkerID                num_threads          = config::WorkerCount(options);
  const std::uint16_t           num_tasks_per_worker = config::NumTasksPerWorker(options);
  const std::uint32_t           total_num_tasks      = config::TotalNumTasks(num_threads, num_tasks_per_worker);
 
  void*                       alloc_ptr        = memory;
  JobSystemContext*           job_system       = LinearAlloc<JobSystemContext>(alloc_ptr, 1u).ptr;
  Span<job::ThreadLocalState> all_workers      = LinearAlloc<job::ThreadLocalState>(alloc_ptr, num_threads);
  Span<TaskMemoryBlock>       all_tasks        = LinearAlloc<TaskMemoryBlock>(alloc_ptr, total_num_tasks);
  Span<AtomicTaskPtr>         worker_task_ptrs = LinearAlloc<AtomicTaskPtr>(alloc_ptr, total_num_tasks);
  Span<TaskHandle>            all_task_handles = LinearAlloc<TaskHandle>(alloc_ptr, total_num_tasks);
 
  job_system->workers     = all_workers.ptr;
  job_system->num_workers = num_threads;
  job_system->num_user_threads_setup.store(0, std::memory_order_relaxed);
  job_system->num_tasks_per_worker = num_tasks_per_worker;
  job_system->sys_arch_str         = "Unknown Arch";
  job_system->num_available_jobs.store(0, std::memory_order_relaxed);
  job_system->needs_delete           = needs_delete;
  job_system->system_alloc_size      = memory_requirements.byte_size;
  job_system->system_alloc_alignment = memory_requirements.alignment;
  job_system->init_lock.num_workers_ready.store(1u, std::memory_order_relaxed);  // Main thread already initialized.
 
#if IS_WINDOWS
  SYSTEM_INFO sysinfo;
  GetSystemInfo(&sysinfo);
 
  switch (sysinfo.wProcessorArchitecture)
  {
    case PROCESSOR_ARCHITECTURE_AMD64:
    {
      job_system->sys_arch_str = "x64 (Intel or AMD)";
      break;
    }
    case PROCESSOR_ARCHITECTURE_ARM:
    {
      job_system->sys_arch_str = "ARM";
      break;
    }
    case PROCESSOR_ARCHITECTURE_ARM64:
    {
      job_system->sys_arch_str = "ARM64";
      break;
    }
    case PROCESSOR_ARCHITECTURE_IA64:
    {
      job_system->sys_arch_str = "Intel Itanium-Based";
      break;
    }
    case PROCESSOR_ARCHITECTURE_INTEL:
    {
      job_system->sys_arch_str = "Intel x86";
      break;
    }
    case PROCESSOR_ARCHITECTURE_UNKNOWN:
    default:
    {
      job_system->sys_arch_str = "Unknown Arch";
      break;
    }
  }
#endif
 
  job::ThreadLocalState* const main_thread_worker = job_system->workers;
 
  for (std::uint64_t worker_index = 0; worker_index < num_threads; ++worker_index)
  {
    job::ThreadLocalState* const worker = SpanAlloc(&all_workers, 1u);
 
    worker->normal_queue.Initialize(SpanAlloc(&worker_task_ptrs, options.normal_queue_size), options.normal_queue_size);
    worker->worker_queue.Initialize(SpanAlloc(&worker_task_ptrs, options.worker_queue_size), options.worker_queue_size);
    task_pool::Initialize(&worker->task_allocator, SpanAlloc(&all_tasks, num_tasks_per_worker), num_tasks_per_worker);
    worker->allocated_tasks     = SpanAlloc(&all_task_handles, num_tasks_per_worker);
    worker->num_allocated_tasks = 0u;
    pcg32_srandom_r(&worker->rng_state, worker_index + rng_seed, worker_index * 2u + 1u + rng_seed);
    worker->last_stolen_worker = main_thread_worker;
  }
 
  g_JobSystem     = job_system;
  g_CurrentWorker = main_thread_worker;
 
  std::atomic_thread_fence(std::memory_order_release);
  for (std::uint64_t worker_index = 1; worker_index < num_threads; ++worker_index)
  {
    worker::InitializeThread(job_system->workers + worker_index);
  }
 
  JobAssert(all_workers.num_elements == 0u, "All elements expected to be allocated out.");
  JobAssert(all_tasks.num_elements == 0u, "All elements expected to be allocated out.");
  JobAssert(worker_task_ptrs.num_elements == 0u, "All elements expected to be allocated out.");
  JobAssert(all_task_handles.num_elements == 0u, "All elements expected to be allocated out.");
}

Referenced by Initialize().

◆ ProcessorArchitectureName()

const char * job::ProcessorArchitectureName ( )

noexcept

An implementation defined name for the CPU architecture of the device. This function can be called by any thread concurrently.

Returns: const char* Nul terminated name for the CPU architecture of the device.

Definition at line 868 of file job_system.cpp.

{
  return g_JobSystem->sys_arch_str;
}

References g_JobSystem, and job::JobSystemContext::sys_arch_str.

◆ NumWorkers()

std::uint16_t job::NumWorkers ( )

noexcept

Returns the number of workers created by the system. This function can be called by any thread concurrently.

Returns: std::size_t The number of workers created by the system.

Definition at line 863 of file job_system.cpp.

{
  return std::uint16_t(g_JobSystem->num_workers);
}

References g_JobSystem, and job::JobSystemContext::num_workers.

Referenced by job::internal::DispatchImpl(), and job::Splitter::EvenSplit().

◆ CurrentWorker()

job::WorkerID job::CurrentWorker ( )

noexcept

The current id of the current thread. This function can be called by any thread concurrently.

The main thread will always be 0.

Returns: WorkerID The current id of the current thread.

Definition at line 873 of file job_system.cpp.

{
  JobAssert(g_CurrentWorker != nullptr, "This thread was not created by the job system.");
  return job::WorkerID(g_CurrentWorker - g_JobSystem->workers);
}

References g_CurrentWorker, g_JobSystem, JobAssert, and job::JobSystemContext::workers.

Referenced by WaitOn().

◆ IsMainThread()

bool job::IsMainThread ( )

noexcept

Allows for querying if we are currently executing in the main thread.

Returns: True if we are in the main thread, false otherwise.

Warning: Must only be called from a thread registered with the job system.

Definition at line 879 of file job_system.cpp.

{
  return worker::IsMainThread(g_CurrentWorker);
}

References g_CurrentWorker, and IsMainThread().

Referenced by IsMainThread().

◆ Shutdown()

void job::Shutdown ( )

noexcept

This will deallocate any memory used by the system and shutdown any threads created by 'bfjob::initialize'.

Warning: This function may only be called by the main thread.

Definition at line 884 of file job_system.cpp.

{
  JobAssert(g_JobSystem != nullptr, "Cannot shutdown when never initialized.");
 
  static_assert(std::is_trivially_destructible_v<TaskMemoryBlock>, "TaskMemoryBlock's destructor not called.");
  static_assert(std::is_trivially_destructible_v<job::TaskPtr>, "job::TaskPtr's destructor not called.");
  static_assert(std::is_trivially_destructible_v<AtomicTaskPtr>, "AtomicTaskPtr's destructor not called.");
  static_assert(std::is_trivially_destructible_v<TaskHandle>, "TaskHandle's destructor not called.");
 
  JobSystemContext* const job_system  = g_JobSystem;
  const std::uint32_t     num_workers = job_system->num_workers;
 
  // Incase all threads are not initialized by the time shutdown is called.
  while (job_system->is_running.load(std::memory_order_relaxed) != true) {}
 
  {
    std::unique_lock<std::mutex> lock(job_system->worker_sleep_mutex);
    job_system->is_running.store(false, std::memory_order_relaxed);
  }
 
  // Allow one last update loop to allow them to end.
  system::WakeUpAllWorkers();
 
  for (std::uint32_t i = 0; i < num_workers; ++i)
  {
    job::ThreadLocalState* const worker = job_system->workers + i;
 
    if (i != 0)
    {
      worker::ShutdownThread(worker);
    }
 
    worker->~ThreadLocalState();
  }
 
  const bool needs_delete = job_system->needs_delete;
 
  job_system->~JobSystemContext();
  g_CurrentWorker = nullptr;
  g_JobSystem     = nullptr;
 
  if (needs_delete)
  {
    ::operator delete[](job_system, job_system->system_alloc_size, std::align_val_t{job_system->system_alloc_alignment});
  }
}

References g_CurrentWorker, g_JobSystem, job::JobSystemContext::is_running, JobAssert, job::JobSystemContext::needs_delete, job::JobSystemContext::num_workers, job::JobSystemContext::system_alloc_size, job::JobSystemContext::worker_sleep_mutex, and job::JobSystemContext::workers.

◆ Dispatch()

template<typename Closure >

void job::Dispatch	(	const char *const	name,
		Counter *const	counter,
		const Closure &	Callback,
		const QueueMode	queue = `QueueMode::Default`
	)

noexcept

Main API entrypoint, Pushes a task onto the queue.

Template Parameters

Closure Callable Type with void Closure(const job::Ctx& ctx);.

Parameters

name	Optional name for the task, can be null. Not used internally for anything.
counter	The counter to associate the job with.
Callback	Callable with `[](const job::Ctx& ctx) -> void {}`.
queue	Which queue to push the task to.

Warning: If the no free tasks are avaiable from the pool the task will run inline of this thread regardles of the queue mode.

Definition at line 251 of file job_api.hpp.

  {
    const internal::JobFn ErasedCallback = +[](const internal::PrivateCtx& ctx) -> void {
      alignas(Closure) unsigned char local_user_data[sizeof(Closure)];
      Closure* const                 src_user_data  = static_cast<Closure*>(ctx.src_user_data);
      Closure* const                 typed_callback = ::new (local_user_data) Closure(std::move(*src_user_data));
 
      src_user_data->~Closure();
      ctx.ReleaseTaskToPool();
 
      (*typed_callback)(static_cast<const job::Ctx&>(ctx));
      typed_callback->~Closure();
    };
 
    internal::DispatchImpl(name, counter, queue, ErasedCallback, sizeof(Closure), alignof(Closure), &Callback, +[](void* const dst_user_data, const void* const src_user_data) -> void {
      ::new (dst_user_data) Closure(*static_cast<const Closure*>(src_user_data));
    });
  }

References job::internal::DispatchImpl().

Referenced by ParallelFor(), ParallelInvoke(), and ParallelReduce().

◆ WaitOn()

void job::WaitOn ( const Counter & counter )

noexcept

Blocks until all tasks associated with counter are done while This function will block but do work while being blocked.

Parameters

counter The counter to wait for on.

Definition at line 931 of file job_system.cpp.

{
  const WorkerID worker_id = CurrentWorker();
 
  system::WakeUpAllWorkers();
 
  job::ThreadLocalState* const worker = system::GetWorker(worker_id);
 
  while (counter.unfinished_tasks.load(std::memory_order_acquire) != 0u)
  {
    worker::TryRunTask(worker);
  }
}

References CurrentWorker(), and job::Counter::unfinished_tasks.

Referenced by ParallelReduce().

◆ PauseProcessor()

void job::PauseProcessor ( )

noexcept

CPU pause instruction to indicate when you are in a spin wait loop.

Definition at line 1051 of file job_system.cpp.

{
  NativePause();
}

References NativePause.

Referenced by job::MPMCQueue::Commit().

◆ YieldTimeSlice()

void job::YieldTimeSlice ( )

noexcept

Asks the OS to yield this threads execution to another thread on the current cpu core.

Definition at line 1058 of file job_system.cpp.

{
  // Windows : SwitchToThread()
  // Linux   : sched_yield()
  std::this_thread::yield();
}

◆ ParallelFor() [1/2]

template<typename F , typename S >

void job::ParallelFor	(	const char *const	name,
		Counter *const	counter,
		const std::size_t	start,
		const std::size_t	count,
		S &&	splitter,
		F &&	fn,
		const QueueMode	queue = `QueueMode::Default`
	)

Parallel for algorithm, splits the work up recursively splitting based on the splitter passed in.

Assumes all callable objects passed in can be invoked on multiple threads at the same time.

Template Parameters

F	Type of function object passed in. Must be callable like: fn(const job::Ctx& ctx, const std::size_t index)
S	Callable splitter, must be callable like: splitter(std::size_t count)

Parameters

start	Start index for the range to be parallelized.
count	`start` + count defines the end range.
splitter	Callable splitter, must be callable like: splitter(std::size_t count)
fn	Function object must be callable like: fn(const job::Ctx& ctx, const std::size_t index)
parent	Parent task to add this task as a child of.

Returns: The new task holding the work of the parallel for.

Definition at line 354 of file job_api.hpp.

  {
    job::Dispatch(name, counter, [=, splitter = std::forward<S>(splitter), fn = std::forward<F>(fn)](const job::Ctx& ctx) -> void {
      if (count > 1u && splitter(count))
      {
        const std::size_t left_count  = count / 2;
        const std::size_t right_count = count - left_count;
 
        job::ParallelFor(ctx.task_name, ctx.task_counter, start + 0, left_count, splitter, fn, queue);
        job::ParallelFor(ctx.task_name, ctx.task_counter, start + left_count, right_count, splitter, fn, queue);
      }
      else
      {
        for (std::size_t offset = 0u; offset < count; ++offset)
        {
          fn(ctx, start + offset);
        }
      } }, queue);
  }

References Dispatch(), ParallelFor(), job::Ctx::task_counter, and job::Ctx::task_name.

Referenced by ParallelFor(), and ParallelReduce().

◆ ParallelFor() [2/2]

template<typename T , typename F , typename S >

void job::ParallelFor	(	const char *const	name,
		Counter *const	counter,
		T *const	data,
		const std::size_t	count,
		S &&	splitter,
		F &&	fn,
		const QueueMode	queue = `QueueMode::Default`
	)

Definition at line 375 of file job_api.hpp.

  {
    return job::ParallelFor(name, counter, std::size_t(0), count, std::forward<S>(splitter), [=](const job::Ctx& ctx, const std::size_t index) { fn(ctx, data + index); }, queue);
  }

References ParallelFor().

◆ ParallelInvoke()

template<typename... F>

void job::ParallelInvoke	(	const char *const	name,
		Counter *const	counter,
		const QueueMode	queue,
		F &&...	fns
	)

Invokes each passed in function object in parallel.

Template Parameters

...F	The function objects types. Must be callable like: fn(Task* task)

Parameters

parent	Parent task to add this task as a child of.
...fns	Function objects must be callable like: fn(Task* task)

Returns: The new task holding the work of the parallel invoke.

Definition at line 398 of file job_api.hpp.

  {
    (job::Dispatch(name, counter, std::forward<F>(fns), queue), ...);
  }

References Dispatch().

◆ ParallelReduce()

template<typename Splitter , typename Reducer >

void job::ParallelReduce	(	const char *const	name,
		Counter *const	counter,
		const std::size_t	start,
		const std::size_t	count,
		Splitter &&	splitter,
		Reducer &&	reduce,
		const QueueMode	queue = `QueueMode::Default`
	)

Definition at line 404 of file job_api.hpp.

  {
    const auto ParallelReduce_Impl = [=, splitter = std::forward<Splitter>(splitter), reduce = std::forward<Reducer>(reduce)](const job::Ctx& ctx) -> void {
      // NOTE(SR):
      //   Could also have a stride that increases each step.
      //   This would be bad for Cuda GPU (Shared Memory Bank Conflict)
      //   But good on CPU with better locality.
      //   https://developer.download.nvidia.com/assets/cuda/files/reduction.pdf
 
      std::size_t count_left = count;
 
      while (count_left > 1)
      {
        const std::size_t stride = count_left / 2;
 
        const auto ReduceRange = [stride, &reduce](const job::Ctx& ctx, const std::size_t index) -> void {
          reduce(ctx, index, index + stride);
        };
 
        Counter c{};
        ParallelFor(name, &c, start, stride, splitter, ReduceRange, queue);
        WaitOn(c);
 
        if ((count_left & 1) != 0)
        {
          reduce(ctx, start, start + count_left - 1);
        }
 
        count_left = stride;
      }
    };
 
    job::Dispatch(name, counter, ParallelReduce_Impl, queue);
  }

References Dispatch(), ParallelFor(), and WaitOn().

Variable Documentation

◆ k_FalseSharingPadSize

constexpr std::size_t job::k_FalseSharingPadSize = std::hardware_destructive_interference_size

staticconstexpr

Definition at line 29 of file job_queue.hpp.

◆ k_CachelineSize

constexpr std::size_t job::k_CachelineSize = 64u

staticconstexpr

Definition at line 72 of file job_system.cpp.

◆ k_ExpectedTaskSize

constexpr std::size_t job::k_ExpectedTaskSize = std::max(std::size_t(128u), k_CachelineSize)

staticconstexpr

Definition at line 75 of file job_system.cpp.

◆ NullTaskHandle

constexpr TaskHandle job::NullTaskHandle = std::numeric_limits<TaskHandle>::max()

staticconstexpr

Definition at line 86 of file job_system.cpp.

Referenced by job::TaskPtr::isNull(), and job::TaskPtr::job::TaskPtr().

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Class Documentation

◆ job::Counter

◆ job::InitializationLock

◆ job::JobSystemContext

◆ job::JobSystemCreateOptions

◆ job::TaskMemoryBlock

◆ job::TaskPool

◆ job::ThreadLocalState

Typedef Documentation

◆ WorkerID

◆ TaskHandle

◆ TaskHandleType

◆ AtomicTaskHandleType

◆ WorkerIDType

◆ AtomicInt32

◆ Byte

◆ AtomicTaskPtr

Enumeration Type Documentation

◆ QueueMode

◆ SPMCDequeStatus

Function Documentation

◆ NumSystemThreads()

◆ Initialize()

◆ ProcessorArchitectureName()

◆ NumWorkers()

◆ CurrentWorker()

◆ IsMainThread()

◆ Shutdown()

◆ Dispatch()

◆ WaitOn()

◆ PauseProcessor()

◆ YieldTimeSlice()

◆ ParallelFor() [1/2]

◆ ParallelFor() [2/2]

◆ ParallelInvoke()

◆ ParallelReduce()

Variable Documentation

◆ k_FalseSharingPadSize

◆ k_CachelineSize

◆ k_ExpectedTaskSize

◆ NullTaskHandle