Example #1
0
        /// <summary>
        /// Loads the given kernel and returns a launcher delegate that
        /// can receive arbitrary accelerator streams (first parameter).
        /// </summary>
        /// <param name="method">The method to compile into a kernel.</param>
        /// <returns>The loaded kernel-launcher delegate.</returns>
        public TDelegate LoadAutoGroupedKernel <TDelegate>(MethodInfo method)
            where TDelegate : class
        {
            var loader   = AutoKernelLoader.Default;
            var launcher = new LauncherProvider();

            return(LoadGenericKernel <TDelegate, AutoKernelLoader, LauncherProvider>(
                       method,
                       KernelSpecialization.Empty,
                       ref loader,
                       ref launcher));
        }
Example #2
0
        /// <summary>
        /// Loads the given kernel and returns a launcher delegate that
        /// can receive arbitrary accelerator streams (first parameter).
        /// </summary>
        /// <param name="method">The method to compile into a kernel.</param>
        /// <param name="customGroupSize">The custom group size to use.</param>
        /// <returns>The loaded kernel-launcher delegate.</returns>
        /// <remarks>
        /// Note that implictly-grouped kernel will be launched with the given
        /// group size.
        /// </remarks>
        public TDelegate LoadImplicitlyGroupedKernel <TDelegate>(MethodInfo method, int customGroupSize)
            where TDelegate : class
        {
            var loader   = new GroupedKernelLoader(customGroupSize);
            var launcher = new LauncherProvider();

            return(LoadGenericKernel <TDelegate, GroupedKernelLoader, LauncherProvider>(
                       method,
                       new KernelSpecialization(customGroupSize, null),
                       ref loader,
                       ref launcher));
        }
Example #3
0
        /// <summary>
        /// Loads the given kernel and returns a launcher delegate that
        /// can receive arbitrary accelerator streams (first parameter).
        /// </summary>
        /// <typeparam name="TDelegate">The delegate type.</typeparam>
        /// <param name="method">The method to compile into a kernel.</param>
        /// <param name="specialization">The kernel specialization.</param>
        /// <returns>The loaded kernel-launcher delegate.</returns>
        /// <remarks>
        /// Note that implictly-grouped kernels will be launched with a group size
        /// of the current warp size of the accelerator.
        /// </remarks>
        public TDelegate LoadKernel <TDelegate>(MethodInfo method, KernelSpecialization specialization)
            where TDelegate : class
        {
            var loader   = DefaultKernelLoader.Default;
            var launcher = new LauncherProvider();

            return(LoadGenericKernel <TDelegate, DefaultKernelLoader, LauncherProvider>(
                       method,
                       specialization,
                       ref loader,
                       ref launcher));
        }
Example #4
0
        /// <summary>
        /// Loads the given kernel and returns a launcher delegate that
        /// can receive arbitrary accelerator streams (first parameter).
        /// </summary>
        /// <param name="method">The method to compile into a kernel.</param>
        /// <param name="groupSize">The estimated group size to gain maximum occupancy on this device.</param>
        /// <param name="minGridSize">The minimum grid size to gain maximum occupancy on this device.</param>
        /// <returns>The loaded kernel-launcher delegate.</returns>
        public TDelegate LoadAutoGroupedKernel <TDelegate>(
            MethodInfo method,
            out int groupSize,
            out int minGridSize)
            where TDelegate : class
        {
            var loader   = AutoKernelLoader.Default;
            var launcher = new LauncherProvider();
            var result   = LoadGenericKernel <TDelegate, AutoKernelLoader, LauncherProvider>(
                method,
                KernelSpecialization.Empty,
                ref loader,
                ref launcher);

            groupSize   = loader.GroupSize;
            minGridSize = loader.MinGridSize;
            return(result);
        }