Fixed quantization bug

llvm/projects/soc_simulator/src/driver_new_config.py

@@ -150,7 +150,7 @@ class Driver:
             self.__tensor_table[layer_name] = layer_operations
             line = table_file.readline().strip()
         table_file.close()
-        print(self.__tensor_table["Conv2"])
+
 
     @staticmethod
     def is_promise(layer_hardware):
@@ -176,6 +176,7 @@ class Driver:
             line = config_file.readline().strip()
             first_line = line
             conf_name = line.split(' ')[0]
+            print("CONF NAME: %s" % conf_name)
             assert(conf_name.startswith("conf"))
             line = config_file.readline().strip()
 
@@ -233,13 +234,13 @@ class Driver:
                                 curr_layer = Driver.PrecisionTypes.FP16
                             elif line.find("fp32") != -1:
                                 curr_layer = Driver.PrecisionTypes.FP32
-                        quant_time, quant_energy = 0, 0 #self.__quantize(curr_layer, prev_layer, \
-                                    #tensor_count, layer_table_data)
-
+                        quant_time, quant_energy = self.__quantize(op_type, precision_type, op_number, curr_layer, prev_layer, \
+                                    tensor_count, layer_table_data)
                         if quant_time != 0:
-                            print("QUANT TIME/ENERGY", quant_time, quant_energy)
+                            assert i == 2
                         conv_time, conv_energy = self.__run_gpu_simulation(curr_layer, layer_name, \
                                     tensor_count, approx_type, op_number) 
+                        print(quant_time, quant_energy, conv_time, conv_energy)
                         layer_results.append((quant_time + conv_time, quant_energy + conv_energy, ' '.join(layer_as_lst[i : i + 3])))
                         prev_layer = curr_layer
                         tensor_count += 1
@@ -248,17 +249,16 @@ class Driver:
                 prev_layer = curr_layer
                 curr_conf_results.append(layer_results)
 
-            #self.__conf_results[conf_name] = (first_line, curr_conf_results)
-            print(curr_conf_results)
             self.__conf_results.append( (first_line, curr_conf_results) )
             line = config_file.readline().strip()
         config_file.close()
 
-    def __quantize(self, curr_layer, prev_layer, h2f_f2h_operation_ind, layer_data):
+
+    def __quantize(self, op_type, precision_type, op_number, curr_layer, prev_layer, h2f_f2h_operation_ind, layer_data):
         if curr_layer == prev_layer or curr_layer == Driver.PrecisionTypes.PROMISE \
                     or prev_layer == Driver.PrecisionTypes.PROMISE:
             return 0.0, 0.0
-       
+        print("IN QUANTIZE") 
         layer_name = layer_data["Name"]
 
         # NOTE: Ignoring logic where curr == promise or prev == promise bc 
@@ -270,12 +270,20 @@ class Driver:
         time_key = None
         energy_key = None
 
+        print(precision_type, op_number)
+        if op_number == "1":
+            lookup_key = "_" #lookup_key = precision_type
+        else:
+            lookup_key = "_" + precision_type + str(op_number) + "_"
+
+        print("QUANT LOOKUP KEY", lookup_key)
         if curr_layer == Driver.PrecisionTypes.FP32:
-            time_key = "h2f_time"
-            energy_key = "h2f_energy"
+            time_key = "h2f%stime" % lookup_key
+            energy_key = "h2f%senergy" % lookup_key
         elif curr_layer == Driver.PrecisionTypes.FP16:
-            time_key = "f2h_time"
-            energy_key = "f2h_energy"
+            time_key = "f2h%stime" % lookup_key
+            energy_key = "f2h%senergy" % lookup_key
+        print(time_key, energy_key)
         time = tensor_op_row[time_key]
         energy = tensor_op_row[energy_key]
         print("Quantization: (%f, %f)" % (time, energy))
@@ -321,7 +329,6 @@ class Driver:
         time_key = None
         energy_key = None
 
-        print(self.__get_str(approx_type))
         if approx_type == Driver.ApproxTypes.PERF or approx_type == Driver.ApproxTypes.SAMP: # fp16_perf2_energy
             approx_type_str = None
             if approx_type == Driver.ApproxTypes.PERF:
@@ -348,7 +355,7 @@ class Driver:
         print(time_key, energy_key)
         conversion_time = tensor_info[time_key]
         conversion_energy = tensor_info[energy_key]
-        print("GPU: (%f, %f)\n" % (conversion_time, conversion_energy))
+        #print("GPU: (%f, %f)\n" % (conversion_time, conversion_energy))
         return conversion_time, conversion_energy
 
 
@@ -402,15 +409,14 @@ class Driver:
                 for tensor_ind, (op_time, op_energy, tensor_op) in enumerate(layer):
                     baseline_time, baseline_energy, baseline_op = baseline_conf[1][layer_ind][tensor_ind]
                     final_tensor_op = tensor_op
-                    ''''
                     if op_time > baseline_time:
+                        print("**************** BIGGER ******************")
                         final_time += baseline_time
                         final_energy += baseline_energy
                         final_tensor_op = baseline_op
                     else:
-                    '''
-                    final_time += op_time
-                    final_energy += op_energy
+                        final_time += op_time
+                        final_energy += op_energy
                     '''
                     # Ignoring bigger energies for now  
                     if op_energy > baseline_energy:
@@ -432,27 +438,18 @@ class Driver:
             if line.startswith("conf"):
                 orig_line_lst = line.split(' ')
                 conf_name = orig_line_lst[0]
-                print("\n")
                 if not baseline_conf:
                     baseline_conf = self.__conf_results[conf_index] #conf_name]
-                    print("BASELINE")
-                    #print(baseline_conf)
-                    print("\n")
                     baseline_total_time, baseline_total_energy = get_baseline_times_energies(baseline_conf)
                     results_file.write("%s %s\n" % (repr(baseline_total_time), repr(baseline_total_energy))) # write baseline time to top of file
                     write_conf_to_file(conf_name, baseline_conf, 1, 1)
-                    print(baseline_total_time, baseline_total_energy)
                 else:
                     curr_conf = self.__conf_results[conf_index] #conf_name]
-                    print("CURRENT")
-                    #print(curr_conf)
-                    print("\n")
                     final_time, final_energy = get_baseline_times_energies(curr_conf)
                     #final_time, final_energy, curr_conf = get_final_times_energies_conf(curr_conf)
                     #assert(final_time <= baseline_total_time)
                     #assert(final_energy <= baseline_total_energy)
                     #write_conf_to_file(conf_name, curr_conf, final_time, final_energy)
-                    print(baseline_total_time, final_time, baseline_total_energy, final_energy)
                     write_conf_to_file(conf_name, curr_conf, baseline_total_time / final_time, baseline_total_energy / final_energy) 
                 conf_index += 1
         results_file.close()