{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# Measures a vector sum with different accumulator type\n", "\n", "This notebook compares how fast is the sum if the accumulator used to store the sum is of a different type than the summed elements."]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"text/html": ["<div id=\"my_id_menu_nb\">run previous cell, wait for 2 seconds</div>\n", "<script>\n", "function repeat_indent_string(n){\n", "    var a = \"\" ;\n", "    for ( ; n > 0 ; --n)\n", "        a += \"    \";\n", "    return a;\n", "}\n", "// look up into all sections and builds an automated menu //\n", "var update_menu_string = function(begin, lfirst, llast, sformat, send, keep_item, begin_format, end_format) {\n", "    var anchors = document.getElementsByClassName(\"section\");\n", "    if (anchors.length == 0) {\n", "        anchors = document.getElementsByClassName(\"text_cell_render rendered_html\");\n", "    }\n", "    var i,t;\n", "    var text_menu = begin;\n", "    var text_memo = \"<pre>\\nlength:\" + anchors.length + \"\\n\";\n", "    var ind = \"\";\n", "    var memo_level = 1;\n", "    var href;\n", "    var tags = [];\n", "    var main_item = 0;\n", "    var format_open = 0;\n", "    for (i = 0; i <= llast; i++)\n", "        tags.push(\"h\" + i);\n", "\n", "    for (i = 0; i < anchors.length; i++) {\n", "        text_memo += \"**\" + anchors[i].id + \"--\\n\";\n", "\n", "        var child = null;\n", "        for(t = 0; t < tags.length; t++) {\n", "            var r = anchors[i].getElementsByTagName(tags[t]);\n", "            if (r.length > 0) {\n", "child = r[0];\n", "break;\n", "            }\n", "        }\n", "        if (child == null) {\n", "            text_memo += \"null\\n\";\n", "            continue;\n", "        }\n", "        if (anchors[i].hasAttribute(\"id\")) {\n", "            // when converted in RST\n", "            href = anchors[i].id;\n", "            text_memo += \"#1-\" + href;\n", "            // passer \u00e0 child suivant (le chercher)\n", "        }\n", "        else if (child.hasAttribute(\"id\")) {\n", "            // in a notebook\n", "            href = child.id;\n", "            text_memo += \"#2-\" + href;\n", "        }\n", "        else {\n", "            text_memo += \"#3-\" + \"*\" + \"\\n\";\n", "            continue;\n", "        }\n", "        var title = child.textContent;\n", "        var level = parseInt(child.tagName.substring(1,2));\n", "\n", "        text_memo += \"--\" + level + \"?\" + lfirst + \"--\" + title + \"\\n\";\n", "\n", "        if ((level < lfirst) || (level > llast)) {\n", "            continue ;\n", "        }\n", "        if (title.endsWith('\u00b6')) {\n", "            title = title.substring(0,title.length-1).replace(\"<\", \"&lt;\")\n", "         .replace(\">\", \"&gt;\").replace(\"&\", \"&amp;\");\n", "        }\n", "        if (title.length == 0) {\n", "            continue;\n", "        }\n", "\n", "        while (level < memo_level) {\n", "            text_menu += end_format + \"</ul>\\n\";\n", "            format_open -= 1;\n", "            memo_level -= 1;\n", "        }\n", "        if (level == lfirst) {\n", "            main_item += 1;\n", "        }\n", "        if (keep_item != -1 && main_item != keep_item + 1) {\n", "            // alert(main_item + \" - \" + level + \" - \" + keep_item);\n", "            continue;\n", "        }\n", "        while (level > memo_level) {\n", "            text_menu += \"<ul>\\n\";\n", "            memo_level += 1;\n", "        }\n", "        text_menu += repeat_indent_string(level-2);\n", "        text_menu += begin_format + sformat.replace(\"__HREF__\", href).replace(\"__TITLE__\", title);\n", "        format_open += 1;\n", "    }\n", "    while (1 < memo_level) {\n", "        text_menu += end_format + \"</ul>\\n\";\n", "        memo_level -= 1;\n", "        format_open -= 1;\n", "    }\n", "    text_menu += send;\n", "    //text_menu += \"\\n\" + text_memo;\n", "\n", "    while (format_open > 0) {\n", "        text_menu += end_format;\n", "        format_open -= 1;\n", "    }\n", "    return text_menu;\n", "};\n", "var update_menu = function() {\n", "    var sbegin = \"\";\n", "    var sformat = '<a href=\"#__HREF__\">__TITLE__</a>';\n", "    var send = \"\";\n", "    var begin_format = '<li>';\n", "    var end_format = '</li>';\n", "    var keep_item = -1;\n", "    var text_menu = update_menu_string(sbegin, 2, 4, sformat, send, keep_item,\n", "       begin_format, end_format);\n", "    var menu = document.getElementById(\"my_id_menu_nb\");\n", "    menu.innerHTML=text_menu;\n", "};\n", "window.setTimeout(update_menu,2000);\n", "            </script>"], "text/plain": ["<IPython.core.display.HTML object>"]}, "execution_count": 2, "metadata": {}, "output_type": "execute_result"}], "source": ["from jyquickhelper import add_notebook_menu\n", "add_notebook_menu()"]}, {"cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": ["%matplotlib inline"]}, {"cell_type": "markdown", "metadata": {}, "source": ["[numpy](http://www.numpy.org/) is multithreaded. For an accurate comparison, this needs to be disabled. This can be done as follows or by setting environment variable ``MKL_NUM_THREADS=1``."]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": ["try:\n", "    import mkl\n", "    mkl.set_num_threads(1)\n", "except ModuleNotFoundError as e:\n", "    print('mkl not found', e)\n", "    import os\n", "    os.environ['MKL_NUM_THREADS']='1'"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## First comparison\n", "\n", "We compare the two following implementation."]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": ["# float scenario_Float(const float *p1, size_t size)\n", "# {\n", "#     float sum = 0;\n", "#     const float * end1 = p1 + size;\n", "#     for(; p1 != end1; ++p1)\n", "#         sum += *p1;\n", "#     return sum;\n", "# }\n", "# \n", "# float scenario_Double(const float *p1, size_t size)\n", "# {\n", "#     double sum = 0;\n", "#     const float * end1 = p1 + size;\n", "#     for(; p1 != end1; ++p1)\n", "#         sum += *p1;\n", "#     return (float)sum;\n", "# }"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The third line is also repeated 10 times to avoid the loop being too significant. "]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": ["from cpyquickhelper.numbers.cbenchmark_sum_type import measure_scenario_Double, measure_scenario_Float"]}, {"cell_type": "code", "execution_count": 6, "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>average</th>\n", "      <th>deviation</th>\n", "      <th>doc</th>\n", "      <th>label</th>\n", "      <th>max_exec</th>\n", "      <th>min_exec</th>\n", "      <th>name</th>\n", "      <th>number</th>\n", "      <th>repeat</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>7.664200e-09</td>\n", "      <td>7.683250e-08</td>\n", "      <td>a double accumulator</td>\n", "      <td>sorted</td>\n", "      <td>7.910000e-07</td>\n", "      <td>3.950000e-07</td>\n", "      <td>scenario_Double</td>\n", "      <td>100.0</td>\n", "      <td>100.0</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>5.096300e-09</td>\n", "      <td>5.378331e-08</td>\n", "      <td>a float accumulator</td>\n", "      <td>sorted</td>\n", "      <td>7.910000e-07</td>\n", "      <td>3.950000e-07</td>\n", "      <td>scenario_Float</td>\n", "      <td>100.0</td>\n", "      <td>100.0</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["        average     deviation                   doc   label      max_exec  \\\n", "0  7.664200e-09  7.683250e-08  a double accumulator  sorted  7.910000e-07   \n", "1  5.096300e-09  5.378331e-08   a float accumulator  sorted  7.910000e-07   \n", "\n", "       min_exec             name  number  repeat  \n", "0  3.950000e-07  scenario_Double   100.0   100.0  \n", "1  3.950000e-07   scenario_Float   100.0   100.0  "]}, "execution_count": 7, "metadata": {}, "output_type": "execute_result"}], "source": ["import pandas\n", "import numpy\n", "\n", "def test_benchmark(label, values, repeat=100, number=100):\n", "    funcs = [(k, v) for k, v in globals().copy().items() if k.startswith(\"measure_scenario\")]\n", "    rows = []\n", "    for k, v in funcs:\n", "        exe = v(values, repeat, number)\n", "        d = exe.todict()\n", "        d['doc'] = \" \".join(v.__doc__.split('ExecutionStat')[1].strip().split(' ')[-3:]).strip('.')\n", "        d['label'] = label\n", "        d['name'] = k.replace(\"measure_\", \"\")\n", "        rows.append(d)        \n", "    df = pandas.DataFrame(rows)\n", "    return df\n", "\n", "test_benchmark(\"sorted\", numpy.random.rand(10).astype(numpy.float32))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Times are not very conclusive on such small lists."]}, {"cell_type": "code", "execution_count": 7, "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>average</th>\n", "      <th>deviation</th>\n", "      <th>doc</th>\n", "      <th>label</th>\n", "      <th>max_exec</th>\n", "      <th>min_exec</th>\n", "      <th>name</th>\n", "      <th>number</th>\n", "      <th>repeat</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>0.000140</td>\n", "      <td>0.00143</td>\n", "      <td>a double accumulator</td>\n", "      <td>sorted</td>\n", "      <td>0.042079</td>\n", "      <td>0.013098</td>\n", "      <td>scenario_Double</td>\n", "      <td>100.0</td>\n", "      <td>100.0</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>0.000141</td>\n", "      <td>0.00143</td>\n", "      <td>a float accumulator</td>\n", "      <td>sorted</td>\n", "      <td>0.037468</td>\n", "      <td>0.013094</td>\n", "      <td>scenario_Float</td>\n", "      <td>100.0</td>\n", "      <td>100.0</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["    average  deviation                   doc   label  max_exec  min_exec  \\\n", "0  0.000140    0.00143  a double accumulator  sorted  0.042079  0.013098   \n", "1  0.000141    0.00143   a float accumulator  sorted  0.037468  0.013094   \n", "\n", "              name  number  repeat  \n", "0  scenario_Double   100.0   100.0  \n", "1   scenario_Float   100.0   100.0  "]}, "execution_count": 8, "metadata": {}, "output_type": "execute_result"}], "source": ["values = numpy.random.rand(100000).astype(numpy.float32)\n", "\n", "df = test_benchmark(\"sorted\", values)\n", "df"]}, {"cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": ["df = pandas.concat([df])\n", "dfg = df[[\"doc\", \"label\", \"average\"]].pivot(\"doc\", \"label\", \"average\")"]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["ax = dfg.plot.bar(rot=30)\n", "labels = [l.get_text() for l in ax.get_xticklabels()]\n", "ax.set_xticklabels(labels, ha='right')\n", "ax.set_title(\"Comparison of all implementations\");"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## For different sizes"]}, {"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>average</th>\n", "      <th>deviation</th>\n", "      <th>doc</th>\n", "      <th>label</th>\n", "      <th>max_exec</th>\n", "      <th>min_exec</th>\n", "      <th>name</th>\n", "      <th>number</th>\n", "      <th>repeat</th>\n", "      <th>size</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>1.418275e-07</td>\n", "      <td>0.000001</td>\n", "      <td>a double accumulator</td>\n", "      <td>sorted</td>\n", "      <td>0.000026</td>\n", "      <td>0.000013</td>\n", "      <td>scenario_Double</td>\n", "      <td>100.0</td>\n", "      <td>20.0</td>\n", "      <td>100.0</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>1.590125e-07</td>\n", "      <td>0.000002</td>\n", "      <td>a float accumulator</td>\n", "      <td>sorted</td>\n", "      <td>0.000043</td>\n", "      <td>0.000012</td>\n", "      <td>scenario_Float</td>\n", "      <td>100.0</td>\n", "      <td>20.0</td>\n", "      <td>100.0</td>\n", "    </tr>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>1.380739e-06</td>\n", "      <td>0.000014</td>\n", "      <td>a double accumulator</td>\n", "      <td>sorted</td>\n", "      <td>0.000190</td>\n", "      <td>0.000127</td>\n", "      <td>scenario_Double</td>\n", "      <td>100.0</td>\n", "      <td>20.0</td>\n", "      <td>1000.0</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>1.292245e-06</td>\n", "      <td>0.000013</td>\n", "      <td>a float accumulator</td>\n", "      <td>sorted</td>\n", "      <td>0.000161</td>\n", "      <td>0.000124</td>\n", "      <td>scenario_Float</td>\n", "      <td>100.0</td>\n", "      <td>20.0</td>\n", "      <td>1000.0</td>\n", "    </tr>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>1.415682e-05</td>\n", "      <td>0.000142</td>\n", "      <td>a double accumulator</td>\n", "      <td>sorted</td>\n", "      <td>0.001969</td>\n", "      <td>0.001293</td>\n", "      <td>scenario_Double</td>\n", "      <td>100.0</td>\n", "      <td>20.0</td>\n", "      <td>10000.0</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["        average  deviation                   doc   label  max_exec  min_exec  \\\n", "0  1.418275e-07   0.000001  a double accumulator  sorted  0.000026  0.000013   \n", "1  1.590125e-07   0.000002   a float accumulator  sorted  0.000043  0.000012   \n", "0  1.380739e-06   0.000014  a double accumulator  sorted  0.000190  0.000127   \n", "1  1.292245e-06   0.000013   a float accumulator  sorted  0.000161  0.000124   \n", "0  1.415682e-05   0.000142  a double accumulator  sorted  0.001969  0.001293   \n", "\n", "              name  number  repeat     size  \n", "0  scenario_Double   100.0    20.0    100.0  \n", "1   scenario_Float   100.0    20.0    100.0  \n", "0  scenario_Double   100.0    20.0   1000.0  \n", "1   scenario_Float   100.0    20.0   1000.0  \n", "0  scenario_Double   100.0    20.0  10000.0  "]}, "execution_count": 11, "metadata": {}, "output_type": "execute_result"}], "source": ["dfs = []\n", "\n", "for i in range(2, 7):\n", "    n = 10 ** i\n", "    values = numpy.random.rand(n).astype(numpy.float32)\n", "    df = test_benchmark(\"sorted\", values, repeat=20)\n", "    df[\"size\"] = float(n)\n", "    dfs.append(df)\n", "    \n", "df = pandas.concat(dfs)\n", "df.head()"]}, {"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>doc</th>\n", "      <th>size</th>\n", "      <th>a double accumulator</th>\n", "      <th>a float accumulator</th>\n", "      <th>ratio</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>100.0</td>\n", "      <td>1.418275e-07</td>\n", "      <td>1.590125e-07</td>\n", "      <td>0.891927</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>1000.0</td>\n", "      <td>1.380739e-06</td>\n", "      <td>1.292245e-06</td>\n", "      <td>1.068480</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>10000.0</td>\n", "      <td>1.415682e-05</td>\n", "      <td>1.347988e-05</td>\n", "      <td>1.050218</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>100000.0</td>\n", "      <td>1.558953e-04</td>\n", "      <td>1.326750e-04</td>\n", "      <td>1.175017</td>\n", "    </tr>\n", "    <tr>\n", "      <th>4</th>\n", "      <td>1000000.0</td>\n", "      <td>1.391328e-03</td>\n", "      <td>1.367595e-03</td>\n", "      <td>1.017354</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["doc       size  a double accumulator  a float accumulator     ratio\n", "0        100.0          1.418275e-07         1.590125e-07  0.891927\n", "1       1000.0          1.380739e-06         1.292245e-06  1.068480\n", "2      10000.0          1.415682e-05         1.347988e-05  1.050218\n", "3     100000.0          1.558953e-04         1.326750e-04  1.175017\n", "4    1000000.0          1.391328e-03         1.367595e-03  1.017354"]}, "execution_count": 12, "metadata": {}, "output_type": "execute_result"}], "source": ["piv = df.pivot(\"size\", \"doc\", \"average\")\n", "cols = piv.columns\n", "piv = piv.reset_index(drop=False)\n", "piv[\"ratio\"] = piv[\"a double accumulator\"] / piv[\"a float accumulator\"]\n", "piv"]}, {"cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["ax = piv.plot(x='size', y=cols, logy=True, logx=True)\n", "ax.set_title(\"Compares float and double accumulator for a sum.\");"]}, {"cell_type": "markdown", "metadata": {}, "source": ["There is almost no difference."]}, {"cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": []}], "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.2"}}, "nbformat": 4, "nbformat_minor": 2}