Replace the strings with struct for function Append.

Author: junzhezhang

include/singa/core/common.h

@@ -53,6 +53,9 @@ typedef struct _Opencl { } Opencl;
 }  // namespace lang
 
 class Device;
+struct DeviceOptInfoToAppend;
+
+
 /// Block represent a chunk of memory (on device or host).
 class Block {
  public:
@@ -97,6 +100,16 @@ class Block {
   std::atomic<int> ref_count_;
 };
 
+// struct for Append purpose in device class.
+struct DeviceOptInfoToAppend{
+    string operation_type;
+    string block_ptr;
+    int size;
+    long t = (std::chrono::system_clock::now()).time_since_epoch().count();
+
+    DeviceOptInfoToAppend(string opt_type, string ptr,int s):operation_type(opt_type),block_ptr(ptr),size(s){}
+};
+
 typedef struct _Context {
   std::mt19937 random_generator;
 #ifdef USE_CUDA

include/singa/core/device.h

@@ -66,7 +66,6 @@ class Device {
   /// Called by Tensor.
   void FreeBlock(Block* block);
 
-  void AppendInfo(string block_info);
   void* UpdateGpuPtrInfo(const Block* block_ptr);
 
   /// Return the size (bytes) of memory in use
@@ -107,7 +106,7 @@ class Device {
   int id() const { return id_; }
 
   virtual void* UpdateGpuPtr(const Block* block_ptr) = 0;
-
+  virtual void Append(DeviceOptInfoToAppend dev_opt_info) = 0;
  private:
   Device() {};
 
@@ -124,7 +123,7 @@ class Device {
   /// Free device memory.
   virtual void Free(void* ptr) = 0;
   virtual void AppendAfterMalloc(Block* block,void* data_ptr,int size) = 0;
-  virtual void Append(string block_info) = 0;
+  
 
  protected:
   int id_ = 0;
@@ -154,6 +153,7 @@ class CppCPU : public Device {
 
   std::shared_ptr<Device> host() const override { return defaultDevice;}
   void SetRandSeed(unsigned seed) override;
+  void Append(DeviceOptInfoToAppend dev_opt_info) override {}
 
  protected:
   void DoExec(function<void(Context*)>&& fn, int executor) override;
@@ -167,7 +167,7 @@ class CppCPU : public Device {
   /// Free cpu memory.
   void Free(void* ptr) override;
   void AppendAfterMalloc(Block* block,void* data_ptr,int size) override {}
-  void Append(string block_info) override {}
+
   void* UpdateGpuPtr(const Block* block_ptr) override {}
 
 };
@@ -188,6 +188,8 @@ class CudaGPU : public Device {
 
   void SetRandSeed(unsigned seed) override;
   size_t GetAllocatedMem() override;
+  void Append(DeviceOptInfoToAppend dev_opt_info) override {}
+
 
  protected:
   void DoExec(function<void(Context*)>&& fn, int executor) override;
@@ -201,7 +203,6 @@ class CudaGPU : public Device {
   /// Free cpu memory.
   void Free(void* ptr) override;
   void AppendAfterMalloc(Block* block,void* data_ptr,int size) override {}
-  void Append(string block_info) override;
   void* UpdateGpuPtr(const Block* block_ptr) override;
 
  private:
@@ -284,6 +285,8 @@ class SwapGPU : public Device {
 
   void SetRandSeed(unsigned seed) override;
   size_t GetAllocatedMem() override;
+  //Append at every index: free, read, mutable
+  void Append(DeviceOptInfoToAppend dev_opt_info) override;
 
  protected:
   void DoExec(function<void(Context*)>&& fn, int executor) override;
@@ -295,10 +298,7 @@ class SwapGPU : public Device {
   void* Malloc(int size) override;
 
   /// Free cpu memory.
-  void Free(void* ptr) override;
-
-  //Append at every index: free, read, mutable
-  void Append(string block_info) override;
+  void Free(void* ptr) override; 
 
   //append info after Malloc, as Block* is not available till Malloc() done.
   void AppendAfterMalloc(Block* block,void* data_ptr,int size) override; 
@@ -408,7 +408,7 @@ class OpenclDevice : public singa::Device {
   virtual void CopyDataToFrom(Block* dst, Block* src, size_t nBytes,
                       CopyDirection direction, int dst_offset = 0,
                       int src_offset = 0) override;
-
+  void Append(DeviceOptInfoToAppend dev_opt_info) override {}
 protected:
   /// The OpenCL device that this object represents.
   /// Each OpenclDevice contains exactly one cl::Device for the lifetime of the
@@ -439,7 +439,7 @@ class OpenclDevice : public singa::Device {
   /// This has the effect of freeing up device memory.
   void Free(void* ptr) override;
   void AppendAfterMalloc(Block* block,void* data_ptr,int size) override {}
-  void Append(string block_info) override {}
+  
   void* UpdateGpuPtr(const Block* block_ptr) override {}
 
 

src/core/common/common.cc

@@ -30,15 +30,13 @@ void* Block::mutable_data() {
 
     //Append block info: opt_type, ptr, time_stamp
     if (ptr_device_!=nullptr){
-      stringstream strm2;
-      strm2<<this;
-      string temp_str2 = strm2.str();
-      stringstream strm4;
-      auto t2 = (std::chrono::system_clock::now()).time_since_epoch().count();
-      strm4<<t2;
-      string temp_str4 = strm4.str();
-      string temp = "Mutable "+temp_str2+" "+temp_str4;   
-      ptr_device_->AppendInfo(temp);
+      stringstream strm;
+      strm<<this;
+      string temp_str = strm.str();
+      DeviceOptInfoToAppend dev_opt_info("Mutable", temp_str,size());
+      auto t = (std::chrono::system_clock::now()).time_since_epoch().count();
+      dev_opt_info.t = t;
+      ptr_device_->Append(dev_opt_info);
     }
 
     //update ptr after swap in done, if variable is not swapped back yet as expected.
@@ -56,16 +54,13 @@ const void* Block::data() const {
 
     //Append block info: opt_type, ptr, time_stamp
     if (ptr_device_!=nullptr){
-      //Append info.
-      stringstream strm2;
-      strm2<<this;
-      string temp_str2 = strm2.str();
-      stringstream strm4;
-      auto t2 = (std::chrono::system_clock::now()).time_since_epoch().count();
-      strm4<<t2;
-      string temp_str4 = strm4.str();
-      string temp = "Read "+temp_str2+" "+temp_str4;
-      ptr_device_->AppendInfo(temp);
+      stringstream strm;
+      strm<<this;
+      string temp_str = strm.str();
+      DeviceOptInfoToAppend dev_opt_info("Read", temp_str,size());
+      auto t = (std::chrono::system_clock::now()).time_since_epoch().count();
+      dev_opt_info.t = t;
+      ptr_device_->Append(dev_opt_info);
     }
 
     //update ptr after swap in done, if variable is not swapped back yet as expected.

src/core/device/cuda_gpu.cc

@@ -123,10 +123,6 @@ void CudaGPU::Free(void* ptr) {
   }
 }
 
-void CudaGPU::Append(string blockInfo){
-    pool_->Append(blockInfo);
-}
-
 void* CudaGPU::UpdateGpuPtr(const Block* block_){
   return nullptr;
 }

src/core/device/device.cc

@@ -55,23 +55,18 @@ void Device::FreeBlock(Block* block) {
     Free(tempPtr);
 
     //append block info for free operation.
-    stringstream strm1;
-    strm1<<block;
-    string temp_str1 = strm1.str();
-    stringstream strm4;
-    auto t2 = (std::chrono::system_clock::now()).time_since_epoch().count();
-    strm4<<t2;
-    string temp_str4 = strm4.str();
-    string blockInfo ="Free "+temp_str1+" "+temp_str4;
-    Append(blockInfo);
+    stringstream strm;
+    strm<<block;
+    string temp_str = strm.str();
+    DeviceOptInfoToAppend dev_opt_info("Free", temp_str,block->size());
+    auto t = (std::chrono::system_clock::now()).time_since_epoch().count();
+    dev_opt_info.t = t;
+    Append(dev_opt_info);
 
     delete block;
   }
 }
 
-void Device::AppendInfo(string blockInfo){
-  Append(blockInfo);
-}
 
 void* Device::UpdateGpuPtrInfo(const Block* block_){
   return UpdateGpuPtr(block_);

src/core/device/swap_gpu.cc

@@ -904,18 +904,13 @@ void SwapGPU::AppendAfterMalloc(Block* block_ptr,void* data_ptr,int size){
   */
 
   //append info
-  stringstream strm1;
-  strm1<<size;
-  string temp_str1 = strm1.str();
-  stringstream strm3;
-  strm3<<block_ptr;
-  string temp_str3 = strm3.str();
-  stringstream strm4;
-  auto t2 = (std::chrono::system_clock::now()).time_since_epoch().count();
-  strm4<<t2;
-  string temp_str4 = strm4.str();
-  string block_info ="Malloc "+temp_str3+" "+temp_str1+" "+temp_str4;
-  Append(block_info);
+  stringstream strm;
+  strm<<block_ptr;
+  string temp_str = strm.str();
+  DeviceOptInfoToAppend dev_opt_info("Malloc", temp_str,size);
+  auto t = (std::chrono::system_clock::now()).time_since_epoch().count();
+  dev_opt_info.t = t;
+  Append(dev_opt_info);
 
 }
 
@@ -994,49 +989,39 @@ void SwapGPU::DeploySwapExec(int r_global_index){
   }
 }
 
-void SwapGPU::Append(string block_info){
-  /*
-  Append Operation block info after each operation
-  Meantime execute following operations:
-    insert size for non-malloc operations
-    update global memory load
-    control swap flag on and off
-    update table_meta and table_sched
-    deploy swap at every index.
-    test moved from start of malloc/free to end of append, only global_index+1 changed
-    call PoolOpt to Construct Pool
-  */
+void SwapGPU::Append(DeviceOptInfoToAppend dev_opt_info){
 
-  vector<string> v = SplitOptString(block_info, " ");
+  //convert block_ptr from string to Block*
   void* temp_ptr;
-  stringstream convert(v[1]);
+  stringstream convert(dev_opt_info.block_ptr);
   convert>>temp_ptr;
   auto block_ptr = static_cast<Block*>(temp_ptr);
-  
-  // insert size, malloc : flag, block_, size, t; others: insert size t.
-  if (v.size() != 4) {
-    stringstream strm1;
-    strm1<<block_ptr->size();
-    string temp_str1 = strm1.str();
-    block_info = v[0] + ' ' + v[1] + ' ' + temp_str1 + ' ' + v[2];
-  }
 
   // update global load
   if (iteration_length < iteration_length_threshold){
-    if (v[0] == "Malloc"){
+    if (dev_opt_info.operation_type == "Malloc"){
       if (global_load.size()>0){
         global_load.push_back(global_load[global_load.size()-1]+block_ptr->size());
       } else {
         global_load.push_back(block_ptr->size());
       }
-    } else if (v[0] == "Free"){
+    } else if (dev_opt_info.operation_type  == "Free"){
       global_load.push_back(global_load[global_load.size()-1]-block_ptr->size());
     } else {
       global_load.push_back(global_load[global_load.size()-1]);
     }
   }
 
   //append into vec_block
+  stringstream strm1;
+  strm1<<dev_opt_info.size;
+  string temp_str1 = strm1.str();
+  stringstream strm4;
+  strm4<<dev_opt_info.t;
+  string temp_str4 = strm4.str();
+  string block_info = dev_opt_info.operation_type + " " + dev_opt_info.block_ptr + " " +
+  temp_str1 + " " + temp_str4;
+  //cout<<"1 "<<block_info<<endl;
   vec_block.push_back(block_info);
 
   //change swap flag on and off
@@ -1067,6 +1052,8 @@ void SwapGPU::Append(string block_info){
 
 }
 
+
+
 void* SwapGPU::UpdateGpuPtr(const Block* block_ptr){
   /*
   in case that block is not at device memory, swapIn ad hoc.