results.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "import regex as re\n",
    "import numpy as np\n",
    "from statistics import mean, stdev\n",
    "import matplotlib\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "from bento_bench import bar_plot, parse_elapsed_secs, get_avg_from_table_str, set_size\n",
    "import pandas as pd\n",
    "import json\n",
    "import os\n",
    "import seaborn as sns\n",
    "matplotlib.use(\"pgf\")\n",
    "matplotlib.rcParams.update({\n",
    "    \"pgf.texsystem\": \"pdflatex\",\n",
    "    'font.family': 'serif',\n",
    "    'text.usetex': True,\n",
    "    'pgf.rcfonts': False,\n",
    "    \"font.size\": 7,\n",
    "})\n",
    "fsl = [\"ext4-ordered\", \"ext4-journal\", \"Bento-fs\", \"Bento-prov\", \"Bento-user\"]\n",
    "tl = [1, 18]\n",
    "ops_workloads = [\"createfiles_1t.f\", \"deletefiles_1t.f\", \"fileserver.f\", \"varmail.f\", \"webserver.f\"]\n",
    "fb_ops_regex = \"\\d*.\\d*(?=\\sops\\/s)\"\n",
    "fb_mbs_regex = \"(?<=rd\\/wr\\s*)\\d*.\\d*(?=mb\\/s)\"\n",
    "fio_log_regex = \"(?<=^\\d*, )\\d*\"\n",
    "textwidth=470"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "otherapps_1 = [\"untar\", \"tar\"]\n",
    "otherapps_2 = [\"grep\"]\n",
    "otherapps_1_avg = {}\n",
    "otherapps_1_std = {}\n",
    "otherapps_2_avg = {}\n",
    "otherapps_2_std = {}\n",
    "fsl_tar = [\"ext4-ordered\", \"ext4-journal\", \"Bento-fs\", \"Bento-prov\"]\n",
    "for fs in fsl:\n",
    "\totherapps_2_avg[fs] = []\n",
    "\totherapps_2_std[fs] = []\n",
    "\tfor app in otherapps_2:\n",
    "\t\ttmp = []\n",
    "\t\tdir = \"./results/\" + fs + \"/\" + app\n",
    "\t\tfor f in os.listdir(dir):\n",
    "\t\t\ti = int(f.split(\"_\")[1])\n",
    "\t\t\tfr = open(dir + \"/\" + f, 'r')\n",
    "\t\t\tt = fr.read()\n",
    "\t\t\tfr.close()\n",
    "\t\t\tmatches = re.findall(\"\\d*:\\d*.\\d*(?=elapsed)\", t)\n",
    "\t\t\ttmp.append(parse_elapsed_secs(matches[0]))\n",
    "\t\totherapps_2_avg[fs].append(mean(tmp))\n",
    "\t\totherapps_2_std[fs].append(stdev(tmp))\n",
    "\n",
    "\tif fs == \"Bento-user\": continue # Bento-user tar is broken\n",
    "\n",
    "\totherapps_1_avg[fs] = []\n",
    "\totherapps_1_std[fs] = []\n",
    "\tfor app in otherapps_1:\n",
    "\t\ttmp = []\n",
    "\t\tdir = \"./results/\" + fs + \"/\" + app\n",
    "\t\tfor f in os.listdir(dir):\n",
    "\t\t\ti = int(f.split(\"_\")[1])\n",
    "\t\t\tfr = open(dir + \"/\" + f, 'r')\n",
    "\t\t\tt = fr.read()\n",
    "\t\t\tfr.close()\n",
    "\t\t\tmatches = re.findall(\"\\d*:\\d*.\\d*(?=elapsed)\", t)\n",
    "\t\t\ttmp.append(parse_elapsed_secs(matches[0]))\n",
    "\t\totherapps_1_avg[fs].append(mean(tmp))\n",
    "\t\totherapps_1_std[fs].append(stdev(tmp))\n",
    "\n",
    "fig, ax = plt.subplots(figsize=set_size(textwidth/2))\n",
    "bar_plot(ax, otherapps_1_avg, fsl_tar, yerr=otherapps_1_std, total_width=.8, single_width=.9)\n",
    "plt.xticks(range(len(otherapps_1)), otherapps_1)\n",
    "plt.ylim(0, 20)\n",
    "plt.ylabel(\"Time (s)\")\n",
    "plt.savefig(\"./plots/untartar.pgf\")\n",
    "\n",
    "print(\"Bento-user grep avg = \" + str(otherapps_2_avg[\"Bento-user\"][0]))\n",
    "print(\"Bento-user grep std = \" + str(otherapps_2_std[\"Bento-user\"][0]))\n",
    "fig, ax = plt.subplots(figsize=set_size(textwidth/2))\n",
    "bar_plot(ax, otherapps_2_avg, fsl, yerr=otherapps_2_std, total_width=.8, single_width=.9)\n",
    "plt.xticks(range(len(otherapps_2)), otherapps_2)\n",
    "plt.ylim(0, 4)\n",
    "plt.ylabel(\"Time (s)\")\n",
    "plt.savefig(\"./plots/grep.pgf\")\n",
    "\n",
    "plt.close()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Bento-user grep avg = 17.580000000000002\n",
      "Bento-user grep std = 3.834749013951239\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "redis = [\"set\", \"get\"]\n",
    "rocksdb = [\"fillrandom\", \"readrandom\"]\n",
    "redis_avg = {}\n",
    "redis_std = {}\n",
    "rocksdb_avg = {}\n",
    "rocksdb_std = {}\n",
    "\n",
    "for fs in fsl:\n",
    "\tredis_avg[fs] = []\n",
    "\tredis_std[fs] = []\n",
    "\ttmp_set = []\n",
    "\ttmp_get = []\n",
    "\tdir = \"./results/\" + fs + \"/redis\"\n",
    "\tfor f in os.listdir(dir):\n",
    "\t\ti = int(f.split(\"_\")[1])\n",
    "\t\tfr = open(dir + \"/\" + f, 'r')\n",
    "\t\tt = fr.read()\n",
    "\t\tfr.close()\n",
    "\t\tmatches = re.findall(\"\\d*.\\d*(?= requests per second)\", t)\n",
    "\t\ttmp_set.append(float(matches[0]) * 0.0001) # convert\n",
    "\t\ttmp_get.append(float(matches[1]) * 0.0001) # convert\n",
    "\tredis_avg[fs].append(mean(tmp_set))\n",
    "\tredis_std[fs].append(stdev(tmp_set))\n",
    "\tredis_avg[fs].append(mean(tmp_get))\n",
    "\tredis_std[fs].append(stdev(tmp_get))\n",
    "\n",
    "\trocksdb_avg[fs] = []\n",
    "\trocksdb_std[fs] = []\n",
    "\ttmp_fillrandom = []\n",
    "\ttmp_readrandom = []\n",
    "\tdir = \"./results/\" + fs + \"/rocksdb\"\n",
    "\tfor f in os.listdir(dir):\n",
    "\t\ti = int(f.split(\"_\")[1])\n",
    "\t\tfr = open(dir + \"/\" + f, 'r')\n",
    "\t\tt = fr.read()\n",
    "\t\tfr.close()\n",
    "\t\tmatches = re.findall(\"\\d*.\\d*(?= MB/s)\", t)\n",
    "\t\ttmp_fillrandom.append(float(matches[0]))\n",
    "\t\ttmp_readrandom.append(float(matches[1]))\n",
    "\trocksdb_avg[fs].append(mean(tmp_fillrandom))\n",
    "\trocksdb_std[fs].append(stdev(tmp_fillrandom))\n",
    "\trocksdb_avg[fs].append(mean(tmp_readrandom))\n",
    "\trocksdb_std[fs].append(stdev(tmp_readrandom))\n",
    "\n",
    "fig, ax = plt.subplots(figsize=set_size(textwidth/2))\n",
    "bar_plot(ax, redis_avg, fsl, yerr=redis_std, total_width=.8, single_width=.9)\n",
    "plt.xticks(range(len(redis)), redis)\n",
    "plt.ylabel(\"MB/s\")\n",
    "plt.ylim(0, 33)\n",
    "plt.savefig(\"./plots/redis.pgf\")\n",
    "\n",
    "fig, ax = plt.subplots(figsize=set_size(textwidth/2))\n",
    "bar_plot(ax, rocksdb_avg, fsl, yerr=rocksdb_std, total_width=.8, single_width=.9)\n",
    "plt.xticks(range(len(rocksdb)), rocksdb)\n",
    "plt.ylabel(\"MB/s\")\n",
    "plt.ylim(0, 110)\n",
    "plt.savefig(\"./plots/rocksdb.pgf\")\n",
    "\n",
    "plt.close()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "fbresults = pd.DataFrame(columns=[\"fs\", \"workload\", \"T\", \"i\", \"r\"])\n",
    "for fs in fsl:\n",
    "\tfbfsresdir = \"./results/\" + fs + \"/filebench/\"\n",
    "\tfor f in os.listdir(fbfsresdir):\n",
    "\t\tfresdir = fbfsresdir + f\n",
    "\t\tfor r in os.listdir(fresdir):\n",
    "\t\t\trfile = open(fresdir + \"/\" + r)\n",
    "\t\t\trtext = rfile.read()\n",
    "\t\t\trfile.close()\n",
    "\n",
    "\t\t\tregex = \"\"\n",
    "\t\t\tif f in ops_workloads:\n",
    "\t\t\t\tregex = fb_ops_regex\n",
    "\t\t\telse:\n",
    "\t\t\t\tregex = fb_mbs_regex\n",
    "\n",
    "\t\t\tmatches = re.findall(regex, rtext)\n",
    "\n",
    "\t\t\tT = \"\"\n",
    "\t\t\tif \"1t\" in f:\n",
    "\t\t\t\t(T, i) = r.split(\"_\")\n",
    "\t\t\telse:\n",
    "\t\t\t\ti = r\n",
    "\n",
    "\t\t\tfbresults = fbresults.append({\"fs\": fs,\n",
    "\t\t\t\t\t\t       \"workload\": f.replace(\"_1t\", \"\"),\n",
    "\t\t\t\t\t\t       \"T\": T,\n",
    "\t\t\t\t\t\t       \"i\": i,\n",
    "\t\t\t\t\t\t       \"r\": float(matches[0])},\n",
    "\t\t\t\t\t\t      ignore_index=True)\n",
    "\n",
    "fbavg_cols = [\"Workload\"]\n",
    "for fs in fsl:\n",
    "\tfbavg_cols.append(fs)\n",
    "\n",
    "fbavg = pd.DataFrame(columns=fbavg_cols)\n",
    "for w in fbresults[\"workload\"].unique():\n",
    "\td = fbresults[fbresults[\"workload\"] == w]\n",
    "\tw = w.split(\".\")[0] # remove the file extension\n",
    "\tfor T in d[\"T\"].unique():\n",
    "\t\td1 = d[d[\"T\"] == T]\n",
    "\t\twT = w\n",
    "\t\tif T != \"\":\n",
    "\t\t\twT += \", T=\" + T\n",
    "\n",
    "\t\trow = { \"Workload\": wT }\n",
    "\t\tfor fs in fsl:\n",
    "\t\t\td2 = d1[d1[\"fs\"] == fs]\n",
    "\t\t\tr = str(round(d2[\"r\"].mean(), 2))\n",
    "\t\t\tif len(d2) > 1:\n",
    "\t\t\t\tr += \" (\" + str(round(d2[\"r\"].std(), 2)) + \")\"\n",
    "\t\t\trow[fs] = r\n",
    "\t\tfbavg = fbavg.append(row, ignore_index=True)\n",
    "\n",
    "sort_dict = {\n",
    "\t\"seq_read_4k, T=1\": 0, \"seq_read_32k, T=1\": 1,\"seq_read_128k, T=1\": 2,\"seq_read_1024k, T=1\": 3,\n",
    "\t\"seq_read_4k, T=18\": 4, \"seq_read_32k, T=18\": 5,\"seq_read_128k, T=18\": 6,\"seq_read_1024k, T=18\": 7,\n",
    "\t\"rand_read_4k, T=1\": 8, \"rand_read_32k, T=1\": 9,\"rand_read_128k, T=1\": 10,\"rand_read_1024k, T=1\": 11,\n",
    "\t\"rand_read_4k, T=18\": 12, \"rand_read_32k, T=18\": 13,\"rand_read_128k, T=18\": 14 ,\"rand_read_1024k, T=18\": 15,\n",
    "\t\"seq_write_4k, T=1\": 16, \"seq_write_32k, T=1\": 17,  \"seq_write_128k, T=1\": 18, \"seq_write_1024k, T=1\": 19,\n",
    "\t\"seq_write_4k, T=18\": 20, \"seq_write_32k, T=18\": 21,\"seq_write_128k, T=18\": 22,\"seq_write_1024k, T=18\": 23,\n",
    "\t\"rand_write_4k, T=1\": 24, \"rand_write_32k, T=1\": 25,\"rand_write_128k, T=1\": 26,\"rand_write_1024k, T=1\": 27,\n",
    "\t\"rand_write_4k, T=18\": 28, \"rand_write_32k, T=18\": 29,\"rand_write_128k, T=18\": 30 ,\"rand_write_1024k, T=18\": 31,\n",
    "\t\"createfiles, T=1\": 32, \"createfiles, T=18\": 33, \"deletefiles, T=1\": 34, \"deletefiles, T=18\": 35}\n",
    "fbavg = fbavg.sort_values(by=\"Workload\", key=lambda x: x.map(sort_dict))\n",
    "\n",
    "fbavg\n",
    "\n",
    "fbavg[:-3].drop([\"Bento-prov\"], axis=1).to_latex(\"./tables/filebench.txt\", index=False)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "app_workloads = [ \"varmail\", \"fileserver\", \"webserver\" ]\n",
    "app_workloads_avg = {}\n",
    "app_workloads_std = {}\n",
    "for fs in fsl:\n",
    "\tapp_workloads_avg[fs] = []\n",
    "\tapp_workloads_std[fs] = []\n",
    "\tfor aw in app_workloads:\n",
    "\t\tapp_workloads_avg[fs].append(float(fbavg[fbavg[\"Workload\"] == aw].iloc[0][fs].split(\" (\")[0]) / 1000)\n",
    "\t\tapp_workloads_std[fs].append(float(fbavg[fbavg[\"Workload\"] == aw].iloc[0][fs].split(\" (\")[1].split(\")\")[0]) / 1000)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=set_size(textwidth/2))\n",
    "bar_plot(ax, app_workloads_avg, fsl, yerr=app_workloads_std, total_width=.8, single_width=.9)\n",
    "plt.xticks(range(len(app_workloads)), app_workloads)\n",
    "plt.ylabel(\"KOps/s\")\n",
    "plt.savefig(\"./plots/app_workloads.pgf\", bbox_inches = \"tight\")\n",
    "plt.close()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "source": [
    "fbcmp = pd.DataFrame(columns=[\"Workload\"])\n",
    "\n",
    "for i, row in fbavg.iterrows():\n",
    "\tfbcmp.loc[i, \"Workload\"] = row[\"Workload\"]\n",
    "\tfbcmp.loc[i, \"Bento-fs:ext4-j\"] = round(get_avg_from_table_str(row[\"Bento-fs\"]) / get_avg_from_table_str(row[\"ext4-journal\"]), 2)\n",
    "\n",
    "fbcmp = fbcmp[:-3]\n",
    "\n",
    "paper_Bento_cmp = [1.01, 1.01, 1.01, 1.02, 1.00, 0.98, 0.99, 1.00, 1.01, 1.00, 1.00, 1.00, 1.02, 1.01, 1.00, 1.00,\n",
    "\t     1.46, 2.45, 4.12, 3.93, 1.16, 2.27, 6.55, 12.24, 1.15, 4.20, 6.24, 6.50, 1.41, 1.05, 1.09, 0.91]\n",
    "\n",
    "fbcmp[\"Paper Bento-fs:ext4-j\"] = paper_Bento_cmp\n",
    "\n",
    "\n",
    "for i, row in fbavg.iterrows():\n",
    "\tfbcmp.loc[i, \"Bento-user:ext4-j\"] = round(get_avg_from_table_str(row[\"Bento-user\"]) / get_avg_from_table_str(row[\"ext4-journal\"]), 2)\n",
    "fbcmp = fbcmp[:-3]\n",
    "\n",
    "paper_user_cmp = [1.01, 1.00, 1.01, 0.99, 0.99, 0.96, 1.00, 1.00, 1.00, 0.99, 0.98, 0.99, 1.02, 1.02, 1.00, 1.00,\n",
    "\t\t  0.02, 0.01, 0.01, 0.01, 0.07, 0.03, 0.03, 0.03, 0.04, 0.03, 0.03, 0.04, 0.02, 0.01, 0.03, 0.01]\n",
    "\n",
    "fbcmp[\"Paper Bento-user:ext4-j\"] = paper_user_cmp\n",
    "\n",
    "fbcmp.to_latex(\"./tables/filebench_cmp.txt\", index=False)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "clat = {}\n",
    "fiol = [\"randwrite\", \"write\", \"read\"]\n",
    "graph_names = {\n",
    "\t\"randwrite\": \"random write\",\n",
    "\t\"write\": \"sequential write\",\n",
    "\t\"read\": \"sequential read\",\n",
    "}\n",
    "fiofsl = [\"ext4-journal\", \"Bento-fs\"]\n",
    "fiofsl_ordered = {\n",
    "\t\"randwrite\": [\"ext4-journal\", \"Bento-fs\"],\n",
    "\t\"write\": [\"Bento-fs\", \"ext4-journal\"],\n",
    "\t\"read\": [\"Bento-fs\", \"ext4-journal\"],\n",
    "}\n",
    "fscolor = {\n",
    "\t\"ext4-journal\": '#ff7f0e',\n",
    "\t\"Bento-fs\": '#2ca02c'\n",
    "}\n",
    "for fs in fiofsl:\n",
    "\tclat[fs] = {}\n",
    "\td = \"./results/\" + fs + \"/fio/\"\n",
    "\tfor fio in fiol:\n",
    "\t\tfname = d + fio + \"_clat.1.log\"\n",
    "\t\tf = open(fname)\n",
    "\t\tmatches = re.findall(fio_log_regex, f.read(), re.MULTILINE)\n",
    "\t\tclat[fs][fio] = np.array(matches).astype(int) * 0.000001\n",
    "\n",
    "#xticks = [0, 100, 10000, 100000]\n",
    "yticks = [0, 0.2, 0.4, 0.6, 0.8, 1.0]\n",
    "for fio in fiol:\n",
    "\tfig, ax = plt.subplots(figsize=set_size(textwidth, fraction=0.3))\n",
    "\tax.set_xscale('log', base=2)\n",
    "\tax.set_xlabel(\"Latency (ms)\")\n",
    "\tax.set_ylabel(\"Proportion\")\n",
    "\tax.set_title(graph_names[fio])\n",
    "\t#ax.set_xticks(xticks)\n",
    "\tax.set_yticks(yticks)\n",
    "\tfor fs in fiofsl_ordered[fio]:\n",
    "\t\tx = np.sort(clat[fs][fio])\n",
    "\t\ty = np.arange(len(clat[fs][fio])) / len(clat[fs][fio])\n",
    "\t\tax.plot(x, y, color=fscolor[fs], label=fs)\n",
    "\tif fio == \"randwrite\":\n",
    "\t\thandles,labels = ax.get_legend_handles_labels()\n",
    "\t\thandles.reverse()\n",
    "\t\tlabels.reverse()\n",
    "\t\tax.legend(handles, labels, loc=\"lower right\")\n",
    "\telse:\n",
    "\t\tax.legend(loc=\"lower right\")\n",
    "\tplt.savefig(\"./plots/fio_latency_\" + fio + \".pgf\", bbox_inches = \"tight\")\n",
    "plt.close()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "fbramresults = pd.DataFrame(columns=[\"fs\", \"workload\", \"T\", \"i\", \"r\"])\n",
    "fbramfsl = [ \"Bento-fs\", \"ext4-journal\" ]\n",
    "for fs in fbramfsl:\n",
    "\tfbfsresdir = \"./results/ram/\" + fs + \"/filebench/\"\n",
    "\tfor f in os.listdir(fbfsresdir):\n",
    "\t\tfresdir = fbfsresdir + f\n",
    "\t\tfor r in os.listdir(fresdir):\n",
    "\t\t\trfile = open(fresdir + \"/\" + r)\n",
    "\t\t\trtext = rfile.read()\n",
    "\t\t\trfile.close()\n",
    "\n",
    "\t\t\tregex = \"\"\n",
    "\t\t\tif f in ops_workloads:\n",
    "\t\t\t\tregex = fb_ops_regex\n",
    "\t\t\telse:\n",
    "\t\t\t\tregex = fb_mbs_regex\n",
    "\n",
    "\t\t\tmatches = re.findall(regex, rtext)\n",
    "\n",
    "\t\t\tT = \"\"\n",
    "\t\t\tif \"1t\" in f:\n",
    "\t\t\t\t(T, i) = r.split(\"_\")\n",
    "\t\t\telse:\n",
    "\t\t\t\ti = r\n",
    "\n",
    "\t\t\tfbramresults = fbramresults.append({\"fs\": fs,\n",
    "\t\t\t\t\t\t       \"workload\": f.replace(\"_1t\", \"\"),\n",
    "\t\t\t\t\t\t       \"T\": T,\n",
    "\t\t\t\t\t\t       \"i\": i,\n",
    "\t\t\t\t\t\t       \"r\": float(matches[0])},\n",
    "\t\t\t\t\t\t      ignore_index=True)\n",
    "\n",
    "fbramavg_cols = [\"Workload\"]\n",
    "for fs in fbramfsl:\n",
    "\tfbramavg_cols.append(fs)\n",
    "\n",
    "fbramavg = pd.DataFrame(columns=fbramavg_cols)\n",
    "for w in fbramresults[\"workload\"].unique():\n",
    "\td = fbramresults[fbramresults[\"workload\"] == w]\n",
    "\tw = w.split(\".\")[0] # remove the file extension\n",
    "\tfor T in d[\"T\"].unique():\n",
    "\t\td1 = d[d[\"T\"] == T]\n",
    "\t\twT = w\n",
    "\t\tif T != \"\":\n",
    "\t\t\twT += \", T=\" + T\n",
    "\n",
    "\t\trow = { \"Workload\": wT }\n",
    "\t\tfor fs in fbramfsl:\n",
    "\t\t\td2 = d1[d1[\"fs\"] == fs]\n",
    "\t\t\tr = str(round(d2[\"r\"].mean(), 2))\n",
    "\t\t\tif len(d2) > 1:\n",
    "\t\t\t\tr += \" (\" + str(round(d2[\"r\"].std(), 2)) + \")\"\n",
    "\t\t\trow[fs] = r\n",
    "\t\tfbramavg = fbramavg.append(row, ignore_index=True)\n",
    "\n",
    "sort_dict = {\n",
    "\t\"seq_read_128k, T=1\": 0, \"seq_read_128k, T=18\": 1,\n",
    "\t\"rand_read_128k, T=1\": 2, \"rand_read_128k, T=18\": 3,\n",
    "\t\"seq_write_128k, T=1\": 4,\n",
    "\t\"rand_write_128k, T=1\": 6, \"rand_write_128k, T=18\": 7\n",
    "}\n",
    "fbramavg = fbramavg.sort_values(by=\"Workload\", key=lambda x: x.map(sort_dict))\n",
    "\n",
    "fbramavg.to_latex(\"./tables/filebench_ram.txt\", index=False)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "fbramcmp = pd.DataFrame(columns=[\"Workload\"])\n",
    "\n",
    "for i, row in fbramavg.iterrows():\n",
    "\tfbramcmp.loc[i, \"Workload\"] = row[\"Workload\"]\n",
    "\tfbramcmp.loc[i, \"RAM Bento-fs:ext4-j\"] = round(get_avg_from_table_str(row[\"Bento-fs\"]) / get_avg_from_table_str(row[\"ext4-journal\"]), 2)\n",
    "\n",
    "for i, row in fbramcmp.iterrows():\n",
    "\td = fbcmp[fbcmp[\"Workload\"] == row[\"Workload\"]]\n",
    "\tfbramcmp.loc[i, \"900P Bento-fs:ext4-j\"] = d[\"Bento-fs:ext4-j\"].iloc[0]\n",
    "\n",
    "fbramcmp.to_latex(\"./tables/filebench_ram_cmp.txt\", index=False)"
   ],
   "outputs": [],
   "metadata": {}
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "4e1d9a8909477db77738c33245c29c7265277ef753467dede8cf3f814cde494e"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.9.6 64-bit"
  },
  "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}