CF21Plots.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "# Parsec Traces\n",
       "\n",
       "5 Programs\n",
       "\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "# Parsec Traces\n",
    "\n",
    "5 Programs\n",
    "\n"
   ]
  },
  {
   "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\n",
    "import importlib\n",
    "importlib.reload(sim)\n",
    "pass\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Paths\n",
    "os.chdir('/storage/home/hhive1/plavin3/data/ModelSwapping')\n",
    "DATADIR = '/storage/home/hhive1/plavin3/scratch/DataV5/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Params\n",
    "SIZE    = 'simdev'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Available Choices for parsec traces\n",
    "app_names        = ['blackscholes', 'bodytrack', 'ferret', 'fluidanimate', 'freqmine']\n",
    "parsec_sizes     = ['simdev', 'simsmall']\n",
    "models           = ['BASE', 'FR', 'M4', 'M8', 'ALL', 'ACC']\n",
    "suffixes         = ['data', 'model']\n",
    "\n",
    "meabo_sizes      = ['small', 'medium', 'large']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Represents a single data or model file. The memory can be repeatedly freed and reloaded with free() and reload().\n",
    "\n",
    "class ParsecFile:\n",
    "    def __init__(self, app, size, model, suffix, openFile=False):\n",
    "        if app not in app_names:\n",
    "            raise ValueError('ParsecFile.init: app [{}] invalid'.format(app))\n",
    "        if size not in parsec_sizes:\n",
    "            raise ValueError('ParsecFile.init: size [{}] invalid'.format(size))\n",
    "        if model not in models:\n",
    "            raise ValueError('ParsecFile.init: model [{}] invalid'.format(model))\n",
    "        if suffix not in suffixes:\n",
    "            raise ValueError('ParsecFile.init: suffix [{}] invalid'.format(suffix))\n",
    "        \n",
    "        self.object    = None \n",
    "        self.filename  = DATADIR + app + '-' + size + '-' + model + '-' + suffix + '.pkl'\n",
    "        self.shortname = os.path.splitext(os.path.basename(os.path.normpath(self.filename)))[0]\n",
    "        self.app       = app\n",
    "        self.size      = size\n",
    "        self.model     = model\n",
    "        self.suffix    = suffix\n",
    "        self.file      = None\n",
    "        \n",
    "        if not os.path.exists(self.filename):\n",
    "            raise Exception('Error in ParsecFile.init: file [{}] not found'.format(self.filename))\n",
    "            \n",
    "        if openFile:\n",
    "            self.object= sim.load_object(self.filename)\n",
    "    \n",
    "    def load(self):\n",
    "        self.object= sim.load_object(self.filename)\n",
    "    \n",
    "    def free(self):\n",
    "        if self.object != None:\n",
    "            del self.object\n",
    "            self.object = None\n",
    "            \n",
    "class MeaboFile(ParsecFile):\n",
    "    def __init__(self, size, model, suffix, openFile=False):\n",
    "        if size not in meabo_sizes:\n",
    "            raise ValueError('MeaboFile.init: size [{}] invalid'.format(size))\n",
    "        if model not in models:\n",
    "            raise ValueError('MeaboFile.init: model [{}] invalid'.format(model))\n",
    "        if suffix not in suffixes:\n",
    "            raise ValueError('MeaboFile.init: suffix [{}] invalid'.format(suffix))\n",
    "        \n",
    "        self.object    = None \n",
    "        self.filename  = DATADIR + 'meabo_' + size + '-' + model + '-' + suffix + '.pkl'\n",
    "        self.shortname = os.path.splitext(os.path.basename(os.path.normpath(self.filename)))[0]\n",
    "        self.size      = size\n",
    "        self.model     = model\n",
    "        self.suffix    = suffix\n",
    "        self.file      = None\n",
    "        self.app       = 'meabo'\n",
    "        \n",
    "        if not os.path.exists(self.filename):\n",
    "            raise Exception('Error in MeaboFile.init: file [{}] not found'.format(self.filename))\n",
    "            \n",
    "        if openFile:\n",
    "            self.object= sim.load_object(self.filename)\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found all parsec files!\n",
      "Found all parsec-alt files!\n",
      "Found all meabo files!\n"
     ]
    }
   ],
   "source": [
    "# Check that all of our files exist\n",
    "missing  = False\n",
    "allfiles = []\n",
    "for app in app_names:\n",
    "    for m in models:\n",
    "        for s in suffixes:\n",
    "            try:\n",
    "                allfiles.append(ParsecFile(app, SIZE, m, s))\n",
    "            except:\n",
    "                missing = True\n",
    "                print('   Couldnt find {} {} {} {}'.format(app, SIZE, m, s))\n",
    "\n",
    "if missing: \n",
    "    print('Some parsec files weren\\'t found!')\n",
    "else:\n",
    "    print('Found all parsec files!')\n",
    "    \n",
    "missing  = False\n",
    "filesaltblack = []\n",
    "for app in app_names:\n",
    "    if app is 'blackscholes':\n",
    "        sz = 'simsmall'\n",
    "    else:\n",
    "        sz = 'simdev'\n",
    "    for m in models:\n",
    "        for s in suffixes:\n",
    "            try:\n",
    "                filesaltblack.append(ParsecFile(app, sz, m, s))\n",
    "            except:\n",
    "                missing = True\n",
    "                print('   Couldnt find {} {} {} {}'.format(app, SIZE, m, s))\n",
    "\n",
    "if missing: \n",
    "    print('Some parsec-alt files weren\\'t found!')\n",
    "else:\n",
    "    print('Found all parsec-alt files!')\n",
    "                \n",
    "missing  = False\n",
    "meabofiles = []\n",
    "for sz in meabo_sizes:\n",
    "    for m in models:\n",
    "        for s in suffixes:\n",
    "            try:\n",
    "                meabofiles.append(MeaboFile(sz, m, s))\n",
    "            except:\n",
    "                missing = True\n",
    "                print('   Couldnt find {} {} {}'.format(sz, m, s))\n",
    "\n",
    "if missing: \n",
    "    print('Some meabo files weren\\'t found!')\n",
    "else:\n",
    "    print('Found all meabo files!')\n",
    "\n",
    "\n",
    "    \n",
    "FILESETNAME = 'meabo' # should be either 'simdevaltblack' or 'simdev' or 'meabo'\n",
    "\n",
    "if FILESETNAME is 'simdevaltblack':\n",
    "    fileset = filesaltblack\n",
    "elif FILESETNAME is 'simdev':\n",
    "    fileset = allfiles\n",
    "elif FILESETNAME is 'meabo':\n",
    "    fileset = meabofiles\n",
    "    meabosize = 'large'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "meabo_small-BASE-data\n",
      "meabo_small-FR-data\n",
      "meabo_small-M4-data\n",
      "meabo_small-M8-data\n",
      "meabo_small-ALL-data\n",
      "meabo_small-ACC-data\n",
      "meabo_medium-BASE-data\n",
      "meabo_medium-FR-data\n",
      "meabo_medium-M4-data\n",
      "meabo_medium-M8-data\n",
      "meabo_medium-ALL-data\n",
      "meabo_medium-ACC-data\n",
      "meabo_large-BASE-data\n",
      "meabo_large-FR-data\n",
      "meabo_large-M4-data\n",
      "meabo_large-M8-data\n",
      "meabo_large-ALL-data\n",
      "meabo_large-ACC-data\n"
     ]
    }
   ],
   "source": [
    "def listize(a):\n",
    "    if a and not isinstance(a, list):\n",
    "        return [a]\n",
    "    return a\n",
    "\n",
    "def validate(val, gold):\n",
    "    if val is None:\n",
    "        return\n",
    "    for v in val:\n",
    "        if v not in gold:\n",
    "            raise ValueError('{} is not a valid value'.format(v))\n",
    "    \n",
    "    \n",
    "# Utility function for working with lists of data as opposed to loading all the data\n",
    "# TODO: drop all this and use Dask\n",
    "def subset(files, app=None, model=None, size=None, suffix=None):\n",
    "\n",
    "    app    = listize(app)\n",
    "    model  = listize(model)\n",
    "    size   = listize(size)\n",
    "    suffix = listize(suffix)\n",
    "    \n",
    "    validate(app, app_names)\n",
    "    validate(size, parsec_sizes)\n",
    "    validate(model, models)\n",
    "    validate(suffix, suffixes)\n",
    "    \n",
    "    ret = files\n",
    "    \n",
    "    if app is not None:\n",
    "        files = ret\n",
    "        ret = []\n",
    "        for f in files:\n",
    "            if f.app in app:\n",
    "                ret.append(f)            \n",
    "\n",
    "    if model is not None:\n",
    "        files = ret\n",
    "        ret   = []\n",
    "        for f in files:\n",
    "            if f.model in model:\n",
    "                ret.append(f)\n",
    "        \n",
    "    if size is not None:\n",
    "        files = ret\n",
    "        ret   = []\n",
    "        for f in files:\n",
    "            if f.size in size:\n",
    "                ret.append(f)\n",
    "                \n",
    "    if suffix is not None:\n",
    "        files = ret\n",
    "        ret   = []\n",
    "        for f in files:\n",
    "            if f.suffix in suffix:\n",
    "                ret.append(f)\n",
    "    \n",
    "                \n",
    "    if len(ret) == 0:\n",
    "        raise Exception('subset() refuses to return an empty list')\n",
    "        \n",
    "    return ret\n",
    "\n",
    "def print_filenames(files):\n",
    "    files = listize(files)\n",
    "    for f in files:\n",
    "        print(f.shortname)\n",
    "        \n",
    "                \n",
    "print_filenames(subset(fileset, suffix='data'))\n",
    "#print(subset(allfiles, app='bodytrack', model='M4', suffix='data'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "asdf\n",
      "['asdf']\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "### Phase Trace Object\n",
       "We first need to grab the phase trace object from the stats of our simulation. It is stored in `stats_*.phase_trace`. This object\n",
       "has type `PhaseTrace` which is defined in `PhaseDetector.py` and includes 4 fields.\n",
       "\n",
       "* `trace`: The phase assigned to each interval. -1 represents an interval not identified as part of a phase. \n",
       "* `nphases`: The number of unique phases identified.\n",
       "* `phase_count`: A list of length nphases where phase_count[i] is the number of intervals assigned to phase i\n",
       "* `phase_unique`: A list of length nphases where phase_unique[i] is the number of times phase i was entered\n",
       "\n",
       "Let's take a look at these for the 'large' trace. \n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "### Phase Trace Object\n",
    "We first need to grab the phase trace object from the stats of our simulation. It is stored in `stats_*.phase_trace`. This object\n",
    "has type `PhaseTrace` which is defined in `PhaseDetector.py` and includes 4 fields.\n",
    "\n",
    "* `trace`: The phase assigned to each interval. -1 represents an interval not identified as part of a phase. \n",
    "* `nphases`: The number of unique phases identified.\n",
    "* `phase_count`: A list of length nphases where phase_count[i] is the number of intervals assigned to phase i\n",
    "* `phase_unique`: A list of length nphases where phase_unique[i] is the number of times phase i was entered\n",
    "\n",
    "Let's take a look at these for the 'large' trace. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "meabo_small-BASE-data :\n",
      "  Identified 6 phases\n",
      "  Number of intervals assigned to each phase [3, 11, 43, 21, 8, 32]\n",
      "meabo_medium-BASE-data :\n",
      "  Identified 6 phases\n",
      "  Number of intervals assigned to each phase [3, 11, 77, 47, 21, 69]\n",
      "meabo_large-BASE-data :\n",
      "  Identified 7 phases\n",
      "  Number of intervals assigned to each phase [3, 9, 45, 114, 231, 112, 337]\n"
     ]
    }
   ],
   "source": [
    "def phase_summary(file):\n",
    "    file.load()\n",
    "    \n",
    "    tr=file.object.phase_trace\n",
    "    print(file.shortname, ':')\n",
    "    print('  Identified', tr.nphases, 'phases')\n",
    "    print('  Number of intervals assigned to each phase', tr.phase_count)\n",
    "    #print('  Number of times each phase was entered', tr.phase_unique)\n",
    "    file.free()\n",
    "    \n",
    "for file in subset(fileset, model='BASE', suffix='data'):\n",
    "    phase_summary(file)\n",
    "#for tr in slu.keys():\n",
    "#    if 'BASE' in slu[tr].keys():\n",
    "#        phase_summary(tr, slu[tr]['BASE'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 3 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",
    "    ax.set_yticks([-1, *range(max(trace)+1)])\n",
    "    if axis_labels:\n",
    "        ax.set_ylabel('Phase Number (-1 is uncategorized)')\n",
    "        ax.set_xlabel('Interval number (Interval = 10k inst)')\n",
    "\n",
    "local_files = subset(fileset, model='BASE', suffix='data')\n",
    "fig, ax = plt.subplots(1, len(local_files), figsize=(16,4))\n",
    "\n",
    "for idx, file in enumerate(local_files):\n",
    "    file.load()\n",
    "    if FILESETNAME == 'meabo':\n",
    "        label = file.size\n",
    "    else:\n",
    "        label = file.app\n",
    "    plot_trace(ax[idx], label,  file.object.phase_trace.trace,  idx == 0)\n",
    "    file.free()\n",
    "    \n",
    "plt.savefig(DATADIR+'/plots/phase-traces-{}.svg'.format(FILESETNAME))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "->meabo accuracy\n"
     ]
    },
    {
     "ename": "Exception",
     "evalue": "Too man files in list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mException\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-8179625ce0fd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     43\u001b[0m     \u001b[0mbase\u001b[0m   \u001b[0;34m=\u001b[0m \u001b[0msubset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfileset\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'BASE'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapp\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mapp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msuffix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'data'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     44\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbase\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 45\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Too man files in list'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     46\u001b[0m     \u001b[0mbase\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbase\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     47\u001b[0m     \u001b[0mothers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msubset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfileset\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'FR'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'M4'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'M8'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'ALL'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'ACC'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapp\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mapp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msuffix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'data'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mException\u001b[0m: Too man files in list"
     ]
    }
   ],
   "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",
    "def get_stats(base, others):\n",
    "    nphases = base.phase_trace.nphases\n",
    "    name_map={'FR':'Fixed Rate', 'M4': 'Markov 4', 'M8':'Markov 8', 'ALL':'All', 'ACC':'ACC'}\n",
    "    data = {}\n",
    "    for file in others:\n",
    "        file.load()\n",
    "        _acc = []\n",
    "        for i in range(nphases):\n",
    "            _acc.append(get_acc(base, file.object, i))\n",
    "        data[name_map[file.model]] = _acc\n",
    "        file.free()\n",
    "    return pd.DataFrame(data)\n",
    "\n",
    "acc = {}\n",
    "\n",
    "#local_files = subset(allfiles, suffix='data')\n",
    "#print_filenames(local_files)\n",
    "\n",
    "for app in app_names:\n",
    "    print('->{} accuracy'.format(app))\n",
    "    base   = subset(fileset, model='BASE', app=app, suffix='data')\n",
    "    if len(base) > 1:\n",
    "        raise Exception('Too man files in list')\n",
    "    base = base[0]\n",
    "    others = subset(fileset, model=['FR', 'M4', 'M8', 'ALL', 'ACC'], app=app, suffix='data')\n",
    "    \n",
    "    base.load()\n",
    "    acc[app] = get_stats(base.object, others)\n",
    "    print(acc[app])\n",
    "    print()\n",
    "    base.free()\n",
    "\n",
    "sim.save_object(acc, DATADIR+'intermediate/acc-{}.pkl'.format(FILESETNAME))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 612x720 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "nn=1\n",
    "name_map={'FR':'Fixed Rate', 'M4': 'Markov 4', 'M8':'Markov 8', 'ALL':'All', 'ACC':'ACC'}\n",
    "\n",
    "local_models = [name_map[x] for x in ['FR', 'M4', 'M8','ACC']]\n",
    "def acc_plot(ax, acc, tr):\n",
    "    df = acc[tr]\n",
    "    \n",
    "    # Subset models\n",
    "    df = df[local_models]\n",
    "    ny = len(df)\n",
    "    #ax=plt.gca()\n",
    "    df.plot(xticks=[*range(0,ny,1)],\n",
    "            yticks=[i/nn for i in range(0,nn+1)], \n",
    "                 title='{} per-phase accuracy'.format(tr),ax=ax, \n",
    "                 marker='o', linestyle=(0, (2,4)))\n",
    "    ax.set_ylabel('Accuracy')\n",
    "    ax.set_xlabel('Phase')\n",
    "    #ax.get_legend().remove()\n",
    "\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    cmap = plt.get_cmap(\"tab10\")\n",
    "    #ax.text( x=ny-1+.1, y=df['Fixed Rate'][ny-1], s='Fixed Rate', color=cmap(0))\n",
    "    #ax.text( x=4.1, y=df['Markov 4'][ny-1], s='Markov 4', color=cmap(1))\n",
    "    #ax.text( x=4.1, y=df['Markov 8'][ny-1], s='Markov 8', color=cmap(2))\n",
    "    plt.tight_layout()\n",
    "\n",
    "fig, ax = plt.subplots(len(app_names), 1, figsize=(8.5,10))\n",
    "for idx, tr in enumerate(app_names):\n",
    "    acc_plot(ax[idx], acc, tr)\n",
    "    #acc_plot(acc, slu, 'steam2')\n",
    "plt.savefig(DATADIR+'/plots/per-phase-accuracy-{}.svg'.format(FILESETNAME))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "blackscholes\n",
      "bodytrack\n",
      "ferret\n",
      "fluidanimate\n",
      "freqmine\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x648 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "nn=1\n",
    "maxidx=len(slu.keys())\n",
    "barwidth=.2\n",
    "\n",
    "colors = plt.cm.get_cmap('tab10').colors\n",
    "colormap={'All': colors[0], 'Markov 4':colors[1], 'Markov 8':colors[2], 'Fixed Rate':colors[3]}\n",
    "\n",
    "\n",
    "def acc_plot(ax, acc, slu, tr, idx):\n",
    "    df = acc[tr]\n",
    "    ny = slu[tr]['BASE'].phase_trace.nphases\n",
    "    #ax=plt.gca()\n",
    "    print(tr)\n",
    "    for idx,k in enumerate(acc[tr]):\n",
    "        bars=acc[tr][k]\n",
    "        r = np.arange(len(bars)) + barwidth*idx\n",
    "        ax.bar(r, bars, color=colormap[k], width=barwidth, edgecolor='white', label='var1')\n",
    "\n",
    "    #ax.xticks([r + barwidth for r in range(len(bars))], ['A', 'B', 'C', 'D'])\n",
    "    ax.set_yticks([0,1])\n",
    "    ax.set_xticks([*range(0,22,1)])\n",
    "    \n",
    "\n",
    "    \n",
    "    #df.plot(xticks=[*range(0,ny,1)],\n",
    "    #        yticks=[i/nn for i in range(0,nn+1)], \n",
    "    #             title='{}'.format(tr),ax=ax, \n",
    "    #             marker='o', linestyle=(0, (2,4)))\n",
    "    #if idx == maxidx - 1:\n",
    "    #    ax.set_ylabel('Accuracy')\n",
    "    #    ax.set_xlabel('Phase')\n",
    "\n",
    "    #ax.get_legend().remove()\n",
    "\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    #cmap = plt.get_cmap(\"tab10\")\n",
    "\n",
    "    #plt.tight_layout()\n",
    "\n",
    "fig, ax = plt.subplots(len(slu.keys()), 1, figsize=(10,9))\n",
    "for idx, tr in enumerate(slu.keys()):\n",
    "    if 'BASE' in slu[tr].keys():\n",
    "        acc_plot(ax[idx], acc, slu, tr, idx)\n",
    "    #acc_plot(acc, slu, 'steam2')\n",
    "#plt.savefig('plots/per-phase-accuracy.svg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Working on blackscholes\n",
      "Working on bodytrack\n",
      "Working on ferret\n",
      "Working on fluidanimate\n",
      "Working on freqmine\n",
      "             app model        L1         L2         L3     cycles\n",
      "0   blackscholes    FR  0.142755  59.984234 -85.226123 -43.703494\n",
      "1   blackscholes    M4  0.081033  57.510326 -81.512839 -41.299360\n",
      "2   blackscholes    M8 -0.185856  52.866413 -73.386895 -35.394945\n",
      "3   blackscholes   ALL -0.213015  53.430998 -73.879713 -35.578503\n",
      "4   blackscholes   ACC -0.182279  52.864388 -73.439449 -35.415795\n",
      "5      bodytrack    FR  0.063947  90.610497 -39.477542 -38.487638\n",
      "6      bodytrack    M4 -0.144719  91.284288 -38.334284 -36.767313\n",
      "7      bodytrack    M8 -0.448652  84.064544 -31.873645 -30.930248\n",
      "8      bodytrack   ALL -0.383725  82.632478 -30.985314 -31.009528\n",
      "9      bodytrack   ACC -0.365063  82.154396 -32.246690 -30.886170\n",
      "10        ferret    FR  1.208474  37.032825 -53.420955 -31.134320\n",
      "11        ferret    M4  1.484294  32.753992 -51.722209 -29.780169\n",
      "12        ferret    M8  0.365291  37.336819 -45.862191 -26.471810\n",
      "13        ferret   ALL  0.673146  35.167177 -46.116531 -26.874089\n",
      "14        ferret   ACC  0.594329  35.475172 -45.999597 -26.549401\n",
      "15  fluidanimate    FR  3.756862  -2.406898 -83.053985 -37.736457\n",
      "16  fluidanimate    M4  3.721808  -2.246124 -83.887411 -37.180865\n",
      "17  fluidanimate    M8  3.331102   0.330624 -78.932023 -35.026580\n",
      "18  fluidanimate   ALL  3.750794  -3.237847 -83.021084 -36.724180\n",
      "19  fluidanimate   ACC  3.312272   0.515965 -78.541321 -35.024532\n",
      "20      freqmine    FR  1.225235  17.419305 -45.085833 -21.175781\n",
      "21      freqmine    M4  0.991521  17.443559 -44.505145 -17.977543\n",
      "22      freqmine    M8  0.489460  21.017236 -36.964434 -15.984839\n",
      "23      freqmine   ALL  1.029005  15.855458 -42.360639 -17.670066\n",
      "24      freqmine   ACC  0.526927  20.503006 -37.109045 -16.023918\n"
     ]
    }
   ],
   "source": [
    "def pct_change(new, old):\n",
    "    ret = []\n",
    "    for i,v in enumerate(new):\n",
    "        ret.append((v - old[i])/abs(old[i])*100)\n",
    "    return ret\n",
    "\n",
    "\n",
    "dd = []\n",
    "for app in app_names:\n",
    "    print('Working on {}'.format(app))\n",
    "    base = subset(fileset, app=app, model='BASE')[0]\n",
    "    base.load()\n",
    "    for model in ['FR', 'M4', 'M8', 'ALL', 'ACC']:\n",
    "        file = subset(fileset, app=app, model=model)[0]\n",
    "        file.load()\n",
    "\n",
    "        new = file.object.hitcount\n",
    "        old = base.object.hitcount\n",
    "    \n",
    "        new.append(file.object.total_cycles)\n",
    "        old.append(base.object.total_cycles)\n",
    "                   \n",
    "        pct = [app, model, *pct_change(new, old)]\n",
    "        dd.append(pct)\n",
    "\n",
    "        file.free()\n",
    "    base.free()\n",
    "    \n",
    "pct_change_df = pd.DataFrame(dd, columns=['app', 'model', 'L1', 'L2', 'L3', 'cycles'])\n",
    "print(pct_change_df)\n",
    "sim.save_object(pct_change_df, DATADIR+'/intermediate/pct_change-{}.pkl'.format(FILESETNAME))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grouped By Model\n",
      "             app model        L1         L2         L3     cycles\n",
      "0   blackscholes    FR  0.142755  59.984234 -85.226123 -43.703494\n",
      "5      bodytrack    FR  0.063947  90.610497 -39.477542 -38.487638\n",
      "10        ferret    FR  1.208474  37.032825 -53.420955 -31.134320\n",
      "15  fluidanimate    FR  3.756862  -2.406898 -83.053985 -37.736457\n",
      "20      freqmine    FR  1.225235  17.419305 -45.085833 -21.175781\n",
      "             app model        L1         L2         L3     cycles\n",
      "1   blackscholes    M4  0.081033  57.510326 -81.512839 -41.299360\n",
      "6      bodytrack    M4 -0.144719  91.284288 -38.334284 -36.767313\n",
      "11        ferret    M4  1.484294  32.753992 -51.722209 -29.780169\n",
      "16  fluidanimate    M4  3.721808  -2.246124 -83.887411 -37.180865\n",
      "21      freqmine    M4  0.991521  17.443559 -44.505145 -17.977543\n",
      "             app model        L1         L2         L3     cycles\n",
      "2   blackscholes    M8 -0.185856  52.866413 -73.386895 -35.394945\n",
      "7      bodytrack    M8 -0.448652  84.064544 -31.873645 -30.930248\n",
      "12        ferret    M8  0.365291  37.336819 -45.862191 -26.471810\n",
      "17  fluidanimate    M8  3.331102   0.330624 -78.932023 -35.026580\n",
      "22      freqmine    M8  0.489460  21.017236 -36.964434 -15.984839\n",
      "             app model        L1         L2         L3     cycles\n",
      "3   blackscholes   ALL -0.213015  53.430998 -73.879713 -35.578503\n",
      "8      bodytrack   ALL -0.383725  82.632478 -30.985314 -31.009528\n",
      "13        ferret   ALL  0.673146  35.167177 -46.116531 -26.874089\n",
      "18  fluidanimate   ALL  3.750794  -3.237847 -83.021084 -36.724180\n",
      "23      freqmine   ALL  1.029005  15.855458 -42.360639 -17.670066\n",
      "             app model        L1         L2         L3     cycles\n",
      "4   blackscholes   ACC -0.182279  52.864388 -73.439449 -35.415795\n",
      "9      bodytrack   ACC -0.365063  82.154396 -32.246690 -30.886170\n",
      "14        ferret   ACC  0.594329  35.475172 -45.999597 -26.549401\n",
      "19  fluidanimate   ACC  3.312272   0.515965 -78.541321 -35.024532\n",
      "24      freqmine   ACC  0.526927  20.503006 -37.109045 -16.023918\n",
      "\n",
      "Grouped By Apps\n",
      "             app model        L1         L2         L3     cycles\n",
      "0   blackscholes    FR  0.142755  59.984234 -85.226123 -43.703494\n",
      "1   blackscholes    M4  0.081033  57.510326 -81.512839 -41.299360\n",
      "2   blackscholes    M8 -0.185856  52.866413 -73.386895 -35.394945\n",
      "3   blackscholes   ALL -0.213015  53.430998 -73.879713 -35.578503\n",
      "4   blackscholes   ACC -0.182279  52.864388 -73.439449 -35.415795\n",
      "5      bodytrack    FR  0.063947  90.610497 -39.477542 -38.487638\n",
      "6      bodytrack    M4 -0.144719  91.284288 -38.334284 -36.767313\n",
      "7      bodytrack    M8 -0.448652  84.064544 -31.873645 -30.930248\n",
      "8      bodytrack   ALL -0.383725  82.632478 -30.985314 -31.009528\n",
      "9      bodytrack   ACC -0.365063  82.154396 -32.246690 -30.886170\n",
      "10        ferret    FR  1.208474  37.032825 -53.420955 -31.134320\n",
      "11        ferret    M4  1.484294  32.753992 -51.722209 -29.780169\n",
      "12        ferret    M8  0.365291  37.336819 -45.862191 -26.471810\n",
      "13        ferret   ALL  0.673146  35.167177 -46.116531 -26.874089\n",
      "14        ferret   ACC  0.594329  35.475172 -45.999597 -26.549401\n",
      "15  fluidanimate    FR  3.756862  -2.406898 -83.053985 -37.736457\n",
      "16  fluidanimate    M4  3.721808  -2.246124 -83.887411 -37.180865\n",
      "17  fluidanimate    M8  3.331102   0.330624 -78.932023 -35.026580\n",
      "18  fluidanimate   ALL  3.750794  -3.237847 -83.021084 -36.724180\n",
      "19  fluidanimate   ACC  3.312272   0.515965 -78.541321 -35.024532\n",
      "20      freqmine    FR  1.225235  17.419305 -45.085833 -21.175781\n",
      "21      freqmine    M4  0.991521  17.443559 -44.505145 -17.977543\n",
      "22      freqmine    M8  0.489460  21.017236 -36.964434 -15.984839\n",
      "23      freqmine   ALL  1.029005  15.855458 -42.360639 -17.670066\n",
      "24      freqmine   ACC  0.526927  20.503006 -37.109045 -16.023918\n"
     ]
    }
   ],
   "source": [
    "#pct_change_df = sim.load_object(DATADIR+'/intermediate/pct_change.pkl')\n",
    "\n",
    "print('Grouped By Model')\n",
    "for m in ['FR', 'M4', 'M8', 'ALL', 'ACC']:\n",
    "    print(pct_change_df[pct_change_df['model']==m])\n",
    "    \n",
    "print()\n",
    "print('Grouped By Apps')\n",
    "print(pct_change_df)\n",
    "#for app in app_names:\n",
    "#    print(pct_change_df[pct_change_df['app']==app])\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "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": 92,
   "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",
    "    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",
    "    nintervals = int(len(t1_hits) // interval_len)-1\n",
    "    \n",
    "    acc = []\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.append(num_correct / interval_len)\n",
    "    \n",
    "    return acc\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\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "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",
    "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",
    "    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",
    "#plt.savefig('plots/acc-over-time.svg')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "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": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 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()\n",
    "cmap = plt.get_cmap(\"tab10\")\n",
    "for i in range(5):\n",
    "    ax.scatter([sz['fr']], accuracy_df['Fixed Rate'][i], marker='${}$'.format(i), color=cmap(0), s=60)\n",
    "for i in range(5):\n",
    "    ax.scatter([sz['m4']], accuracy_df['Markov 4'][i], marker='${}$'.format(i), color=cmap(1), s=60)\n",
    "for i in range(5):\n",
    "    ax.scatter([sz['m8']], accuracy_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([.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('plots/acc_vs_modelsize.svg')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "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": 111,
   "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": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 26515/26515 [00:07<00:00, 3328.31it/s]\n",
      "100%|██████████| 27694/27694 [00:02<00:00, 10488.76it/s]\n",
      "100%|██████████| 26426/26426 [00:02<00:00, 9462.64it/s] \n",
      "100%|██████████| 26080/26080 [00:03<00:00, 7609.16it/s]\n",
      "100%|██████████| 4826/4826 [00:02<00:00, 2337.25it/s]\n",
      "0it [00:00, ?it/s]\n",
      "100%|██████████| 10253/10253 [00:01<00:00, 6556.16it/s]\n",
      "100%|██████████| 10851/10851 [00:01<00:00, 6900.54it/s]\n",
      "100%|██████████| 38604/38604 [00:44<00:00, 863.72it/s] \n",
      "100%|██████████| 39157/39157 [00:15<00:00, 2585.33it/s]\n",
      "100%|██████████| 39890/39890 [00:15<00:00, 2531.24it/s]\n",
      "100%|██████████| 39154/39154 [00:40<00:00, 970.48it/s] \n",
      "100%|██████████| 27781/27781 [00:05<00:00, 4956.51it/s]\n",
      "100%|██████████| 29881/29881 [00:04<00:00, 6106.55it/s]\n",
      "100%|██████████| 29946/29946 [00:05<00:00, 5900.33it/s]\n",
      "100%|██████████| 30012/30012 [00:05<00:00, 5731.53it/s]\n",
      "100%|██████████| 33025/33025 [00:02<00:00, 15125.95it/s]\n",
      "100%|██████████| 33649/33649 [00:01<00:00, 27364.02it/s]\n",
      "100%|██████████| 32104/32104 [00:01<00:00, 21853.44it/s]\n",
      "100%|██████████| 36357/36357 [00:02<00:00, 17691.74it/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'].cache_trace[1], phase), gran)\n",
    "    reuse_perphase_markov4[phase] = reuse(get_addrs(stats['m4'].cache_trace[1], phase), gran)\n",
    "    reuse_perphase_markov8[phase] = reuse(get_addrs(stats['m8'].cache_trace[1], phase), gran)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 20 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "binwidth=16\n",
    "#maxbin={1:50, 2:850, 3:225, 4:50}\n",
    "maxbin={0:200,1:200, 2:200, 3:200, 4:200}\n",
    "\n",
    "yl=45000\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):\n",
    "    if not data:\n",
    "        data = [1]\n",
    "    ax.hist(data, bins=bins(data, binwidth, maxbin=maxbin[phase]), color='black')\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",
    "    if phase == 0:\n",
    "        ax.get_yaxis().set_ticks([30000])\n",
    "        ax.set_yticklabels(['30k'])\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=(8,8))\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)\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",
    "#plt.savefig('plots/locality_per_phase.svg')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:svecachesim_ipykernel_conda_env]",
   "language": "python",
   "name": "conda-env-svecachesim_ipykernel_conda_env-py"
  },
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}