plot_access_om2_scaling.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import parse_access_om2_results as par\n",
    "import plot_pandas_data as ppd\n",
    "import plot_right_axis_time as pra\n",
    "from convert_time import days_to_gregorian_years, gregorian_years_to_days"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = par.parse_om2_dataframe(\"../access-om2/archive\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bw = lambda d: d[d[\"nodesize\"] == 28]\n",
    "cl = lambda d: d[d[\"nodesize\"] == 48]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_bw = bw(df)\n",
    "df_cl = cl(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ocean_cice_ratio_middle = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hi_ice = lambda d: d[d[\"ocean_ncpus\"] / d[\"ice_ncpus\"] <= ocean_cice_ratio_middle]\n",
    "lo_ice = lambda d: d[d[\"ocean_ncpus\"] / d[\"ice_ncpus\"] > ocean_cice_ratio_middle]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_bw_hi = hi_ice(df_bw)\n",
    "df_bw_lo = lo_ice(df_bw)\n",
    "df_cl_hi = hi_ice(df_cl)\n",
    "df_cl_lo = lo_ice(df_cl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const_ice_nbr_blocks = 5767"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const_blocks = lambda d: d[d[\"ice_nbr_blocks\"] == const_ice_nbr_blocks]\n",
    "var_blocks =   lambda d: d[d[\"ice_nbr_blocks\"] != const_ice_nbr_blocks]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lo_ice_const_blocks = const_blocks(df_cl_lo)\n",
    "lo_ice_var_blocks = var_blocks(df_cl_lo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_allowed_init_time = 300.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fast_init = lambda d: d[d[\"Initialization\"] <= max_allowed_init_time]\n",
    "slow_init = lambda d: d[d[\"Initialization\"] > max_allowed_init_time]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_cl_fast_init = fast_init(df_cl)\n",
    "df_cl_slow_init = slow_init(df_cl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_ice_block_comparison(plot_fn, x, data,\n",
    "        xticks=[],\n",
    "        right_axis_fn=pra.no_right_axis,\n",
    "        fig_nbr=0,\n",
    "        caption=None,\n",
    "        **kwargs):                      \n",
    "    if xticks == []:\n",
    "        xticks = data[x].sort_values().unique()\n",
    "    xtick_labels = [str(int(val)) for val in xticks]\n",
    "    fig, ax = plt.subplots()\n",
    "    plots = [\n",
    "        plot_fn(\n",
    "            hi_ice(data),\n",
    "            ax=ax,\n",
    "            xticks=xticks,\n",
    "            right_axis_fn=right_axis_fn,\n",
    "            fig_nbr=fig_nbr,\n",
    "            caption=caption,\n",
    "            **kwargs)]\n",
    "    for dataframe in [\n",
    "        const_blocks(lo_ice(data)),\n",
    "        var_blocks(lo_ice(data))]:\n",
    "        plots.append(plot_fn(\n",
    "            dataframe,\n",
    "            ax=ax,\n",
    "            xticks=xticks,\n",
    "            right_axis_fn=pra.no_right_axis,\n",
    "            **kwargs))\n",
    "    legend = (\n",
    "            \"High CICE cores\",\n",
    "            \"Low CICE cores, const #blocks\",\n",
    "            \"Low CICE cores, var #blocks\")\n",
    "    plt.legend((plot[0] for plot in plots), legend)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loglog_om2_speed_by_ncpus(df, **kwargs):\n",
    "    p = ppd.loglog(\"om2_ncpus\", \"OM2 speed\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of ACCESS-OM2 cores\",\n",
    "        ylabel=\"ACCESS-OM2 speed (d/d)\",\n",
    "        **kwargs)\n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ppd.plot_by_xy_labels_fn(\n",
    "    loglog_om2_speed_by_ncpus,\n",
    "    \"om2_ncpus\",\n",
    "    data=df_bw,\n",
    "    yticks=[200,500,1000],\n",
    "    right_yticks=[1,2],\n",
    "    right_axis_fn=pra.plot_right_axis_yd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "ppd.plot_by_xy_labels_fn(\n",
    "    loglog_om2_speed_by_ncpus,\n",
    "    \"om2_ncpus\",\n",
    "    data=df_cl_hi,\n",
    "    yticks=[500,1000,2000],\n",
    "    right_yticks=[1,2,3,5],\n",
    "    right_axis_fn=pra.plot_right_axis_yd,\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2 with current proportion of CICE cores:\\n\"\n",
    "            \"Simulation speed from walltime\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def semilogx_om2_speed_per_cpu_by_ncpus(df, **kwargs):\n",
    "    p = ppd.semilogx(\"om2_ncpus\", \"OM2 speed per cpu\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of ACCESS-OM2 cores\",\n",
    "        ylabel=\"ACCESS-OM2 speed (d/d) per core\",\n",
    "        **kwargs)\n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "ppd.plot_by_xy_labels_fn(\n",
    "    semilogx_om2_speed_per_cpu_by_ncpus,\n",
    "    \"om2_ncpus\", \n",
    "    data=df_cl_hi,\n",
    "    yticks=[0.05 * n for n in range(5)],\n",
    "    right_yticks=[0.0001 * n for n in range(6)],\n",
    "    right_axis_fn=pra.plot_right_axis_yd,\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2 with current proportion of CICE cores:\\n\"\n",
    "            \"simulation speed per OM2 core\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loglog_ocean_speed_by_ncpus(df, **kwargs):\n",
    "    p = ppd.loglog(\"ocean_ncpus\", \"Ocean speed\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of MOM cores\",\n",
    "        ylabel=\"Ocean loop speed (d/d)\",\n",
    "        **kwargs) \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "ppd.plot_by_xy_labels_fn(\n",
    "    loglog_ocean_speed_by_ncpus,\n",
    "    \"ocean_ncpus\", \n",
    "    data=df_cl_hi,\n",
    "    yticks=[500,1000,2000,5000],\n",
    "    right_yticks=[1,2,5,10],\n",
    "    right_axis_fn=pra.plot_right_axis_yd,\n",
    "    marker='d',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2 with current proportion of CICE cores:\\n\"\n",
    "            \"Simulation speed from Ocean loop time by number of MOM cores\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def semilogx_ocean_speed_per_cpu_by_ncpus(df, **kwargs):\n",
    "    p = ppd.semilogx(\"ocean_ncpus\", \"Ocean speed per cpu\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of MOM cores\",\n",
    "        ylabel=\"Ocean loop speed (d/d) per core\",\n",
    "        **kwargs) \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "ppd.plot_by_xy_labels_fn(\n",
    "    semilogx_ocean_speed_per_cpu_by_ncpus,    \n",
    "    \"ocean_ncpus\",\n",
    "    data=df_cl_hi,\n",
    "    yticks=[n/20.0 for n in range(7)],\n",
    "    right_yticks=[n/5000.0 for n in range(5)],\n",
    "    right_axis_fn=pra.plot_right_axis_yd,\n",
    "    marker='d',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2 with current proportion of CICE cores:\\n\"\n",
    "            \"Ocean loop speed per OM2 core by number of MOM cores\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loglog_ice_speed_by_ncpus(df, **kwargs):\n",
    "    p = ppd.loglog(\"ice_ncpus\", \"Ice TimeLoop speed\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of CICE cores\",\n",
    "        ylabel=\"Ice loop speed (d/d)\",\n",
    "        **kwargs) \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "ppd.plot_by_xy_labels_fn(\n",
    "    loglog_ice_speed_by_ncpus, \n",
    "    \"ice_ncpus\", \n",
    "    data=df_cl_hi,\n",
    "    yticks=[500,1000,2000],\n",
    "    right_yticks=[1,2,5,10,20],\n",
    "    right_axis_fn=pra.plot_right_axis_yd,\n",
    "    marker='*',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2 with current proportion of CICE cores:\\n\"\n",
    "            \"Simulation speed from Ice loop time by number of CICE cores\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def semilogx_ice_speed_per_cpu_by_ncpus(df, **kwargs):\n",
    "    p = ppd.semilogx(\"ice_ncpus\", \"Ice speed per cpu\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of CICE cores\",\n",
    "        ylabel=\"Ice loop speed (d/d) per core\",\n",
    "        **kwargs) \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "ppd.plot_by_xy_labels_fn(\n",
    "    semilogx_ice_speed_per_cpu_by_ncpus,\n",
    "    \"ice_ncpus\",\n",
    "    data=df_cl_hi,\n",
    "    yticks=[n/5.0 for n in range(8)],\n",
    "    right_yticks=[n/1000.0 for n in range(8)],\n",
    "    right_axis_fn=pra.plot_right_axis_yd,\n",
    "    marker='*',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2 with current proportion of CICE cores:\\n\"\n",
    "            \"Ice loop speed per OM2 core by number of CICE cores\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loglog_ice_speed_by_ocean_ncpus_nbr_blocks(df, **kwargs):\n",
    "    p = ppd.loglog_by_group(\"ice_nbr_blocks\", \"Ice TimeLoop speed\",\n",
    "        by=\"ocean_ncpus\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of CICE blocks\",\n",
    "        ylabel=\"Ice loop speed (d/d)\",\n",
    "        legend_title=\"MOM cores\",\n",
    "        **kwargs)\n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "ppd.plot_by_xy_labels_fn(\n",
    "    loglog_ice_speed_by_ocean_ncpus_nbr_blocks,\n",
    "    \"ice_nbr_blocks\",  \n",
    "    data=df_cl_hi,\n",
    "    yticks=[500,1000,2000,3000],\n",
    "    right_yticks=[1,2,4,8],\n",
    "    right_axis_fn=pra.plot_right_axis_yd,\n",
    "    marker='*',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2 with current proportion of CICE cores:\\n\"\n",
    "            \"Effect on Ice loop speed of varying number of CICE blocks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ppd.plot_by_xy_labels_fn(\n",
    "    loglog_ice_speed_by_ocean_ncpus_nbr_blocks,\n",
    "    \"ice_nbr_blocks\", \n",
    "    data=df_cl_lo,\n",
    "    yticks=[500,1000,2000,3000],\n",
    "    right_yticks=[1,2,4,8],\n",
    "    right_axis_fn=pra.plot_right_axis_yd,\n",
    "    marker='*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "plot_ice_block_comparison(\n",
    "    loglog_om2_speed_by_ncpus,\n",
    "    \"om2_ncpus\",\n",
    "    df_cl,\n",
    "    yticks=[500,1000,2000],\n",
    "    right_yticks=[1,2,3,5],\n",
    "    right_axis_fn=pra.plot_right_axis_yd,\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2: Effect on simulation speed from walltime:\\n\"\n",
    "            \"Varying the proportion of CICE cores and number of CICE blocks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "plot_ice_block_comparison(\n",
    "    semilogx_om2_speed_per_cpu_by_ncpus,\n",
    "    \"om2_ncpus\",\n",
    "    df_cl,\n",
    "    yticks=[0.05 * n for n in range(5)],\n",
    "    right_yticks=[0.0001 * n for n in range(6)],\n",
    "    right_axis_fn=pra.plot_right_axis_yd,\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2: Effect on simulation speed per OM2 core:\\n\"\n",
    "            \"Varying the proportion of CICE cores and number of CICE blocks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loglog_om2_speed_by_ocean_ncpus_ice_ncpus(df, **kwargs):\n",
    "    p = ppd.loglog_by_group(\"ocean_ncpus\", \"OM2 speed\",\n",
    "        by=\"ice_ncpus\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of MOM cores\",\n",
    "        ylabel=\"ACCESS-OM2 speed (d/d)\",\n",
    "        legend_title=\"CICE cores\",\n",
    "        **kwargs)\n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "ppd.plot_by_xy_labels_fn(\n",
    "    loglog_om2_speed_by_ocean_ncpus_ice_ncpus,\n",
    "    \"ocean_ncpus\",  \n",
    "    data=const_blocks(df_cl),\n",
    "    yticks=[500,1000,2000],\n",
    "    right_yticks=[1,2,3,5],\n",
    "    right_axis_fn=pra.plot_right_axis_yd,\n",
    "    marker='+',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2: Effect on simulation speed:\\n\"\n",
    "            \"Varying the number of MOM cores, keeping CICE cores and blocks constant\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def semilogx_om2_speed_per_cpu_by_ocean_ncpus_ice_ncpus(df, **kwargs):\n",
    "    p = ppd.semilogx_by_group(\"ocean_ncpus\", \"OM2 speed per cpu\",\n",
    "        by=\"ice_ncpus\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of MOM cores\",\n",
    "        ylabel=\"ACCESS-OM2 speed (d/d) per core\",\n",
    "        legend_title=\"CICE cores\",\n",
    "        **kwargs)\n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "ppd.plot_by_xy_labels_fn(\n",
    "    semilogx_om2_speed_per_cpu_by_ocean_ncpus_ice_ncpus,\n",
    "    \"ocean_ncpus\",  \n",
    "    data=const_blocks(df_cl),\n",
    "    yticks=[0.05 * n for n in range(5)],\n",
    "    right_yticks=[0.0001 * n for n in range(6)],\n",
    "    right_axis_fn=pra.plot_right_axis_yd,\n",
    "    marker='+',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2: Effect on simulation speed per OM2 core:\\n\"\n",
    "            \"Varying the number of MOM cores, keeping CICE cores and blocks constant\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "plot_ice_block_comparison(\n",
    "    loglog_ocean_speed_by_ncpus,\n",
    "    \"ocean_ncpus\",\n",
    "    df_cl,\n",
    "    yticks=[500,1000,2000,5000],\n",
    "    right_yticks=[1,2,5,10],\n",
    "    right_axis_fn=pra.plot_right_axis_yd,\n",
    "    marker='d',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2: Effect on Ocean loop speed by number of MOM cores:\\n\"\n",
    "            \"Varying the proportion of CICE cores and number of CICE blocks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "plot_ice_block_comparison(\n",
    "    semilogx_ocean_speed_per_cpu_by_ncpus,\n",
    "    \"ocean_ncpus\",\n",
    "    df_cl,\n",
    "    yticks=[n/20.0 for n in range(7)],\n",
    "    right_yticks=[n/5000.0 for n in range(5)],\n",
    "    right_axis_fn=pra.plot_right_axis_yd,\n",
    "    marker='d',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2: Effect on Ocean loop speed per MOM core:\\n\"\n",
    "            \"Varying the proportion of CICE cores and number of CICE blocks\")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "plot_ice_block_comparison(\n",
    "    loglog_ice_speed_by_ncpus,\n",
    "    \"ice_ncpus\", \n",
    "    df_cl,\n",
    "    yticks=[500,1000,2000],\n",
    "    right_yticks=[1,2,5,10],\n",
    "    right_axis_fn=pra.plot_right_axis_yd,\n",
    "    marker='*',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2: Effect on Ice loop speed by number of CICE cores:\\n\"\n",
    "            \"Varying the proportion of CICE cores and number of CICE blocks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "plot_ice_block_comparison(\n",
    "    semilogx_ice_speed_per_cpu_by_ncpus,\n",
    "    \"ice_ncpus\", \n",
    "    df_cl,\n",
    "    yticks=[0,0.5,1,1.5,2],\n",
    "    right_yticks=[n/1000.0 for n in range(6)],\n",
    "    right_axis_fn=pra.plot_right_axis_yd,\n",
    "    marker='*',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2: Effect on Ice loop speed per CICE core:\\n\"\n",
    "            \"Varying the proportion of CICE cores and number of CICE blocks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_mean(df, x, y):\n",
    "    mean_y_by_x=dict()\n",
    "    group_ncpus=df.groupby(x)\n",
    "    for name, group in group_ncpus:\n",
    "        means = group.groupby(x)[y].mean()\n",
    "        mean_y_by_x[name] = means[name]\n",
    "    return mean_y_by_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def round_dict(d, n):\n",
    "    return {k: round(v, n) for k, v in d.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def days_to_years_dict(d):\n",
    "    return {k: days_to_gregorian_years(v) for k, v in d.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def div_dicts(a, b, rounding=3):\n",
    "    a_keys = a.keys()\n",
    "    b_keys = b.keys()\n",
    "    common_keys = sorted(list(set(a_keys) & set(b_keys)))\n",
    "    return dict([(k, round(a[k]/b[k], rounding)) for k in common_keys])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"ACCESS-OM2 speed per core by OM2 cores\")\n",
    "print(\"High\")\n",
    "high_mean = get_mean(df_cl_hi,\"om2_ncpus\",\"OM2 speed per cpu\")\n",
    "print(\"d/d\")\n",
    "print(round_dict(high_mean,3))\n",
    "print(\"Y/d\")\n",
    "print(round_dict(days_to_years_dict(high_mean), 5))                        \n",
    "print(\"Const\")\n",
    "low_const_mean = get_mean(lo_ice_const_blocks,\"om2_ncpus\",\"OM2 speed per cpu\")\n",
    "print(\"d/d\")\n",
    "print(round_dict(low_const_mean,3))\n",
    "print(\"Y/d\")\n",
    "print(round_dict(days_to_years_dict(low_const_mean), 5))                        \n",
    "print(\"Var\")\n",
    "low_var_mean = get_mean(lo_ice_var_blocks,\"om2_ncpus\",\"OM2 speed per cpu\")\n",
    "print(\"d/d\")\n",
    "print(round_dict(low_var_mean,3))\n",
    "print(\"Y/d\")\n",
    "print(round_dict(days_to_years_dict(low_var_mean), 5))                        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"ACCESS-OM2 speed by MOM cores\")\n",
    "print(\"High\")\n",
    "high_mean = get_mean(df_cl_hi,\"ocean_ncpus\",\"OM2 speed\")\n",
    "print(\"d/d\")\n",
    "print(round_dict(high_mean,3))\n",
    "print(\"Y/d\")\n",
    "print(round_dict(days_to_years_dict(high_mean), 5))                        \n",
    "print(\"Const\")\n",
    "low_const_mean = get_mean(lo_ice_const_blocks,\"ocean_ncpus\",\"OM2 speed\")\n",
    "print(\"d/d\")\n",
    "print(round_dict(low_const_mean,3))\n",
    "print(\"Y/d\")\n",
    "print(round_dict(days_to_years_dict(low_const_mean), 5))                        \n",
    "print(\"Var\")\n",
    "low_var_mean = get_mean(lo_ice_var_blocks,\"ocean_ncpus\",\"OM2 speed\")\n",
    "print(\"d/d\")\n",
    "print(round_dict(low_var_mean,3))\n",
    "print(\"Y/d\")\n",
    "print(round_dict(days_to_years_dict(low_var_mean), 5))\n",
    "print(div_dicts(high_mean, low_const_mean, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"ACCESS-OM2 speed per core by MOM cores\")\n",
    "print(\"High\")\n",
    "high_mean = get_mean(df_cl_hi,\"ocean_ncpus\",\"OM2 speed per cpu\")\n",
    "print(\"d/d\")\n",
    "print(round_dict(high_mean,3))\n",
    "print(\"Y/d\")\n",
    "print(round_dict(days_to_years_dict(high_mean), 5))                        \n",
    "print(\"Const\")\n",
    "low_const_mean = get_mean(lo_ice_const_blocks,\"ocean_ncpus\",\"OM2 speed per cpu\")\n",
    "print(\"d/d\")\n",
    "print(round_dict(low_const_mean,3))\n",
    "print(\"Y/d\")\n",
    "print(round_dict(days_to_years_dict(low_const_mean), 5))                        \n",
    "print(\"Var\")\n",
    "low_var_mean = get_mean(lo_ice_var_blocks,\"ocean_ncpus\",\"OM2 speed per cpu\")\n",
    "print(\"d/d\")\n",
    "print(round_dict(low_var_mean,3))\n",
    "print(\"Y/d\")\n",
    "print(round_dict(days_to_years_dict(low_var_mean), 5))\n",
    "print(div_dicts(high_mean, low_const_mean, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Ocean loop speed per core\")\n",
    "print(\"High\")\n",
    "high_mean = get_mean(df_cl_hi,\"ocean_ncpus\",\"Ocean speed per cpu\")\n",
    "print(\"d/d\")\n",
    "print(round_dict(high_mean,2))\n",
    "print(\"Y/d\")\n",
    "print(round_dict(days_to_years_dict(high_mean), 5))                        \n",
    "print(\"Const\")\n",
    "low_const_mean = get_mean(lo_ice_const_blocks,\"ocean_ncpus\",\"Ocean speed per cpu\")\n",
    "print(\"d/d\")\n",
    "print(round_dict(low_const_mean,2))\n",
    "print(\"Y/d\")\n",
    "print(round_dict(days_to_years_dict(low_const_mean), 5))                        \n",
    "print(\"Var\")\n",
    "low_var_mean = get_mean(lo_ice_var_blocks,\"ocean_ncpus\",\"Ocean speed per cpu\")\n",
    "print(\"d/d\")\n",
    "print(round_dict(low_var_mean,2))\n",
    "print(\"Y/d\")\n",
    "print(round_dict(days_to_years_dict(low_var_mean), 5))\n",
    "print(div_dicts(high_mean, low_const_mean, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Ice loop speed per core\")\n",
    "print(\"High\")\n",
    "high_mean = get_mean(df_cl_hi,\"ice_ncpus\",\"Ice speed per cpu\")\n",
    "print(\"d/d\")\n",
    "print(round_dict(high_mean,2))\n",
    "print(\"Y/d\")\n",
    "print(round_dict(days_to_years_dict(high_mean), 4))                        \n",
    "print(\"Const\")\n",
    "low_const_mean = get_mean(lo_ice_const_blocks,\"ice_ncpus\",\"Ice speed per cpu\")\n",
    "print(\"d/d\")\n",
    "print(round_dict(low_const_mean,2))\n",
    "print(\"Y/d\")\n",
    "print(round_dict(days_to_years_dict(low_const_mean), 4))                        \n",
    "print(\"Var\")\n",
    "low_var_mean = get_mean(lo_ice_var_blocks,\"ice_ncpus\",\"Ice speed per cpu\")\n",
    "print(\"d/d\")\n",
    "print(round_dict(low_var_mean,2))\n",
    "print(\"Y/d\")\n",
    "print(round_dict(days_to_years_dict(low_var_mean), 4))\n",
    "print(div_dicts(high_mean, low_const_mean, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def semilogx_relative_ocean_oasis_recv_by_om2_ncpus(df, **kwargs):\n",
    "    p = ppd.semilogx(\"om2_ncpus\", \"relative ocean_oasis_recv\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of ACCESS-OM2 cores\",\n",
    "        ylabel=\"MOM oasis_recv / Ocean loop time\",\n",
    "        **kwargs) \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "plot_ice_block_comparison(\n",
    "    semilogx_relative_ocean_oasis_recv_by_om2_ncpus,\n",
    "    \"om2_ncpus\",\n",
    "    df_cl,\n",
    "    yticks=[n/5.0 for n in range(6)],\n",
    "    marker='d',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2: Effect on relative MOM wait time:\\n\"\n",
    "            \"Varying the proportion of CICE cores and number of CICE blocks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def semilogx_relative_ice_from_ocn_by_om2_ncpus(df, **kwargs):\n",
    "    p = ppd.semilogx(\"om2_ncpus\", \"relative ice_from_ocn\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of ACCESS-OM2 cores\",\n",
    "        ylabel=\"CICE from_ocn / TimeLoop\",\n",
    "        **kwargs) \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "plot_ice_block_comparison(\n",
    "    semilogx_relative_ice_from_ocn_by_om2_ncpus,\n",
    "    \"om2_ncpus\",\n",
    "    df_cl,\n",
    "    yticks=[n/10.0 for n in range(5)],\n",
    "    marker='*',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2: Effect on relative CICE wait time:\\n\"\n",
    "            \"Varying the proportion of CICE cores and number of CICE blocks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def semilogx_relative_wait_by_om2_ncpus(df, **kwargs):\n",
    "    p = ppd.semilogx(\"om2_ncpus\", \"relative wait\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of ACCESS-OM2 cores\",\n",
    "        ylabel=\"(from_ocn + oasis_recv) / (TimeLoop + Ocean)\",\n",
    "        **kwargs) \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "plot_ice_block_comparison(\n",
    "    semilogx_relative_wait_by_om2_ncpus,\n",
    "    \"om2_ncpus\",\n",
    "    df_cl,\n",
    "    yticks=[n/10.0 for n in range(4)],\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2: Effect on MOM wait time vs CICE wait time:\\n\"\n",
    "            \"Varying the proportion of CICE cores and number of CICE blocks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def semilogx_walltime_wait_by_om2_ncpus(df, **kwargs):\n",
    "    p = ppd.semilogx(\"om2_ncpus\", \"wait relative to walltime\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of ACCESS-OM2 cores\",\n",
    "        ylabel=\"(from_ocn + oasis_recv) / Walltime\",\n",
    "        **kwargs) \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "plot_ice_block_comparison(\n",
    "    semilogx_walltime_wait_by_om2_ncpus,\n",
    "    \"om2_ncpus\",\n",
    "    df_cl,\n",
    "    yticks=[n/10.0 for n in range(6)],\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2: Effect on relative total wait time:\\n\"\n",
    "            \"Varying the proportion of CICE cores and number of CICE blocks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def semilogx_om2_init_time_by_om2_ncpus(df, **kwargs):\n",
    "    p = ppd.semilogx(\"om2_ncpus\", \"Initialization\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of ACCESS-OM2 cores\",\n",
    "        ylabel=\"ACCESS-OM2 Initialization time (s)\",\n",
    "        **kwargs) \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "plot_ice_block_comparison(\n",
    "    semilogx_om2_init_time_by_om2_ncpus,\n",
    "    \"om2_ncpus\", \n",
    "    df_cl,\n",
    "    yticks=[100*n for n in range(6)],\n",
    "    right_yticks=[n/50.0 for n in range(8)],\n",
    "    right_axis_fn=pra.plot_right_axis_sh,\n",
    "    marker='+',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2: Effect on initialization time:\\n\"\n",
    "            \"Varying the proportion of CICE cores and number of CICE blocks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "plot_ice_block_comparison(\n",
    "    semilogx_om2_init_time_by_om2_ncpus,\n",
    "    \"om2_ncpus\", \n",
    "    df_cl_fast_init,\n",
    "    yticks=[50*n for n in range(7)],\n",
    "    right_yticks=[n/50.0 for n in range(5)],\n",
    "    right_axis_fn=pra.plot_right_axis_sh,\n",
    "    marker='+',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2: Effect on initialization time (outliers removed):\\n\"\n",
    "            \"Varying the proportion of CICE cores and number of CICE blocks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def semilogx_ocean_init_time_by_om2_ncpus(df, **kwargs):\n",
    "    p = ppd.semilogx(\"om2_ncpus\", \"(Ocean initialization)\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of ACCESS-OM2 cores\",\n",
    "        ylabel=\"MOM Initialization time (s)\",\n",
    "        **kwargs) \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_ice_block_comparison(\n",
    "    semilogx_ocean_init_time_by_om2_ncpus,\n",
    "    \"om2_ncpus\", \n",
    "    df_cl,\n",
    "    yticks=[100*n for n in range(6)],\n",
    "    right_yticks=[n/50.0 for n in range(9)],\n",
    "    right_axis_fn=pra.plot_right_axis_sh,\n",
    "    marker='d')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "plot_ice_block_comparison(\n",
    "    semilogx_ocean_init_time_by_om2_ncpus,\n",
    "    \"om2_ncpus\", \n",
    "    df_cl_fast_init,\n",
    "    yticks=[20*n for n in range(5)],\n",
    "    right_yticks=[n/100.0 for n in range(4)],\n",
    "    right_axis_fn=pra.plot_right_axis_sh,\n",
    "    marker='d',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2: Effect on MOM initialization time (outliers removed):\\n\"\n",
    "            \"Varying the proportion of CICE cores and number of CICE blocks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def semilogx_ice_init_time_by_om2_ncpus(df, **kwargs):\n",
    "    p = ppd.semilogx(\"om2_ncpus\", \"Ice initialization\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of ACCESS-OM2 cores\",\n",
    "        ylabel=\"CICE initialization time (s)\",\n",
    "        **kwargs) \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_ice_block_comparison(\n",
    "    semilogx_ice_init_time_by_om2_ncpus,\n",
    "    \"om2_ncpus\", \n",
    "    df_cl,\n",
    "    yticks=[50*n for n in range(7)],\n",
    "    right_yticks=[n/50.0 for n in range(5)],\n",
    "    right_axis_fn=pra.plot_right_axis_sh,\n",
    "    marker='*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "plot_ice_block_comparison(\n",
    "    semilogx_ice_init_time_by_om2_ncpus,\n",
    "    \"om2_ncpus\", \n",
    "    df_cl_fast_init,\n",
    "    yticks=[20*n for n in range(7)],\n",
    "    right_yticks=[n/100.0 for n in range(4)],\n",
    "    right_axis_fn=pra.plot_right_axis_sh,\n",
    "    marker='*',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=\"ACCESS-OM2: Effect on CICE initialization time (outliers removed):\\n\"\n",
    "            \"Varying the proportion of CICE cores and number of CICE blocks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loglog_ocean_time_per_step_by_om2_ncpus(df, **kwargs):\n",
    "    p = ppd.loglog(\"om2_ncpus\", \"Ocean per step\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of ACCESS-OM2 cores\",\n",
    "        ylabel=\"Ocean loop time per step (s)\",\n",
    "        **kwargs) \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plot_ice_block_comparison(\n",
    "    loglog_ocean_time_per_step_by_om2_ncpus,\n",
    "    \"om2_ncpus\",\n",
    "    df_cl,\n",
    "    yticks=[0.1,0.2,0.5,1],\n",
    "    right_yticks=[0.00005,0.0001,0.0002],\n",
    "    right_axis_fn=pra.plot_right_axis_sh,\n",
    "    marker='d')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def semilogx_ocean_cpu_time_per_step_by_om2_ncpus(df, **kwargs):\n",
    "    p = ppd.semilogx(\"om2_ncpus\", \"ocean_cpu_time per step\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of ACCESS-OM2 cores\",\n",
    "        ylabel=\"MOM OM2 core time per step (core s)\",\n",
    "        **kwargs) \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr=29"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "plot_ice_block_comparison(\n",
    "    semilogx_ocean_cpu_time_per_step_by_om2_ncpus,\n",
    "    \"om2_ncpus\", \n",
    "    df_cl,\n",
    "    yticks=[],\n",
    "    right_yticks=[n/10.0 for n in range(8)],\n",
    "    right_axis_fn=pra.plot_right_axis_sh,\n",
    "    marker='d',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=r\"ACCESS-OM2: Ocean loop time per step $\\times$ number of OM2 cores:\"\n",
    "           \"\\nVarying the proportion of CICE cores and number of CICE blocks\")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loglog_ice_time_per_step_by_om2_ncpus(df, **kwargs):\n",
    "    p = ppd.loglog(\"om2_ncpus\", \"Ice TimeLoop per step\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of ACCESS-OM2 cores\",\n",
    "        ylabel=\"Ice loop time per step (s)\",\n",
    "        **kwargs) \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plot_ice_block_comparison(\n",
    "    loglog_ice_time_per_step_by_om2_ncpus,\n",
    "    \"om2_ncpus\",\n",
    "    df_cl,\n",
    "    yticks=[0.1,0.2,0.5,1],\n",
    "    right_axis_fn=pra.no_right_axis,\n",
    "    marker='*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def semilogx_ice_cpu_time_per_step_by_om2_ncpus(df, **kwargs):\n",
    "    p = ppd.semilogx(\"om2_ncpus\", \"ice_cpu_time per step\",\n",
    "        data=df,\n",
    "        xlabel=\"Number of ACCESS-OM2 cores\",\n",
    "        ylabel=\"CICE OM2 core time per step (core s)\",\n",
    "        **kwargs) \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_nbr += 1\n",
    "plot_ice_block_comparison(\n",
    "    semilogx_ice_cpu_time_per_step_by_om2_ncpus,\n",
    "    \"om2_ncpus\", \n",
    "    df_cl,\n",
    "    yticks=[100*n for n in range(7)],\n",
    "    right_yticks=[n/50.0 for n in range(9)],\n",
    "    right_axis_fn=pra.plot_right_axis_sh,\n",
    "    marker='*',\n",
    "    fig_nbr=fig_nbr,\n",
    "    caption=r\"ACCESS-OM2: Ocean loop time per step $\\times$ number of OM2 cores:\"\n",
    "           \"\\nVarying the proportion of CICE cores and number of CICE blocks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:analysis3-20.10] *",
   "language": "python",
   "name": "conda-env-analysis3-20.10-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}