embench.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "parameters"
    ]
   },
   "outputs": [],
   "source": [
    "basedir = '/home/jun/run/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "parameters"
    ]
   },
   "outputs": [],
   "source": [
    "dis = [\n",
    "    \"aha-mont64: Montgomery multiplication, branch low, memroy low, compute high\",\n",
    "    \"crc32: CRC error checking 32b, branch high, memory medium, compute low\",\n",
    "    \"cubic: Cubic root solver, branch low, memory medium, compute high \",\n",
    "    \"edn: More general filter, branch low, memory high , compute medium\",\n",
    "    \"huffbench: Compress/Decompress, branch medium, memory medium, compute medium\",\n",
    "    \"matmult-int: Integer matrix multiply, branch medium, memory medium, compute medium\",\n",
    "    \"md5sum: MD5 sum, characteristic unknown\",\n",
    "    \"minver: Matrix inversion, branch high, memory low, compute medium\",\n",
    "    \"nbody: Satellite N body, large data, branch medium, memory low, compute high\",\n",
    "    \"nettle-aes: AES encryption, characteristic unknown\",\n",
    "    \"nettle-sha256: SHA256 hash, characteristic unknown\",\n",
    "    \"nsichneu: PetriNet simulated by if-statements, branch medium, memory high, compute low\",\n",
    "    \"pico-jpeg: branch medium, memory medium, compute high\",\n",
    "    \"primecount: Prime counting, characteristic unknown\",\n",
    "    \"qrduino: qr code. branch low, memory medium, compute high\",\n",
    "    \"slre: super light regex engine, branch high, memory medium, compute medium\",\n",
    "    \"st: Statistics from WCET. branch medium, memory low, compute high\",\n",
    "    \"statemate: State machine (car window), branch high, memory high, compute low\",\n",
    "    \"tarfind: Tar file finder, characteristic unknown\",\n",
    "    \"ud: LUD composition Int, branch medium, memory low, compute high\",\n",
    "    \"wikisort: merge sort, branch medium, memory medium, compute medium\"\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "parameters"
    ]
   },
   "outputs": [],
   "source": [
    "comment = {'ahamont64': 'aha-mont64: Montgomery multiplication, branch low, memroy low, compute high',\n",
    "           'crc32': 'crc32: CRC error checking 32b, branch high, memory medium, compute low',\n",
    "           'cubic': 'cubic: Cubic root solver, branch low, memory medium, compute high ',\n",
    "           'edn': 'edn: More general filter, branch low, memory high , compute medium',\n",
    "           'huffbench': 'huffbench: Compress/Decompress, branch medium, memory medium, compute medium',\n",
    "           'matmultint': 'matmult-int: Integer matrix multiply, branch medium, memory medium, compute medium',\n",
    "           'md5sum': 'md5sum: MD5 sum, characteristic unknown', 'minver': 'minver: Matrix inversion, branch high, memory low, compute medium',\n",
    "           'nbody': 'nbody: Satellite N body, large data, branch medium, memory low, compute high',\n",
    "           'nettleaes': 'nettle-aes: AES encryption, characteristic unknown',\n",
    "           'nettlesha256': 'nettle-sha256: SHA256 hash, characteristic unknown',\n",
    "           'nsichneu': 'nsichneu: PetriNet simulated by if-statements, branch medium, memory high, compute low',\n",
    "           'picojpeg': 'pico-jpeg: branch medium, memory medium, compute high',\n",
    "           'primecount': 'primecount: Prime counting, characteristic unknown',\n",
    "           'qrduino': 'qrduino: qr code. branch low, memory medium, compute high',\n",
    "           'slre': 'slre: super light regex engine, branch high, memory medium, compute medium',\n",
    "           'st': 'st: Statistics from WCET. branch medium, memory low, compute high',\n",
    "           'statemate': 'statemate: State machine (car window), branch high, memory high, compute low',\n",
    "           'tarfind': 'tarfind: Tar file finder, characteristic unknown',\n",
    "           'ud': 'ud: LUD composition Int, branch medium, memory low, compute high',\n",
    "           'wikisort': 'wikisort: merge sort, branch medium, memory medium, compute medium'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "parameters"
    ]
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import re\n",
    "import string\n",
    "from typing import Dict, List, Tuple\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from pprint import pprint\n",
    "from matplotlib.lines import Line2D\n",
    "import matplotlib.transforms as mtransforms\n",
    "\n",
    "def find_top5_asymmetry(data: np.ndarray) -> Tuple:\n",
    "    asymmetry_matrix = np.abs(np.triu(data, k=1) - np.tril(data, k=-1).T)\n",
    "    asymmetry_combinations = np.triu(asymmetry_matrix, k=1)\n",
    "    top5_indices = np.unravel_index(np.argsort(\n",
    "        asymmetry_combinations, axis=None)[-5:], asymmetry_combinations.shape)\n",
    "    return top5_indices\n",
    "\n",
    "\n",
    "def draw_heatmap(title: str, data: np.ndarray, eventList: list) -> None:\n",
    "    xticklabels = eventList\n",
    "    yticklabels = list(reversed(eventList))\n",
    "    matrix_flipped = np.flipud(data)\n",
    "    ax = sns.heatmap(matrix_flipped, xticklabels=xticklabels,\n",
    "                     yticklabels=yticklabels)\n",
    "    plt.gcf().set_size_inches(10, 8)\n",
    "    line = Line2D([matrix_flipped.shape[1], 0], [\n",
    "        0, matrix_flipped.shape[0]], color='white')\n",
    "    plt.gca().add_line(line)\n",
    "    plt.title(title)\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def draw_heatmap_twin(comment: str, m16: np.ndarray, m256: np.ndarray, eventList: list, save: bool = False, name: str = None) -> None:\n",
    "    xticklabels = eventList\n",
    "    yticklabels = list(reversed(eventList))\n",
    "    matrix_flipped1 = np.flipud(m16)\n",
    "    matrix_flipped4 = np.flipud(m256)\n",
    "\n",
    "    fig, (ax1, ax2) = plt.subplots(1, 2)\n",
    "    global_max = max(np.max(matrix_flipped1), np.max(matrix_flipped4))\n",
    "\n",
    "    sns.heatmap(matrix_flipped1, ax=ax1, xticklabels=xticklabels,\n",
    "                yticklabels=yticklabels, vmin=0, vmax=global_max)\n",
    "    sns.heatmap(matrix_flipped4, ax=ax2, xticklabels=xticklabels,\n",
    "                yticklabels=yticklabels, vmin=0, vmax=global_max)\n",
    "\n",
    "    fig.autofmt_xdate(rotation=45)\n",
    "\n",
    "    ax1.set_title('Time Window: 16 cycle')\n",
    "    ax2.set_title('Time Window: 256 cycle')\n",
    "\n",
    "    fig.suptitle(comment, x=0.45, y=0.95, fontsize=14)\n",
    "    plt.gcf().set_size_inches(17, 7.5)\n",
    "    plt.subplots_adjust(top=0.8, wspace=0.4, hspace=3)\n",
    "    for ax in [ax1, ax2]:\n",
    "        line = Line2D([matrix_flipped1.shape[1], 0], [\n",
    "                      0, matrix_flipped1.shape[0]], color='white')\n",
    "        ax.add_line(line)\n",
    "        # ax.xaxis.labelpad = 1.0\n",
    "        # ax.tick_params(axis='x', pad=0)\n",
    "\n",
    "    import matplotlib.transforms as mtransforms\n",
    "    for ax in [ax1, ax2]:\n",
    "        labels = ax.get_xticklabels()\n",
    "        for label in labels:\n",
    "            yoffset = len(eventList)\n",
    "            trans = mtransforms.Affine2D().translate(0.5, yoffset+0.3) + ax.transData\n",
    "            label.set_transform(trans)\n",
    "    if save == True:\n",
    "        os.chdir(basedir)\n",
    "        plt.savefig(name+'.svg', format='svg')\n",
    "\n",
    "    # plt.show()\n",
    "\n",
    "\n",
    "def draw_heatmap_group(comment: str, m16: np.ndarray, m32: np.ndarray, m64: np.ndarray, m256: np.ndarray, eventList: list, save: bool = False, name: str = None) -> None:\n",
    "    xticklabels = eventList\n",
    "    yticklabels = list(reversed(eventList))\n",
    "    matrix_flipped1 = np.flipud(m16)\n",
    "    matrix_flipped2 = np.flipud(m32)\n",
    "    matrix_flipped3 = np.flipud(m64)\n",
    "    matrix_flipped4 = np.flipud(m256)\n",
    "\n",
    "    fig, axs = plt.subplots(2, 2)\n",
    "    global_max = max(np.max(matrix_flipped1), np.max(\n",
    "        matrix_flipped2), np.max(matrix_flipped3), np.max(matrix_flipped4))\n",
    "\n",
    "    sns.heatmap(matrix_flipped1, ax=axs[0, 0], xticklabels=xticklabels,\n",
    "                yticklabels=yticklabels, vmin=0, vmax=global_max)\n",
    "    sns.heatmap(matrix_flipped2, ax=axs[0, 1], xticklabels=xticklabels,\n",
    "                yticklabels=yticklabels, vmin=0, vmax=global_max)\n",
    "    sns.heatmap(matrix_flipped3, ax=axs[1, 0], xticklabels=xticklabels,\n",
    "                yticklabels=yticklabels, vmin=0, vmax=global_max)\n",
    "    sns.heatmap(matrix_flipped4, ax=axs[1, 1], xticklabels=xticklabels,\n",
    "                yticklabels=yticklabels, vmin=0, vmax=global_max)\n",
    "\n",
    "    fig.autofmt_xdate(rotation=45)\n",
    "\n",
    "    axs[0, 0].set_title('Time Window: 16 cycle')\n",
    "    axs[0, 1].set_title('Time Window: 32 cycle')\n",
    "    axs[1, 0].set_title('Time Window: 64 cycle')\n",
    "    axs[1, 1].set_title('Time Window: 256 cycle')\n",
    "\n",
    "    fig.suptitle(comment, x=0.45, y=0.95, fontsize=16)\n",
    "    plt.gcf().set_size_inches(17, 15.5)\n",
    "    plt.subplots_adjust(left=0.15, wspace=0.4, hspace=0.5)\n",
    "    for ax in axs.flatten():\n",
    "        line = Line2D([matrix_flipped1.shape[1], 0], [\n",
    "                      0, matrix_flipped1.shape[0]], color='white')\n",
    "        ax.add_line(line)\n",
    "        # ax.xaxis.labelpad = 1.0\n",
    "        # ax.tick_params(axis='x', pad=0)\n",
    "\n",
    "    import matplotlib.transforms as mtransforms\n",
    "    for ax in axs.flatten():\n",
    "        labels = ax.get_xticklabels()\n",
    "        for label in labels:\n",
    "            yoffset = len(eventList)\n",
    "            trans = mtransforms.Affine2D().translate(0.5, yoffset+0.3) + ax.transData\n",
    "            label.set_transform(trans)\n",
    "    if save == True:\n",
    "        os.chdir(basedir)\n",
    "        plt.savefig(name+'.svg', format='svg')\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def do_normalization(bench: str, matrix: np.ndarray, eventList: list) -> np.ndarray:\n",
    "    path = os.path.join(basedir, bench)\n",
    "    os.chdir(path)\n",
    "    numbers = []\n",
    "    final_counters = parse_stdout(bench)\n",
    "    ins = int(final_counters[\"Executed instructions\"])\n",
    "    numbers = [int(final_counters[event])*1000/ins for event in eventList]\n",
    "\n",
    "    ret = matrix / np.array(numbers)\n",
    "\n",
    "    # error checking\n",
    "    indices = np.where(ret > 1.1)\n",
    "    if indices[0].size != 0:\n",
    "        zipped = zip(indices[0], indices[1])\n",
    "        for i, j in zipped:\n",
    "            print(i, j)\n",
    "            print(numbers[j]*ins/1000)\n",
    "            print(eventList[i], eventList[j])\n",
    "            print(ret[i][j])\n",
    "        raise (Exception(\"Found elements at indices:\", indices, bench))\n",
    "    return ret\n",
    "\n",
    "\n",
    "def parse_stdout(bench: str) -> Dict:\n",
    "    path = os.path.join(basedir, bench)\n",
    "    os.chdir(path)\n",
    "    with open(bench+'.out', 'r') as f:\n",
    "        text = f.read()\n",
    "        lines = text.strip().split(\"\\n\")\n",
    "        start_index = lines.index(\"1145141919810\") + 1\n",
    "        relevant_lines = lines[start_index:]\n",
    "        key_value_pairs = [re.split(r\":\\s+\", line) for line in relevant_lines]\n",
    "        final_counters = {key: value for key, value in key_value_pairs}\n",
    "    return final_counters\n",
    "\n",
    "\n",
    "def get_ipc(bench: str) -> string:\n",
    "    # find the line start with \"IPC\", capture the number after it\n",
    "    path = os.path.join(basedir, bench)\n",
    "    os.chdir(path)\n",
    "    with open(bench+'.out', 'r') as f:\n",
    "        text = f.read()\n",
    "        lines = text.strip().split(\"\\n\")\n",
    "        for line in lines:\n",
    "            if line.startswith(\"IPC\"):\n",
    "                ret = 'IPC: '+ '{:.4f}'.format(float(line.split(':')[1]))\n",
    "                return ret \n",
    "\n",
    "\n",
    "def get_miss(bench: str) -> string:\n",
    "    final_count = parse_stdout(bench)\n",
    "    ki = int(final_count[\"Executed instructions\"])/1000\n",
    "    ret = \"MPKI of L1d: {:.4f}, L1i: {:.4f}, L2: {:.4f}, L3: {:.4f}\".format(int(final_count[\"l1dcache.overallMisses\"])/ki, int(\n",
    "        final_count[\"l1icache.overallMisses\"])/ki, int(final_count[\"l2cache.overallMisses\"])/ki, int(final_count[\"l3cache.overallMisses\"])/ki)\n",
    "    return ret\n",
    "\n",
    "\n",
    "def get_branch_miss(bench: str) -> string:\n",
    "    final_count = parse_stdout(bench)\n",
    "    ki = int(final_count[\"Executed instructions\"])/1000\n",
    "    path = os.path.join(basedir, bench, \"m5out\")\n",
    "    os.chdir(path)\n",
    "    with open('stats.txt', 'r') as f:\n",
    "        text = f.read()\n",
    "        lines = text.strip().split(\"\\n\")\n",
    "        incorrect = int()\n",
    "        for line in lines:\n",
    "            if line.startswith(\"board.processor.cores.core.branchPred.condIncorrect\"):\n",
    "                incorrect = int(line.split()[1])\n",
    "        return \"branch: {:.4f}\".format(incorrect/ki)\n",
    "\n",
    "\n",
    "def analyze(bench: str, normalize: bool = False, version: str = \"v2\") -> Tuple:\n",
    "    # map = {}\n",
    "    top_pairs = []\n",
    "\n",
    "    path = os.path.join(basedir, bench)\n",
    "    os.chdir(path)\n",
    "\n",
    "    final_counters = parse_stdout(bench)\n",
    "\n",
    "    ki = int(final_counters[\"Executed instructions\"])/1000\n",
    "    eventList = final_counters[\"recorded events\"].split()\n",
    "\n",
    "    assert len(eventList) == int(\n",
    "        final_counters[\"all events count\"]), \"event count mismatch\"\n",
    "\n",
    "    fd = 'bc16v1.txt'\n",
    "    with open(fd, 'r') as file:\n",
    "        data = file.read()\n",
    "    data_list = eval(data)\n",
    "    m16v1 = np.array(data_list, np.uint64) / ki\n",
    "\n",
    "    fd = 'bc16v2.txt'\n",
    "    with open(fd, 'r') as file:\n",
    "        data = file.read()\n",
    "    data_list = eval(data)\n",
    "    m16v2 = np.array(data_list, np.uint64) / ki\n",
    "\n",
    "    fd = 'bc32v1.txt'\n",
    "    with open(fd, 'r') as file:\n",
    "        data = file.read()\n",
    "    data_list = eval(data)\n",
    "    m32v1 = np.array(data_list, np.uint64) / ki\n",
    "\n",
    "    fd = 'bc32v2.txt'\n",
    "    with open(fd, 'r') as file:\n",
    "        data = file.read()\n",
    "    data_list = eval(data)\n",
    "    m32v2 = np.array(data_list, np.uint64) / ki\n",
    "\n",
    "    fd = 'bc64v1.txt'\n",
    "    with open(fd, 'r') as file:\n",
    "        data = file.read()\n",
    "    data_list = eval(data)\n",
    "    m64v1 = np.array(data_list, np.uint64) / ki\n",
    "\n",
    "    fd = 'bc64v2.txt'\n",
    "    with open(fd, 'r') as file:\n",
    "        data = file.read()\n",
    "    data_list = eval(data)\n",
    "    m64v2 = np.array(data_list, np.uint64) / ki\n",
    "\n",
    "    fd = 'bc128v1.txt'\n",
    "    with open(fd, 'r') as file:\n",
    "        data = file.read()\n",
    "    data_list = eval(data)\n",
    "    m128v1 = np.array(data_list, np.uint64) / ki\n",
    "\n",
    "    fd = 'bc128v2.txt'\n",
    "    with open(fd, 'r') as file:\n",
    "        data = file.read()\n",
    "    data_list = eval(data)\n",
    "    m128v2 = np.array(data_list, np.uint64) / ki\n",
    "\n",
    "    fd = 'bc256v1.txt'\n",
    "    with open(fd, 'r') as file:\n",
    "        data = file.read()\n",
    "    data_list = eval(data)\n",
    "    m256v1 = np.array(data_list, np.uint64) / ki\n",
    "\n",
    "    fd = 'bc256v2.txt'\n",
    "    with open(fd, 'r') as file:\n",
    "        data = file.read()\n",
    "    data_list = eval(data)\n",
    "    m256v2 = np.array(data_list, np.uint64) / ki\n",
    "\n",
    "    m32v1 = m32v1 + m16v1\n",
    "    m32v2 = m32v2 + m16v2\n",
    "    m64v1 = m64v1 + m32v1\n",
    "    m64v2 = m64v2 + m32v2\n",
    "    m128v1 = m128v1 + m64v1\n",
    "    m128v2 = m128v2 + m64v2\n",
    "    m256v1 = m256v1 + m128v1\n",
    "    m256v2 = m256v2 + m128v2\n",
    "\n",
    "    if normalize == True:\n",
    "        for i, m in enumerate([m16v1, m16v2, m32v1, m32v2, m64v1, m64v2, m128v1, m128v2, m256v1, m256v2]):\n",
    "            # print(i)\n",
    "            m = do_normalization(bench, m, eventList)\n",
    "            if i == 0:\n",
    "                m16v1 = m\n",
    "            elif i == 1:\n",
    "                m16v2 = m\n",
    "            elif i == 2:\n",
    "                m32v1 = m\n",
    "            elif i == 3:\n",
    "                m32v2 = m\n",
    "            elif i == 4:\n",
    "                m64v1 = m\n",
    "            elif i == 5:\n",
    "                m64v2 = m\n",
    "            elif i == 6:\n",
    "                m128v1 = m\n",
    "            elif i == 7:\n",
    "                m128v2 = m\n",
    "            elif i == 8:\n",
    "                m256v1 = m\n",
    "            elif i == 9:\n",
    "                m256v2 = m\n",
    "\n",
    "    top5_asymmetry_results = {}\n",
    "    top5_asymmetry_results[bench] = find_top5_asymmetry(m256v2)\n",
    "    # indices in index of event\n",
    "    indices = top5_asymmetry_results[bench]\n",
    "    top_pairs = [(eventList[i], eventList[j]) for i, j in zip(*indices)]\n",
    "\n",
    "    max_index = np.unravel_index(np.argmax(m16v2, axis=None), m16v2.shape)\n",
    "    top16 = (eventList[max_index[0]], eventList[max_index[1]])\n",
    "\n",
    "    max_index = np.unravel_index(np.argmax(m32v2, axis=None), m32v2.shape)\n",
    "    top32 = (eventList[max_index[0]], eventList[max_index[1]])\n",
    "\n",
    "    max_index = np.unravel_index(np.argmax(m64v2, axis=None), m64v2.shape)\n",
    "    top64 = (eventList[max_index[0]], eventList[max_index[1]])\n",
    "\n",
    "    max_index = np.unravel_index(np.argmax(m128v2, axis=None), m128v2.shape)\n",
    "    top128 = (eventList[max_index[0]], eventList[max_index[1]])\n",
    "\n",
    "    max_index = np.unravel_index(np.argmax(m256v2, axis=None), m256v2.shape)\n",
    "    top256 = (eventList[max_index[0]], eventList[max_index[1]])\n",
    "\n",
    "    tops = zip(\"top16, top32, top64, top128, top256\".split(\", \"),\n",
    "               [top16, top32, top64, top128, top256])\n",
    "\n",
    "    if version == \"v1\":\n",
    "        m = {key: value for (key, value) in zip(\"m16v1, m32v1, m64v1, m128v1, m256v1\".split(\n",
    "            \", \"), [m16v1, m32v1, m64v1, m128v1, m256v1])}\n",
    "    else:\n",
    "        m = {key: value for (key, value) in zip(\"m16v2, m32v2, m64v2, m128v2, m256v2\".split(\n",
    "            \", \"), [m16v2, m32v2, m64v2, m128v2, m256v2])}\n",
    "\n",
    "    # for i in \"m16v2, m32v2, m64v2, m128v2, m256v2\".split(', '):\n",
    "    #     print(m[i])\n",
    "\n",
    "    # return matrixs[bench], top_pairs[bench], tops[bench], events[bench]\n",
    "    return m, top_pairs, dict(tops), eventList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "benchlist = '''ahamont64 crc32 cubic edn huffbench matmultint md5sum minver nbody nettleaes\n",
    "    nettlesha256 nsichneu primecount qrduino slre st statemate tarfind ud wikisort'''.split()\n",
    "\n",
    "tops_n = {}\n",
    "matrixs_n = {}\n",
    "top_pairs_n = {}\n",
    "events = {}\n",
    "results = {}\n",
    "\n",
    "for bench in benchlist:\n",
    "    matrixs_n[bench], top_pairs_n[bench], tops_n[bench], events[bench] = analyze(\n",
    "        bench, normalize=True)\n",
    "\n",
    "for bench in benchlist:\n",
    "    with open(os.path.join(basedir, bench, bench+\".out\"), 'r') as file:\n",
    "        for line in file:\n",
    "            match = re.search(\n",
    "                r'Simulated time \\(ms\\): (\\d+\\.\\d+)', line)\n",
    "            if match:\n",
    "                results[bench] = float(match.group(1))\n",
    "\n",
    "\n",
    "def draw_heatmap_group_all(benchlist: list, matrixs_n: dict, events: dict,\n",
    "                           save: bool = False, name: str = None) -> None:\n",
    "    from collections import OrderedDict\n",
    "    d = OrderedDict()\n",
    "    for bench in benchlist:\n",
    "        d[bench] = matrixs_n[bench]['m16v2']\n",
    "\n",
    "    row = len(benchlist)//2\n",
    "    col = 2\n",
    "    fig, axs = plt.subplots(row, col)\n",
    "\n",
    "    ec = 0\n",
    "    for index, (bench, data) in enumerate(d.items()):\n",
    "        e = events[bench]\n",
    "        ec = len(e)\n",
    "        sns.heatmap(data, ax=axs[index//col, index % col], xticklabels=e, yticklabels=list(reversed(e)))\n",
    "\n",
    "    fig.autofmt_xdate(rotation=45)\n",
    "\n",
    "    for index, (bench, data) in enumerate(d.items()):\n",
    "        t = bench + \"\\n\" + get_miss(bench)+\", \" + \"\\nMPKI of\" + get_branch_miss(bench)+\"\\n\"+get_ipc(bench) \\\n",
    "        + \"  Time: \" + '{:.4f}'.format(results[bench]) + \"ms\"\n",
    "        axs[index//col, index % col].set_title(t)\n",
    "\n",
    "    plt.gcf().set_size_inches(16, 9*row)\n",
    "    plt.subplots_adjust(wspace=0.5, hspace=0.8)\n",
    "    for ax in axs.flatten():\n",
    "        line = Line2D([ec, 0], [0, ec], color='white')\n",
    "        ax.add_line(line)\n",
    "    # plt.suptitle(\"embench\\ntime window = 16 cycles\", y=0.94, fontsize=18)\n",
    "\n",
    "\n",
    "    for ax in axs.flatten():\n",
    "        labels = ax.get_xticklabels()\n",
    "        for label in labels:\n",
    "            yoffset = ec\n",
    "            trans = mtransforms.Affine2D().translate(0.5, yoffset+0.3) + ax.transData\n",
    "            label.set_transform(trans)\n",
    "\n",
    "    if save == True:\n",
    "        os.chdir(basedir)\n",
    "        plt.savefig(name+'.svg', format='svg')\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "draw_heatmap_group_all(benchlist, matrixs_n, events, save=False, name='embench_all_n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "benchlist = '''ahamont64 crc32 cubic edn huffbench matmultint md5sum minver nbody nettleaes\n",
    "    nettlesha256 nsichneu picojpeg primecount qrduino slre st statemate tarfind ud wikisort'''.split()\n",
    "# benchlist = [\"huffbench\"]\n",
    "\n",
    "for bench in benchlist:\n",
    "    m, p, t, e = analyze(bench, normalize=False)\n",
    "    # name = \"{bench}+{w1}+{w2}\".format(bench=bench, w1=16, w2=256)\n",
    "    name = bench+\"unnoramlized\"\n",
    "    t = comment[bench]+\"\\n\" + get_miss(bench)+\", \" + \\\n",
    "        get_branch_miss(bench)+\"\\n\"+get_ipc(bench)\n",
    "    # draw_heatmap_twin(t, m2['m16v2'], m2['m256v2'], e2, name)\n",
    "    draw_heatmap_group(t, m['m16v2'],\n",
    "                       m['m32v2'], m['m64v2'], m['m256v2'], e, save=False, name=name)\n",
    "    # for normalized version\n",
    "    m2, p2, t2, e2 = analyze(bench, normalize=True)\n",
    "    t2 = \"[normalized] \"+comment[bench]+\"\\n\" + \\\n",
    "        get_miss(bench)+\", \"+get_branch_miss(bench)+\"\\n\"+get_ipc(bench)\n",
    "    # name2 = \"{bench}+{w1}+{w2}\".format(bench=bench, w1=16, w2=256)\n",
    "    name2 = bench+\"noramlized\"\n",
    "    # draw_heatmap_twin(t2, m2['m16v2'], m2['m256v2'], e2, name2)\n",
    "    draw_heatmap_group(t2, m2['m16v2'],\n",
    "                       m2['m32v2'], m2['m64v2'], m2['m256v2'], e2, save=False, name=name2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "benchlist = [\"mm\"]\n",
    "# benchlist = [\"huffbench\"]\n",
    "\n",
    "for bench in benchlist:\n",
    "    m, p, t, e = analyze(bench, normalize=False)\n",
    "    # name = \"{bench}+{w1}+{w2}\".format(bench=bench, w1=16, w2=256)\n",
    "    name = bench+\"unnoramlized\"\n",
    "    t = \"mm\"+\"\\n\" + get_miss(bench)+\", \" + \\\n",
    "        get_branch_miss(bench)+\"\\n\"+get_ipc(bench)\n",
    "    # draw_heatmap_twin(t, m2['m16v2'], m2['m256v2'], e2, name)\n",
    "    draw_heatmap_group(t, m['m16v2'],\n",
    "                       m['m32v2'], m['m64v2'], m['m256v2'], e, save=False, name=name)\n",
    "    # for normalized version\n",
    "    m2, p2, t2, e2 = analyze(bench, normalize=True)\n",
    "    t2 = \"[normalized] \"+\"mm\"+\"\\n\" + \\\n",
    "        get_miss(bench)+\", \"+get_branch_miss(bench)+\"\\n\"+get_ipc(bench)\n",
    "    # name2 = \"{bench}+{w1}+{w2}\".format(bench=bench, w1=16, w2=256)\n",
    "    name2 = bench+\"noramlized\"\n",
    "    # draw_heatmap_twin(t2, m2['m16v2'], m2['m256v2'], e2, name2)\n",
    "    draw_heatmap_group(t2, m2['m16v2'],\n",
    "                       m2['m32v2'], m2['m64v2'], m2['m256v2'], e2, save=False, name=name2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "benchlist = '''ahamont64 crc32 cubic edn huffbench matmultint md5sum minver nbody nettleaes\n",
    "    nettlesha256 nsichneu picojpeg primecount qrduino slre st statemate tarfind ud wikisort'''.split()\n",
    "# benchlist = [\"huffbench\"]\n",
    "tops = {}\n",
    "matrixs = {}\n",
    "top_pairs = {}\n",
    "events = {}\n",
    "\n",
    "for bench in benchlist:\n",
    "    matrixs[bench], top_pairs[bench], tops[bench], events[bench] = analyze(\n",
    "        bench)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tops_n = {}\n",
    "matrixs_n = {}\n",
    "top_pairs_n = {}\n",
    "events = {}\n",
    "\n",
    "for bench in benchlist:\n",
    "    matrixs_n[bench], top_pairs_n[bench], tops_n[bench], events[bench] = analyze(\n",
    "        bench, normalize=True)\\\n",
    "\n",
    "for bench in benchlist:\n",
    "    print(bench)\n",
    "    pprint(tops_n[bench])\n",
    "    print(\"top 5 pairs\")\n",
    "    pprint(top_pairs_n[bench])\n",
    "    # newline\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "count = dict()\n",
    "for bench in benchlist:\n",
    "    for pair in top_pairs[bench]:\n",
    "        count[pair] = count.get(pair, 0) + 1\n",
    "\n",
    "print(\"Top pairs:\")\n",
    "pprint(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "count = dict()\n",
    "for bench in benchlist:\n",
    "    for pair in top_pairs_n[bench]:\n",
    "        count[pair] = count.get(pair, 0) + 1\n",
    "\n",
    "print(\"Top pairs:\")\n",
    "pprint(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for bench in benchlist:\n",
    "#     draw_heatmap(bench+\", 16 cycle\", matrixs[bench]['m16v2'], events[bench])\n",
    "#     draw_heatmap(bench+\", 256 cycle\", matrixs[bench]['m256v2'], events[bench])"
   ]
  }
 ],
 "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.10.6"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}