Esempio n. 1
0
        /// <summary>
        ///     Retrieves the specified information about the OpenCL memory object.
        /// </summary>
        /// <typeparam name="T">
        ///     The type of the data that is to be returned.</param>
        ///     <param name="memoryObjectInformation">The kind of information that is to be retrieved.</param>
        ///     <exception cref="OpenClException">
        ///         If the information could not be retrieved, then an <see cref="OpenClException" />
        ///         is thrown.
        ///     </exception>
        ///     <returns>Returns the specified information.</returns>
        private T GetMemoryObjectInformation <T>(MemoryObjectInformation memoryObjectInformation)
        {
            // Retrieves the size of the return value in bytes, this is used to later get the full information
            Result result = MemoryNativeApi.GetMemoryObjectInformation(
                Handle,
                memoryObjectInformation,
                UIntPtr.Zero,
                null,
                out UIntPtr returnValueSize
                );

            if (result != Result.Success)
            {
                throw new OpenClException("The memory object information could not be retrieved.", result);
            }

            // Allocates enough memory for the return value and retrieves it
            byte[] output = new byte[returnValueSize.ToUInt32()];
            result = MemoryNativeApi.GetMemoryObjectInformation(
                Handle,
                memoryObjectInformation,
                new UIntPtr((uint)output.Length),
                output,
                out returnValueSize
                );
            if (result != Result.Success)
            {
                throw new OpenClException("The memory object information could not be retrieved.", result);
            }

            // Returns the output
            return(InteropConverter.To <T>(output));
        }
 internal void Release()
 {
     if (buffer != IntPtr.Zero)
     {
         allocatedMemory -= bufferSizeInBytes;
         MemoryNativeApi.ReleaseMemoryObject(buffer);
         buffer = IntPtr.Zero;
     }
 }
Esempio n. 3
0
        /// <summary>
        /// Disposes of the resources that have been acquired by the memory object.
        /// </summary>
        /// <param name="disposing">Determines whether managed object or managed and unmanaged resources should be disposed of.</param>
        public override void Dispose()
        {
            // Checks if the memory object has already been disposed of, if not, then the memory object is disposed of
            if (!IsDisposed)
            {
                MemoryNativeApi.ReleaseMemoryObject(Handle);
            }

            // Makes sure that the base class can execute its dispose logic
            base.Dispose();
        }
        /// <summary>
        /// Disposes of the resources that have been acquired by the memory object.
        /// </summary>
        /// <param name="disposing">Determines whether managed object or managed and unmanaged resources should be disposed of.</param>
        protected override void Dispose(bool disposing)
        {
            // Checks if the memory object has already been disposed of, if not, then the memory object is disposed of
            if (!this.IsDisposed)
            {
                MemoryNativeApi.ReleaseMemoryObject(this.Handle);
            }

            // Makes sure that the base class can execute its dispose logic
            base.Dispose(disposing);
        }
Esempio n. 5
0
        /// <summary>
        /// Creates a new memory buffer with the specified flags and of the specified size.
        /// </summary>
        /// <param name="memoryFlags">The flags, that determines the how the memory buffer is created and how it can be accessed.</param>
        /// <param name="size">The size of memory that should be allocated for the memory buffer.</param>
        /// <exception cref="OpenClException">If the memory buffer could not be created, then an <see cref="OpenClException"/> is thrown.</exception>
        /// <returns>Returns the created memory buffer.</returns>
        public MemoryBuffer CreateBuffer(Memory.MemoryFlag memoryFlags, int size, object handleIdentifier)
        {
            // Creates a new memory buffer of the specified size and with the specified memory flags
            IntPtr memoryBufferPointer = MemoryNativeApi.CreateBuffer(Handle, (Interop.Memory.MemoryFlag)memoryFlags,
                                                                      new UIntPtr((uint)size), IntPtr.Zero, out Result result);

            // Checks if the creation of the memory buffer was successful, if not, then an exception is thrown
            if (result != Result.Success)
            {
                throw new OpenClException("The memory buffer could not be created.", result);
            }

            // Creates the memory buffer from the pointer to the memory buffer and returns it
            return(new MemoryBuffer(memoryBufferPointer, handleIdentifier));
        }
Esempio n. 6
0
        /// <summary>
        /// Creates a new memory buffer with the specified flags and of the specified size.
        /// </summary>
        /// <param name="memoryFlags">The flags, that determines the how the memory buffer is created and how it can be accessed.</param>
        /// <param name="size">The size of memory that should be allocated for the memory buffer.</param>
        /// <exception cref="OpenClException">If the memory buffer could not be created, then an <see cref="OpenClException"/> is thrown.</exception>
        /// <returns>Returns the created memory buffer.</returns>
        public MemoryBuffer CreateBuffer(OpenCl.DotNetCore.Memory.MemoryFlag memoryFlags, long size)
        {
            // Creates a new memory buffer of the specified size and with the specified memory flags
            Result result;
            IntPtr memoryBufferPointer = MemoryNativeApi.CreateBuffer(this.Handle, (Interop.Memory.MemoryFlag)memoryFlags, new UIntPtr((ulong)size), IntPtr.Zero, out result);

            // Checks if the creation of the memory buffer was successful, if not, then an exception is thrown
            if (result != Result.Success)
            {
                throw new OpenClException("The memory buffer could not be created.", result);
            }

            // Creates the memory buffer from the pointer to the memory buffer and returns it
            return(new MemoryBuffer(memoryBufferPointer));
        }
        public MemoryAllocation CreateMemoryAllocation(IntPtr clContext, uint byteSize, MemoryFlag flags, IntPtr data)
        {
            Result err;
            var    buffer = MemoryNativeApi.CreateBuffer(clContext, flags, new UIntPtr(byteSize), data, out err);

            if (err != Result.Success)
            {
                OnLowDeviceMemory();
                buffer = MemoryNativeApi.CreateBuffer(clContext, flags, new UIntPtr(byteSize), data, out err);
                if (err != Result.Success)
                {
                    ThrowOnError(err, String.Format("Failed to allocate device memory. Size: {0}", byteSize));
                }
            }
            return(new MemoryAllocation(buffer, byteSize, flags));
        }
Esempio n. 8
0
        public MemoryBuffer CreateBuffer(MemoryFlag memoryFlags, Type t, object[] value, object handleIdentifier)
        {
            // Tries to create the memory buffer, if anything goes wrong, then it is crucial to free the allocated memory
            IntPtr hostBufferPointer = IntPtr.Zero;

            try
            {
                // Determines the size of the specified value and creates a pointer that points to the data inside the structure
                int size = Marshal.SizeOf(t) * value.Length;
                hostBufferPointer = Marshal.AllocHGlobal(size);

                for (int i = 0; i < value.Length; i++)
                {
                    Marshal.StructureToPtr(value[i], IntPtr.Add(hostBufferPointer, i * Marshal.SizeOf(t)), false);
                }

                // Creates a new memory buffer for the specified value
                IntPtr memoryBufferPointer = MemoryNativeApi.CreateBuffer(
                    Handle,
                    (Interop.Memory.MemoryFlag)memoryFlags,
                    new UIntPtr(( uint )size),
                    hostBufferPointer,
                    out Result result
                    );

                // Checks if the creation of the memory buffer was successful, if not, then an exception is thrown
                if (result != Result.Success)
                {
                    throw new OpenClException("The memory buffer could not be created.", result);
                }

                // Creates the memory buffer from the pointer to the memory buffer and returns it
                return(new MemoryBuffer(memoryBufferPointer, handleIdentifier));
            }
            finally
            {
                // Deallocates the host memory allocated for the value
                if (hostBufferPointer != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(hostBufferPointer);
                }
            }
        }