mem_usage.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Memory usage for FlexDriver and CPU driver\n",
    "\n",
    "This notebook estimates the memory usage for an mlx5 driver for RDMA and compares it to the memory usage for FlexDriver."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "from copy import copy\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import plotnine as p9\n",
    "\n",
    "from common import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def log2(value):\n",
    "    return np.ceil(np.log2(value)).astype('int')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def round_pow2(value):\n",
    "    return np.left_shift(1, log2(value))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cuckoo_hash(tag_size, value_size):\n",
    "    '''Compute the size of the cuckoo hash table in bytes.'''\n",
    "    num_banks = 4\n",
    "    num_entries = 2 * round_pow2(value_size) / num_banks\n",
    "    tag_width = log2(tag_size)\n",
    "    value_width = log2(value_size)\n",
    "    return num_banks * num_entries * (tag_width + value_width) / 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bdp(df):\n",
    "    '''Compute the bandwidth-delay product.'''\n",
    "    linerate = df['linerate_gbps']\n",
    "    df[f'packet_rate_mpps'] = linerate / (df['min_packet_size_bytes'] + 20) * 125\n",
    "    for dir in ('tx', 'rx'):\n",
    "        latency = df[f'latency_{dir}_usec']\n",
    "        df[f'{dir}_bdp_bytes'] = np.ceil(linerate * latency * 125)\n",
    "        df[f'{dir}_bdp_descs'] = np.ceil(df['packet_rate_mpps'] * latency)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def outstanding_buffer_fragmentation(df):\n",
    "    '''Compute necessary buffer size for outstanding receive/transmit packets,\n",
    "    taking fragmentation into account.'''\n",
    "\n",
    "    # Use double the computed size for fragmentation (assumes minimal packet size >= block size)\n",
    "    assert (df['fld_tx_data_block_bytes'] <= df['min_packet_size_bytes']).all()\n",
    "    rx_stride = 64 # byte\n",
    "    assert (rx_stride <= df['min_packet_size_bytes']).all()\n",
    "    # Standard SRQ uses same computation as unshared tx buffer\n",
    "    for dir in ('tx', 'rx'):\n",
    "        df[f'{dir}_descs'] = df[f'{dir}_bdp_descs']\n",
    "    \n",
    "        # FLD\n",
    "        outstanding_fragmentation_bytes = df[f'{dir}_bdp_bytes'].rename(f'{dir}_outstanding_fragmentation_bytes') * 2\n",
    "        # not FLD\n",
    "        outstanding_fragmentation_bytes = outstanding_fragmentation_bytes.where(df['fld'],\n",
    "                                            df[f'{dir}_descs'] * df['max_packet_size_bytes'])\n",
    "\n",
    "        df[f'{dir}_outstanding_bytes'] = np.maximum(df[f'{dir}_bdp_bytes'], outstanding_fragmentation_bytes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def srq(df):\n",
    "    '''Compute the size of the receive queue with FLD and with a standard driver.'''\n",
    "    df['rwqe_bytes'] = np.where(df['fld'], 32, 16)\n",
    "    df['cqe_bytes'] = np.where(df['fld'], 120 / 8, 64)\n",
    "    rx_descs_pow2 = round_pow2(df['rx_descs'])\n",
    "    df['srq_wq_bytes'] = (rx_descs_pow2 * df['rwqe_bytes']).where(~df['fld'], 0)\n",
    "    df['rcq_bytes'] = rx_descs_pow2 * df['cqe_bytes']\n",
    "    df['srq_doorbell_record_bytes'] = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "wqebb_bytes = 64\n",
    "fld_wqe_bytes = 8\n",
    "\n",
    "def txq(df):\n",
    "    '''Compute the size of the transmit queues.'''\n",
    "\n",
    "    tx_descs_pow2 = round_pow2(df['tx_descs'])\n",
    "    df['twqe_bytes'] = np.where(df['fld'], fld_wqe_bytes, wqebb_bytes)\n",
    "    txq_wq_bytes_fld = tx_descs_pow2 * df['twqe_bytes']\n",
    "    txq_wq_bytes_no_fld = tx_descs_pow2 * df['num_tx_queues'] * df['twqe_bytes']\n",
    "\n",
    "    df['txq_wq_trans_table_tag_size'] = tx_descs_pow2 * df['num_tx_queues']\n",
    "    txq_wq_translation_table_bytes_fld = cuckoo_hash(tag_size=df['txq_wq_trans_table_tag_size'],\n",
    "                                                        value_size=df['tx_descs'])\n",
    "    df['txq_data_trans_table_tag_size'] = (df['tx_outstanding_bytes'] * df['num_tx_queues'] / df['fld_tx_data_block_bytes'])\n",
    "    txq_data_translation_table_bytes_fld = cuckoo_hash(tag_size=df['txq_data_trans_table_tag_size'],\n",
    "                                                            value_size=df['tx_outstanding_bytes'] / df['fld_tx_data_block_bytes'])\n",
    "\n",
    "    df['txq_wq_bytes'] = txq_wq_bytes_fld.where(df['fld'], txq_wq_bytes_no_fld)\n",
    "    df['txq_wq_translation_table_bytes'] = txq_wq_translation_table_bytes_fld.where(df['fld'], 0)\n",
    "    df['txq_data_translation_table_bytes'] = txq_data_translation_table_bytes_fld.where(df['fld'], 0)\n",
    "\n",
    "    df['tcq_bytes'] = tx_descs_pow2 * df['cqe_bytes']\n",
    "    df['txq_doorbell_record_bytes'] = 4 * df['num_tx_queues']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "metadata_fields = ['srq_wq_bytes', 'rcq_bytes', 'txq_wq_bytes', 'tcq_bytes',\n",
    "                    'srq_doorbell_record_bytes', 'txq_doorbell_record_bytes',\n",
    "                    'txq_wq_translation_table_bytes',\n",
    "                    'txq_data_translation_table_bytes']\n",
    "data_fields = [f'{dir}_outstanding_bytes' for dir in ('tx', 'rx')]\n",
    "\n",
    "def mem_usage(df):\n",
    "    '''Compute usage of the different driver components with FlexDriver and for\n",
    "    a CPU driver.'''\n",
    "    keys = list(df.columns)\n",
    "    bdp(df)\n",
    "    outstanding_buffer_fragmentation(df)\n",
    "    srq(df)\n",
    "    txq(df)\n",
    "    df = df.set_index(keys)\n",
    "    df['total_pi_bytes'] = df['txq_doorbell_record_bytes'] + df['srq_doorbell_record_bytes']\n",
    "    df['total_cq_bytes'] = df['rcq_bytes'] + df['tcq_bytes']\n",
    "    df['total_metadata_bytes'] = df.groupby(keys)[metadata_fields].sum().sum(axis=1)\n",
    "    df['total_data_bytes'] = df.groupby(keys)[data_fields].sum().sum(axis=1)\n",
    "    df['total_bytes'] = df['total_metadata_bytes'] + df['total_data_bytes']\n",
    "    return df.reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>linerate_gbps</th>\n",
       "      <th>fld</th>\n",
       "      <th>num_tx_queues</th>\n",
       "      <th>min_packet_size_bytes</th>\n",
       "      <th>max_packet_size_kib</th>\n",
       "      <th>latency_rx_usec</th>\n",
       "      <th>latency_tx_usec</th>\n",
       "      <th>packet_rate_mpps</th>\n",
       "      <th>tx_bdp_descs</th>\n",
       "      <th>rx_bdp_descs</th>\n",
       "      <th>tx_bdp_kib</th>\n",
       "      <th>rx_bdp_kib</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>100</td>\n",
       "      <td>False</td>\n",
       "      <td>512</td>\n",
       "      <td>256</td>\n",
       "      <td>16.0</td>\n",
       "      <td>5</td>\n",
       "      <td>25</td>\n",
       "      <td>45.289855</td>\n",
       "      <td>1133.0</td>\n",
       "      <td>227.0</td>\n",
       "      <td>305.175781</td>\n",
       "      <td>61.035156</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>74</th>\n",
       "      <td>100</td>\n",
       "      <td>True</td>\n",
       "      <td>512</td>\n",
       "      <td>256</td>\n",
       "      <td>16.0</td>\n",
       "      <td>5</td>\n",
       "      <td>25</td>\n",
       "      <td>45.289855</td>\n",
       "      <td>1133.0</td>\n",
       "      <td>227.0</td>\n",
       "      <td>305.175781</td>\n",
       "      <td>61.035156</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    linerate_gbps    fld  num_tx_queues  min_packet_size_bytes  \\\n",
       "22            100  False            512                    256   \n",
       "74            100   True            512                    256   \n",
       "\n",
       "    max_packet_size_kib  latency_rx_usec  latency_tx_usec  packet_rate_mpps  \\\n",
       "22                 16.0                5               25         45.289855   \n",
       "74                 16.0                5               25         45.289855   \n",
       "\n",
       "    tx_bdp_descs  rx_bdp_descs  tx_bdp_kib  rx_bdp_kib  \n",
       "22        1133.0         227.0  305.175781   61.035156  \n",
       "74        1133.0         227.0  305.175781   61.035156  "
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Scenarios: FLD / CPU x Linerate x No. TX queues\n",
    "df = (pd.DataFrame({'fld': (False, True)})\n",
    "      .merge(pd.DataFrame({'linerate_gbps': [50 << i for i in range(4)]}), how='cross')\n",
    "      .merge(pd.DataFrame({'num_tx_queues': [1 << i for i in range(0, 13)]}), how='cross')\n",
    ").assign(latency_tx_usec=25, latency_rx_usec=5, min_packet_size_bytes=256, max_packet_size_bytes=1 << 14, fld_tx_data_block_bytes=256)\n",
    "df = mem_usage(df)\n",
    "\n",
    "# add KiB/MiB units results\n",
    "for col in df.columns:\n",
    "      if col.endswith('bytes'):\n",
    "            df[col.split('_bytes')[0] + '_kib'] = df[col] / (1 << 10)\n",
    "            df[col.split('_bytes')[0] + '_mib'] = df[col] / (1 << 20)\n",
    "\n",
    "interesting_rows = (df.linerate_gbps.isin((100,))) & (df.num_tx_queues == 512)\n",
    "keys = ['linerate_gbps', 'fld', 'num_tx_queues']\n",
    "table_2a_cols = ['min_packet_size_bytes', 'max_packet_size_kib', 'latency_rx_usec', 'latency_tx_usec', 'packet_rate_mpps', 'tx_bdp_descs', 'rx_bdp_descs', 'tx_bdp_kib', 'rx_bdp_kib']\n",
    "df[interesting_rows][keys + table_2a_cols]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>linerate_gbps</th>\n",
       "      <th>fld</th>\n",
       "      <th>num_tx_queues</th>\n",
       "      <th>twqe_bytes</th>\n",
       "      <th>rwqe_bytes</th>\n",
       "      <th>cqe_bytes</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>100</td>\n",
       "      <td>False</td>\n",
       "      <td>512</td>\n",
       "      <td>64</td>\n",
       "      <td>16</td>\n",
       "      <td>64.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>74</th>\n",
       "      <td>100</td>\n",
       "      <td>True</td>\n",
       "      <td>512</td>\n",
       "      <td>8</td>\n",
       "      <td>32</td>\n",
       "      <td>15.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    linerate_gbps    fld  num_tx_queues  twqe_bytes  rwqe_bytes  cqe_bytes\n",
       "22            100  False            512          64          16       64.0\n",
       "74            100   True            512           8          32       15.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "table_2b_cols = ['twqe_bytes', 'rwqe_bytes', 'cqe_bytes']\n",
    "df[interesting_rows][keys + table_2b_cols]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>linerate_gbps</th>\n",
       "      <th>fld</th>\n",
       "      <th>num_tx_queues</th>\n",
       "      <th>txq_wq_mib</th>\n",
       "      <th>txq_wq_kib</th>\n",
       "      <th>txq_wq_translation_table_kib</th>\n",
       "      <th>tx_outstanding_mib</th>\n",
       "      <th>tx_outstanding_kib</th>\n",
       "      <th>txq_data_translation_table_kib</th>\n",
       "      <th>rx_outstanding_mib</th>\n",
       "      <th>rx_outstanding_kib</th>\n",
       "      <th>total_cq_kib</th>\n",
       "      <th>srq_wq_mib</th>\n",
       "      <th>srq_wq_kib</th>\n",
       "      <th>total_pi_bytes</th>\n",
       "      <th>total_mib</th>\n",
       "      <th>total_kib</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>100</td>\n",
       "      <td>False</td>\n",
       "      <td>512</td>\n",
       "      <td>64.000000</td>\n",
       "      <td>65536.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>17.703125</td>\n",
       "      <td>18128.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.546875</td>\n",
       "      <td>3632.000000</td>\n",
       "      <td>144.00</td>\n",
       "      <td>0.003906</td>\n",
       "      <td>4.0</td>\n",
       "      <td>2052</td>\n",
       "      <td>85.396488</td>\n",
       "      <td>87446.003906</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>74</th>\n",
       "      <td>100</td>\n",
       "      <td>True</td>\n",
       "      <td>512</td>\n",
       "      <td>0.015625</td>\n",
       "      <td>16.0</td>\n",
       "      <td>15.5</td>\n",
       "      <td>0.596046</td>\n",
       "      <td>610.351562</td>\n",
       "      <td>33.0</td>\n",
       "      <td>0.119209</td>\n",
       "      <td>122.070312</td>\n",
       "      <td>33.75</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2052</td>\n",
       "      <td>0.813160</td>\n",
       "      <td>832.675781</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    linerate_gbps    fld  num_tx_queues  txq_wq_mib  txq_wq_kib  \\\n",
       "22            100  False            512   64.000000     65536.0   \n",
       "74            100   True            512    0.015625        16.0   \n",
       "\n",
       "    txq_wq_translation_table_kib  tx_outstanding_mib  tx_outstanding_kib  \\\n",
       "22                           0.0           17.703125        18128.000000   \n",
       "74                          15.5            0.596046          610.351562   \n",
       "\n",
       "    txq_data_translation_table_kib  rx_outstanding_mib  rx_outstanding_kib  \\\n",
       "22                             0.0            3.546875         3632.000000   \n",
       "74                            33.0            0.119209          122.070312   \n",
       "\n",
       "    total_cq_kib  srq_wq_mib  srq_wq_kib  total_pi_bytes  total_mib  \\\n",
       "22        144.00    0.003906         4.0            2052  85.396488   \n",
       "74         33.75    0.000000         0.0            2052   0.813160   \n",
       "\n",
       "       total_kib  \n",
       "22  87446.003906  \n",
       "74    832.675781  "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "table_3_cols = [\n",
    "    'txq_wq_mib', 'txq_wq_kib', \n",
    "    'txq_wq_translation_table_kib', \n",
    "    'tx_outstanding_mib', 'tx_outstanding_kib', \n",
    "    'txq_data_translation_table_kib',\n",
    "    'rx_outstanding_mib', 'rx_outstanding_kib', \n",
    "    'total_cq_kib',\n",
    "    'srq_wq_mib', 'srq_wq_kib', \n",
    "    'total_pi_bytes', \n",
    "    'total_mib',\n",
    "    'total_kib']\n",
    "df[interesting_rows][keys + table_3_cols]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Color palette\n",
    "software_color, fld_color, fpga_color = pal(3) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 337.566x100 with 4 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 145,
       "width": 319
      }
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<ggplot: (8765399848659)>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def linerate_labeller(linerate):\n",
    "    return f'{linerate} Gbps'\n",
    "\n",
    "def log2_labeller(breaks):\n",
    "    return [f'$2^{{{i}}}$' for i in np.log2(breaks).astype('int')]\n",
    "\n",
    "def minor_breaks(limits):\n",
    "    major = [10 ** i for i in range(0, 5)]\n",
    "    res = [m * 1.5 for m in major\n",
    "           if m * 1.5 < limits[1]]\n",
    "    return res\n",
    "\n",
    "limit_xcku15p_df = pd.DataFrame({'type': ['BRAM', 'URAM', 'LUTRAM'],\n",
    "  'Mibit': [34.6, 36, 9.8]})\n",
    "limit_xcku15p_mib = limit_xcku15p_df['Mibit'].sum() / 8\n",
    "\n",
    "grid_color = p9.options.current_theme.themeables['panel_grid_major'].theme_element.properties['color']\n",
    "ticks_color = \"#000000\"\n",
    "\n",
    "df['total_mib'] = df['total_bytes'] / (2 ** 20)\n",
    "df['fld_name'] = np.where(df['fld'], 'FLD', 'software')\n",
    "plt = (p9.ggplot(df, p9.aes(x='num_tx_queues', y='total_mib', linetype='fld_name', color='fld_name')) +\n",
    "  p9.geom_line() +\n",
    "  p9.geom_hline(mapping=p9.aes(linetype=['XCKU15P limit'], color=['XCKU15P limit'], yintercept=limit_xcku15p_mib)) + \n",
    "  p9.scale_x_continuous(trans='log2', name='# transmit queues', labels=log2_labeller) +\n",
    "  p9.scale_y_continuous(trans='log10', name='shared memory [MiB]',\n",
    "      minor_breaks=minor_breaks) +\n",
    "  p9.facet_grid('~ linerate_gbps', labeller=linerate_labeller) + \n",
    "  p9.theme(\n",
    "    figure_size=(fig_width, 1),\n",
    "    subplots_adjust={'top': 0.77},\n",
    "    axis_ticks_minor_y=p9.element_line(ticks_color),\n",
    "    panel_grid_minor_y=p9.element_line(color=grid_color, size=0.5),\n",
    "  ) +\n",
    "  top_legend + \\\n",
    "  p9.scale_color_manual(values=[fld_color, software_color, fpga_color])\n",
    ")\n",
    "plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/haggai/miniconda3/envs/flc-model/lib/python3.9/site-packages/plotnine/ggplot.py:719: PlotnineWarning: Saving 3.37566 x 1 in image.\n",
      "/home/haggai/miniconda3/envs/flc-model/lib/python3.9/site-packages/plotnine/ggplot.py:722: PlotnineWarning: Filename: mem_usage.pdf\n"
     ]
    }
   ],
   "source": [
    "plt.save('mem_usage.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type                  col  \n",
       "tx_meta_total_bytes   ratio    2080.507937\n",
       "tx_data_total_bytes   ratio      28.177440\n",
       "total_cq_bytes        ratio       4.266667\n",
       "srq_wq_bytes          ratio            inf\n",
       "rx_outstanding_bytes  ratio      29.753344\n",
       "total_bytes           ratio     105.018071\n",
       "Name: (100, 512), dtype: float64"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduction = copy(df)\n",
    "reduction['tx_meta_total_bytes'] = reduction['txq_wq_bytes'] + reduction['txq_wq_translation_table_bytes']\n",
    "reduction['tx_data_total_bytes'] = reduction['tx_outstanding_bytes'] + reduction['txq_data_translation_table_bytes']\n",
    "reduction_cols = ['tx_meta_total_bytes', 'tx_data_total_bytes', 'total_cq_bytes', 'srq_wq_bytes', 'rx_outstanding_bytes', 'total_bytes']\n",
    "reduction = reduction.pivot_table(values=reduction_cols, columns=['fld'], index=['linerate_gbps', 'num_tx_queues'])\n",
    "\n",
    "def slice_fld(df, fld):\n",
    "    new_df = df.loc[:, [(col, fld) for col in reduction_cols]]\n",
    "    new_df.columns = new_df.columns.droplevel(1)\n",
    "    return new_df\n",
    "\n",
    "no_fld = slice_fld(reduction, False)\n",
    "fld = slice_fld(reduction, True)\n",
    "ratio = no_fld / fld\n",
    "ratio.columns = pd.MultiIndex.from_tuples((c, 'ratio') for c in ratio.columns)\n",
    "reduction = pd.concat([reduction, ratio], axis=1)#.sort_values(by=1, axis=1)\n",
    "reduction.columns.names = ['type', 'col']\n",
    "reduction = reduction.sort_values(by=['type', 'col'], axis=1)\n",
    "reduction[[(col, 'ratio') for col in reduction_cols]].loc[(100, 512)]"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "c6e5e40b5d548b459b1e0d7764dd601243dd92169d54f8c16faf73bff9192545"
  },
  "kernelspec": {
   "display_name": "Python 3.8.8 64-bit ('base': conda)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}