Merge remote-tracking branch 'origin/master' into cnet

include/tkDNN/DetectionNN.h

@@ -4,7 +4,10 @@
 #include <iostream>
 #include <signal.h>
 #include <stdlib.h>    
+#ifdef __linux__
 #include <unistd.h>
+#endif 
+
 #include <mutex>
 #include "utils.h"
 
@@ -14,7 +17,7 @@
 
 #include "tkdnn.h"
 
-// #define OPENCV_CUDACONTRIB //if OPENCV has been compiled with CUDA and contrib.
+//#define OPENCV_CUDACONTRIB //if OPENCV has been compiled with CUDA and contrib.
 
 #ifdef OPENCV_CUDACONTRIB
 #include <opencv2/cudawarping.hpp>
@@ -150,7 +153,6 @@ class DetectionNN {
             int x0, w, x1, y0, h, y1;
             int objClass;
             std::string det_class;
-
             int baseline = 0;
             float font_scale = 0.5;
             int thickness = 2;   

include/tkDNN/ImuOdom.h

@@ -1,7 +1,14 @@
 #include <iostream>
 #include <signal.h>
 #include <stdlib.h>     /* srand, rand */
+
+#ifdef __linux__
 #include <unistd.h>
+#elif _WIN32
+#define _USE_MATH_DEFINES
+#include <math.h>
+#endif 
+
 #include <mutex>
 #include <Eigen/Dense>
 #include "utils.h"

include/tkDNN/Int8BatchStream.h

@@ -11,8 +11,11 @@
 #include <fstream>
 #include <iomanip>
 #include <signal.h>
-#include <stdlib.h>    
+#include <stdlib.h>
+#ifdef __linux__    
 #include <unistd.h>
+#endif
+
 #include <mutex>
 
 #include "NvInfer.h"

include/tkDNN/Layer.h

@@ -19,6 +19,7 @@ enum layerType_t {
     LAYER_ACTIVATION_CRELU,
     LAYER_ACTIVATION_LEAKY,
     LAYER_ACTIVATION_MISH,
+    LAYER_ACTIVATION_LOGISTIC,
     LAYER_FLATTEN,
     LAYER_RESHAPE,
     LAYER_MULADD,
@@ -68,6 +69,7 @@ public:
             case LAYER_ACTIVATION_CRELU:    return "ActivationCReLU";
             case LAYER_ACTIVATION_LEAKY:    return "ActivationLeaky";
             case LAYER_ACTIVATION_MISH:     return "ActivationMish";
+            case LAYER_ACTIVATION_LOGISTIC: return "ActivationLogistic";
             case LAYER_FLATTEN:             return "Flatten";
             case LAYER_RESHAPE:             return "Reshape";
             case LAYER_MULADD:              return "MulAdd";
@@ -212,7 +214,8 @@ public:
 typedef enum {
     ACTIVATION_ELU     = 100,
     ACTIVATION_LEAKY   = 101,
-    ACTIVATION_MISH   = 102
+    ACTIVATION_MISH   = 102,
+    ACTIVATION_LOGISTIC   = 103
 } tkdnnActivationMode_t;
 
 /**
@@ -233,6 +236,8 @@ public:
             return LAYER_ACTIVATION_LEAKY;
         else if (act_mode == ACTIVATION_MISH)
             return LAYER_ACTIVATION_MISH;
+        else if (act_mode == ACTIVATION_LOGISTIC)
+            return LAYER_ACTIVATION_LOGISTIC;
         else
             return LAYER_ACTIVATION;
          };

include/tkDNN/NetworkRT.h

@@ -6,6 +6,7 @@
 #include "Network.h"
 #include "Layer.h"
 #include "NvInfer.h"
+#include <memory>
 
 namespace tk { namespace dnn {
 
@@ -24,6 +25,7 @@ template<typename T> T readBUF(const char*& buffer)
 
 using namespace nvinfer1;
 #include "pluginsRT/ActivationLeakyRT.h"
+#include "pluginsRT/ActivationLogisticRT.h"
 #include "pluginsRT/ActivationReLUCeilingRT.h"
 #include "pluginsRT/ActivationMishRT.h"
 #include "pluginsRT/ReorgRT.h"
@@ -59,6 +61,7 @@ public:
 #if NV_TENSORRT_MAJOR >= 6  
     nvinfer1::IBuilderConfig *configRT;
 #endif
+    
     nvinfer1::ICudaEngine *engineRT;
     nvinfer1::IExecutionContext *contextRT;
 
@@ -114,6 +117,9 @@ public:
 
     bool serialize(const char *filename);
     bool deserialize(const char *filename);
+
+
+
 };
 
 }}

include/tkDNN/pluginsRT/ActivationLeakyRT.h

@@ -52,8 +52,9 @@ public:
 	}
 
 	virtual void serialize(void* buffer) override {
-		char *buf = reinterpret_cast<char*>(buffer);
+		char *buf = reinterpret_cast<char*>(buffer),*a=buf;
 		tk::dnn::writeBUF(buf, size);
+		assert(buf == a + getSerializationSize());
 	}
 
 	int size;

include/tkDNN/pluginsRT/ActivationLogisticRT.h

@@ -0,0 +1,60 @@
+#include<cassert>
+#include "../kernels.h"
+
+class ActivationLogisticRT : public IPlugin {
+
+public:
+    ActivationLogisticRT() {
+
+
+    }
+
+    ~ActivationLogisticRT(){
+
+    }
+
+    int getNbOutputs() const override {
+        return 1;
+    }
+
+    Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override {
+        return inputs[0];
+    }
+
+    void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override {
+        size = 1;
+        for(int i=0; i<outputDims[0].nbDims; i++)
+            size *= outputDims[0].d[i];
+    }
+
+    int initialize() override {
+
+        return 0;
+    }
+
+    virtual void terminate() override {
+    }
+
+    virtual size_t getWorkspaceSize(int maxBatchSize) const override {
+        return 0;
+    }
+
+    virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override {
+
+        activationLOGISTICForward((dnnType*)reinterpret_cast<const dnnType*>(inputs[0]),
+                                  reinterpret_cast<dnnType*>(outputs[0]), batchSize*size, stream);
+        return 0;
+    }
+
+
+    virtual size_t getSerializationSize() override {
+        return 1*sizeof(int);
+    }
+
+    virtual void serialize(void* buffer) override {
+        char *buf = reinterpret_cast<char*>(buffer);
+        tk::dnn::writeBUF(buf, size);
+    }
+
+    int size;
+};

include/tkDNN/pluginsRT/ActivationMishRT.h

@@ -52,8 +52,9 @@ public:
 	}
 
 	virtual void serialize(void* buffer) override {
-		char *buf = reinterpret_cast<char*>(buffer);
+		char *buf = reinterpret_cast<char*>(buffer),*a=buf;
 		tk::dnn::writeBUF(buf, size);
+		assert(buf == a + getSerializationSize());
 	}
 
 	int size;

include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h

@@ -51,9 +51,10 @@ public:
 	}
 
 	virtual void serialize(void* buffer) override {
-		char *buf = reinterpret_cast<char*>(buffer);
+		char *buf = reinterpret_cast<char*>(buffer),*a=buf;
 		tk::dnn::writeBUF(buf, ceiling);
 		tk::dnn::writeBUF(buf, size);
+		assert(buf = a + getSerializationSize());
 		
 	}
 

include/tkDNN/pluginsRT/ActivationSigmoidRT.h

@@ -52,8 +52,9 @@ public:
 	}
 
 	virtual void serialize(void* buffer) override {
-		char *buf = reinterpret_cast<char*>(buffer);
+		char *buf = reinterpret_cast<char*>(buffer),*a=buf;
 		tk::dnn::writeBUF(buf, size);
+		assert(buf == a + getSerializationSize());
 	}
 
 	int size;

include/tkDNN/pluginsRT/DeformableConvRT.h

@@ -116,7 +116,7 @@ public:
 	}
 
 	virtual void serialize(void* buffer) override {
-		char *buf = reinterpret_cast<char*>(buffer);
+		char *buf = reinterpret_cast<char*>(buffer),*a=buf;
 		tk::dnn::writeBUF(buf, chunk_dim);
 		tk::dnn::writeBUF(buf, kh);
 		tk::dnn::writeBUF(buf, kw);
@@ -163,6 +163,7 @@ public:
         for(int i=0; i<dim_ones; i++)
     		tk::dnn::writeBUF(buf, aus[i]);
 		free(aus);
+		assert(buf == a + getSerializationSize());
 	}
 
 	cublasStatus_t stat; 

include/tkDNN/pluginsRT/FlattenConcatRT.h

@@ -65,12 +65,13 @@ public:
 	}
 
 	virtual void serialize(void* buffer) override {
-		char *buf = reinterpret_cast<char*>(buffer);
+		char *buf = reinterpret_cast<char*>(buffer),*a = buf;
 		tk::dnn::writeBUF(buf, c);
 		tk::dnn::writeBUF(buf, h);
 		tk::dnn::writeBUF(buf, w);
 		tk::dnn::writeBUF(buf, rows);
 		tk::dnn::writeBUF(buf, cols);
+		assert(buf == a + getSerializationSize());
 	}
 
 	int c, h, w;

include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h

@@ -55,7 +55,7 @@ public:
 	}
 
 	virtual void serialize(void* buffer) override {
-		char *buf = reinterpret_cast<char*>(buffer);
+		char *buf = reinterpret_cast<char*>(buffer),*a=buf;
 
 		tk::dnn::writeBUF(buf, this->c);
 		tk::dnn::writeBUF(buf, this->h);
@@ -65,6 +65,7 @@ public:
 		tk::dnn::writeBUF(buf, this->stride_W);
 		tk::dnn::writeBUF(buf, this->winSize);
 		tk::dnn::writeBUF(buf, this->padding);
+		assert(buf == a + getSerializationSize());
 	}
 
 	int n, c, h, w;

include/tkDNN/pluginsRT/RegionRT.h

@@ -73,13 +73,14 @@ public:
 	}
 
 	virtual void serialize(void* buffer) override {
-		char *buf = reinterpret_cast<char*>(buffer);
+		char *buf = reinterpret_cast<char*>(buffer),*a=buf;
 		tk::dnn::writeBUF(buf, classes);
 		tk::dnn::writeBUF(buf, coords);
 		tk::dnn::writeBUF(buf, num);
 		tk::dnn::writeBUF(buf, c);
 		tk::dnn::writeBUF(buf, h);
 		tk::dnn::writeBUF(buf, w);
+		assert(buf == a + getSerializationSize());
 	}
 
 	int c, h, w;

include/tkDNN/pluginsRT/ReorgRT.h

@@ -52,11 +52,12 @@ public:
 	}
 
 	virtual void serialize(void* buffer) override {
-		char *buf = reinterpret_cast<char*>(buffer);
+		char *buf = reinterpret_cast<char*>(buffer),*a=buf;
 		tk::dnn::writeBUF(buf, stride);
 		tk::dnn::writeBUF(buf, c);
 		tk::dnn::writeBUF(buf, h);
 		tk::dnn::writeBUF(buf, w);
+		assert(buf == a + getSerializationSize());
 	}
 
 	int c, h, w, stride;

include/tkDNN/pluginsRT/ReshapeRT.h

@@ -50,11 +50,12 @@ public:
 	}
 
 	virtual void serialize(void* buffer) override {
-		char *buf = reinterpret_cast<char*>(buffer);
+		char *buf = reinterpret_cast<char*>(buffer),*a = buf;
 		tk::dnn::writeBUF(buf, n);
 		tk::dnn::writeBUF(buf, c);
 		tk::dnn::writeBUF(buf, h);
 		tk::dnn::writeBUF(buf, w);
+		assert(buf == a + getSerializationSize());
 	}
 
 	int n, c, h, w;

include/tkDNN/pluginsRT/ResizeLayerRT.h

@@ -52,7 +52,7 @@ public:
 	}
 
 	virtual void serialize(void* buffer) override {
-		char *buf = reinterpret_cast<char*>(buffer);
+		char *buf = reinterpret_cast<char*>(buffer),*a=buf;
 
 		tk::dnn::writeBUF(buf, o_c);
 		tk::dnn::writeBUF(buf, o_h);
@@ -61,6 +61,7 @@ public:
 		tk::dnn::writeBUF(buf, i_c);
 		tk::dnn::writeBUF(buf, i_h);
 		tk::dnn::writeBUF(buf, i_w);
+		assert(buf == a + getSerializationSize());
 	}
 
 	int i_c, i_h, i_w, o_c, o_h, o_w;

include/tkDNN/pluginsRT/RouteRT.h

@@ -75,7 +75,7 @@ public:
 	}
 
 	virtual void serialize(void* buffer) override {
-		char *buf = reinterpret_cast<char*>(buffer);
+		char *buf = reinterpret_cast<char*>(buffer),*a=buf;
 		tk::dnn::writeBUF(buf, groups);
 		tk::dnn::writeBUF(buf, group_id);
 		tk::dnn::writeBUF(buf, in);
@@ -85,6 +85,7 @@ public:
 		tk::dnn::writeBUF(buf, c);
 		tk::dnn::writeBUF(buf, h);
 		tk::dnn::writeBUF(buf, w);
+		assert(buf == a + getSerializationSize());
 	}
 
 	static const int MAX_INPUTS = 4;

include/tkDNN/pluginsRT/ShortcutRT.h

@@ -59,13 +59,14 @@ public:
 	}
 
 	virtual void serialize(void* buffer) override {
-		char *buf = reinterpret_cast<char*>(buffer);
+		char *buf = reinterpret_cast<char*>(buffer),*a=buf;
 		tk::dnn::writeBUF(buf, bc);
 		tk::dnn::writeBUF(buf, bh);
 		tk::dnn::writeBUF(buf, bw);
 		tk::dnn::writeBUF(buf, c);
 		tk::dnn::writeBUF(buf, h);
 		tk::dnn::writeBUF(buf, w);
+		assert(buf == a + getSerializationSize());
 		
 	}
 

include/tkDNN/pluginsRT/UpsampleRT.h

@@ -54,11 +54,12 @@ public:
 	}
 
 	virtual void serialize(void* buffer) override {
-		char *buf = reinterpret_cast<char*>(buffer);
+		char *buf = reinterpret_cast<char*>(buffer),*a=buf;
 		tk::dnn::writeBUF(buf, stride);
 		tk::dnn::writeBUF(buf, c);
 		tk::dnn::writeBUF(buf, h);
 		tk::dnn::writeBUF(buf, w);
+		assert(buf == a + getSerializationSize());
 	}
 
 	int c, h, w, stride;

include/tkDNN/pluginsRT/YoloRT.h

@@ -64,20 +64,23 @@ public:
 
 		checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream));
 
-		for (int b = 0; b < batchSize; ++b){
-			for(int n = 0; n < n_masks; ++n){
-				int index = entry_index(b, n*w*h, 0);
-				if (new_coords == 1)
-					activationLOGISTICForward(srcData + index, dstData + index, 4*w*h, stream); //x,y,w,h
-				else
-					activationLOGISTICForward(srcData + index, dstData + index, 2*w*h, stream); //x,y
 
-				if (this->scaleXY != 1) scalAdd(dstData + index, 2 * w*h, this->scaleXY, -0.5*(this->scaleXY - 1), 1);
-				
-				index = entry_index(b, n*w*h, 4);
-				activationLOGISTICForward(srcData + index, dstData + index, (1+classes)*w*h, stream);
-			}
-		}
+        for (int b = 0; b < batchSize; ++b){
+            for(int n = 0; n < n_masks; ++n){
+                int index = entry_index(b, n*w*h, 0);
+                if (new_coords == 1){
+                    if (this->scaleXY != 1) scalAdd(dstData + index, 2 * w*h, this->scaleXY, -0.5*(this->scaleXY - 1), 1);
+                }
+                else{
+                    activationLOGISTICForward(srcData + index, dstData + index, 2*w*h, stream); //x,y
+
+                    if (this->scaleXY != 1) scalAdd(dstData + index, 2 * w*h, this->scaleXY, -0.5*(this->scaleXY - 1), 1);
+
+                    index = entry_index(b, n*w*h, 4);
+                    activationLOGISTICForward(srcData + index, dstData + index, (1+classes)*w*h, stream);
+                }
+            }
+        }
 
 		//std::cout<<"YOLO END\n";
 		return 0;
@@ -89,21 +92,25 @@ public:
 	}
 
 	virtual void serialize(void* buffer) override {
-		char *buf = reinterpret_cast<char*>(buffer);
-		tk::dnn::writeBUF(buf, classes);
-		tk::dnn::writeBUF(buf, num);
-		tk::dnn::writeBUF(buf, n_masks);
-		tk::dnn::writeBUF(buf, scaleXY);
-		tk::dnn::writeBUF(buf, nms_thresh);
-		tk::dnn::writeBUF(buf, nms_kind);
-		tk::dnn::writeBUF(buf, new_coords);
-		tk::dnn::writeBUF(buf, c);
-		tk::dnn::writeBUF(buf, h);
-		tk::dnn::writeBUF(buf, w);
-        for(int i=0; i<n_masks; i++)
-    		tk::dnn::writeBUF(buf, mask[i]);
-        for(int i=0; i<n_masks*2*num; i++)
-    		tk::dnn::writeBUF(buf, bias[i]);
+		char *buf = reinterpret_cast<char*>(buffer),*a=buf;
+		tk::dnn::writeBUF(buf, classes); std::cout << "Classes :" << classes << std::endl;
+		tk::dnn::writeBUF(buf, num); std::cout << "Num : " << num << std::endl;
+		tk::dnn::writeBUF(buf, n_masks); std::cout << "N_Masks" << n_masks << std::endl;
+		tk::dnn::writeBUF(buf, scaleXY); std::cout << "ScaleXY :" << scaleXY << std::endl;
+		tk::dnn::writeBUF(buf, nms_thresh); std::cout << "nms_thresh :" << nms_thresh << std::endl;
+		tk::dnn::writeBUF(buf, nms_kind); std::cout << "nms_kind : " << nms_kind << std::endl;
+		tk::dnn::writeBUF(buf, new_coords); std::cout << "new_coords : " << new_coords << std::endl;
+		tk::dnn::writeBUF(buf, c); std::cout << "C : " << c << std::endl;
+		tk::dnn::writeBUF(buf, h); std::cout << "H : " << h << std::endl;
+		tk::dnn::writeBUF(buf, w); std::cout << "C : " << c << std::endl;
+		for (int i = 0; i < n_masks; i++)
+		{
+			tk::dnn::writeBUF(buf, mask[i]); std::cout << "mask[i] : " << mask[i] << std::endl;
+		}
+		for (int i = 0; i < n_masks * 2 * num; i++)
+		{
+			tk::dnn::writeBUF(buf, bias[i]); std::cout << "bias[i] : " << bias[i] << std::endl;
+		}
 
 		// save classes names
 		for(int i=0; i<classes; i++) {
@@ -113,6 +120,7 @@ public:
 				tk::dnn::writeBUF(buf, tmp[j]);
 			}
 		}
+		assert(buf == a + getSerializationSize());
 	}
 
 	int c, h, w;

include/tkDNN/test.h

@@ -29,7 +29,8 @@ int testInference(std::vector<std::string> input_bins, std::vector<std::string>
     readBinaryFile(input_bins[0], net->input_dim.tot(), &input_h, &data);
 
     // outputs
-    dnnType *cudnn_out[outputs.size()], *rt_out[outputs.size()]; 
+    //dnnType *cudnn_out[outputs.size()], *rt_out[outputs.size()];
+    std::vector<dnnType *> cudnn_out,rt_out;
 
     tk::dnn::dataDim_t dim1 =  net->input_dim; //input dim
     printCenteredTitle(" CUDNN inference ", '=', 30); {
@@ -39,7 +40,7 @@ int testInference(std::vector<std::string> input_bins, std::vector<std::string>
         TKDNN_TSTOP
         dim1.print();   
     }
-    for(int i=0; i<outputs.size(); i++) cudnn_out[i] = outputs[i]->dstData;
+    for(int i=0; i<outputs.size(); i++) cudnn_out.push_back(outputs[i]->dstData);
 
     if(netRT != nullptr) {
         tk::dnn::dataDim_t dim2 = net->input_dim;
@@ -50,7 +51,7 @@ int testInference(std::vector<std::string> input_bins, std::vector<std::string>
             TKDNN_TSTOP
             dim2.print();
         }
-        for(int i=0; i<outputs.size(); i++) rt_out[i] = (dnnType*)netRT->buffersRT[i+1];
+        for(int i=0; i<outputs.size(); i++) rt_out.push_back((dnnType*)netRT->buffersRT[i+1]);
     }
 
     int ret_cudnn = 0, ret_tensorrt = 0, ret_cudnn_tensorrt = 0; 

include/tkDNN/utils.h

@@ -12,8 +12,12 @@
 #include <cublas_v2.h>
 #include <cudnn.h>
 
+#ifdef __linux__
 #include <unistd.h>
+#endif
+
 #include <ios>
+#include <chrono>
 
 
 #define dnnType float
@@ -39,6 +43,7 @@
 #define TKDNN_VERBOSE 0
 
 // Simple Timer 
+#ifdef __linux__
 #define TKDNN_TSTART timespec start, end;                               \
                     clock_gettime(CLOCK_MONOTONIC, &start);            
 
@@ -48,6 +53,14 @@
     if(show) std::cout<<col<<"Time:"<<std::setw(16)<<t_ns<<" ms\n"<<COL_END; 
 
 #define TKDNN_TSTOP TKDNN_TSTOP_C(COL_CYANB, TKDNN_VERBOSE)
+#elif _WIN32
+#define TKDNN_TSTART auto start = std::chrono::high_resolution_clock::now();
+#define TKDNN_TSTOP auto stop = std::chrono::high_resolution_clock::now(); \
+std::chrono::duration<double> duration = stop -start;                      \
+auto time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(duration);\
+double t_ns = time_ms.count();
+#endif
+
 
 /********************************************************
  * Prints the error message, and exits