CLOO: Memory Leaking Troubles

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Cloo;
 
namespace OpenCLTesting
{
    class Program
    {
        static void Main(string[] args)
        {
            ///first lets collect all the compute devices on all detected platforms
            ///this may be a little overkill but i was experimenting with ideas at the time
            Dictionary<ComputeContext, List<ComputeDevice>> thesystem
                = new Dictionary<ComputeContext, List<ComputeDevice>>();
            List<ComputeDevice> allDevices;
            ComputeContext context;
            foreach(ComputePlatform cp in ComputePlatform.Platforms)
            {
 
                ComputeContextPropertyList propertyList = new ComputeContextPropertyList(cp);
                context = new ComputeContext(ComputeDeviceTypes.All, propertyList, null, IntPtr.Zero);
                allDevices = new List<ComputeDevice>();
                foreach(ComputeDevice cd in context.Devices)
                {
                    allDevices.Add(cd);
                }
                thesystem.Add(context, allDevices);
            }
 
 
            string vectorAddKernel = @"kernel void
            vectorAdd(global read_only float * a,
                      global read_only float * b,
                      global write_only float * c)
            {
                // Vector element index
                int nIndex = get_global_id(0);
                c[nIndex] = a[nIndex] + b[nIndex];
            }";
 
            int testSize = 1024;
            int testLengthInSeconds = 60;
 
            ///we will be tested each device in each platform for performance
            ///we will print off the data so it can be collected and observed
            foreach (KeyValuePair<ComputeContext, List<ComputeDevice>> platform in thesystem)
            {
                ComputeContext localContext = platform.Key;
                List<ComputeDevice> devices = platform.Value;
 
                foreach (ComputeDevice device in devices)
                {
                    //Testing each individual device
                    Console.WriteLine("DevicePlatform = {0}",device.Platform.Name);
                    Console.WriteLine("DeviceName = {0}",device.Name);
                    Console.WriteLine("DeviceCUnits = {0}", device.MaxComputeUnits);
                    Console.WriteLine("DeviceSpeed = {0}", device.MaxClockFrequency);
 
                    float result = testDevice(localContext, device, testLengthInSeconds, testSize, vectorAddKernel, "vectorAdd");
                    Console.WriteLine("DevicePerformance = {0}",result);
 
                    //float result1 = testYetAgain(localContext, device, testLengthInSeconds, testSize, vectorAddKernel, "vectorAdd");
                    //Console.WriteLine("DevicePerformance1 = {0}", result1 );
                }
            }
            Console.ReadLine();
        }
 
        /// <summary>
        /// here we attempt to separate the oonstruction of the values needed 
        /// by the kernel during execution time.  This is being done in an
        /// attempt to make execution of the kernel slightly more abstracted
        /// </summary>
        /// <param name="localContext">the compute context</param>
        /// <param name="device">the device we are running on</param>
        /// <param name="lengthOfTestSeconds">how long in seconds we would like the test to run</param>
        /// <param name="testSize">the number of objects the kernel will be performing in one batch 'these are just floats for now'</param>
        /// <param name="kernelSource">the kernels source</param>
        /// <param name="kernelName">the name of the kernel in the source</param>
        /// <returns>a float value representing how well this device performed</returns>
        private static float testDevice(
            ComputeContext localContext, 
            ComputeDevice device, 
            int lengthOfTestSeconds, 
            int testSize,
            string kernelSource, 
            string kernelName)
        {
            float result = 0.0f;
 
            //create our test kernel instance
            Test2Kernel t2k = new Test2Kernel(localContext, device, kernelSource, kernelName);
 
            //the number of inputs to the kernel
            int inputCount = 2;
            List<float[]> inputs = new List<float[]>();
            for (int i = 0; i < inputCount; i++)
            {
                float[] arrI = new float[testSize];
                inputs.Add(arrI);
            }
 
            //an array for our outputs
            int outputCount = 1;
            List<float[]> outputs = new List<float[]>();
            for (int i = 0; i < outputCount; i++)
            {
                float[] arrC = new float[testSize];
                outputs.Add(arrC);
            }
 
            //just setting up random number gen some timing stuff and the
            //arrays list that will store all of our communication with the kernel
            Random rand = new Random();
            DateTime start = DateTime.Now;
            TimeSpan testLength = new TimeSpan(0, 0, lengthOfTestSeconds);
            List<float[]> arrays = new List<float[]>();
 
            //just looping through till time is up
            while ((DateTime.Now - start) < testLength)
            {
                //clear our array
                arrays.Clear();
 
                //for the size of the test, (currently set to 1024)
                for (int i = 0; i < testSize; i++)
                {
                    //for each input buffer we will genereate a random double
                    for (int l_inputs = 0; l_inputs < inputCount; l_inputs++)
                    {
                        inputs[l_inputs][i] = (float)(rand.NextDouble() * 100);
                    }
                    //for each output buffer we will initialize to zero
                    for (int l_outputs = 0; l_outputs < outputCount; l_outputs++)
                    {
                        outputs[l_outputs][i] = 0.0f;
                    }
                }
 
                //now loop through our inputs and add them to arrays
                for (int i = 0; i < inputCount; i++)
                {
                    arrays.Add(inputs[i]);
                }
                //do the same with outputs
                for (int i = 0; i < outputCount; i++)
                {
                    arrays.Add(outputs[i]);
                }
 
                //now perform our calculation by lettting the kernel know how long
                //the test is, where the arrays are, the number of inputs and the
                //number of outputs
                t2k.performCalculation(testSize, ref arrays, inputCount, outputCount);
 
                //just some debuging to let us know it is running
                //Console.WriteLine("{0}){1} + {2} = {3}", result, arrays[0][0], arrays[1][0], arrays[2][0]);
                result++;
 
                //desparate attempt to get the memory leak to go away
                GC.Collect();
                GC.WaitForPendingFinalizers();
            }
 
            //we are calcualting performance as the size of the test (so 1024)
            //multiplied by the number of times it got through the loop
            //devided by the length of the test
            //this should possibly give us something like calculations per second
            return (float)testSize * result / lengthOfTestSeconds;
        }
 
        /// <summary>
        /// flattened version of test2kernel to rule out anything weird happening
        /// in our test2kernel instance based test.
        /// </summary>
        /// <param name="localContext"></param>
        /// <param name="device"></param>
        /// <param name="lengthOfTestSeconds"></param>
        /// <param name="testSize"></param>
        /// <param name="kernelSource"></param>
        /// <param name="kernelName"></param>
        /// <returns></returns>
        public static float testYetAgain(ComputeContext localContext,
            ComputeDevice device,
            int lengthOfTestSeconds,
            int testSize,
            string kernelSource,
            string kernelName)
        {
            float result = 0.0f;
 
            ComputeProgram m_computeProgram;
            ComputeKernel m_computeKernel;
            ComputeBuffer<float> tempBuffer;
            ComputeCommandQueue m_queue;
            ComputeBuffer<float>[] m_buffers;
 
            m_computeProgram = new ComputeProgram(localContext, new string[] { kernelSource });
            m_computeProgram.Build(null, null, null, IntPtr.Zero);
            m_computeKernel = m_computeProgram.CreateKernel(kernelName);
            m_queue = new ComputeCommandQueue(localContext, device, ComputeCommandQueueFlags.None);
            m_buffers = new ComputeBuffer<float>[3];
 
            // the number of values we want to run through the kernel each pass
            //int count = 10;
            //the number of inputs to the kernel
            int inputCount = 2;
            List<float[]> inputs = new List<float[]>();
            for (int i = 0; i < inputCount; i++)
            {
                float[] arrI = new float[testSize];
                inputs.Add(arrI);
            }
 
            //an array for our outputs
            int outputCount = 1;
            List<float[]> outputs = new List<float[]>();
            for (int i = 0; i < outputCount; i++)
            {
                float[] arrC = new float[testSize];
                outputs.Add(arrC);
            }
 
 
            Random rand = new Random();
            DateTime start = DateTime.Now;
            TimeSpan testLength = new TimeSpan(0, 0, lengthOfTestSeconds);
            List<float[]> arrays = new List<float[]>();
 
            while ((DateTime.Now - start) < testLength)
            {
                arrays.Clear();
 
                for (int i = 0; i < testSize; i++)
                {
 
                    for (int l_inputs = 0; l_inputs < inputCount; l_inputs++)
                    {
                        inputs[l_inputs][i] = (float)(rand.NextDouble() * 100);
                    }
                    for (int l_outputs = 0; l_outputs < outputCount; l_outputs++)
                    {
                        outputs[l_outputs][i] = 0.0f;
                    }
                }
 
                for (int i = 0; i < inputCount; i++)
                {
                    arrays.Add(inputs[i]);
                }
                for (int i = 0; i < outputCount; i++)
                {
                    arrays.Add(outputs[i]);
                }
 
                //t2k.performCalculation(testSize, ref arrays, inputCount, outputCount);
                for (int i = 0; i < inputCount; i++)
                {
                    m_buffers[i] = new ComputeBuffer<float>(localContext, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, arrays[i]);
                }
 
                for (int i = inputCount; i < inputCount + outputCount; i++)
                {
                    m_buffers[i] = new ComputeBuffer<float>(localContext, ComputeMemoryFlags.WriteOnly, arrays[i].Length);
                }
 
                for (int i = 0; i < inputCount + outputCount; i++)
                {
                    m_computeKernel.SetMemoryArgument(i, m_buffers[i]);
                }
 
                m_queue.Execute(m_computeKernel, null, new long[] { testSize }, null, null);
 
                for (int i = inputCount; i < inputCount + outputCount; i++)
                {
                    arrays[i] = m_queue.Read(m_buffers[i], true, 0, testSize, null);
                }
 
                for (int i = 0; i < inputCount + outputCount; i++)
                {
                    m_buffers[i].Dispose();
                }
 
 
                //Console.WriteLine("{0})", result);
                result++;
                //GC.Collect();
                //GC.WaitForPendingFinalizers();
            }
 
            return (float)testSize * result / lengthOfTestSeconds;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Cloo;
 
namespace OpenCLTesting
{
    class Test2Kernel
    {
        ComputeContext m_context;
        ComputeDevice m_device;
        ComputeProgram m_computeProgram;
        ComputeKernel m_computeKernel;
        ComputeBuffer<float> tempBuffer;
        ComputeCommandQueue m_queue;
        //ComputeBuffer<float>[] m_buffers;
        List<ComputeBuffer<float>> m_buffers;
        string m_kernelSource;
        string m_kernelName;
 
        /// <summary>
        /// Constructor prepares a device given the the kernel information
        /// </summary>
        /// <param name="context"></param>
        /// <param name="device"></param>
        /// <param name="kernelSource"></param>
        /// <param name="kernelName"></param>
        public Test2Kernel(ComputeContext context, ComputeDevice device, String kernelSource, String kernelName)
        {
            m_context = context;
            m_device = device;
            m_kernelSource = kernelSource;
            m_kernelName = kernelName;
            initialize();
 
        }
 
 
        /// <summary>
        /// pull out the instantiation of everything
        /// originally thought to 're-initialize' everything if certain conditions
        /// arize during execution 
        /// </summary>
        private void initialize()
        {
            m_computeProgram = new ComputeProgram(m_context, new string[]{m_kernelSource});
            m_computeProgram.Build(null, null, null, IntPtr.Zero);
            m_computeKernel = m_computeProgram.CreateKernel(m_kernelName);
            m_queue = new ComputeCommandQueue(m_context, m_device, ComputeCommandQueueFlags.None);
            //m_buffers = new ComputeBuffer<float>[3];
            m_buffers = new List<ComputeBuffer<float>>();
        }
 
        /// <summary>
        /// this perofrms the actual construciton of our compute buffers
        /// and then performs the calculation.  The only Cloo items that
        /// are being reset each time are the ComputeBuffers.
        /// 
        /// Have tried several ways of storing the buffers 'as array'
        /// 'as a list' but each way we still end up with a rather nasty
        /// memory leak
        /// </summary>
        /// <param name="count"></param>
        /// <param name="arrays"></param>
        /// <param name="inputCount"></param>
        /// <param name="outputCount"></param>
        public void performCalculation( 
            int count,
            ref List<float[]> arrays,
            int inputCount,
            int outputCount)
        {
            //add our 'input' compute buffers to the compute buffer list
            for (int i = 0; i < inputCount; i++)
            {
                tempBuffer = new ComputeBuffer<float>(m_context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, arrays[i]);
                m_buffers.Add(tempBuffer);
                //m_buffers[i] = new ComputeBuffer<float>(m_context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, arrays[i]);
            }
 
            //add our 'output' compute bufferes to the main compute buffer list
            for (int i = inputCount; i < inputCount + outputCount; i++)
            {
                tempBuffer = new ComputeBuffer<float>(m_context, ComputeMemoryFlags.WriteOnly, arrays[i].Length);
                m_buffers.Add(tempBuffer);
                //m_buffers[i] = new ComputeBuffer<float>(m_context, ComputeMemoryFlags.WriteOnly, arrays[i].Length);
            }
 
            //map our compute buffers to the kernel
            for (int i = 0; i < inputCount + outputCount; i++)
            {
                m_computeKernel.SetMemoryArgument(i, m_buffers[i]);
            }
 
            //execute our kernel
            m_queue.Execute(m_computeKernel, null, new long[] { count }, null, null);
 
            //read from each output buffer and save it into our array reference
            for (int i = inputCount; i < inputCount + outputCount; i++)
            {
                arrays[i] = m_queue.Read(m_buffers[i], true, 0, count, null);
            }
 
            //dispose of each buffer
            for (int i = 0; i < inputCount+outputCount; i++)
            {
                m_buffers[i].Dispose();
            }
 
            m_buffers.Clear();
            //tempBuffer.Dispose();
        }
    }
}