HPC-Distributed-Computing-HWSA2020.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Writing Parallel Code (Manodeep Sinha, Harley-Wood School, July 2020)\n",
    "\n",
    "The goal for this session is to introduce you to the distributed programming paradigm. We will discuss the differences between writing sequential (or serial) code and parallel code, and work on an example parallel python code (using mpi4py). The key idea in this talk is to understand how to partition work into independent units and then use `mpi4py` to run the jobs in parallel.\n",
    "\n",
    "Attendee pre-requesites:\n",
    "- Familiar with good coding practices (see talks by Rebecca, Paul at this HWSA or HWSA 2019)\n",
    "- Familiar with python programming\n",
    "\n",
    "Software pre-requisites:\n",
    "- python3.6+\n",
    "- numpy\n",
    "- mpi4py\n",
    "\n",
    "\n",
    "## Why you might want to write parallel code\n",
    "\n",
    "Python, by design, only runs in a sequential mode. While there are way to run multi-threaded using `C` or `cython`, python code is sequential in general. Being able to run a job in parallel reduces the total time taken, which means you get to your Science results quicker. \n",
    "\n",
    "One way of parallelising code is through the `multiprocessing` package; however, that only runs on a single computer and is limited by the total number of available cores on that computer (almost certainly less 100 cores per computer). Running a job in a distributed fashion (e.g., MPI parallel) let's you scale to 100's-1000's of cores. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib\n",
    "matplotlib.rcParams.update({'font.size': 18})\n",
    "matplotlib.rcParams.update({'xtick.direction': 'in'})\n",
    "matplotlib.rcParams.update({'ytick.direction': 'in'})\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's look at some processing code\n",
    "\n",
    "Here we will count the number of lines in each file from a list of ascii files. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_lines_in_filenames(filenames):\n",
    "    \"\"\"\n",
    "    Returns a list containing the number of lines in the \n",
    "    input (ascii) files   \n",
    "    \"\"\"\n",
    "    \n",
    "    def _count_lines(fname):\n",
    "        with open(fname, 'rt') as f:\n",
    "            count = 0\n",
    "            for line in f:\n",
    "                count += 1\n",
    "        return count\n",
    "        \n",
    "    # Protect against the case where a single\n",
    "    # file was passsed\n",
    "    if not isinstance(filenames, (list, tuple)):\n",
    "        filenames = [filenames]\n",
    "        \n",
    "    numlines = []\n",
    "    for fname in filenames:\n",
    "        numlines.append(_count_lines(fname))\n",
    "\n",
    "    # or use list-comprehension\n",
    "    # numlines = [_count_lines(fname) for fname in filenames]\n",
    "\n",
    "    return numlines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### But what if you want to count lines a different way\n",
    "\n",
    "Easy enough - just add a second parameter that accepts a function. If this parameter is unspecified, then the internal `_count_lines` function will be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_lines_in_filenames_external_func(filenames, line_counter_func=None):\n",
    "    def _count_lines(fname):\n",
    "        with open(fname, 'rt') as f:\n",
    "            count = 0\n",
    "            for line in f:\n",
    "                count += 1\n",
    "        return count\n",
    "    \n",
    "    if not line_counter_func:        \n",
    "        line_counter_func = _count_lines\n",
    "    \n",
    "    # Protect against the case where a single\n",
    "    # file was passsed\n",
    "    if not isinstance(filenames, (list, tuple)):\n",
    "        filenames = [filenames]\n",
    "\n",
    "    numlines = []\n",
    "    for fname in filenames:\n",
    "        numlines.append(line_counter_func(fname))\n",
    "\n",
    "    # or use list comprehension\n",
    "    # numlines = [line_counter_func(fname) for fname in filenames]\n",
    "\n",
    "    return numlines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### But line-counting is simple, how about an arbitrary function?\n",
    "\n",
    "So far we have used the simple example of counting lines, but you can easily extend to concept to any arbitrary processing of a file. If no external processing function is passed, then we will use the \"line-counting\" function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def arbitrary_processing(filenames, processing_func=None):\n",
    "    def _count_lines(fname):\n",
    "        with open(fname, 'rt') as f:\n",
    "            count = 0\n",
    "            for line in f:\n",
    "                count += 1\n",
    "        return count\n",
    "\n",
    "    if not processing_func:        \n",
    "        processing_func = _count_lines\n",
    "    \n",
    "    # Protect against the case where a single\n",
    "    # file was passsed\n",
    "    if not isinstance(filenames, (list, tuple)):\n",
    "        files = [filenames]\n",
    "        \n",
    "    results = []\n",
    "    for fname in filenames:\n",
    "        results.append(processing_func(fname))\n",
    "\n",
    "    # or use list comprehension\n",
    "    # results = [processing_func(fname) for fname in filenames]        \n",
    "\n",
    "    return results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid gray\"> </hr>\n",
    "\n",
    "# Basic Concepts of Distributed Computing\n",
    "\n",
    "\n",
    "* What information is shared\n",
    "* Which instruction runs when\n",
    "* Which task does what\n",
    "* Where is the output produced\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid gray\"> </hr>\n",
    "\n",
    "\n",
    "## What information is shared\n",
    "\n",
    "While programming, we are always working with variables. Generally speaking there are three kinds of variables:\n",
    "\n",
    "1. local variables - variables defined at/near code location where it is used\n",
    "2. global variables - variables that are explicitly defined to be available to all functions\n",
    "3. function parameters - variables that are explicitly passed as arguments to a function\n",
    "\n",
    "In a sequential code, variables that are required can be made available by altering how the variable is declared. \n",
    "\n",
    "In a multiprocessing code, all variables values are shared up to the point where the multiprocessing call is made. After that point, any modifications in the variable values in one process are no longer visible to other processes.\n",
    "\n",
    "In a distributed code, variables on the same process follow the rules of sequential code; however, explicit transfers are required to obtain values of variables on different processes. \n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid gray\"> </hr>\n",
    "\n",
    "\n",
    "## Which instruction runs when\n",
    "\n",
    "In a sequential code, each line of code is executed in serial; lines occurring earlier are guaranteed to be executed before any later lines of code are executed. \n",
    "\n",
    "In a distributed code, each task runs in a sequential mode but by default, there is no connection between the execution states of the various tasks. For instance, it is possible for one task to have completed before another task has even started up. If your problem needs any guarantee about all tasks having completed up to a certain point in the code, you will have to explicitly program in these \"synchronisation\" points (or barriers). In a distributed code, when such a synchronisation point is reached, tasks will wait at that state until **every** task has reached that synchronisation point. \n",
    "\n",
    "Think about it as a 400m race where the sprinters (\"tasks\") can be anyone from Florence Griffith Joyner to Usain Bolt, to you and I. Clearly, without additional gates and barriers, some of the sprinters (\"tasks\") will finish much earlier than others. This is when you need to consider how to partition the work such that everyone takes the similar amount of time to finish their workload.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid gray\"> </hr>\n",
    "\n",
    "\n",
    "## Which task does what\n",
    "\n",
    "In a sequential code, there is only one task and that task performs the entirety of the computation.\n",
    "In a distributed code, you will have to explicitly partition the entire computation over the available tasks. While partitioning, you will need to make sure of the following:\n",
    "\n",
    "- The entirety of the computation is done\n",
    "- Every unique work unit is performed by exactly one task (i.e., no redundant work between multiple tasks)\n",
    "- The results from each work unit are collected at an unique location, either in memory or on the hard-drive (e.g., task 0 does not overwrite the results from task 1)\n",
    "  \n",
    "-----\n",
    "<details><summary>Advanced Section(click to expand)</summary>\n",
    "    \n",
    "    Partitioning the entire computation for distributed computing also needs to account for the following edge-cases:\n",
    "\n",
    "      - What happens if there are fewer tasks than work units? You will have to consider whether you can split your work units even further (i.e., more fine-grained parallelism)\n",
    "      - What happens if the individual work units take different amounts of time? You will have to guess-timate the workload for each work unit, and then assign based on the total workload. Another strategy could be to distribute the first `NTasks` workunits over the available tasks, and then distribute the remaining work units as each task finishes with the previously assigned work unit. \n",
    "\n",
    "</details>\n",
    "\n",
    "-----\n",
    "\n",
    "## Which task does what\n",
    "\n",
    "Or, how to partition the data over all available tasks. For instance, say you have a list containing `N` elements (say a list of `N` filenames), and you have `ntasks` that are available, then how do you distribute the `N` elements over these `ntasks` such that these two conditions hold:\n",
    "\n",
    "1. Every element is processed\n",
    "2. No element is processed twice \n",
    "\n",
    "There are two common mechanisms to partition the list:\n",
    "\n",
    "-----\n",
    "\n",
    "### Which task does what (Pattern 1)\n",
    "\n",
    "1. Assign first element to task1, second element to task2, third element to task3 and so on until taskN has been assigned. After taskN is assigned, assign the next work element to task1, and then repeat until all work elements have been assigned. \n",
    "\n",
    "\n",
    "```python\n",
    "    # assumes rank is the unique identifier among all tasks and \n",
    "    # that rank goes from 0 to ntasks-1 (inclusive)\n",
    "    for i in range(rank, nwork, ntasks):\n",
    "        do_processing(array[i])\n",
    "```\n",
    "\n",
    "Consider three cases:\n",
    "\n",
    "1. The number of work units (`nwork`) is smaller than the number of available tasks (`ntasks`), i.e. `nwork < ntasks`\n",
    "\n",
    "If the total number of work units (`nwork`) is smaller than `ntasks`, then the initial tasks numbered from 0 to `nwork-1` will get one work unit a piece, and the remaining (`ntasks - nwork`) tasks will not have any work. \n",
    "\n",
    "---\n",
    "\n",
    "2. The number of work units (`nwork`) is *exactly* equal to the number of available tasks (`ntasks`), i.e., `nwork == ntasks`\n",
    "\n",
    "Then each task gets *exactly* one work unit. \n",
    "\n",
    "---\n",
    "3. The number of work units (`nwork`) is larger than the number of available tasks (`ntasks`), i.e., `nwork > ntasks`\n",
    "\n",
    "Then each task gets at least `nwork // ntasks` work units. The remaining units (`nrem := nwork mod ntasks`) is distributed over the first `nrem` tasks.\n",
    "\n",
    "---\n",
    "\n",
    "This partitioning scheme ensures that i) every element is processed and ii) no element is processed twice, regardless of the relative values of `N` and `ntasks`.\n",
    "\n",
    "\n",
    "**This is the pattern we are going to follow here.**\n",
    "\n",
    "\n",
    "### Which task does what (Pattern 2)\n",
    "\n",
    "\n",
    "2. Calculate the average number of work units per task. Then assign a contiguous block of work units to each unit. If the total number of work units is not exactly divisible by the number of tasks, then assign one additional work unit for the initial tasks until all the extra work units are assigned. (Make sure that these additional work units are accounted for in later tasks)\n",
    "\n",
    "```python\n",
    "    nwork_per_task = nwork // ntasks\n",
    "    nrem = nwork % ntasks\n",
    "\n",
    "    start = 0\n",
    "    for itask in ntasks:\n",
    "        nwork_this_task = nwork_per_task\n",
    "        if nrem > 0:\n",
    "            nwork_this_task += 1\n",
    "            nrem -= 1\n",
    "\n",
    "        end = start + nwork_this_task\n",
    "        if rank == itask:\n",
    "            break\n",
    "\n",
    "        start = end\n",
    "\n",
    "    do_processing(array[start:end])\n",
    "```\n",
    "\n",
    "This is the same logic as [np.array_split](https://numpy.org/doc/stable/reference/generated/numpy.array_split.html).\n",
    "\n",
    "----\n",
    "\n",
    "<details> <summary> Advanced challenge (click to expand)</summary>\n",
    "    \n",
    "The assumption in both of the patterns above is that every work unit takes the same amount of computing time. However, that is not necessarily the case for many real-world problems, and some units of work may take a lot more computing time than others. Ideally, when you are partitioning the `nwork` units over the `ntasks`, you will want to distribute the work such that *every* task gets a work that takes similar amount of total computing time. That way, all tasks finish at about the same time; otherwise, some tasks might finish early and sit idle while a small number of the total tasks requested are actually working (and then you possibly get pointed emails from supercomputer admins)\n",
    "\n",
    "*How would you distribute the work in such a scenario?*\n",
    "Assume that you have an array of shape `nwork`, that contains an estimate of the computing time for each work unit.\n",
    "      \n",
    "</details>\n",
    "\n",
    "----\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid gray\"> </hr>\n",
    "\n",
    "\n",
    "## Where is the output produced\n",
    "\n",
    "In a sequential code, since there is only one task, and that task does the entire computation, the return address is unique by default. For instance, imagine a code that writes out results to a file called \"results.txt\". In the sequential case, there will be only one file created and that file will contain all of the results. \n",
    "\n",
    "In a distributed code, you have to ensure that each task returns results to an unique location. For instance, if you simply run the previous code in a distributed fashion, then every task will write to a `results.txt` file and the the final output file will be corrupted (and the contents are likely to change everytime). A standard resolution is to use `result_<tasknumber>.txt`, and then collate all the files into a `results.txt` file at the end (if necessaary).\n",
    "\n",
    "----\n",
    "<details> <summary> Advanced Section (click to expand)</summary>\n",
    "    \n",
    "Another option is to create a single file, but have each task write to a separate region (e.g., parallel hdf5):\n",
    "\n",
    "  - You will need to compute (or know) the filesize for the entire computation. This means you will need to know the size of the result for every work unit\n",
    "  - (Typically) You will need to create the empty file with the correct total size\n",
    "  - Every task will need to know where to write the output results from processing a specific work unit (i.e., you will need to create a mapping that knows the byte-offset in the output file). If you know the size of every result (the byte-size of the result and *not* the values in bytes), then you can calculate the byte-offset for each result from a cumulative sum of all preceeding byte-sizes (something like `np.cumsum(result_sizes)`)\n",
    "      \n",
    "</details>\n",
    "\n",
    "----\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's look at code at how the partition works in practice\n",
    "\n",
    "<hr style=\"border:4px solid gray\"> </hr>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_partition(nwork, ntasks, partition_type=1):\n",
    "    import numpy as np\n",
    "    assigned_task = np.empty(nwork, dtype=np.int)\n",
    "    if partition_type == 1:\n",
    "        task = 0\n",
    "        for i in range(nwork):\n",
    "            assigned_task[i] = task\n",
    "            task += 1\n",
    "            if task == ntasks: \n",
    "                task = 0\n",
    "    else:\n",
    "        nwork_each_task = nwork // ntasks\n",
    "        nrem = nwork % ntasks\n",
    "        start = 0\n",
    "        for itask in range(ntasks):\n",
    "            nwork_this_task = nwork_each_task\n",
    "            if nrem > 0:\n",
    "                nwork_this_task += 1\n",
    "                nrem -= 1\n",
    "            assigned_task[start:start+nwork_this_task] = itask\n",
    "            start += nwork_this_task\n",
    "    \n",
    "    print(f\"nwork = {nwork} ntasks = {ntasks} partition-type = {partition_type}\")\n",
    "    print(\"{}\".format('-'*(nwork*5 + 8))) \n",
    "    print(\"| Work |\", end=\"\")\n",
    "    for i in range(nwork):\n",
    "        print(\" {:02d} |\".format(i), end='')\n",
    "    print(\"\")\n",
    "    print(\"{}\".format('+'*(nwork*5 + 8))) \n",
    "    \n",
    "    print(\"| Task |\", end=\"\")\n",
    "    for i in range(nwork):\n",
    "        print(\" {:02d} |\".format(assigned_task[i]), end='')\n",
    "    print(\"\")\n",
    "    print(\"{}\".format('-'*(nwork*5 + 8))) \n",
    "        \n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nwork = 14 ntasks = 3 partition-type = 1\n",
      "------------------------------------------------------------------------------\n",
      "| Work | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 |\n",
      "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n",
      "| Task | 00 | 01 | 02 | 00 | 01 | 02 | 00 | 01 | 02 | 00 | 01 | 02 | 00 | 01 |\n",
      "------------------------------------------------------------------------------\n",
      "\n",
      "nwork = 14 ntasks = 3 partition-type = 2\n",
      "------------------------------------------------------------------------------\n",
      "| Work | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 |\n",
      "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n",
      "| Task | 00 | 00 | 00 | 00 | 00 | 01 | 01 | 01 | 01 | 01 | 02 | 02 | 02 | 02 |\n",
      "------------------------------------------------------------------------------\n",
      "\n",
      "\n",
      "nwork = 3 ntasks = 5 partition-type = 1\n",
      "-----------------------\n",
      "| Work | 00 | 01 | 02 |\n",
      "+++++++++++++++++++++++\n",
      "| Task | 00 | 01 | 02 |\n",
      "-----------------------\n",
      "\n",
      "nwork = 3 ntasks = 5 partition-type = 2\n",
      "-----------------------\n",
      "| Work | 00 | 01 | 02 |\n",
      "+++++++++++++++++++++++\n",
      "| Task | 00 | 01 | 02 |\n",
      "-----------------------\n",
      "\n",
      "\n",
      "nwork = 7 ntasks = 4 partition-type = 1\n",
      "-------------------------------------------\n",
      "| Work | 00 | 01 | 02 | 03 | 04 | 05 | 06 |\n",
      "+++++++++++++++++++++++++++++++++++++++++++\n",
      "| Task | 00 | 01 | 02 | 03 | 00 | 01 | 02 |\n",
      "-------------------------------------------\n",
      "\n",
      "nwork = 7 ntasks = 4 partition-type = 2\n",
      "-------------------------------------------\n",
      "| Work | 00 | 01 | 02 | 03 | 04 | 05 | 06 |\n",
      "+++++++++++++++++++++++++++++++++++++++++++\n",
      "| Task | 00 | 00 | 01 | 01 | 02 | 02 | 03 |\n",
      "-------------------------------------------\n",
      "\n",
      "\n",
      "nwork = 8 ntasks = 4 partition-type = 1\n",
      "------------------------------------------------\n",
      "| Work | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 |\n",
      "++++++++++++++++++++++++++++++++++++++++++++++++\n",
      "| Task | 00 | 01 | 02 | 03 | 00 | 01 | 02 | 03 |\n",
      "------------------------------------------------\n",
      "\n",
      "nwork = 8 ntasks = 4 partition-type = 2\n",
      "------------------------------------------------\n",
      "| Work | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 |\n",
      "++++++++++++++++++++++++++++++++++++++++++++++++\n",
      "| Task | 00 | 00 | 01 | 01 | 02 | 02 | 03 | 03 |\n",
      "------------------------------------------------\n",
      "\n",
      "\n",
      "nwork = 15 ntasks = 3 partition-type = 1\n",
      "-----------------------------------------------------------------------------------\n",
      "| Work | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 | 14 |\n",
      "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n",
      "| Task | 00 | 01 | 02 | 00 | 01 | 02 | 00 | 01 | 02 | 00 | 01 | 02 | 00 | 01 | 02 |\n",
      "-----------------------------------------------------------------------------------\n",
      "\n",
      "nwork = 15 ntasks = 3 partition-type = 2\n",
      "-----------------------------------------------------------------------------------\n",
      "| Work | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 | 14 |\n",
      "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n",
      "| Task | 00 | 00 | 00 | 00 | 00 | 01 | 01 | 01 | 01 | 01 | 02 | 02 | 02 | 02 | 02 |\n",
      "-----------------------------------------------------------------------------------\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "nwork_and_ntasks = [(14, 3), (3, 5), (7, 4), (8, 4), (15, 3)]\n",
    "for nw, nt in nwork_and_ntasks:\n",
    "    for ptype in [1, 2]:\n",
    "        print_partition(nw, nt, partition_type=ptype)\n",
    "        print(\"\")\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Advanced] How would you improve the previous code?\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "----\n",
    "\n",
    "<details> <summary> Here's my attempt (Click to expand)</summary>\n",
    "\n",
    "\n",
    "```python\n",
    "def assign_partition(nwork, ntasks, partition_type=1, \n",
    "                     pretty_print=True):\n",
    "    \"\"\"\n",
    "    Partitions a set of work over the specified number of tasks\n",
    "    \n",
    "    Parameters\n",
    "    -----------\n",
    "    \n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    \n",
    "    \n",
    "    \"\"\"\n",
    "    import numpy as np\n",
    "    def _pretty_print(assigned_tasks, nwork, ntasks, partition_type):\n",
    "        get_numchars = lambda x : (x*5 + 8)\n",
    "        print(f\"nwork = {nwork} ntasks = {ntasks} partition-type = {partition_type}\")\n",
    "        print(\"{}\".format('-'*get_numchars(nwork)))\n",
    "        print(\"| Work |\", end=\"\")\n",
    "        for i in range(nwork):\n",
    "            print(\" {:02d} |\".format(i), end='')\n",
    "        print(\"\")\n",
    "        print(\"{}\".format('+'*get_numchars(nwork))) \n",
    "\n",
    "        print(\"| Task |\", end=\"\")\n",
    "        for i in range(nwork):\n",
    "            print(\" {:02d} |\".format(assigned_task[i]), end='')\n",
    "        print(\"\")\n",
    "        print(\"{}\".format('-'*get_numchars(nwork))) \n",
    "\n",
    "        return\n",
    "\n",
    "    # the main function begins here\n",
    "    if nwork < 0 or ntasks < 1:\n",
    "        msg = f\"Error: Number of work units = {nwork} must \"\\\n",
    "              f\"be >= 0 *and* the number of tasks = {ntasks} \"\\\n",
    "              f\"must be >= 1\"\n",
    "        raise ValueError(msg)\n",
    "\n",
    "    # You may additionally want to check that both\n",
    "    # nwork and ntasks are scalar *and* integers\n",
    "    \n",
    "    assigned_task = np.empty(nwork, dtype=np.int64)\n",
    "\n",
    "    # Instead of the functions being written here, \n",
    "    # you might want to write sub-functions for each \n",
    "    # partition type, and then call the correct type \n",
    "    # based on the partition type requested. \n",
    "    # Raise NotImplementedError when an unknown partition type\n",
    "    # is requested\n",
    "    if partition_type == 1:\n",
    "        task = 0\n",
    "        for i in range(nwork):\n",
    "            assigned_task[i] = task\n",
    "            task += 1\n",
    "            if task == ntasks: \n",
    "                task = 0\n",
    "    elif partition_type == 2:\n",
    "        nwork_each_task = nwork // ntasks\n",
    "        nrem = nwork % ntasks\n",
    "        start = 0\n",
    "        for itask in range(ntasks):\n",
    "            nwork_this_task = nwork_each_task\n",
    "            if nrem > 0:\n",
    "                nwork_this_task += 1\n",
    "                nrem -= 1\n",
    "            assigned_task[start:start+nwork_this_task] = itask\n",
    "            start += nwork_this_task\n",
    "    else:\n",
    "        msg = f\"Unknown partition type = {partition_type}\"\n",
    "        raise NotImplementedError(msg)\n",
    "    \n",
    "    if pretty_print:\n",
    "        _pretty_print(assigned_tasks, nwork, ntasks, partition_type)\n",
    "        \n",
    "    return assigned_task\n",
    "```\n",
    "\n",
    "</details>\n",
    "\n",
    "----\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def assign_partition(nwork, ntasks, partition_type=1, \n",
    "                     pretty_print=True):\n",
    "    \"\"\"\n",
    "    Partitions a set of work over the specified number of tasks\n",
    "    \n",
    "    Parameters\n",
    "    -----------\n",
    "    \n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    \n",
    "    \n",
    "    \"\"\"\n",
    "    import numpy as np\n",
    "    def _pretty_print(assigned_tasks, nwork, ntasks, partition_type):\n",
    "        get_numchars = lambda x : (x*5 + 8)\n",
    "        print(f\"nwork = {nwork} ntasks = {ntasks} partition-type = {partition_type}\")\n",
    "        print(\"{}\".format('-'*get_numchars(nwork)))\n",
    "        print(\"| Work |\", end=\"\")\n",
    "        for i in range(nwork):\n",
    "            print(\" {:02d} |\".format(i), end='')\n",
    "        print(\"\")\n",
    "        print(\"{}\".format('+'*get_numchars(nwork))) \n",
    "\n",
    "        print(\"| Task |\", end=\"\")\n",
    "        for i in range(nwork):\n",
    "            print(\" {:02d} |\".format(assigned_task[i]), end='')\n",
    "        print(\"\")\n",
    "        print(\"{}\".format('-'*get_numchars(nwork))) \n",
    "\n",
    "        return\n",
    "\n",
    "    # the main function begins here\n",
    "    if nwork < 0 or ntasks < 1:\n",
    "        msg = f\"Error: Number of work units = {nwork} must \"\\\n",
    "              f\"be >= 0 *and* the number of tasks = {ntasks} \"\\\n",
    "              f\"must be >= 1\"\n",
    "        raise ValueError(msg)\n",
    "\n",
    "    # You may additionally want to check that both\n",
    "    # nwork and ntasks are scalar *and* integers\n",
    "    \n",
    "    assigned_task = np.empty(nwork, dtype=np.int64)\n",
    "\n",
    "    # Instead of the functions being written here, \n",
    "    # you might want to write sub-functions for each \n",
    "    # partition type, and then call the correct type \n",
    "    # based on the partition type requested. \n",
    "    # Raise NotImplementedError when an unknown partition type\n",
    "    # is requested\n",
    "    if partition_type == 1:\n",
    "        task = 0\n",
    "        for i in range(nwork):\n",
    "            assigned_task[i] = task\n",
    "            task += 1\n",
    "            if task == ntasks: \n",
    "                task = 0\n",
    "    elif partition_type == 2:\n",
    "        nwork_each_task = nwork // ntasks\n",
    "        nrem = nwork % ntasks\n",
    "        start = 0\n",
    "        for itask in range(ntasks):\n",
    "            nwork_this_task = nwork_each_task\n",
    "            if nrem > 0:\n",
    "                nwork_this_task += 1\n",
    "                nrem -= 1\n",
    "            assigned_task[start:start+nwork_this_task] = itask\n",
    "            start += nwork_this_task\n",
    "    else:\n",
    "        msg = f\"Unknown partition type = {partition_type}\"\n",
    "        raise NotImplementedError(msg)\n",
    "    \n",
    "    if pretty_print:\n",
    "        _pretty_print(assigned_task, nwork, ntasks, partition_type)\n",
    "        \n",
    "    return assigned_task"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nwork = 14 ntasks = 3 partition-type = 1\n",
      "------------------------------------------------------------------------------\n",
      "| Work | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 |\n",
      "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n",
      "| Task | 00 | 01 | 02 | 00 | 01 | 02 | 00 | 01 | 02 | 00 | 01 | 02 | 00 | 01 |\n",
      "------------------------------------------------------------------------------\n",
      "\n",
      "nwork = 14 ntasks = 3 partition-type = 2\n",
      "------------------------------------------------------------------------------\n",
      "| Work | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 |\n",
      "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n",
      "| Task | 00 | 00 | 00 | 00 | 00 | 01 | 01 | 01 | 01 | 01 | 02 | 02 | 02 | 02 |\n",
      "------------------------------------------------------------------------------\n",
      "\n",
      "\n",
      "nwork = 3 ntasks = 5 partition-type = 1\n",
      "-----------------------\n",
      "| Work | 00 | 01 | 02 |\n",
      "+++++++++++++++++++++++\n",
      "| Task | 00 | 01 | 02 |\n",
      "-----------------------\n",
      "\n",
      "nwork = 3 ntasks = 5 partition-type = 2\n",
      "-----------------------\n",
      "| Work | 00 | 01 | 02 |\n",
      "+++++++++++++++++++++++\n",
      "| Task | 00 | 01 | 02 |\n",
      "-----------------------\n",
      "\n",
      "\n",
      "nwork = 7 ntasks = 4 partition-type = 1\n",
      "-------------------------------------------\n",
      "| Work | 00 | 01 | 02 | 03 | 04 | 05 | 06 |\n",
      "+++++++++++++++++++++++++++++++++++++++++++\n",
      "| Task | 00 | 01 | 02 | 03 | 00 | 01 | 02 |\n",
      "-------------------------------------------\n",
      "\n",
      "nwork = 7 ntasks = 4 partition-type = 2\n",
      "-------------------------------------------\n",
      "| Work | 00 | 01 | 02 | 03 | 04 | 05 | 06 |\n",
      "+++++++++++++++++++++++++++++++++++++++++++\n",
      "| Task | 00 | 00 | 01 | 01 | 02 | 02 | 03 |\n",
      "-------------------------------------------\n",
      "\n",
      "\n",
      "nwork = 8 ntasks = 4 partition-type = 1\n",
      "------------------------------------------------\n",
      "| Work | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 |\n",
      "++++++++++++++++++++++++++++++++++++++++++++++++\n",
      "| Task | 00 | 01 | 02 | 03 | 00 | 01 | 02 | 03 |\n",
      "------------------------------------------------\n",
      "\n",
      "nwork = 8 ntasks = 4 partition-type = 2\n",
      "------------------------------------------------\n",
      "| Work | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 |\n",
      "++++++++++++++++++++++++++++++++++++++++++++++++\n",
      "| Task | 00 | 00 | 01 | 01 | 02 | 02 | 03 | 03 |\n",
      "------------------------------------------------\n",
      "\n",
      "\n",
      "nwork = 15 ntasks = 3 partition-type = 1\n",
      "-----------------------------------------------------------------------------------\n",
      "| Work | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 | 14 |\n",
      "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n",
      "| Task | 00 | 01 | 02 | 00 | 01 | 02 | 00 | 01 | 02 | 00 | 01 | 02 | 00 | 01 | 02 |\n",
      "-----------------------------------------------------------------------------------\n",
      "\n",
      "nwork = 15 ntasks = 3 partition-type = 2\n",
      "-----------------------------------------------------------------------------------\n",
      "| Work | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 | 14 |\n",
      "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n",
      "| Task | 00 | 00 | 00 | 00 | 00 | 01 | 01 | 01 | 01 | 01 | 02 | 02 | 02 | 02 | 02 |\n",
      "-----------------------------------------------------------------------------------\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "nwork_and_ntasks = [(14, 3), (3, 5), (7, 4), (8, 4), (15, 3)]\n",
    "for nw, nt in nwork_and_ntasks:\n",
    "    for ptype in [1, 2]:\n",
    "        assigned_tasks = assign_partition(nw, nt, partition_type=ptype)\n",
    "        print(\"\")\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's visualise the partition scheme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Taken from https://stackoverflow.com/a/28730546\n",
    "def discrete_matshow(assigned_tasks, cmapname='viridis', ax=None):\n",
    "    import matplotlib.pyplot as plt\n",
    "    \n",
    "    nwork = assigned_tasks.shape[0]\n",
    "    data = assigned_tasks.reshape((1, nwork))   \n",
    "    if not ax:\n",
    "        fig, ax = plt.subplots()\n",
    "    \n",
    "    # get discrete colormap\n",
    "    numcolors = assigned_tasks.max() - assigned_tasks.min() + 1\n",
    "    cmap = plt.get_cmap(cmapname, numcolors)\n",
    "\n",
    "    ax.pcolor(data, cmap=cmap, edgecolors='k', linewidths=4)\n",
    "    ax.set_xlim([0, nwork])\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "    ax.get_xaxis().set_ticks(np.arange(nwork+1))\n",
    "    ax.set_xlabel('Work Unit')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "nwork_and_ntasks = [(14, 3), (15, 3), (16, 3), \n",
    "                     (9, 4),  (9, 3),  (9, 2), \n",
    "                     (3, 3),  (3, 4),  (3, 5)]\n",
    "\n",
    "partition_types = [1, 2]\n",
    "ncols = len(partition_types)\n",
    "figheight = 1.0\n",
    "figsize=(20.0 * figheight, figheight)\n",
    "for nw, nt in nwork_and_ntasks:\n",
    "    fig, axes = plt.subplots(1, ncols, figsize=figsize)\n",
    "    fig.subplots_adjust(top=0.6)\n",
    "    fig.suptitle(f\"Dividing {nw} work-units over {nt} tasks (colour shows task assigned)\", fontsize=24)\n",
    "    \n",
    "    for ptype, ax in zip(partition_types, axes):\n",
    "        assigned_tasks = assign_partition(nw, nt, partition_type=ptype, pretty_print=False)\n",
    "        discrete_matshow(assigned_tasks, ax=ax)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<hr style=\"border:2px solid gray\"> </hr>\n",
    "\n",
    "## Using `mpi4py` for distributed computing\n",
    "\n",
    "The `mpi4py` package makes it very easy to write distributed code. There are a variety of examples in the [mpi4py tutorial](https://mpi4py.readthedocs.io/en/stable/tutorial.html) to show how `mpi4py` works. \n",
    "\n",
    "Every MPI spawned process has a \"communicator\" associated with it. We will exclusively use the \"global\" communicator, `MPI.COMM_WORLD` to figure out:\n",
    "\n",
    "1. How many tasks (`ntasks`) are in this computation  -- `MPI.COMM_WORLD.Get_rank()`\n",
    "2. An unique ID (`rank`) to identify each task -- `MPI.COMM_WORLD.Get_size()`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid gray\"> </hr>\n",
    "\n",
    "## Where is the output produced\n",
    "\n",
    "We are going to take a shortcut and assume there is no explicit output returned by the ``processing_function``. You can easily mimic this by creating an unique output file per MPI task and appending all results (from that task) into the unique file. For instance, you could create a file called `results_<rank>.txt` and then append a newline containing the `(filename, results)` for every processed `filename`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def your_custom_processing_func(input_fname, rank=0, outputfilebase='results'):\n",
    "    numlines = None\n",
    "    try:\n",
    "        with open(input_fname, 'r') as f:\n",
    "            numlines = 0\n",
    "            for line in f:\n",
    "                numlines += 1\n",
    "    except IOError:\n",
    "        print(f\"[Rank={rank}]: Did not find input file = '{input_fname}'\")\n",
    "        pass\n",
    "\n",
    "    # Now write the reusult\n",
    "    outputfilename=f\"{outputfilebase}_{rank}.csv\"\n",
    "    with open(outputfilename, 'a') as f:\n",
    "        f.write(f\"{input_fname}, {numlines}\\n\")\n",
    "\n",
    "    return      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "here\n",
      "[Rank=0]: Converting nfiles = 1 over ntasks = 1...\n",
      "[Rank=0]: Converting nfiles = 1 over ntasks = 1...done. Time taken = 0.00 seconds\n"
     ]
    }
   ],
   "source": [
    "def distributed_processing(filenames, processing_func=None, outputfilebase='results'):\n",
    "    import sys\n",
    "    import time\n",
    "    \n",
    "    rank = 0\n",
    "    ntasks = 1\n",
    "    MPI = None\n",
    "    comm = None\n",
    "    try:\n",
    "        from mpi4py import MPI\n",
    "        comm = MPI.COMM_WORLD\n",
    "        rank = comm.Get_rank()\n",
    "        ntasks = comm.Get_size()\n",
    "    except ImportError:\n",
    "        pass\n",
    "    \n",
    "    # Protect against the case where a single\n",
    "    # file was passsed\n",
    "    if not isinstance(filenames, (list, tuple)):\n",
    "        filenames = [filenames]\n",
    "        \n",
    "    sys.stdout.flush()\n",
    "    nfiles = len(filenames)\n",
    "    if nfiles < ntasks:\n",
    "        print(f\"[Rank={rank}]: Nfiles = {nfiles} < total tasks = {ntasks}. \"\\\n",
    "               \"Some tasks will not have any work assigned (and will be idle)\")\n",
    "\n",
    "    tstart = time.perf_counter()\n",
    "    if rank == 0:\n",
    "        print(f\"[Rank={rank}]: Converting nfiles = {nfiles} over ntasks = {ntasks}...\")\n",
    "\n",
    "    # Convert files in MPI parallel (if requested)\n",
    "    # the range will produce filenum starting with \"rank\"\n",
    "    # and then incrementing by \"ntasks\" all the way upto\n",
    "    # and inclusive of [nfiles-1]. That is, the range [0, nfiles-1]\n",
    "    # will be uniquely distributed over ntasks.\n",
    "    for filenum in range(rank, nfiles, ntasks):  \n",
    "        processing_func(filenames[filenum], rank)\n",
    "\n",
    "    # The barrier is only essential so that the total time printed\n",
    "    # out on rank==0 is correct.\n",
    "    if comm:\n",
    "        comm.Barrier()\n",
    "\n",
    "    if rank == 0:\n",
    "        t1 = time.perf_counter()\n",
    "        print(\"[Rank={}]: Converting nfiles = {} over ntasks = {}...done. \"\\\n",
    "              \"Time taken = {:0.2f} seconds\".format(rank, nfiles, ntasks, t1 - tstart))        \n",
    "        \n",
    "    return True\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    print(\"here\")\n",
    "    import glob\n",
    "    filenames = glob.glob(\"*.txt\")\n",
    "    distributed_processing(filenames, your_custom_processing_func)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Switch to the command-line to run MPI code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge: If you keep re-running the code, then the output file keeps getting appended to. How would you fix that?\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Advanced] What happens if the input files have been modified?\n",
    "\n",
    "----\n",
    "\n",
    "<details> <summary> Recommended Practice (click to expand)</summary>\n",
    "    \n",
    "A couple of things to consider:\n",
    "\n",
    "1. When was the input file last modified?\n",
    "2. When did the line-counter (i.e., this code) run?\n",
    "3. Is it possible that file contents have been modified without changing the number of lines?\n",
    "\n",
    "Of course, if a file has not been modified, then there is no reason to add another line. If the file has been updated, but the number of lines has not been changed, then how do you know if the file content was altered or not?\n",
    "\n",
    "The generic recommendation is to **always add metadata info**. For instance, in this case, you might want to consider the following (in increasing order of complexity/paranoia/thoroughness):\n",
    "\n",
    "1. The file modification time for the input file\n",
    "2. Some sort of hash for the input file contents (md5, sha, ...)\n",
    "3. The date-time when the line-counter program was run\n",
    "4. A git sha identifying the source commit, or a hash of the entire source code if there are outstanding changes\n",
    "\n",
    "\n",
    "</details>\n",
    "\n",
    "----\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running parallel code within Jupyter notebooks \n",
    "\n",
    "Can be done but takes a bit of setup. I followed the instructions [here](https://charlesreid1.com/wiki/Jupyter/MPI) to setup `ipyparallel` and then run the following chunk of code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Client MPI.COMM_WORLD.Get_size()=1\n",
      "Client engine ids [0, 1]\n",
      "Remote COMM_WORLD ranks [0, 1]\n",
      "Remote COMM_WORLD size [2, 2]\n"
     ]
    }
   ],
   "source": [
    "from ipyparallel import Client\n",
    "from mpi4py import MPI\n",
    "\n",
    "c = Client(profile='mpi')\n",
    "view = c[:]\n",
    "\n",
    "print(\"Client MPI.COMM_WORLD.Get_size()=%s\" % MPI.COMM_WORLD.Get_size())\n",
    "print(\"Client engine ids %s\" % c.ids)\n",
    "\n",
    "def _get_rank():\n",
    "    from mpi4py import MPI\n",
    "    return MPI.COMM_WORLD.Get_rank()\n",
    "\n",
    "def _get_size():\n",
    "    from mpi4py import MPI\n",
    "    return MPI.COMM_WORLD.Get_size()\n",
    "\n",
    "print(\"Remote COMM_WORLD ranks %s\" % view.apply_sync(_get_rank))\n",
    "print(\"Remote COMM_WORLD size %s\" % view.apply_sync(_get_size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}