luke
/
OpenRAM
mirror of https://github.com/VLSIDA/OpenRAM.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Removed data collection script

This commit is contained in:
Hunter Nichols 2019-02-26 22:46:38 -08:00
parent 42bc6efb21
commit ea51cfdbb4
2 changed files with 0 additions and 824 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
compiler/tests/config_data.py
View File

@ -1,16 +0,0 @@
#Config file used for collecting data.
word_size = 1
num_words = 16
tech_name = "freepdk45"
#Default corner
#process_corners = ["TT"]
supply_voltages = [1.0]
temperatures = [25]
#Corner options
process_corners = ["TT", "FF", "SS"]
#supply_voltages = [.9, 1.0, 1.1]
#temperatures = [10,25,50]

808
compiler/tests/delay_data_collection.py
View File

@ -1,808 +0,0 @@
#!/usr/bin/env python3
"""
Run a regression test on various srams
"""
import csv,sys,os
import pandas as pd
import matplotlib.pyplot as plt
import unittest
from testutils import header,openram_test
sys.path.append(os.path.join(sys.path[0],".."))
import globals
from globals import OPTS
import debug
from sram import sram
from sram_config import sram_config
MODEL_DIR = "model_data/"
DATASET_CSV_NAME = MODEL_DIR+'datasets.csv'
# Data Collection class
# This module can perform two tasks
# 1) Collect data
# 2) Display data
# Data Collection -
# A single SRAM simulation will collect 6 datasets: wordline (WL) delays, sense amp enable (SAE) delays,
# WL slews, SAE slews, WL model delays, SAE model delays.
# Each dataset is stored in a separate csv file. Each row of the CSV refers to a different corner simulated on.
# The files names are stored in DATASET_CSV_NAME marked above.
# There are 2 main ways the collection is targeted: looking at different delay chain sizes and looking at different SRAM configurations.
# These are separated by different functions and should not be collected together.
#
# Data display -
# There are many functions in this file which will search (or told) for data using DATASET_CSV_NAME as a guide.
# Delay chain data is analyzed in analyze_delay_chain_data, graph_delays_and_inp_slews, and graph_inp_slews_and_delay_var
# WL and SAE graphing is done in analyze_sae_data and graph_delays_and_var
#
# Data collection and each analysis can be run independently, but the one you want needs to be commented in/out.
class data_collection(openram_test):
def runTest(self):
#Uncomment this for model evaluation
# ratio_data = self.calculate_delay_ratios_of_srams()
# self.display_data(ratio_data)
self.run_setup()
self.run_delay_chain_analysis()
#self.run_sae_analysis()
globals.end_openram()
def run_setup(self):
"""Checks file existence and sets some member variables"""
if not os.path.isdir(MODEL_DIR):
os.mkdir(MODEL_DIR)
#File requires names from the delay measurement object.
#Initialization is delayed until one configuration simulation has occurred.
self.dataset_initialized=False
#These help mark positions in the csv file for data collection and analysis
self.config_fields = ['word_size', 'num_words', 'words_per_row', 'dc_resized', 'process', 'voltage', 'temp']
self.sae_config_fields = ['dc_start_ind', 'dc_end_ind']
self.other_data_fields = ['sum']
def init_dataset_csv(self, file_fields):
"""Creates csv which holds files names of all available datasets."""
debug.info(2,'Initializing dataset file and dataframe.')
self.dataset_file_fields = file_fields
self.dataset_file_fields.sort()
config_fields = ['word_size', 'num_words', 'words_per_row', 'dc_config']
self.dataset_fields = config_fields+self.dataset_file_fields
if not os.path.exists(DATASET_CSV_NAME):
debug.info(2,'No dataset file found. Creating dataset file.')
dataset_csv = open(DATASET_CSV_NAME, 'w')
csv_writer = csv.writer(dataset_csv, lineterminator = '\n')
csv_writer.writerow(self.dataset_fields)
dataset_csv.close()
self.dataset_initialized=True
self.datasets_df = pd.read_csv(DATASET_CSV_NAME, encoding='utf-8')
def add_dataset(self, word_size, num_words, words_per_row):
"""Added filenames to DATASET_CSV_NAME"""
cur_len = len(self.datasets_df)
#list converted to str as lists as saved as str in the csv file.
#e.g. list=[2,2] -> csv entry = '[2,2]'
fanout_str = str(self.delay_obj.get_num_delay_fanout_list())
file_names = [self.file_name_dict[fname] for fname in self.dataset_file_fields]
new_df_row = [word_size, num_words, words_per_row,fanout_str]+file_names
df_bool = (self.datasets_df['word_size'] == word_size) & (self.datasets_df['num_words'] == num_words) & (self.datasets_df['words_per_row'] == words_per_row) & (self.datasets_df['dc_config'] == fanout_str)
if len(self.datasets_df.loc[df_bool]) == 0:
self.datasets_df = self.datasets_df.append(pd.Series(new_df_row, self.dataset_fields), ignore_index=True)
else:
self.datasets_df.loc[df_bool] = [new_df_row]
def get_filename_by_config(self, data_types, word_size, num_words, words_per_row, fanout_list):
"""Searches the dataset csv for a config match. Extracts the filenames for the desired data."""
start_fname_ind = 4 # four query items
fanout_str = str(fanout_list)
datasets_df = pd.read_csv(DATASET_CSV_NAME, encoding='utf-8')
df_bool = (datasets_df['word_size'] == word_size) & (datasets_df['num_words'] == num_words) & (datasets_df['words_per_row'] == words_per_row) & (datasets_df['dc_config'] == fanout_str)
df_filtered = datasets_df.loc[df_bool]
if len(df_filtered) > 1:
debug.info(1,"Found more than 1 dataset entry with the same configuration. Using the first found")
elif len(df_filtered) == 0:
debug.error("Dataset for configuration not found:\n \
word_size={}, num_words={}, words_per_row={}, fanout_list={}".format(word_size,
num_words,
words_per_row,
fanout_list), 1)
df_row = df_filtered.iloc[0]
#Check csv header against expected
csv_data_types = list(df_filtered)[start_fname_ind:]
if not set(data_types).issubset(set(csv_data_types)):
debug.error("Dataset csv header does not match expected:\nExpected={}\nCSV={}".format(data_types,
csv_data_types),1)
return [df_row[dt] for dt in data_types]
def get_all_filenames(self, data_types):
"""Gets all files from dataset.csv specified by the datatype (model/measure)"""
start_fname_ind = 4 # four query items
datasets_df = pd.read_csv(DATASET_CSV_NAME, encoding='utf-8')
csv_data_types = list(datasets_df)[start_fname_ind:]
if not set(data_types).issubset(set(csv_data_types)):
debug.error("Dataset csv header does not match expected:\nExpected={}\nCSV={}".format(data_types,
csv_data_types),1)
return [list(datasets_df[dt]) for dt in data_types]
def run_sae_analysis(self):
"""Generates sram with different delay chain configs over different corners and
analyzes delay average and variation."""
#config_tuple_list = [(8, 16, 1),(8, 32, 1),(16, 32, 1), (32, 64, 1), (64, 32, 1), (64, 64, 1), (32, 128, 1)]
#config_tuple_list = [(1, 16, 1),(4, 16, 1),(16, 16, 1), (32, 32, 1)]
config_tuple_list = [(1, 16, 1),(4, 16, 1)]
self.save_sram_data_using_configs(config_tuple_list)
self.analyze_sae_data() #Uses all available data
#self.graph_delays_and_var('sae_measures')
#self.graph_delays_and_var('wl_measures')
#self.compare_wl_sae_data()
def save_sram_data_using_configs(self, config_list):
"""Get SRAM data for different configurations"""
for config in config_list:
word_size, num_words, words_per_row = config
self.init_data_gen()
self.save_data_sram_corners(word_size, num_words, words_per_row)
def analyze_sae_data(self):
"""Compare and graph delay chain variations over different configurations."""
delay_avgs_ratio = []
delay_vars_ratio = []
sram_configs = []
data_types = ["sae_measures"]
sae_filenames = self.get_all_filenames(data_types)[0]
sae_dataframes = self.get_csv_data(sae_filenames)
for df in sae_dataframes:
#Each row in df contains sram config. Only use the first one (they should all be the same)
config = df[['word_size', 'num_words', 'words_per_row']].values.tolist()[0]
sram_configs.append(config)
delay_sums = self.get_sum(df)
delay_chain_sums = self.get_delay_chain_sums(df)
delay_avgs_ratio.append(self.get_average(delay_chain_sums)/self.get_average(delay_sums))
delay_vars_ratio.append(self.get_variance(delay_chain_sums)/self.get_variance(delay_sums))
debug.info(1,"DC config={}: avg ratio={} var ratio={}".format(sram_configs[-1],
delay_avgs_ratio[-1],
delay_vars_ratio[-1]))
#Sort by the delays then graph
all_data = zip(delay_avgs_ratio,sram_configs,delay_vars_ratio)
delay_avgs_ratio,sram_configs,delay_vars_ratio = zip(*sorted(all_data))
x_ax_label = '[word_size, num_words, words_per_row]'
y_ax_labels = ['DC/SAE Delay Ratio', 'DC/SAE Var. Ratio']
self.plot_delay_variance_data_sets(sram_configs, x_ax_label, y_ax_labels, delay_avgs_ratio, delay_vars_ratio)
def compare_wl_sae_data(self):
"""Compare and graph delay chain variations over different configurations."""
delay_avgs_ratio = []
delay_vars_ratio = []
sram_configs = []
data_types = ["wl_measures","sae_measures"]
data_filenames = self.get_all_filenames(data_types)
wl_filenames = data_filenames[0]
wl_dataframes = self.get_csv_data(wl_filenames)
sae_filenames = data_filenames[1]
sae_dataframes = self.get_csv_data(sae_filenames)
#Loop through all configurations found
for wl_df,sae_df in zip(wl_dataframes,sae_dataframes):
#Each row in df contains sram config. Only use the first one (they should all be the same)
config = wl_df[['word_size', 'num_words', 'words_per_row']].values.tolist()[0]
sram_configs.append(config)
wl_delays = self.get_sum(wl_df)
sae_delays = self.get_sum(sae_df)
delay_avgs_ratio.append(self.get_average(wl_delays)/self.get_average(sae_delays))
delay_vars_ratio.append(self.get_variance(wl_delays)/self.get_variance(sae_delays))
debug.info(1,"DC config={}: avg ratio={} var ratio={}".format(sram_configs[-1],
delay_avgs_ratio[-1],
delay_vars_ratio[-1]))
#Sort by the delays then graph
all_data = zip(delay_avgs_ratio,sram_configs,delay_vars_ratio)
delay_avgs_ratio,sram_configs,delay_vars_ratio = zip(*sorted(all_data))
x_ax_label = 'SRAM Config'
y_ax_labels = ['WL/SAE Delay Ratio', 'WL/SAE Var. Ratio']
self.plot_delay_variance_data_sets(sram_configs, x_ax_label, y_ax_labels, delay_avgs_ratio, delay_vars_ratio)
def graph_delays_and_var(self, data_type):
delay_avgs = []
delay_vars = []
sram_configs = []
data_filenames = self.get_all_filenames([data_type])[0]
dataframes = self.get_csv_data(data_filenames)
#Loop through all configurations found
for df in dataframes:
#Each row in df contains sram config. Only use the first one (they should all be the same)
config = df[['word_size', 'num_words', 'words_per_row']].values.tolist()[0]
sram_configs.append(config)
delays = self.get_sum(df)
delay_avgs.append(self.get_average(delays))
delay_vars.append(self.get_variance(delays))
debug.info(1,"DC config={}: avg={}, var={}".format(sram_configs[-1],
delay_avgs[-1],
delay_vars[-1]))
#Sort by the delays then graph
all_data = zip(delay_avgs,sram_configs,delay_vars)
delay_avgs,sram_configs,delay_vars = zip(*sorted(all_data))
x_ax_label = 'SRAM Config'
y_ax_labels = ['Avg. Delay', 'Delay Variance']
self.plot_delay_variance_data_sets(sram_configs, x_ax_label, y_ax_labels, delay_avgs, delay_vars)
def run_delay_chain_analysis(self):
"""Generates sram with different delay chain configs over different corners and
analyzes delay average and variation."""
OPTS.use_tech_delay_chain_size = True
#Constant sram config for this test
word_size, num_words, words_per_row = 1, 16, 1
#Only change delay chain
#dc_config_list = [(2,3), (3,3), (3,4), (4,2), (4,3), (4,4), (2,4), (2,5)]
#dc_config_list = [(2,3), (3,3)]
#fanout_configs = [[3,3], [3,3,3]]
old_fanout_configs = []
fanout_configs = [[3,3], [2,3,2,3], [2,4,2,4], [2,2,2,2], [3,3,3,3], [4,4],[4,4,4,4], [5,5], \
[2,2], [2,5,2,5], [2,6,2,6], [2,8,2,8], [3,5,3,5], [4,5,4,5], [2,2,2,2,2,2], [3,3,3,3,3,3],\
[6,6],[7,7],[8,8],[9,9],[10,10],[11,11],
[5,2,5,2], [6,2,6,2], [8,2,8,2], [5,3,5,3], [5,4,5,4], [2,3,4,5], [7,2,7,2]]
analysis_configs = fanout_configs+old_fanout_configs
#self.save_delay_chain_data(word_size, num_words, words_per_row, fanout_configs)
#self.analyze_delay_chain_data(word_size, num_words, words_per_row, analysis_configs)
#self.graph_delays_and_inp_slews(word_size, num_words, words_per_row, analysis_configs)
self.graph_inp_slews_and_delay_var(word_size, num_words, words_per_row, analysis_configs)
def save_delay_chain_data(self, word_size, num_words, words_per_row, fanout_configs):
"""Get the delay data by only varying the delay chain size."""
for fanouts in fanout_configs:
self.init_data_gen()
self.set_delay_chain(fanouts)
self.save_data_sram_corners(word_size, num_words, words_per_row)
def analyze_delay_chain_data(self, word_size, num_words, words_per_row, fanout_configs):
"""Compare and graph delay chain variations over different configurations."""
if not os.path.exists(DATASET_CSV_NAME):
debug.error("Could not find dataset CSV. Aborting analysis...",1)
dc_avgs, dc_vars = [],[]
rise_avgs, rise_vars = [],[]
fall_avgs, fall_vars = [],[]
for fanouts in fanout_configs:
data_types = ["wl_measures","sae_measures"]
filenames = self.get_filename_by_config(data_types, word_size, num_words, words_per_row, fanouts)
wl_dataframe, sae_dataframe = self.get_csv_data(filenames)
rise_delay, fall_delay = self.get_rise_fall_dc_sum(sae_dataframe)
delay_sums = self.get_delay_chain_sums(sae_dataframe)
dc_avgs.append(self.get_average(delay_sums))
dc_vars.append(self.get_variance(delay_sums))
rise_avgs.append(self.get_average(rise_delay))
rise_vars.append(self.get_variance(rise_delay))
fall_avgs.append(self.get_average(fall_delay))
fall_vars.append(self.get_variance(fall_delay))
debug.info(1,"DC config={}: avg={} variance={}".format(fanouts, dc_avgs[-1], dc_vars[-1]))
#Sort by the delays then graph
config_copy = list(fanout_configs)
all_data = zip(dc_avgs,config_copy,dc_vars)
dc_avgs,config_copy,dc_vars = zip(*sorted(all_data))
x_ax_label = 'DC Fanouts'
y_ax_labels = ['Average Delay (ns)', 'Delay Variance (ns)']
self.plot_delay_variance_data_sets(config_copy, x_ax_label, y_ax_labels, dc_avgs, dc_vars)
config_copy = list(fanout_configs)
all_data = zip(rise_avgs,config_copy,rise_vars)
rise_avgs,config_copy,rise_vars = zip(*sorted(all_data))
x_ax_label = 'DC Fanouts'
y_ax_labels = ['Average Rise Delay (ns)', 'Rise Delay Variance (ns)']
self.plot_delay_variance_data_sets(config_copy, x_ax_label, y_ax_labels, rise_avgs, rise_vars)
config_copy = list(fanout_configs)
all_data = zip(fall_avgs,config_copy,fall_vars)
fall_avgs,config_copy,fall_vars = zip(*sorted(all_data))
x_ax_label = 'DC Fanouts'
y_ax_labels = ['Average Fall Delay (ns)', 'Fall Delay Variance (ns)']
self.plot_delay_variance_data_sets(config_copy, x_ax_label, y_ax_labels, fall_avgs, fall_vars)
def graph_inp_slews_and_delay_var(self, word_size, num_words, words_per_row, fanout_configs):
"""Compare and graph delay chain variations over different configurations."""
if not os.path.exists(DATASET_CSV_NAME):
debug.error("Could not find dataset CSV. Aborting analysis...",1)
dc_delays_var, dc_slews = [],[]
rise_delay_var, rise_slew_avgs = [],[]
fall_delay_var, fall_slew_avgs = [],[]
for fanouts in fanout_configs:
data_types = ["sae_measures", "sae_slews"]
filenames = self.get_filename_by_config(data_types, word_size, num_words, words_per_row, fanouts)
sae_delay_df, sae_slew_df = self.get_csv_data(filenames)
delay_sums = self.get_delay_chain_sums(sae_delay_df)
slew_sums = self.get_delay_chain_avg(sae_slew_df)
dc_delays_var.append(self.get_variance(delay_sums))
dc_slews.append(self.get_average(slew_sums))
rise_delay, fall_delay = self.get_rise_fall_dc_sum(sae_delay_df)
rise_delay_var.append(self.get_variance(rise_delay))
fall_delay_var.append(self.get_variance(fall_delay))
rise_slews, fall_slews = self.get_rise_fall_dc_avg(sae_slew_df)
rise_slew_avgs.append(self.get_average(rise_slews))
fall_slew_avgs.append(self.get_average(fall_slews))
debug.info(1,"DC config={}: slew avg={} delay var={}".format(fanouts, dc_slews[-1], dc_delays_var[-1]))
#Sort by the delays then graph
config_copy = list(fanout_configs)
all_data = zip(dc_slews,config_copy,dc_delays_var)
dc_slews,config_copy,dc_delays_var = zip(*sorted(all_data))
x_ax_label = 'DC Fanouts'
y_ax_labels = ['Average Input Slew (ns)', 'Delay Variance (ns)']
self.plot_delay_variance_data_sets(config_copy, x_ax_label, y_ax_labels, dc_slews, dc_delays_var)
config_copy = list(fanout_configs)
all_data = zip(rise_slew_avgs,config_copy,rise_delay_var)
rise_slew_avgs,config_copy,rise_delay_var = zip(*sorted(all_data))
x_ax_label = 'DC Fanouts'
y_ax_labels = ['Average Rise Stage Input Slew (ns)', 'Rise Delay Variance (ns)']
self.plot_delay_variance_data_sets(config_copy, x_ax_label, y_ax_labels, rise_slew_avgs, rise_delay_var)
config_copy = list(fanout_configs)
all_data = zip(fall_slew_avgs,config_copy,fall_delay_var)
fall_slew_avgs,config_copy,fall_delay_var = zip(*sorted(all_data))
x_ax_label = 'DC Fanouts'
y_ax_labels = ['Average Fall Stage Input Slew (ns)', 'Fall Delay Variance (ns)']
self.plot_delay_variance_data_sets(config_copy, x_ax_label, y_ax_labels, fall_slew_avgs, fall_delay_var)
def graph_delays_and_inp_slews(self, word_size, num_words, words_per_row, fanout_configs):
"""Compare and graph delay chain variations over different configurations."""
if not os.path.exists(DATASET_CSV_NAME):
debug.error("Could not find dataset CSV. Aborting analysis...",1)
dc_delays, dc_slews = [],[]
rise_delay_avgs, rise_slew_avgs = [],[]
fall_delay_avgs, fall_slew_avgs = [],[]
for fanouts in fanout_configs:
data_types = ["sae_measures", "sae_slews"]
filenames = self.get_filename_by_config(data_types, word_size, num_words, words_per_row, fanouts)
sae_delay_df, sae_slew_df = self.get_csv_data(filenames)
delay_sums = self.get_delay_chain_sums(sae_delay_df)
slew_sums = self.get_delay_chain_avg(sae_slew_df)
dc_delays.append(self.get_average(delay_sums))
dc_slews.append(self.get_average(slew_sums))
rise_delay, fall_delay = self.get_rise_fall_dc_sum(sae_delay_df)
rise_delay_avgs.append(self.get_average(rise_delay))
fall_delay_avgs.append(self.get_average(fall_delay))
rise_slews, fall_slews = self.get_rise_fall_dc_avg(sae_slew_df)
rise_slew_avgs.append(self.get_average(rise_slews))
fall_slew_avgs.append(self.get_average(fall_slews))
debug.info(1,"DC config={}: delay avg={} slew avg={}".format(fanouts, dc_delays[-1], dc_slews[-1]))
#Sort by the delays then graph
config_copy = list(fanout_configs)
all_data = zip(dc_delays,config_copy,dc_slews)
dc_delays,config_copy,dc_slews = zip(*sorted(all_data))
x_ax_label = 'DC Fanouts'
y_ax_labels = ['Average Delay (ns)', 'Average Input Slew (ns)']
self.plot_delay_variance_data_sets(config_copy, x_ax_label, y_ax_labels, dc_delays, dc_slews)
config_copy = list(fanout_configs)
all_data = zip(rise_delay_avgs,config_copy,rise_slew_avgs)
rise_delay_avgs,config_copy,rise_slew_avgs = zip(*sorted(all_data))
x_ax_label = 'DC Fanouts'
y_ax_labels = ['Average Rise Delay (ns)', 'Average Input Slew (ns)']
self.plot_delay_variance_data_sets(config_copy, x_ax_label, y_ax_labels, rise_delay_avgs, rise_slew_avgs)
config_copy = list(fanout_configs)
all_data = zip(fall_delay_avgs,config_copy,fall_slew_avgs)
fall_delay_avgs,config_copy,fall_slew_avgs = zip(*sorted(all_data))
x_ax_label = 'DC Fanouts'
y_ax_labels = ['Average Fall Delay (ns)', 'Average Input Slew (ns)']
self.plot_delay_variance_data_sets(config_copy, x_ax_label, y_ax_labels, fall_delay_avgs, fall_slew_avgs)
def get_delay_chain_data(self, sae_dataframe):
"""Get the data of the delay chain over different corners"""
start_dc_pos = sae_dataframe.columns.get_loc('dc_start_ind')
end_dc_pos = sae_dataframe.columns.get_loc('dc_end_ind')
start_data_pos = len(self.config_fields)+len(self.sae_config_fields)+1 #items before this point are configuration related
delay_data = []
#Get delay sums over different corners
for sae_row in sae_dataframe.itertuples():
start_dc, end_dc = sae_row[start_dc_pos+1], sae_row[end_dc_pos+1]
dc_delays = sae_row[start_data_pos+start_dc:start_data_pos+end_dc]
delay_data.append(dc_delays)
return delay_data
def get_delay_chain_sums(self, sae_dataframe):
"""Calculate the sum of each delay chain for each corner"""
dc_data = self.get_delay_chain_data(sae_dataframe)
return [sum(data_list) for data_list in dc_data]
def get_delay_chain_avg(self, sae_dataframe):
"""Calculate the average of each delay chain for each corner"""
dc_data = self.get_delay_chain_data(sae_dataframe)
return [sum(data_list)/len(data_list) for data_list in dc_data]
def get_rise_fall_dc_data_per_corner(self,sae_dataframe):
"""Extracts the data from the dataframe which represents the delay chain.
Delay chain data is marked by indices in the CSV.
"""
start_dc_pos = sae_dataframe.columns.get_loc('dc_start_ind')
end_dc_pos = sae_dataframe.columns.get_loc('dc_end_ind')
start_data_pos = len(self.config_fields)+len(self.sae_config_fields)+1 #items before this point are configuration related
rise_data = []
fall_data = []
#Get delay sums over different corners
for sae_row in sae_dataframe.itertuples():
start_dc, end_dc = sae_row[start_dc_pos+1], sae_row[end_dc_pos+1]
fall_list = sae_row[start_data_pos+start_dc:start_data_pos+end_dc:2]
rise_list = sae_row[start_data_pos+start_dc+1:start_data_pos+end_dc:2]
fall_data.append(fall_list)
rise_data.append(rise_list)
return rise_data, fall_data
def get_rise_fall_dc_sum(self,sae_dataframe):
"""Gets the delay/slew sum of the delay chain for every corner"""
#Get list of lists of delay chain data and reduce to sums
rise_data, fall_data = self.get_rise_fall_dc_data_per_corner(sae_dataframe)
rise_sums = [sum(dc_data) for dc_data in rise_data]
fall_sums = [sum(dc_data) for dc_data in fall_data]
return rise_sums,fall_sums
def get_rise_fall_dc_avg(self,sae_dataframe):
"""Gets the delay/slew average of the delay chain for every corner"""
#Get list of lists of delay chain data and reduce to sums
rise_data, fall_data = self.get_rise_fall_dc_data_per_corner(sae_dataframe)
rise_avgs = [sum(dc_data)/len(dc_data) for dc_data in rise_data]
fall_avgs = [sum(dc_data)/len(dc_data) for dc_data in fall_data]
return rise_avgs,fall_avgs
def get_sum(self, dataframe):
"""Get full delay from csv using the sum field in the df"""
return list(dataframe['sum'])
def get_variance(self, nums):
avg = self.get_average(nums)
delay_variance = sum((xi - avg) ** 2 for xi in nums) / len(nums)
return delay_variance
def get_average(self,nums):
return sum(nums) / len(nums)
def plot_data(self, x_labels, y_values):
"""Display a plot using matplot lib.
Assumes input x values are just labels and y values are actual data."""
data_range = [i+1 for i in range(len(x_labels))]
plt.xticks(data_range, x_labels)
plt.plot(data_range, y_values, 'ro')
plt.show()
def plot_delay_variance_data_sets(self, x_labels, x_ax_name, y_labels, y1_delays, y2_vars):
"""Plots two data sets on the same x-axis."""
data_range = [i for i in range(len(x_labels))]
fig, ax1 = plt.subplots()
color = 'tab:red'
ax1.set_xlabel(str(x_ax_name))
ax1.set_ylabel(y_labels[0], color=color)
ax1.plot(data_range, y1_delays, marker='o', color=color, linestyle='')
ax1.tick_params(axis='y', labelcolor=color)
ax1.tick_params(axis='x', labelrotation=-90)
ax2 = ax1.twinx() # instantiate a second axes that shares the same x-axis
color = 'tab:blue'
#ax2.set_xticks(data_range, x_labels)
ax2.set_ylabel(y_labels[1], color=color) # we already handled the x-label with ax1
ax2.plot(data_range, y2_vars, marker='*', color=color, linestyle='')
ax2.tick_params(axis='y', labelcolor=color)
fig.tight_layout() # otherwise the right y-label is slightly clipped
plt.xticks(data_range, x_labels, rotation=90)
plt.show()
def calculate_delay_ratios_of_srams(self):
"""Runs delay measurements on several sram configurations.
Computes the delay ratio for each one."""
delay_ratio_data = {}
config_tuple_list = [(32, 1024, None)]
#config_tuple_list = [(1, 16, 1),(4, 16, 1), (16, 16, 1), (32, 32, 1)]
for sram_config in config_tuple_list:
word_size, num_words, words_per_row = sram_config
self.init_data_gen()
self.save_data_sram_corners(word_size, num_words, words_per_row)
model_delay_ratios, meas_delay_ratios, ratio_error = self.compare_model_to_measure()
delay_ratio_data[sram_config] = ratio_error
debug.info(1, "Ratio percentage error={}".format(ratio_error))
return delay_ratio_data
def get_csv_data(self, filenames):
"""Returns a dataframe for each file name. Returns as tuple for convenience"""
dataframes = [pd.read_csv(fname,encoding='utf-8') for fname in filenames]
return tuple(dataframes)
def evaluate_data(self, wl_dataframe, sae_dataframe):
"""Analyze the delay error and variation error"""
delay_error = self.calculate_delay_error(wl_dataframe, sae_dataframe)
debug.info(1, "Delay errors:{}".format(delay_error))
variation_error = self.calculate_delay_variation_error(wl_dataframe, sae_dataframe)
debug.info(1, "Variation errors:{}".format(variation_error))
def compare_model_to_measure(self):
"""Uses the last 4 recent data sets (wl_meas, sen_meas, wl_model, sen_model)
and compare the wl-sen delay ratio between model and measured.
"""
model_delay_ratios = {}
meas_delay_ratios = {}
ratio_error = {}
#The full file name contains unrelated portions, separate them into the four that are needed
file_list = self.file_name_dict.values()
wl_meas_df = [pd.read_csv(file_name,encoding='utf-8') for file_name in file_list if "wl_measures" in file_name][0]
sae_meas_df = [pd.read_csv(file_name,encoding='utf-8') for file_name in file_list if "sae_measures" in file_name][0]
wl_model_df = [pd.read_csv(file_name,encoding='utf-8') for file_name in file_list if "wl_model" in file_name][0]
sae_model_df = [pd.read_csv(file_name,encoding='utf-8') for file_name in file_list if "sae_model" in file_name][0]
#Assume each csv has the same corners (and the same row order), use one of the dfs for corners
proc_pos, volt_pos, temp_pos = wl_meas_df.columns.get_loc('process'), wl_meas_df.columns.get_loc('voltage'), wl_meas_df.columns.get_loc('temp')
wl_sum_pos = wl_meas_df.columns.get_loc('sum')
sae_sum_pos = sae_meas_df.columns.get_loc('sum')
df_zip = zip(wl_meas_df.itertuples(),sae_meas_df.itertuples(),wl_model_df.itertuples(),sae_model_df.itertuples())
for wl_meas,sae_meas,wl_model,sae_model in df_zip:
#Use previously calculated position to index the df row.
corner = (wl_meas[proc_pos+1], wl_meas[volt_pos+1], wl_meas[temp_pos+1])
meas_delay_ratios[corner] = wl_meas[wl_sum_pos+1]/sae_meas[sae_sum_pos+1]
model_delay_ratios[corner] = wl_model[wl_sum_pos+1]/sae_model[sae_sum_pos+1]
#Not using absolute error, positive error means model was larger, negative error means it was smaller.
ratio_error[corner] = 100*(model_delay_ratios[corner]-meas_delay_ratios[corner])/meas_delay_ratios[corner]
return model_delay_ratios, meas_delay_ratios, ratio_error
def display_data(self, data):
"""Displays the ratio data using matplotlib (requires graphics)"""
config_data = []
xticks = []
#Organize data
#First key level if the sram configuration (wordsize, num words, words per row)
for config,corner_data_dict in data.items():
#Second level is the corner data for that configuration.
for corner, corner_data in corner_data_dict.items():
#Right now I am only testing with a single corner, will not work with more than 1 corner
config_data.append(corner_data)
xticks.append("{}b,{}w,{}wpr".format(*config))
#plot data
data_range = [i+1 for i in range(len(data))]
shapes = ['ro', 'bo', 'go', 'co', 'mo']
plt.xticks(data_range, xticks)
plt.plot(data_range, config_data, 'ro')
plt.show()
def calculate_delay_error(self, wl_dataframe, sae_dataframe):
"""Calculates the percentage difference in delays between the wordline and sense amp enable"""
wl_start_data_pos = len(self.config_fields)
sae_start_data_pos = len(self.config_fields)+len(self.sae_config_fields)
error_list = []
row_count = 0
for wl_row, sae_row in zip(wl_dataframe.itertuples(), sae_dataframe.itertuples()):
debug.info(2, "wl_row:{}".format(wl_row))
wl_sum = sum(wl_row[wl_start_data_pos+1:])
debug.info(2, "wl_sum:{}".format(wl_sum))
sae_sum = sum(sae_row[sae_start_data_pos+1:])
error_list.append(abs((wl_sum-sae_sum)/wl_sum))
return error_list
def calculate_delay_variation_error(self, wl_dataframe, sae_dataframe):
"""Measures a base delay from the first corner then the variations from that base"""
wl_start_data_pos = len(self.config_fields)
sae_start_data_pos = len(self.config_fields)+len(self.sae_config_fields)
variation_error_list = []
count = 0
for wl_row, sae_row in zip(wl_dataframe.itertuples(), sae_dataframe.itertuples()):
if count == 0:
#Create a base delay, variation is defined as the difference between this base
wl_base = sum(wl_row[wl_start_data_pos+1:])
debug.info(1, "wl_sum base:{}".format(wl_base))
sae_base = sum(sae_row[sae_start_data_pos+1:])
variation_error_list.append(0.0)
else:
#Calculate the variation from the respective base and then difference between the variations
wl_sum = sum(wl_row[wl_start_data_pos+1:])
wl_base_diff = abs((wl_base-wl_sum)/wl_base)
sae_sum = sum(sae_row[sae_start_data_pos+1:])
sae_base_diff = abs((sae_base-sae_sum)/sae_base)
variation_diff = abs((wl_base_diff-sae_base_diff)/wl_base_diff)
variation_error_list.append(variation_diff)
count+=1
return variation_error_list
def save_data_sram_corners(self, word_size, num_words, words_per_row):
"""Performs corner analysis on a single SRAM configuration"""
self.create_sram(word_size, num_words, words_per_row)
#Setting to none forces SRAM to determine the value. Must be checked after sram creation
if not words_per_row:
words_per_row = self.sram.s.words_per_row
#Run on one size to initialize CSV writing (csv names come from return value). Strange, but it is okay for now.
corner_gen = self.corner_combination_generator()
init_corner = next(corner_gen)
sram_data = self.get_sram_data(init_corner)
dc_resized = self.was_delay_chain_resized()
self.initialize_csv_file(word_size, num_words, words_per_row)
self.add_sram_data_to_csv(sram_data, word_size, num_words, words_per_row, dc_resized, init_corner)
#Run openRAM for all corners
for corner in corner_gen:
sram_data = self.get_sram_data(corner)
self.add_sram_data_to_csv(sram_data, word_size, num_words, words_per_row, dc_resized, corner)
#Save file names generated by this run
if not self.dataset_initialized:
self.init_dataset_csv(list(sram_data))
self.add_dataset(word_size, num_words, words_per_row)
self.close_files()
debug.info(1,"Data Generated")
def init_data_gen(self):
"""Initialization for the data test to run"""
globals.init_openram("config_data")
from tech import parameter
global parameter
if OPTS.tech_name == "scmos":
debug.warning("Device models not up to date with scn4m technology.")
OPTS.spice_name="hspice" #Much faster than ngspice.
OPTS.trim_netlist = False
OPTS.netlist_only = True
OPTS.analytical_delay = False
#OPTS.use_tech_delay_chain_size = True
# This is a hack to reload the characterizer __init__ with the spice version
from importlib import reload
import characterizer
reload(characterizer)
def set_delay_chain(self, fanout_list):
"""Force change the parameter in the tech file to specify a delay chain configuration"""
parameter["static_fanout_list"] = fanout_list
def close_files(self):
"""Closes all files stored in the file dict"""
#Close the files holding data
for key,file in self.csv_files.items():
file.close()
#Write dataframe to the dataset csv
self.datasets_df.to_csv(DATASET_CSV_NAME, index=False)
def corner_combination_generator(self):
processes = OPTS.process_corners
voltages = OPTS.supply_voltages
temperatures = OPTS.temperatures
"""Generates corner using a combination of values from config file"""
for proc in processes:
for volt in voltages:
for temp in temperatures:
yield (proc, volt, temp)
def get_sram_configs(self):
"""Generate lists of wordsizes, number of words, and column mux size (words per row) to be tested."""
min_word_size = 1
max_word_size = 16
min_num_words_log2 = 4
max_num_words_log2 = 8
word_sizes = [i for i in range(min_word_size,max_word_size+1)]
num_words = [2**i for i in range(min_num_words_log2,max_num_words_log2+1)]
words_per_row = [1]
return word_sizes, num_words, words_per_row
def add_sram_data_to_csv(self, sram_data, word_size, num_words, words_per_row, dc_resized, corner):
"""Writes data to its respective CSV file. There is a CSV for each measurement target
(wordline, sense amp enable, and models)"""
dc_start_ind, dc_end_ind = self.delay_obj.delay_chain_indices
sram_specs = [word_size,num_words,words_per_row,dc_resized,*corner]
sae_specs = [dc_start_ind, dc_end_ind]
for data_name, data_values in sram_data.items():
if 'sae' in data_name:
all_specs = sram_specs+sae_specs
else:
all_specs = sram_specs
other_values = self.calculate_other_data_values(data_values)
self.csv_writers[data_name].writerow(all_specs+sram_data[data_name]+other_values)
debug.info(2,"Data Added to CSV file.")
def calculate_other_data_values(self, sram_data_list):
"""A function to calculate extra values related to the data. Only does the sum for now"""
data_sum = sum(sram_data_list)
return [data_sum]
def initialize_csv_file(self, word_size, num_words, words_per_row):
"""Opens a CSV file and writer for every data set being written (wl/sae measurements and model values)"""
#CSV File writing
header_dict = self.delay_obj.get_all_signal_names()
self.csv_files = {}
self.csv_writers = {}
self.file_name_dict = {}
delay_fanout_list = self.delay_obj.get_num_delay_fanout_list()
fanout_str = '_'.join(str(fanout) for fanout in delay_fanout_list)
delay_stages = self.delay_obj.get_num_delay_stages()
delay_stage_fanout = self.delay_obj.get_num_delay_stage_fanout()
for data_name, header_list in header_dict.items():
file_name = '{}data_{}b_{}word_{}way_dc{}_{}.csv'.format(MODEL_DIR,
word_size,
num_words,
words_per_row,
fanout_str,
data_name)
self.file_name_dict[data_name] = file_name
self.csv_files[data_name] = open(file_name, 'w')
if 'sae' in data_name:
fields = (*self.config_fields, *self.sae_config_fields, *header_list, *self.other_data_fields)
else:
fields = (*self.config_fields, *header_list, *self.other_data_fields)
self.csv_writers[data_name] = csv.writer(self.csv_files[data_name], lineterminator = '\n')
self.csv_writers[data_name].writerow(fields)
def create_sram(self, word_size, num_words, words_per_row):
"""Generates the SRAM based on input configuration."""
c = sram_config(word_size=word_size,
num_words=num_words,
num_banks=1,
words_per_row=words_per_row)
debug.info(1, "Creating SRAM: {} bit, {} words, with 1 bank".format(word_size, num_words))
self.sram = sram(c, name="sram_{}ws_{}words".format(word_size, num_words))
self.sram_spice = OPTS.openram_temp + "temp.sp"
self.sram.sp_write(self.sram_spice)
def get_sram_data(self, corner):
"""Generates the delay object using the corner and runs a simulation for data."""
from characterizer import model_check
self.delay_obj = model_check(self.sram.s, self.sram_spice, corner)
import tech
#Only 1 at a time
probe_address = "1" * self.sram.s.addr_size
probe_data = self.sram.s.word_size - 1
loads = [tech.spice["msflop_in_cap"]*4]
slews = [tech.spice["rise_time"]*2]
sram_data = self.delay_obj.analyze(probe_address,probe_data,slews,loads)
return sram_data
def remove_lists_from_dict(self, dict):
"""Check all the values in the dict and replaces the list items with its first value."""
#This is useful because the tests performed here only generate 1 value but a list
#with 1 item makes writing it to a csv later harder.
for key in dict.keys():
if type(dict[key]) is list:
if len(dict[key]) > 0:
dict[key] = dict[key][0]
else:
del dict[key]
def was_delay_chain_resized(self):
"""Accesses the dc resize boolean in the control logic module."""
#FIXME:assumes read/write port only
return self.sram.s.control_logic_rw.delay_chain_resized
# instantiate a copdsay of the class to actually run the test
if __name__ == "__main__":
(OPTS, args) = globals.parse_args()
del sys.argv[1:]
header(__file__, OPTS.tech_name)
unittest.main()