/// <summary>
/// Creates a new CPU accelerator.
/// </summary>
/// <param name="context">The ILGPU context.</param>
/// <param name="cpuDeviceIndex">
/// The relative device index for the CPU device. 0 here refers to the first
/// CPU device, 1 to the second, etc.
/// </param>
/// <param name="mode">The CPU accelerator mode.</param>
/// <param name="threadPriority">
/// The thread priority of the execution threads.
/// </param>
/// <returns>The created CPU accelerator.</returns>
public static CPUAccelerator CreateCPUAccelerator(
this Context context,
int cpuDeviceIndex,
CPUAcceleratorMode mode,
ThreadPriority threadPriority) =>
context.GetCPUDevice(cpuDeviceIndex)
.CreateCPUAccelerator(context, mode, threadPriority);
/// <summary>
/// Constructs a new CPU runtime.
/// </summary>
/// <param name="context">The ILGPU context.</param>
/// <param name="numThreadsPerWarp">
/// The number of threads per group for parallel processing.
/// </param>
/// <param name="numWarpsPerMultiprocessor">
/// The number of warps per multiprocessor.
/// </param>
/// <param name="numMultiprocessors">
/// The number of multiprocessors (number of parallel groups) to simulate.
/// </param>
/// <param name="mode">The current accelerator mode.</param>
/// <param name="threadPriority">
/// The thread priority of the execution threads.
/// </param>
public CPUAccelerator(
Context context,
int numThreadsPerWarp,
int numWarpsPerMultiprocessor,
int numMultiprocessors,
CPUAcceleratorMode mode,
ThreadPriority threadPriority)
: base(context, AcceleratorType.CPU)
{
if (numThreadsPerWarp < 2 || !Utilities.IsPowerOf2(numWarpsPerMultiprocessor))
{
throw new ArgumentOutOfRangeException(nameof(numThreadsPerWarp));
}
if (numWarpsPerMultiprocessor < 1)
{
throw new ArgumentOutOfRangeException(nameof(numWarpsPerMultiprocessor));
}
if (numMultiprocessors < 1)
{
throw new ArgumentOutOfRangeException(nameof(numMultiprocessors));
}
// Check for existing limitations with respect to barrier participants
if (numThreadsPerWarp * numWarpsPerMultiprocessor > short.MaxValue)
{
throw new ArgumentOutOfRangeException(nameof(numWarpsPerMultiprocessor));
}
if (NumMultiprocessors > short.MaxValue)
{
throw new ArgumentOutOfRangeException(nameof(numMultiprocessors));
}
NativePtr = new IntPtr(1);
WarpSize = numThreadsPerWarp;
MaxNumThreadsPerGroup = numThreadsPerWarp * numWarpsPerMultiprocessor;
MaxNumThreadsPerMultiprocessor = MaxNumThreadsPerGroup;
NumMultiprocessors = numMultiprocessors;
MaxGroupSize = new Index3(
MaxNumThreadsPerGroup,
MaxNumThreadsPerGroup,
MaxNumThreadsPerGroup);
MemorySize = long.MaxValue;
MaxGridSize = new Index3(int.MaxValue, int.MaxValue, int.MaxValue);
MaxSharedMemoryPerGroup = int.MaxValue;
MaxConstantMemory = int.MaxValue;
DefaultStream = CreateStream();
Name = nameof(CPUAccelerator);
NumThreads = MaxNumThreads * numMultiprocessors;
Mode = mode;
UsesSequentialExecution =
Mode == CPUAcceleratorMode.Sequential ||
Mode == CPUAcceleratorMode.Auto && Debugger.IsAttached;
Bind();
InitExecutionEngine(numWarpsPerMultiprocessor, threadPriority);
Init(context.DefautltILBackend);
}
/// <summary>
/// Constructs a new CPU runtime.
/// </summary>
/// <param name="context">The ILGPU context.</param>
/// <param name="description">The accelerator description.</param>
/// <param name="mode">The current accelerator mode.</param>
/// <param name="threadPriority">
/// The thread priority of the execution threads.
/// </param>
internal CPUAccelerator(
Context context,
CPUDevice description,
CPUAcceleratorMode mode,
ThreadPriority threadPriority)
: base(context, description)
{
NativePtr = new IntPtr(1);
DefaultStream = CreateStream();
NumThreads = description.NumThreads;
Mode = mode;
ThreadPriority = threadPriority;
UsesSequentialExecution =
Mode == CPUAcceleratorMode.Sequential ||
Mode == CPUAcceleratorMode.Auto && Debugger.IsAttached;
finishedEventPerMultiprocessor = new Barrier(NumMultiprocessors + 1);
multiprocessors = new CPUMultiprocessor[NumMultiprocessors];
for (int i = 0, e = NumMultiprocessors; i < e; ++i)
{
multiprocessors[i] = CPUMultiprocessor.Create(
this,
i,
UsesSequentialExecution);
}
Bind();
Init(context.DefautltILBackend);
}
/// <summary>
/// Creates a CPU accelerator that simulates a common configuration specified
/// by the given <paramref name="kind"/>.
/// </summary>
/// <param name="context">The current context.</param>
/// <param name="kind">The desired CPU accelerator kind.</param>
/// <param name="mode">The accelerator mode.</param>
/// <returns>The created CPU accelerator instance.</returns>
public static CPUAccelerator Create(
Context context,
CPUAcceleratorKind kind,
CPUAcceleratorMode mode) =>
kind <CPUAcceleratorKind.Default || kind> CPUAcceleratorKind.Intel
? throw new ArgumentOutOfRangeException(nameof(kind))
: CreateAccelerators[(int)kind](context, mode);
/// <summary>
/// Constructs a new CPU runtime with the default number of 4 threads per warp,
/// 4 warps per multiprocessor and 1 multiprocessor.
/// </summary>
/// <param name="context">The ILGPU context.</param>
/// <param name="mode">The accelerator mode.</param>
public CPUAccelerator(Context context, CPUAcceleratorMode mode)
: this(
context,
DefaultWarpSize,
DefaultNumWarpsPerMultiprocessor,
DefaultNumMultiprocessors,
mode)
{
}
/// <summary>
/// Constructs a new CPU runtime.
/// </summary>
/// <param name="context">The ILGPU context.</param>
/// <param name="numThreadsPerWarp">
/// The number of threads per warp within a group.
/// </param>
/// <param name="numWarpsPerMultiprocessor">
/// The number of warps per multiprocessor.
/// </param>
/// <param name="numMultiprocessors">
/// The number of multiprocessors (number of parallel groups) to simulate.
/// </param>
/// <param name="mode">The accelerator mode.</param>
public CPUAccelerator(
Context context,
int numThreadsPerWarp,
int numWarpsPerMultiprocessor,
int numMultiprocessors,
CPUAcceleratorMode mode)
: this(
context,
numThreadsPerWarp,
numWarpsPerMultiprocessor,
numMultiprocessors,
mode,
ThreadPriority.Normal)
{
}
/// <summary>
/// Constructs a new CPU runtime.
/// </summary>
/// <param name="context">The ILGPU context.</param>
/// <param name="description">The accelerator description.</param>
/// <param name="mode">The current accelerator mode.</param>
/// <param name="threadPriority">
/// The thread priority of the execution threads.
/// </param>
internal CPUAccelerator(
Context context,
CPUDevice description,
CPUAcceleratorMode mode,
ThreadPriority threadPriority)
: base(context, description)
{
NativePtr = new IntPtr(1);
DefaultStream = CreateStream();
NumThreads = description.NumThreads;
Mode = mode;
UsesSequentialExecution =
Mode == CPUAcceleratorMode.Sequential ||
Mode == CPUAcceleratorMode.Auto && Debugger.IsAttached;
Bind();
InitExecutionEngine(threadPriority);
Init(context.DefautltILBackend);
}
/// <summary>
/// Creates a new CPU accelerator with default thread priority.
/// </summary>
/// <param name="context">The ILGPU context.</param>
/// <param name="cpuDeviceIndex">
/// The relative device index for the CPU device. 0 here refers to the first
/// CPU device, 1 to the second, etc.
/// </param>
/// <param name="mode">The CPU accelerator mode.</param>
/// <returns>The created CPU accelerator.</returns>
public static CPUAccelerator CreateCPUAccelerator(
this Context context,
int cpuDeviceIndex,
CPUAcceleratorMode mode) =>
context.GetCPUDevice(cpuDeviceIndex)
.CreateCPUAccelerator(context, mode);
/// <summary>
/// Creates a new CPU accelerator.
/// </summary>
/// <param name="context">The ILGPU context.</param>
/// <param name="mode">The CPU accelerator mode.</param>
/// <param name="threadPriority">
/// The thread priority of the execution threads.
/// </param>
/// <returns>The created CPU accelerator.</returns>
public CPUAccelerator CreateCPUAccelerator(
Context context,
CPUAcceleratorMode mode,
ThreadPriority threadPriority) =>
new CPUAccelerator(context, this, mode, threadPriority);
/// <summary>
/// Creates a new CPU accelerator with default thread priority.
/// </summary>
/// <param name="context">The ILGPU context.</param>
/// <param name="mode">The CPU accelerator mode.</param>
/// <returns>The created CPU accelerator.</returns>
public CPUAccelerator CreateCPUAccelerator(
Context context,
CPUAcceleratorMode mode) =>
CreateCPUAccelerator(context, mode, ThreadPriority.Normal);
/// <summary>
/// Creates a CPU accelerator that simulates a common configuration of an Intel
/// GPU with 1 multiprocessor.
/// </summary>
/// <param name="context">The current context.</param>
/// <param name="mode">The accelerator mode.</param>
/// <returns>The created CPU accelerator instance.</returns>
public static CPUAccelerator CreateIntelSimulator(
Context context,
CPUAcceleratorMode mode) =>
new CPUAccelerator(context, 16, 8, 1, mode);
/// <summary>
/// Creates a CPU accelerator that simulates a common configuration of a legacy
/// GCN AMD GPU with 1 multiprocessor.
/// </summary>
/// <param name="context">The current context.</param>
/// <param name="mode">The accelerator mode.</param>
/// <returns>The created CPU accelerator instance.</returns>
public static CPUAccelerator CreateLegacyAMDSimulator(
Context context,
CPUAcceleratorMode mode) =>
new CPUAccelerator(context, 64, 4, 1, mode);
/// <summary>
/// Creates a CPU accelerator that simulates a common configuration of an AMD
/// GPU with 1 multiprocessor.
/// </summary>
/// <param name="context">The current context.</param>
/// <param name="mode">The accelerator mode.</param>
/// <returns>The created CPU accelerator instance.</returns>
public static CPUAccelerator CreateAMDSimulator(
Context context,
CPUAcceleratorMode mode) =>
new CPUAccelerator(context, 32, 8, 1, mode);
/// <summary>
/// Creates a CPU accelerator that simulates a common configuration of a default
/// GPU simulator with 1 multiprocessor, a warp size of 4 and 4 warps per
/// multiprocessor.
/// </summary>
/// <param name="context">The current context.</param>
/// <param name="mode">The accelerator mode.</param>
/// <returns>The created CPU accelerator instance.</returns>
public static CPUAccelerator CreateDefaultSimulator(
Context context,
CPUAcceleratorMode mode) =>
new CPUAccelerator(context, mode);
