diff --git a/notebooks/asp.ipynb b/notebooks/asp.ipynb
index a14e0d1..8509089 100644
--- a/notebooks/asp.ipynb
+++ b/notebooks/asp.ipynb
@@ -38,18 +38,10 @@
},
{
"cell_type": "code",
- "execution_count": 17,
+ "execution_count": null,
"id": "1dc78750",
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "🥳 Well done!\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"using Printf\n",
"\n",
@@ -65,11 +57,19 @@
"function q1_answer(bool)\n",
" bool || return\n",
" msg = \"\"\"\n",
- " It is not needed to start the loop over `j` with `j=k` as none of the entries of the matrix will be updated\n",
- " in this particular case. Rememebr: `C[i,j] = min(C[i,j],C[i,k]+C[k,j])` if we substitute `j=k`, we get:\n",
- " `C[i,k] = min(C[i,k],C[i,k]+C[k,k])`. Rememeber that `C[k,k]=0, thus, `C[i,k] = min(C[i,k],C[i,k])`, or\n",
- " `C[i,k] = C[i,k]`. In other words, the new value of `C[i,k]` will correspond to the old value.\n",
- " The same is true for `i=k`.\n",
+ " The we can change the loop order over i and j without changing the result. Rememebr:\n",
+ " \n",
+ " C[i,j] = min(C[i,j],C[i,k]+C[k,j])\n",
+ " \n",
+ " if we substitute j=k, we get\n",
+ " \n",
+ " C[i,k] = min(C[i,k],C[i,k]+C[k,k]).\n",
+ " \n",
+ " Since C[k,k]=0, thus, C[i,k] = min(C[i,k],C[i,k]), and C[i,k] = C[i,k].\n",
+ " \n",
+ " In other words, the value of C[i,k] will not be updated at iteration k.\n",
+ " \n",
+ " The same is true for i=k.\n",
" \"\"\"\n",
" println(msg)\n",
"end\n",
@@ -97,8 +97,8 @@
"id": "1faddbfa",
"metadata": {},
"source": [
- "We represent the distance table as a matrix $C$, where $C_{ij}$ is the distance from node $i$ to node $j$ via a direct connection (a single hop in the graph). If there is no direct connection from $i$ to $j$, this is represented using a very large value in $C_{ij}$ (e.g. the largest possible floating point number, `inf`). \n",
- "The next figure shows a simple directed graph with 4 nodes an its corresponding distance matrix (matrix labeled as \"input\")."
+ "We represent the distance table as a matrix $C$, where $C_{ij}$ is the distance from node $i$ to node $j$ via a direct connection (a single hop in the graph). If there is no direct connection from $i$ to $j$, this is represented using a large value in $C_{ij}$ representing infinity. \n",
+ "The next figure shows a simple directed graph with 4 nodes an its corresponding distance matrix (labeled as \"input\")."
]
},
{
@@ -121,7 +121,7 @@
"id": "ade31d26",
"metadata": {},
"source": [
- "The ASP problem consists in computing the minimum distance between any two pair of nodes $i$ and $j$ in the graph. All these values can be also represented as a matrix (matrix labeled as \"output\" in the figure above). For instance, the minimum distance from node 2 to node 3 is 8 as highlighted in the figure."
+ "The ASP problem consists in computing the minimum distance between any two pair of nodes $i$ and $j$ in the graph. All these values can be also represented as a matrix (labeled as \"output\" in the figure above). For instance, the minimum distance from node 2 to node 3 is 8 as highlighted in the figure. You can understand both input and output matrices as distance tables. The key difference is that the input contains the distance using direct connections only, whereas the output contains the (minimum) distance allowing indirect connections."
]
},
{
@@ -136,21 +136,10 @@
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": null,
"id": "4fe447c5",
"metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "floyd! (generic function with 1 method)"
- ]
- },
- "execution_count": 4,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
+ "outputs": [],
"source": [
"function floyd!(C)\n",
" n = size(C,1)\n",
@@ -176,25 +165,10 @@
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": null,
"id": "860e537c",
"metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "4×4 Matrix{Int64}:\n",
- " 0 9 6 1\n",
- " 2 0 8 3\n",
- " 5 3 0 6\n",
- " 10 8 5 0"
- ]
- },
- "execution_count": 6,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
+ "outputs": [],
"source": [
"inf = 1000\n",
"C = [\n",
@@ -228,7 +202,7 @@
"source": [
"### The algorithm explained\n",
"\n",
- "The main idea of the algorithm is to perform as many iterations as nodes in the graph. At iteration $k$, we update the distance matrix $C$ by finding the shortest paths between each pair of nodes, allowing indirect paths via nodes from 1 to $k$. At the last iteration, it is allowed to visit all nodes and, thus, the distance table will contain the minimum possible distances, i.e. the solution of the ASP problem.\n",
+ "The main idea of the Floyd–Warshall algorithm is to perform as many iterations as nodes in the graph. At iteration $k$, we update the distance matrix $C$ by finding the shortest paths between each pair of nodes, allowing indirect paths via nodes from 1 to $k$. At the last iteration, it is allowed to visit all nodes and, thus, the distance table will contain the minimum possible distances, i.e. the solution of the ASP problem.\n",
"\n",
"This process is cleverly done with three nested loops:\n",
"\n",
@@ -243,7 +217,7 @@
"end\n",
"```\n",
"\n",
- "At each outer iteration $k$, we do a loop over the distance matrix $C$. For each pair of nodes $i$ and $j$ we compare the current distance $C_{ij}$ against the distance via node $k$, namely $C_{ik}+C_{kj}$, and update $C_{ij}$ with the minimum."
+ "At each outer iteration $k$, we do a loop over the distance matrix $C$. For each pair of nodes $i$ and $j$ we compare the current distance $C_{ij}$ against the distance via node $k$, namely $C_{ik}+C_{kj}$, and update $C_{ij}$ with the minimum. I.e., at iteration $k$ one checks if it is beneficial to visit node $k$ to reduce the distance between nodes $i$ and $j$."
]
},
{
@@ -266,7 +240,7 @@
"id": "722e330c",
"metadata": {},
"source": [
- "The update of the distance matrix at each iteration is illustrated in the next figure for a small ASP presented above. We highlight in green the distances that are updated in each iteration."
+ "The update of the distance matrix at each iteration is illustrated in the next figure for the small ASP presented above. We highlight in green the distances that are updated in each iteration. Note that some distances that were initially infinity (i.e., no connection) will be updated with a finite value in this process. You can understand this as adding new edges in the graph as illustrated in the figures below."
]
},
{
@@ -352,28 +326,17 @@
"source": [
"### Serial performance\n",
"\n",
- "This algorithm is memory bound, meaning that the main cost is in getting and setting data from the input matrix `C`. In this situation, the order in which we traverse the entries of matrix `C` has a significant performance impact.\n",
+ "Before starting to parallelize this code, we want to make sure that we have an efficient sequential implementation. In this algorithm, the order in which we traverse the entries of matrix `C` has a significant performance impact.\n",
"\n",
"The following function computes the same result as for the previous function `floyd!`, but the nesting of loops over i and j is changed.\n"
]
},
{
"cell_type": "code",
- "execution_count": 8,
+ "execution_count": null,
"id": "75cac17e",
"metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "floyd2! (generic function with 1 method)"
- ]
- },
- "execution_count": 8,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
+ "outputs": [],
"source": [
"function floyd2!(C)\n",
" n = size(C,1)\n",
@@ -399,19 +362,10 @@
},
{
"cell_type": "code",
- "execution_count": 10,
+ "execution_count": null,
"id": "907bc8c9",
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- " 1.777208 seconds\n",
- " 2.967238 seconds\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"n = 1000\n",
"C = rand(n,n)\n",
@@ -457,32 +411,19 @@
"\n",
"\n",
"\n",
- "Question (hard): Can we really parallelize the loops over `i` and `j` ? To compute `C[i,j]` at iteration `k`, we first need to compute `C[i,k]` and `C[k,j]`. In order words, it seems that the order of the loops over `i` and `j` cannot be arbitrary. The first value of `i` and `j` in the loops should be `k`. However, this is not really necessary, why?\n",
+ "Question (hard): Can we really parallelize the loops over `i` and `j` ? To compute `C[i,j]` at iteration `k`, we first need to compute `C[i,k]` and `C[k,j]`. In order words, it seems that the order of the loops over `i` and `j` cannot be arbitrary. However, this is not really true, why?\n",
"
"
]
},
{
"cell_type": "code",
- "execution_count": 18,
+ "execution_count": null,
"id": "8d05b686",
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "It is not needed to start the loop over `j` with `j=k` as none of the entries of the matrix will be updated\n",
- "in this particular case. Rememebr: `C[i,j] = min(C[i,j],C[i,k]+C[k,j])` if we substitute `j=k`, we get:\n",
- "`C[i,k] = min(C[i,k],C[i,k]+C[k,k])`. Rememeber that `C[k,k]=0, thus, `C[i,k] = min(C[i,k],C[i,k])`, or\n",
- "`C[i,k] = C[i,k]`. In other words, the new value of `C[i,k]` will correspond to the old value.\n",
- "The same is true for `i=k`.\n",
- "\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
- "uncover = true\n",
- "q1_answer(uncover)"
+ "uncover = false\n",
+ "q1_answer(true)"
]
},
{
@@ -616,7 +557,7 @@
"metadata": {},
"source": [
"\n",
- "Question: How much data is communicated in each iteration in this parallel algorithm?\n",
+ "Question: How much data is send from the owner of row k in each iteration in this parallel algorithm?\n",
"
\n",
"\n",
" a) O(N²/P)\n",
@@ -627,18 +568,10 @@
},
{
"cell_type": "code",
- "execution_count": 25,
+ "execution_count": null,
"id": "1bf4de56",
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "It's not correct. Keep trying! 💪\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"answer = \"x\" # replace x with a, b, c or d\n",
"floyd_check(answer)"
@@ -659,7 +592,7 @@
"source": [
"### Computation complexity\n",
"\n",
- "Each process updates $N^2/P$ entries per iteration. The computation complexity is $O(N^2/P)$."
+ "Each process updates $N^2/P$ entries per iteration. The computation complexity per iteration is $O(N^2/P)$."
]
},
{
@@ -699,7 +632,7 @@
"metadata": {},
"source": [
"\n",
- "
![](\"attachment:fig-asp-efficiency-comm-2.png\")
\n",
+ "
\n",
"
\n",
+ "
\n",
"