Esempio n. 1
0
        /// <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);
        }
Esempio n. 2
0
        /// <summary>
        /// Constructs a new CPU-based runtime context for parallel processing.
        /// </summary>
        /// <param name="multiprocessor">The target CPU multiprocessor.</param>
        protected CPURuntimeContext(CPUMultiprocessor multiprocessor)
        {
            Multiprocessor = multiprocessor
                             ?? throw new ArgumentNullException(nameof(multiprocessor));

            broadcastBuffer = new CPUMemoryBufferCache(multiprocessor.Accelerator);
            broadcastBuffer.Allocate <int>(16);
        }
Esempio n. 3
0
        /// <summary>
        /// Constructs a new CPU-based runtime context for parallel processing.
        /// </summary>
        /// <param name="multiprocessor">The target CPU multiprocessor.</param>
        /// <param name="numThreadsPerWarp">The number of threads per warp.</param>
        public CPURuntimeWarpContext(
            CPUMultiprocessor multiprocessor,
            int numThreadsPerWarp)
            : base(multiprocessor)
        {
            WarpSize = numThreadsPerWarp;

            shuffleBuffer = new MemoryBufferCache(Multiprocessor.Accelerator);
            shuffleBuffer.Allocate <int>(2 * sizeof(int) * numThreadsPerWarp);
        }
Esempio n. 4
0
 /// <summary>
 /// Constructs a new CPU-based runtime context for parallel processing.
 /// </summary>
 /// <param name="multiprocessor">The target CPU multiprocessor.</param>
 public CPURuntimeGroupContext(CPUMultiprocessor multiprocessor)
     : base(multiprocessor)
 {
 }