Ejemplo n.º 1
0
        private void TestCommandQueueMemCopy(Context c, CommandQueue cq)
        {
            Output("Testing synchronous host memory->memory copy");

            AlignedArrayFloat aafSrc = new AlignedArrayFloat(1024 * 1024, 64);
            AlignedArrayFloat aafDst = new AlignedArrayFloat(1024 * 1024, 64);

            SetAAF(aafSrc, 0.0f);
            SetAAF(aafDst, 1.0f);

            /// Test HOST_PTR -> HOST_PTR copy
            /// The call to EnqueueMapBuffer synchronizes caches before testing the result
            using (Mem memSrc = c.CreateBuffer((MemFlags)((ulong)MemFlags.READ_WRITE+(ulong)MemFlags.USE_HOST_PTR), aafSrc.ByteLength, aafSrc))
            {
                using (Mem memDst = c.CreateBuffer((MemFlags)((ulong)MemFlags.READ_WRITE+(ulong)MemFlags.USE_HOST_PTR), aafDst.ByteLength, aafDst))
                {
                    cq.EnqueueCopyBuffer(memSrc, memDst, IntPtr.Zero, IntPtr.Zero, (IntPtr)aafSrc.ByteLength);
                    cq.EnqueueBarrier();
                    IntPtr mappedPtr = cq.EnqueueMapBuffer(memDst, true, MapFlags.READ_WRITE, (IntPtr)0, (IntPtr)aafDst.ByteLength);
                    if (!TestAAF(aafDst, 0.0f))
                        Error("EnqueueCopyBuffer failed, destination is invalid");
                    cq.EnqueueUnmapMemObject(memDst, mappedPtr);
                    cq.EnqueueBarrier();
                }
            }

            /// Test COPY_HOST_PTR -> COPY_HOST_PTR copy
            /// Verify that original source buffers are intact and that the copy was successful
            SetAAF(aafSrc, 0.0f);
            SetAAF(aafDst, 1.0f);
            using (Mem memSrc = c.CreateBuffer(MemFlags.COPY_HOST_PTR, aafSrc.ByteLength, aafSrc))
            {
                using (Mem memDst = c.CreateBuffer(MemFlags.COPY_HOST_PTR, aafSrc.ByteLength, aafDst))
                {
                    SetAAF(aafSrc, 2.0f);
                    SetAAF(aafDst, 3.0f);

                    cq.EnqueueCopyBuffer(memSrc, memDst, IntPtr.Zero, IntPtr.Zero, (IntPtr)aafSrc.ByteLength);
                    cq.Finish();

                    if (!TestAAF(aafSrc, 2.0f))
                        Error("Memory copy destroyed src buffer");
                    if (!TestAAF(aafDst, 3.0f))
                        Error("Memory copy destroyed dst buffer");
                    Event ev;
                    cq.EnqueueReadBuffer(memDst, false, IntPtr.Zero, (IntPtr)aafDst.ByteLength, aafDst,0, null, out ev);
                    cq.EnqueueWaitForEvents(1, new Event[] { ev });
                    ev.Dispose();
                    cq.Finish();
                    if (!TestAAF(aafDst, 0.0f))
                        Error("Memory copy failed");
                }
            }

            /// Test ALLOC_HOST_PTR -> ALLOC_HOST_PTR copy
            SetAAF(aafSrc, 0.0f);
            SetAAF(aafDst, 1.0f);
            using (Mem memSrc = c.CreateBuffer((MemFlags)((ulong)MemFlags.ALLOC_HOST_PTR + (ulong)MemFlags.READ_WRITE), aafSrc.ByteLength, IntPtr.Zero))
            {
                using (Mem memDst = c.CreateBuffer((MemFlags)((ulong)MemFlags.ALLOC_HOST_PTR + (ulong)MemFlags.WRITE_ONLY), aafSrc.ByteLength, IntPtr.Zero))
                {
                    cq.EnqueueWriteBuffer(memSrc, false, (IntPtr)0, (IntPtr)aafSrc.ByteLength, aafSrc);
                    cq.EnqueueWriteBuffer(memDst, false, (IntPtr)0, (IntPtr)aafSrc.ByteLength, aafSrc);
                    cq.EnqueueBarrier();

                    cq.EnqueueCopyBuffer(memSrc, memDst, IntPtr.Zero, IntPtr.Zero, (IntPtr)aafSrc.ByteLength);
                    cq.EnqueueBarrier();

                    cq.EnqueueReadBuffer(memDst, true, IntPtr.Zero, (IntPtr)aafDst.ByteLength, aafDst);
                    if (!TestAAF(aafDst, 0.0f))
                        Error("Memory copy failed");
                }
            }

            /// Test DEFAULT -> DEFAULT copy
            SetAAF(aafSrc, 0.0f);
            SetAAF(aafDst, 1.0f);
            using (Mem memSrc = c.CreateBuffer((MemFlags)((ulong)MemFlags.ALLOC_HOST_PTR + (ulong)MemFlags.READ_ONLY), aafSrc.ByteLength, IntPtr.Zero))
            {
                using (Mem memDst = c.CreateBuffer((MemFlags)((ulong)MemFlags.ALLOC_HOST_PTR + (ulong)MemFlags.WRITE_ONLY), aafSrc.ByteLength, IntPtr.Zero))
                {
                    cq.EnqueueWriteBuffer(memSrc, false, (IntPtr)0, (IntPtr)aafSrc.ByteLength, aafSrc);
                    cq.EnqueueWriteBuffer(memDst, false, (IntPtr)0, (IntPtr)aafSrc.ByteLength, aafSrc);
                    cq.EnqueueBarrier();

                    cq.EnqueueCopyBuffer(memSrc, memDst, IntPtr.Zero, IntPtr.Zero, (IntPtr)aafSrc.ByteLength);
                    cq.EnqueueBarrier();

                    cq.EnqueueReadBuffer(memDst, true, IntPtr.Zero, (IntPtr)aafDst.ByteLength, aafDst);
                    if (!TestAAF(aafDst, 0.0f))
                        Error("Memory copy failed");
                }
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Test all versions of:
        /// 
        /// EnqueueReadBuffer
        /// EnqueueWriteBuffer
        /// EnqueueCopyBuffer
        /// 
        /// 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 TestReadWriteCopyOps(Context c, CommandQueue cq)
        {
            Output("Testing read/write/copy functions");
            Mem buf0 = null;
            Mem buf1 = null;
            Mem buf2 = null;
            int bufLen = 1024 * 1024;
            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
            {
                buf0 = c.CreateBuffer(MemFlags.READ_WRITE, bufLen, IntPtr.Zero);
                buf1 = c.CreateBuffer(MemFlags.READ_WRITE, bufLen, IntPtr.Zero);
                buf2 = c.CreateBuffer(MemFlags.READ_WRITE, bufLen, IntPtr.Zero);

                #region Test EnqueueReadBuffer EnqueueWriteBuffer EnqueueCopyBuffer

                fixed (byte* pSrc = srcData)
                {
                    fixed (byte* pCmp = cmpData)
                    {
                        {
                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteBuffer(buf0, true, (IntPtr)0, (IntPtr)bufLen, (IntPtr)pSrc);
                            cq.EnqueueCopyBuffer(buf0, buf1, (IntPtr)0, (IntPtr)0, (IntPtr)bufLen);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadBuffer(buf1, true, (IntPtr)0, (IntPtr)bufLen, (IntPtr)pCmp);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestReadWriteCopyOps(IntPtr version): Copy not identical to source");

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteBuffer(buf0, true, (IntPtr)0, (IntPtr)bufLen, (IntPtr)pSrc, 0, null, out event0 );
                            cq.EnqueueCopyBuffer(buf0, buf1, (IntPtr)0, (IntPtr)0, (IntPtr)bufLen, 0, null, out event1);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadBuffer(buf1, true, (IntPtr)0, (IntPtr)bufLen, (IntPtr)pCmp, 0, null, out event2);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestReadWriteCopyOps(IntPtr version): Copy not identical to source");

                            Event[] events = new Event[] { event0, event1, event2 };

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteBuffer(buf0, true, (IntPtr)0, (IntPtr)bufLen, (IntPtr)pSrc, 3, events);
                            cq.EnqueueCopyBuffer(buf0, buf1, (IntPtr)0, (IntPtr)0, (IntPtr)bufLen, 3, events);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadBuffer(buf1, true, (IntPtr)0, (IntPtr)bufLen, (IntPtr)pCmp, 3, events);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestReadWriteCopyOps(IntPtr version): Copy not identical to source");

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteBuffer(buf0, true, (IntPtr)0, (IntPtr)bufLen, (IntPtr)pSrc, 3, events, out event3);
                            cq.EnqueueCopyBuffer(buf0, buf1, (IntPtr)0, (IntPtr)0, (IntPtr)bufLen, 3, events, out event4);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadBuffer(buf1, true, (IntPtr)0, (IntPtr)bufLen, (IntPtr)pCmp, 3, events, out event5);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestReadWriteCopyOps(IntPtr version): Copy not identical to source");

                            event0.Dispose();
                            event1.Dispose();
                            event2.Dispose();
                            event3.Dispose();
                            event4.Dispose();
                            event5.Dispose();
                        }

                        {
                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteBuffer(buf0, true, 0, bufLen, (IntPtr)pSrc);
                            cq.EnqueueCopyBuffer(buf0, buf1, 0, 0, bufLen);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadBuffer(buf1, true, 0, bufLen, (IntPtr)pCmp);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestReadWriteCopyOps(int version): Copy not identical to source");

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteBuffer(buf0, true, 0, bufLen, (IntPtr)pSrc, 0, null, out event0);
                            cq.EnqueueCopyBuffer(buf0, buf1, 0, 0, bufLen, 0, null, out event1);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadBuffer(buf1, true, 0, bufLen, (IntPtr)pCmp, 0, null, out event2);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestReadWriteCopyOps(int version): Copy not identical to source");

                            Event[] events = new Event[] { event0, event1, event2 };

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteBuffer(buf0, true, 0, bufLen, (IntPtr)pSrc, 3, events);
                            cq.EnqueueCopyBuffer(buf0, buf1, 0, 0, bufLen, 3, events);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadBuffer(buf1, true, 0, bufLen, (IntPtr)pCmp, 3, events);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestReadWriteCopyOps(int version): Copy not identical to source");

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteBuffer(buf0, true, 0, bufLen, (IntPtr)pSrc, 3, events, out event3);
                            cq.EnqueueCopyBuffer(buf0, buf1, 0, 0, bufLen, 3, events, out event4);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadBuffer(buf1, true, 0, bufLen, (IntPtr)pCmp, 3, events, out event5);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestReadWriteCopyOps(int version): Copy not identical to source");

                            event0.Dispose();
                            event1.Dispose();
                            event2.Dispose();
                            event3.Dispose();
                            event4.Dispose();
                            event5.Dispose();
                        }

                        {
                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteBuffer(buf0, true, 0L, (long)bufLen, (IntPtr)pSrc);
                            cq.EnqueueCopyBuffer(buf0, buf1, 0L, 0L, (long)bufLen);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadBuffer(buf1, true, 0L, (long)bufLen, (IntPtr)pCmp);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestReadWriteCopyOps(long version): Copy not identical to source");

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteBuffer(buf0, true, 0L, (long)bufLen, (IntPtr)pSrc, 0, null, out event0);
                            cq.EnqueueCopyBuffer(buf0, buf1, 0L, 0L, (long)bufLen, 0, null, out event1);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadBuffer(buf1, true, 0L, (long)bufLen, (IntPtr)pCmp, 0, null, out event2);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestReadWriteCopyOps(long version): Copy not identical to source");

                            Event[] events = new Event[] { event0, event1, event2 };

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteBuffer(buf0, true, 0L, (long)bufLen, (IntPtr)pSrc, 3, events);
                            cq.EnqueueCopyBuffer(buf0, buf1, 0L, 0L, (long)bufLen, 3, events);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadBuffer(buf1, true, 0L, (long)bufLen, (IntPtr)pCmp, 3, events);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestReadWriteCopyOps(long version): Copy not identical to source");

                            Array.Clear(cmpData, 0, cmpData.Length);
                            cq.EnqueueWriteBuffer(buf0, true, 0L, (long)bufLen, (IntPtr)pSrc, 3, events, out event3);
                            cq.EnqueueCopyBuffer(buf0, buf1, 0L, 0L, (long)bufLen, 3, events, out event4);
                            cq.EnqueueBarrier();
                            cq.EnqueueReadBuffer(buf1, true, 0L, (long)bufLen, (IntPtr)pCmp, 3, events, out event5);
                            if (!CompareArray(cmpData, srcData))
                                Error("TestReadWriteCopyOps(long version): Copy not identical to source");

                            event0.Dispose();
                            event1.Dispose();
                            event2.Dispose();
                            event3.Dispose();
                            event4.Dispose();
                            event5.Dispose();
                        }
                    }
                }
                #endregion
            }
            catch (Exception e)
            {
                Error("Exception during testing: " + e.ToString());
            }
            finally
            {
                if (buf0 != null)
                    buf0.Dispose();
                if (buf1 != null)
                    buf1.Dispose();
                if (buf2 != null)
                    buf2.Dispose();
            }
        }