Merge pull request #27 from fverdugo/francesc

LEQ and TSP

docs/make.jl

@@ -123,6 +123,8 @@ makedocs(;
                          "Matrix-matrix multiplication"=>"matrix_matrix.md",
                          "Jacobi method" => "jacobi_method.md",
                          "All pairs of shortest paths" => "asp.md",
+                         "Gaussian elimination" => "LEQ.md",
+                         "Traveling salesperson problem" => "tsp.md",
                          ],
           "Solutions" => "solutions_for_all_notebooks.md",
           ],

notebooks/LEQ.ipynb

@@ -22,7 +22,7 @@
     "In this notebook, we will learn\n",
     "\n",
     "- How to parallelize Gaussian elimination\n",
-    "- How the data partition can create (or solve) load imbalances"
+    "- How to fix static load imbalance"
    ]
   },
   {
@@ -32,7 +32,8 @@
    "source": [
     "## Gaussian elimination\n",
     "\n",
-    "[Gaussian elimination](https://en.wikipedia.org/wiki/Gaussian_elimination) is provably one of the first algorithms you have learned to solve linear equations like this one:\n",
+    "\n",
+    "System of linear algebraic equations\n",
     "\n",
     "$$\n",
     "\\left[\n",
@@ -59,8 +60,8 @@
     "\\right]\n",
     "$$\n",
     "\n",
+    "Elimination steps\n",
     "\n",
-    "The value of $x$, $y$, and $z$ can be found by creating an *augmented matrix* and applying Gaussian elimination to it:\n",
     "\n",
     "$$\n",
     "\\left[\n",
@@ -83,12 +84,26 @@
     "\\begin{matrix}\n",
     "1 & 3 & 1 & 9 \\\\\n",
     "0 & 1 & 2 & 8 \\\\\n",
+    "0 & 2 & 2 & 8 \\\\\n",
+    "\\end{matrix}\n",
+    "\\right]\n",
+    "\\rightarrow\n",
+    "\\left[\n",
+    "\\begin{matrix}\n",
+    "1 & 3 & 1 & 9 \\\\\n",
+    "0 & 1 & 2 & 8 \\\\\n",
+    "0 & 0 & -2 & -8 \\\\\n",
+    "\\end{matrix}\n",
+    "\\right]\n",
+    "\\rightarrow\n",
+    "\\left[\n",
+    "\\begin{matrix}\n",
+    "1 & 3 & 1 & 9 \\\\\n",
+    "0 & 1 & 2 & 8 \\\\\n",
     "0 & 0 & 1 & 4 \\\\\n",
     "\\end{matrix}\n",
     "\\right]\n",
     "$$\n",
-    "\n",
-    "The result is an upper diagonal matrix with ones on the diagonal. From this matrix the values $x$, $y$, and $z$ can be found via [backward substitution](https://en.wikipedia.org/wiki/Triangular_matrix).\n",
     "\n"
    ]
   },
@@ -97,28 +112,15 @@
    "id": "94c10106",
    "metadata": {},
    "source": [
-    "### Serial implementation\n",
-    "\n",
-    "Gaussian elimination can be implemented as shown in the following function. Note that the result is overwritten in-place on the input matrix."
+    "### Serial implementation\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 70,
+   "execution_count": null,
    "id": "e4070214",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "gaussian_elimination! (generic function with 2 methods)"
-      ]
-     },
-     "execution_count": 70,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "function gaussian_elimination!(B)\n",
     "    n,m = size(B)\n",
@@ -138,80 +140,25 @@
     "end"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "cb7f89e5",
-   "metadata": {},
-   "source": [
-    "Let us test the function with the example above:"
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 68,
+   "execution_count": null,
    "id": "eb30df0d",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "3×4 Matrix{Float64}:\n",
-       " 1.0   3.0   1.0   9.0\n",
-       " 1.0   2.0  -1.0   1.0\n",
-       " 3.0  11.0   5.0  35.0"
-      ]
-     },
-     "execution_count": 68,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "A = Float64[1 3 1; 1 2 -1; 3 11 5]\n",
     "b = Float64[9,1,35]\n",
-    "B = [A b]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 71,
-   "id": "52bfada2",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "3×4 Matrix{Float64}:\n",
-       " 1.0  3.0  1.0  9.0\n",
-       " 0.0  1.0  2.0  8.0\n",
-       " 0.0  0.0  1.0  4.0"
-      ]
-     },
-     "execution_count": 71,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
+    "B = [A b]\n",
     "gaussian_elimination!(B)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "563aa0d0",
