Esempio n. 1
0
        /// <summary>
        /// Test all versions of:
        /// 
        /// EnqueueWriteImage
        /// EnqueueReadImage
        /// EnqueueCopyImage
        /// 
        /// The test just copies the entirety of a buffer and checks if the result is equal to the original.
        /// An error indicates that one of the above functions failed and further manual analysis is required
        /// to pinpoint the error.
        /// </summary>
        /// <param name="c"></param>
        /// <param name="cq"></param>
        private void TestImageReadWriteCopyOps(Context c, CommandQueue cq)
        {
            if (!cq.Device.ImageSupport)
            {
                Output("Skipping image read/write/copy tests(not supported on this device)");
                return;
            }

            Output("Testing image read/write/copy functions");

            OpenCLNet.Image img0 = null;
            OpenCLNet.Image img1 = null;
            OpenCLNet.Image img2 = null;
            int imgWidth = 1024;
            int imgHeight = 1024;
            int bufLen = imgWidth*4*imgHeight;
            byte[] srcData = new byte[bufLen];
            byte[] cmpData = new byte[bufLen];
            Event event0;
            Event event1;
            Event event2;
            Event event3;
            Event event4;
            Event event5;

            for (int i = 0; i < srcData.Length; i++)
                srcData[i] = (byte)(i);
            Array.Clear(cmpData, 0, cmpData.Length);

            try
            {
                img0 = c.CreateImage2D(MemFlags.READ_WRITE, ImageFormat.RGBA8U, imgWidth, imgHeight);
                img1 = c.CreateImage2D(MemFlags.READ_WRITE, ImageFormat.RGBA8U, imgWidth, imgHeight);
                img2 = c.CreateImage2D(MemFlags.READ_WRITE, ImageFormat.RGBA8U, imgWidth, imgHeight);

                Array.Clear(cmpData, 0, cmpData.Length);
                fixed (byte* pSrc = srcData)
                {
                    fixed (byte* pCmp = cmpData)
                    {
                        {
                            IntPtr[] origin = new IntPtr[3] { (IntPtr)0, (IntPtr)0, (IntPtr)0 };
                            IntPtr[] region = new IntPtr[3] { (IntPtr)imgWidth, (IntPtr)imgHeight, (IntPtr)1 };
                            IntPtr[] dstOrigin = new IntPtr[3] { (IntPtr)0, (IntPtr)0, (IntPtr)0 };
                            IntPtr[] dstRegion = new IntPtr[3] { (IntPtr)imgWidth, (IntPtr)imgHeight, (IntPtr)1 };

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteImage(img0, true, origin, region, IntPtr.Zero, IntPtr.Zero, (IntPtr)pSrc);
                            cq.EnqueueCopyImage(img0, img1, origin, dstOrigin, region);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadImage(img1, true, origin, region, IntPtr.Zero, IntPtr.Zero, (IntPtr)pCmp);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestImageReadWriteCopyOps: (IntPtr version)Copy not identical to source when using no event args");

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteImage(img0, true, origin, region, IntPtr.Zero, IntPtr.Zero, (IntPtr)pSrc, 0, null, out event0);
                            cq.EnqueueCopyImage(img0, img1, origin, dstOrigin, region, 0, null, out event1);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadImage(img1, true, origin, region, IntPtr.Zero, IntPtr.Zero, (IntPtr)pCmp, 0, null, out event2);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestImageReadWriteCopyOps: (IntPtr version)Copy not identical to source with event output and no wait list");

                            Array.Clear(cmpData, 0, cmpData.Length);
                            Event[] events = new Event[] { event0, event1, event2 };
                            cq.EnqueueWriteImage(img0, true, origin, region, IntPtr.Zero, IntPtr.Zero, (IntPtr)pSrc, 3, events);
                            cq.EnqueueCopyImage(img0, img1, origin, dstOrigin, region, 3, events);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadImage(img1, true, origin, region, IntPtr.Zero, IntPtr.Zero, (IntPtr)pCmp, 3, events);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestImageReadWriteCopyOps: (IntPtr version)Copy not identical to source using no event output and a wait list");

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteImage(img0, true, origin, region, IntPtr.Zero, IntPtr.Zero, (IntPtr)pSrc, 3, events, out event3);
                            cq.EnqueueCopyImage(img0, img1, origin, dstOrigin, region, 3, events, out event4);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadImage(img1, true, origin, region, IntPtr.Zero, IntPtr.Zero, (IntPtr)pCmp, 3, events, out event5);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestImageReadWriteCopyOps: (IntPtr version)Copy not identical to source using event output and a wait list");

                            event0.Dispose();
                            event1.Dispose();
                            event2.Dispose();
                            event3.Dispose();
                            event4.Dispose();
                            event5.Dispose();
                        }
                        {
                            int[] origin = new int[3] { 0, 0, 0 };
                            int[] region = new int[3] { imgWidth, imgHeight, 1 };
                            int[] dstOrigin = new int[3] { 0, 0, 0 };
                            int[] dstRegion = new int[3] { imgWidth, imgHeight, 1 };

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteImage(img0, true, origin, region, 0, 0, (IntPtr)pSrc);
                            cq.EnqueueCopyImage(img0, img1, origin, dstOrigin, region);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadImage(img1, true, origin, region, 0, 0, (IntPtr)pCmp);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestImageReadWriteCopyOps: (int version)Copy not identical to source when using no event args");

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteImage(img0, true, origin, region, 0, 0, (IntPtr)pSrc, 0, null, out event0);
                            cq.EnqueueCopyImage(img0, img1, origin, dstOrigin, region, 0, null, out event1);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadImage(img1, true, origin, region, 0, 0, (IntPtr)pCmp, 0, null, out event2);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestImageReadWriteCopyOps: (int version)Copy not identical to source with event output and no wait list");

                            Array.Clear(cmpData, 0, cmpData.Length);
                            Event[] events = new Event[] { event0, event1, event2 };
                            cq.EnqueueWriteImage(img0, true, origin, region, 0, 0, (IntPtr)pSrc, 3, events);
                            cq.EnqueueCopyImage(img0, img1, origin, dstOrigin, region, 0, events);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadImage(img1, true, origin, region, 0, 0, (IntPtr)pCmp, 3, events);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestImageReadWriteCopyOps: (int version)Copy not identical to source using no event output and a wait list");

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteImage(img0, true, origin, region, 0, 0, (IntPtr)pSrc, 3, events, out event3);
                            cq.EnqueueCopyImage(img0, img1, origin, dstOrigin, region, 0, events, out event4);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadImage(img1, true, origin, region, 0, 0, (IntPtr)pCmp, 3, events, out event5);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestImageReadWriteCopyOps: (int version)Copy not identical to source using no event output and a wait list");

                            event0.Dispose();
                            event1.Dispose();
                            event2.Dispose();
                            event3.Dispose();
                            event4.Dispose();
                            event5.Dispose();
                        }
                        {
                            long[] origin = new long[3] { 0, 0, 0 };
                            long[] region = new long[3] { imgWidth, imgHeight, 1 };
                            long[] dstOrigin = new long[3] { 0, 0, 0 };
                            long[] dstRegion = new long[3] { imgWidth, imgHeight, 1 };

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteImage(img0, true, origin, region, 0L, 0L, (IntPtr)pSrc);
                            cq.EnqueueCopyImage(img0, img1, origin, dstOrigin, region);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadImage(img1, true, origin, region, 0L, 0L, (IntPtr)pCmp);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestImageReadWriteCopyOps: (long version)Copy not identical to source when using no event args");

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteImage(img0, true, origin, region, 0L, 0L, (IntPtr)pSrc, 0, null, out event0);
                            cq.EnqueueCopyImage(img0, img1, origin, dstOrigin, region, 0, null, out event1);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadImage(img1, true, origin, region, 0L, 0L, (IntPtr)pCmp, 0, null, out event2);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestImageReadWriteCopyOps: (long version)Copy not identical to source with event output and no wait list");

                            Array.Clear(cmpData, 0, cmpData.Length);
                            Event[] events = new Event[] { event0, event1, event2 };
                            cq.EnqueueWriteImage(img0, true, origin, region, 0L, 0L, (IntPtr)pSrc, 3, events);
                            cq.EnqueueCopyImage(img0, img1, origin, dstOrigin, region, 0, events);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadImage(img1, true, origin, region, 0L, 0L, (IntPtr)pCmp, 3, events);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestImageReadWriteCopyOps: (long version)Copy not identical to source using no event output and a wait list");

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteImage(img0, true, origin, region, 0L, 0L, (IntPtr)pSrc, 3, events, out event3);
                            cq.EnqueueCopyImage(img0, img1, origin, dstOrigin, region, 0, events, out event4);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadImage(img1, true, origin, region, 0L, 0L, (IntPtr)pCmp, 3, events, out event5);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestImageReadWriteCopyOps: (long version)Copy not identical to source using no event output and a wait list");

                            event0.Dispose();
                            event1.Dispose();
                            event2.Dispose();
                            event3.Dispose();
                            event4.Dispose();
                            event5.Dispose();
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Error("Exception during testing: "+e.ToString());
            }
            finally
            {
                if (img0 != null)
                    img0.Dispose();
                if (img1 != null)
                    img1.Dispose();
                if (img2 != null)
                    img2.Dispose();
            }
        }