public FIRFilterSolver(Platform platform, Device device, IList<FIRFilter> filters)
        {
            FilterCount = filters.Count;
            var order = filters[0].B.Count;
            FilterOrder = order;
            foreach (var x in filters)
                if (order != x.B.Count)
                    throw new InvalidOperationException("The filters should have the same order");
            var table = new float[filters.Count * order];
            var f = 0;
            foreach (var x in filters)
            {
                for (int i = 0; i < order; i++)
                    table[f*order + i] = x.B[i];
                f++;
            }
            Platform = platform;
            OpenCLContext = Platform.CreateDefaultContext();
            OpenCLCommandQueue = OpenCLContext.CreateCommandQueue(device);//, CommandQueueProperties.PROFILING_ENABLE);
            DiffEqnProgram = OpenCLContext.CreateProgramWithSource(File.OpenText("opencl/FIRKernels.cl").ReadToEnd());
            DiffEqnProgram.Build();
            initWorkBufferKernel = DiffEqnProgram.CreateKernel("initWorkBuffer");
            filterKernel = DiffEqnProgram.CreateKernel("filter");
            bufferedFilterKernel = DiffEqnProgram.CreateKernel("bufferedFilter");

            Table = OpenCLContext.CreateBuffer(MemFlags.READ_ONLY, table.Length * 4);
            WorkBuffer = OpenCLContext.CreateBuffer(MemFlags.WRITE_ONLY, table.Length * 4);
            OutputBuffer = OpenCLContext.CreateBuffer(MemFlags.WRITE_ONLY, filters.Count * 4);

            fixed (float* array = table)
            {
                OpenCLCommandQueue.EnqueueWriteBuffer(Table, false, 0, table.Length * 4, new IntPtr((void*)array));
            }
            initWorkBufferKernel.SetArg(0, WorkBuffer);
            OpenCLCommandQueue.EnqueueNDRangeKernel(initWorkBufferKernel, 1, null, new int[] { table.Length }, null);
            OpenCLCommandQueue.EnqueueBarrier();
            filterKernel.SetArg(2, FilterOrder);
            filterKernel.SetArg(3, Table);
            filterKernel.SetArg(4, WorkBuffer);
            filterKernel.SetArg(5, OutputBuffer);
            bufferedFilterKernel.SetArg(2, FilterOrder);
            bufferedFilterKernel.SetArg(3, Table);
            bufferedFilterKernel.SetArg(4, WorkBuffer);
            bufferedFilterKernel.SetArg(5, OutputBuffer);
            filterKernelGlobalWorkSize = new int[] { table.Length };
            //mapToOutputKernel.SetArg(1, FilterOrder);
            //mapToOutputKernel.SetArg(2, WorkBuffer);
            //mapToOutputKernel.SetArg(3, OutputBuffer);
            mapToOutputKernelGlobalWorkSize = new int[] { filters.Count };
            filterKernelLocalWorkSize = getLocalSize(filterKernelGlobalWorkSize[0]);
            mapToOutputLocalWorkSize = getLocalSize(mapToOutputKernelGlobalWorkSize[0]);
            SetOutputBufferLength(1);
        }
Exemple #2
0
        internal Context( Platform platform, ContextProperties[] properties, Device[] devices )
        {
            IntPtr[] intPtrProperties;
            IntPtr[] deviceIDs;
            ErrorCode result;

            Platform = platform;
            deviceIDs = InteropTools.ConvertDevicesToDeviceIDs( devices );

            intPtrProperties = new IntPtr[properties.Length];
            for( int i=0; i<properties.Length; i++ )
                intPtrProperties[i] = new IntPtr( (long)properties[i] );

            ContextID = (IntPtr)OpenCL.CreateContext( intPtrProperties,
                (uint)devices.Length,
                deviceIDs,
                null,
                IntPtr.Zero,
                out result );
            if( result!=ErrorCode.SUCCESS )
                throw new OpenCLException( "CreateContext failed: "+result , result);
            Is64BitContext = ContainsA64BitDevice();
        }
Exemple #3
0
        public Platform( IntPtr platformID )
        {
            PlatformID = platformID;

            // Create a local representation of all devices
            DeviceIDs = QueryDeviceIntPtr( DeviceType.ALL );
            for( int i=0; i<DeviceIDs.Length; i++ )
                _Devices[DeviceIDs[i]] = new Device( this, DeviceIDs[i] );
            DeviceList = InteropTools.ConvertDeviceIDsToDevices( this, DeviceIDs );

            InitializeExtensionHashSet();

            Match m = VersionStringRegex.Match(Version);
            if (m.Success)
            {
                OpenCLMajorVersion = int.Parse(m.Groups["Major"].Value);
                OpenCLMinorVersion = int.Parse(m.Groups["Minor"].Value);
            }
            else
            {
                OpenCLMajorVersion = 1;
                OpenCLMinorVersion = 0;
            }
        }
        public UpSampler(Platform platform, Device device, int by, int inputBufferLen)
        {
            InputBufferLen = inputBufferLen;
            By = by;
            Platform = platform;
            OpenCLContext = Platform.CreateDefaultContext();
            OpenCLCommandQueue = OpenCLContext.CreateCommandQueue(device);
            UpSampleProgram = OpenCLContext.CreateProgramWithSource(File.OpenText("opencl/upSample.cl").ReadToEnd());
            UpSampleProgram.Build();
            upsampleKernel = UpSampleProgram.CreateKernel("upSample");
            upsample2Kernel = UpSampleProgram.CreateKernel("upSample2");
            upsampleKernel.SetArg(0, by);
            upsampleKernel.SetArg(1, inputBufferLen);
            upsample2Kernel.SetArg(0, by);
            upsample2Kernel.SetArg(1, inputBufferLen);

            InputBuffer = OpenCLContext.CreateBuffer(MemFlags.WRITE_ONLY, inputBufferLen * 4);
            OutputBuffer = OpenCLContext.CreateBuffer(MemFlags.WRITE_ONLY, inputBufferLen * by * 4);
            upsampleKernel.SetArg(2, InputBuffer);
            upsampleKernel.SetArg(3, OutputBuffer);
            upsample2Kernel.SetArg(2, InputBuffer);
            upsample2Kernel.SetArg(3, OutputBuffer);
            globalworksize = new int[] { (int)(by * inputBufferLen) };
        }
Exemple #5
0
        public void CreateContext( Platform platform, Device device )
        {
            IntPtr[] contextProperties = new IntPtr[]
            {
                (IntPtr)ContextProperties.PLATFORM, platform.PlatformID,
                IntPtr.Zero, IntPtr.Zero
            };

            Device[] devices = new Device[]
            {
                device
            };

            oclContext = platform.CreateContext(contextProperties, devices, oclContextNotify, IntPtr.Zero);
            oclCQ = oclContext.CreateCommandQueue(device, CommandQueueProperties.PROFILING_ENABLE);
        }
Exemple #6
0
 private void TestDevice( Device d )
 {
     Output("");
     Output("Testing device: \"" + d.Name+"\"");
     // d.ToString() is overloaded to output all properties as a string, so every property will be used that way
     Output(d.ToString());
 }
Exemple #7
0
 public void Build(Device[] devices, ProgramNotify notify, IntPtr userData)
 {
     Build(devices, null, notify, userData);
 }
Exemple #8
0
        public Program CreateProgramWithBinary( Device[] devices, byte[][] binaries, ErrorCode[] binaryStatus )
        {
            IntPtr programID;
            ErrorCode result;
            IntPtr[] lengths;
            int[] binStatus = new int[binaryStatus.Length];

            lengths = new IntPtr[devices.Length];
            for (int i = 0; i < lengths.Length; i++)
                lengths[i] = (IntPtr)binaries[i].Length;
            programID = OpenCL.CreateProgramWithBinary(ContextID,
                (uint)devices.Length,
                InteropTools.ConvertDevicesToDeviceIDs(devices),
                lengths,
                binaries,
                binStatus,
                out result );
            for( int i=0; i<binaryStatus.Length; i++ )
                binaryStatus[i] = (ErrorCode)binStatus[i];
            if (result != ErrorCode.SUCCESS)
                throw new OpenCLException("CreateProgramWithBinary failed with error code " + result, result);
            return new Program(this, programID);
        }
