analysis/investigative_plots_ZNS.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26c7f947",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import os, sys\n",
    "parent_dir = os.path.abspath('..')\n",
    "if parent_dir not in sys.path:\n",
    "    sys.path.append(parent_dir)\n",
    "from bench_utils import *\n",
    "from plot_utils import *"
   ]
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95b77158",
   "metadata": {},
   "source": [
    "# ZNS append versus write performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d648b18",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setup plot\n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"Append versus write performance (request size=4KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "# Get data for writemq\n",
    "qdss = [1,2,4,8,16,32,64]\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf3\", \"writemq\", 1, qd, 4096\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "# Writemq line plot\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"writes\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "# Writemq QD labels\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "            if qdss[i] == 1:\n",
    "                plt.text((kiops[i] - 25) * (1.01), (lats[i] + 5) *\n",
    "                         (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 15) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            elif qdss[i] > 8:\n",
    "                plt.text((kiops[i] - 35) * (1.01), (lats[i] + 5) *\n",
    "                         (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i] - 25) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] - 15) * (1.01), (lats[i] + 5) *\n",
    "                         (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 5) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "   \n",
    "\n",
    " # Get data for Append\n",
    "qdss = [1,2,4,8,16]\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3\", \"append\", 1, qd, 4096\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "# Append line plot\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"appends\",\n",
    "    color=\"#EE6677\",\n",
    ")\n",
    "\n",
    "# Append QD labels\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#EE6677\")\n",
    "            if qdss[i] >= 8:\n",
    "                plt.text((kiops[i] + 3) * (1.01), (lats[i]+5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i] + 3) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] + 3) * (1.01), (lats[i]-10) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] + 3) * (1.01), kiops[i]],[(lats[i]-10) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "# Plot it\n",
    "plt.xlim(0, 300)\n",
    "plt.ylim(0, 250)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3b7dcd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setup plot\n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"Append versus write performance (request size=8KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "# Get data for writemq\n",
    "qdss = [1,2,4,8,16,32]\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf3\", \"writemq\", 1, qd, 4096<<1\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "# Writemq line plot\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"writes\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "# Writemq QD labels\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "            if qdss[i] < 8:\n",
    "                plt.text((kiops[i] - 10) * (1.01), (lats[i] + 5) *\n",
    "                         (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 5) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] - 15) * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 5) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "# Get data for append\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3\", \"append\", 1, qd, 4096<<1\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "# Append line plot\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"append\",\n",
    "    color=\"#EE6677\",\n",
    ")\n",
    "\n",
    "# Append QD labels\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#EE6677\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text(kiops[i] * (1.01), (lats[i] - 10) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]) * (1.01), kiops[i]],[(lats[i]-10) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text(kiops[i] * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "# Plot it\n",
    "plt.xlim(0, 160)\n",
    "plt.ylim(0, 250)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05dce599",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"Append performance\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8,16,32]\n",
    "\n",
    "    \n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3\", \"append\", 1, qd, 4096<<1\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"append\",\n",
    "    color=\"#EE6677\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#EE6677\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text(kiops[i] * (1.01), (lats[i] - 10) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]) * (1.01), kiops[i]],[(lats[i]-10) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text(kiops[i] * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "plt.xlim(0, 160)\n",
    "plt.ylim(0, 250)\n",
    "# plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb7860de",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 4\n",
    "bss = [4096, 8192, 16384, 32768, 65536, 131072]\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for bs in bss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3\", \"append\", 1, qd, bs\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    kiopse.append(dat.iops_stddev / 1000)\n",
    "\n",
    "    \n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"Request size\")\n",
    "plt.title(\"Append througput (QD=4)\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 160)\n",
    "\n",
    "ax.barh(range(len(bss)), kiops, xerr=kiopse, align='center', color=\"#EE6677\")\n",
    "ax.set_yticks(range(len(bss)), labels=[\"4KiB\", \"8KiB\", \"16KiB\", \"32KiB\", \"64KiB\", \"128KiB\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e807c25",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 1\n",
    "bss = [4096, 8192, 16384, 32768, 65536, 131072]\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for bs in bss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3\", \"append\", 1, qd, bs\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    kiopse.append(dat.iops_stddev / 1000)\n",
    "\n",
    "    \n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"Request size\")\n",
    "plt.title(\"Append througput (QD=1)\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 160)\n",
    "\n",
    "ax.barh(range(len(bss)), kiops, xerr=kiopse, align='center', color=\"#EE6677\")\n",
    "ax.set_yticks(range(len(bss)), labels=[\"4KiB\", \"8KiB\", \"16KiB\", \"32KiB\", \"64KiB\", \"128KiB\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d04fdf28",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 4\n",
    "bss = [4096, 8192, 16384, 32768, 65536, 131072]\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for bs in bss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf0\", \"append\", 1, qd, bs\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    kiopse.append(dat.iops_stddev / 1000)\n",
    "\n",
    "    \n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"Request size\")\n",
    "plt.title(\"Append througput (lba format 0 QD=4)\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 160)\n",
    "\n",
    "ax.barh(range(len(bss)), kiops, xerr=kiopse, align='center', color=\"#EE6677\")\n",
    "ax.set_yticks(range(len(bss)), labels=[\"4KiB\", \"8KiB\", \"16KiB\", \"32KiB\", \"64KiB\", \"128KiB\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e820c61a",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 4\n",
    "bss = [4096, 8192, 16384, 32768, 65536]\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for bs in bss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3\", \"append\", 1, qd, bs\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.lat_mean / 1000)\n",
    "    kiopse.append(dat.lat_stdef / 1000)\n",
    "\n",
    "    \n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Latency (micros)\")\n",
    "plt.ylabel(\"Request size\")\n",
    "plt.title(\"Append latency (QD=4)\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 450)\n",
    "\n",
    "ax.barh(range(len(bss)), kiops, xerr=kiopse, align='center', color=\"#EE6677\")\n",
    "ax.set_yticks(range(len(bss)), labels=[\"4KiB\", \"8KiB\", \"16KiB\", \"32KiB\", \"64KiB\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "052134f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 4\n",
    "conc = [1,2,4]\n",
    "# https://personal.sron.nl/~pault/\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Latency (micros)\")\n",
    "plt.ylabel(\"Level of concurrency\")\n",
    "plt.title(\"Append latency\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 80)\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for c in conc:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3\", \"append\", c, 1, 4096<<1\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.lat_mean / 1000)\n",
    "    kiopse.append(dat.lat_stdef / 1000)\n",
    "\n",
    "ax.barh([(x*0.6) - 0.125 for x in range(len(conc))], kiops, xerr=kiopse, align='center', color=\"#AA3377\", height=0.25,\n",
    "       label='Appends to concurrent zones')\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for c in conc:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3\", \"append\", 1, c, 4096<<1\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.lat_mean / 1000)\n",
    "    kiopse.append(dat.lat_stdef / 1000)\n",
    "    \n",
    "    \n",
    "ax.barh([(x*0.6) + 0.125 for x in range(len(conc))], kiops, xerr=kiopse, align='center', color=\"#EE6677\", height=0.25,\n",
    "       label='Appends with higher QD')\n",
    "    \n",
    "ax.set_yticks([x * 0.6 for x in range(len(conc))], labels=[\"1\", \"2\", \"4\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93167c49",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 4\n",
    "conc = [1,2,4]\n",
    "# https://personal.sron.nl/~pault/\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"Level of concurrency\")\n",
    "plt.title(\"Append througput\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 160)\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for c in conc:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3\", \"append\", c, 1, 4096<<1\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    kiopse.append(dat.iops_stddev / 1000)\n",
    "\n",
    "ax.barh([(x*0.6) - 0.125 for x in range(len(conc))], kiops, xerr=kiopse, align='center', color=\"#AA3377\", \n",
    "        height=0.25, label='Appends to concurrent zones')\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for c in conc:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3\", \"append\", 1, c, 4096<<1\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    kiopse.append(dat.iops_stddev / 1000)\n",
    "    \n",
    "    \n",
    "ax.barh([(x*0.6) + 0.125 for x in range(len(conc))], kiops, xerr=kiopse, align='center', color=\"#EE6677\", \n",
    "        height=0.25, label='Appends with higher QD')\n",
    "    \n",
    "ax.set_yticks([x*0.6 for x in range(len(conc))], labels=[\"1\", \"2\", \"4\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2e1802d",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"Append performance (request size=32KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8]\n",
    "bss = [512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072]\n",
    "    \n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3\", \"append\", 1, qd, 32768\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"append\",\n",
    "    color=\"#EE6677\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#EE6677\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i]+5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] +5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf3\", \"writemq\", 1, qd, 32768\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"writes\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "                \n",
    "                \n",
    "plt.xlim(0, 160)\n",
    "plt.ylim(0, 250)\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a171e05",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 1\n",
    "bss = [4096, 8192, 16384, 32768, 65536, 131072]\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for operation in [\"write\", \"append\"]:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3\", operation, 1, 1, 4096<<1\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    kiopse.append(dat.iops_stddev / 1000)\n",
    "\n",
    "    \n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"SPDK operation\")\n",
    "plt.title(\"Operation throughput (QD=1, request size=8KiB)\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 100)\n",
    "\n",
    "ax.barh([0.125,0.5], kiops, xerr=kiopse, align='center', color=[\"#AA3377\", \"#EE6677\"], height=0.25)\n",
    "ax.set_yticks([0.125,0.5], labels=[\"write\", \"append\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bb7b59f",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"ZNS append versus NVMe write performance (request size=8KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8,16,32]\n",
    "\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"nvme-a\", \n",
    "            \"lbaf3\", \"write\", 1, qd, 4096<<1\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"NVMe writes\",\n",
    "    color=\"#228833\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#228833\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text(kiops[i] * (1.01), (lats[i] - 10) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]) * (1.01), kiops[i]],[(lats[i]-10) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text(kiops[i] * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "    \n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3\", \"append\", 1, qd, 4096<<1\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"ZNS append\",\n",
    "    color=\"#EE6677\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#EE6677\")\n",
    "            if qdss[i] < 8:\n",
    "                plt.text((kiops[i] - 10) * (1.01), (lats[i] + 5) *\n",
    "                         (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 5) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] - 15) * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 5) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "plt.xlim(0, 160)\n",
    "plt.ylim(0, 250)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "364c2a4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"ZNS versus NVMe write performance (request size=8KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8,16,32]\n",
    "\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"nvme-a\", \n",
    "            \"lbaf3\", \"write\", 1, qd, 4096<<1\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"NVMe writes\",\n",
    "    color=\"#228833\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#228833\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text(kiops[i] * (1.01), (lats[i] - 10) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]) * (1.01), kiops[i]],[(lats[i]-10) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text(kiops[i] * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "    \n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf3\", \"writemq\", 1, qd, 4096<<1\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"ZNS writes\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "            if qdss[i] < 8:\n",
    "                plt.text((kiops[i] - 10) * (1.01), (lats[i] + 5) *\n",
    "                         (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 5) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] - 15) * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 5) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "plt.xlim(0, 160)\n",
    "plt.ylim(0, 250)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0a1b9a3",
   "metadata": {},
   "source": [
    "# ZNS write performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "522e1ae9",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 32\n",
    "bss = [4096, 8192, 16384, 32768, 65536, 131072]\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for bs in bss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf3\", \"writemq\", 1, qd, bs\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    kiopse.append(dat.iops_stddev / 1000)\n",
    "\n",
    "    \n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"Request size\")\n",
    "plt.title(\"Write througput QD=32\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 300)\n",
    "\n",
    "ax.barh(range(len(bss)), kiops, xerr=kiopse, align='center', color=\"#4477AA\")\n",
    "ax.set_yticks(range(len(bss)), labels=[\"4KiB\", \"8KiB\", \"16KiB\", \"32KiB\", \"64KiB\", \"128KiB\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa030c76",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 1\n",
    "bss = [4096, 8192, 16384, 32768, 65536, 131072]\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for bs in bss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf3\", \"writemq\", 1, qd, bs\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    kiopse.append(dat.iops_stddev / 1000)\n",
    "\n",
    "    \n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"Request size\")\n",
    "plt.title(\"Write througput QD=1\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 100)\n",
    "\n",
    "ax.barh(range(len(bss)), kiops, xerr=kiopse, align='center', color=\"#4477AA\")\n",
    "ax.set_yticks(range(len(bss)), labels=[\"4KiB\", \"8KiB\", \"16KiB\", \"32KiB\", \"64KiB\", \"128KiB\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef9d0290",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 32\n",
    "bss = [4096, 8192, 16384, 32768, 65536]\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for bs in bss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf3\", \"writemq\", 1, qd, bs\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.lat_mean / 1000)\n",
    "    kiopse.append(dat.lat_stdef / 1000)\n",
    "\n",
    "    \n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Latency (micros)\")\n",
    "plt.ylabel(\"Request size\")\n",
    "plt.title(\"Write latency (QD=32)\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 2500)\n",
    "\n",
    "ax.barh(range(len(bss)), kiops, xerr=kiopse, align='center', color=\"#4477AA\")\n",
    "ax.set_yticks(range(len(bss)), labels=[\"4KiB\", \"8KiB\", \"16KiB\", \"32KiB\", \"64KiB\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "413c0240",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 1\n",
    "bss = [4096, 8192, 16384, 32768]\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for bs in bss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf3\", \"writemq\", 1, qd, bs\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.lat_mean / 1000)\n",
    "    kiopse.append(dat.lat_stdef / 1000)\n",
    "\n",
    "    \n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Latency (micros)\")\n",
    "plt.ylabel(\"Request size\")\n",
    "plt.title(\"Write latency (QD=1)\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 50)\n",
    "\n",
    "ax.barh(range(len(bss)), kiops, xerr=kiopse, align='center', color=\"#4477AA\")\n",
    "ax.set_yticks(range(len(bss)), labels=[\"4KiB\", \"8KiB\", \"16KiB\", \"32KiB\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17fa1145",
   "metadata": {},
   "source": [
    "# ZNS randomly writeable area performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab22fd73",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 4\n",
    "bss = [4096, 8192, 16384, 32768, 65536, 131072]\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for bs in bss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf3nvme\", \"write\", 1, qd, bs\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    kiopse.append(dat.iops_stddev / 1000)\n",
    "\n",
    "    \n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"Request size\")\n",
    "plt.title(\"Write througput (QD=4)\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 300)\n",
    "\n",
    "ax.barh(range(len(bss)), kiops, xerr=kiopse, align='center', color=\"#4477AA\")\n",
    "ax.set_yticks(range(len(bss)), labels=[\"4KiB\", \"8KiB\", \"16KiB\", \"32KiB\", \"64KiB\", \"128KiB\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a094b05",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 4\n",
    "bss = [4096, 8192, 16384, 32768, 65536]\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for bs in bss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf3nvme\", \"write\", 1, qd, bs\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.lat_mean / 1000)\n",
    "    kiopse.append(dat.lat_stdef / 1000)\n",
    "\n",
    "    \n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Latency (micros)\")\n",
    "plt.ylabel(\"Request size\")\n",
    "plt.title(\"Write latency (QD=4)\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 500)\n",
    "\n",
    "ax.barh(range(len(bss)), kiops, xerr=kiopse, align='center', color=\"#4477AA\")\n",
    "ax.set_yticks(range(len(bss)), labels=[\"4KiB\", \"8KiB\", \"16KiB\", \"32KiB\", \"64KiB\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfdfd911",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"ZNS versus NVMe write performance (request size=8KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8,16,32]\n",
    "\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"nvme-a\", \n",
    "            \"lbaf3\", \"write\", 1, qd, 4096<<1\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"NVMe writes\",\n",
    "    color=\"#228833\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#228833\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text(kiops[i] * (1.01), (lats[i] - 10) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]) * (1.01), kiops[i]],[(lats[i]-10) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text(kiops[i] * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "    \n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf3nvme\", \"write\", 1, qd, 4096<<1\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"ZNS (NVMe namespace) writes\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "            if qdss[i] < 8:\n",
    "                plt.text((kiops[i] - 10) * (1.01), (lats[i] + 5) *\n",
    "                         (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 5) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] - 15) * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 5) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "plt.xlim(0, 160)\n",
    "plt.ylim(0, 250)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7faf94a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"ZNS versus NVMe write performance (request size=8KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8,16,32]\n",
    "\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"nvme-a\", \n",
    "            \"lbaf3\", \"write\", 1, qd, 4096<<1\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"NVMe writes\",\n",
    "    color=\"#228833\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#228833\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text(kiops[i] * (1.01), (lats[i] - 10) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]) * (1.01), kiops[i]],[(lats[i]-10) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text(kiops[i] * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "    \n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3nvme\", \"write\", 1, qd, 4096<<1\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"ZNS (NVMe namespace) writes\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "            if qdss[i] < 8:\n",
    "                plt.text((kiops[i] - 10) * (1.01), (lats[i] + 5) *\n",
    "                         (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 5) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] - 15) * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 5) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "plt.xlim(0, 160)\n",
    "plt.ylim(0, 250)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7693e759",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ... Marker 1 ...\n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"ZNS versus NVMe write performance (request size=4KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8,16,32,64]\n",
    "\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"nvme-a\", \n",
    "            \"lbaf3\", \"write\", 1, qd, 4096\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"NVMe writes\",\n",
    "    color=\"#228833\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#228833\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text(kiops[i] * (1.01), (lats[i] - 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]) * (1.01), kiops[i]],[(lats[i]-5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            elif qdss[i] >= 32:\n",
    "                pass\n",
    "            else:\n",
    "                plt.text((kiops[i]-30) * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]-30)  * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "    \n",
    "qdss = [1,2,4,8,16,32]\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf3nvme\", \"write\", 1, qd, 4096\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"ZNS write\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i] - 10) * (1.01), (lats[i] + 5) *\n",
    "                         (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 5) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] - 25) * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 15) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "plt.xlim(0, 320)\n",
    "plt.ylim(0, 300)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5a40b09",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ... Marker 1 ...\n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"ZNS versus NVMe write performance (request size=4KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8,16,32,64]\n",
    "\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"nvme-a\", \n",
    "            \"lbaf3\", \"write\", 1, qd, 4096\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"NVMe writes\",\n",
    "    color=\"#228833\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#228833\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text(kiops[i] * (1.01), (lats[i] - 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]) * (1.01), kiops[i]],[(lats[i]-5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            elif qdss[i] >= 32:\n",
    "                pass\n",
    "            else:\n",
    "                plt.text((kiops[i]-30) * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]-30)  * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "    \n",
    "qdss = [1,2,4,8,16,32]\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3nvme\", \"write\", 1, qd, 4096\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"ZNS write\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i] - 10) * (1.01), (lats[i] + 5) *\n",
    "                         (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 5) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] - 25) * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 15) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "plt.xlim(0, 320)\n",
    "plt.ylim(0, 300)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d02a5f93",
   "metadata": {},
   "source": [
    "# Small I/O (<4 KiB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "137f2b8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"Append performance (request size=512 bytes)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8]\n",
    "    \n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf0\", \"append\", 1, qd, 512\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"append\",\n",
    "    color=\"#EE6677\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#EE6677\")\n",
    "\n",
    "lats = [25,50,100,200]\n",
    "for i in range(len(kiops)): \n",
    "    if qdss[i] < 4:\n",
    "        plt.text((kiops[i]+5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "    else:\n",
    "        plt.text((kiops[i] +5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf0\", \"writemq\", 1, qd, 512\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"writes\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "                \n",
    "                \n",
    "plt.xlim(0, 160)\n",
    "plt.ylim(0, 250)\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe32c826",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"Append performance (request size=2KiBs)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8]\n",
    "    \n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf0\", \"append\", 1, qd, 2048\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"append\",\n",
    "    color=\"#EE6677\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#EE6677\")\n",
    "\n",
    "lats = [25,50,100,200]\n",
    "for i in range(len(kiops)): \n",
    "    if qdss[i] < 4:\n",
    "        plt.text((kiops[i]+5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "    else:\n",
    "        plt.text((kiops[i] +5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf0\", \"writemq\", 1, qd, 2048\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"writes\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "                \n",
    "                \n",
    "plt.xlim(0, 160)\n",
    "plt.ylim(0, 250)\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6558f85e",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 1\n",
    "bss = [512, 1024, 2048]\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for bs in bss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf0\", \"append\", 1, 32, bs\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    kiopse.append(dat.iops_stddev / 1000)\n",
    "\n",
    "    \n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"Request size\")\n",
    "plt.title(\"Append througput\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 50)\n",
    "\n",
    "ax.barh(range(len(bss)), kiops, xerr=kiopse, align='center', color=\"#EE6677\")\n",
    "ax.set_yticks(range(len(bss)), labels=[\"512\", \"1KiB\", \"2KiB\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f566b0a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 1\n",
    "bss = [512, 1024, 2048]\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for bs in bss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf0\", \"append\", 1, 32, bs\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.lat_mean / 1000)\n",
    "    kiopse.append(dat.lat_stdef / 1000)\n",
    "\n",
    "    \n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Latency (micros)\")\n",
    "plt.ylabel(\"Request size\")\n",
    "plt.title(\"Append Latency\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 1000)\n",
    "\n",
    "ax.barh(range(len(bss)), kiops, xerr=kiopse, align='center', color=\"#EE6677\")\n",
    "ax.set_yticks(range(len(bss)), labels=[\"512\", \"1KiB\", \"2KiB\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4408e386",
   "metadata": {},
   "source": [
    "# LBAF performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f44c076b",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"Append performance (request size=8KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8]\n",
    "    \n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf0\", \"append\", 1, qd, 8192\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"lba format 512 bytes pages\",\n",
    "    color=\"#AA3377\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#AA3377\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i]+5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] +5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3\", \"append\", 1, qd, 8192\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"lba format 4KiB pages\",\n",
    "    color=\"#EE6677\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#EE6677\")\n",
    "                \n",
    "                \n",
    "plt.xlim(0, 160)\n",
    "plt.ylim(0, 60)\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54f4678d",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"Write performance (request size=8KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8]\n",
    "    \n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf0\", \"writemq\", 1, qd, 8192\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"lba format 512 bytes pages\",\n",
    "    color=\"#66CCEE\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#66CCEE\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i]+5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] +5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf3\", \"writemq\", 1, qd, 8192\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"lba format 4KiB pages\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "                \n",
    "                \n",
    "plt.xlim(0, 160)\n",
    "plt.ylim(0, 60)\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "565121c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"Write performance (request size=4KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8,16,32,64]\n",
    "    \n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf0\", \"writemq\", 1, qd, 4096\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"lba format 512 bytes pages\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i]-25) * (1.01), (lats[i]+3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]-15) * (1.01), kiops[i]],[(lats[i]+1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            elif qdss[i] == 8:\n",
    "                plt.text((kiops[i]-25) * (1.01), (lats[i]+10) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]-15) * (1.01), kiops[i]],[(lats[i]+9) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] - 30) * (1.01), (lats[i]+3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] -20) * (1.01), kiops[i]],[(lats[i]+1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf3\", \"writemq\", 1, qd, 4096\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"lba format 4KiB pages\",\n",
    "    color=\"#66CCEE\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#66CCEE\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i]+5) * (1.01), (lats[i]-8) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-7) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            elif qdss[i] > 16:\n",
    "                plt.text((kiops[i] -30) * (1.01), (lats[i]+8) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]-30) * (1.01), kiops[i]],[(lats[i]+7) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] +5) * (1.01), (lats[i]-8) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-7) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#66CCEE\")\n",
    "                \n",
    "                \n",
    "plt.xlim(0, 300)\n",
    "plt.ylim(0, 300)\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "069a611e",
   "metadata": {},
   "source": [
    "# NVMe versus ZNS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9ff4e7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 32\n",
    "bss = [4096, 8192, 16384, 32768, 65536, 131072]\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for bs in bss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"nvme-a\", \n",
    "            \"lbaf3\", \"write\", 1, qd, bs\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    kiopse.append(dat.iops_stddev / 1000)\n",
    "\n",
    "    \n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"Request size\")\n",
    "plt.title(\"Write througput (NVMe)\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 320)\n",
    "\n",
    "ax.barh(range(len(bss)), kiops, xerr=kiopse, align='center', color=\"#228833\")\n",
    "ax.set_yticks(range(len(bss)), labels=[\"4KiB\", \"8KiB\", \"16KiB\", \"32KiB\", \"64KiB\", \"128KiB\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "583c87ef",
   "metadata": {},
   "source": [
    "# Write rand (NVMe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45cfa830",
   "metadata": {},
   "outputs": [],
   "source": [
    "qd = 32\n",
    "bss = [4096, 8192, 16384, 32768, 65536, 131072]\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for bs in bss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"nvme-a\", \n",
    "            \"lbaf3\", \"writerand\", 1, qd, bs\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    kiopse.append(dat.iops_stddev / 1000)\n",
    "\n",
    "    \n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"Request size\")\n",
    "plt.title(\"Write througput (QD=32)\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 320)\n",
    "\n",
    "ax.barh(range(len(bss)), kiops, xerr=kiopse, align='center', color=\"#228833\")\n",
    "ax.set_yticks(range(len(bss)), labels=[\"4KiB\", \"8KiB\", \"16KiB\", \"32KiB\", \"64KiB\", \"128KiB\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "622cbbb7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Marker 3\n",
    "qd = 1\n",
    "bss = [4096, 8192, 16384, 32768, 65536, 131072]\n",
    "\n",
    "kiops = []\n",
    "kiopse = []\n",
    "for bs in bss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"nvme-a\", \n",
    "            \"lbaf3\", \"writerand\", 1, qd, bs\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    kiopse.append(dat.iops_stddev / 1000)\n",
    "\n",
    "    \n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"Request size\")\n",
    "plt.title(\"Write througput (QD=1)\")\n",
    "ax.xaxis.grid() # horizontal lines\n",
    "plt.xlim(0, 150)\n",
    "\n",
    "ax.barh(range(len(bss)), kiops, xerr=kiopse, align='center', color=\"#228833\")\n",
    "ax.set_yticks(range(len(bss)), labels=[\"4KiB\", \"8KiB\", \"16KiB\", \"32KiB\", \"64KiB\", \"128KiB\"])\n",
    "ax.invert_yaxis()  # labels read top-to-bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41e0531b",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"ZNS append versus NVMe write performance (request size=4KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8,16,32]\n",
    "\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"nvme-a\", \n",
    "            \"lbaf3\", \"write\", 1, qd, 4096\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"NVMe writes\",\n",
    "    color=\"#228833\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#228833\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text(kiops[i] * (1.01), (lats[i] - 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]) * (1.01), kiops[i]],[(lats[i]-5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i]-30) * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]-30)  * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "    \n",
    "qdss = [1,2,4,8,16]\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"zns-a\", \n",
    "            \"lbaf3\", \"append\", 1, qd, 4096\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"ZNS append\",\n",
    "    color=\"#EE6677\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#EE6677\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i] - 10) * (1.01), (lats[i] + 5) *\n",
    "                         (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 5) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] - 25) * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 15) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "plt.xlim(0, 320)\n",
    "plt.ylim(0, 150)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b4ab6dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"ZNS versus NVMe write performance (request size=4KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8,16,32,64]\n",
    "\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"nvme-a\", \n",
    "            \"lbaf3\", \"write\", 1, qd, 4096\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"NVMe writes\",\n",
    "    color=\"#228833\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#228833\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text(kiops[i] * (1.01), (lats[i] - 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]) * (1.01), kiops[i]],[(lats[i]-5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            elif qdss[i] >= 32:\n",
    "                pass\n",
    "            else:\n",
    "                plt.text((kiops[i]-30) * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]-30)  * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "    \n",
    "qdss = [1,2,4,8,16,32,64]\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"zns-a\", \n",
    "            \"lbaf3\", \"writemq\", 1, qd, 4096\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"ZNS write\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i] - 10) * (1.01), (lats[i] + 5) *\n",
    "                         (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 5) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] - 25) * (1.01), (lats[i] + 5) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i] - 15) * (1.01), kiops[i]],[(lats[i]+5) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "plt.xlim(0, 320)\n",
    "plt.ylim(0, 300)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "134a4e66",
   "metadata": {},
   "source": [
    "# NVMe vs NVMe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ebeb295",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"Write performance for NVMe SSDs (request size=16KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8]\n",
    "bss = [512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072]\n",
    "    \n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"nvme-a\", \n",
    "            \"lbaf0\", \"write\", 1, qd, 16384\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"SSD1\",\n",
    "    color=\"#EE6677\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#EE6677\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i]+5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] +5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "qdss = [1,2,4,8,16]\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"nvme-b\", \n",
    "            \"lbaf0\", \"write\", 1, qd, 16384\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"SSD2\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i]+5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] +5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "                \n",
    "                \n",
    "plt.xlim(0, 200)\n",
    "plt.ylim(0, 250)\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52dc412b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ... MARKER 2 ...\n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"Write performance for NVMe SSDs (request size=32KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4,8]\n",
    "bss = [512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072]\n",
    "    \n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"nvme-a\", \n",
    "            \"lbaf0\", \"write\", 1, qd, 32768\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"SSD1\",\n",
    "    color=\"#EE6677\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#EE6677\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i]+5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] +5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"nvme-b\", \n",
    "            \"lbaf0\", \"write\", 1, qd, 32768\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"SSD2\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i]+5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] +5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "                \n",
    "                \n",
    "plt.xlim(0, 160)\n",
    "plt.ylim(0, 250)\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c874e593",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ... MARKER 2 ...\n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"Write performance for NVMe SSDs (request size=64KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2,4]\n",
    "bss = [512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072]\n",
    "    \n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"nvme-a\", \n",
    "            \"lbaf0\", \"write\", 1, qd, 65536\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"SSD1\",\n",
    "    color=\"#EE6677\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#EE6677\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i]+5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] +5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"nvme-b\", \n",
    "            \"lbaf0\", \"write\", 1, qd, 65536\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"SSD2\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i]+5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] +5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "                \n",
    "                \n",
    "plt.xlim(0, 160)\n",
    "plt.ylim(0, 250)\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fdf06ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ... MARKER 2 ...\n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel(\"Througput (KIOPS)\")\n",
    "plt.ylabel(\"latency (micros)\")\n",
    "plt.title(\"Write performance for NVMe SSDs (request size=128KiB)\")\n",
    "ax.grid(True)\n",
    "\n",
    "qdss = [1,2]\n",
    "bss = [512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072]\n",
    "    \n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"spdk\"), \"nvme-a\", \n",
    "            \"lbaf0\", \"write\", 1, qd, 131072\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "\n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"SSD1\",\n",
    "    color=\"#EE6677\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#EE6677\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i]+5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] +5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "\n",
    "qdss = [1,2,4]\n",
    "kiops = []\n",
    "lats = []\n",
    "for qd in qdss:\n",
    "    dat = parse_fio_file(\n",
    "        BenchPath(\n",
    "            string_to_io_engine(\"io_uring\"), \"nvme-b\", \n",
    "            \"lbaf0\", \"write\", 1, qd, 131072\n",
    "            )\n",
    "        )\n",
    "    kiops.append(dat.iops_mean / 1000)\n",
    "    lats.append(dat.lat_mean / 1000)\n",
    "    \n",
    "plt.plot(\n",
    "    kiops,\n",
    "    lats,\n",
    "    linewidth=3,\n",
    "    label=\"SSD2\",\n",
    "    color=\"#4477AA\",\n",
    ")\n",
    "\n",
    "for i in range(len(kiops)):\n",
    "            plt.plot(kiops[i], lats[i], \"o\", color=\"#4477AA\")\n",
    "            if qdss[i] < 4:\n",
    "                plt.text((kiops[i]+5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)                \n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "            else:\n",
    "                plt.text((kiops[i] +5) * (1.01), (lats[i]-3) *\n",
    "                     (1.01), s='qd='+str(qdss[i]), fontsize=9)\n",
    "                plt.plot([(kiops[i]+5) * (1.01), kiops[i]],[(lats[i]-1) *\n",
    "                     (1.01),lats[i]], color='grey')\n",
    "                \n",
    "                \n",
    "plt.xlim(0, 160)\n",
    "plt.ylim(0, 250)\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ff3852f",
   "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}