Notebooks/vnx-benchmark-throughput.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Benchmark Throughput experiment (point to point)\n",
    "This notebook will show you how to measure the throughput between two Alveo nodes using the benchmark application with UDP as a transport protocol.\n",
    "We are going to rely on a Dask cluster to configure the local and remote Alveo cards.\n",
    "\n",
    "This notebook assumes:\n",
    "* Direct connection between the Alveo cards\n",
    "* Dask cluster is already created and running. For more information about setting up a Dask cluster visit the [Dask documentation](https://docs.dask.org/en/latest/setup.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Connect to the Dask cluster\n",
    "1. Connect to the Dask cluster\n",
    "1. Grab workers name\n",
    "1. Check if there are two workers available"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table style=\"border: 2px solid white;\">\n",
       "<tr>\n",
       "<td style=\"vertical-align: top; border: 0px solid white\">\n",
       "<h3 style=\"text-align: left;\">Client</h3>\n",
       "<ul style=\"text-align: left; list-style: none; margin: 0; padding: 0;\">\n",
       "  <li><b>Scheduler: </b>tcp://10.1.212.126:8786</li>\n",
       "  <li><b>Dashboard: </b><a href='http://10.1.212.126:8787/status' target='_blank'>http://10.1.212.126:8787/status</a>\n",
       "</ul>\n",
       "</td>\n",
       "<td style=\"vertical-align: top; border: 0px solid white\">\n",
       "<h3 style=\"text-align: left;\">Cluster</h3>\n",
       "<ul style=\"text-align: left; list-style:none; margin: 0; padding: 0;\">\n",
       "  <li><b>Workers: </b>2</li>\n",
       "  <li><b>Cores: </b>32</li>\n",
       "  <li><b>Memory: </b>232.35 GB</li>\n",
       "</ul>\n",
       "</td>\n",
       "</tr>\n",
       "</table>"
      ],
      "text/plain": [
       "<Client: 'tcp://10.1.212.126:8786' processes=2 threads=32, memory=232.35 GB>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from dask.distributed import Client, get_client\n",
    "\n",
    "client = Client(\"tcp://10.1.212.126:8786\")\n",
    "client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "client_info = client.scheduler_info()['workers']\n",
    "workers = []\n",
    "for cli in client_info:\n",
    "    workers.append(client_info[cli]['name'])\n",
    "\n",
    "if len(workers) != 2:\n",
    "    print(\"Configure your Dask cluster with two workers\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic remote functions\n",
    "In this part we are going to schedule a basic function to the workers to verify that we are able to pinpoint tasks to a particular worker, we are also going to grab the Alveo shell name.\n",
    "You should visually check that your xclbin file is built for the Alveo shell available on the workers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Worker name: alveo3b | shell version: \"xilinx_u280_xdma_201920_3\"\n",
      "Worker name: alveo3c | shell version: \"xilinx_u280_xdma_201920_3\"\n"
     ]
    }
   ],
   "source": [
    "import platform, os\n",
    "\n",
    "def verify_workers():\n",
    "    node_name = platform.node()\n",
    "    shell_version = os.popen(\"xbutil dump | grep dsa_name\").read()\n",
    "    #match = True\n",
    "    #if 'xilinx_u280_xdma_201920_3' not in shell_version:\n",
    "    #    match = False\n",
    "    return node_name, shell_version[24:-2]\n",
    "\n",
    "worker_0 = client.submit(verify_workers ,workers=workers[0], pure=False)\n",
    "worker_1 = client.submit(verify_workers ,workers=workers[1], pure=False)\n",
    "\n",
    "worker_check = [worker_0.result(),worker_1.result()]\n",
    "\n",
    "for w in worker_check:\n",
    "    print('Worker name: {} | shell version: {}'.format(w[0],w[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Source Dask device and utilities\n",
    "\n",
    "In this section we will declare the Dask code that builds on top of the `pynq` framework. This piece of code allow us to:\n",
    "\n",
    "* Download a `xclbin` file to a worker\n",
    "* Peek and poke registers\n",
    "* Allocate buffers\n",
    "* Start kernels\n",
    "\n",
    "All of these capabilities are available for both local and remote workers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "try {\n",
       "require(['notebook/js/codecell'], function(codecell) {\n",
       "  codecell.CodeCell.options_default.highlight_modes[\n",
       "      'magic_text/x-csrc'] = {'reg':[/^%%microblaze/]};\n",
       "  Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n",
       "      Jupyter.notebook.get_cells().map(function(cell){\n",
       "          if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n",
       "  });\n",
       "});\n",
       "} catch (e) {};\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from vnx_utils import *\n",
    "import pynq\n",
    "import ctypes\n",
    "import tempfile\n",
    "import numpy as np\n",
    "import re\n",
    "from pynq.pl_server.xrt_device import XrtStream\n",
    "\n",
    "# Hold references to buffers to avoid them being collected\n",
    "# Won't be visible in the process but is an easy way to\n",
    "# let workers hold on to local references\n",
    "buffers = []\n",
    "\n",
    "# Functions that will be called in the context of dask\n",
    "def _invalidate(bo, offset, size):\n",
    "    buf = bytearray(size)\n",
    "    pynq.Device.active_device.invalidate(bo, offset, 0, size)\n",
    "    pynq.Device.active_device.buffer_read(bo, offset, buf)\n",
    "    return bytes(buf)\n",
    "\n",
    "def _flush(bo, offset, size, data):\n",
    "    pynq.Device.active_device.buffer_write(bo, offset, bytearray(data))\n",
    "    pynq.Device.active_device.flush(bo, offset, 0, size)\n",
    "    \n",
    "def _read_registers(address, length):\n",
    "    return pynq.Device.active_device.read_registers(address, length)\n",
    "\n",
    "def _write_registers(address, data):\n",
    "    pynq.Device.active_device.write_registers(address, data)\n",
    "    \n",
    "def _download(bitstream_data):\n",
    "    with tempfile.NamedTemporaryFile() as f:\n",
    "        f.write(bitstream_data)\n",
    "        f.flush()\n",
    "        ol = pynq.Overlay(f.name)\n",
    "\n",
    "def _alloc(size, memdesc):\n",
    "    mem = pynq.Device.active_device.get_memory(memdesc)\n",
    "    buf = mem.allocate((size,), 'u1')\n",
    "    buffers.append(buf)\n",
    "    return buf.bo, buf.device_address\n",
    "\n",
    "class DaskMemory:\n",
    "    \"\"\"Memory object proxied over dask\n",
    "    \n",
    "    \"\"\"\n",
    "    def __init__(self, device, desc):\n",
    "        self._desc = desc\n",
    "        self._device = device\n",
    "    \n",
    "    def allocate(self, shape, dtype):\n",
    "        from pynq.buffer import PynqBuffer\n",
    "        buf = PynqBuffer(shape, dtype, device_address=0,\n",
    "                         bo=0, device=self._device, coherent=False)\n",
    "        bo, addr = self._device._call_dask(_alloc, buf.nbytes, self._desc)\n",
    "        buf.bo = bo\n",
    "        buf.device_address = addr\n",
    "        return buf\n",
    "\n",
    "class DaskDevice(pynq.Device):\n",
    "    \"\"\"PYNQ Proxy device for using PYNQ via dask\n",
    "    \n",
    "    \"\"\"\n",
    "    def __init__(self, client, worker):\n",
    "        \"\"\"The worker ID should be unique\n",
    "        \n",
    "        \"\"\"\n",
    "        super().__init__(\"dask-\" + re.sub(r'[^\\w]', '_', worker))\n",
    "        self._dask_client = client\n",
    "        self._worker = worker\n",
    "        self.capabilities = {\n",
    "            'REGISTER_RW': True,\n",
    "            'CALLABLE': True\n",
    "        }\n",
    "        self._streams = {}\n",
    "        \n",
    "    def _call_dask(self, func, *args):\n",
    "        future = self._dask_client.submit(func, *args, workers=self._worker, pure=False)\n",
    "        return future.result()\n",
    "\n",
    "    def invalidate(self, bo, offset, ptr, size):\n",
    "        ctype = ctypes.c_uint8 * size\n",
    "        target = ctype.from_address(ptr)\n",
    "        target[:] = self._call_dask(_invalidate, bo, offset, size)\n",
    "        \n",
    "    def flush(self, bo, offset, ptr, size):\n",
    "        ctype = ctypes.c_uint8 * size\n",
    "        target = ctype.from_address(ptr)\n",
    "        self._call_dask(_flush, bo, offset, size, bytes(target))\n",
    "        \n",
    "    def read_registers(self, address, length):\n",
    "        return self._call_dask(_read_registers, address, length)\n",
    "    \n",
    "    def write_registers(self, address, data):\n",
    "        self._call_dask(_write_registers, address, bytes(data))\n",
    "        \n",
    "    def get_bitfile_metadata(self, bitfile_name):\n",
    "        return pynq.pl_server.xclbin_parser.XclBin(bitfile_name)\n",
    "    \n",
    "    def download(self, bitstream, parser=None):\n",
    "        with open(bitstream.bitfile_name, 'rb') as f:\n",
    "            bitstream_data = f.read()\n",
    "        self._call_dask(_download, bitstream_data)\n",
    "        super().post_download(bitstream, parser)\n",
    "    \n",
    "    def get_memory(self, desc):\n",
    "        if desc['streaming']:\n",
    "            if desc['idx'] not in self._streams:\n",
    "                self._streams[desc['idx']] = XrtStream(self, desc)\n",
    "            return self._streams[desc['idx']]\n",
    "        else:\n",
    "            return DaskMemory(self, desc)\n",
    "    \n",
    "    def get_memory_by_idx(self, idx):\n",
    "        for m in self.mem_dict.values():\n",
    "            if m['idx'] == idx:\n",
    "                return self.get_memory(m)\n",
    "        raise RuntimeError(\"Could not find memory\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Download xclbin to workers\n",
    "1. Create Dask device for each worker\n",
    "2. Create an overlay object for each worker, this step will download the `xclbin` file to the Alveo card"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/mnt/scratch/marruiz/conda/lib/python3.7/site-packages/distributed/worker.py:3321: UserWarning: Large object of size 50.18 MB detected in task graph: \n",
      "  (b'xclbin2\\x00\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff ... ROR_DATA_END',)\n",
      "Consider scattering large objects ahead of time\n",
      "with client.scatter to reduce scheduler burden and \n",
      "keep data on workers\n",
      "\n",
      "    future = client.submit(func, big_data)    # bad\n",
      "\n",
      "    big_future = client.scatter(big_data)     # good\n",
      "    future = client.submit(func, big_future)  # good\n",
      "  % (format_bytes(len(b)), s)\n"
     ]
    }
   ],
   "source": [
    "daskdev_w0 = DaskDevice(client, workers[0])\n",
    "daskdev_w1 = DaskDevice(client, workers[1])\n",
    "\n",
    "xclbin = '../benchmark.intf3.xilinx_u280_xdma_201920_3/vnx_benchmark_if3.xclbin'\n",
    "ol_w0 = pynq.Overlay(xclbin, device=daskdev_w0)\n",
    "ol_w1 = pynq.Overlay(xclbin, device=daskdev_w1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check Link \n",
    "\n",
    "We are going to use the function `linkStatus` that reports if the CMAC is detecting link, which means that the physical connection\n",
    "between the two Alveo cards is established."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Link worker 0 {'cmac_link': True}; link worker 1 {'cmac_link': True}"
     ]
    }
   ],
   "source": [
    "print(\"Link worker 0 {}; link worker 1 {}\".format(ol_w0.cmac_1.linkStatus(),ol_w1.cmac_1.linkStatus()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Configure remote Alveo card\n",
    "\n",
    "1. Set up IP address and MAC address\n",
    "2. Set up connection table\n",
    "3. Launch ARP discovery\n",
    "4. Print out ARP Table "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'HWaddr': '00:0a:35:02:9d:0a', 'inet addr': '192.168.0.10', 'gateway addr': '192.168.0.1', 'Mask': '255.255.255.0'}\n",
      "Position   5\tMAC address 00:0a:35:02:9d:e5\tIP address 192.168.0.5\n"
     ]
    }
   ],
   "source": [
    "print(ol_w1.networklayer_1.updateIPAddress('192.168.0.10', debug=True))\n",
    "#2\n",
    "ol_w1.networklayer_1.sockets[1] = ('192.168.0.5', 62177, 60512, True)\n",
    "ol_w1.networklayer_1.populateSocketTable()\n",
    "#3 \n",
    "ol_w1.networklayer_1.arpDiscovery()\n",
    "#4\n",
    "ol_w1.networklayer_1.readARPTable()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Configure local Alveo card\n",
    "\n",
    "1. Print out IP and MAC address\n",
    "2. Set up connection table\n",
    "3. Launch ARP discovery\n",
    "4. Print out ARP Table "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'HWaddr': '00:0a:35:02:9d:e5', 'inet addr': '192.168.0.5', 'gateway addr': '192.168.0.1', 'Mask': '255.255.255.0'}\n",
      "Position  10\tMAC address 00:0a:35:02:9d:ea\tIP address 192.168.0.10\n"
     ]
    }
   ],
   "source": [
    "print(ol_w0.networklayer_1.getNetworkInfo())\n",
    "#2\n",
    "ol_w0.networklayer_1.sockets[7] = ('192.168.0.10', 60512, 62177, True)\n",
    "ol_w0.networklayer_1.populateSocketTable()\n",
    "#3 \n",
    "ol_w0.networklayer_1.arpDiscovery()\n",
    "#4\n",
    "ol_w0.networklayer_1.readARPTable()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configure application\n",
    "* Configure remote traffic generator 1 in `CONSUMER` mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "ol_w1_tg = ol_w1.traffic_generator_1_1\n",
    "ol_w1_tg.register_map.debug_reset = 1\n",
    "ol_w1_tg.register_map.mode = benchmark_mode.index('CONSUMER')\n",
    "ol_w1_tg.register_map.CTRL.AP_START = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Configure local traffic generator 1\n",
    "* Run the application for different packet sizes\n",
    "* Compute and store results for both local (Tx) and remote (Rx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sent      1,000,000 size:   64-Byte done!\tGot      1,000,000 took   0.0107 sec, thr: 48.023 Gbps\n",
      "Sent      1,000,000 size:  128-Byte done!\tGot      1,000,000 took   0.0167 sec, thr: 61.440 Gbps\n",
      "Sent      1,000,000 size:  192-Byte done!\tGot      1,000,000 took   0.0233 sec, thr: 65.874 Gbps\n",
      "Sent      1,000,000 size:  256-Byte done!\tGot      1,000,000 took   0.0257 sec, thr: 79.693 Gbps\n",
      "Sent      1,000,000 size:  320-Byte done!\tGot      1,000,000 took   0.0308 sec, thr: 83.099 Gbps\n",
      "Sent      1,000,000 size:  384-Byte done!\tGot      1,000,000 took   0.0359 sec, thr: 85.537 Gbps\n",
      "Sent      1,000,000 size:  448-Byte done!\tGot      1,000,000 took   0.0410 sec, thr: 87.367 Gbps\n",
      "Sent      1,000,000 size:  512-Byte done!\tGot      1,000,000 took   0.0461 sec, thr: 88.793 Gbps\n",
      "Sent      1,000,000 size:  576-Byte done!\tGot      1,000,000 took   0.0512 sec, thr: 89.934 Gbps\n",
      "Sent      1,000,000 size:  640-Byte done!\tGot      1,000,000 took   0.0563 sec, thr: 90.868 Gbps\n",
      "Sent      1,000,000 size:  704-Byte done!\tGot      1,000,000 took   0.0615 sec, thr: 91.647 Gbps\n",
      "Sent      1,000,000 size:  768-Byte done!\tGot      1,000,000 took   0.0666 sec, thr: 92.306 Gbps\n",
      "Sent      1,000,000 size:  832-Byte done!\tGot      1,000,000 took   0.0717 sec, thr: 92.871 Gbps\n",
      "Sent      1,000,000 size:  896-Byte done!\tGot      1,000,000 took   0.0768 sec, thr: 93.361 Gbps\n",
      "Sent      1,000,000 size:  960-Byte done!\tGot      1,000,000 took   0.0819 sec, thr: 93.790 Gbps\n",
      "Sent      1,000,000 size: 1024-Byte done!\tGot      1,000,000 took   0.0870 sec, thr: 94.169 Gbps\n",
      "Sent      1,000,000 size: 1088-Byte done!\tGot      1,000,000 took   0.0921 sec, thr: 94.506 Gbps\n",
      "Sent      1,000,000 size: 1152-Byte done!\tGot      1,000,000 took   0.0972 sec, thr: 94.807 Gbps\n",
      "Sent      1,000,000 size: 1216-Byte done!\tGot      1,000,000 took   0.1023 sec, thr: 95.078 Gbps\n",
      "Sent      1,000,000 size: 1280-Byte done!\tGot      1,000,000 took   0.1074 sec, thr: 95.323 Gbps\n",
      "Sent      1,000,000 size: 1344-Byte done!\tGot      1,000,000 took   0.1125 sec, thr: 95.546 Gbps\n",
      "Sent      1,000,000 size: 1408-Byte done!\tGot      1,000,000 took   0.1176 sec, thr: 95.750 Gbps\n",
      "Sent      1,000,000 size: 1472-Byte done!\tGot      1,000,000 took   0.1227 sec, thr: 95.937 Gbps\n",
      "Sent  1,000,000,000 size:   64-Byte done!\tGot  1,000,000,000 took  10.6667 sec, thr: 48.000 Gbps\n",
      "Sent  1,000,000,000 size:  128-Byte done!\tGot  1,000,000,000 took  16.6667 sec, thr: 61.440 Gbps\n",
      "Sent  1,000,000,000 size:  192-Byte done!\tGot  1,000,000,000 took  23.3333 sec, thr: 65.829 Gbps\n",
      "Sent  1,000,000,000 size:  256-Byte done!\tGot  1,000,000,000 took  25.6987 sec, thr: 79.693 Gbps\n",
      "Sent  1,000,000,000 size:  320-Byte done!\tGot  1,000,000,000 took  30.8066 sec, thr: 83.099 Gbps\n",
      "Sent  1,000,000,000 size:  384-Byte done!\tGot  1,000,000,000 took  35.9144 sec, thr: 85.537 Gbps\n",
      "Sent  1,000,000,000 size:  448-Byte done!\tGot  1,000,000,000 took  41.0222 sec, thr: 87.367 Gbps\n",
      "Sent  1,000,000,000 size:  512-Byte done!\tGot  1,000,000,000 took  46.1300 sec, thr: 88.792 Gbps\n",
      "Sent  1,000,000,000 size:  576-Byte done!\tGot  1,000,000,000 took  51.2378 sec, thr: 89.934 Gbps\n",
      "Sent  1,000,000,000 size:  640-Byte done!\tGot  1,000,000,000 took  56.3457 sec, thr: 90.868 Gbps\n",
      "Sent  1,000,000,000 size:  704-Byte done!\tGot  1,000,000,000 took  61.4535 sec, thr: 91.647 Gbps\n",
      "Sent  1,000,000,000 size:  768-Byte done!\tGot  1,000,000,000 took  66.5613 sec, thr: 92.306 Gbps\n",
      "Sent  1,000,000,000 size:  832-Byte done!\tGot  1,000,000,000 took  71.6691 sec, thr: 92.871 Gbps\n",
      "Sent  1,000,000,000 size:  896-Byte done!\tGot  1,000,000,000 took  76.7770 sec, thr: 93.361 Gbps\n",
      "Sent  1,000,000,000 size:  960-Byte done!\tGot  1,000,000,000 took  81.8848 sec, thr: 93.790 Gbps\n",
      "Sent  1,000,000,000 size: 1024-Byte done!\tGot  1,000,000,000 took  86.9926 sec, thr: 94.169 Gbps\n",
      "Sent  1,000,000,000 size: 1088-Byte done!\tGot  1,000,000,000 took  92.1004 sec, thr: 94.506 Gbps\n",
      "Sent  1,000,000,000 size: 1152-Byte done!\tGot  1,000,000,000 took  97.2083 sec, thr: 94.807 Gbps\n",
      "Sent  1,000,000,000 size: 1216-Byte done!\tGot  1,000,000,000 took 102.3161 sec, thr: 95.078 Gbps\n",
      "Sent  1,000,000,000 size: 1280-Byte done!\tGot  1,000,000,000 took 107.4239 sec, thr: 95.323 Gbps\n",
      "Sent  1,000,000,000 size: 1344-Byte done!\tGot  1,000,000,000 took 112.5317 sec, thr: 95.546 Gbps\n",
      "Sent  1,000,000,000 size: 1408-Byte done!\tGot  1,000,000,000 took 117.6395 sec, thr: 95.750 Gbps\n",
      "Sent  1,000,000,000 size: 1472-Byte done!\tGot  1,000,000,000 took 122.7474 sec, thr: 95.937 Gbps\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "freq = 300\n",
    "ol_w0_tg = ol_w0.traffic_generator_1_3\n",
    "experiment_dict = {}\n",
    "local_dict = {}\n",
    "ol_w0_tg.register_map.mode = benchmark_mode.index('PRODUCER')\n",
    "ol_w0_tg.register_map.dest_id = 7\n",
    "ol_w1_tg.freq = freq\n",
    "ol_w0_tg.freq = freq\n",
    "for pkt in [1000000, 1000000000]:\n",
    "    ol_w0_tg.register_map.debug_reset = 1\n",
    "    ol_w1_tg.register_map.debug_reset = 1\n",
    "    ol_w0_tg.register_map.time_between_packets = 0\n",
    "    ol_w0_tg.register_map.number_packets = pkt\n",
    "    local_dict = {}\n",
    "    for i in range(23):\n",
    "        beats = i + 1\n",
    "        ol_w0_tg.register_map.number_beats = beats\n",
    "        ol_w0_tg.register_map.CTRL.AP_START = 1\n",
    "        while int(ol_w0_tg.register_map.out_traffic_packets) != pkt:\n",
    "            time.sleep(0.8)\n",
    "        # Get results from local and remote worker\n",
    "        rx_tot_pkt, rx_thr, rx_time = ol_w1_tg.computeThroughputApp('rx')\n",
    "        tx_tot_pkt, tx_thr, tx_time = ol_w0_tg.computeThroughputApp('tx')\n",
    "        #Create dict entry for this particular experiment\n",
    "        entry_dict = {'size': (beats * 64), 'rx_pkts' : rx_tot_pkt, 'tx_thr': tx_thr, 'rx_thr': rx_thr}\n",
    "        local_dict[beats] = entry_dict\n",
    "        # Reset probes to prepare for next computation\n",
    "        ol_w0_tg.resetProbes()\n",
    "        ol_w1_tg.resetProbes() \n",
    "        print(\"Sent {:14,} size: {:4}-Byte done!\\tGot {:14,} took {:8.4f} sec, thr: {:.3f} Gbps\"\\\n",
    "              .format(pkt,beats*64, rx_tot_pkt, rx_time, rx_thr))\n",
    "        time.sleep(0.5)\n",
    "    experiment_dict[pkt] = local_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot the results\n",
    "Finally we can plot the results using matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1332x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "dict_oneM = experiment_dict[1000000]\n",
    "dict_oneB = experiment_dict[1000000000]\n",
    "labels = []\n",
    "oneM_thr = []\n",
    "oneB_thr = []\n",
    "\n",
    "for b in dict_oneM:\n",
    "    labels.append(dict_oneM[b]['size'])\n",
    "    oneM_thr.append(dict_oneM[b]['rx_thr'])\n",
    "\n",
    "for b in dict_oneB:\n",
    "    oneB_thr.append(dict_oneB[b]['rx_thr'])\n",
    "\n",
    "x = np.arange(len(labels))  # the label locations\n",
    "width = 0.35  # the width of the bars\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "rects1 = ax.bar(x - width/2, oneM_thr, width, label='A Million Packets')\n",
    "rects2 = ax.bar(x + width/2, oneB_thr, width, label='A Billion Packets')\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('Throughput (Gbit/s)')\n",
    "ax.set_xlabel('Payload Size (Byte)')\n",
    "ax.set_title('Throughput for different packet size at application level')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.legend()\n",
    "ax.set_ylim(40,100)\n",
    "fig.set_size_inches(18.5, 7)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Release Alveo cards\n",
    "To release the alveo cards the pynq overlay is freed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "pynq.Overlay.free(ol_w0)\n",
    "pynq.Overlay.free(ol_w1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------------------------------------------\n",
    "Copyright (c) 2020-2021, Xilinx, Inc."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}