Exemple #9
0
        public CommandQueue CreateCommandQueue( Device device, CommandQueueProperties properties )
        {
            IntPtr commandQueueID;
            ErrorCode result;

            commandQueueID = (IntPtr)OpenCL.CreateCommandQueue( ContextID, device.DeviceID, (ulong)properties, out result );
            if( result!=ErrorCode.SUCCESS )
                throw new OpenCLException( "CreateCommandQueue failed with error code "+result, result);
            return new CommandQueue( this, device, commandQueueID );
        }
Exemple #10
0
        public static IntPtr[] ConvertDevicesToDeviceIDs(Device[] devices)
        {
            IntPtr[] deviceIDs;

            if (devices == null)
                return null;

            deviceIDs = new IntPtr[devices.Length];
            for (int i = 0; i < devices.Length; i++)
                deviceIDs[i] = devices[i];
            return deviceIDs;
        }
Exemple #11
0
        private void comboBoxOpenCLDevices_SelectedIndexChanged(object sender, EventArgs e)
        {
            bool supportsImages;
            bool supportsImageFormat;

            try
            {
                ReleaseDeviceResources();
                panelScaled.Refresh();

                oclDevice = oclDevices[comboBoxOpenCLDevices.SelectedIndex];
                CreateContext(oclPlatform, oclDevice);
                supportsImages = oclDevice.ImageSupport;
                supportsImageFormat = oclContext.SupportsImageFormat(MemFlags.READ_WRITE, MemObjectType.IMAGE2D, ChannelOrder.RGBA, ChannelType.UNSIGNED_INT8);
                if (oclDevice.ImageSupport && supportsImageFormat)
                {
                    buttonScaleImage.Enabled = true;
                    labelImageSupportIndicator.Text = "Yes";
                    OpenCLSource = File.ReadAllText(@"OpenCLFunctions.cl");
                    BuildOCLSource(OpenCLSource);
                    CreateOCLImages(oclContext);
                    oclFullyInitialized = true;
                }
                else
                {
                    buttonScaleImage.Enabled = false;
                    labelImageSupportIndicator.Text = "No " + (supportsImageFormat ? "(No Image support at all)" : "(Images supported, but no support for RGBA8888)");
                    oclContext = null;
                }
            }
            catch (OpenCLBuildException oclbe)
            {
                MessageBox.Show(this, oclbe.BuildLogs[0], "OpenCL build error");
            }
            catch (OpenCLException ocle)
            {
                MessageBox.Show(this, ocle.Message, "OpenCL exception");
            }
        }
Exemple #12
0
        public Context CreateContext(IntPtr[] contextProperties, Device[] devices, ContextNotify notify, IntPtr userData)
        {
            IntPtr contextID;
            ErrorCode result;

            IntPtr[] deviceIDs = InteropTools.ConvertDevicesToDeviceIDs(devices);
            contextID = (IntPtr)OpenCL.CreateContext(contextProperties,
                (uint)deviceIDs.Length,
                deviceIDs,
                notify,
                userData,
                out result);
            if (result != ErrorCode.SUCCESS)
                throw new OpenCLException("CreateContext failed with error code: " + result, result);
            return new Context(this, contextID);
        }
Exemple #13
0
 public BuildInfo( Program p, Device d )
 {
     Program = p;
     Device = d;
 }
Exemple #14
0
        public BuildStatus GetBuildStatus( Device device )
        {
            BuildInfo buildInfo;

            buildInfo = new BuildInfo( this, device );
            return (BuildStatus)InteropTools.ReadInt( buildInfo, (uint)ProgramBuildInfo.STATUS );
        }
Exemple #15
0
        public string GetBuildOptions( Device device )
        {
            BuildInfo buildInfo;

            buildInfo = new BuildInfo( this, device );
            return InteropTools.ReadString( buildInfo, (uint)ProgramBuildInfo.OPTIONS );
        }
Exemple #16
0
        public string GetBuildLog( Device device )
        {
            BuildInfo buildInfo;

            buildInfo = new BuildInfo( this, device );
            return InteropTools.ReadString( buildInfo, (uint)ProgramBuildInfo.LOG );
        }
