timePlots.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# matplotlib configuration\n",
    "plt.rcParams[\"figure.figsize\"] = (8, 8)\n",
    "plt.rcParams[\"axes.labelsize\"] = 14\n",
    "plt.rcParams[\"axes.labelweight\"] = \"bold\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def readTimeFiles(inFileName, inMode, numTests, delta, tCount=\"\"):\n",
    "    baseDir = \"time-tests\"\n",
    "    # Format of the timing files: $inFileName-$inMode$tCount-d$delta-run$i.out\n",
    "    times = []\n",
    "    for i in range(numTests):\n",
    "        with open(\"{}/{}-{}{}-d{}-run{}.out\".format(baseDir, inFileName, inMode, tCount, delta, i)) as f:\n",
    "            times.append(float(f.read()))\n",
    "    return times\n",
    "def isParallel(mode):\n",
    "    return mode.__contains__(\"parallel\")\n",
    "def readModesMean(benchDir, fileName, modes, numTimes, deltas, ts):\n",
    "    modeTime = dict()\n",
    "    for mode in modes:\n",
    "        for delta in deltas:\n",
    "            if isParallel(mode):\n",
    "                for tCount in ts:\n",
    "                    times = readTimeFiles(fileName, mode, numTimes, delta, tCount)\n",
    "                    modeTime[mode + \"-d{}t{}\".format(delta, tCount)] = np.mean(times)\n",
    "            else:\n",
    "                times = readTimeFiles(fileName, mode, numTimes)\n",
    "                modeTime[mode] = np.mean(times)\n",
    "    return modeTime\n",
    "def runReadModesMean(benchDir, fileName, modes, numTimes, deltas, ts):\n",
    "    modeTime = dict()\n",
    "    for mode in modes:\n",
    "        for delta in deltas:\n",
    "            if isParallel(mode):\n",
    "                for tCount in ts:\n",
    "                    os.system(\"bash testTimeBenchmarks.sh {} {}/{} {} {} {} 1> /dev/null\"\\\n",
    "                              .format(numTimes, benchDir, fileName, mode, delta, tCount))\n",
    "                    times = readTimeFiles(fileName, mode, numTimes, delta, tCount)\n",
    "                    modeTime[mode + \"-d{}t{}\".format(delta, tCount)] = np.mean(times)\n",
    "            else:\n",
    "                os.system(\"bash testTimeBenchmarks.sh {} {}/{} {} {} 1> /dev/null\".format(numTimes, benchDir, fileName, mode, delta))\n",
    "                times = readTimeFiles(fileName, mode, numTimes, delta)\n",
    "                modeTime[mode] = np.mean(times)\n",
    "    return modeTime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "modes = [\"dijkstra\", \"parallel\", \"parallel-bucket-fusion\"]\n",
    "deltaForTs = 1000\n",
    "tsForTs = np.arange(1, 9)\n",
    "numTimesForTs = 10\n",
    "modeTimePolblogsVarTs = runReadModesMean(\"benchmarks\", \"slashdot_posedges.mtx\", modes,\n",
    "                                                   numTimes=numTimesForTs, deltas=[deltaForTs], ts=tsForTs)\n",
    "modeTimeFacebookVarTs = runReadModesMean(\"benchmarks\", \"facebook-wchars.txt\", modes,\n",
    "                                                   numTimes=numTimesForTs, deltas=[deltaForTs], ts=tsForTs)\n",
    "modeTime08blocksVarTs = runReadModesMean(\"benchmarks\", \"08blocks.mtx\", modes,\n",
    "                                                   numTimes=numTimesForTs, deltas=[deltaForTs], ts=tsForTs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "deltaRange = []\n",
    "for i in range(4, 21):\n",
    "    deltaRange.append(2 ** i)\n",
    "threadsForDs = 4\n",
    "numTimesForDs = 10\n",
    "modeTimePolblogsVarDs = runReadModesMean(\"benchmarks\", \"slashdot_posedges.mtx\", modes,\n",
    "                                                   numTimes=numTimesForDs, deltas=deltaRange, ts=[threadsForDs])\n",
    "modeTimeFacebookVarDs = runReadModesMean(\"benchmarks\", \"facebook-wchars.txt\", modes,\n",
    "                                                   numTimes=numTimesForDs, deltas=deltaRange, ts=[threadsForDs])\n",
    "modeTime08blocksVarDs = runReadModesMean(\"benchmarks\", \"08blocks.mtx\", modes,\n",
    "                                                   numTimes=numTimesForDs, deltas=deltaRange, ts=[threadsForDs])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now plot these"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot experiments varying by number of threads\n",
    "def plotVarByThread(m, mode, delta, ts):\n",
    "    if not isParallel(mode):\n",
    "        plt.scatter([0], [m[mode]], label=mode)\n",
    "    else:\n",
    "        yAxis = []\n",
    "        for t in ts:\n",
    "            yAxis.append(m[mode + \"-d{}t{}\".format(delta, t)])\n",
    "        plt.plot(ts, yAxis, label=mode)\n",
    "def plotAllVarByThread(maps, plotTitles, modes):\n",
    "    figureDir = \"figures\"\n",
    "    for i in range(len(maps)):\n",
    "        plt.figure()\n",
    "        plt.title(plotTitles[i])\n",
    "        plt.xlabel(\"Number of threads (delta={})\".format(deltaForTs))\n",
    "        plt.ylabel(\"Execution time (secs)\")\n",
    "        plt.ylim(min(maps[i].values()) * 0.9, max(maps[i].values()) * 1.1)\n",
    "        for md in modes:\n",
    "            plotVarByThread(maps[i], md, deltaForTs, tsForTs)\n",
    "        plt.legend()\n",
    "        plt.savefig(figureDir + \"/\" + plotTitles[i] + \"VarTs\")\n",
    "        plt.show()\n",
    "\n",
    "varTsMaps = [modeTimePolblogsVarTs, modeTimeFacebookVarTs, modeTime08blocksVarTs]\n",
    "varTsPlotTitles = [\"PolBlogs\", \"Facebook\", \"08blocks\"]\n",
    "plotAllVarByThread(varTsMaps, varTsPlotTitles, modes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot experiments varying by delta\n",
    "def plotVarByDelta(m, mode, deltas, t):\n",
    "    if not isParallel(mode):\n",
    "        plt.scatter([0], [m[mode]], label=mode)\n",
    "    else:\n",
    "        yAxis = []\n",
    "        for d in deltas:\n",
    "            yAxis.append(m[mode + \"-d{}t{}\".format(d, t)])\n",
    "        plt.plot(deltas, yAxis, label=mode)\n",
    "    plt.xscale(\"log\")\n",
    "    plt.yscale(\"log\")\n",
    "def plotAllVarByDelta(maps, plotTitles, modes):\n",
    "    figureDir = \"figures\"\n",
    "    for i in range(len(maps)):\n",
    "        plt.figure()\n",
    "        plt.title(plotTitles[i])\n",
    "        plt.xlabel(\"Delta (#threads={})\".format(threadsForDs))\n",
    "        plt.ylabel(\"Execution time (secs)\")\n",
    "        plt.xlim(min(deltaRange) * 0.9, max(deltaRange) * 1.1)\n",
    "        for md in modes:\n",
    "            plotVarByDelta(maps[i], md, deltaRange, threadsForDs)\n",
    "        plt.legend()\n",
    "        plt.savefig(figureDir + \"/\" + plotTitles[i] + \"VarDs\")\n",
    "        plt.show()\n",
    "\n",
    "varDsMaps = [modeTimePolblogsVarDs, modeTimeFacebookVarDs, modeTime08blocksVarDs]\n",
    "varDsPlotTitles = [\"PolBlogs\", \"Facebook\", \"08blocks\"]\n",
    "plotAllVarByDelta(varDsMaps, varDsPlotTitles, modes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now varying the way the main loops is scheduled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: take the mean of a few runs, instead of just doing one\n",
    "scheduleList = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]\n",
    "times = []\n",
    "for schedule in scheduleList:\n",
    "    with open(\"time-tests/schedule{}-slash.out\".format(schedule)) as f:\n",
    "        times.append(float(f.read()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot it\n",
    "plt.figure()\n",
    "plt.plot(scheduleList, times)\n",
    "plt.xscale(\"log\")\n",
    "plt.yscale(\"log\")\n",
    "plt.savefig(\"figures/scheduleGraph\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}