Including utility definitions - tensorUtils

llvm/test/VISC/DNN_Benchmarks/common/include/tensorUtils.h

-#include <tensorTypes.h>
 
 // Header guards
 #ifndef UTILS_HEADER
 #define UTILS_HEADER
 
-void printTensorInfo(void* tensor_ptr);
-void dumpWeightsToFile(char* file_name, void* weights_ptr);
-void fillTensorWithOnes(void* tensor_ptr);
-void fillWithOnesAndTwos(void* tensor_ptr);
-void fillTensorWithNegOnes(void* tensor_ptr);
-void fillTensorVals(void* tensor_ptr);
-void printTensorValues(void* tensor_ptr);
-void printTensorDims(void* tensor_ptr);
-void compareTensors(void* tensor1_ptr, void* tensor2_ptr);
-void compareValues(void* tensor_ptr, float* data, size_t num_elems);
+
+#include <sstream>
+//#include <tensorTypes.h>
+#include <tensor_runtime.h>
+#include <tensor.h>
+//#include "../../../../../projects/hpvm-tensor-rt/tensor_runtime/include/tensor.h"
+//#include "../../../projects/hpvm-tensor-rt/tensor_runtime/include/tensor.h"
+//#include "types.h"
+
+
+void printTensorInfo(void* tensor_ptr){
+
+  struct Tensor* tensor = (struct Tensor*) tensor_ptr;
+
+  if(tensor->gpu_data != NULL){
+    printf("Successful cudaMalloc \n");
+  }
+
+  printf("tensor dims = %d \n", tensor->dims.num_dims);
+  printf("dim1_size = %d \n", tensor->dims.dim_sizes[0]);
+  printf("dim2_size = %d \n", tensor->dims.dim_sizes[1]);
+  printf("num_elems = %d \n", tensor->num_elems);
+}
+
+
+// FIXIT: Move this to debug.h and include in all files
+void dumpWeightsToFile(char* file_name, void* weights_ptr){
+
+  struct Tensor* weights = (Tensor*) weights_ptr;
+
+  // Move data back to host
+  hpvm_request_tensor(weights, 0);
+  
+  FILE* fp = fopen(file_name, "wb");
+  if(fp == NULL){
+    printf("File %s could not be created. Check if directory exists \n", file_name);
+    abort();
+  }
+
+  printf("size_in_bytes = %d \n", weights->size_in_bytes);
+  size_t bytes_written = fwrite(weights->host_data, 1, weights->size_in_bytes, fp);
+  printf("bytes_written = %d \n", bytes_written);
+  fclose(fp);
+}
+
+
+
+void fillTensorWithOnes(void* tensor_ptr){
+
+  struct Tensor* tensor = (struct Tensor*) tensor_ptr;
+    
+  hpvm_request_tensor(tensor, 0);
+  
+  // initialization is specific to the floating point type
+  if(tensor->data_type == CUDNN_DATA_FLOAT){
+    float* data_arr = (float*) tensor->host_data;
+    for(unsigned int i = 0; i < tensor->num_elems; i++){
+      data_arr[i] = 1.0;    
+    }
+  }
+}
+
+
+void fillWithOnesAndTwos(void* tensor_ptr){
+
+  struct Tensor* tensor = (struct Tensor*) tensor_ptr;
+  
+  hpvm_request_tensor(tensor, 0);
+  
+  // initialization is specific to the floating point type
+  if(tensor->data_type == CUDNN_DATA_FLOAT){
+    float* data_arr = (float*) tensor->host_data;
+    for(unsigned int i = 0; i < tensor->num_elems/2; i++){
+      data_arr[i] = 1.0;    
+    }
+
+    for(unsigned int i = tensor->num_elems/2; i < tensor->num_elems; i++){
+      data_arr[i] = 2.0;    
+    }
+ 
+  }
+}
+
+
+void fillTensorWithNegOnes(void* tensor_ptr){
+
+  struct Tensor* tensor = (struct Tensor*) tensor_ptr;
+    
+  hpvm_request_tensor(tensor, 0);
+  
+  // initialization is specific to the floating point type
+  if(tensor->data_type == CUDNN_DATA_FLOAT){
+    float* data_arr = (float*) tensor->host_data;
+    for(unsigned int i = 0; i < tensor->num_elems; i++){
+      data_arr[i] = -1.0;    
+    }
+  }
+}
+
+
+void fillTensorVals(void* tensor_ptr){
+
+  struct Tensor* tensor = (struct Tensor*) tensor_ptr;
+  // initialization is specific to the floating point type
+  if(tensor->data_type == CUDNN_DATA_FLOAT){
+    float* data_arr = (float*) tensor->host_data;
+    for(unsigned int i = 0; i < tensor->num_elems; i++){
+      data_arr[i] = i + 1;    
+    }
+  }
+}
+
+
+void printTensorValues(void* tensor_ptr){
+
+  struct Tensor* tensor = (struct Tensor*) tensor_ptr;
+
+  hpvm_request_tensor(tensor, 0);
+  
+  // printing is specific to the floating point type
+  if(tensor->data_type == CUDNN_DATA_FLOAT){
+    float* data_arr = (float*) tensor->host_data;
+    for(unsigned int i = 0; i < tensor->num_elems; i++){
+      printf("%f,", data_arr[i]);    
+    }
+  }
+
+  printf("\n");
+}
+
+
+void printTensorDims(void* tensor_ptr){
+
+  struct Tensor* tensor = (struct Tensor*) tensor_ptr;
+
+  printf("Num_elems = %d \n", tensor->num_elems);
+  for (int i = 0; i < tensor->dims.num_dims; i++){
+    printf("dim[%d] = %d \n", i, tensor->dims.dim_sizes[i]);
+  }
+}
+
+
+
+void compareTensors(void* tensor1_ptr, void* tensor2_ptr){
+
+  struct Tensor* tensor1 = (struct Tensor*) tensor1_ptr;
+  struct Tensor* tensor2 = (struct Tensor*) tensor2_ptr;
+
+  hpvm_request_tensor(tensor1, 0);
+  hpvm_request_tensor(tensor2, 0);
+
+  float* tensor_data1 = (float*) tensor1->host_data;
+  float* tensor_data2 = (float*) tensor2->host_data;
+  
+  for(unsigned int i = 0; i < tensor1->num_elems; i++){
+    if(tensor_data1[i] != tensor_data2[i]){
+      printf("Tensor data mismatch at index %d \n", i);
+      abort();
+    }
+  }
+}
+
+
+
+void compareValues(void* tensor_ptr, float* data, size_t num_elems){
+
+  struct Tensor* tensor = (struct Tensor*) tensor_ptr;
+    
+  hpvm_request_tensor(tensor, 0);
+  
+  float* tensor_data = (float*) tensor->host_data;
+  for(unsigned int i = 0; i < num_elems; i++){
+    if(tensor_data[i] != data[i]){
+      printf("Tensor data mismatch");
+      abort();
+    }
+  }
+}
+
+
 void* readInputTensor(char* file_name, int data_type, int dim1_size, int dim2_size,
-		      int dim3_size, int dim4_size);
+		      int dim3_size, int dim4_size){
+
+  int type_size = 4; // NOTE: Assuming floating point tensors
+  int num_elems = dim1_size * dim2_size * dim3_size * dim4_size;
+  int size_in_bytes = type_size * dim1_size * dim2_size * dim3_size * dim4_size;
+  uint8_t* file_data = (uint8_t*) malloc(sizeof(char) * num_elems);
+  float* tensor_data = (float*) malloc(sizeof(float) * num_elems);
+  int file_header_size = 16;
+  
+  FILE* file = fopen(file_name, "rb");
+  if(file == NULL){
+    printf("Data file %s is not found. Aborting... \n", file_name);
+    abort();
+  }
+
+ 
+  fseek(file, file_header_size, SEEK_CUR); // Skipping the file header
+  size_t bytes_read = fread(file_data, 1, sizeof(uint8_t) * num_elems, file);
+  
+  for (size_t i = 0; i < num_elems; ++i){
+    tensor_data[i] = (float) file_data[i] / 255.0f;
+  }
+
+  printf("tensor_data[%d] = %f \n", 10, tensor_data[10]);
+
+  // NOTE: Using NCHW format
+  struct Tensor* input = (struct Tensor*) create4DTensor(data_type, nchw, dim1_size, dim2_size,
+					dim3_size, dim4_size);
+  
+  initTensorData(input, tensor_data, size_in_bytes);
+  compareValues(input, tensor_data, num_elems);
+  
+  return input;  
+}
+
+
+
 struct Tensor* readTrainedWeights(char* file_name, int data_type, int dim1_size, int dim2_size,
-				  int dim3_size, int dim4_size);
-uint8_t* readLabels(char* labels_file, int num_labels);
-void computeAccuracy(char* labels_file, int num_labels, void* result_ptr);
+				  int dim3_size, int dim4_size){
+
+  // FIXIT: Don't assume floating point types
+  int type_size = 4; // NOTE: Assuming floating point tensors
+  int num_elems = dim1_size * dim2_size * dim3_size * dim4_size;
+  int size_in_bytes = type_size * dim1_size * dim2_size * dim3_size * dim4_size;
+  float* tensor_data = (float*) malloc(sizeof(float) * num_elems);
+  int file_header_size = 0;
+  
+  FILE* file = fopen(file_name, "rb");
+  if(file == NULL){
+    printf("Data file %s is not found. Aborting... \n", file_name);
+    abort();
+  }
+    
+  fseek(file, file_header_size, SEEK_CUR); // Skipping the file header
+  size_t bytes_read = fread(tensor_data, 1, size_in_bytes, file);
+
+  //printf("tensor_data[%d] = %f \n", num_elems-1, tensor_data[num_elems-1]);
+  
+  struct Tensor* weights = (struct Tensor*) create4DTensor(data_type, nchw, dim1_size, dim2_size,
+					  dim3_size, dim4_size);
+  
+  initTensorData(weights, tensor_data, size_in_bytes);
+  compareValues(weights, tensor_data, num_elems);
+
+  return weights;
+}
+
+
+uint8_t* readLabels(char* labels_file, int num_labels){
+
+  int file_header_size = 8;
+  uint8_t* labels = (uint8_t*) malloc(sizeof(uint8_t) * num_labels);
+  FILE* file = fopen(labels_file, "rb");
+  if(file == NULL){
+    printf("Data file %s is not found. Aborting...\n", labels_file);
+    abort();
+  }
+
+  fseek(file, file_header_size, SEEK_CUR); // Skipping the file header
+  size_t bytes_read = fread(labels, 1, sizeof(uint8_t) * num_labels, file);
+  printf("--labels bytes_read = %d \n", bytes_read);
+  return labels;
+}
+
+
+
+void computeAccuracy(char* labels_file, int num_labels, void* result_ptr){
+
+  struct Tensor* result = (struct Tensor*) result_ptr;
+  
+  uint8_t* labels = readLabels(labels_file, num_labels);
+  size_t batch_dim = result->dims.dim_sizes[0];
+  size_t channels = result->dims.dim_sizes[1];
+  float* data = (float*) result->host_data;
+  int num_errors = 0;
+  
+  for(int i = 0; i < batch_dim; i++){
+    int chosen = 0;
+    for (int id = 1; id < 10; ++id){
+      if (data[i * channels + chosen] < data[i * channels + id]) chosen = id;
+    }
+    
+    //printf("chosen = %d, label = %d \n", chosen, labels[i]);
+    if(chosen != labels[i])
+      num_errors++;
+  }
+
+  float accuracy = ((batch_dim - num_errors) * 1.0 / batch_dim * 1.0) * 100.0;
+  printf("****** Accuracy = %f \n\n", accuracy);
+
+
+  FILE* fp = fopen("final_accuracy", "w+");
+  if(fp != NULL){
+
+    std::ostringstream ss;
+    ss << std::fixed << accuracy;
+    std::string print_str = ss.str();
+  
+    fwrite(print_str.c_str(), 1, print_str.length(), fp);
+    fclose(fp);
+  }
+  
+}
+
+
+
+
+void computeAccuracy2(uint8_t* labels, int num_labels, void* result_ptr){
+
+  struct Tensor* result = (struct Tensor*) result_ptr;
+  
+  //uint8_t* labels = readLabels(labels_file, num_labels);
+  size_t batch_dim = result->dims.dim_sizes[0];
+  size_t channels = result->dims.dim_sizes[1];
+  float* data = (float*) result->host_data;
+  int num_errors = 0;
+  
+  for(int i = 0; i < batch_dim; i++){
+    int chosen = 0;
+    for (int id = 1; id < 10; ++id){
+      if (data[i * channels + chosen] < data[i * channels + id]) chosen = id;
+    }
+    
+    //printf("chosen = %d, label = %d \n", chosen, labels[i]);
+    if(chosen != labels[i])
+      num_errors++;
+  }
+
+  float accuracy = ((batch_dim - num_errors) * 1.0 / batch_dim * 1.0) * 100.0;
+  printf("****** Accuracy = %f \n\n", accuracy);
+
+
+  FILE* fp = fopen("final_accuracy", "w+");
+  if(fp != NULL){
+
+    std::ostringstream ss;
+    ss << std::fixed << accuracy;
+    std::string print_str = ss.str();
+  
+    fwrite(print_str.c_str(), 1, print_str.length(), fp);
+    fclose(fp);
+  }
+  
+}
+
 
 #endif