Exemple #17
0
        public void Build(Device[] devices, string options, ProgramNotify notify, IntPtr userData)
        {
            ErrorCode result;
            IntPtr[] deviceIDs;
            int deviceLength = 0;

            if (devices != null)
                deviceLength = devices.Length;

            deviceIDs = InteropTools.ConvertDevicesToDeviceIDs(devices);
            result = (ErrorCode)OpenCL.BuildProgram(ProgramID,
                (uint)deviceLength,
                deviceIDs,
                options,
                notify,
                userData);
            if (result != ErrorCode.SUCCESS)
                throw new OpenCLBuildException(this, result);
        }
Exemple #18
0
        private void comboBoxOpenCLPlatforms_SelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                ReleaseDeviceResources();

                oclPlatform = OpenCL.GetPlatform(comboBoxOpenCLPlatforms.SelectedIndex);
                oclDevices = oclPlatform.QueryDevices(DeviceType.ALL);
                PopulateOCLDevicesComboBox(oclPlatform, DeviceType.ALL);
                if (comboBoxOpenCLDevices.Items.Count > 0)
                {
                    comboBoxOpenCLDevices.SelectedIndex = 0;
                }
                else
                {
                    oclDevice = null;
                }
            }
            catch (OpenCLException ocle)
            {
                MessageBox.Show(this, ocle.Message, "OpenCL exception");
            }
        }
Exemple #19
0
        /// <summary>
        /// CreateSubDevicesEXT uses a slightly modified API,
        /// due to the overall messiness of creating a
        /// cl_device_partition_property_ext in managed C#.
        /// 
        /// The object list properties is a linear list of partition properties and arguments
        /// add the DevicePartition property IDs  and ListTerminators as ulongs and the argument lists as ints
        /// CreateSubDevicesEXT will use that info to construct a binary block
        /// </summary>
        /// <param name="properties"></param>
        public unsafe Device[] CreateSubDevicesEXT(List<object> properties)
        {
            ErrorCode result;
            MemoryStream ms = new MemoryStream();
            BinaryWriter bw = new BinaryWriter(ms);

            for (int i = 0; i < properties.Count; i++)
            {
                if (properties[i] is ulong)
                    bw.Write((ulong)properties[i]);
                else if (properties[i] is int)
                    bw.Write((int)properties[i]);
                else
                    throw new ArgumentException("CreateSubDevicesEXT: property lists only accepts ulongs and ints");
            }
            bw.Flush();
            byte[] propertyArray = ms.ToArray();
            uint numDevices;
            result = OpenCL.CreateSubDevicesEXT(DeviceID, propertyArray, 0, null, &numDevices);
            if (result != ErrorCode.SUCCESS)
                throw new OpenCLException("CreateSubDevicesEXT failed with error code: "+result, result);

            IntPtr[] subDeviceIDs = new IntPtr[(int)numDevices];
            result = OpenCL.CreateSubDevicesEXT(DeviceID, propertyArray, numDevices, subDeviceIDs, null);
            if (result != ErrorCode.SUCCESS)
                throw new OpenCLException("CreateSubDevicesEXT failed with error code: " + result, result);

            Device[] subDevices = new Device[(int)numDevices];
            for (int i = 0; i < (int)numDevices; i++)
            {
                Device d = new Device(Platform, subDeviceIDs[i]);
                d.IsSubDevice = true;
                subDevices[i] = d;
            }
            return subDevices;
        }
Exemple #20
0
 protected void SaveDeviceBinary(Context context, string fileName, byte[][] binaries, string platformDirectoryName, Device device )
 {
     throw new NotImplementedException("SaveDeviceBinary not implemented");
 }
Exemple #21
0
 public CommandQueue CreateCommandQueue(Device device)
 {
     return CreateCommandQueue(device, (CommandQueueProperties)0);
 }
Exemple #22
0
        public static Device[] ConvertDeviceIDsToDevices(Platform platform, IntPtr[] deviceIDs)
        {
            Device[] devices;

            if (deviceIDs == null)
                return null;

            devices = new Device[deviceIDs.Length];
            for (int i = 0; i < deviceIDs.Length; i++)
                devices[i] = platform.GetDevice(deviceIDs[i]);
            return devices;
        }
Exemple #23
0
 internal CommandQueue( Context context, Device device, IntPtr commandQueueID )
 {
     Context = context;
     Device = device;
     CommandQueueID = commandQueueID;
 }