CMSC6950 - The LJ System - parallel.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "8671f1fd-8ec0-470a-a896-e52ee27f4978"
    }
   },
   "outputs": [],
   "source": [
    "from lennard_jones_potential import *\n",
    "from multiprocessing import Pool\n",
    "import numpy as np\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "c6c10019-c8fe-473f-b620-0472b52c113f"
    }
   },
   "source": [
    "## Parallel calculation of the LJ energy for 2000 points using 1, 2, 4 CPUs.\n",
    "\n",
    "In a first attempt we are using the same algorithm we used calculating the energy in serial.\n",
    "Only ecaluation of `v_LJ(d)` is executed in parallel.\n",
    "\n",
    "**From: `LJ_multi_1.py`:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "nbpresent": {
     "id": "1db5504e-d32b-434f-9665-44f493e1a5c7"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parallel execution of 2000 points using 1 processes\n",
      "v_Total: 23630468668.50\n",
      "Total Runtime: 26.584 seconds\n",
      "--------------------\n",
      "\n",
      "Parallel execution of 2000 points using 2 processes\n",
      "v_Total: 23630468668.50\n",
      "Total Runtime: 27.638 seconds\n",
      "--------------------\n",
      "\n",
      "Parallel execution of 2000 points using 4 processes\n",
      "v_Total: 23630468668.50\n",
      "Total Runtime: 24.943 seconds\n",
      "--------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def main_1():\n",
    "    \"Calculate LJ energy of 2000 points using 1, 2, 4 CPUs.\"\n",
    "\n",
    "    n_points = 2000\n",
    "\n",
    "    for n_CPUs in [1, 2, 4]:\n",
    "\n",
    "        print(\"Parallel execution of {} points using {} processes\".format(n_points, n_CPUs))\n",
    "        start = time.time()                 # start timer\n",
    "\n",
    "        coords = generate_coodinates(n_points, 3, upper=100, seed=5)\n",
    "\n",
    "        distances = calc_distances(coords)\n",
    "\n",
    "        pool = Pool(n_CPUs)                 # create multiprocessing pool\n",
    "        results = pool.map(v_LJ, distances) # calculate results IN PARALLEL\n",
    "        pool.close()                        # stop pool (free memory)\n",
    "        \n",
    "        v_total = np.sum(results)           # sum up total\n",
    "        print(\"v_Total: {:.2f}\".format(v_total))# print result\n",
    "\n",
    "        stop = time.time()                  # stop timer\n",
    "        print(\"Total Runtime: {:.3f} seconds\".format(stop-start))\n",
    "        print(20*\"-\"+\"\\n\")\n",
    "\n",
    "\n",
    "\n",
    "main_1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "354f98e6-b29b-4b1d-9c25-acf2dc231b62"
    }
   },
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "d1ef3030-1c30-43a9-a354-85a166aeadd4"
    }
   },
   "source": [
    "### A poor man's Profiler: ;-)\n",
    "\n",
    "We not measure the time for the following steps individually:\n",
    "\n",
    "* generating coordinates\n",
    "* calculating distances\n",
    "* calculating LJ energies\n",
    "\n",
    "\n",
    "**From: `LJ_multi_2.py`:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "nbpresent": {
     "id": "7ee9f55e-08b8-4077-ae0e-9a3d5a107795"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start LJ-Potential on 2000 points using 1 processes:\n",
      "Generating coordinates...done!\t\tRuntime:  0.002 seconds\n",
      "Calculating distances...done!\t\tRuntime: 11.148 seconds\n",
      "Calculating LJ on 1 CPUs ...done!\tRuntime: 14.544 seconds\n",
      "v_Total: 23630468668.50\n",
      "--------------------\n",
      "\n",
      "Start LJ-Potential on 2000 points using 2 processes:\n",
      "Generating coordinates...done!\t\tRuntime:  0.000 seconds\n",
      "Calculating distances...done!\t\tRuntime: 11.380 seconds\n",
      "Calculating LJ on 2 CPUs ...done!\tRuntime: 12.770 seconds\n",
      "v_Total: 23630468668.50\n",
      "--------------------\n",
      "\n",
      "Start LJ-Potential on 2000 points using 4 processes:\n",
      "Generating coordinates...done!\t\tRuntime:  0.000 seconds\n",
      "Calculating distances...done!\t\tRuntime: 11.392 seconds\n",
      "Calculating LJ on 4 CPUs ...done!\tRuntime: 12.197 seconds\n",
      "v_Total: 23630468668.50\n",
      "--------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def main_2():\n",
    "    \"Same as before but with separate time-keeping.\"\n",
    "\n",
    "    n_points = 2000\n",
    "\n",
    "    for n_CPUs in [1, 2, 4]:\n",
    "        print(\"Start LJ-Potential on {} points using {} processes:\".format(n_points, n_CPUs))\n",
    "\n",
    "        print(\"Generating coordinates...\", end='', flush=True)          ####\n",
    "        start = time.time()\n",
    "        coords  = generate_coodinates(n_points, 3, upper=100, seed=5)\n",
    "        stop = time.time()\n",
    "        print(\"done!\\t\\tRuntime: {:6.3f} seconds\".format(stop-start))\n",
    "\n",
    "        print(\"Calculating distances...\", end='', flush=True)\n",
    "        start = time.time()\n",
    "        distances   = calc_distances(coords)\n",
    "        stop = time.time()\n",
    "        print(\"done!\\t\\tRuntime: {:6.3f} seconds\".format(stop-start))   ####\n",
    "\n",
    "        print(\"Calculating LJ on {} CPUs ...\".format(n_CPUs), end='', flush=True)\n",
    "        start = time.time()\n",
    "        pool = Pool(n_CPUs)                 # create multiprocessing pool\n",
    "        results = pool.map(v_LJ, distances) # calculate results IN PARALLEL\n",
    "        pool.close()\n",
    "        stop = time.time()\n",
    "        print(\"done!\\tRuntime: {:6.3f} seconds\".format(stop-start))\n",
    "\n",
    "        v_total = np.sum(results)           # sum up total\n",
    "\n",
    "        print(\"v_Total: {:.2f}\".format(v_total))# print result\n",
    "        print(20*\"-\"+\"\\n\")\n",
    "\n",
    "main_2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "bc78f91c-3afa-49b6-a965-91ff987f0d36"
    }
   },
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "732ecab9-30f1-4232-b7c4-0c9b4a08f6c0"
    }
   },
   "source": [
    "### There is no need to calculate the distances three times...\n",
    "\n",
    "Instead of generating the coordinates for each number of CPUs and\n",
    "re-calculating the distances, we can pull them put of the loop:\n",
    "\n",
    "**From: `LJ_multi_3.py`:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "nbpresent": {
     "id": "586d2ee0-5b33-48c1-ae5c-886ec540dacf"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating coordinates...done!\t\tRuntime:  0.000 seconds\n",
      "Calculating distances...done!\t\tRuntime: 11.319 seconds\n",
      "--------------------\n",
      "\n",
      "Start LJ-Potential on 2000 points using 1 processes:\n",
      "Calculating LJ on 1 CPUs ...done!\tRuntime: 15.330 seconds\n",
      "v_Total: 23630468668.50\n",
      "--------------------\n",
      "\n",
      "Start LJ-Potential on 2000 points using 2 processes:\n",
      "Calculating LJ on 2 CPUs ...done!\tRuntime: 14.021 seconds\n",
      "v_Total: 23630468668.50\n",
      "--------------------\n",
      "\n",
      "Start LJ-Potential on 2000 points using 4 processes:\n",
      "Calculating LJ on 4 CPUs ...done!\tRuntime: 14.836 seconds\n",
      "v_Total: 23630468668.50\n",
      "--------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def main_3():\n",
    "    \"Same as before but calculate distances only once (using single CPU).\"\n",
    "\n",
    "    n_points = 2000\n",
    "\n",
    "    print(\"Generating coordinates...\", end='', flush=True)\n",
    "    start = time.time()\n",
    "    coords  = generate_coodinates(n_points, 3, upper=100, seed=5)\n",
    "    stop = time.time()\n",
    "    print(\"done!\\t\\tRuntime: {:6.3f} seconds\".format(stop-start))\n",
    "\n",
    "    print(\"Calculating distances...\", end='', flush=True)\n",
    "    start = time.time()\n",
    "    distances   = calc_distances(coords)\n",
    "    stop = time.time()\n",
    "    print(\"done!\\t\\tRuntime: {:6.3f} seconds\".format(stop-start))\n",
    "    print(20*\"-\"+\"\\n\")\n",
    "\n",
    "    for n_CPUs in [1, 2, 4]:\n",
    "        print(\"Start LJ-Potential on {} points using {} processes:\".format(n_points, n_CPUs))\n",
    "\n",
    "        print(\"Calculating LJ on {} CPUs ...\".format(n_CPUs), end='', flush=True)\n",
    "        start = time.time()\n",
    "        pool = Pool(n_CPUs)                 # create multiprocessing pool\n",
    "        results = pool.map(v_LJ, distances) # calculate results IN PARALLEL\n",
    "        pool.close()\n",
    "        stop = time.time()\n",
    "        print(\"done!\\tRuntime: {:6.3f} seconds\".format(stop-start))\n",
    "\n",
    "        v_total = np.sum(results)           # sum up total\n",
    "\n",
    "        print(\"v_Total: {:.2f}\".format(v_total))# print result\n",
    "        print(20*\"-\"+\"\\n\")\n",
    "\n",
    "\n",
    "main_3()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "02c65e09-e77f-4c3b-9274-0bb72ccd35f4"
    }
   },
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "dee40352-2098-4675-83be-306c5237a248"
    }
   },
   "source": [
    "### Calculating the distances in parallel\n",
    "\n",
    "Calculating the distances of points takes a significant amount of \n",
    "the total run-time and so far this part was only executed in serial.\n",
    "\n",
    "In order to be able to distribute the distance calculation evenly across\n",
    "multiple CPUs, we must know the point-pairs, before dispatching the parallel work.\n",
    "\n",
    "**From `LJ_multi_4.py`:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "nbpresent": {
     "id": "5028a4aa-0a36-41d6-b7bd-f58e8a3b9169"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating coordinates...done!\t\tRuntime:  0.000 seconds\n",
      "Generating pairs...done!\t\tRuntime:  0.707 seconds\n",
      "--------------------\n",
      "\n",
      "Parallel LJ-Potential on 2000 points using 1 processes:\n",
      "Calculating LJ on 1 CPUs ...done!\tRuntime: 24.739 seconds\n",
      "v_Total: 23630468668.50\n",
      "--------------------\n",
      "\n",
      "Parallel LJ-Potential on 2000 points using 2 processes:\n",
      "Calculating LJ on 2 CPUs ...done!\tRuntime: 16.139 seconds\n",
      "v_Total: 23630468668.50\n",
      "--------------------\n",
      "\n",
      "Parallel LJ-Potential on 2000 points using 4 processes:\n",
      "Calculating LJ on 4 CPUs ...done!\tRuntime: 14.906 seconds\n",
      "v_Total: 23630468668.50\n",
      "--------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def generate_pairs(n):\n",
    "    \"\"\"generate unique point pairs (i<j)\n",
    "    \n",
    "    returns:: list of tuples with pair indecies\n",
    "    \n",
    "    >>> generate_pairs(3)\n",
    "    [(0, 1), (0, 2), (1, 2)]\n",
    "    \"\"\"\n",
    "    pairs = []\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            if j>i:\n",
    "                pairs.append((i,j))\n",
    "    return pairs\n",
    "\n",
    "def calc_pot(args):\n",
    "    \"\"\"calculate the distance for a pair i j in coords and return LJ potential\n",
    "    \n",
    "    >>> coords = np.array(\n",
    "      [[  6.25533007e-01,   1.08048674e+00,   1.71562226e-04],\n",
    "       [  4.53498859e-01,   2.20133836e-01,   1.38507892e-01],\n",
    "       [  2.79390317e-01,   5.18341091e-01,   5.95151211e-01]])\n",
    "    >>> args = (0, 1, coords)\n",
    "    >>> calc_pot(args)\n",
    "    21402303.167507425\n",
    "    \"\"\"\n",
    "\n",
    "    i, j, coords = args                 # unpack arguments tupel\n",
    "    r = np.sqrt(np.sum(np.square(np.subtract(coords[i],coords[j]))))\n",
    "    v = v_LJ(r)\n",
    "\n",
    "    return v\n",
    "\n",
    "def main_4():\n",
    "    \"Calculate distances in parallel as well.\"\n",
    "    n_points = 2000\n",
    "\n",
    "    print(\"Generating coordinates...\", end='', flush=True)\n",
    "    start = time.time()\n",
    "    coords  = generate_coodinates(n_points, 3, upper=100, seed=5)\n",
    "    stop = time.time()\n",
    "    print(\"done!\\t\\tRuntime: {:6.3f} seconds\".format(stop-start))\n",
    "\n",
    "    print(\"Generating pairs...\", end='', flush=True)\n",
    "    start = time.time()\n",
    "    pairs   = generate_pairs(len(coords))\n",
    "    stop = time.time()\n",
    "    print(\"done!\\t\\tRuntime: {:6.3f} seconds\".format(stop-start))\n",
    "    print(20*\"-\"+\"\\n\")\n",
    "\n",
    "    for n_CPUs in [1, 2, 4]:\n",
    "        print(\"Parallel LJ-Potential on {} points using {} processes:\".format(n_points, n_CPUs))\n",
    "        pool = Pool(n_CPUs)\n",
    "\n",
    "        print(\"Calculating LJ on {} CPUs ...\".format(n_CPUs), end='', flush=True)\n",
    "        start = time.time()\n",
    "\n",
    "        tasks = []                              # prepare tasks\n",
    "        for p in pairs:\n",
    "            args = (p[0], p[1], coords)         # pack arguments tupel\n",
    "            tasks.append(args)\n",
    "\n",
    "        results = pool.map(calc_pot, tasks)     # <-- in parallel\n",
    "        pool.close()\n",
    "\n",
    "        stop = time.time()\n",
    "        print(\"done!\\tRuntime: {:6.3f} seconds\".format(stop-start))\n",
    "\n",
    "        v_total = np.sum(results)               # sum up total\n",
    "        print(\"v_Total: {:.2f}\".format(v_total))    # print result\n",
    "        print(20*\"-\"+\"\\n\")\n",
    "\n",
    "main_4()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculating the distances in parallel\n",
    "\n",
    "Instead of creating the `tasks` list with a python loop,\n",
    "we can use list comprehensons.\n",
    "\n",
    "instead of:\n",
    "\n",
    "```python\n",
    "tasks = []                            # prepare tasks\n",
    "for p in pairs:\n",
    "    args = (p[0], p[1], coords)       # pack arguments tupel\n",
    "    tasks.append(args)\n",
    "```\n",
    "\n",
    "we can write:\n",
    "\n",
    "```python\n",
    "tasks = [ (p[0], p[1], coords) for p in pairs ]\n",
    "```\n",
    "\n",
    "**From `LJ_multi_5.py`:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating coordinates...done!\t\tRuntime:  0.000 seconds\n",
      "Generating pairs...done!\t\tRuntime:  0.548 seconds\n",
      "--------------------\n",
      "\n",
      "Parallel LJ-Potential on 2000 points using 1 processes:\n",
      "Calculating LJ on 1 CPUs ...done!\tRuntime: 23.936 seconds\n",
      "v_Total: 23630468668.50\n",
      "--------------------\n",
      "\n",
      "Parallel LJ-Potential on 2000 points using 2 processes:\n",
      "Calculating LJ on 2 CPUs ...done!\tRuntime: 15.956 seconds\n",
      "v_Total: 23630468668.50\n",
      "--------------------\n",
      "\n",
      "Parallel LJ-Potential on 2000 points using 4 processes:\n",
      "Calculating LJ on 4 CPUs ...done!\tRuntime: 15.565 seconds\n",
      "v_Total: 23630468668.50\n",
      "--------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def main_5():\n",
    "    \"Same as before but using list comprehensions.\"\n",
    "    n_points = 2000\n",
    "\n",
    "    print(\"Generating coordinates...\", end='', flush=True)\n",
    "    start = time.time()\n",
    "    coords  = generate_coodinates(n_points, 3, upper=100, seed=5)\n",
    "    stop = time.time()\n",
    "    print(\"done!\\t\\tRuntime: {:6.3f} seconds\".format(stop-start))\n",
    "\n",
    "    print(\"Generating pairs...\", end='', flush=True)\n",
    "    start = time.time()\n",
    "    pairs   = generate_pairs(len(coords))\n",
    "    stop = time.time()\n",
    "    print(\"done!\\t\\tRuntime: {:6.3f} seconds\".format(stop-start))\n",
    "    print(20*\"-\"+\"\\n\")\n",
    "\n",
    "    for n_CPUs in [1, 2, 4]:\n",
    "        print(\"Parallel LJ-Potential on {} points using {} processes:\".format(n_points, n_CPUs))\n",
    "        pool = Pool(n_CPUs)\n",
    "\n",
    "        print(\"Calculating LJ on {} CPUs ...\".format(n_CPUs), end='', flush=True)\n",
    "        start = time.time()\n",
    "\n",
    "        tasks = [ (p[0], p[1], coords) for p in pairs]\n",
    "\n",
    "        results = pool.map(calc_pot, tasks)     # <-- in parallel\n",
    "        pool.close()\n",
    "\n",
    "        stop = time.time()\n",
    "        print(\"done!\\tRuntime: {:6.3f} seconds\".format(stop-start))\n",
    "\n",
    "        v_total = np.sum(results)               # sum up total\n",
    "        print(\"v_Total: {:.2f}\".format(v_total))    # print result\n",
    "        print(20*\"-\"+\"\\n\")\n",
    "\n",
    "main_5()"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  },
  "nbpresent": {
   "slides": {},
   "themes": {}
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}