initial commit

src/Activation.cpp

@@ -0,0 +1,46 @@
+#include <iostream>
+
+#include "Layer.h"
+
+namespace tkDNN {
+
+Activation::Activation(Network *net, dataDim_t input_dim, cudnnActivationMode_t act_mode) : 
+    Layer(net, input_dim) {
+
+    this->act_mode = act_mode;
+    checkCuda( cudaMalloc(&dstData, input_dim.tot()*sizeof(value_type)) );
+
+    checkCUDNN( cudnnSetTensor4dDescriptor(srcTensorDesc,
+                                        net->tensorFormat,
+                                        net->dataType,
+                                        input_dim.n, input_dim.c,
+                                        input_dim.h, input_dim.w) );
+    checkCUDNN( cudnnSetTensor4dDescriptor(dstTensorDesc,
+                                            net->tensorFormat,
+                                            net->dataType,
+                                            input_dim.n, input_dim.c,
+                                            input_dim.h, input_dim.w) );
+}
+
+Activation::~Activation() {
+
+    checkCuda( cudaFree(dstData) );
+}
+
+value_type* Activation::infer(dataDim_t &dim, value_type* srcData) {
+
+    value_type alpha = value_type(1);
+    value_type beta  = value_type(0);
+    checkCUDNN( cudnnActivationForward(net->cudnnHandle,
+                                        act_mode,
+                                        &alpha,
+                                        srcTensorDesc,
+                                        srcData,
+                                        &beta,
+                                        dstTensorDesc,
+                                        dstData) );    
+
+    return dstData;
+}
+
+}

src/Dense.cpp

@@ -0,0 +1,54 @@
+#include <iostream>
+
+#include "Layer.h"
+
+namespace tkDNN {
+
+Dense::Dense(Network *net, dataDim_t in_dim, 
+    int out_ch, const char* fname_weights, const char* fname_bias) : 
+    LayerWgs(net, in_dim, in_dim.tot(), out_ch, 1, 1, 1, fname_weights, fname_bias) {
+
+    this->out_ch = out_ch;
+    //allocate data for infer result
+    checkCuda( cudaMalloc(&dstData, outputs*sizeof(value_type)) );
+}
+
+Dense::~Dense() {
+
+    checkCuda( cudaFree(dstData) );
+}
+
+value_type* Dense::infer(dataDim_t &dim, value_type* srcData) {
+
+    if (dim.n != 1)
+        FatalError("Not Implemented"); 
+    
+    int dim_x = dim.tot();
+    int dim_y = outputs;
+
+    if (dim_x != inputs)
+        FatalError("Input mismatch");
+
+    value_type alpha = value_type(1), beta = value_type(1);
+    // place bias into dstData
+    checkCuda( cudaMemcpy(dstData, bias_d, dim_y*sizeof(value_type), cudaMemcpyDeviceToDevice) );
+    
+    //do matrix moltiplication
+    checkERROR( cublasSgemv(net->cublasHandle, CUBLAS_OP_T,
+                            dim_x, dim_y,
+                            &alpha,
+                            data_d, dim_x,
+                            srcData, 1,
+                            &beta,
+                            dstData, 1) );
+
+    //update data dimensions    
+    dim.h = 1;
+    dim.w = 1;
+    dim.l = 1;
+    dim.c = dim_y;
+
+    return dstData;
+}
+
+}

src/Layer.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+
+#include "Layer.h"
+
+namespace tkDNN {
+
+Layer::Layer(Network *net, dataDim_t in_dim) {
+
+    this->net = net;
+    this->input_dim = in_dim;
+
+    checkCUDNN( cudnnCreateTensorDescriptor(&srcTensorDesc) );
+    checkCUDNN( cudnnCreateTensorDescriptor(&dstTensorDesc) );
+}
+
+Layer::~Layer() {
+
+    checkCUDNN( cudnnDestroyTensorDescriptor(srcTensorDesc) );
+    checkCUDNN( cudnnDestroyTensorDescriptor(dstTensorDesc) );
+}
+
+}

src/LayerWgs.cpp

@@ -0,0 +1,29 @@
+#include <iostream>
+
+#include "Layer.h"
+
+namespace tkDNN {
+
+LayerWgs::LayerWgs(Network *net, dataDim_t in_dim, 
+                int inputs, int outputs, int kh, int kw, int kl, 
+                const char* fname_weights, const char* fname_bias) : Layer(net, in_dim) {
+
+    this->inputs  = inputs;
+    this->outputs = outputs;    
+    this->weights_path  = std::string(fname_weights);
+    this->bias_path     = std::string(fname_bias);
+
+    std::cout<<"Reading weights: I="<<inputs<<" O="<<outputs<<" KERNEL="<<kh<<"x"<<kw<<"x"<<kl<<"\n";
+    readBinaryFile(weights_path.c_str(), inputs*outputs*kh*kw*kl, &data_h, &data_d);
+    readBinaryFile(bias_path.c_str(), outputs, &bias_h, &bias_d);
+}
+
+LayerWgs::~LayerWgs() {
+
+    delete [] data_h;
+    delete [] bias_h;
+    checkCuda( cudaFree(data_d) );
+    checkCuda( cudaFree(bias_d) );
+}
+
+}

src/Network.cpp

@@ -0,0 +1,23 @@
+#include <iostream>
+
+#include "Network.h"
+
+namespace tkDNN {
+
+Network::Network() {
+
+    std::cout<<"New NETWORK with CUDNN v"<<float(cudnnGetVersion())/1000<<"\n";
+    dataType = CUDNN_DATA_FLOAT;
+    tensorFormat = CUDNN_TENSOR_NCHW;
+
+    checkCUDNN( cudnnCreate(&cudnnHandle) );
+    checkERROR( cublasCreate(&cublasHandle) );
+}
+
+Network::~Network() {
+
+    checkCUDNN( cudnnDestroy(cudnnHandle) );
+    checkERROR( cublasDestroy(cublasHandle) );
+}
+
+}

src/utils.cpp

@@ -0,0 +1,45 @@
+#include "utils.h"
+
+void readBinaryFile(const char* fname, int size, value_type** data_h, value_type** data_d)
+{
+    std::ifstream dataFile (fname, std::ios::in | std::ios::binary);
+    std::stringstream error_s;
+    if (!dataFile)
+    {
+        error_s << "Error opening file " << fname; 
+        FatalError(error_s.str());
+    }
+    int size_b = size*sizeof(value_type);
+    *data_h = new value_type[size];
+    if (!dataFile.read ((char*) *data_h, size_b)) 
+    {
+        error_s << "Error reading file " << fname; 
+        FatalError(error_s.str());
+    }
+    
+    checkCuda( cudaMalloc(data_d, size_b) );
+    checkCuda( cudaMemcpy(*data_d, *data_h,
+                                size_b,
+                                cudaMemcpyHostToDevice) );
+}
+
+void printDeviceVector(int size, value_type* vec_d)
+{
+    value_type *vec;
+    vec = new value_type[size];
+    cudaDeviceSynchronize();
+    cudaMemcpy(vec, vec_d, size*sizeof(value_type), cudaMemcpyDeviceToHost);
+    for (int i = 0; i < size; i++)
+    {
+        std::cout << vec[i] << " ";
+    }
+    std::cout << std::endl;
+    delete [] vec;
+}
+
+void resize(int size, value_type **data)
+{
+    if (*data != NULL)
+        checkCuda( cudaFree(*data) );
+    checkCuda( cudaMalloc(data, size*sizeof(value_type)) );
+}