Source files for upstreaming

Author: Ananda Samajdar

clean

@@ -0,0 +1,2 @@
+rm -rf *.csv
+

run_nets.py

@@ -10,7 +10,8 @@ def run_net( ifmap_sram_size=1,
              array_w=32,
              data_flow = 'os',
              topology_file = './topologies/yolo_v2.csv',
-             net_name='yolo_v2'
+             net_name='yolo_v2',
+             offset_list = [0, 10000000, 20000000]
             ):
 
     ifmap_sram_size *= 1024
@@ -29,9 +30,21 @@ def run_net( ifmap_sram_size=1,
     f3name = net_name + "_cycles.csv"
     cycl = open(f3name, 'w')
 
+    f4name = net_name + "_detail.csv"
+    detail = open(f4name, 'w')
+
     bw.write("IFMAP SRAM Size,\tFilter SRAM Size,\tOFMAP SRAM Size,\tConv Layer Num,\tDRAM IFMAP Read BW,\tDRAM Filter Read BW,\tDRAM OFMAP Write BW,\tSRAM Read BW,\tSRAM OFMAP Write BW, \n")
     maxbw.write("IFMAP SRAM Size,\tFilter SRAM Size,\tOFMAP SRAM Size,\tConv Layer Num,\tMax DRAM IFMAP Read BW,\tMax DRAM Filter Read BW,\tMax DRAM OFMAP Write BW,\tMax SRAM Read BW,\tMax SRAM OFMAP Write BW,\n")
     cycl.write("Layer,\tCycles,\t% Utilization,\n")
+    detailed_log = "Layer," +\
+                 "\tDRAM_IFMAP_start,\tDRAM_IFMAP_stop,\tDRAM_IFMAP_bytes," + \
+                 "\tDRAM_Filter_start,\tDRAM_Filter_stop,\tDRAM_Filter_bytes," + \
+                 "\tDRAM_OFMAP_start,\tDRAM_OFMAP_stop,\tDRAM_OFMAP_bytes," + \
+                 "\tSRAM_read_start,\tSRAM_read_stop,\tSRAM_read_bytes," +\
+                 "\tSRAM_write_start,\tSRAM_write_stop,\tSRAM_write_bytes,\n"
+
+    detail.write(detailed_log)
+
 
     first = True
 
@@ -61,12 +74,16 @@ def run_net( ifmap_sram_size=1,
         num_filters = int(elems[6])
 
         strides = int(elems[7])
-        filter_base = 1000000 * 100
+        
+        ifmap_base  = offset_list[0]
+        filter_base = offset_list[1]
+        ofmap_base  = offset_list[2]
 
         bw_log = str(ifmap_sram_size) +",\t" + str(filter_sram_size) + ",\t" + str(ofmap_sram_size) + ",\t" + name + ",\t"
         max_bw_log = bw_log
+        detailed_log = name + ",\t"
 
-        bw_str, util, clk =  \
+        bw_str, detailed_str, util, clk =  \
             tg.gen_all_traces(  array_h = array_h,
                                 array_w = array_w,
                                 ifmap_h = ifmap_h,
@@ -81,7 +98,9 @@ def run_net( ifmap_sram_size=1,
                                 filter_sram_size = filter_sram_size,
                                 ifmap_sram_size = ifmap_sram_size,
                                 ofmap_sram_size = ofmap_sram_size,
-                                filt_base =  filter_base,
+                                filt_base = filter_base,
+                                ifmap_base = ifmap_base,
+                                ofmap_base = ofmap_base,
                                 sram_read_trace_file= net_name + "_" + name + "_sram_read.csv",
                                 sram_write_trace_file= net_name + "_" + name + "_sram_write.csv",
                                 dram_filter_trace_file=net_name + "_" + name + "_dram_filter_read.csv",
@@ -92,6 +111,9 @@ def run_net( ifmap_sram_size=1,
         bw_log += bw_str
         bw.write(bw_log + "\n")
 
+        detailed_log += detailed_str
+        detail.write(detailed_log + "\n")
+
         max_bw_log += tg.gen_max_bw_numbers(
                                 sram_read_trace_file = net_name + "_" + name + "_sram_read.csv",
                                 sram_write_trace_file= net_name + "_" + name + "_sram_write.csv",

scale.cfg

@@ -1,14 +1,17 @@
 [general]
-run_name = "test_yolo_tiny_24x24"
+run_name = "MLPERF_AlphaGoZero_32x32_os"
 
 [architecture_presets]
-ArrayHeight:    24
-ArrayWidth:     24 
-IfmapSramSz:    256
-FilterSramSz:   256 
-OfmapSramSz:    128 
+ArrayHeight:    32 
+ArrayWidth:     32 
+IfmapSramSz:    512 
+FilterSramSz:   512 
+OfmapSramSz:    256 
+IfmapOffset:    0
+FilterOffset:   10000000
+OfmapOffset:    20000000
 Dataflow:       os
 
 [network_presets]
-TopologyCsvLoc: "./topologies/yolo_tiny.csv"
+TopologyCsvLoc: "./topologies/mlperf/AlphaGoZero.csv"
 

scale.py

@@ -5,10 +5,9 @@
 
 
 class scale:
-    def __init__(self):
-        self.sweep = False 
-        #self.save_space = True
-        self.save_space = False
+    def __init__(self, sweep = False, save = False):
+        self.sweep = sweep 
+        self.save_space = save 
 
     def parse_config(self):
         general = 'general'
@@ -63,20 +62,37 @@ def parse_config(self):
 
         self.dataflow= config.get(arch_sec, 'Dataflow')
 
+        ifmap_offset = config.get(arch_sec, 'IfmapOffset')
+        self.ifmap_offset = int(ifmap_offset.strip())
+
+        filter_offset = config.get(arch_sec, 'FilterOffset')
+        self.filter_offset = int(filter_offset.strip())
+
+        ofmap_offset = config.get(arch_sec, 'OfmapOffset')
+        self.ofmap_offset = int(ofmap_offset.strip())
+
         ## Read network_presets
         ## For now that is just the topology csv filename
         topology_file = config.get(net_sec, 'TopologyCsvLoc')
         self.topology_file = topology_file.split('"')[1]     #Config reads the quotes as well 
 
 
     def run_scale(self):
+        self.parse_config()
 
         if self.sweep == False:
-            self.parse_config()
+            self.run_once()
+        else:
+            self.run_sweep()
+
+
+    def run_once(self):
 
         df_string = "Output Stationary"
         if self.dataflow == 'ws':
             df_string = "Weight Stationary"
+        elif self.dataflow == 'is':
+            df_string = "Input Stationary"
 
         print("====================================================")
         print("******************* SCALE SIM **********************")
@@ -91,6 +107,7 @@ def run_scale(self):
 
         net_name = self.topology_file.split('/')[-1].split('.')[0]
         #print("Net name = " + net_name)
+        offset_list = [self.ifmap_offset, self.filter_offset, self.ofmap_offset]
 
         r.run_net(  ifmap_sram_size  = int(self.isram_min),
                     filter_sram_size = int(self.fsram_min),
@@ -99,7 +116,8 @@ def run_scale(self):
                     array_w = int(self.ar_w_min),
                     net_name = net_name,
                     data_flow = self.dataflow,
-                    topology_file = self.topology_file
+                    topology_file = self.topology_file,
+                    offset_list = offset_list
                 )
         self.cleanup()
         print("************ SCALE SIM Run Complete ****************") 
@@ -144,32 +162,31 @@ def cleanup(self):
 
 
     def run_sweep(self):
-        self.parse_config()
-        self.sweep = True
 
-        data_flow_list = ['os', 'ws']
-        #arr_h_list = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384]
-        #arr_w_list = [16384, 8192, 4096, 2048, 1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1]
-        #ifmap_sram_list = [256, 512, 1024]
-        #filter_sram_list = [256, 512, 1024]
-        #ofmap_sram_list = [128, 256, 512]
+        all_data_flow_list = ['os', 'ws', 'is']
+        all_arr_dim_list = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384]
+        all_sram_sz_list = [256, 512, 1024]
 
+        data_flow_list = all_data_flow_list[1:]
+        arr_h_list = all_arr_dim_list[3:8]
+        arr_w_list = all_arr_dim_list[3:8]
+        #arr_w_list = list(reversed(arr_h_list))
+        
+        net_name = self.topology_file.split('/')[-1].split('.')[0]
         for df in data_flow_list:
             self.dataflow = df
 
-            #for i in range(len(arr_h_list)):
-            #    self.ar_h_min = arr_h_list[i]
-            #    self.ar_w_min = arr_w_list[i]
+            for i in range(len(arr_h_list)):
+                self.ar_h_min = arr_h_list[i]
+                self.ar_w_min = arr_w_list[i]
 
-            net_name = self.topology_file.split('/')[-1].split('.')[0]
-            self.run_name = net_name + "_" + df + "_" + self.ar_h_min + "x" + self.ar_w_min 
+                self.run_name = net_name + "_" + df + "_" + str(self.ar_h_min) + "x" + str(self.ar_w_min)
 
-            self.run_scale()
+                self.run_once()
 
 
 if __name__ == "__main__":
-    s = scale()
+    s = scale(save = False, sweep = False)
     s.run_scale()
-    #s.run_sweep()