ErrorBarPlots.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "# ErrorBarPlots\n",
       "\n",
       "This file derives from ModelSwapping.ipynb but takes averages for some plots.\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "# ErrorBarPlots\n",
    "\n",
    "This file derives from ModelSwapping.ipynb but takes averages for some plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sveCacheSim as sim\n",
    "import CacheModels\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pickle\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load Data\n",
    "size='Large'\n",
    "sizel = size.lower()\n",
    "data = sim.load_object('DataPMBS20/{}AllModels10Runs.pkl'.format(size))\n",
    "stats = {}\n",
    "gold_file='gold_python3.7/base_{}_stats.pkl'.format(sizel)\n",
    "stats['base'] = sim.load_object('gold_python3.7/base_{}_stats.pkl'.format(sizel))\n",
    "stats['fr'] = data[sizel]['FR']\n",
    "stats['m4'] = data[sizel]['M4']\n",
    "stats['m8'] = data[sizel]['M8']\n",
    "stats['all'] = data[sizel]['ALL']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Summary:\n",
      " L1 percent change in hit count: -0.09%\n",
      " L2 percent change in hit count: 54.35%\n",
      " L3 percent change in hit count: -71.17%\n",
      " Percent change in cycles: -27.88%\n",
      "Summary:\n",
      " L1 percent change in hit count: -0.37%\n",
      " L2 percent change in hit count: 46.10%\n",
      " L3 percent change in hit count: -51.74%\n",
      " Percent change in cycles: -23.22%\n",
      "Summary:\n",
      " L1 percent change in hit count: -0.19%\n",
      " L2 percent change in hit count: 12.16%\n",
      " L3 percent change in hit count: -4.10%\n",
      " Percent change in cycles: -7.60%\n",
      "Summary:\n",
      " L1 percent change in hit count: 0.07%\n",
      " L2 percent change in hit count: 10.14%\n",
      " L3 percent change in hit count: -4.89%\n",
      " Percent change in cycles: -7.91%\n"
     ]
    }
   ],
   "source": [
    "# Check that the right stats were loaded\n",
    "# Error should be ~3-4% for M8/All on Small Medium\n",
    "# Error should be ~7-8% for M8/All on Large\n",
    "sim.print_summary(stats['fr'][0], 'gold_python3.7/base_{}_stats.pkl'.format(sizel))\n",
    "sim.print_summary(stats['m4'][0], 'gold_python3.7/base_{}_stats.pkl'.format(sizel))\n",
    "sim.print_summary(stats['m8'][0], 'gold_python3.7/base_{}_stats.pkl'.format(sizel))\n",
    "sim.print_summary(stats['all'][0], 'gold_python3.7/base_{}_stats.pkl'.format(sizel))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "## Meabo Traces\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "## Meabo Traces\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_trace(ax, label, trace, axis_labels):\n",
    "    ax.scatter([*range(len(trace))], trace,s=2, color='black')\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.set_title(label)\n",
    "    if axis_labels:\n",
    "        ax.set_ylabel('Phase Number (-1 is uncategorized)')\n",
    "        ax.set_xlabel('Interval number (Interval = 10k inst)')\n",
    "\n",
    "        \n",
    "fig, ax = plt.subplots(figsize=(4,3))\n",
    "#plot_trace(ax, '{} Trace'.format(size), stats['base'].phase_trace.trace, True)\n",
    "plot_trace(ax, None, stats['base'].phase_trace.trace, True)\n",
    "plt.tight_layout()\n",
    "\n",
    "\n",
    "plt.savefig('DataPMBS20/plots_{}/phase_trace.pdf'.format(sizel))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "## Accuracy \n",
       "\n",
       "This time we'll average 10 runs\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown \n",
    "\n",
    "## Accuracy \n",
    "\n",
    "This time we'll average 10 runs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Accuracy\n",
      "   Fixed Rate  Markov 4  Markov 8\n",
      "0    0.668482  0.679830  0.733407\n",
      "1    0.991046  0.982168  0.981472\n",
      "2    0.698494  0.707939  0.876057\n",
      "3    0.532295  0.624644  0.688235\n",
      "4    0.739240  0.815036  0.927995\n",
      "Stddev Accuracy\n",
      "     Fixed Rate  Markov 4  Markov 8\n",
      "0  3.519085e-04  0.000351  0.000620\n",
      "1  1.110223e-16  0.000068  0.000059\n",
      "2  1.633939e-04  0.000219  0.000133\n",
      "3  3.439110e-04  0.000442  0.000467\n",
      "4  1.790020e-04  0.000123  0.000122\n"
     ]
    }
   ],
   "source": [
    "def get_acc(st1, st2, phase):\n",
    "    # t1 is assumed to be from the base cache\n",
    "    \n",
    "    t1 = st1.cache_trace[0] # cache trace from st1\n",
    "    t2 = st2.cache_trace[0] # cache trace from st2\n",
    "    \n",
    "    # Just get accesses where were are in phase `phase` and in state is Swapped (2)\n",
    "    pick_state = t2['state'] == 2\n",
    "    pick_phase = t2['phase'] == phase\n",
    "    \n",
    "    pick = np.logical_and(pick_state, pick_phase)\n",
    "    \n",
    "    # Get the hit/miss from each \n",
    "    t1_hits = t1['isHit'][pick]\n",
    "    t2_hits = t2['isHit'][pick]\n",
    "    \n",
    "    num_correct = np.sum(np.equal(t1_hits, t2_hits))\n",
    "    acc = num_correct / len(t1_hits)\n",
    "    \n",
    "    return acc\n",
    "\n",
    "    \n",
    "nphases = stats['base'].phase_trace.nphases\n",
    "name_map={'fr':'Fixed Rate', 'm4': 'Markov 4', 'm8':'Markov 8', 'all':'All'}\n",
    "data_mean = {}\n",
    "data_std = {}\n",
    "data_std_up = {}\n",
    "data_std_down = {}\n",
    "\n",
    "for name in stats:\n",
    "    if name is 'base' or name is 'all':\n",
    "        continue\n",
    "    acc_mean = []\n",
    "    acc_std = []\n",
    "    for i in range(nphases):\n",
    "        agg = []\n",
    "        for j in range(len(stats[name])):\n",
    "            agg.append(get_acc(stats['base'], stats[name][j], i))\n",
    "        acc_mean.append(np.mean(agg))\n",
    "        acc_std.append(np.std(agg))\n",
    "    data_mean[name_map[name]] = acc_mean\n",
    "    data_std[name_map[name]] = acc_std\n",
    "    data_std_up[name_map[name]] = [acc_mean[i] + acc_std[i] for i in range(len(acc_mean))]\n",
    "    data_std_down[name_map[name]] = [acc_mean[i] - acc_std[i] for i in range(len(acc_mean))]\n",
    "\n",
    "acc_mean_df = pd.DataFrame(data_mean)\n",
    "acc_std_df = pd.DataFrame(data_std)\n",
    "acc_std_up_df = pd.DataFrame(data_std_up)\n",
    "acc_std_down_df = pd.DataFrame(data_std_down)\n",
    "\n",
    "print('Mean Accuracy')\n",
    "print(acc_mean_df)\n",
    "print('Stddev Accuracy')\n",
    "print(acc_std_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{table}[hp]\n",
      "\\caption{Mean Per-Phase Accuracy (10 Runs)}\\label{tab:acc}\n",
      "\\begin{tabularx}{\\linewidth}{|l|X|X|X|X|X|}\n",
      "\\hline{}\n",
      " & Phase 0 & Phase 1 & Phase 2 & Phase 3 & Phase 4 \\\\ \\hline\\hline\n",
      "Fixed Rate & 0.67 & 0.99 & 0.70 & 0.53 & 0.74 \\\\ \\hline\n",
      "Markov 4 & 0.68 & 0.98 & 0.71 & 0.62 & 0.82 \\\\ \\hline\n",
      "Markov 8 & 0.73 & 0.98 & 0.88 & 0.69 & 0.93 \\\\ \\hline\n",
      "All & 0.73 & 0.99 & 0.88 & 0.69 & 0.93 \\\\ \\hline\n",
      "\\end{tabularx}\n",
      "\\end{table}\n",
      "\n",
      "\\begin{table}[hp]\n",
      "\\caption{Std.Dev. in Per-Phase Accuracy (10 Runs)}\\label{tab:stddev}\n",
      "\\begin{tabularx}{\\linewidth}{|l|X|X|X|X|X|}\n",
      "\\hline{}\n",
      " & Phase 0 & Phase 1 & Phase 2 & Phase 3 & Phase 4 \\\\ \\hline\\hline\n",
      "Fixed Rate & 0.0004 & 0.0000 & 0.0002 & 0.0003 & 0.0002 \\\\ \\hline\n",
      "Markov 4 & 0.0004 & 0.0001 & 0.0002 & 0.0004 & 0.0001 \\\\ \\hline\n",
      "Markov 8 & 0.0006 & 0.0001 & 0.0001 & 0.0005 & 0.0001 \\\\ \\hline\n",
      "All & 0.0005 & 0.0000 & 0.0002 & 0.0004 & 0.0001 \\\\ \\hline\n",
      "\\end{tabularx}\n",
      "\\end{table}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Format these as latex tables\n",
    "\n",
    "\n",
    "def latex_table_2(df):\n",
    "    s = \"\\\\begin{table}[hp]\\n\"\n",
    "    s += \"\\\\caption{Mean Per-Phase Accuracy (10 Runs)}\\\\label{tab:acc}\\n\"\n",
    "    s += \"\\\\begin{tabularx}{\\\\linewidth}{|l|X|X|X|X|X|}\\n\"\n",
    "    s += \"\\\\hline{}\\n\"\n",
    "    s += \" & Phase 0 & Phase 1 & Phase 2 & Phase 3 & Phase 4 \\\\\\\\ \\\\hline\\\\hline\\n\"\n",
    "    for i in df:\n",
    "        s += \"{} & {:.2f} & {:.2f} & {:.2f} & {:.2f} & {:.2f} \\\\\\\\ \\\\hline\\n\".format(i, df[i][0], df[i][1], df[i][2], df[i][3], df[i][4])\n",
    "    s += \"\\\\end{tabularx}\\n\\\\end{table}\\n\"\n",
    "    return s\n",
    "def latex_table_4(df):\n",
    "    s = \"\\\\begin{table}[hp]\\n\"\n",
    "    s += \"\\\\caption{Std.Dev. in Per-Phase Accuracy (10 Runs)}\\\\label{tab:stddev}\\n\"\n",
    "    s += \"\\\\begin{tabularx}{\\\\linewidth}{|l|X|X|X|X|X|}\\n\"\n",
    "    s += \"\\\\hline{}\\n\"\n",
    "    s += \" & Phase 0 & Phase 1 & Phase 2 & Phase 3 & Phase 4 \\\\\\\\ \\\\hline\\\\hline\\n\"\n",
    "    for i in df:\n",
    "        s += \"{} & {:.4f} & {:.4f} & {:.4f} & {:.4f} & {:.4f} \\\\\\\\ \\\\hline\\n\".format(i, df[i][0], df[i][1], df[i][2], df[i][3], df[i][4])\n",
    "    s += \"\\\\end{tabularx}\\n\\\\end{table}\\n\"\n",
    "    return s\n",
    "    \n",
    "        \n",
    "print(latex_table_2(acc_mean_df))\n",
    "\n",
    "print(latex_table_4(acc_std_df))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ny = 5\n",
    "cmap = plt.get_cmap(\"tab10\")\n",
    "fig, ax = plt.subplots(figsize=(4,3))\n",
    "\n",
    "mark = {'Fixed Rate':'+', 'Markov 4':'_',  'Markov 8':'^', 'All':'x'}\n",
    "\n",
    "for name in acc_mean_df:\n",
    "    ax.plot(acc_mean_df[name], \n",
    "            linestyle=(0, (2,4)),\n",
    "            marker='o')\n",
    "\n",
    "\n",
    "ax.set_ylim((0,1))\n",
    "\n",
    "\n",
    "ax.set_ylabel('Accuracy')\n",
    "ax.set_xlabel('Phase')\n",
    "cmap = plt.get_cmap(\"tab10\")\n",
    "\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.spines['left'].set_visible(False)\n",
    "ax.text( x=4.1, y=acc_mean_df['Fixed Rate'][ny-1], s='Fixed Rate', color=cmap(0))\n",
    "ax.text( x=4.1, y=acc_mean_df['Markov 4'][ny-1], s='Markov 4', color=cmap(1))\n",
    "ax.text( x=4.1, y=acc_mean_df['Markov 8'][ny-1], s='Markov 8', color=cmap(2))\n",
    "\n",
    "ax.text(x=0, y=.05, s='Initialization', rotation=90, color='grey')\n",
    "ax.text(x=1, y=.05, s='Marker', rotation=90, color='grey')\n",
    "ax.text(x=2, y=.05, s='High Locality', rotation=90, color='grey')\n",
    "ax.text(x=3, y=.05, s='Vector Add', rotation=90, color='grey')\n",
    "ax.text(x=4, y=.05, s='Random', rotation=90, color='grey')\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig('DataPMBS20/plots_{}/per-phase-accuracy.pdf'.format(sizel))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "## Accuracy Over Time\n",
       "Let's now take a look at how accuracy changes over the course of a simulation. Does it get worse over time? \n",
       "\n",
       "As we're using the small trace, we won't see much here. Please re-run the notebook to get a better large chart. \n",
       "\n",
       "The reason a legend isn't generated is because it is hard to place it well. To get a legend, re-run the plot and uncomment the line labeled as such. \n",
       "Then grab the legend and paste it onto the plot in a good area. \n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "## Accuracy Over Time\n",
    "Let's now take a look at how accuracy changes over the course of a simulation. Does it get worse over time? \n",
    "\n",
    "As we're using the small trace, we won't see much here. Please re-run the notebook to get a better large chart. \n",
    "\n",
    "The reason a legend isn't generated is because it is hard to place it well. To get a legend, re-run the plot and uncomment the line labeled as such. \n",
    "Then grab the legend and paste it onto the plot in a good area. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "interval_len = 10000\n",
    "def acc_over_time(st1, st2, phase):\n",
    "    \n",
    "    t1 = st1.cache_trace[0] # cache trace from st1 \n",
    "    \n",
    "    # Just get accesses where were are in phase `phase` and in state is Swapped (2)\n",
    "    t2_temp = st2[0].cache_trace[0]\n",
    "    pick_state = t2_temp['state'] == 2\n",
    "    pick_phase = t2_temp['phase'] == phase\n",
    "    pick = np.logical_and(pick_state, pick_phase)\n",
    "\n",
    "    t1_hits = t1['isHit'][pick]\n",
    "    nintervals = int(len(t1_hits) // interval_len)-1\n",
    "    \n",
    "    acc = np.zeros((len(st2), nintervals))\n",
    "\n",
    "    for j in range(len(st2)):\n",
    "        t2 = st2[j].cache_trace[0] # cache trace from st2\n",
    "    \n",
    "        # Get the hit/miss from each \n",
    "        t2_hits = t2['isHit'][pick]\n",
    "        \n",
    "        for i in range(nintervals):\n",
    "            start = i*interval_len\n",
    "            end   = (i+1)*interval_len\n",
    "            t1_hits_rest = t1_hits[start:end]\n",
    "            t2_hits_rest = t2_hits[start:end]\n",
    "    \n",
    "            num_correct = np.sum(np.equal(t1_hits_rest, t2_hits_rest))\n",
    "            acc[j, i] = num_correct / interval_len\n",
    "    \n",
    "    mean = np.mean(acc, axis=0)\n",
    "    std = np.std(acc, axis=0)\n",
    "    return mean, std\n",
    "\n",
    "nphases = stats['base'].phase_trace.nphases\n",
    "name_map={'fr':'Fixed Rate', 'm4': 'Markov 4', 'm8':'Markov 8', 'all':'All'}\n",
    "all_df = {}\n",
    "for i in range(nphases):\n",
    "    data = {}\n",
    "    for name in stats:\n",
    "        if name is 'base':\n",
    "            continue\n",
    "        data[name_map[name]],_ = acc_over_time(stats['base'], stats[name], i)\n",
    "    data_df = pd.DataFrame(data)    \n",
    "    all_df[i] = data_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x216 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pretty=['Initialization', 'Marker', 'High Locality', 'Vector Add', 'Random']\n",
    "cmap = plt.get_cmap(\"tab10\")\n",
    "\n",
    "def acc_over_time_plot(ax, approx, m4, m8, phase):\n",
    "    ax.plot(approx, label='Fixed Rate')\n",
    "    ax.plot(m4, label='Markov 4')\n",
    "    ax.plot(m8, label='Markov 8')    \n",
    "    ax.set_ylim((0,1))\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.spines['left'].set_visible(False)\n",
    "    ax.get_yaxis().set_ticks([])\n",
    "    ax.set_title('Phase {}'.format(phase))\n",
    "    ax.text(x=0, y=.05, s=pretty[phase], color='grey')\n",
    "    \n",
    "    ax.scatter(0, approx[0], marker='v', color=cmap(0))\n",
    "    ax.scatter(0, m4[0], marker='+', color=cmap(1))\n",
    "    ax.scatter(0, m8[0], marker='x', color=cmap(2))\n",
    "    \n",
    "    adj_up=.015\n",
    "    if phase == 4:\n",
    "        ax.text(len(approx), approx[len(approx)-1]+adj_up, s='Fixed HR', ha='right', size=8, color=cmap(0))\n",
    "        ax.text(len(m4), m4[len(m4)-1]+adj_up, s='Markov 4', ha='right', size=8, color=cmap(1))\n",
    "        ax.text(len(m8), m8[len(m8)-1]+adj_up, s='Markov 8', ha='right', size=8, color=cmap(2))\n",
    "    if phase == 0:\n",
    "        ax.set_ylabel('Accuracy')\n",
    "        ax.get_yaxis().set_ticks([.2, .4, .6, .8, 1.])\n",
    "        ax.set_xlabel('Interval number')\n",
    "    if phase == 4:\n",
    "        pass\n",
    "        #ax.legend(loc=10) ##UNCOMMENT ME FOR LEGEND\n",
    "\n",
    "fig, ax = plt.subplots(1, 5, figsize=(12,3), squeeze=False)\n",
    "for phase in range(5):    \n",
    "    acc_over_time_plot(ax[0,phase], \n",
    "          all_df[phase]['Fixed Rate'],\n",
    "          all_df[phase]['Markov 4'],\n",
    "          all_df[phase]['Markov 8'],\n",
    "          phase)\n",
    "#Remove whitespace around plot\n",
    "plt.gca().xaxis.set_major_locator(plt.NullLocator())\n",
    "plt.gca().yaxis.set_major_locator(plt.NullLocator())\n",
    "\n",
    "plt.savefig('DataPMBS20/plots_{}/acc-over-time.pdf'.format(sizel))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "## Accuracy as a function of Model Size\n",
       "\n",
       "This is just a fun little plot. \n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "## Accuracy as a function of Model Size\n",
    "\n",
    "This is just a fun little plot. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x252 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "bs=8192\n",
    "sz = {'base':1, 'fr':24/bs, 'm4':(3 * (4 * 4) * 8)/bs, 'm8':(3 * (8 * 8) * 8)/bs}\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(4,3.5))\n",
    "\n",
    "cmap = plt.get_cmap(\"tab10\")\n",
    "for i in range(5):\n",
    "    ax.scatter([sz['fr']], acc_mean_df['Fixed Rate'][i], marker='${}$'.format(i), color=cmap(0), s=60)\n",
    "for i in range(5):\n",
    "    ax.scatter([sz['m4']], acc_mean_df['Markov 4'][i], marker='${}$'.format(i), color=cmap(1), s=60)\n",
    "for i in range(5):\n",
    "    ax.scatter([sz['m8']], acc_mean_df['Markov 8'][i], marker='${}$'.format(i), color=cmap(2), s=60)\n",
    "ax.scatter(1,1,  color=cmap(3))\n",
    "ax.set_xscale('log')\n",
    "\n",
    "\n",
    "labs=np.float64([24/bs, (3 * (4 * 4) * 8)/bs, (3 * (8 * 8) * 8)/bs, 1])*100\n",
    "ax.get_xaxis().set_ticks([24/bs, (3 * (4 * 4) * 8)/bs, (3 * (8 * 8) * 8)/bs, 1])\n",
    "ax.set_xticklabels(['{:.2f}%'.format(labs[i]) for i in range(4)])\n",
    "\n",
    "ax.get_yaxis().set_ticks([.2,.4,.6, .8, 1])\n",
    "\n",
    "ax.set_xlabel('Model Size (% of Base Cache)')\n",
    "ax.set_ylabel('Accuracy')\n",
    "ax.set_ylim(0,1.05)\n",
    "ax.set_xlim(0,1.5)\n",
    "ax.text(x=labs[0]/100, y=.05, s='Fixed Rate', rotation=90, color='grey')\n",
    "ax.text(x=labs[1]/100, y=.05, s='Markov 4', rotation=90, color='grey')\n",
    "ax.text(x=labs[2]/100, y=.05, s='Markov 8', rotation=90, color='grey')\n",
    "ax.text(x=labs[3]/100, y=.05, s='Base', rotation=90, color='grey')\n",
    "\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "\n",
    "#ax.set_title('Points are Phase Numbers', size=10)\n",
    "#fig.suptitle('Accuracy as a function of Model Size')\n",
    "\n",
    "plt.savefig('DataPMBS20/plots_{}/acc_vs_modelsize.pdf'.format(sizel))\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "# Model Scores\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "# Model Scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{table}\n",
      "\\caption{Model Scores (lower is better)}\\label{tab:scores}\n",
      "\\begin{tabularx}{\\linewidth}{|l|X|X|X|X|X|}\n",
      "\\hline{}\n",
      " & Phase 0 & Phase 1 & Phase 2 & Phase 3 & Phase 4 \\\\ \\hline\\hline\n",
      "Fixed Rate & 0.6875 & 0.0626 & 0.6035 & 0.9273 & 0.5188 \\\\ \\hline\n",
      "Markov 4 & 0.6519 & 0.0781 & 0.6070 & 0.7479 & 0.3842 \\\\ \\hline\n",
      "Markov 8 & 0.5802 & 0.2253 & 0.3313 & 0.6659 & 0.2668 \\\\ \\hline\n",
      "\\end{tabularx}\n",
      "\\end{table}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#stats['all'][0].phase_obj[0][4].score_history.get()\n",
    "d = np.zeros((5,3))\n",
    "for phase in stats['all'][0].phase_obj[0]:\n",
    "    if phase == -1:\n",
    "        continue\n",
    "    for i in range(3):\n",
    "        d[phase,i] = stats['all'][0].phase_obj[0][phase].score_history.get()[1][i]\n",
    "\n",
    "d = np.transpose(d)\n",
    "names={0:'Fixed Rate', 1:'Markov 4', 2:'Markov 8'}\n",
    "\n",
    "def score_table(df):\n",
    "    s = \"\\\\begin{table}\\n\"\n",
    "    s += \"\\\\caption{Model Scores (lower is better)}\\\\label{tab:scores}\\n\"\n",
    "    s += \"\\\\begin{tabularx}{\\\\linewidth}{|l|X|X|X|X|X|}\\n\"\n",
    "    s += \"\\\\hline{}\\n\"\n",
    "    s += \" & Phase 0 & Phase 1 & Phase 2 & Phase 3 & Phase 4 \\\\\\\\ \\\\hline\\\\hline\\n\"\n",
    "    for i in range(len(d)):\n",
    "        s += \"{} & {:.4f} & {:.4f} & {:.4f} & {:.4f} & {:.4f} \\\\\\\\ \\\\hline\\n\".format(names[i], d[i][0], d[i][1], d[i][2], d[i][3], d[i][4])\n",
    "    s += \"\\\\end{tabularx}\\n\\\\end{table}\\n\"\n",
    "    return s\n",
    "\n",
    "\n",
    "print(score_table(d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "## Locality Analysis\n",
       "\n",
       "Finally, we get to the hardest plot to generate, the locality plot. \n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "## Locality Analysis\n",
    "\n",
    "Finally, we get to the hardest plot to generate, the locality plot. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "def index(array, item):\n",
    "    for idx, val in enumerate(array):\n",
    "        if val == item:\n",
    "            return idx\n",
    "    return -1\n",
    "\n",
    "def rightshift(val: np.uint64, shift: np.uint64) -> np.uint64:\n",
    "    return val >> shift\n",
    "\n",
    "def reuse(trace, shift, outfile=None):\n",
    "    stack = np.array([], dtype=np.int64)\n",
    "    out = []\n",
    "    for i in tqdm(range(len(trace))):\n",
    "        addr = rightshift(trace[i], np.uint64(shift)) # Cache line\n",
    "        idx = index(stack, addr)\n",
    "        if idx == -1:\n",
    "            stack = np.insert(stack, 0, addr)\n",
    "        else:\n",
    "            out.append(idx)\n",
    "            stack = np.delete(stack, idx)\n",
    "            stack = np.insert(stack, 0, addr)\n",
    "\n",
    "    if outfile is not None:\n",
    "        save_object(out, outfile)\n",
    "        print('Wrote reuse trace to: {}'.format(outfile))\n",
    "        \n",
    "    return out\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 134238/134238 [01:41<00:00, 1326.93it/s]\n",
      "100%|██████████| 147223/147223 [00:21<00:00, 6727.18it/s]\n",
      "100%|██████████| 145995/145995 [00:24<00:00, 5976.24it/s]\n",
      "100%|██████████| 142677/142677 [00:35<00:00, 3971.09it/s]\n",
      "100%|██████████| 9910/9910 [00:08<00:00, 1126.22it/s]\n",
      "0it [00:00, ?it/s]\n",
      "100%|██████████| 19314/19314 [00:06<00:00, 3068.16it/s]\n",
      "100%|██████████| 20214/20214 [00:06<00:00, 3048.90it/s]\n",
      "100%|██████████| 428279/428279 [40:07<00:00, 177.92it/s]\n",
      "100%|██████████| 430296/430296 [07:02<00:00, 1018.92it/s]\n",
      "100%|██████████| 452872/452872 [08:54<00:00, 846.49it/s] \n",
      "100%|██████████| 430921/430921 [39:40<00:00, 181.04it/s]\n",
      "100%|██████████| 416968/416968 [04:01<00:00, 1724.97it/s]\n",
      "100%|██████████| 419095/419095 [03:15<00:00, 2140.84it/s]\n",
      "100%|██████████| 414141/414141 [03:36<00:00, 1913.98it/s]\n",
      "100%|██████████| 405620/405620 [03:38<00:00, 1855.23it/s]\n",
      "100%|██████████| 521732/521732 [01:07<00:00, 7724.60it/s]\n",
      "100%|██████████| 521319/521319 [00:23<00:00, 22442.14it/s]\n",
      "100%|██████████| 506815/506815 [00:37<00:00, 13594.37it/s]\n",
      "100%|██████████| 526050/526050 [01:00<00:00, 8706.46it/s] \n"
     ]
    }
   ],
   "source": [
    "reuse_perphase_base    = {}\n",
    "reuse_perphase_approx  = {}\n",
    "reuse_perphase_markov4 = {}\n",
    "reuse_perphase_markov8 = {}\n",
    "gran=6\n",
    "\n",
    "def get_addrs(data, phase):\n",
    "    df = pd.DataFrame(data)\n",
    "    return np.array(df[df['phase']==phase]['addr'], dtype=np.uint64)\n",
    "\n",
    "for phase in range(0,5):\n",
    "    reuse_perphase_base[phase] = reuse(get_addrs(stats['base'].cache_trace[1], phase), gran)\n",
    "    reuse_perphase_approx[phase] = reuse(get_addrs(stats['fr'][0].cache_trace[1], phase), gran)\n",
    "    reuse_perphase_markov4[phase] = reuse(get_addrs(stats['m4'][0].cache_trace[1], phase), gran)\n",
    "    reuse_perphase_markov8[phase] = reuse(get_addrs(stats['m8'][0].cache_trace[1], phase), gran)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "reuse_perphase_base=sim.load_object('reuse_backup/reuse_perphase_base.pkl')\n",
    "reuse_perphase_approx=sim.load_object('reuse_backup/reuse_perphase_approx.pkl')\n",
    "reuse_perphase_markov4=sim.load_object('reuse_backup/reuse_perphase_markov4.pkl')\n",
    "reuse_perphase_markov8=sim.load_object('reuse_backup/reuse_perphase_markov8.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x360 with 20 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "binwidth=16\n",
    "#maxbin={1:50, 2:850, 3:225, 4:50}\n",
    "mb=500\n",
    "maxbin={0:mb,1:mb, 2:mb, 3:mb, 4:mb}\n",
    "\n",
    "yl=125000\n",
    "ylim={0:yl,1:yl, 2:yl, 3:yl, 4:yl}\n",
    "\n",
    "\n",
    "def bins(data, binwidth, maxbin):\n",
    "    #return range(min(data), min(maxbin, max(data) + binwidth), binwidth)\n",
    "   # print(data)\n",
    "    return range(min(data), maxbin, binwidth)\n",
    "\n",
    "def plot(ax, data, title, phase, plot_labels=False):\n",
    "    if not data:\n",
    "        data = [1]\n",
    "    ax.hist(data, bins=bins(data, binwidth, maxbin=maxbin[phase]), color='black')\n",
    "    ax.set_yscale('log')\n",
    "    ax.set_ylim((0,ylim[phase]))\n",
    "    #ax.suptitle(title)\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.spines['left'].set_visible(False)\n",
    "    ax.get_yaxis().set_ticks([])\n",
    "    ax.get_xaxis().set_ticks([])\n",
    "    ax.set_xticklabels([''])\n",
    "    #ax.get_yaxis().set_ticks([30000])\n",
    "\n",
    "\n",
    "    if plot_labels:\n",
    "        ax.set_yticklabels(['30k'])\n",
    "\n",
    "    \n",
    "#plot(reuse_perphase_base[1], 'Base Cache', maxbin=maxbin[1])\n",
    "#plot(reuse_perphase_approx[1], 'Fixed Rate Cache', maxbin=maxbin[1])\n",
    "#plot(reuse_perphase_markov4[1], '4-State Markov Cache', maxbin=maxbin[1])\n",
    "#plot(reuse_perphase_markov8[1], '8-State Markov Cache', maxbin=maxbin[1])\n",
    "\n",
    "#i = 1\n",
    "\n",
    "fig, ax = plt.subplots(4, 5, figsize=(9,5))\n",
    "for i in range(5):\n",
    "    #phase = i+1\n",
    "    phase=i\n",
    "    \n",
    "    plot(ax[0,i], reuse_perphase_base[phase], 'Base Cache', phase, plot_labels=(phase==0))\n",
    "    plot(ax[1,i], reuse_perphase_approx[phase], 'Fixed Rate Cache', phase)\n",
    "    plot(ax[2,i], reuse_perphase_markov4[phase], '4-State Markov Cache', phase)\n",
    "    plot(ax[3,i], reuse_perphase_markov8[phase], '8-State Markov Cache', phase)\n",
    "\n",
    "for i in range(5):\n",
    "    ax[3,i].text(s='Phase {}'.format(i), y=-.2, x=.5, ha='center', transform=ax[3,i].transAxes)\n",
    "    \n",
    "    \n",
    "ax[0,0].text(s='Base', y=10000,x=100, size=10)\n",
    "ax[1,0].text(s='Fixed HR', y=10000,x=100, size=10)\n",
    "ax[2,0].text(s='Markov 4', y=10000,x=100, size=10)\n",
    "ax[3,0].text(s='Markov 8', y=10000,x=100, size=10)\n",
    "\n",
    "#fig.suptitle('Per-Phase Reuse Distance')\n",
    "plt.savefig('DataPMBS20/plots_{}/locality_per_phase.pdf'.format(sizel))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "sim.save_object(reuse_perphase_base, 'reuse_backup/reuse_perphase_base.pkl')\n",
    "sim.save_object(reuse_perphase_approx, 'reuse_backup/reuse_perphase_approx.pkl')\n",
    "sim.save_object(reuse_perphase_markov4, 'reuse_backup/reuse_perphase_markov4.pkl')\n",
    "sim.save_object(reuse_perphase_markov8, 'reuse_backup/reuse_perphase_markov8.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "# Error in L1/L2/L3 hits\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "# Error in L1/L2/L3 hits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{table}\n",
      "\\caption{Percent Change in Cache Stats}\\label{tab:loc_stats}\n",
      "\\begin{tabularx}{\\linewidth}{|l|X|X|X||X|}\n",
      "\\hline{}\n",
      " & L1 Hits & L2 Hits & L3 Hits & Cycles  \\\\ \\hline\\hline\n",
      "Base & 7.69e+06 & 7.78e+05 & 2.53e+05 & 1.37e+08 \\\\ \\hline\\hline\n",
      "Fixed Hit Rate & -0.07\\% & 54.11\\% & -71.11\\% & -27.91\\% \\\\ \\hline\n",
      "Markov 4 & -0.37\\% & 46.10\\% & -52.14\\% & -23.13\\% \\\\ \\hline\n",
      "Markov 8 & -0.19\\% & 12.13\\% & -4.18\\% & -7.59\\% \\\\ \\hline\n",
      "ALL & 0.07\\% & 10.12\\% & -4.65\\% & -7.99\\% \\\\ \\hline\n",
      "\\end{tabularx}\n",
      "\\end{table}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def get_stats(stats):\n",
    "    return np.array([stats.hitcount[0], stats.hitcount[1], stats.hitcount[2], stats.total_cycles])\n",
    "\n",
    "\n",
    "base = get_stats(stats['base'])\n",
    "\n",
    "acc2 = {}\n",
    "for name in stats:\n",
    "    if name is 'base':\n",
    "        continue\n",
    "        \n",
    "    dat = np.zeros((len(stats['fr']), 4))\n",
    "    \n",
    "    for i, st in enumerate(stats[name]):\n",
    "        dat[i,:] = get_stats(st)\n",
    "        \n",
    "    tmp = np.mean(dat, axis=0)\n",
    "    \n",
    "    tmp = [100*(tmp[i] - base[i]) / base[i] for i in range(len(tmp))]\n",
    "    \n",
    "    acc2[name]=tmp\n",
    "            \n",
    "names={'all':'ALL', 'm8':'Markov 8', 'm4':'Markov 4', 'fr':'Fixed Hit Rate'}\n",
    "        \n",
    "def latex_loc_stats(df):\n",
    "    s = \"\\\\begin{table}\\n\"\n",
    "    s += \"\\\\caption{Percent Change in Cache Stats}\\\\label{tab:loc_stats}\\n\"\n",
    "    s += \"\\\\begin{tabularx}{\\\\linewidth}{|l|X|X|X||X|}\\n\"\n",
    "    s += \"\\\\hline{}\\n\"\n",
    "    s += \" & L1 Hits & L2 Hits & L3 Hits & Cycles  \\\\\\\\ \\\\hline\\\\hline\\n\"        \n",
    "    s += \"{} & {:.2e} & {:.2e} & {:.2e} & {:.2e} \\\\\\\\ \\\\hline\\\\hline\\n\".format('Base', base[0], base[1], base[2], base[3])\n",
    "    for i in df:\n",
    "        s += \"{} & {:.2f}\\\\% & {:.2f}\\\\% & {:.2f}\\\\% & {:.2f}\\\\% \\\\\\\\ \\\\hline\\n\".format(names[i], df[i][0], df[i][1], df[i][2], df[i][3])\n",
    "    s += \"\\\\end{tabularx}\\n\\\\end{table}\\n\"\n",
    "    return s\n",
    "print(latex_loc_stats(acc2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}