create_figures_with_new_data.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "from matplotlib.ticker import FormatStrFormatter\n",
    "\n",
    "# giray's style\n",
    "scale_factor = 16\n",
    "\n",
    "colors = sns.color_palette(\"plasma\", 4 * scale_factor)\n",
    "\n",
    "ext_colors = []\n",
    "i = 0 \n",
    "while i < 4:\n",
    "    c = colors[i*scale_factor]\n",
    "    cn = tuple([cc * 0.9 for cc in c])\n",
    "    ext_colors.append(cn)\n",
    "    ext_colors.append(c)\n",
    "    i+=1\n",
    "\n",
    "print(ext_colors)\n",
    "\n",
    "ext_colors = [ext_colors[0], ext_colors[2], ext_colors[4], ext_colors[6], ext_colors[7], ext_colors[5], ext_colors[3], ext_colors[1]]\n",
    "\n",
    "mypalette = sns.color_palette(ext_colors)\n",
    "\n",
    "mypalette\n",
    "\n",
    "# read all csv files in this folder and concatenate them into one dataframe\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import re\n",
    "import os\n",
    "\n",
    "host_machines = [\n",
    "  'safari-fpga37',\n",
    "  'safari-fpga55',\n",
    "  'safari-fpga56-new',\n",
    "  'safari-fpga57',\n",
    "  'safari-fpga58',\n",
    "  'safari-fpga59'\n",
    "]\n",
    "\n",
    "rows_tested_for_bitflips = 3072\n",
    "\n",
    "dfs = []\n",
    "\n",
    "# Loop over all CSV files in the directory\n",
    "for host_machine in host_machines:\n",
    "  dir_path = './' + 'fast_forward_data/' + host_machine\n",
    "  for filename in os.listdir(dir_path):\n",
    "    if filename.startswith('rows_only_rowhammer') and 'tAggOn' not in filename:\n",
    "      tokens = filename.split('_')\n",
    "      ch_num = int(tokens[4])\n",
    "      pc_num = int(tokens[6])\n",
    "      bank_num = int(tokens[8])\n",
    "      pattern = tokens[10].split('.')[0]\n",
    "      # create a dataframe from the csv file\n",
    "      df = pd.read_csv(dir_path + '/' + filename)\n",
    "      # add the channel, pc, bank and pattern numbers as columns\n",
    "      df['CH'] = ch_num\n",
    "      df['PC'] = pc_num\n",
    "      df['bank'] = bank_num\n",
    "      df['pattern'] = pattern\n",
    "      df['machine'] = host_machine\n",
    "      # append the dataframe to the list\n",
    "      dfs.append(df)\n",
    "\n",
    "# Concatenate all dataframes into one\n",
    "df = pd.concat(dfs, ignore_index=True)\n",
    "\n",
    "# map the channels by decrementing them by 8\n",
    "df['CH'] = df['CH'].map(lambda x: x - 8)\n",
    "\n",
    "# map the rows in the following ranges to the following ranges\n",
    "# [0-1023] -> [0-1023]\n",
    "# [1024-2047] -> [7168-8191]\n",
    "# [2048-3071] -> [13310-14333]\n",
    "\n",
    "def map_row(row):\n",
    "  if row < 1024:\n",
    "    return row\n",
    "  elif row < 2048:\n",
    "    return row + 6144\n",
    "  else:\n",
    "    return row + 11262\n",
    "\n",
    "common_rows = [\n",
    "  range(0, 1024, 1),\n",
    "  range(7168, 8192, 1),\n",
    "  range(13310, 14334, 1)\n",
    "]\n",
    "\n",
    "common_banks = [\n",
    "  0, 1, 2\n",
    "]\n",
    "\n",
    "# group by machine, channel, pc, bank, pattern\n",
    "# if the group has 3072 rows, then apply map row\n",
    "# otherwise, leave the row as is\n",
    "df['row'] = df.groupby(['machine', 'CH', 'PC', 'bank', 'pattern'])['row'].transform(lambda x: x.map(map_row) if len(x) == rows_tested_for_bitflips else x)\n",
    "\n",
    "# rename machine using the following map\n",
    "machine_map = {\n",
    "  'safari-fpga37': 'Chip 0',\n",
    "  'safari-fpga55': 'Chip 1',\n",
    "  'safari-fpga56-new': 'Chip 2',\n",
    "  'safari-fpga57': 'Chip 3',\n",
    "  'safari-fpga58': 'Chip 4',\n",
    "  'safari-fpga59': 'Chip 5'\n",
    "}\n",
    "df['machine'] = df['machine'].map(machine_map)\n",
    "\n",
    "pattern_map = {\n",
    "  '0': '00',\n",
    "  '1': 'FF',\n",
    "  '2': '55',\n",
    "  '3': 'AA'\n",
    "}\n",
    "\n",
    "# modify pattern column only if the pattern is not one of the values in the map\n",
    "df['pattern'] = df['pattern'].map(lambda x: pattern_map[x] if x in pattern_map else x)\n",
    "\n",
    "# rename machine column to chip\n",
    "df.rename(columns={'machine': 'chip'}, inplace=True)\n",
    "\n",
    "# rename row_errors to bitflips\n",
    "df.rename(columns={'row_errors': 'bitflips'}, inplace=True)\n",
    "\n",
    "df['bitflips'] = df['bitflips'] / 5\n",
    "\n",
    "# create bit error rate column \n",
    "# ber = bitflips / row size (1024*8)\n",
    "df['ber'] = df['bitflips'] / (1024*8) * 100\n",
    "\n",
    "# filter out uncommon rows\n",
    "df_common_rows = df[df['row'].isin(common_rows[0]) | df['row'].isin(common_rows[1]) | df['row'].isin(common_rows[2])].copy()\n",
    "df_common_banks_rows = df_common_rows[df_common_rows['bank'].isin(common_banks)].copy()\n",
    "\n",
    "# a new data point for each row is created for a new worst case data pattern\n",
    "# this is the data pattern that maximizes ber for a row in a given channel, pc, bank, chip, with different patterns\n",
    "\n",
    "# group by chip, channel, pc, bank, row\n",
    "# for each group, find the pattern that maximizes ber\n",
    "# create a new dataframe with the following columns: chip, channel, pc, bank, row, pattern, ber\n",
    "df_worst_case = df_common_banks_rows.groupby(['chip', 'CH', 'PC', 'bank', 'row'])[['pattern', 'ber']].max().reset_index()\n",
    "\n",
    "df_worst_case.reset_index(drop=True, inplace=True)\n",
    "\n",
    "# rename pattern values with \"WCDP\"\n",
    "df_worst_case['pattern'] = df_worst_case['pattern'].map(lambda x: 'WCDP')\n",
    "\n",
    "# add df_worst_case to df\n",
    "df_common_banks_rows = pd.concat([df_common_banks_rows, df_worst_case], ignore_index=True)\n",
    "\n",
    "df_common_banks_rows\n",
    "\n",
    "\n",
    "ber_chip_ch = df_common_banks_rows.copy()\n",
    "\n",
    "# flatten the multi-index\n",
    "ber_chip_ch.reset_index(inplace=True)\n",
    "\n",
    "# if ber smaller than 0.1%, remove the row\n",
    "ber_chip_ch = ber_chip_ch[ber_chip_ch['ber'] > 0.1]\n",
    "\n",
    "# select only chip, channel and bitflips\n",
    "ber_chip_ch = ber_chip_ch[['chip', 'CH', 'pattern', 'ber']]\n",
    "ber_chip_ch\n",
    "\n",
    "# order for the pattern column is:\n",
    "pattern_order = ['FF', '00', 'AA', '55', 'WCDP']\n",
    "# apply this order\n",
    "ber_chip_ch['pattern'] = pd.Categorical(ber_chip_ch['pattern'], pattern_order)\n",
    "\n",
    "# sort by pattern, chip, channel\n",
    "ber_chip_ch.sort_values(by=['pattern', 'chip', 'CH'], inplace=True)\n",
    "\n",
    "\n",
    "# create a subplot for each chip\n",
    "fig, axes = plt.subplots(nrows=len(ber_chip_ch['chip'].unique()), figsize=(8.1, 2.0*len(ber_chip_ch['chip'].unique())))\n",
    "\n",
    "data_patterns = {\n",
    "  0: \"Rowstripe0\",\n",
    "  1: \"Rowstripe1\",\n",
    "  2: \"Checkered0\",\n",
    "  3: \"Checkered1\",\n",
    "  4: \"WCDP\"\n",
    "}\n",
    "\n",
    "# create a bar plot for each chip\n",
    "for chip, ax in zip(ber_chip_ch['chip'].unique(), axes):\n",
    "  sns.boxplot(x='pattern', y='ber', hue='CH', data=ber_chip_ch[ber_chip_ch['chip'] == chip], ax=ax, palette=mypalette, whis=(0,100), showmeans=True, meanprops={\"marker\":\"o\",\"markerfacecolor\":\"white\", \"markeredgecolor\":\"black\",\"markersize\":\"3\"})\n",
    "  # add text saying Chip X in a box\n",
    "  ax.text(0.1, 0.85, chip, horizontalalignment='center', verticalalignment='center', transform=ax.transAxes, bbox=dict(facecolor='white', edgecolor='black', boxstyle='round,pad=0.5', alpha=0.5), fontsize=12)\n",
    "  ax.get_legend().remove()\n",
    "  # if chip != 'Chip 5':\n",
    "  ax.set_xlabel('')\n",
    "  ax.set_xticklabels([])\n",
    "  ax.set_xticks([])\n",
    "  if chip == 'Chip 0':\n",
    "    # prepend 'CH' to legend labels\n",
    "    handles, labels = ax.get_legend_handles_labels()\n",
    "    ax.legend(handles, ['CH' + label for label in labels], loc='upper center', title='Channel', ncol=8, bbox_to_anchor=(0.5, 1.5), fancybox=True, shadow=True, columnspacing=0.5)\n",
    "  if chip == 'Chip 5':\n",
    "    ax.set_xticks(range(5))\n",
    "    ax.set_xticklabels([data_patterns[i] for i in range(5)])\n",
    "    ax.set_xlabel('Data pattern')\n",
    "  ax.set_ylabel('')\n",
    "  # ax.set_title('Bank {}'.format(b))\n",
    "  # put horizontal grid lines in the background\n",
    "  ax.set_axisbelow(True)\n",
    "  shade_gray = 0.8\n",
    "  ax.axvspan(3.5, 4.5, facecolor=(shade_gray,shade_gray,shade_gray), alpha=0.2)\n",
    "  ax.axvline(3.5, color='black', linestyle='dashed')\n",
    "  ax.set_xlim(-0.5, 4.5)\n",
    "  ax.yaxis.grid(color='gray', linestyle='dashed')\n",
    "  ax.set_ylim(0, 3.2)\n",
    "  ax.set_yticks([0, 0.4, 0.8, 1.2, 1.6, 2.0, 2.4, 2.8, 3.2])\n",
    "  ax.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))\n",
    "  # remove legend\n",
    "  # ax.set_yticklabels([str(x*100) for x in ax.get_yticks()])\n",
    "\n",
    "# add text as y axis label that spans all subplots\n",
    "fig.text(0.05, 0.5, 'RowHammer Bit Error Rate ($BER$)', va='center', rotation='vertical', fontsize=12)\n",
    "\n",
    "# set subplots apart\n",
    "# fig.tight_layout()\n",
    "fig.subplots_adjust(hspace=0.15)\n",
    "\n",
    "# save plot\n",
    "fig.savefig('figure6-new.pdf', bbox_inches='tight')\n",
    "\n",
    "# print the average BER across everything for WCDP\n",
    "print('Max BER across everything for WCDP: {}'.format(ber_chip_ch[ber_chip_ch['pattern'] == 'WCDP']['ber'].max()))\n",
    "print(ber_chip_ch[ber_chip_ch['pattern'] == 'WCDP']['ber'].max()*8192/100)\n",
    "\n",
    "# print the average bit error rate for Chip 0 CH7 for WCDP\n",
    "print('Average BER for Chip 0 CH7 for WCDP: {}'.format(ber_chip_ch[(ber_chip_ch['pattern'] == 'WCDP') & (ber_chip_ch['chip'] == 'Chip 0') & (ber_chip_ch['CH'] == 7)]['ber'].mean()))\n",
    "print('Average BER for Chip 0 CH3 for WCDP: {}'.format(ber_chip_ch[(ber_chip_ch['pattern'] == 'WCDP') & (ber_chip_ch['chip'] == 'Chip 0') & (ber_chip_ch['CH'] == 3)]['ber'].mean()))\n",
    "\n",
    "\n",
    "print('Average BER for Chip 4 CH7 for WCDP: {}'.format(ber_chip_ch[(ber_chip_ch['pattern'] == 'WCDP') & (ber_chip_ch['chip'] == 'Chip 4') & (ber_chip_ch['CH'] == 7)]['ber'].mean()))\n",
    "print('Average BER for Chip 4 CH1 for WCDP: {}'.format(ber_chip_ch[(ber_chip_ch['pattern'] == 'WCDP') & (ber_chip_ch['chip'] == 'Chip 4') & (ber_chip_ch['CH'] == 1)]['ber'].mean()))\n",
    "\n",
    "\n",
    "# print by how much CH7 is worse than CH3\n",
    "print('CH7 is worse than CH3 by: {}'.format(ber_chip_ch[(ber_chip_ch['pattern'] == 'WCDP') & (ber_chip_ch['chip'] == 'Chip 0') & (ber_chip_ch['CH'] == 7)]['ber'].mean() / ber_chip_ch[(ber_chip_ch['pattern'] == 'WCDP') & (ber_chip_ch['chip'] == 'Chip 0') & (ber_chip_ch['CH'] == 3)]['ber'].mean()))\n",
    "\n",
    "print('Maximum observed BER in CH7 in Chip 0 for RowStripe 1: {}'.format(ber_chip_ch[(ber_chip_ch['pattern'] == '00') & (ber_chip_ch['chip'] == 'Chip 0') & (ber_chip_ch['CH'] == 7)]['ber'].max()))\n",
    "print('Maximum observed BER in CH7 in Chip 0 for Checkered 0: {}'.format(ber_chip_ch[(ber_chip_ch['pattern'] == 'AA') & (ber_chip_ch['chip'] == 'Chip 0') & (ber_chip_ch['CH'] == 7)]['ber'].max()))\n",
    "\n",
    "# print the average BER for each chip\n",
    "for chip in ber_chip_ch['chip'].unique():\n",
    "  print('Average BER for Chip {}: {}'.format(chip, ber_chip_ch[(ber_chip_ch['pattern'] == 'WCDP') & (ber_chip_ch['chip'] == chip)]['ber'].mean()))\n",
    "\n",
    "# seledct chip 4 and checkered 0\n",
    "ber_chip_ch[(ber_chip_ch['pattern'] == 'AA') & (ber_chip_ch['chip'] == 'Chip 4')]\n",
    "\n",
    "# group by channels, take mean of BER, find min and max of those\n",
    "# then find the difference between the min and max\n",
    "ber_chip_ch[(ber_chip_ch['pattern'] == 'AA') & (ber_chip_ch['chip'] == 'Chip 4')].groupby('CH')['ber'].mean().max() - ber_chip_ch[(ber_chip_ch['pattern'] == 'AA') & (ber_chip_ch['chip'] == 'Chip 4')].groupby('CH')['ber'].mean().min() \n",
    "\n",
    "\n",
    "fig = plt.figure(figsize=(8.1, 2.0))\n",
    "\n",
    "sns.boxplot(x='pattern', y='ber', hue='chip', data=ber_chip_ch, whis=(0,100), showmeans=True, meanprops={\"marker\":\"o\",\"markerfacecolor\":\"white\", \"markeredgecolor\":\"black\",\"markersize\":\"3\"}, palette=sns.color_palette(\"Set2\", 6))\n",
    "\n",
    "# get figure's ax\n",
    "fig = plt.gca()\n",
    "\n",
    "# move legend above figure\n",
    "handles, labels = fig.get_legend_handles_labels()\n",
    "fig.legend(handles, labels, loc='upper center', title='Chip', ncol=6, bbox_to_anchor=(0.5, 1.4), fancybox=True, shadow=True, columnspacing=0.5)\n",
    "\n",
    "fig.set_xticks(range(5))\n",
    "fig.set_xticklabels([data_patterns[i] for i in range(5)])\n",
    "fig.set_xlabel('Data pattern')\n",
    "fig.set_ylabel('RowHammer BER (%)')\n",
    "# ax.set_title('Bank {}'.format(b))\n",
    "# put horizontal grid lines in the background\n",
    "fig.set_axisbelow(True)\n",
    "shade_gray = 0.8\n",
    "fig.axvspan(3.5, 4.5, facecolor=(shade_gray,shade_gray,shade_gray), alpha=0.2)\n",
    "fig.axvline(3.5, color='black', linestyle='dashed')\n",
    "fig.set_xlim(-0.5, 4.5)\n",
    "fig.yaxis.grid(color='gray', linestyle='dashed')\n",
    "fig.set_ylim(0, 3.2)\n",
    "fig.set_yticks([0, 0.4, 0.8, 1.2, 1.6, 2.0, 2.4, 2.8, 3.2])\n",
    "fig.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))\n",
    "# remove legend\n",
    "# ax.set_yticklabels([str(x*100) for x in ax.get_yticks()])\n",
    "\n",
    "# save figure\n",
    "plt.savefig('figure4-new.pdf', bbox_inches='tight')\n",
    "\n",
    "# Chip 0 and Chip 5 mean BER for Checkered 0\n",
    "print('Chip 0 max BER for Checkered 0: {:.2f}%'.format(ber_chip_ch[(ber_chip_ch['pattern'] == 'AA') & (ber_chip_ch['chip'] == 'Chip 0')]['ber'].max()))\n",
    "print('Chip 0 mean BER for Checkered 0: {:.2f}%'.format(ber_chip_ch[(ber_chip_ch['pattern'] == 'AA') & (ber_chip_ch['chip'] == 'Chip 0')]['ber'].mean()))\n",
    "print('Chip 5 max BER for Checkered 0: {:.2f}%'.format(ber_chip_ch[(ber_chip_ch['pattern'] == 'AA') & (ber_chip_ch['chip'] == 'Chip 5')]['ber'].max()))\n",
    "print('Chip 5 mean BER for Checkered 0: {:.2f}%'.format(ber_chip_ch[(ber_chip_ch['pattern'] == 'AA') & (ber_chip_ch['chip'] == 'Chip 5')]['ber'].mean()))\n",
    "\n",
    "\n",
    "print('Mean BER for Checkered 0 and 1: {:.2f}%'.format(ber_chip_ch[(ber_chip_ch['pattern'] == 'AA') | (ber_chip_ch['pattern'] == '55')]['ber'].mean()))\n",
    "print('Mean BER for Rowstripe 0 and 1: {:.2f}%'.format(ber_chip_ch[(ber_chip_ch['pattern'] == 'FF') | (ber_chip_ch['pattern'] == '00')]['ber'].mean()))\n",
    "\n",
    "\n",
    "print('Max BER for a chip for Checkered0: {:.2f}%'.format(ber_chip_ch[(ber_chip_ch['pattern'] == 'AA')].groupby('chip')['ber'].mean().max()))\n",
    "print('Min BER for a chip for Checkered0: {:.2f}%'.format(ber_chip_ch[(ber_chip_ch['pattern'] == 'AA')].groupby('chip')['ber'].mean().min()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "from matplotlib.ticker import FormatStrFormatter\n",
    "\n",
    "# giray's style\n",
    "scale_factor = 16\n",
    "\n",
    "colors = sns.color_palette(\"plasma\", 4 * scale_factor)\n",
    "\n",
    "ext_colors = []\n",
    "i = 0 \n",
    "while i < 4:\n",
    "    c = colors[i*scale_factor]\n",
    "    cn = tuple([cc * 0.9 for cc in c])\n",
    "    ext_colors.append(cn)\n",
    "    ext_colors.append(c)\n",
    "    i+=1\n",
    "\n",
    "print(ext_colors)\n",
    "\n",
    "ext_colors = [ext_colors[0], ext_colors[2], ext_colors[4], ext_colors[6], ext_colors[7], ext_colors[5], ext_colors[3], ext_colors[1]]\n",
    "\n",
    "mypalette = sns.color_palette(ext_colors)\n",
    "\n",
    "mypalette\n",
    " \n",
    "\n",
    "# read all csv files in this folder and concatenate them into one dataframe\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import re\n",
    "import os\n",
    "\n",
    "host_machines = [\n",
    "  # 'safari-fgpa37',\n",
    "  'safari-fpga55',\n",
    "  'safari-fpga56-new',\n",
    "  'safari-fpga57',\n",
    "  'safari-fpga58',\n",
    "  'safari-fpga59'\n",
    "]\n",
    "\n",
    "dfs = []\n",
    "\n",
    "# Loop over all CSV files in the directory\n",
    "for host_machine in host_machines:\n",
    "  dir_path = './' + 'fast_forward_data/' +  host_machine\n",
    "  for filename in os.listdir(dir_path):\n",
    "    if filename.startswith('hcfirst') and 'tAggOn' not in filename:\n",
    "      tokens = filename.split('_')\n",
    "      ch_num = int(tokens[2])\n",
    "      pc_num = int(tokens[4])\n",
    "      bank_num = int(tokens[6])\n",
    "      pattern = tokens[8].split('.')[0]\n",
    "      # create a dataframe from the csv file\n",
    "      df = pd.read_csv(dir_path + '/' + filename, header=None, names=['hcfirst'])\n",
    "      # add the channel, pc, bank and pattern numhcfirsts as columns\n",
    "      df['CH'] = ch_num\n",
    "      df['PC'] = pc_num\n",
    "      df['bank'] = bank_num\n",
    "      df['pattern'] = pattern\n",
    "      df['machine'] = host_machine\n",
    "      df['row'] = df.index\n",
    "      # append the dataframe to the list\n",
    "      dfs.append(df)\n",
    "\n",
    "\n",
    "# Loop over all CSV files in the directory\n",
    "for host_machine in ['safari-fpga37']:\n",
    "  dir_path = './' + 'fast_forward_data/' + host_machine\n",
    "  for filename in os.listdir(dir_path):\n",
    "    if filename.startswith('hcfirst') and 'tAggOn' not in filename:\n",
    "      tokens = filename.split('_')\n",
    "      ch_num = int(tokens[2])\n",
    "      pc_num = 0\n",
    "      bank_num = int(tokens[4])\n",
    "      pattern = tokens[6].split('.')[0]\n",
    "      # create a dataframe from the csv file\n",
    "      df = pd.read_csv(dir_path + '/' + filename, header=None, names=['hcfirst'])\n",
    "      # add the channel, pc, bank and pattern numhcfirsts as columns\n",
    "      df['CH'] = ch_num\n",
    "      df['PC'] = pc_num\n",
    "      df['bank'] = bank_num\n",
    "      df['pattern'] = pattern\n",
    "      df['machine'] = host_machine\n",
    "      df['row'] = df.index\n",
    "\n",
    "      # remove entries with row in the following ranges\n",
    "      # [1024-3095], [4120-6167], [7168, 9215]\n",
    "      df = df[~df['row'].between(1024, 3095)]\n",
    "      df = df[~df['row'].between(4120, 6167)]\n",
    "      df = df[~df['row'].between(7168, 9215)]\n",
    "      # append the dataframe to the list\n",
    "      dfs.append(df)\n",
    "\n",
    "# Concatenate all dataframes into one\n",
    "df = pd.concat(dfs, ignore_index=True)\n",
    "\n",
    "# map the channels by decrementing them by 8\n",
    "df['CH'] = df['CH'].map(lambda x: x - 8)\n",
    "\n",
    "# map the rows in the following ranges to the following ranges\n",
    "# [0-255] -> [0-255]\n",
    "# [256-511] -> [7936-8191]\n",
    "# [2048-3071] -> [15614-15869]\n",
    "\n",
    "def map_row(row):\n",
    "  if row < 1024:\n",
    "    return row\n",
    "  elif row < 2048:\n",
    "    return row + 7168\n",
    "  else:\n",
    "    return row + 13310\n",
    "\n",
    "# apply map_row to the row column\n",
    "df['row'] = df['row'].map(map_row)\n",
    "\n",
    "# rename machine using the following map\n",
    "machine_map = {\n",
    "  'safari-fpga37': 'Chip 0',\n",
    "  'safari-fpga55': 'Chip 1',\n",
    "  'safari-fpga56-new': 'Chip 2',\n",
    "  'safari-fpga57': 'Chip 3',\n",
    "  'safari-fpga58': 'Chip 4',\n",
    "  'safari-fpga59': 'Chip 5'\n",
    "}\n",
    "df['machine'] = df['machine'].map(machine_map)\n",
    "\n",
    "pattern_map = {\n",
    "  '0': '00',\n",
    "  '1': 'FF',\n",
    "  '2': '55',\n",
    "  '3': 'AA'\n",
    "}\n",
    "\n",
    "# modify pattern column only if the pattern is not one of the values in the map\n",
    "df['pattern'] = df['pattern'].map(lambda x: pattern_map[x] if x in pattern_map else x)\n",
    "\n",
    "# rename machine column to chip\n",
    "df.rename(columns={'machine': 'chip'}, inplace=True)\n",
    "\n",
    "# a new data point for each row is created for a new worst case data pattern\n",
    "# this is the data pattern that maximizes hcfirst for a row in a given channel, pc, bank, chip, with different patterns\n",
    "\n",
    "# remove rows with hcfirst >= 256000\n",
    "df = df[df['hcfirst'] < 256000]\n",
    "\n",
    "# a row should have an entry for each pattern\n",
    "# if a row does not have an entry for a pattern, then remove it completely\n",
    "# remove rows that do not have all patterns\n",
    "df = df.groupby(['chip', 'CH', 'PC', 'row', 'bank']).filter(lambda x: len(x['pattern'].unique()) == 4)\n",
    "\n",
    "# group by chip, channel, pc, bank, row\n",
    "# for each group, find the pattern that maximizes hcfirst\n",
    "# create a new dataframe with the following columns: chip, channel, pc, bank, row, pattern, ber\n",
    "df_worst_case = df.groupby(['chip', 'CH', 'PC', 'bank', 'row'])[['pattern', 'hcfirst']].min().reset_index()\n",
    "\n",
    "df_worst_case.reset_index(drop=True, inplace=True)\n",
    "\n",
    "\n",
    "# rename pattern values with \"WCDP\"\n",
    "df_worst_case['pattern'] = df_worst_case['pattern'].map(lambda x: 'WCDP')\n",
    "\n",
    "# add df_worst_case to df\n",
    "df = pd.concat([df, df_worst_case], ignore_index=True)\n",
    "\n",
    "\n",
    "hcf_chip_ch = df.copy()\n",
    "\n",
    "# flatten the multi-index\n",
    "hcf_chip_ch.reset_index(inplace=True)\n",
    "\n",
    "# select only chip, channel and bitflips\n",
    "hcf_chip_ch = hcf_chip_ch[['chip', 'CH', 'pattern', 'hcfirst', 'row', 'bank', 'PC']]\n",
    "\n",
    "# order chips\n",
    "chip_order = ['Chip 0', 'Chip 1', 'Chip 2', 'Chip 3', 'Chip 4', 'Chip 5']\n",
    "# apply this order\n",
    "hcf_chip_ch['chip'] = pd.Categorical(hcf_chip_ch['chip'], chip_order)\n",
    "\n",
    "# order for the pattern column is:\n",
    "pattern_order = ['FF', '00', 'AA', '55', 'WCDP']\n",
    "# apply this order\n",
    "hcf_chip_ch['pattern'] = pd.Categorical(hcf_chip_ch['pattern'], pattern_order)\n",
    "\n",
    "# sort by pattern, chip, channel\n",
    "hcf_chip_ch.sort_values(by=['pattern', 'chip', 'CH'], inplace=True)\n",
    "\n",
    "# create a subplot for each chip\n",
    "fig, axes = plt.subplots(nrows=len(hcf_chip_ch['chip'].unique()), figsize=(8.1, 2.0*len(hcf_chip_ch['chip'].unique())))\n",
    "\n",
    "data_patterns = {\n",
    "  0: \"Rowstripe0\",\n",
    "  1: \"Rowstripe1\",\n",
    "  2: \"Checkered0\",\n",
    "  3: \"Checkered1\",\n",
    "  4: \"WCDP\"\n",
    "}\n",
    "\n",
    "# create a bar plot for each chip\n",
    "for chip, ax in zip(hcf_chip_ch['chip'].unique(), axes):\n",
    "  sns.boxplot(x='pattern', y='hcfirst', data=hcf_chip_ch[hcf_chip_ch['chip'] == chip], ax=ax, showfliers=False, hue=\"CH\", palette=mypalette, whis=(0,100), showmeans=True, meanprops={\"marker\":\"o\",\"markerfacecolor\":\"white\", \"markeredgecolor\":\"black\",\"markersize\":\"3\"})\n",
    "  ax.text(0.1, 0.85, chip, horizontalalignment='center', verticalalignment='center', transform=ax.transAxes, bbox=dict(facecolor='white', edgecolor='black', boxstyle='round,pad=0.5', alpha=0.5), fontsize=12)\n",
    "  ax.get_legend().remove()\n",
    "  ax.set_xlabel('')\n",
    "  ax.set_xticklabels([])\n",
    "  ax.set_xticks([])\n",
    "\n",
    "  if chip == 'Chip 0':\n",
    "    # prepend 'CH' to legend labels\n",
    "    handles, labels = ax.get_legend_handles_labels()\n",
    "    ax.legend(handles, ['CH' + label for label in labels], loc='upper center', title='Channel', ncol=8, bbox_to_anchor=(0.5, 1.5), fancybox=True, shadow=True, columnspacing=0.5)\n",
    "  if chip == 'Chip 5':\n",
    "    ax.set_xticks(range(5))\n",
    "    ax.set_xticklabels([data_patterns[i] for i in range(5)])\n",
    "    ax.set_xlabel('Data pattern')\n",
    "\n",
    "  ax.set_yticks([x * 40000 for x in range(7)])\n",
    "  ax.set_yticklabels([str(int(int(t) / 1000))+\"K\" if t > 0 else \"0\" for t in ax.get_yticks()])\n",
    "  ax.set_ylabel('')\n",
    "\n",
    "  # Put grid lines in the background\n",
    "  ax.set_axisbelow(True)\n",
    "  # # put a shade on the background of worst case\n",
    "  shade_gray = 0.8\n",
    "  ax.axvspan(3.5, 4.5, facecolor=(shade_gray,shade_gray,shade_gray), alpha=0.2)\n",
    "  ax.axvline(3.5, color='black', linestyle='dashed')\n",
    "  ax.set_xlim(-0.5, 4.5)\n",
    "  ax.grid(color='gray', linestyle='dashed')\n",
    "\n",
    "  # Put grid lines only on y-axis\n",
    "  ax.xaxis.grid(False)\n",
    "\n",
    "fig.subplots_adjust(hspace=0.15)\n",
    "    \n",
    "\n",
    "# add text as y axis label that spans all subplots\n",
    "fig.text(0.04, 0.5, 'Minimum Hammer Count to Induce the First Bitflip ($HC_{first}$)', va='center', rotation='vertical', fontsize=12)\n",
    "\n",
    "# save plot\n",
    "fig.savefig('figure7-new.pdf', bbox_inches='tight')\n",
    "\n",
    "# minimum hcfirst across everything\n",
    "min_hcfirst = df['hcfirst'].min()\n",
    "print(\"Minimum hcfirst across everything: {}\".format(min_hcfirst))\n",
    "\n",
    "# mean hcfirst for Rowstripe0 in chip 1 channel 0\n",
    "mean_hcfirst = df[(df['chip'] == 'Chip 1') & (df['CH'] == 0) & (df['pattern'] == 'FF')]['hcfirst'].median()\n",
    "print(\"Mean hcfirst for Rowstripe0 in chip 1 channel 0: {}\".format(mean_hcfirst))\n",
    "\n",
    "# mean hcfirst for Rowstripe1 in chip 1 channel 0\n",
    "mean_hcfirst = df[(df['chip'] == 'Chip 1') & (df['CH'] == 0) & (df['pattern'] == '00')]['hcfirst'].median()\n",
    "print(\"Mean hcfirst for Rowstripe1 in chip 1 channel 0: {}\".format(mean_hcfirst))\n",
    "\n",
    "fig = plt.figure(figsize=(8.1, 2.0))\n",
    "\n",
    "sns.boxplot(x='pattern', y='hcfirst', hue='chip', data=hcf_chip_ch, whis=(0,100), showmeans=True, meanprops={\"marker\":\"o\",\"markerfacecolor\":\"white\", \"markeredgecolor\":\"black\",\"markersize\":\"3\"}, palette=sns.color_palette(\"Set2\", 6))\n",
    "\n",
    "# get figure's ax\n",
    "fig = plt.gca()\n",
    "\n",
    "# move legend above figure\n",
    "handles, labels = fig.get_legend_handles_labels()\n",
    "fig.legend(handles, labels, loc='upper center', title='Chip', ncol=6, bbox_to_anchor=(0.5, 1.4), fancybox=True, shadow=True, columnspacing=0.5)\n",
    "\n",
    "fig.set_xticks(range(5))\n",
    "fig.set_xticklabels([data_patterns[i] for i in range(5)])\n",
    "fig.set_xlabel('Data pattern')\n",
    "fig.set_ylabel('Minimum Hammer Count\\nto Induce the First Bitflip')\n",
    "# ax.set_title('Bank {}'.format(b))\n",
    "# put horizontal grid lines in the background\n",
    "fig.set_axisbelow(True)\n",
    "shade_gray = 0.8\n",
    "fig.axvspan(3.5, 4.5, facecolor=(shade_gray,shade_gray,shade_gray), alpha=0.2)\n",
    "fig.axvline(3.5, color='black', linestyle='dashed')\n",
    "fig.set_xlim(-0.5, 4.5)\n",
    "fig.yaxis.grid(color='gray', linestyle='dashed')\n",
    "fig.set_yticks([x * 40000 for x in range(7)])\n",
    "fig.set_yticklabels([str(int(int(t) / 1000))+\"K\" if t > 0 else \"0\" for t in fig.get_yticks()])\n",
    "\n",
    "# save plot\n",
    "plt.savefig('figure5-new.pdf', bbox_inches='tight')\n",
    "\n",
    "\n",
    "print('Minimum hcfirst across everything: {:.0f}'.format(hcf_chip_ch['hcfirst'].min()))\n",
    "print('This hcfirst comes from chip {} and pattern {}'.format(hcf_chip_ch[hcf_chip_ch['hcfirst'] == hcf_chip_ch['hcfirst'].min()]['chip'].values[0], hcf_chip_ch[hcf_chip_ch['hcfirst'] == hcf_chip_ch['hcfirst'].min()]['pattern'].values[0]))\n",
    "print('Minimum hcfirst across everything takes {:.0f} microseconds'.format(hcf_chip_ch['hcfirst'].min()*45.0*2/1000)) # 45 taken from oconnor thesis\n",
    "\n",
    "# min HCfirst in each chip (for all patterns)\n",
    "print('Chip 0 min HCfirst for all patterns: {:.0f}'.format(hcf_chip_ch[hcf_chip_ch['chip'] == 'Chip 0']['hcfirst'].min()))\n",
    "print('Chip 1 min HCfirst for all patterns: {:.0f}'.format(hcf_chip_ch[hcf_chip_ch['chip'] == 'Chip 1']['hcfirst'].min()))\n",
    "print('Chip 2 min HCfirst for all patterns: {:.0f}'.format(hcf_chip_ch[hcf_chip_ch['chip'] == 'Chip 2']['hcfirst'].min()))\n",
    "print('Chip 3 min HCfirst for all patterns: {:.0f}'.format(hcf_chip_ch[hcf_chip_ch['chip'] == 'Chip 3']['hcfirst'].min()))\n",
    "print('Chip 4 min HCfirst for all patterns: {:.0f}'.format(hcf_chip_ch[hcf_chip_ch['chip'] == 'Chip 4']['hcfirst'].min()))\n",
    "print('Chip 5 min HCfirst for all patterns: {:.0f}'.format(hcf_chip_ch[hcf_chip_ch['chip'] == 'Chip 5']['hcfirst'].min()))\n",
    "\n",
    "# the row with the min HCfirst for each chip\n",
    "chip4_df = hcf_chip_ch[hcf_chip_ch['chip'] == 'Chip 4']\n",
    "print('This hcfirst comes from row {} in Chip 4'.format(chip4_df[chip4_df['hcfirst'] == chip4_df['hcfirst'].min()][['row', 'bank', 'CH', 'PC']].values))\n",
    "\n",
    "# and in chip 2\n",
    "chip2_df = hcf_chip_ch[hcf_chip_ch['chip'] == 'Chip 2']\n",
    "print('This hcfirst comes from row {} in Chip 2'.format(chip2_df[chip2_df['hcfirst'] == chip2_df['hcfirst'].min()][['row', 'bank', 'CH', 'PC']].values))\n",
    "\n",
    "# Chip 2 and Chip 5 mean hcfirst for Rowstripe0\n",
    "print('Chip 2 max HCfirst for Checkered 0: {:.0f}'.format(hcf_chip_ch[(hcf_chip_ch['pattern'] == 'FF') & (hcf_chip_ch['chip'] == 'Chip 2')]['hcfirst'].mean()))\n",
    "print('Chip 5 max HCfirst for Checkered 0: {:.0f}'.format(hcf_chip_ch[(hcf_chip_ch['pattern'] == 'FF') & (hcf_chip_ch['chip'] == 'Chip 5')]['hcfirst'].mean()))\n",
    "print(104548/94540)\n",
    "#fig.set_ylim(0, 3.2)\n",
    "#fig.set_yticks([0, 0.4, 0.8, 1.2, 1.6, 2.0, 2.4, 2.8, 3.2])\n",
    "# fig.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))\n",
    "# remove legend\n",
    "# ax.set_yticklabels([str(x*100) for x in ax.get_yticks()])\n",
    "\n",
    "# group by chip, CH. find minimum hcfirst. then add those to the dataframe\n",
    "\n",
    "minhcfs = hcf_chip_ch.groupby(['chip','CH'])['hcfirst'].min().reset_index().groupby('chip')['hcfirst'].min().reset_index()\n",
    "maxhcfs = hcf_chip_ch.groupby(['chip','CH'])['hcfirst'].min().reset_index().groupby('chip')['hcfirst'].max().reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "from matplotlib.ticker import FormatStrFormatter\n",
    "\n",
    "# giray's style\n",
    "scale_factor = 16\n",
    "\n",
    "colors = sns.color_palette(\"plasma\", 4 * scale_factor)\n",
    "\n",
    "ext_colors = []\n",
    "i = 0 \n",
    "while i < 4:\n",
    "    c = colors[i*scale_factor]\n",
    "    cn = tuple([cc * 0.9 for cc in c])\n",
    "    ext_colors.append(cn)\n",
    "    ext_colors.append(c)\n",
    "    i+=1\n",
    "\n",
    "print(ext_colors)\n",
    "\n",
    "ext_colors = [ext_colors[0], ext_colors[6], ext_colors[4]]\n",
    "\n",
    "mypalette = sns.color_palette(ext_colors)\n",
    "\n",
    "shade_gray = 0.8\n",
    "shade_red = 0.8\n",
    "shade_alpha = 0.5\n",
    "\n",
    "mypalette\n",
    "\n",
    "# read all csv files in this folder and concatenate them into one dataframe\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import re\n",
    "import os\n",
    "\n",
    "host_machines = [\n",
    "  'safari-fpga37',\n",
    "  'safari-fpga55',\n",
    "  'safari-fpga56-new',\n",
    "  'safari-fpga57',\n",
    "  'safari-fpga58',\n",
    "  'safari-fpga59'\n",
    "]\n",
    "\n",
    "rows_tested_for_bitflips = 3072\n",
    "\n",
    "dfs = []\n",
    "\n",
    "# Loop over all CSV files in the directory\n",
    "for host_machine in host_machines:\n",
    "  dir_path = './' + 'fast_forward_data/' + host_machine\n",
    "  for filename in os.listdir(dir_path):\n",
    "    if filename.startswith('rows_only_rowhammer') and 'tAggOn' not in filename:\n",
    "      tokens = filename.split('_')\n",
    "      ch_num = int(tokens[4])\n",
    "      if ch_num > 10:\n",
    "        continue\n",
    "      pc_num = int(tokens[6])\n",
    "      if pc_num > 0:\n",
    "        continue\n",
    "      bank_num = int(tokens[8])\n",
    "      if bank_num > 0:\n",
    "        continue\n",
    "      pattern = tokens[10].split('.')[0]\n",
    "      # create a dataframe from the csv file\n",
    "      df = pd.read_csv(dir_path + '/' + filename)\n",
    "      # add the channel, pc, bank and pattern numbers as columns\n",
    "      df['CH'] = ch_num\n",
    "      df['PC'] = pc_num\n",
    "      df['bank'] = bank_num\n",
    "      df['pattern'] = pattern\n",
    "      df['machine'] = host_machine\n",
    "      # append the dataframe to the list\n",
    "      dfs.append(df)\n",
    "\n",
    "# Concatenate all dataframes into one\n",
    "df = pd.concat(dfs, ignore_index=True)\n",
    "\n",
    "# map the channels by decrementing them by 8\n",
    "df['CH'] = df['CH'].map(lambda x: x - 8)\n",
    "\n",
    "# rename machine using the following map\n",
    "machine_map = {\n",
    "  'safari-fpga37': 'Chip 0',\n",
    "  'safari-fpga55': 'Chip 1',\n",
    "  'safari-fpga56-new': 'Chip 2',\n",
    "  'safari-fpga57': 'Chip 3',\n",
    "  'safari-fpga58': 'Chip 4',\n",
    "  'safari-fpga59': 'Chip 5'\n",
    "}\n",
    "df['machine'] = df['machine'].map(machine_map)\n",
    "\n",
    "pattern_map = {\n",
    "  '0': '00',\n",
    "  '1': 'FF',\n",
    "  '2': '55',\n",
    "  '3': 'AA'\n",
    "}\n",
    "\n",
    "# modify pattern column only if the pattern is not one of the values in the map\n",
    "df['pattern'] = df['pattern'].map(lambda x: pattern_map[x] if x in pattern_map else x)\n",
    "\n",
    "# rename machine column to chip\n",
    "df.rename(columns={'machine': 'chip'}, inplace=True)\n",
    "\n",
    "# rename row_errors to bitflips\n",
    "df.rename(columns={'row_errors': 'bitflips'}, inplace=True)\n",
    "\n",
    "df['bitflips'] = df['bitflips'] / 5\n",
    "\n",
    "# create bit error rate column \n",
    "# ber = bitflips / row size (1024*8)\n",
    "df['ber'] = df['bitflips'] / (1024*8) * 100\n",
    "\n",
    "# group by chip, channel, pc, bank, row\n",
    "# for each group, find the pattern that maximizes ber\n",
    "# create a new dataframe with the following columns: chip, channel, pc, bank, row, pattern, ber\n",
    "df_worst_case = df.groupby(['chip', 'CH', 'PC', 'bank', 'row'])[['pattern', 'ber']].max().reset_index()\n",
    "\n",
    "df_worst_case.reset_index(drop=True, inplace=True)\n",
    "\n",
    "# rename pattern values with \"WCDP\"\n",
    "df_worst_case['pattern'] = df_worst_case['pattern'].map(lambda x: 'WCDP')\n",
    "\n",
    "# add df_worst_case to df\n",
    "df = pd.concat([df, df_worst_case], ignore_index=True)\n",
    "\n",
    "df\n",
    "\n",
    "FAST = True # create the plot faster\n",
    "PATTERN = 'WCDP' # use this data pattern\n",
    "BANK = 0\n",
    "PC = 0\n",
    "\n",
    "sample_size = 32\n",
    "\n",
    "# find row'ids where ber is 0 for chip 0\n",
    "df_zero_ber = df[(df['chip'] == 'Chip 0') & (df['ber'] <= 0.1) & (df['pattern'] == PATTERN) & (df['bank'] == BANK) & (df['PC'] == PC)]\n",
    "sorted_boundaries = sorted(df_zero_ber['row'].unique())\n",
    "\n",
    "\n",
    "# pick every other row id from the sorted list\n",
    "# this will be used to draw vertical lines on the plot\n",
    "boundaries = [sorted_boundaries[i] for i in range(len(sorted_boundaries)) if i % 2 == 0]\n",
    "boundaries.append(0)\n",
    "\n",
    "sa_pattern_df = df.copy()\n",
    "\n",
    "fig, axes = plt.subplots(nrows=len(sa_pattern_df['chip'].unique()),figsize=(8.1,1.35*len(sa_pattern_df['chip'].unique())))\n",
    "\n",
    "# reduce the number of rows to plot by taking the average of 8 row's ber\n",
    "sa_pattern_df['row'] = sa_pattern_df['row'] // sample_size\n",
    "\n",
    "if FAST:\n",
    "  sa_pattern_df = sa_pattern_df.groupby(['chip', 'CH', 'PC', 'bank', 'row', 'pattern'])['ber'].mean().reset_index()\n",
    "\n",
    "for chip, ax in zip(sa_pattern_df['chip'].unique(), axes):\n",
    "  if FAST:\n",
    "    sns.lineplot(x=\"row\", y=\"ber\", hue=\"CH\", data=sa_pattern_df[(sa_pattern_df['chip'] == chip) & (sa_pattern_df['pattern'] == PATTERN) & (sa_pattern_df['bank'] == BANK) & (sa_pattern_df['PC'] == PC)], palette=mypalette, ax = ax, ci=None)\n",
    "  else:\n",
    "    sns.lineplot(x=\"row\", y=\"ber\", hue=\"CH\", data=sa_pattern_df[(sa_pattern_df['chip'] == chip) & (sa_pattern_df['pattern'] == PATTERN) & (sa_pattern_df['bank'] == BANK) & (sa_pattern_df['PC'] == PC)], palette=mypalette, ax = ax)\n",
    "  ax.text(0.037, 0.5, chip, horizontalalignment='center', verticalalignment='center', transform=ax.transAxes, bbox=dict(facecolor='white', edgecolor='black', boxstyle='round,pad=0.5', alpha=0.5), fontsize=12, rotation=90)\n",
    "  ax.get_legend().remove()\n",
    "  ax.set_xlabel('')\n",
    "  ax.set_xticklabels([])\n",
    "  ax.set_xticks([])\n",
    "\n",
    "  if chip == 'Chip 0':\n",
    "    # prepend 'CH' to legend labels\n",
    "    handles, labels = ax.get_legend_handles_labels()\n",
    "    ax.legend(handles, ['CH' + label for label in labels], loc='upper center', title='Channel', ncol=8, bbox_to_anchor=(0.5, 1.7), fancybox=True, shadow=True, columnspacing=0.5)\n",
    "  if chip == 'Chip 5':\n",
    "    ax.set_xticks([-1, 16383/sample_size-1])\n",
    "    ax.set_xticklabels([0, 16383])\n",
    "    # rotate xtick labels\n",
    "    # for tick in ax.get_xticklabels():\n",
    "    #   tick.set_rotation(45)      \n",
    "    ax.set_xlabel('Row ID')\n",
    "\n",
    "  #ax.set_ylabel('RowHammer BER (%)')\n",
    "  ax.set_ylabel('')\n",
    "\n",
    "  #ax.set_ylim(0.2, 2.2)\n",
    "  #ax.set_yticks([0.3, 0.6, 0.9, 1.2, 1.5, 1.8, 2.1])\n",
    "  #ax.set_yticks([0.3, 0.9, 1.5, 2.1])\n",
    "  # find the largest and smallest y values in the plot\n",
    "  ymax = max(ax.get_ylim())\n",
    "  ymin = min(ax.get_ylim())\n",
    "  # set the y limit to the largest y value\n",
    "  ax.set_ylim(ymin-0.1, ymax+0.1)\n",
    "  \n",
    "  # if the avg of ymin and ymax can be expressed with 1 decimal place, use it\n",
    "  if (ymin+ymax)/2 == round((ymin+ymax)/2, 1):\n",
    "    ax.set_yticks([ymin, (ymin+ymax)/2, ymax])\n",
    "  else:\n",
    "    # if not, use 2 decimal places\n",
    "    ax.set_yticks([ymin, round((ymin+ymax)/2, 2), ymax])\n",
    "\n",
    "  ax.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))\n",
    "\n",
    "  ax.set_xlim(-40, (16384/sample_size)+8)\n",
    "  \n",
    "  # ax.set_xlim(0, 1000)\n",
    "\n",
    "  ax.grid(color='gray', linestyle='dashed')\n",
    "  # Put grid lines only on y-axis\n",
    "  ax.xaxis.grid(False)\n",
    "\n",
    "  # # draw vertical lines\n",
    "  for boundary in boundaries:\n",
    "    ax.axvline(x=(boundary/sample_size) - 1, color='black', linestyle='dashed', linewidth=0.5)\n",
    "\n",
    "  ax.axvspan(boundaries[2]/sample_size, boundaries[3]/sample_size, facecolor=(0,1,0), alpha=0.2)\n",
    "  if chip == 'Chip 0':\n",
    "    ax.text((boundaries[2]/sample_size + boundaries[3]/sample_size) / 2, (ymax+ymin)/2 - (ymax-ymin)/2.5, \"SA X\", horizontalalignment='center', verticalalignment='center', fontsize=8, color='green')\n",
    "  ax.axvspan(boundaries[6]/sample_size, boundaries[7]/sample_size, facecolor=(0,0,1), alpha=0.2)\n",
    "  if chip == 'Chip 0':\n",
    "    ax.text((boundaries[6]/sample_size + boundaries[7]/sample_size) / 2, (ymax+ymin)/2  - (ymax-ymin)/2.5, \"SA Y\", horizontalalignment='center', verticalalignment='center', fontsize=8, color='blue')\n",
    "\n",
    "  ax.axvspan(boundaries[8]/sample_size, boundaries[9]/sample_size - 1, facecolor=(1,0.2,0.2), alpha=0.2)\n",
    "  ax.axvspan(boundaries[18]/sample_size, boundaries[19]/sample_size - 1, facecolor=(1,0.2,0.2), alpha=0.2)\n",
    "\n",
    "\n",
    "fig.subplots_adjust(hspace=0.15)\n",
    "fig.text(0.04, 0.5, 'RowHammer Bit Error Rate (%)', va='center', rotation='vertical', fontsize=12)\n",
    "\n",
    "fig.savefig('figure8-new.pdf', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "from matplotlib.ticker import FormatStrFormatter\n",
    "\n",
    "# giray's style\n",
    "scale_factor = 16\n",
    "\n",
    "colors = sns.color_palette(\"plasma\", 4 * scale_factor)\n",
    "\n",
    "ext_colors = []\n",
    "i = 0 \n",
    "while i < 4:\n",
    "    c = colors[i*scale_factor]\n",
    "    cn = tuple([cc * 0.9 for cc in c])\n",
    "    ext_colors.append(cn)\n",
    "    ext_colors.append(c)\n",
    "    i+=1\n",
    "\n",
    "print(ext_colors)\n",
    "\n",
    "ext_colors = [ext_colors[0], ext_colors[2], ext_colors[4], ext_colors[6], ext_colors[7], ext_colors[5], ext_colors[3], ext_colors[1]]\n",
    "\n",
    "mypalette = sns.color_palette(ext_colors)\n",
    "\n",
    "mypalette\n",
    "\n",
    "# read all csv files in this folder and concatenate them into one dataframe\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import re\n",
    "import os\n",
    "\n",
    "host_machines = [\n",
    "  'safari-fpga37',\n",
    "  'safari-fpga55',\n",
    "  'safari-fpga56-new',\n",
    "  'safari-fpga57',\n",
    "  'safari-fpga58',\n",
    "  'safari-fpga59'\n",
    "]\n",
    "\n",
    "dfs = []\n",
    "\n",
    "# Loop over all CSV files in the directory\n",
    "for host_machine in host_machines:\n",
    "  dir_path = './' + 'fast_forward_data/' + host_machine\n",
    "  for filename in os.listdir(dir_path):\n",
    "    if filename.startswith('hcnth') and 'wordlevel' not in filename:\n",
    "      tokens = filename.split('_')\n",
    "      ch_num = int(tokens[1].split('-')[1])\n",
    "      pc_num = int(tokens[2].split('-')[1])\n",
    "      bank_num = int(tokens[3].split('-')[1])\n",
    "      pattern = tokens[4].split('.')[0].split('-')[1]\n",
    "      print(pattern)\n",
    "      # create a dataframe from the csv file\n",
    "      df = pd.read_csv(dir_path + '/' + filename)\n",
    "      # add the channel, pc, bank and pattern numhcfirsts as columns\n",
    "      df['CH'] = ch_num\n",
    "      df['PC'] = pc_num\n",
    "      df['bank'] = bank_num\n",
    "      df['pattern'] = pattern\n",
    "      df['machine'] = host_machine\n",
    "      # append the dataframe to the list\n",
    "      dfs.append(df)\n",
    "\n",
    "# Concatenate all dataframes into one\n",
    "df = pd.concat(dfs, ignore_index=True)\n",
    "\n",
    "# map the channels by decrementing them by 8\n",
    "df['CH'] = df['CH'].map(lambda x: x - 8)\n",
    "\n",
    "# rename machine using the following map\n",
    "machine_map = {\n",
    "  'safari-fpga37': 'Chip 0',\n",
    "  'safari-fpga55': 'Chip 1',\n",
    "  'safari-fpga56-new': 'Chip 2',\n",
    "  'safari-fpga57': 'Chip 3',\n",
    "  'safari-fpga58': 'Chip 4',\n",
    "  'safari-fpga59': 'Chip 5'\n",
    "}\n",
    "df['machine'] = df['machine'].map(machine_map)\n",
    "\n",
    "pattern_map = {\n",
    "  '0': '00',\n",
    "  '1': 'FF',\n",
    "  '2': '55',\n",
    "  '3': 'AA'\n",
    "}\n",
    "\n",
    "# modify pattern column only if the pattern is not one of the values in the map\n",
    "df['pattern'] = df['pattern'].map(lambda x: pattern_map[x] if x in pattern_map else x)\n",
    "\n",
    "# rename machine column to chip\n",
    "df.rename(columns={'machine': 'chip'}, inplace=True)\n",
    "\n",
    "# rename hc to hcnth and hcnth to hc\n",
    "df.rename(columns={'hc': 'hcnth', 'hcnth': 'hc'}, inplace=True)\n",
    "\n",
    "# remove rows where hc is non-numeric\n",
    "df = df[df['hc'].apply(lambda x: str(x).isnumeric())]\n",
    "\n",
    "# convert hc to int and hcnth to int\n",
    "df['hc'] = df['hc'].astype(int)\n",
    "df['hcnth'] = df['hcnth'].astype(int)\n",
    "\n",
    "hcf_chip_ch = df.copy()\n",
    "\n",
    "# flatten the multi-index\n",
    "hcf_chip_ch.reset_index(inplace=True)\n",
    "\n",
    "# select only chip, channel and bitflips\n",
    "hcf_chip_ch = hcf_chip_ch[['chip', 'CH', 'pattern', 'hc', 'hcnth', 'row']]\n",
    "\n",
    "# remove rows where CH is not 1 or 6\n",
    "hcf_chip_ch = hcf_chip_ch[(hcf_chip_ch['CH'] == 1) | (hcf_chip_ch['CH'] == 6)]\n",
    "\n",
    "# remove \"0x\" from patterns\n",
    "hcf_chip_ch['pattern'] = hcf_chip_ch['pattern'].str.replace('0x', '')\n",
    "\n",
    "# based on row, create 3 categories\n",
    "# cat1: rows < 64\n",
    "# cat2: rows < 8256\n",
    "# cat3: rows < 16384\n",
    "hcf_chip_ch['row'] = hcf_chip_ch['row'].astype(int)\n",
    "hcf_chip_ch['row_cat'] = pd.cut(hcf_chip_ch['row'], bins=[0, 64, 8256, 16384], labels=['cat1', 'cat2', 'cat3'])\n",
    "\n",
    "print(hcf_chip_ch)\n",
    "\n",
    "# order chips\n",
    "chip_order = ['Chip 0', 'Chip 1', 'Chip 2', 'Chip 3', 'Chip 4', 'Chip 5']\n",
    "# apply this order\n",
    "hcf_chip_ch['chip'] = pd.Categorical(hcf_chip_ch['chip'], chip_order)\n",
    "\n",
    "# order for the pattern column is:\n",
    "pattern_order = ['FF', '00', 'AA', '55']\n",
    "# apply this order\n",
    "hcf_chip_ch['pattern'] = pd.Categorical(hcf_chip_ch['pattern'], pattern_order)\n",
    "\n",
    "# sort by pattern, chip, channel\n",
    "hcf_chip_ch.sort_values(by=['pattern', 'chip', 'CH'], inplace=True)\n",
    "\n",
    "# create a subplot for each chip\n",
    "fig = plt.plot(figsize=(8.1, 2.0))\n",
    "\n",
    "data_patterns = {\n",
    "  0: \"Rowstripe0\",\n",
    "  1: \"Rowstripe1\",\n",
    "  2: \"Checkered0\",\n",
    "  3: \"Checkered1\"\n",
    "}\n",
    "\n",
    "sns.boxplot(x='hcnth', y='hc', data=hcf_chip_ch[hcf_chip_ch['chip'] == chip], showfliers=False, hue=\"row_cat\", palette=mypalette, whis=(0,100), showmeans=True, meanprops={\"marker\":\"o\",\"markerfacecolor\":\"white\", \"markeredgecolor\":\"black\",\"markersize\":\"3\"})\n",
    "\n",
    "# we are working on df hcf_chip_ch\n",
    "# group by chip, CH, pattern, row, row_cat. copy the hc for hcnth = 1 in each group to a new column in the df called hc_baseline\n",
    "\n",
    "newdf = hcf_chip_ch.groupby(['chip', 'CH', 'pattern', 'row', 'row_cat'], group_keys=True).apply(lambda x: x[x['hcnth'] == 1]['hc']).reset_index().rename(columns={0: 'hc_baseline'})\n",
    "\n",
    "# merge the newdf with the original df\n",
    "newdf2 = pd.merge(hcf_chip_ch, newdf, on=['chip', 'CH', 'pattern', 'row', 'row_cat'], how='left')\n",
    "\n",
    "newdf2.rename(columns={'hc_y':'Baseline HC', 'hc_x':'hc'}, inplace=True)\n",
    "\n",
    "# remove column level_5\n",
    "newdf2.drop('level_5', axis=1, inplace=True)\n",
    "\n",
    "# divide hc by Baseline HC\n",
    "\n",
    "newdf2['hcratio'] = newdf2['hc'].astype(float)/newdf2['Baseline HC'].astype(float)\n",
    "\n",
    "fig = plt.figure(figsize=(8.1, 2.0))\n",
    "\n",
    "# order for the pattern column is:\n",
    "pattern_order = ['FF', '00', 'AA', '55']\n",
    "# apply this order\n",
    "newdf2['pattern'] = pd.Categorical(newdf2['pattern'], pattern_order)\n",
    "\n",
    "data_patterns = {\n",
    "  0: \"Rowstripe0\",\n",
    "  1: \"Rowstripe1\",\n",
    "  2: \"Checkered0\",\n",
    "  3: \"Checkered1\"\n",
    "}\n",
    "\n",
    "# plot mean hcratio\n",
    "sns.boxplot(x='hcnth', y='hcratio', data=newdf2, showfliers=False, hue=\"pattern\", palette=mypalette, showmeans=True, meanprops={\"marker\":\"o\",\"markerfacecolor\":\"white\", \"markeredgecolor\":\"black\",\"markersize\":\"3\"}, whis=(0,100))\n",
    "\n",
    "# rename y axis label\n",
    "plt.ylabel('Hammer Count\\nNormalized to $HC_{first}$', fontsize=12)\n",
    "\n",
    "# rename x axis label\n",
    "# plt.xlabel('Unique bitflip in the same row', fontsize=12)\n",
    "\n",
    "# place legend top left of plot\n",
    "plt.legend(loc='upper left', bbox_to_anchor=(0.0, 1.0), ncol=1, fontsize=12)\n",
    "\n",
    "# rename legend labels with data_patterns\n",
    "handles, labels = plt.gca().get_legend_handles_labels()\n",
    "plt.legend(handles, [data_patterns[pattern_order.index(i)] for i in labels], loc='center right', bbox_to_anchor=(1.22, 0.5), ncol=1, fontsize=9, title=\"Data Pattern\")\n",
    "\n",
    "# draw red dashed line at y=1\n",
    "plt.axhline(y=1, color='red', linestyle='--')\n",
    "\n",
    "new_xaxislabels=[\n",
    "    '$HC_{first}$',\n",
    "    '$HC_{second}$',\n",
    "    '$HC_{third}$',\n",
    "    '$HC_{fourth}$',\n",
    "    '$HC_{fifth}$',\n",
    "    '$HC_{sixth}$',\n",
    "    '$HC_{seventh}$',\n",
    "    '$HC_{eighth}$',\n",
    "    '$HC_{ninth}$',\n",
    "    '$HC_{tenth}$'\n",
    "]\n",
    "\n",
    "new_xaxislables2=[\n",
    "    '$HC_{1^{st}}$',\n",
    "    '$HC_{2^{nd}}$',\n",
    "    '$HC_{3^{rd}}$',\n",
    "    '$HC_{4^{th}}$',\n",
    "    '$HC_{5^{th}}$',\n",
    "    '$HC_{6^{th}}$',\n",
    "    '$HC_{7^{th}}$',\n",
    "    '$HC_{8^{th}}$',\n",
    "    '$HC_{9^{th}}$',\n",
    "    '$HC_{10^{th}}$'\n",
    "]\n",
    "\n",
    "# set x-axis tick labels\n",
    "plt.xticks(np.arange(0, 10, 1), new_xaxislables2, fontsize=10)\n",
    "\n",
    "# remove x axis label\n",
    "plt.xlabel('')\n",
    "\n",
    "# point to the red line with text saying $HC_{first}$\n",
    "# plt.annotate('$HC_{first}$', xy=(-0.5, 1.0), xytext=(0.12, 1.8), arrowprops=dict(facecolor='red', shrink=0.01), fontsize=12, color='red', ha='center', va='center')\n",
    "plt.gca().get_xticklabels()[0].set_color('red')\n",
    "\n",
    "# color first y-axis tick red\n",
    "plt.gca().get_yticklabels()[1].set_color('red')\n",
    "\n",
    "# draw major grid lines only for y-axis\n",
    "plt.grid(axis='y', which='major', color='black', linestyle='dotted', linewidth=0.5)\n",
    "\n",
    "# save figure as \"hcnth_plot.pdf\"\n",
    "plt.savefig('figure10-new.pdf', bbox_inches='tight')\n",
    "\n",
    "# smallest HC10th value\n",
    "print(\"Smallest HC ratio 10th value: \" + str(newdf2[newdf2['hcnth'] == 10]['hcratio'].min()))\n",
    "print(\"Highest HC ratio 10th value: \" + str(newdf2[newdf2['hcnth'] == 10]['hcratio'].max()))\n",
    "\n",
    "print(\"Average HCratio2nd, HCratio4th, HCratio8th and HCratio10th\", newdf2[(newdf2['hcnth'].isin([2, 4, 8, 10]))&(newdf2['pattern']=='00')].groupby('hcnth')['hcratio'].mean())\n",
    "\n",
    "print(\"Average HCtenth for data patterns\", newdf2[(newdf2['hcnth']==10)].groupby('pattern')['hcratio'].mean())\n",
    "\n",
    "newdf2\n",
    "import numpy as np\n",
    "# import stats\n",
    "from scipy import stats\n",
    "import matplotlib.ticker as ticker\n",
    "\n",
    "\n",
    "\n",
    "# select Chip 0, CH 1, pattern FF\n",
    "# filtered = newdf2[(newdf2['chip'] == 'Chip 0') & (newdf2['CH'] == 1) & (newdf2['pattern'] == 'FF')]\n",
    "filtered = newdf2.copy()\n",
    "# sort by Baseline HC\n",
    "filtered.sort_values(by=['Baseline HC'])\n",
    "\n",
    "# select hcnth = 1 and 10\n",
    "f2 = filtered[(filtered['hcnth'] == 1) | (filtered['hcnth'] == 10)]\n",
    "\n",
    "# sort f2 by hcratio\n",
    "f2 = f2.sort_values(by=['hcratio'])\n",
    "\n",
    "# remove hcnth = 1 from f2\n",
    "f2 = f2[f2['hcnth'] != 1]\n",
    "fig.clf()\n",
    "fig,ax = plt.subplots(figsize=(9, 6), ncols=2, nrows=3)\n",
    "\n",
    "# f2 add column is hc - hcfirst\n",
    "f2['additional'] = f2['hc'] - f2['Baseline HC']\n",
    "\n",
    "# for all chips\n",
    "for r in range(0, 3):\n",
    "    for c in range(0, 2):\n",
    "        chip_id = r*2 + c\n",
    "        # select chip i\n",
    "        f3 = f2[f2['chip'] == 'Chip ' + str(chip_id)]\n",
    "               # highlight the region with 90% of the plotted population\n",
    "        # get the 90% quantile of hcratio\n",
    "        q = f3['hcratio'].quantile(0.99)\n",
    "        # get the 90% quantile of Baseline HC\n",
    "        q2 = f3['Baseline HC'].quantile(0.99)\n",
    "\n",
    "        # remove outliers\n",
    "        f3 = f3[(f3['hcratio'] < q) & (f3['Baseline HC'] < q2)]\n",
    "        sns.scatterplot(ax=ax[r][c], y='additional', x='Baseline HC', data=f3, s=4, palette=mypalette, c='blue')\n",
    "        # set only the color of the circles to what i want which is orange\n",
    "\n",
    " \n",
    "\n",
    "        # plot a vertical line at x = q\n",
    "        # plt.axvline(x=q, color='red')\n",
    "        # # plot a horizontal line at y = q2\n",
    "        # plt.axhline(y=q2, color='red')\n",
    "\n",
    "        # # limit x, y axes by quartiles\n",
    "        # plt.xlim(1.0, q)\n",
    "        # plt.ylim(30000, q2)\n",
    "\n",
    "        # # limit x by max hcratio\n",
    "        # ax[r][c].set_ylim(f3['hcratio'].min()-0.1, f3['hcratio'].max() + 0.1)\n",
    "        # # limit y thhe same\n",
    "        # ax[r][c].set_xlim(f3['Baseline HC'].min() - 5000, f3['Baseline HC'].max() + 5000)\n",
    "\n",
    "        ax[r][c].set_ylim(0, 250000)\n",
    "        ax[r][c].set_xlim(40000, 220000)\n",
    "\n",
    "        # remove x axis label\n",
    "        ax[r][c].set_xlabel('')\n",
    "        # remove y axis label\n",
    "        ax[r][c].set_ylabel('')\n",
    "\n",
    "        # draw grid\n",
    "        ax[r][c].grid(True, which='both', axis='both', linestyle='--', color='black', alpha=0.25)\n",
    "\n",
    "        # fit a line to hcratio (x) and Baseline HC (y)\n",
    "        # get the slope and intercept\n",
    "        slope, intercept, r_value, p_value, std_err = stats.linregress(f3['Baseline HC'], f3['additional'])\n",
    "        ax[r][c].text(90000, 210000, 'pearson correlation coefficient = %0.2f' % (r_value), color='blue', fontsize=8)\n",
    "\n",
    "        # fit an third order curve to hcratio (x) and Baseline HC (y)\n",
    "        # get the coefficients\n",
    "        coefficients, residuals, rank, singular_values, rcond = np.polyfit(f3['Baseline HC'], f3['additional'], 3, full=True)\n",
    "        # get the polynomial\n",
    "        polynomial = np.poly1d(coefficients)\n",
    "        # get the x values\n",
    "        x_axis = sorted(f3['Baseline HC'].values)\n",
    "        # plot the polynomial\n",
    "        ax[r][c].plot(x_axis, polynomial(x_axis), 'black', label='Polynomial fit', linewidth=2)\n",
    "        ax[r][c].plot(x_axis, polynomial(x_axis), 'orange', label='Polynomial fit', linewidth=1)\n",
    "\n",
    "        # import ticker\n",
    "\n",
    "        # shorten y-axis labels by adding k\n",
    "        ax[r][c].yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, pos: '{:,.0f}'.format(x/1000) + 'k'))\n",
    "\n",
    "        # shorten x-axis labels by adding k\n",
    "        ax[r][c].xaxis.set_major_formatter(ticker.FuncFormatter(lambda x, pos: '{:,.0f}'.format(x/1000) + 'k'))\n",
    "\n",
    "        ax[r][c].text(185000, 150000, 'Chip ' + str(chip_id), color='black', bbox=dict(facecolor='white', edgecolor='black', pad=10.0, boxstyle='round,pad=0.5',alpha=0.1), fontsize=10)\n",
    "\n",
    "        # remove legend from ax\n",
    "        ax[r][c].legend().remove()\n",
    "\n",
    "# put text in the middle\n",
    "fig.text(0.5, 0.04, 'Hammer count to induce the first bitflip $(HC_{first})$', ha='center', va='center')\n",
    "\n",
    "# put text as y axis in the middle\n",
    "fig.text(0.055, 0.5, 'Additional (over $HC_{first}$) hammer count to induce the $10^{th}$ bitflip', ha='center', va='center', rotation='vertical')\n",
    "\n",
    "# reduce vertical space between subplots\n",
    "plt.subplots_adjust(hspace=0.2)\n",
    "# reduce horizontal space between subplots\n",
    "plt.subplots_adjust(wspace=0.17)\n",
    "\n",
    "# y axis is $HC_{first}$\n",
    "# plt.xlabel('Hammer count to induce the first bitflip $(HC_{first})$')\n",
    "# # x axis is Normalized hammer count to induce the $10^{th}$ bitflip\n",
    "# plt.ylabel('Hammer count to induce\\nthe $10^{th}$ bitflip (normalized to $HC_{first}$)')\n",
    "\n",
    "# save the plot\n",
    "plt.savefig('figure11-new.pdf', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "from matplotlib.ticker import FormatStrFormatter\n",
    "\n",
    "# giray's style\n",
    "scale_factor = 16\n",
    "\n",
    "colors = sns.color_palette(\"plasma\", 4 * scale_factor)\n",
    "\n",
    "ext_colors = []\n",
    "i = 0 \n",
    "while i < 4:\n",
    "    c = colors[i*scale_factor]\n",
    "    cn = tuple([cc * 0.9 for cc in c])\n",
    "    ext_colors.append(cn)\n",
    "    ext_colors.append(c)\n",
    "    i+=1\n",
    "\n",
    "print(ext_colors)\n",
    "\n",
    "ext_colors = [ext_colors[0], ext_colors[2], ext_colors[4], ext_colors[6], ext_colors[7], ext_colors[5], ext_colors[3], ext_colors[1]]\n",
    "\n",
    "mypalette = sns.color_palette(ext_colors)\n",
    "\n",
    "mypalette\n",
    "\n",
    "\n",
    "# summarize per bit data into per row\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import re\n",
    "import os\n",
    "\n",
    "host_machines = [\n",
    "  'safari-fpga37',\n",
    "  'safari-fpga55',\n",
    "  'safari-fpga56-new',\n",
    "  'safari-fpga57',\n",
    "  'safari-fpga58',\n",
    "  'safari-fpga59'\n",
    "]\n",
    "\n",
    "rows_tested_for_bitflips = 384\n",
    "\n",
    "ras_scale = [0, 1, 2, 4, 8, 16, 32, 64, 134.48, 1210.34]\n",
    "\n",
    "ras_to_microsec = [0.0333 + (x*33.333/1000) for x in ras_scale]\n",
    "\n",
    "print(ras_to_microsec)\n",
    "\n",
    "dfs = []\n",
    "\n",
    "# Loop over all CSV files in the directory\n",
    "for host_machine in host_machines:\n",
    "  dir_path = './' + 'fast_forward_data/' + host_machine\n",
    "  for filename in os.listdir(dir_path):\n",
    "    if 'aggon' in filename and 'rowpress' in filename:\n",
    "      print(filename)\n",
    "      tokens = filename.split('_')\n",
    "      ch_num = int(tokens[1].split('-')[1])\n",
    "      pc_num = int(tokens[2].split('-')[1])\n",
    "      bank_num = int(tokens[3].split('-')[1])\n",
    "      pattern = \"AA\"\n",
    "      taggon = int(tokens[5].split('-')[1].split('.')[0])\n",
    "      # create a dataframe from the csv file\n",
    "      df = pd.read_csv(dir_path + '/' + filename)\n",
    "      # add the channel, pc, bank and pattern numhcfirsts as columns\n",
    "      df['machine'] = host_machine\n",
    "      df['channel'] = ch_num\n",
    "\n",
    "      if taggon > 7:\n",
    "        rettime = \"10530\"\n",
    "        if taggon == 8:\n",
    "          rettime = \"1170\"\n",
    "        retention_file = \"retention_ch-\"+str(ch_num)+\"_pch-\"+str(pc_num)+\"_bank-\"+str(bank_num)+\"_dp-0xAA_ms-\" + rettime + \".csv\"\n",
    "        print(retention_file)\n",
    "        retention_df = pd.read_csv(dir_path + '/' + retention_file)\n",
    "\n",
    "        retention_df['machine'] = host_machine\n",
    "        retention_df['channel'] = ch_num\n",
    "        # machine, channel, pseudo_channel, bank, row, column, bit indicate position of a bitflip in both dataframes\n",
    "        # remove from df all rows that are in retention_df\n",
    "        df = df[~df[['machine', 'channel', 'pseudo_channel', 'bank', 'row', 'column', 'bit']].apply(tuple,1).isin(retention_df[['machine', 'channel', 'pseudo_channel', 'bank', 'row', 'column', 'bit']].apply(tuple,1))]\n",
    "\n",
    "      # group by machine, channel, pseudo_channel, bank, row, pattern, taggon\n",
    "      # count the entries and add the count as new column\n",
    "      df = df.groupby(['machine', 'channel', 'pseudo_channel', 'bank', 'row', 'data_pattern', 'aggon']).size().reset_index(name='count')\n",
    "      dfs.append(df)\n",
    "      # append the dataframe to the list\n",
    "\n",
    "# # Concatenate all dataframes into one\n",
    "df = pd.concat(dfs, ignore_index=True)\n",
    "\n",
    "# df = pd.read_csv('rowpress_bitflips_row_summary.csv')\n",
    "\n",
    "# map the channels by decrementing them by 8\n",
    "df['CH'] = df['channel']\n",
    "df['CH'] = df['CH'].map(lambda x: x - 8)\n",
    "\n",
    "# rename machine using the following map\n",
    "machine_map = {\n",
    "  'safari-fpga37': 'Chip 0',\n",
    "  'safari-fpga55': 'Chip 1',\n",
    "  'safari-fpga56-new': 'Chip 2',\n",
    "  'safari-fpga57': 'Chip 3',\n",
    "  'safari-fpga58': 'Chip 4',\n",
    "  'safari-fpga59': 'Chip 5'\n",
    "}\n",
    "\n",
    "df['machine'] = df['machine'].map(machine_map)\n",
    "\n",
    "pattern_map = {\n",
    "  '170': 'AA'\n",
    "}\n",
    "\n",
    "# modify pattern column only if the pattern is not one of the values in the map\n",
    "df['pattern'] = df['data_pattern'].map(lambda x: pattern_map[x] if x in pattern_map else x)\n",
    "\n",
    "# rename machine column to chip\n",
    "df.rename(columns={'machine': 'chip'}, inplace=True)\n",
    "\n",
    "# rename row_errors to bitflips\n",
    "df.rename(columns={'count': 'bitflips'}, inplace=True)\n",
    "\n",
    "df['bitflips'] = df['bitflips'] / 5\n",
    "\n",
    "# create bit error rate column \n",
    "# ber = bitflips / row size (1024*8)\n",
    "df['ber'] = df['bitflips'] / (1024*8) * 100\n",
    "\n",
    "sidebyside = True\n",
    "\n",
    "hcf_chip_ch = df.copy()\n",
    "\n",
    "# flatten the multi-index\n",
    "hcf_chip_ch.reset_index(inplace=True)\n",
    "\n",
    "# select only chip, channel and bitflips\n",
    "hcf_chip_ch = hcf_chip_ch[['chip', 'CH', 'aggon', 'ber']]\n",
    "\n",
    "# create a subplot for each chip\n",
    "if sidebyside:\n",
    "  fig, axes = plt.subplots(nrows=len(hcf_chip_ch['chip'].unique()),ncols=2, figsize=(8.1, 1.5*len(hcf_chip_ch['chip'].unique())))\n",
    "else:\n",
    "  fig, axes = plt.subplots(nrows=len(hcf_chip_ch['chip'].unique()), figsize=(8.1, 2.0*len(hcf_chip_ch['chip'].unique())))\n",
    "\n",
    "# select the taggon values at 0, 9, 11, 19\n",
    "# hcf_chip_ch = hcf_chip_ch[hcf_chip_ch['taggon'].isin([0, 1, 2, 3])]\n",
    "# ras_to_microsec = ['29.0ns', '58.0ns', '87.0ns', '116.0ns']\n",
    "\n",
    "# mapping from ras_scale to ras_to_microsec is 29.0 + (x*29.0) for x in ras_scale\n",
    "# create ras_to_microsec list for each element in ras_scale\n",
    "ras_scale = [0, 1, 2, 3, 8, 16, 32, 64, 134.48, 1210.34]\n",
    "ras_to_microsec = [0.0333 + (x*33.333/1000) for x in ras_scale]\n",
    "\n",
    "# ras_scale = ras_scale[:4]\n",
    "ras_to_microsec = [29.0 + (x*29.0) for x in ras_scale]\n",
    "\n",
    "# format ras_to_microsec to have 1 decimal place\n",
    "ras_to_microsec = [round(x, 1) for x in ras_to_microsec]\n",
    "\n",
    "# format ras_to_microsec as a string with ns appended; if an element is larger than 1000, convert it to us\n",
    "ras_to_microsec = [str(x) + 'ns' if x < 1000 else str(round(x/1000,1)) + 'us' for x in ras_to_microsec]\n",
    "\n",
    "ras_to_microsec[8:] = [\"$t_{REFI}$ (3.9$\\mu{}s$)\", \"$9*t_{REFI}$ (35.1$\\mu{}s$)\"]\n",
    "\n",
    "ras_to_microsec[0] = \"$t_{RAS}$\\n(29.0ns)\"\n",
    "\n",
    "hcf_chip_ch['aggon_verbose'] = hcf_chip_ch['aggon'].apply(lambda x: ras_to_microsec[x])\n",
    "\n",
    "# remove aggon larger than 4 from hcf_chip_ch\n",
    "# hcf_chip_ch = hcf_chip_ch[hcf_chip_ch['aggon'] < 4]\n",
    "\n",
    "# create a bar plot for each chip\n",
    "if len(hcf_chip_ch['chip'].unique()) == 1:\n",
    "  sns.boxplot(x='aggon', y='ber', data=hcf_chip_ch, ax=axes, showfliers=False, hue=\"CH\", palette=mypalette, whis=(0,100), showmeans=True, meanprops={\"marker\":\"o\",\"markerfacecolor\":\"white\", \"markeredgecolor\":\"black\",\"markersize\":\"5\"})\n",
    "  axes.text(0.1, 0.8, hcf_chip_ch['chip'].unique(), horizontalalignment='center', verticalalignment='center', transform=axes.transAxes, bbox=dict(facecolor='white', edgecolor='black', boxstyle='round,pad=0.5', alpha=0.5), fontsize=12)\n",
    "  axes.get_legend().remove()\n",
    "  axes.set_xlabel('Aggressor row on time (tAggON)')\n",
    "  axes.set_xticklabels(ras_to_microsec[:10])\n",
    "  axes.set_ylabel('')\n",
    "\n",
    "else:\n",
    "  for chip, ax in zip(hcf_chip_ch['chip'].unique(), axes):\n",
    "    if sidebyside:\n",
    "      sns.boxplot(x='aggon', y='ber', data=hcf_chip_ch[(hcf_chip_ch['chip'] == chip) & (hcf_chip_ch['aggon'] < 4)], ax=ax[0], showfliers=False, hue=\"CH\", palette=mypalette, whis=(0,100), showmeans=True, meanprops={\"marker\":\"o\",\"markerfacecolor\":\"white\", \"markeredgecolor\":\"black\",\"markersize\":\"5\"})\n",
    "      sns.boxplot(x='aggon', y='ber', data=hcf_chip_ch[(hcf_chip_ch['chip'] == chip) & (hcf_chip_ch['aggon'] > 7)], ax=ax[1], showfliers=False, hue=\"CH\", palette=mypalette, whis=(0,100), showmeans=True, meanprops={\"marker\":\"o\",\"markerfacecolor\":\"white\", \"markeredgecolor\":\"black\",\"markersize\":\"5\"})\n",
    "    else:\n",
    "      sns.boxplot(x='aggon', y='ber', data=hcf_chip_ch[hcf_chip_ch['chip'] == chip], ax=ax, showfliers=False, hue=\"CH\", palette=mypalette, whis=(0,100), showmeans=True, meanprops={\"marker\":\"o\",\"markerfacecolor\":\"white\", \"markeredgecolor\":\"black\",\"markersize\":\"5\"})\n",
    "    \n",
    "    if sidebyside:\n",
    "      ax[0].text(0.15, 0.8, chip, horizontalalignment='center', verticalalignment='center', transform=ax[0].transAxes, bbox=dict(facecolor='white', edgecolor='black', boxstyle='round,pad=0.5', alpha=0.5), fontsize=12)\n",
    "      # ax[1].text(0.1, 0.8, chip, horizontalalignment='center', verticalalignment='center', transform=ax[1].transAxes, bbox=dict(facecolor='white', edgecolor='black', boxstyle='round,pad=0.5', alpha=0.5), fontsize=12)\n",
    "      ax[0].get_legend().remove()\n",
    "      ax[1].get_legend().remove()\n",
    "      if chip != 'Chip 5':\n",
    "        ax[0].set_xlabel('')\n",
    "        ax[1].set_xlabel('')\n",
    "        ax[0].set_xticklabels([])\n",
    "        ax[1].set_xticklabels([])\n",
    "        ax[0].set_xticks([])\n",
    "        ax[1].set_xticks([])\n",
    "\n",
    "      if chip == 'Chip 0':\n",
    "        # prepend 'CH' to legend labels\n",
    "        handles, labels = ax[0].get_legend_handles_labels()\n",
    "        ax[0].legend(handles, ['CH' + label for label in labels], loc='upper center', title='Channel', ncol=8, bbox_to_anchor=(1.05, 1.55), fancybox=True, shadow=True, columnspacing=0.5)\n",
    "        # handles, labels = ax[1].get_legend_handles_labels()\n",
    "        # ax[1].legend(handles, ['CH' + label for label in labels], loc='upper center', title='Channel', ncol=8, bbox_to_anchor=(0.5, 1.5), fancybox=True, shadow=True, columnspacing=0.5)\n",
    "      if chip == 'Chip 5':\n",
    "        # ax[0].set_xlabel('Aggressor row on time (tAggON)')\n",
    "        # ax[1].set_xlabel('Aggressor row on time (tAggON)')\n",
    "        ax[0].set_xlabel('')\n",
    "        ax[1].set_xlabel('')\n",
    "        # format ras_to_microsec to string with two decimal places\n",
    "        # ras_to_microsecstr = [float(\"%.2f\" % (t)) for t in ras_to_microsec]\n",
    "        # set the x-axis labels to the formatted values\n",
    "        # ax.set_xticklabels([str(float(t)) for t in ras_to_microsecstr])\n",
    "        ax[0].set_xticklabels(ras_to_microsec[:4])\n",
    "        ax[1].set_xticklabels(ras_to_microsec[8:])\n",
    "        ax[0].text(1.1, -0.40, \"Aggressor row on time ($t_{AggON}$)\", horizontalalignment='center', verticalalignment='center', transform=ax[0].transAxes, fontsize=12)\n",
    "\n",
    "        # rotate x-axis labels\n",
    "        # for tick in ax.get_xticklabels():\n",
    "        #   tick.set_rotation(90)\n",
    "\n",
    "\n",
    "      # ax.set_yticks([x * 40000 for x in range(7)])\n",
    "      # ax.set_yticklabels([str(int(int(t) / 1000))+\"K\" if t > 0 else \"0\" for t in ax.get_yticks()])\n",
    "      ax[0].set_ylabel('')\n",
    "      ax[1].set_ylabel('')\n",
    "\n",
    "      # make x width more narrow\n",
    "      # ax.set_xlim(-0.5, 3.5)\n",
    "\n",
    "      # Put grid lines in the background\n",
    "      ax[0].set_axisbelow(True)\n",
    "      ax[1].set_axisbelow(True)\n",
    "      ax[0].grid(color='gray', linestyle='dashed')\n",
    "      ax[1].grid(color='gray', linestyle='dashed')\n",
    "      # Put grid lines only on y-axis\n",
    "      ax[0].xaxis.grid(False)\n",
    "      ax[1].xaxis.grid(False)\n",
    "      # ax.set_yscale('log')\n",
    "      # ax.set_yticks([1, 10, 100, 1000, 10000, 100000])\n",
    "\n",
    "\n",
    "      ax[0].set_ylim(0, 2.8)\n",
    "      ax[1].set_ylim(0, 70)\n",
    "      # ax.set_yticks([0, 0.4, 0.8, 1.2, 1.6, 2.0, 2.4, 2.8])\n",
    "      ax[0].yaxis.set_major_formatter(FormatStrFormatter('%.0f'))\n",
    "      ax[1].yaxis.set_major_formatter(FormatStrFormatter('%.0f'))\n",
    "\n",
    "    else:\n",
    "      ax.text(0.1, 0.8, chip, horizontalalignment='center', verticalalignment='center', transform=ax.transAxes, bbox=dict(facecolor='white', edgecolor='black', boxstyle='round,pad=0.5', alpha=0.5), fontsize=12)\n",
    "      ax.get_legend().remove()\n",
    "      if chip != 'Chip 5':\n",
    "        ax.set_xlabel('')\n",
    "        ax.set_xticklabels([])\n",
    "        ax.set_xticks([])\n",
    "\n",
    "      if chip == 'Chip 1':\n",
    "        # prepend 'CH' to legend labels\n",
    "        handles, labels = ax.get_legend_handles_labels()\n",
    "        ax.legend(handles, ['CH' + label for label in labels], loc='upper center', title='Channel', ncol=8, bbox_to_anchor=(0.5, 1.5), fancybox=True, shadow=True, columnspacing=0.5)\n",
    "      if chip == 'Chip 5':\n",
    "        ax.set_xlabel('Aggressor row on time (tAggON)')\n",
    "        # format ras_to_microsec to string with two decimal places\n",
    "        # ras_to_microsecstr = [float(\"%.2f\" % (t)) for t in ras_to_microsec]\n",
    "        # set the x-axis labels to the formatted values\n",
    "        # ax.set_xticklabels([str(float(t)) for t in ras_to_microsecstr])\n",
    "        ax.set_xticklabels(ras_to_microsec)\n",
    "\n",
    "        # rotate x-axis labels\n",
    "        # for tick in ax.get_xticklabels():\n",
    "        #   tick.set_rotation(90)\n",
    "\n",
    "\n",
    "      # ax.set_yticks([x * 40000 for x in range(7)])\n",
    "      # ax.set_yticklabels([str(int(int(t) / 1000))+\"K\" if t > 0 else \"0\" for t in ax.get_yticks()])\n",
    "      ax.set_ylabel('')\n",
    "\n",
    "      # make x width more narrow\n",
    "      # ax.set_xlim(-0.5, 3.5)\n",
    "\n",
    "      # Put grid lines in the background\n",
    "      ax.set_axisbelow(True)\n",
    "      ax.grid(color='gray', linestyle='dashed')\n",
    "      # Put grid lines only on y-axis\n",
    "      ax.xaxis.grid(False)\n",
    "      # ax.set_yscale('log')\n",
    "      # ax.set_yticks([1, 10, 100, 1000, 10000, 100000])\n",
    "\n",
    "\n",
    "      # ax.set_ylim(0, 2.8)\n",
    "      # ax.set_yticks([0, 0.4, 0.8, 1.2, 1.6, 2.0, 2.4, 2.8])\n",
    "      ax.yaxis.set_major_formatter(FormatStrFormatter('%.0f'))\n",
    "\n",
    "      # ax.axvspan(boundaries[8]/sample_size, boundaries[9]/sample_size - 1, facecolor=(1,0.2,0.2), alpha=0.2)\n",
    "      # draw a vspan between boxes at the 3.9us \n",
    "      # ax.axvspan(0.5, 1.5, facecolor=(1,0.5,0.2), alpha=0.1)\n",
    "      # # also add lines\n",
    "      # ax.axvline(0.5, color='black', linestyle='--')\n",
    "      # ax.axvline(1.5, color='black', linestyle='--')\n",
    "      # # draw a vspan between boxes at the 35.1us \n",
    "      # ax.axvspan(1.5, 2.5, facecolor=(1,0.2,0.2), alpha=0.1)\n",
    "      # # also add lines\n",
    "      # ax.axvline(2.5, color='black', linestyle='--')\n",
    "\n",
    "      # add text to the first vspan saying \"tREFI\"\n",
    "      # ax.text(0.38, 0.2, '$t_{REFI}$', horizontalalignment='center', verticalalignment='center', transform=ax.transAxes, bbox=dict(facecolor='orange', edgecolor='black', boxstyle='round,pad=0.5', alpha=0.5), fontsize=12)\n",
    "      # ax.text(0.63, 0.2, '$9*t_{REFI}$', horizontalalignment='center', verticalalignment='center', transform=ax.transAxes, bbox=dict(facecolor='red', edgecolor='black', boxstyle='round,pad=0.5', alpha=0.5), fontsize=12)\n",
    "\n",
    "\n",
    "fig.subplots_adjust(hspace=0.1,wspace=0.13)\n",
    "    \n",
    "\n",
    "# add text as y axis label that spans all subplots\n",
    "fig.text(0.065, 0.5, 'RowHammer Bit Error Rate ($BER$)', va='center', rotation='vertical', fontsize=12)\n",
    "\n",
    "# save figure\n",
    "fig.savefig('figure12-new.pdf', bbox_inches='tight')\n",
    "# average ber at each taggon\n",
    "print(hcf_chip_ch.groupby(['aggon_verbose'])['ber'].mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "from matplotlib.ticker import FormatStrFormatter\n",
    "\n",
    "# giray's style\n",
    "scale_factor = 16\n",
    "\n",
    "colors = sns.color_palette(\"plasma\", 4 * scale_factor)\n",
    "\n",
    "ext_colors = []\n",
    "i = 0 \n",
    "while i < 4:\n",
    "    c = colors[i*scale_factor]\n",
    "    cn = tuple([cc * 0.9 for cc in c])\n",
    "    ext_colors.append(cn)\n",
    "    ext_colors.append(c)\n",
    "    i+=1\n",
    "\n",
    "print(ext_colors)\n",
    "\n",
    "ext_colors = [ext_colors[0], ext_colors[6], ext_colors[4]]\n",
    "\n",
    "mypalette = sns.color_palette(ext_colors)\n",
    "\n",
    "mypalette\n",
    " \n",
    "# read all csv files in this folder and concatenate them into one dataframe\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import re\n",
    "import os\n",
    "\n",
    "host_machines = [\n",
    "  'safari-fpga37',\n",
    "  'safari-fpga55',\n",
    "  'safari-fpga56-new',\n",
    "  'safari-fpga57',\n",
    "  'safari-fpga58',\n",
    "  'safari-fpga59'\n",
    "]\n",
    "\n",
    "rows_tested_for_bitflips = 384\n",
    "\n",
    "ras_scale = [0, 1, 2, 4, 8, 16, 32, 64, 118, 256, 512, 1063, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000]\n",
    "\n",
    "ras_to_microsec = [0.0333 + (x*33.333/1000) for x in ras_scale]\n",
    "\n",
    "print(ras_to_microsec)\n",
    "\n",
    "dfs = []\n",
    "\n",
    "# Loop over all CSV files in the directory\n",
    "for host_machine in host_machines:\n",
    "  dir_path = './' + 'fast_forward_data/' + host_machine\n",
    "  for filename in os.listdir(dir_path):\n",
    "    if 'AggOn' in filename and 'hcfirst' in filename:\n",
    "      tokens = filename.split('_')\n",
    "      ch_num = int(tokens[2])\n",
    "      pc_num = int(tokens[4])\n",
    "      bank_num = int(tokens[6])\n",
    "      pattern = tokens[8]\n",
    "      taggon = int(tokens[10].split('.')[0])\n",
    "      # create a dataframe from the csv file\n",
    "      df = pd.read_csv(dir_path + '/' + filename, header=None, names=['hcfirst'])\n",
    "      # add the channel, pc, bank and pattern numhcfirsts as columns\n",
    "      df['CH'] = ch_num\n",
    "      df['PC'] = pc_num\n",
    "      df['bank'] = bank_num\n",
    "      df['pattern'] = pattern\n",
    "      df['machine'] = host_machine\n",
    "      df['taggon'] = taggon\n",
    "      df['row'] = df.index\n",
    "      # append the dataframe to the list\n",
    "      dfs.append(df)\n",
    "\n",
    "# Concatenate all dataframes into one\n",
    "df = pd.concat(dfs, ignore_index=True)\n",
    "\n",
    "# map the channels by decrementing them by 8\n",
    "df['CH'] = df['CH'].map(lambda x: x - 8)\n",
    " \n",
    "# remove channels greater than 3\n",
    "df = df[df['CH'] < 3]\n",
    "\n",
    "def map_row(row):\n",
    "  if row < 128:\n",
    "    return row\n",
    "  elif row < 256:\n",
    "    return row + 7936\n",
    "  else:\n",
    "    return row + 15742\n",
    "\n",
    "# apply map_row to the row column\n",
    "df['row'] = df['row'].map(map_row)\n",
    "\n",
    "# rename machine using the following map\n",
    "machine_map = {\n",
    "  'safari-fpga37': 'Chip 0',\n",
    "  'safari-fpga55': 'Chip 1',\n",
    "  'safari-fpga56-new': 'Chip 2',\n",
    "  'safari-fpga57': 'Chip 3',\n",
    "  'safari-fpga58': 'Chip 4',\n",
    "  'safari-fpga59': 'Chip 5'\n",
    "}\n",
    "df['machine'] = df['machine'].map(machine_map)\n",
    "\n",
    "pattern_map = {\n",
    "  '0': '00',\n",
    "  '1': 'FF',\n",
    "  '2': '55',\n",
    "  '3': 'AA'\n",
    "}\n",
    "\n",
    "# modify pattern column only if the pattern is not one of the values in the map\n",
    "df['pattern'] = df['pattern'].map(lambda x: pattern_map[x] if x in pattern_map else x)\n",
    "\n",
    "# rename machine column to chip\n",
    "df.rename(columns={'machine': 'chip'}, inplace=True)\n",
    "\n",
    "# a new data point for each row is created for a new worst case data pattern\n",
    "# this is the data pattern that maximizes hcfirst for a row in a given channel, pc, bank, chip, with different patterns\n",
    "\n",
    "# remove rows with hcfirst >= 256000\n",
    "df = df[df['hcfirst'] < 256000]\n",
    "\n",
    "# a row should have an entry for each taggon\n",
    "# if a row does not have an entry for a pattern, then remove it completely\n",
    "# remove rows that do not have all patterns\n",
    "df = df.groupby(['chip', 'CH', 'PC', 'row', 'bank', 'pattern']).filter(lambda x: len(x['taggon'].unique()) == 20)\n",
    "\n",
    "# add new column ras_microsec mapping from taggon to ras_to_microsec\n",
    "df['ras_microsec'] = df['taggon'].map(lambda x: ras_to_microsec[x])\n",
    "\n",
    "# add new column experiment_time as the product of ras_to_microsec and hcfirst and 2\n",
    "df['experiment_time'] = df['hcfirst'] * 2 * df['ras_microsec']\n",
    "\n",
    "df_large = df[df['experiment_time'] >= 34000]\n",
    "\n",
    "# if experiemtn times are greater than 32000, remove row\n",
    "df = df[df['experiment_time'] < 34000]\n",
    "\n",
    "df = df[df['taggon'].isin([0, 9, 11, 18])]\n",
    "\n",
    "df = df.groupby(['chip', 'CH', 'PC', 'row', 'bank', 'pattern']).filter(lambda x: len(x['taggon'].unique()) == 4)\n",
    "\n",
    "df2 = df.copy()\n",
    "\n",
    "df2 = df2[df2['taggon'].isin([0, 9, 11, 18])]\n",
    "\n",
    "# remove rows that do not exist for all taggons\n",
    "df2 = df2.groupby(['chip', 'CH', 'PC', 'row', 'bank', 'pattern']).filter(lambda x: len(x['taggon'].unique()) == 4)\n",
    "\n",
    "df2\n",
    "\n",
    "hcf_chip_ch = df.copy()\n",
    "# flatten the multi-index\n",
    "hcf_chip_ch.reset_index(inplace=True)\n",
    "\n",
    "# select only chip, channel and bitflips\n",
    "hcf_chip_ch = hcf_chip_ch[['chip', 'CH', 'taggon', 'hcfirst']]\n",
    "\n",
    "# create a subplot for each chip\n",
    "fig, axes = plt.subplots(nrows=len(hcf_chip_ch['chip'].unique()), figsize=(8.1, 2.0*len(hcf_chip_ch['chip'].unique())))\n",
    "\n",
    "# select the taggon values at 0, 9, 11, 19\n",
    "hcf_chip_ch = hcf_chip_ch[hcf_chip_ch['taggon'].isin([0, 9, 11, 18])]\n",
    "ras_to_microsec = ['29.0ns', '3.9$\\mu$s', '35.1$\\mu$s', '16.0ms']\n",
    "\n",
    "sample_size = [153, 649, 225, 56, 145, 62]\n",
    "\n",
    "# create a bar plot for each chip\n",
    "for chip, ax, i in zip(hcf_chip_ch['chip'].unique(), axes, range(len(hcf_chip_ch['chip'].unique()))):\n",
    "  sns.boxplot(x='taggon', y='hcfirst', data=hcf_chip_ch[hcf_chip_ch['chip'] == chip], ax=ax, showfliers=False, hue=\"CH\", palette=mypalette, whis=(0,100), showmeans=True, meanprops={\"marker\":\"o\",\"markerfacecolor\":\"white\", \"markeredgecolor\":\"black\",\"markersize\":\"5\"})\n",
    "  ax.text(0.12, 0.35, chip, horizontalalignment='center', verticalalignment='center', transform=ax.transAxes, bbox=dict(facecolor='white', edgecolor='black', boxstyle='round,pad=0.5', alpha=0.5), fontsize=12)\n",
    "  ax.get_legend().remove()\n",
    "  if chip != 'Chip 5':\n",
    "    ax.set_xlabel('')\n",
    "    ax.set_xticklabels([])\n",
    "    ax.set_xticks([])\n",
    "\n",
    "  if chip == 'Chip 0':\n",
    "    # prepend 'CH' to legend labels\n",
    "    handles, labels = ax.get_legend_handles_labels()\n",
    "    ax.legend(handles, ['CH' + label for label in labels], loc='upper center', title='Channel', ncol=8, bbox_to_anchor=(0.5, 1.5), fancybox=True, shadow=True, columnspacing=0.5)\n",
    "  if chip == 'Chip 5':\n",
    "    ax.set_xlabel('Aggressor row on time (tAggON)')\n",
    "    # format ras_to_microsec to string with two decimal places\n",
    "    # ras_to_microsecstr = [float(\"%.2f\" % (t)) for t in ras_to_microsec]\n",
    "    # set the x-axis labels to the formatted values\n",
    "    # ax.set_xticklabels([str(float(t)) for t in ras_to_microsecstr])\n",
    "    ax.set_xticklabels(ras_to_microsec)\n",
    "\n",
    "    # rotate x-axis labels\n",
    "    # for tick in ax.get_xticklabels():\n",
    "    #   tick.set_rotation(90)\n",
    "\n",
    "\n",
    "  # ax.set_yticks([x * 40000 for x in range(7)])\n",
    "  # ax.set_yticklabels([str(int(int(t) / 1000))+\"K\" if t > 0 else \"0\" for t in ax.get_yticks()])\n",
    "  ax.set_ylabel('')\n",
    "\n",
    "  # make x width more narrow\n",
    "  ax.set_xlim(-0.5, 3.5)\n",
    "\n",
    "  # Put grid lines in the background\n",
    "  ax.set_axisbelow(True)\n",
    "  ax.grid(color='gray', linestyle='dashed')\n",
    "  # Put grid lines only on y-axis\n",
    "  ax.xaxis.grid(False)\n",
    "  ax.set_yscale('log')\n",
    "  ax.set_yticks([1, 10, 100, 1000, 10000, 100000])\n",
    "\n",
    "  # ax.axvspan(boundaries[8]/sample_size, boundaries[9]/sample_size - 1, facecolor=(1,0.2,0.2), alpha=0.2)\n",
    "  # draw a vspan between boxes at the 3.9us \n",
    "  ax.axvspan(0.5, 1.5, facecolor=(1,0.5,0.2), alpha=0.1)\n",
    "  # also add lines\n",
    "  ax.axvline(0.5, color='black', linestyle='--')\n",
    "  ax.axvline(1.5, color='black', linestyle='--')\n",
    "  # draw a vspan between boxes at the 35.1us \n",
    "  ax.axvspan(1.5, 2.5, facecolor=(1,0.2,0.2), alpha=0.1)\n",
    "  # also add lines\n",
    "  ax.axvline(2.5, color='black', linestyle='--')\n",
    "\n",
    "  # add text to the first vspan saying \"tREFI\"\n",
    "  ax.text(0.38, 0.2, '$t_{REFI}$', horizontalalignment='center', verticalalignment='center', transform=ax.transAxes, bbox=dict(facecolor='orange', edgecolor='black', boxstyle='round,pad=0.5', alpha=0.5), fontsize=12)\n",
    "  ax.text(0.63, 0.2, '$9*t_{REFI}$', horizontalalignment='center', verticalalignment='center', transform=ax.transAxes, bbox=dict(facecolor='red', edgecolor='black', boxstyle='round,pad=0.5', alpha=0.5), fontsize=12)\n",
    "\n",
    "  # add text to signify sample size for each subplot\n",
    "  ax.text(0.88, 0.5, str(sample_size[i]) + ' rows', horizontalalignment='center', verticalalignment='center', transform=ax.transAxes, bbox=dict(facecolor='grey', edgecolor='black', boxstyle='round,pad=0.5', alpha=0.5), fontsize=12)\n",
    "\n",
    "fig.subplots_adjust(hspace=0.15)\n",
    "    \n",
    "\n",
    "# add text as y axis label that spans all subplots\n",
    "fig.text(0.04, 0.5, 'Minimum Hammer Count to Induce the First Bitflip ($HC_{first}$)', va='center', rotation='vertical', fontsize=12)\n",
    "\n",
    "# save figure\n",
    "fig.savefig('figure13-new.pdf', bbox_inches='tight')\n",
    "\n",
    "# average HCfirst across all chips for each taggon value\n",
    "print(hcf_chip_ch.groupby(['taggon'])['hcfirst'].mean())\n",
    "print(hcf_chip_ch.groupby(['taggon'])['hcfirst'].min())\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "def read_data(filename):\n",
    "    file = open(filename, \"r\")\n",
    "    t_df = pd.DataFrame(columns=[\"pivot_row\", \"bitflips\"])\n",
    "    for line in file.readlines():\n",
    "        pivot_row = int(line.partition(\":\")[0].strip())\n",
    "        bitflips = [int(bfs) for bfs in line.partition(\":\")[2].strip().split(\" \")]\n",
    "        bitflips = sum(bitflips)\n",
    "        t_df.loc[len(t_df)] = [pivot_row, bitflips]\n",
    "    return t_df\n",
    "ph = [plt.plot([],marker=\"\", ls=\"\")[0]]\n",
    "\n",
    "\n",
    "num_dummy_rows_list = [4, 5, 6, 7, 8, 9, 10]\n",
    "hammers_per_ref_loop_list = [\n",
    "    \"10 10\",\n",
    "    \"12 12\",\n",
    "    \"14 14\",\n",
    "    \"16 16\",\n",
    "    \"18 18\",\n",
    "    \"20 20\",\n",
    "    \"22 22\",\n",
    "    \"24 24\",\n",
    "    \"26 26\",\n",
    "    \"28 28\",\n",
    "    \"30 30\",\n",
    "    \"32 32\",\n",
    "    \"34 34\",\n",
    "    \"36 36\",\n",
    "    \"38 38\",\n",
    "]\n",
    "\n",
    "\n",
    "before = True\n",
    "after = False\n",
    "trrref_sync = False\n",
    "\n",
    "df = pd.DataFrame()\n",
    "for num_dummy_rows in num_dummy_rows_list:\n",
    "    for hammers_per_ref_loop in hammers_per_ref_loop_list:\n",
    "        for shift_refs in [7]:\n",
    "            # out_filename = \"f\" + str(shift) + \".txt\"\n",
    "            out_filename = \"fast_forward_data/utrr_results-new/\" + \\\n",
    "                    \"dummy_\" + str(num_dummy_rows) + \\\n",
    "                    \"-h_\" + hammers_per_ref_loop.replace(\" \", \"_\") + \\\n",
    "                    \"-before_\" + str(before) + \\\n",
    "                    \"-after_\" + str(after) + \\\n",
    "                    \"-trrrefsync_\" + str(trrref_sync) + \\\n",
    "                    \".txt\"\n",
    "            if(not os.path.exists(out_filename)):\n",
    "                continue\n",
    "\n",
    "            t_df = read_data(out_filename)\n",
    "            t_df[\"num_dummy_rows\"] = num_dummy_rows\n",
    "            t_df[\"hammers_per_ref_loop\"] = hammers_per_ref_loop.split(\" \")[0]\n",
    "\n",
    "            df = pd.concat([df, t_df], ignore_index=True)\n",
    "            \n",
    "# for hammers in hammers_per_ref_loop_list:\n",
    "#     df.loc[len(df)] = [-1, 0, 3, hammers.split(\" \")[0]]\n",
    "\n",
    "df[\"num_dummy_rows\"] = df[\"num_dummy_rows\"].astype(int)\n",
    "df[\"hammers_per_ref_loop\"] = df[\"hammers_per_ref_loop\"].astype(int)\n",
    "\n",
    "df.loc[len(df)] = [-1, 0, 4, 38]\n",
    "df.loc[len(df)] = [-1, 0, 5, 38]\n",
    "df.loc[len(df)] = [-1, 0, 6, 38]\n",
    "df.loc[len(df)] = [-1, 0, 7, 38]\n",
    "df.loc[len(df)] = [-1, 0, 8, 38]\n",
    "df.loc[len(df)] = [-1, 0, 9, 38]\n",
    "df.loc[len(df)] = [-1, 0, 10, 38]\n",
    "df.loc[len(df)] = [-1, 0, 5, 36]\n",
    "\n",
    "df.sort_values(by=['hammers_per_ref_loop', 'num_dummy_rows'], inplace=True)\n",
    "\n",
    "t_df = df.copy()\n",
    "\n",
    "t_df = t_df[t_df['hammers_per_ref_loop'] <= 34]\n",
    "\n",
    "# new column ber is bitflips per row divided by 16*1024*8 then multiplied by 100\n",
    "t_df['ber'] = (t_df['bitflips'] / (8*1024*8)) * 100\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6, 3))\n",
    "# plt.title(\"Average bitflips per row\", )\n",
    "sns.boxplot(x=\"num_dummy_rows\", y=\"ber\", hue=\"hammers_per_ref_loop\", whis=[0,100], data=t_df, palette=\"pastel\", zorder=10, width=0.8, \n",
    "            ax=ax, showmeans=True, meanprops={\"marker\":\"o\",\"markerfacecolor\":\"white\", \"markeredgecolor\":\"black\", \"markersize\":\"3\"})\n",
    "\n",
    "# set legend title \"Aggressor row activation count\"\n",
    "\n",
    "ax.legend(fontsize=9, loc=\"upper center\", bbox_to_anchor=(0.5, 1.25), title='Aggressor row activation count in a $t_{REFI}$', title_fontsize=12, ncols=9, columnspacing=0.5, fancybox=True)\n",
    "\n",
    "ax.set_ylabel(\"RowHammer Bit Error Rate ($BER$)\", fontsize=12)\n",
    "ax.set_xlabel(\"Number of dummy rows\", fontsize=12)\n",
    "ax.tick_params(axis=\"x\", direction=\"out\", labelsize=12, color='black')\n",
    "ax.tick_params(axis=\"y\", direction=\"out\", labelsize=12, color='black')\n",
    "\n",
    "\n",
    "plt.grid(axis='y', alpha=0.8, zorder=0)\n",
    "\n",
    "plt.savefig('./figure14-new.png', bbox_inches='tight', pad_inches=0.01)\n",
    "plt.savefig('./figure14-new.pdf', bbox_inches='tight', pad_inches=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "from matplotlib.ticker import FormatStrFormatter\n",
    "import numpy as np\n",
    "\n",
    "# giray's style\n",
    "scale_factor = 16\n",
    "\n",
    "colors = sns.color_palette(\"plasma\", 4 * scale_factor)\n",
    "\n",
    "ext_colors = []\n",
    "i = 0 \n",
    "while i < 4:\n",
    "    c = colors[i*scale_factor]\n",
    "    cn = tuple([cc * 0.9 for cc in c])\n",
    "    ext_colors.append(cn)\n",
    "    ext_colors.append(c)\n",
    "    i+=1\n",
    "\n",
    "print(ext_colors)\n",
    "\n",
    "ext_colors = [ext_colors[0], ext_colors[2], ext_colors[4], ext_colors[6], ext_colors[7], ext_colors[5], ext_colors[3], ext_colors[1]]\n",
    "\n",
    "mypalette = sns.color_palette(ext_colors)\n",
    "\n",
    "mypalette\n",
    "\n",
    "########################################################\n",
    "######## Run once to generate the summary ##############\n",
    "########################################################\n",
    "\n",
    "# read all csv files in this folder and concatenate them into one dataframe\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import re\n",
    "import os\n",
    "\n",
    "host_machines = [\n",
    "  'safari-fpga56-new'\n",
    "]\n",
    "\n",
    "rows_tested_for_bitflips = 3072\n",
    "\n",
    "dfs = []\n",
    "\n",
    "# Loop over all CSV files in the directory\n",
    "for host_machine in host_machines:\n",
    "  dir_path = './' + 'fast_forward_data/' + host_machine\n",
    "  for filename in os.listdir(dir_path):\n",
    "    if filename.startswith('rowhammer') and 'tAggOn' not in filename:\n",
    "      tokens = filename.split('_')\n",
    "      ch_num = int(tokens[2])\n",
    "      pc_num = int(tokens[4])\n",
    "      bank_num = int(tokens[6])\n",
    "      pattern = tokens[8].split('.')[0]\n",
    "      # create a dataframe from the csv file\n",
    "      df = pd.read_csv(dir_path + '/' + filename)\n",
    "      # add the channel, pc, bank and pattern numbers as columns\n",
    "      df['CH'] = ch_num\n",
    "      df['PC'] = pc_num\n",
    "      df['bank'] = bank_num\n",
    "      df['pattern'] = pattern\n",
    "      df['machine'] = host_machine\n",
    "      # if an entry in the df has byte_errors = 0, remove it\n",
    "      df = df[df['byte_errors'] != 0] \n",
    "      # append the dataframe to the list\n",
    "      dfs.append(df)\n",
    "\n",
    "# Concatenate all dataframes into one\n",
    "df = pd.concat(dfs, ignore_index=True)\n",
    "\n",
    "# map the channels by decrementing them by 8\n",
    "df['CH'] = df['CH'].map(lambda x: x - 8)\n",
    "\n",
    "# map the rows in the following ranges to the following ranges\n",
    "# [0-1023] -> [0-1023]\n",
    "# [1024-2047] -> [7168-8191]\n",
    "# [2048-3071] -> [13310-14333]\n",
    "\n",
    "def map_row(row):\n",
    "  if row < 1024:\n",
    "    return row\n",
    "  elif row < 2048:\n",
    "    return row + 6144\n",
    "  else:\n",
    "    return row + 11262\n",
    "\n",
    "common_rows = [\n",
    "  range(0, 1024, 1),\n",
    "  range(7168, 8192, 1),\n",
    "  range(13310, 14334, 1)\n",
    "]\n",
    "\n",
    "common_banks = [\n",
    "  0, 1, 2\n",
    "]\n",
    "\n",
    "# group by machine, channel, pc, bank, pattern\n",
    "# if the group has 3072 rows, then apply map row\n",
    "# otherwise, leave the row as is\n",
    "df['row'] = df.groupby(['machine', 'CH', 'PC', 'bank', 'pattern'])['row'].transform(lambda x: x.map(map_row) if len(x) == rows_tested_for_bitflips else x)\n",
    "\n",
    "# rename machine using the following map\n",
    "machine_map = {\n",
    "  'safari-fpga56-new': 'Chip 2'\n",
    "}\n",
    "df['machine'] = df['machine'].map(machine_map)\n",
    "\n",
    "pattern_map = {\n",
    "  '0': '00',\n",
    "  '1': 'FF',\n",
    "  '2': '55',\n",
    "  '3': 'AA'\n",
    "}\n",
    "\n",
    "# modify pattern column only if the pattern is not one of the values in the map\n",
    "df['pattern'] = df['pattern'].map(lambda x: pattern_map[x] if x in pattern_map else x)\n",
    "\n",
    "# rename machine column to chip\n",
    "df.rename(columns={'machine': 'chip'}, inplace=True)\n",
    "\n",
    "# rename row_errors to bitflips\n",
    "df.rename(columns={'byte_errors': 'bitflips'}, inplace=True)\n",
    "\n",
    "df['bitflips'] = df['bitflips'] / 5\n",
    "\n",
    "# create bit error rate column \n",
    "# ber = bitflips / row size (1024*8)\n",
    "# df['ber'] = df['bitflips'] / (1024*8) * 100\n",
    "\n",
    "# filter out uncommon rows\n",
    "df_common_rows = df[df['row'].isin(common_rows[0]) | df['row'].isin(common_rows[1]) | df['row'].isin(common_rows[2])].copy()\n",
    "df_common_banks_rows = df_common_rows[df_common_rows['bank'].isin(common_banks)].copy()\n",
    "\n",
    "# a new data point for each row is created for a new worst case data pattern\n",
    "# this is the data pattern that maximizes ber for a row in a given channel, pc, bank, chip, with different patterns\n",
    "\n",
    "# group by chip, channel, pc, bank, row\n",
    "# for each group, find the pattern that maximizes ber\n",
    "# create a new dataframe with the following columns: chip, channel, pc, bank, row, pattern, ber\n",
    "# df_worst_case = df_common_banks_rows.groupby(['chip', 'CH', 'PC', 'bank', 'row'])[['pattern', 'ber']].max().reset_index()\n",
    "\n",
    "# df_worst_case.reset_index(drop=True, inplace=True)\n",
    "\n",
    "# rename pattern values with \"WCDP\"\n",
    "# df_worst_case['pattern'] = df_worst_case['pattern'].map(lambda x: 'WCDP')\n",
    "\n",
    "# add df_worst_case to df\n",
    "# df_common_banks_rows = pd.concat([df_common_banks_rows, df_worst_case], ignore_index=True)\n",
    "\n",
    "df_common_banks_rows\n",
    "\n",
    "# remove pattern\n",
    "# df_common_banks_rows.drop(columns=['pattern'], inplace=True)\n",
    "\n",
    "# round bitflips to the next largest integer\n",
    "df_common_banks_rows['bitflips'] = df_common_banks_rows['bitflips'].map(lambda x: int(x) + 1)\n",
    "\n",
    "# group by chip, CH, PC, bank, row, byte, reduce by summing\n",
    "df_common_banks_rows = df_common_banks_rows.groupby(['chip', 'CH', 'PC', 'bank', 'row', 'pattern', 'byte']).sum().reset_index()\n",
    "\n",
    "# create new column word = byte/8 (integer division)\n",
    "df_common_banks_rows['word'] = df_common_banks_rows['byte'].map(lambda x: int(x / 8))\n",
    "\n",
    "\n",
    "df_errs_per_word = df_common_banks_rows.groupby(['CH','PC','bank','row','pattern','word']).sum().reset_index()\n",
    "df_errs_per_word.drop(columns=['byte'], inplace=True)\n",
    "# sort by decreasing number of bitflips\n",
    "df_errs_per_word.sort_values(by=['bitflips'], ascending=False, inplace=True)\n",
    "\n",
    "# order for the pattern column is:\n",
    "pattern_order = ['FF', '00', 'AA', '55', 'WCDP']\n",
    "# apply this order\n",
    "df_errs_per_word['pattern'] = pd.Categorical(df_errs_per_word['pattern'], pattern_order)\n",
    "# sort by pattern\n",
    "df_errs_per_word.sort_values(by=['pattern'], inplace=True)\n",
    "\n",
    "data_patterns = {\n",
    "  'FF': \"Rowstripe0\",\n",
    "  '00': \"Rowstripe1\",\n",
    "  'AA': \"Checkered0\",\n",
    "  '55': \"Checkered1\"\n",
    "}\n",
    "\n",
    "df_errs_per_word['pattern'] = df_errs_per_word['pattern'].map(data_patterns)\n",
    "# categorize the entries based on the number of bitflips:\n",
    "\n",
    "# more than 2 bitflips, SECDED undetectable\n",
    "# more than 1 bitflips, SECDED uncorrectable\n",
    "# others, SECDED correctable\n",
    "\n",
    "df_errs_per_word[\"ECC Category\"] = pd.cut(df_errs_per_word['bitflips'], bins=[0, 1, 2, np.inf], labels = ['correctable', 'uncorrectable', 'undetectable'])\n",
    "df_errs_per_word[\"Number of Bitflips\"] = pd.cut(df_errs_per_word['bitflips'], bins=[0, 1, 2, np.inf], labels = ['<=1', '<=2', '>2'])\n",
    "# df_errs_per_word.drop(columns=['Unnamed: 0'], inplace=True)\n",
    "df_errs_per_word\n",
    "\n",
    "ax = plt.gca()\n",
    "ax.yaxis.grid(color='gray', linestyle='dashed')\n",
    "\n",
    "sns.countplot(x='Number of Bitflips', hue='pattern', data=df_errs_per_word, palette=mypalette, edgecolor='black', linewidth=1.5)\n",
    "\n",
    "# make figure size smaller\n",
    "plt.gcf().set_size_inches(7, 3)\n",
    "\n",
    "# rename y axis ticks to the K and M format (1000 -> 1K, 1000000 -> 1M)\n",
    "import matplotlib.ticker as mtick\n",
    "ax.yaxis.set_major_formatter(mtick.StrMethodFormatter('{x:,.0f}'))\n",
    "# rename to M format only (divide by one million and append 'M')\n",
    "# ax.yaxis.set_major_formatter(mtick.StrMethodFormatter('{x:,.0f}'))\n",
    "ax.set_yticklabels([0] + [str(x/1000000)+'M' for x in ax.get_yticks()[1:]])\n",
    "\n",
    "# increase al font sizes\n",
    "ax.tick_params(axis='both', which='major', labelsize=12)\n",
    "\n",
    "# rename legend title to Data pattern\n",
    "ax.legend(title='Data pattern', fontsize=12, fancybox=True, shadow=True, title_fontsize=13, ncols=1, loc = 'center right', bbox_to_anchor=(1.35, 0.5))\n",
    "\n",
    "# rename first x axis tick to <2, second to =2\n",
    "ax.set_xticklabels(['1', '2', '>2'], fontsize=12, rotation=0)\n",
    "\n",
    "# rename y axis label \"Number of words (8 byte)\"\n",
    "ax.set_ylabel('Number of words (8 byte)\\nthat exhibit bitflips', fontsize=14) \n",
    "\n",
    "ax.set_xlabel(\"Number of bitflips in a word\", fontsize=14)\n",
    "\n",
    "# save figure 'ecc_analysis.pdf'\n",
    "plt.savefig('figure15-new.pdf', bbox_inches='tight')\n",
    "\n",
    "# number of words with at least 1 bitflip and more than 2 bitflips for Checkered0\n",
    "print('Number of words with at least 1 bitflip: ' + str(len(df_errs_per_word[(df_errs_per_word['pattern'] == 'Checkered0') & (df_errs_per_word['Number of Bitflips'] == '>2')])))\n",
    " "
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}