initial commit

include/Layer.h

@@ -0,0 +1,104 @@
+#ifndef LAYER_H
+#define LAYER_H
+
+#include<iostream>
+#include "utils.h"
+#include "Network.h"
+
+namespace tkDNN {
+
+/**
+    Data rapresentation beetween layers
+*/
+struct dataDim_t {
+
+    int n, c, h, w, l;
+
+    dataDim_t() : n(1), c(1), h(1), w(1), l(1) {};
+
+    dataDim_t(int _n, int _c, int _h, int _w, int _l = 1) :
+        n(_n), c(_c), h(_h), w(_w), l(_l) {};
+
+    void print() {
+        std::cout<<"Data dim: "<<n<<" "<<c<<" "<<h<<" "<<w<<" "<<l<<"\n";
+    }
+
+    int tot() {
+        return n*c*h*w*l;
+    }
+};
+
+/** 
+    Simple layer Father class
+*/
+class Layer {
+
+public:
+    Layer(Network *net, dataDim_t input_dim);
+    virtual ~Layer();
+
+    value_type* infer(dataDim_t &dim, value_type* srcData) {
+        std::cout<<"No infer action for this layer\n";
+        return NULL;
+    }
+
+protected:
+    Network *net;
+    dataDim_t input_dim;
+    cudnnTensorDescriptor_t srcTensorDesc, dstTensorDesc;
+};
+
+/**
+    Father class of all layer that need to load trained weights
+*/
+class LayerWgs : public Layer {
+
+public:
+    LayerWgs(Network *net, dataDim_t input_dim, 
+             int inputs, int outputs, int kh, int kw, int kt, 
+             const char* fname_weights, const char* fname_bias); 
+    virtual ~LayerWgs();
+
+protected:
+    int inputs, outputs;
+    std::string weights_path, bias_path;
+
+    value_type *data_h, *data_d;
+    value_type *bias_h, *bias_d;
+};
+
+/**
+    Dense (full interconnection) layer
+*/
+class Dense : public LayerWgs {
+
+public:
+    Dense(Network *net, dataDim_t in_dim, int out_ch, 
+          const char* fname_weights, const char* fname_bias); 
+    virtual ~Dense();
+
+    value_type* infer(dataDim_t &dim, value_type* srcData);
+
+protected:
+    value_type *dstData;  //where results will be putted
+    int out_ch;
+};
+
+/**
+    Activation layer (it doesnt need weigths)
+*/
+class Activation : public Layer {
+
+public:
+    Activation(Network *net, dataDim_t input_dim, cudnnActivationMode_t act_mode); 
+    virtual ~Activation();
+
+    value_type* infer(dataDim_t &dim, value_type* srcData);
+
+protected:
+    cudnnActivationMode_t act_mode;
+    value_type *dstData;  //where results will be putted
+};
+
+}
+#endif //LAYER_H

include/Network.h

@@ -0,0 +1,21 @@
+#ifndef NETWORK_H
+#define NETWORK_H
+
+#include "utils.h"
+
+namespace tkDNN {
+
+class Network {
+
+public:
+    Network();
+    virtual ~Network();
+
+    cudnnDataType_t dataType;
+    cudnnTensorFormat_t tensorFormat;
+    cudnnHandle_t cudnnHandle;
+    cublasHandle_t cublasHandle;
+};
+
+}
+#endif //NETWORK_H

include/utils.h

@@ -0,0 +1,69 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+#include <iostream>
+#include <sstream>
+#include <fstream>
+#include <iomanip>
+#include <stdlib.h>
+
+#include "cuda.h"
+#include "cuda_runtime_api.h"
+#include <cublas_v2.h>
+#include <cudnn.h>
+
+#define value_type float
+
+
+#define TIMER_START timespec start, end;                               \
+                    clock_gettime(CLOCK_MONOTONIC, &start);            
+
+#define TIMER_STOP  clock_gettime(CLOCK_MONOTONIC, &end);              \
+    double t_ns = ((double)(end.tv_sec - start.tv_sec) * 1.0e9 +       \
+                  (double)(end.tv_nsec - start.tv_nsec))/1.0e6;        \
+    std::cout<<"Time:"<<std::setw(16)<<t_ns<<" ms\n"; 
+
+
+/********************************************************
+ * Prints the error message, and exits
+ * ******************************************************/
+#define EXIT_WAIVED 0
+
+#define FatalError(s) {                                                \
+    std::stringstream _where, _message;                                \
+    _where << __FILE__ << ':' << __LINE__;                             \
+    _message << std::string(s) + "\n" << __FILE__ << ':' << __LINE__;\
+    std::cerr << _message.str() << "\nAborting...\n";                  \
+    cudaDeviceReset();                                                 \
+    exit(EXIT_FAILURE);                                                \
+}
+
+#define checkCUDNN(status) {                                           \
+    std::stringstream _error;                                          \
+    if (status != CUDNN_STATUS_SUCCESS) {                              \
+      _error << "CUDNN failure: " <<cudnnGetErrorString(status);       \
+      FatalError(_error.str());                                        \
+    }                                                                  \
+}
+
+#define checkCuda(status) {                                            \
+    std::stringstream _error;                                          \
+    if (status != 0) {                                                 \
+      _error << "Cuda failure: "<<cudaGetErrorString(status);          \
+      FatalError(_error.str());                                        \
+    }                                                                  \
+}
+
+#define checkERROR(status) {                                           \
+    std::stringstream _error;                                          \
+    if (status != 0) {                                                 \
+      _error << "Generic failure: " << status;                         \
+      FatalError(_error.str());                                        \
+    }                                                                  \
+}
+
+void readBinaryFile(const char* fname, int size, value_type** data_h, value_type** data_d);
+void printDeviceVector(int size, value_type* vec_d);
+void resize(int size, value_type **data);
+
+#endif //UTILS_H