Moved the cuda_data class into its own file, renamed it to cuda_data_ptr, and

also pushed all the cuda #includes into a .cpp file.

dlib/CMakeLists.txt

@@ -577,6 +577,7 @@ if (NOT TARGET dlib)
                dnn/cudnn_dlibapi.cpp
                dnn/cublas_dlibapi.cpp
                dnn/curand_dlibapi.cpp
+               dnn/cuda_data_ptr.cpp
                dnn/gpu_data.cpp
                )
             set(dlib_needed_libraries ${dlib_needed_libraries} 

dlib/dnn/cuda_data_ptr.cpp

+// Copyright (C) 2017  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_DNN_CuDA_DATA_PTR_CPP_
+#define DLIB_DNN_CuDA_DATA_PTR_CPP_
+
+#ifdef DLIB_USE_CUDA
+
+#include "cuda_data_ptr.h"
+#include "cuda_utils.h"
+
+namespace dlib
+{
+    namespace cuda 
+    {
+
+    // -----------------------------------------------------------------------------------
+
+        cuda_data_void_ptr::
+        cuda_data_void_ptr(
+            size_t n
+        ) : num(n)
+        {
+            if (n == 0)
+                return;
+
+            void* data = nullptr;
+
+            CHECK_CUDA(cudaMalloc(&data, n));
+            pdata.reset(data, [](void* ptr){
+                auto err = cudaFree(ptr);
+                if(err!=cudaSuccess)
+                std::cerr << "cudaFree() failed. Reason: " << cudaGetErrorString(err) << std::endl;
+            });
+        }
+
+    // ------------------------------------------------------------------------------------
+
+        void memcpy(
+            void* dest,
+            const cuda_data_void_ptr& src
+        )
+        {
+            if (src.size() != 0)
+            {
+                CHECK_CUDA(cudaMemcpy(dest, src.data(),  src.size(), cudaMemcpyDefault));
+            }
+        }
+
+    // ------------------------------------------------------------------------------------
+
+        void memcpy(
+            cuda_data_void_ptr& dest, 
+            const void* src
+        )
+        {
+            if (dest.size() != 0)
+            {
+                CHECK_CUDA(cudaMemcpy(dest.data(), src, dest.size(), cudaMemcpyDefault));
+            }
+        }
+
+    // ------------------------------------------------------------------------------------
+
+    }  
+}
+
+#endif // DLIB_USE_CUDA
+
+#endif // DLIB_DNN_CuDA_DATA_PTR_CPP_
+
+

dlib/dnn/cuda_data_ptr.h

+// Copyright (C) 2017  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_DNN_CuDA_DATA_PTR_H_
+#define DLIB_DNN_CuDA_DATA_PTR_H_
+
+#ifdef DLIB_USE_CUDA
+
+#include <memory>
+#include <vector>
+
+namespace dlib
+{
+    namespace cuda
+    {
+
+    // ------------------------------------------------------------------------------------
+
+        class cuda_data_void_ptr
+        {
+            /*!
+                WHAT THIS OBJECT REPRESENTS
+                    This is a block of memory on a CUDA device.  
+            !*/
+        public:
+
+            cuda_data_void_ptr() = default;
+
+            cuda_data_void_ptr(size_t n); 
+            /*!
+                ensures
+                    - This object will allocate a device memory buffer of n bytes.
+                    - #size() == n
+            !*/
+
+            void* data() { return pdata.get(); }
+            const void* data() const { return pdata.get(); }
+            operator void*() { return pdata.get(); }
+            operator const void*() const { return pdata.get(); }
+
+            void reset() { pdata.reset(); }
+
+            size_t size() const { return num; }
+            /*!
+                ensures
+                    - returns the length of this buffer, in bytes.
+            !*/
+
+        private:
+
+            size_t num = 0;
+            std::shared_ptr<void> pdata;
+        };
+
+    // ------------------------------------------------------------------------------------
+
+        void memcpy(
+            void* dest,
+            const cuda_data_void_ptr& src
+        );
+        /*!
+            requires
+                - dest == a pointer to at least src.size() bytes on the host machine.
+            ensures
+                - copies the GPU data from src into dest.
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        void memcpy(
+            cuda_data_void_ptr& dest, 
+            const void* src
+        );
+        /*!
+            requires
+                - dest == a pointer to at least src.size() bytes on the host machine.
+            ensures
+                - copies the host data from src to the GPU memory buffer dest.
+        !*/
+
+    // ------------------------------------------------------------------------------------
+    // ------------------------------------------------------------------------------------
+    // ------------------------------------------------------------------------------------
+
+        template <typename T>
+        class cuda_data_ptr
+        {
+            /*!
+                WHAT THIS OBJECT REPRESENTS
+                    This is a block of memory on a CUDA device.   It is just a type safe
+                    version of cuda_data_void_ptr.
+            !*/
+
+        public:
+
+            static_assert(std::is_standard_layout<T>::value, "You can only create basic standard layout types on the GPU");
+
+            cuda_data_ptr() = default;
+            cuda_data_ptr(size_t n) : num(n)
+            /*!
+                ensures
+                    - This object will allocate a device memory buffer of n T objects.
+                    - #size() == n
+            !*/
+            {
+                if (n == 0)
+                    return;
+
+                pdata = cuda_data_void_ptr(n*sizeof(T));
+            }
+
+            T* data() { return (T*)pdata.data(); }
+            const T* data() const { return (T*)pdata.data(); }
+
+            operator T*() { return (T*)pdata.data(); }
+            operator const T*() const { return (T*)pdata.data(); }
+
+            void reset() { pdata.reset(); }
+
+            size_t size() const { return num; }
+
+
+            friend void memcpy(
+                std::vector<T>& dest,
+                const cuda_data_ptr& src
+            )
+            {
+                dest.resize(src.size());
+                if (src.size() != 0)
+                    memcpy(dest.data(), src.pdata);
+            }
+
+            friend void memcpy(
+                cuda_data_ptr& src,
+                const std::vector<T>& dest
+            )
+            {
+                if (dest.size() != src.size())
+                    dest = cuda_data_ptr<T>(src.size());
+
+                if (src.size() != 0)
+                    memcpy(src.pdata, dest.data());
+            }
+
+        private:
+
+            size_t num = 0;
+            cuda_data_void_ptr pdata;
+        };
+
+    // ------------------------------------------------------------------------------------
+
+    }
+}
+
+#endif // DLIB_USE_CUDA
+
+#endif // DLIB_DNN_CuDA_DATA_PTR_H_
+

dlib/dnn/cuda_utils.h

@@ -36,81 +36,6 @@ namespace dlib
 {
     namespace cuda
     {
-        template <typename T>
-        class cuda_data
-        {
-            /*!
-                WHAT THIS OBJECT REPRESENTS
-                    This is a block of memory on a CUDA device.  
-            !*/
-        public:
-            static_assert(std::is_standard_layout<T>::value, "You can only create basic standard layout types on the GPU");
-
-            cuda_data() = default;
-            cuda_data(size_t n) : num(n)
-            /*!
-                ensures
-                    - This object will allocate a device memory buffer of n T objects.
-                    - #size() == n
-            !*/
-            {
-                if (n == 0)
-                    return;
-
-                T* data = nullptr;
-
-                CHECK_CUDA(cudaMalloc(&data, n*sizeof(T)));
-                pdata.reset((T*)data, [](T* ptr){
-                    auto err = cudaFree(ptr);
-                    if(err!=cudaSuccess)
-                        std::cerr << "cudaFree() failed. Reason: " << cudaGetErrorString(err) << std::endl;
-                });
-            }
-
-            T* data() { return pdata.get(); }
-            const T* data() const { return pdata.get(); }
-
-            operator T*() { return pdata.get(); }
-            operator const T*() const { return pdata.get(); }
-
-            void reset() { pdata.reset(); }
-
-            size_t size() const { return num; }
-
-        private:
-
-            size_t num = 0;
-            std::shared_ptr<T> pdata;
-        };
-
-        template <typename T>
-        void memcpy(
-            std::vector<T>& dest,
-            const cuda_data<T>& src
-        )
-        {
-            dest.resize(src.size());
-            if (src.size() != 0)
-            {
-                CHECK_CUDA(cudaMemcpy(dest.data(), src.data(),  src.size()*sizeof(T), cudaMemcpyDefault));
-            }
-        }
-
-        template <typename T>
-        void memcpy(
-            cuda_data<T>& dest, 
-            const std::vector<T>& src
-        )
-        {
-            if (dest.size() != src.size())
-                dest = cuda_data<T>(src.size());
-
-            if (src.size() != 0)
-            {
-                CHECK_CUDA(cudaMemcpy(dest.data(), src.data(),  src.size()*sizeof(T), cudaMemcpyDefault));
-            }
-        }
-
     }
 }