-   "metadata": {},
-   "source": [
-    "We get the same result as shown before (as expected)."
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "39f2e8ef",
    "metadata": {},
    "source": [
-    "## Parallelization\n",
-    "\n",
-    "Gaussian elimination is expensive and thus it makes sense to try to seed-up this computation by using several processors. It requires $(2n^3)/3$ operation, where $n$ is the number of rows in the input matrix. Thus, the time complexity is $O(n^3)$, which rapidly grows with $n$.\n"
+    "## Parallelization\n"
    ]
   },
   {
@@ -235,125 +182,15 @@
     "        B[i,k] = 0\n",
     "    end\n",
     "end\n",
-    "```\n",
-    "\n",
-    "- The loop over k cannot be parallelized (the state of B at iteration k depends on the state at iteration k-1)\n",
-    "- Loops over t, i, and j can be parallelized\n",
-    "- BUT the loop over t needs to be done before loop over i and j"
+    "```"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "a67e0aad",
+   "id": "14d57c52",
    "metadata": {},
    "source": [
-    "### Data partition\n",
-    "\n",
-    "Let us start considering a simple 1D block partition. We assume that each process contains only a portion of the input matrix consisting in a block of consecutive rows. In this algorithm, the data stored in a process does not correspond with the data updated at a given iteration over the outer loop over k. The data updated is only a subset of the data stored, which leads to load imbalances (as we will see in a second).\n",
-    "\n",
-    "Consider next figure. Let's find out which is the data updated and the data used by CPU 3 at iteration $k$.\n"
-   ]
-  },
-  {
-   "attachments": {
-    "g20491.png": {
-     "image/png": "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 truncated
-    }
-   },
-   "cell_type": "markdown",
-   "id": "6d8b79ba",
-   "metadata": {},
-   "source": [
-    "<div>\n",
-    "<img src=\"attachment:g20491.png\"  align=\"left\" width=\"450\"/>\n",
-    "</div>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "edb211d0",
-   "metadata": {},
-   "source": [
-    "By looking into the code above, you can see that `B[i,j]` is updated at iteration k, if and only if i and j are greater or equal than k. Thus, from all entries owned by CPU3, only the ones fulfilling this condition will be updated. See the entries highlighted in the next figure."
-   ]
-  },
-  {
-   "attachments": {
-    "g20853.png": {
-     "image/png": "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 truncated
-    }
-   },
-   "cell_type": "markdown",
-   "id": "f18f33da",
-   "metadata": {},
-   "source": [
-    "<div>\n",
-    "<img src=\"attachment:g20853.png\"  align=\"left\" width=\"450\"/>\n",
-    "</div>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1eced940",
-   "metadata": {},
-   "source": [
-    "### Data dependencies\n",
-    "\n",
-    "At iteration k, CPU3 needs part of row k to update its entries. The process owning row k needs to broadcast this entries to all other processes that require them. This communication pattern is almost identical to the one previously studied in Floyd's algorithm."
-   ]
-  },
-  {
-   "attachments": {
-    "g21211.png": {
-     "image/png": "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 truncated
-    }
-   },
-   "cell_type": "markdown",
-   "id": "410eb1ba",
-   "metadata": {},
-   "source": [
-    "<div>\n",
-    "<img src=\"attachment:g21211.png\"  align=\"left\" width=\"450\"/>\n",
-    "</div>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d04f70fa",
-   "metadata": {},
-   "source": [
-    "### Load imbalance\n",
-    "\n",
-    "Do all processes process the same amount of data at a given iteration? This answer is no. To understand this let us find out the data updated by CPU1 in the figure below. At iteration k, CPU 1 has not data to process since k is larger than all row ids that CPU 1 owns. This is in contrast to CPU 2 and CPU 3 which have data to process. As a result, CPU 1 is idle (doing nothing), which is waisting computational resources that could be otherwise used."
-   ]
-  },
-  {
-   "attachments": {
-    "g23603.png": {
-     "image/png": "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 truncated
-    }
-   },
-   "cell_type": "markdown",
-   "id": "3988b2ae",
-   "metadata": {},
-   "source": [
-    "<div>\n",
-    "<img src=\"attachment:g23603.png\"  align=\"left\" width=\"450\"/>\n",
-    "</div>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c1957040",
-   "metadata": {},
-   "source": [
-    "### Addressing the load imbalance\n",
-    "\n",
-    "For this algorithm, a cyclic distribution mitigates the load imbalance.\n",
-    "\n",
-    "- Cyclic partitions are often useful in algorithms with *predictable* load imbalance\n",
-    "- A cyclic partition is a form of *static* load balancing\n",
-    "- Cyclic partition are not suitable for all communication patters. E.g., algorithms that require communication between nearest-neighbors like Jacobi."
+    "### Two possible data partitions"
    ]
   },
   {
@@ -363,13 +200,154 @@
     }
    },
    "cell_type": "markdown",
-   "id": "c6450ee1",
+   "id": "f06f0869",
    "metadata": {},
    "source": [
     "<div>\n",
     "<img src=\"attachment:g23933.png\"  align=\"left\" width=\"400\"/>\n",
     "</div>"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a67e0aad",
+   "metadata": {},
+   "source": [
+    "### Which is the work per process at iteration k ?\n",
+    "\n"
+   ]
+  },
+  {
+   "attachments": {
+    "g26595.png": {
+     "image/png": "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 truncated
+    }
+   },
+   "cell_type": "markdown",
+   "id": "53a94ed3",
+   "metadata": {},
+   "source": [
+    "<div>\n",
+    "<img src=\"attachment:g26595.png\"  align=\"left\" width=\"250\"/>\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d083cd53",
+   "metadata": {},
+   "source": [
+    "<div>\n",
+    "    <br>\n",
+    "    <br>\n",
+    "    <br>\n",
+    "    <br>\n",
+    "</div>"
+   ]
+  },
+  {
+   "attachments": {
+    "g26786.png": {
+     "image/png": "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 truncated
+    }
+   },
+   "cell_type": "markdown",
+   "id": "0d80cd72",
+   "metadata": {},
+   "source": [
+    "<div>\n",
+    "<img src=\"attachment:g26786.png\"  align=\"left\" width=\"250\"/>\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6409890d",
+   "metadata": {},
+   "source": [
+    "### Load imbalance\n",
+    "\n",
+    "- CPUs with rows <k are idle during iteration k\n",
+    "- Bad load balance means bad speedups, as some CPUs are waiting instead of doing useful work\n",
+    "- Solution: cyclic partition             "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b90252f1",
+   "metadata": {},
+   "source": [
+    "### Cyclic partition\n",
+    "\n",
+    "- Less load imbalance\n",
+    "- Same data dependencies as 1d block partition\n",
+    "- Useful for some problems with predictable load imbalance\n",
+    "- A form of static load balancing\n",
+    "- Not suitable for all communication patterns (e.g. Jacobi)"
+   ]
+  },
+  {
+   "attachments": {
+    "g27009.png": {
+     "image/png": "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 truncated
+    }
+   },
+   "cell_type": "markdown",
+   "id": "6a4c4051",
+   "metadata": {},
+   "source": [
+    "<div>\n",
+    "<img src=\"attachment:g27009.png\"  align=\"left\" width=\"250\"/>\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "20982b04",
+   "metadata": {},
+   "source": [
+    "## Exercise\n",
+    "\n",
+    "- The actual parallel implementation is let as an exercise\n",
+    "- Implement both 1d block and 1d cyclic partitions and compare performance\n",
+    "- Closely related with Floyd's algorithm\n",
+    "- Generate input matrix with function below (a random matrix is not enough, we need a non singular matrix that does not require pivoting)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a65cf8e6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "function tridiagonal_matrix(n)\n",
+    "    C = zeros(n,n)\n",
+    "    stencil = [(-1,2,-1),(-1,0,1)]\n",
+    "    for i in 1:n\n",
+    "        for  (coeff,o) in zip((-1,2,-1),(-1,0,1))\n",
+    "            j = i+o\n",
+    "            if j in 1:n\n",
+    "                C[i,j] = coeff\n",
+    "            end\n",
+    "        end\n",
+    "    end\n",
+    "    C\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "31d8586a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n = 5\n",
+    "C = tridiagonal_matrix(n)\n",
+    "b = ones(n)\n",
+    "gaussian_elimination!(C)"
+   ]
   }
  ],
  "metadata": {

notebooks/tsp.ipynb

@@ -22,6 +22,7 @@
     "In this notebook, we will learn\n",
     "\n",
     "- How to parallelize the solution of the traveling sales person problem\n",
+    "- How to fix dynamic load imbalance\n",
     "- The concept of search overhead\n"
    ]
   },
@@ -32,18 +33,11 @@
    "source": [
     "## The traveling sales person (TSP) problem\n",
     "\n",
-    "Let us start by presenting the [traveling sales person (ASP) problem](https://en.wikipedia.org/wiki/Travelling_salesman_problem) and its solution using a [branch and bound algorithm](https://en.wikipedia.org/wiki/Branch_and_bound).\n",
     "\n",
     "### Problem statement\n",
     "\n",
     "- Given a graph $G$ with a distance table $C$ and an initial node (i.e. a city) in the graph\n",
-    "- Compute the shortest route that visits all cities exactly once, without returning to the initial city.\n",
-    "\n",
-    "\n",
-    "Note that there we consider a version of the problem in which do not return to the initial city. However, the classic version of the problem includes returning to the initial city.\n",
-    "\n",
-    "\n",
-    "As for the ASP problem we represent the distance table as a matrix, where $C_{ij}$ is the distance from node $i$ to node $j$. Next figure shows the input and solution (output) of the TSP problem for a simple 4-node graph. "
+    "- Compute the shortest route that visits all cities exactly once, without returning to the initial city.\n"
    ]
   },
   {
@@ -68,15 +62,10 @@
    "source": [
     "### Branch and bound algorithm\n",
     "\n",
-    "We consider a [branch and bound strategy](https://en.wikipedia.org/wiki/Branch_and_bound) to solve the ASP problem. The first ingredient of this strategy is to enumerate all potential solutions of the problem using a search tree. The tree is defined as follows:\n",
-    "\n",
     "- The root is the initial city\n",
     "- The children of a node are the neighbor cities not visited so-far\n",
     "- **We sort the children using the nearest city first heuristic**\n",
-    "- A node will be a leaf of the tree when all neighbor cities are already visited\n",
-    "\n",
-    "\n",
-    "The nearest city first heuristic is a way to speed up the search as we increase the possibility of finding the solution in the first paths enumerated in the tree."
+    "- A node will be a leaf of the tree when all neighbor cities are already visited\n"
    ]
   },
   {
@@ -94,16 +83,29 @@
     "</div>"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "9da5f5ae",
+   "metadata": {},
+   "source": [
+    "- Number of possible paths might be up to O(N!)\n",
+    "- Visiting all paths is impractical (even in parallel)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "ecf89636",
    "metadata": {},
    "source": [
-    "### Pruning the search tree\n",
-    "\n",
-    "We look for a solution by going over the branches of the search tree via first-depth search. Each time we hit a lead in the tree we have a route between all cities and this a possible solution of the TSP problem (called a partial solution). In this process, we keep track of which is the shortest partial solution found so far. Note that we don't need to completely traverse all branches. In some cases, the distance at an intermediate point in a route will be already equal or greater than the best distance found so-far. In this case, we don't need to continue moving within this branch and we can jump to the next one. This is the \"bound\" criterion in our branch and bound strategy, which is also referred to as \"pruning\" the search tree.\n",
-    "\n",
-    "In the example below, the first route has distance 6. At an intermediate point of the 2nd route we have already covered a distance equal to 6 which guarantees that the solution will not be in this part of the tree.\n"
+    "### Pruning the search tree\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "239b7362",
+   "metadata": {},
+   "source": [
+    "- Only 3 out of 6 routes need to be visited"
    ]
   },
   {
@@ -113,7 +115,7 @@
     }
    },
    "cell_type": "markdown",
-   "id": "f18d02d6",
+   "id": "d8218eaf",
    "metadata": {},
    "source": [
     "<div>\n",
@@ -121,14 +123,6 @@
     "</div>"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "239b7362",
-   "metadata": {},
-   "source": [
-    "Thus, there are only 2 more complete routes that we need to visit. Using this strategy we have significantly reduced the routes visited: from 6 possible routes to 3 visited routes."
-   ]
-  },
   {
    "attachments": {
     "g23549.png": {
@@ -255,8 +249,8 @@
     "    num_cities = length(C_sorted)\n",
     "    if hops != num_cities\n",
     "        city = path[hops]\n",
-    "        connections = C_sorted[city]\n",
     "        next_hops = hops + 1\n",
+    "        connections = C_sorted[city]\n",
     "        for (next_city,distance_increment) in connections\n",
     "            already_visited = (next_city in view(path,1:hops))\n",
     "            if ! already_visited\n",
@@ -266,7 +260,8 @@
     "        end\n",
     "        return nothing\n",
     "    else\n",
-    "        @show path\n",
+    "        #@show path\n",
+    "        println(path)\n",
     "        return nothing\n",
     "    end\n",
     "end"
@@ -303,7 +298,9 @@
    "id": "65e654df",
    "metadata": {},
    "source": [
-    "### Serial implementation without pruning"
+    "### Serial implementation without pruning\n",
+    "\n",
+    "- Now, we add the computation of the minimum distance"
    ]
   },
   {
@@ -326,8 +323,8 @@
     "    num_cities = length(C_sorted)\n",
     "    if hops != num_cities\n",
     "        city = path[hops]\n",
-    "        connections = C_sorted[city]\n",
     "        next_hops = hops + 1\n",
+    "        connections = C_sorted[city]\n",
     "        for (next_city,distance_increment) in connections\n",
     "            already_visited = (next_city in view(path,1:hops))\n",
     "            if ! already_visited\n",
@@ -362,7 +359,9 @@
    "id": "3c160cf9",
    "metadata": {},
    "source": [
-    "### Final serial implementation"
+    "### Final serial implementation\n",
+    "\n",
+    "- Now, we add pruning"
    ]
   },
   {
@@ -434,14 +433,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "n = 11\n",
+    "n = 12 # It is safe to test up to 12\n",
     "using Random\n",
+    "using Test\n",
     "Random.seed!(1)\n",
     "C = rand(1:10,n,n)\n",
     "C_sorted = sort_neighbors(C)\n",
     "city = 1\n",
-    "@time tsp_serial_no_prune(C_sorted,city)\n",
-    "@time tsp_serial(C_sorted,city)"
+    "@time min_no_prune = tsp_serial_no_prune(C_sorted,city)\n",
+    "@time min_prune = tsp_serial(C_sorted,city)\n",
+    "@test min_no_prune == min_prune"
    ]
   },
   {
@@ -452,6 +453,153 @@
     "## Parallel implementation"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "c6375465",
+   "metadata": {},
+   "source": [
+    "### Where can we extract parallelism ?"
+   ]
+  },
+  {
+   "attachments": {
+    "g25091.png": {
+     "image/png": "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 truncated
+    }
+   },
+   "cell_type": "markdown",
+   "id": "5e853346",
+   "metadata": {},
+   "source": [
+    "<div>\n",
+    "<img src=\"attachment:g25091.png\"  align=\"left\" width=\"525\"/>\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7c72df0e",
+   "metadata": {},
+   "source": [
+    "### Option 1\n",
+    "\n",
+    "- We assign a branch to each worker\n",
+    "- Pros? Cons?\n"
+   ]
+  },
+  {
+   "attachments": {
+    "g18142.png": {
+     "image/png": "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 truncated
+    }
+   },
+   "cell_type": "markdown",
+   "id": "73b7633a",
+   "metadata": {},
+   "source": [
+    "<div>\n",
+    "<img src=\"attachment:g18142.png\"  align=\"left\" width=\"300\"/>\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "052a5676",
+   "metadata": {},
+   "source": [
+    "### Option 2\n",
+    "- We assign a fixed number of branches to each worker in advance\n",
+    "- Pros? Cons?"
+   ]
+  },
+  {
+   "attachments": {
+    "g18910.png": {
+     "image/png": "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 truncated
+    }
+   },
+   "cell_type": "markdown",
+   "id": "2701cc6a",
+   "metadata": {},
+   "source": [
+    "<div>\n",
+    "<img src=\"attachment:g18910.png\"  align=\"left\" width=\"300\"/>\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d9edf5c1",
+   "metadata": {},
+   "source": [
+    "<div>\n",
+    "    <br>\n",
+    "    <br>\n",
+    "    <br>\n",
+    "</div>"
+   ]
+  },
+  {
+   "attachments": {
+    "g20390.png": {
+     "image/png": "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 truncated
+    }
+   },
+   "cell_type": "markdown",
+   "id": "673fb192",
+   "metadata": {},
+   "source": [
+    "<div>\n",
+    "<img src=\"attachment:g20390.png\"  align=\"left\" width=\"300\"/>\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d340c63",
+   "metadata": {},
+   "source": [
+    "### Main performance issues\n",
+    "\n",
+    "- Dynamic load imbalance\n",
+    "- Search overhead"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c6d51e00",
+   "metadata": {},
+   "source": [
+    "### Dynamic load balancing with replicated workers model\n",
+    "\n",
+    "- The coordinator searches up to a certain depth in the tree\n",
+    "- When the maximum depth is reached, the coordinator delegates the search to a worker\n",
+    "- Worker processes repeatedly get work and execute it\n"
+   ]
+  },
+  {
+   "attachments": {
+    "Screenshot%20from%202023-09-25%2013-03-57.png": {
+     "image/png": "iVBORw0KGgoAAAANSUhEUgAABH0AAAGhCAYAAAD80shHAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AACAASURBVHic7N15VFz3ff//551hZ4Zt2BEg0IY2ZEnWCmi1ZMl2pMZLEidOE6+JncY936bn/Npvfr+c9vv7fZO2+bZp0yR1YlnyUsdxm9hOLFu2ZQkQSEiyFgvtK2KdYdhh2AZm7u8PdK/vsAkQiO39OGeOfAYYLshiec37834pqqqqCCGEEEIIIYQQQogpxTTeFyCEEEIIIYQQQgghRp+EPkIIIYQQQgghhBBTkIQ+QgghhBBCCCGEEFOQhD5CCCGEEEIIIYQQU5CEPkIIIYQQQgghhBBTkIQ+QgghhBBCCCGEEFOQhD5CCCGEEEIIIYQQU5CEPkIIIYQQQgghhBBTkIQ+QgghhBBCCCGEEFOQhD5CCCGEEEIIIYQQU5CEPkIIIYQQQgghhBBTkIQ+QgghhBBCCCGEEFOQhD5CCCGEEEIIIYQQU5CEPkIIIYQQQgghhBBTkIQ+QgghhBBCCCGEEFOQhD5CCCGEEEIIIYQQU5CEPkIIIYQQQgghhBBTkIQ+QgghhBBCCCGEEFOQ33hfgBBCCCGmrs7OTurq6igvL+fatWt4vV78/f2pr6/HarWSmppKXFwcMTExhIWF4ecnP5oIIYQQQowW+clKCCGEEKNCVVWam5upqrJjt1dht9upqKigvLyckpISLl68iKIoBAQEUF1dTVhYGLNmzSIxMZH4+Hji4+P1ACg6OpqYmBhiYmIIDg4e7w9NCCGEEGJSUlRVVcf7IoQQQggx+bS3t1NTU4Pdbsdut1NZWUl5ebnPzeFw0NHRob+NNsnj8Xjo/SNIcHAwMTExegAUHx9PQkKCHgQZbxEREfj7+9/Vj1cIIYQQYrKR0EcIIYQQt+XxeGhsbMRut1NV9cUUT1lZmU/I09zc3CfMuRMmk4mwsDCfIKh3GGScCgoNDUVRlFF7/0IIIYQQk5mEPkIIIYToo7W1lerqap8pnt4BT01NDW63e1yuLzAwkOjoaJ9jYVoQFBsb6zMVFBkZSWBg4LhcpxBCCCHEeJLQRwghhJjmurq6qK+v1wMefYqntIyy8p6gp6KiApfLNd6XeltWq7XPRNBAu4KsVismkxSZCiGEEGLqktBHCCGEmGZaWlpwOBw+AY82vaNN89TV1dHd3T3el6rTjmyN5McWf39/oqKi+gRB8fHxxMbG+gRBNpuNoKCg0b58IYQQQohxIaGPEEIIMYV1dnZSV1tH1a02Lbvd7hPulJWVYbfbaWtrG/JjBgQEoKoqXV1dQ36biIgIvF4vzc3N+n1paWl4vV5KS0tv+/Za6GMymYiKiiImJgav10tdXR2NjY3DuhZNaGgosbGxPUFQfALxCX0XR0dHRxMTHUNYuNTJCyGEEGLykdBHCCGEmCJUVaWpqQm73a5P8hiXLWt/NjQ04PV6h/SY2u6c2JhYVFTKy8txuVyoqjrkfT4xMTGsW7cOu93OkSNH9PufeOIJZs+eze9//3suXbo0pMkis9msBzVxcXHMSJpBUHAQLS0t1NTUUFtbS01NDTU1NbS2tg57MsjPz4+IiIh+p4Li4uL0qaDo6Giio6MJCQkZ1uMLIYQQQtxN8pSVEEIIMUn1rkyvqqrqM8VTXV3tU5k+GEVRiAiP0CdeEhISiImJwePxUFlZid1ux2w209nZ2edtB5r+iYmJ4dFHH2X79u28/fbbPqFPXFwcX//610lJSeGVV17h1KlTtLe397km+OJYl8fj0T/elJQUIiIiWLhwIXPmzMFiteByufTAq7q6GqfT6RMGNTQ09Hv9mu7ubmpra6mtreXcuXP6/cY6eS0I0v40BkFSJy+EEEKIiURCHyGEEGISMFam+yxbLivzCXmMx6duJzg4mNjYWD28SEpKIjk5mZSUFOLi4uju7ubKlSscPXqUzz77jPLy8j6PYbFYiIqKosvdRV19nc/LtMDne9/7HsHBwf1eQ3R0NI8++ig2m41du3aRn5/v8zEoikJISAh+fn60tbX5TBdpH3t+fj6rVq0iJyeHtWvXkpWVRUREBC6XS596ctgd2B09n7feQVBNTQ0ulwuPxzPg56q9vV1/f5redfLGMEibCjIGQhaLRerkhRBCCHFXSegjhBBCTEDGynSHw0FlRaXepKWFPMOpTNeOLWkTPAkJCcyYMYOUlBRSUlL0sCcwMJAbN25QWFhIXl4ehw4dGjDsmTNnDqmpqTQ0NHDhwgWfazEGPgsXLuTGjRsDXpvVamXbtm1ERUURGRnJBx98QF1dT4CkHUOLiIhg1qxZtLa2UlZW5rODyG63895773H48GGWLVvG+vXrWbNmDYsWLWLOnDnMmTNHf92uri4aGhp8jsA5HA4cDgdOp9MnCKqvr+8zeWTk9XppbGyksbGRS5cu6fcHBgZis9n6DYK0OnktDJI6eSGEEEKMJQl9hBBCiHFmrEw37uIpLS3VA57hVqaHhoYSFxenBzzGKR7tz+joaAICAgBwu93cuHGDw4cPk5eXR35+fr9hT2hoKHPnziUnJ4f09HSuXLnCmTNnqKmp0V+nd+AzFAEBAWRnZ2O1WgkNDeW9997DbrcD4HK5MJvNJCUlsWzZMtxuN+fPn+fKlSs+U0E1NTV8/PHHHD9+nMzMTNavX09WVhZLliwhLi4O6Gnyio2NJTY2liVLluhv29bWRnV1tU+rmXZETJsK0gKh5ubmQfcPdXZ2UlVVRVVVlc/9FovFJwQy1sn7HBGLjsEaJnXyQgghhLhzEvoIIYQQd1nvyvTKykp9gmcklekBAQF6Jblxiic1NVUPeWbMmEFoaGiftzWGPbm5uQNO9hjDno0bN5KYmMjHH3/Mvn37KCkp0V9vJIGP0ZIlS3jxxRexWCy8/fbb+nGqpqYmTp06RWBgIA899BAbN27k3LlzFBUVceHCBRoaGvTHaGhoID8/n1OnTvHxxx+zYcMGsrKyWHrPUhKTEvsNU0JCQkhLSyMtLU2/z3ikzjgVpB0R00IgLRC6XQOay+Xi6tWrXL16Vb/P39+fyMhInxBI+1Ork9cCoaioqAGPyQkhhBBC9EdCHyGEEGIMdXZ2Ultb6xPylJeXU1ZaRll52Ygq07U9Mlo4MGPGDH16R7tFRkYOWjE+1LBHO8alhT2rV6/G3enmtddfY8+ePaMa+GgyMjL47ne/i8Vi4fXXX+f69etAz16dvLw8mpqaeO655/j2t7/N1q1byc/Pp6ioiOLiYmpra/XHaWlp4dixY5w5c4aP9n1EzrocsrOzuXf5vaSkptx22bLZbMZms2Gz2Vi0aJF+f0dHh88CbWMg1DsIamxsHPQIXldXF06nE6fTyZkzZ/T7Q0JCiIuL8/l7TkxM7LdBLDw8XOrkhRBCCNEv+QlBCCGEGCW9K9MdDofPsmXt1tjYOOTK9KCgIGw2m88USHJysj7Fk5KSQkJCwpAnQIZ7jCs7O5uNGzeyZs0a4uPjKSsrG9PAR5Oens7TTz+NxWJhz549eqW71+vl5MmT/Nu//Rsul4uvfOUrrFixgrNnz5KXl8eRI0f4/PPPcTgc+mN1dHRwpvgM5y+c55NPPiErK4ucnBxWrVpFWlrasKdngoKCSE5OJjk5Wb/P6/XS0tLSJwgaaCpIq70fSFtbGyUlJT6fYz8/P8LDwwecCjIGQVInL4QQQgiQ0EcIIYQYMWNlusPh8KlM127DqUw3mUyEh4f3meIxTvCkpKQQHh4+7H0vQw17tMme7OxsNm3axOrVq4mPjwd62rJee23sAx9NUlISf/7nf05kZGSfSvcLFy7wH//xH7hcLp544glycnJYtmwZ27dvJzc3l8OHD/P5559TUVGht3JpbWRXrlzhwIEDevizevVqZs+eg9VqGfG1an934eHhZGRk6Pe7O93U1df57Aky1skbdwUNpU6+rq6Ouro6nzr5oKAgYmJifJZ0G+vkjbeIiAh9j5MQQgghpj4JfYQQQogh8Hg8NDQ0+Bzl6b1sebiV6SEhIfov69rxnd7HtOLi4u6o3Wm4YY/xGJcW9sDdD3w0eqV7lI2Xd73MoUOH9M/xtWvX2LVrFy6XiyeffJJ58+Zx7733snjxYrZv305BQQGFhYWcOHGC0tJSn0BFC+Xy8vJYtWoV69atY82aNWRkZBARETFq1x8QGKCHMEYul6vP0mh9KqimlpraL6aCWlpaBq2T7+jooLy83Ofv1WQyYbVa+yyONtbJ22w2qZMXQgghpjgJfYQQQoh+uFytOJ1ftDn1XrZcVlZGbW3tsCrTIyMj+53iMS5ctlqto3L97k43N0qGH/asWbNGb7rSjFfgo7FarWzbvo0oW0+l+4cffqhXupeXl/Paa6/R3NzMU089xZIlSwgMDGTRokXMnz+frVu3cvjwYQoKCjh27BjXr18fsO59+fLlrFu3jrVr17Jw4UKio6PH7GOyWCzMnj2b2bNn6/f1Vyev/bdxKqi2tpa6urrb1sk3NTXR1NQ0aJ28cSrIeDxM6uSFEEKIqUFCHyGEENNe78p0h8OhBzzaJE9FRQWtra1DfkyLxUJsbKz+C7WxMl0LeqKjo2+7THi4RnKMy7izp7eysjJef/31cQt8NMZKd4vF4lPp7nQ6+d3vfkddXR3PPPMMWVlZWCwWzGYzs2bNYtasWWzatIkjR45w6NAhjh49ytWrV/vUvX/00UccO3aMzMxMNmzYwNq1a33q3sfaYHXyTqfTZyKoqqqK6upqnyCotraWpqamEdXJh4aG9jkeZpwKMt6sVitms3nMPg9CCCGEGD2KOtgWQSGEEGIKam5uprq6Wg95Kisr+yxbrq+vH3FlujbFo03wpKamkpSU1G9l+mjpPdmTl5dHRUVFn9cbatgDozvhc+PGDX70ox/x5ptv6vf94Ac/4Ic//CGRkZHDLine truncated
+    }
+   },
+   "cell_type": "markdown",
+   "id": "a8f431d1",
+   "metadata": {},
+   "source": [
+    "<div>\n",
+    "<img src=\"attachment:Screenshot%20from%202023-09-25%2013-03-57.png\"  align=\"left\" width=\"600\"/>\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5e4fdbe1",
+   "metadata": {},
+   "source": [
+    "### Code"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -474,6 +622,16 @@
     "end"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "26188ad3",
+   "metadata": {},
+   "source": [
+    "### Visit paths in parallel\n",
+    "\n",
+    "- We follow a produce-consumer model using a remote channel"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -481,7 +639,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "function enumerate_paths_dist(C_sorted,city,max_hops)\n",
+    "function visit_all_paths_dist(C_sorted,city,max_hops)\n",
     "    T = typeof((0,Int[]))\n",
     "    jobs_chnl = RemoteChannel(()->Channel{T}(1))\n",
     "    @sync begin\n",
@@ -489,6 +647,7 @@
     "            @spawnat w consume_jobs(C_sorted,jobs_chnl)\n",
     "        end\n",
     "        generate_jobs(C_sorted,city,max_hops,jobs_chnl)\n",
+    "        close(jobs_chnl)\n",
     "    end\n",
     "end\n",
     "function generate_jobs(C_sorted,city,max_hops,jobs_chnl)\n",
@@ -497,10 +656,6 @@
     "    hops = 1\n",
     "    path[hops] = city\n",
     "    generate_jobs_recursive(C_sorted,hops,path,max_hops,jobs_chnl)\n",
-    "    for w in workers()\n",
-    "        put!(jobs_chnl,(0,Int[]))\n",
-    "    end\n",
-    "    close(jobs_chnl)\n",
     "end\n",
     "function generate_jobs_recursive(C_sorted,hops,path,max_hops,jobs_chnl)\n",
     "    num_cities = length(C_sorted)\n",
@@ -524,12 +679,12 @@
     "end\n",
     "@everywhere function consume_jobs(C_sorted,jobs_chnl)\n",
     "    while true\n",
-    "        hops,path = take!(jobs_chnl)\n",
-    "        if hops == 0\n",
-    "            println(\"Done!\")\n",
+    "        try\n",
+    "            hops,path = take!(jobs_chnl)\n",
+    "            consume_jobs_recursive(C_sorted,hops,path)\n",
+    "        catch\n",
     "            break\n",
-    "        end\n",
-    "        consume_jobs_recursive(C_sorted,hops,path)\n",
+    "        end        \n",
     "    end\n",
     "end\n",
     "@everywhere function consume_jobs_recursive(C_sorted,hops,path)\n",
@@ -569,7 +724,30 @@
     "C_sorted = sort_neighbors(C)\n",
     "city = 1\n",
     "max_hops = 2\n",
-    "min_distance = enumerate_paths_dist(C_sorted,city,max_hops)"
+    "min_distance = visit_all_paths_dist(C_sorted,city,max_hops)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d85c8e7c",
+   "metadata": {},
+   "source": [
+    "### How to track the global minimum distance?\n"
+   ]
+  },
+  {
+   "attachments": {
+    "Screenshot%20from%202023-09-25%2013-03-57.png": {
+     "image/png": "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 truncated
+    }
+   },
+   "cell_type": "markdown",
+   "id": "973ba501",
+   "metadata": {},
+   "source": [
+    "<div>\n",
+    "<img src=\"attachment:Screenshot%20from%202023-09-25%2013-03-57.png\"  align=\"left\" width=\"600\"/>\n",
+    "</div>"
    ]
   },
   {
@@ -577,7 +755,10 @@
    "id": "0d579e3d",
    "metadata": {},
    "source": [
-    "### How to track the global minimum distance?"
+    "\n",
+    "### Simplified example\n",
+    "\n",
+    "- Each worker generates a random value and updates a globally shared minimum"
    ]
   },
   {
@@ -587,7 +768,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "buffer = 1 # very important\n",
+    "buffer = 1 # Very important\n",
     "min_distance_chnl = RemoteChannel(()->Channel{Int}(buffer))\n",
     "put!(min_distance_chnl,typemax(Int))\n",
     "@sync for w in workers()\n",
@@ -631,6 +812,7 @@
     "            @spawnat w consume_jobs(C_sorted,jobs_chnl,min_distance_chnl)\n",
     "        end\n",
     "        generate_jobs(C_sorted,city,max_hops,jobs_chnl)\n",
+    "        close(jobs_chnl)\n",
     "    end\n",
     "    min_distance = take!(min_distance_chnl)\n",
     "    close(min_distance_chnl)\n",
@@ -643,15 +825,11 @@
     "    path[hops] = city\n",
     "    distance = 0\n",
     "    generate_jobs_recursive(C_sorted,hops,path,max_hops,jobs_chnl,distance)\n",
-    "    for w in workers()\n",
-    "        put!(jobs_chnl,(0,Int[],0))\n",
-    "    end\n",
-    "    close(jobs_chnl)\n",
     "end\n",
     "function generate_jobs_recursive(C_sorted,hops,path,max_hops,jobs_chnl,distance)\n",
     "    num_cities = length(C_sorted)\n",
     "    if hops == max_hops\n",
-    "        @show path, distance\n",
+    "        #@show path, distance\n",
     "        put!(jobs_chnl,(hops,copy(path),distance))\n",
     "        return nothing\n",
     "    else\n",
@@ -672,14 +850,14 @@
     "end\n",
     "@everywhere function consume_jobs(C_sorted,jobs_chnl,min_distance_chnl)\n",
     "    while true\n",
-    "        hops,path,distance = take!(jobs_chnl)\n",
-    "        if hops == 0\n",
-    "            println(\"Done!\")\n",
-    "            break\n",
-    "        end\n",
     "        min_distance = take!(min_distance_chnl)\n",
     "        put!(min_distance_chnl,min_distance)\n",
-    "        consume_jobs_recursive(C_sorted,hops,path,min_distance_chnl,distance,min_distance)\n",
+    "        try\n",
+    "            hops,path,distance = take!(jobs_chnl)\n",
+    "            consume_jobs_recursive(C_sorted,hops,path,min_distance_chnl,distance,min_distance)\n",
+    "        catch\n",
+    "            break\n",
+    "        end\n",
     "    end\n",
     "end\n",
     "@everywhere function consume_jobs_recursive(C_sorted,hops,path,min_distance_chnl,distance,min_distance)\n",
@@ -705,7 +883,7 @@
     "        min_distance = take!(min_distance_chnl)\n",
     "        min_distance = min(min_distance,distance)\n",
     "        put!(min_distance_chnl,min_distance)\n",
-    "        @show path, distance, min_distance\n",
+    "        #@show path, distance, min_distance\n",
     "        return min_distance\n",
     "    end\n",
     "end"
@@ -722,6 +900,39 @@
     "max_hops = 2\n",
     "min_distance = tsp_dist(C_sorted,city,max_hops)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d950905",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n = 18 # Safe to run up to 18\n",
+    "using Random\n",
+    "Random.seed!(1)\n",
+    "C = rand(1:10,n,n)\n",
+    "C_sorted = sort_neighbors(C)\n",
+    "city = 1\n",
+    "T1 = @elapsed min_serial = tsp_serial(C_sorted,city)\n",
+    "max_hops = 2\n",
+    "P = nworkers()\n",
+    "TP = @elapsed min_dist = tsp_dist(C_sorted,city,max_hops)\n",
+    "println(\"Sequential time = \", T1)\n",
+    "println(\"Parallel time = \", TP)\n",
+    "println(\"Speedup = \", T1/TP)\n",
+    "println(\"Optimal speedup = \", P)\n",
+    "println(\"Efficiency = \", 100*(T1/TP)/P, \"%\")\n",
+    "@test min_serial == min_dist"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "edbea7ac",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {