Merge pull request #45 from fverdugo/francesc

Rather minor changes in async and distributed notebooks

notebooks/julia_async.ipynb

@@ -283,7 +283,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "fun = () -> compute_π(4_000_000_000)\n",
+    "fun = () -> @show compute_π(4_000_000_000)\n",
     "t = Task(fun)"
    ]
   },
@@ -359,7 +359,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "fun = () -> compute_π_yield(3_000_000_000)\n",
+    "fun = () -> @show compute_π_yield(3_000_000_000)\n",
     "t = Task(fun)\n",
     "schedule(t)"
    ]
@@ -729,6 +729,18 @@
     "take!(chnl)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "8a1ef849",
+   "metadata": {},
+   "source": [
+    "In summary:\n",
+    "\n",
+    "- `put!` will wait for a `take!` if there is not space left in the channel's buffer.\n",
+    "- `take!` will wait for a `put!` if there is no data to be consumed in the channel.\n",
+    "- Both `put!` and `take!` will raise an error if the channel is closed."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "9ddd66ca",
@@ -746,7 +758,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "t = @elapsed compute_π(100_000_000)"
+    "t = @elapsed @show compute_π(140_000_000)"
    ]
   },
   {
@@ -772,7 +784,7 @@
    "outputs": [],
    "source": [
     "@time for i in 1:10\n",
-    "    compute_π(100_000_000)\n",
+    "    @show compute_π(140_000_000)\n",
     "end"
    ]
   },
@@ -810,7 +822,7 @@
    "outputs": [],
    "source": [
     "@time for i in 1:10\n",
-    "    @async compute_π(100_000_000)\n",
+    "    @async @show compute_π(140_000_000)\n",
     "end"
    ]
   },
@@ -847,7 +859,7 @@
    "outputs": [],
    "source": [
     "@time @sync for i in 1:10\n",
-    "    @async compute_π(100_000_000)\n",
+    "    @async @show compute_π(140_000_000)\n",
     "end"
    ]
   },
@@ -970,6 +982,22 @@
     "</div>"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "dfab0c90",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "\n",
+    "In order to start \"thinking in parallel\" you first need to be familiar with concepts of asynchronous programming, in particular tasks. In this notebook, we have seen the basics of working with tasks. Some key points to remember:\n",
+    "\n",
+    "- How to create, schedule, and fetch from a task.\n",
+    "- Tasks run asynchronously, but not in parallel. You can have a single core CPU and still be able to work with several tasks.\n",
+    "- Channels are used to communicate data between tasks.\n",
+    "- Adding data (`put!`) or taking data (`take!`) from a channel might wait depending on the channel state. Be careful to avoid dead locks.\n",
+    "\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "a5d3730b",

notebooks/julia_distributed.ipynb

@@ -65,25 +65,25 @@
     "    msg = \"\"\"\n",
     "    We send the matrix (16 entries) and then we receive back the result (1 extra integer). Thus, the total number of transferred integers in 17.\n",
     "    \"\"\"\n",
-    "    display(msg)\n",
+    "    println(msg)\n",
     "end\n",
     "function why_q2()\n",
     "    msg = \"\"\"\n",
     "    Even though we only use a single entry of the matrix in the remote worker, the entire matrix is captured and sent to the worker. Thus, we will transfer 17 integers like in Question 1.\n",
     "    \"\"\"\n",
-    "    display(msg)\n",
+    "    println(msg)\n",
     "end\n",
     "function why_q3()\n",
     "    msg = \"\"\"\n",
     "    The value of x will still be zero since the worker receives a copy of the matrix and it modifies this copy, not the original one.\n",
     "    \"\"\"\n",
-    "    display(msg)\n",
+    "    println(msg)\n",
     "end\n",
     "function why_q4()\n",
     "    msg = \"\"\"\n",
     "    In this case, the code a[2]=2 is executed in the main process. Since the matrix is already in the main process, it is not needed to create and send a copy of it. Thus, the code modifies the original matrix and the value of x will be 2.\n",
     "    \"\"\"\n",
-    "    display(msg)\n",
+    "    println(msg)\n",
     "end\n",
     "println(\"🥳 Well done! \")"
    ]
@@ -143,18 +143,27 @@
   },
   {
    "cell_type": "markdown",
-   "id": "d2e507dc",
+   "id": "a597f9be",
    "metadata": {},
    "source": [
     "### Each process runs a separated Julia instance\n",
     "\n",
-    "When adding the new processes, you can imagine that 3 new Julia REPLs have started under the hood (see figure below). The main point of the Distributed module is to provide a way of coordinating all these Julia processes to run code in parallel. It is important to note that each process runs in a separated Julia instance. This means that each process has its own memory space and therefore they do not share memory. This results in distributed-memory parallelism, and allows one to run processes in different machines.\n",
-    " \n",
-    " <div>\n",
-    "<img src=\"data:image/png;base64,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 truncated
-    "</div>\n",
-    " \n",
-    " "
+    "When adding the new processes, you can imagine that 3 additional Julia REPLs have started under the hood (see figure below). The main point of the Distributed module is to provide a way of coordinating all these Julia processes to run code in parallel. It is important to note that each process runs in a separated Julia instance. This means that each process has its own memory space and therefore they do not share any data. This results in distributed-memory parallelism, and allows one to run processes in different machines."
+   ]
+  },
+  {
+   "attachments": {
+    "image838.png": {
+     "image/png": "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 truncated
+    }
+   },
+   "cell_type": "markdown",
+   "id": "f7065cb8",
+   "metadata": {},
+   "source": [
+    "<div>\n",
+    "<img src=\"attachment:image838.png\"  align=\"left\" width=\"450\"/>\n",
+    "</div>"
    ]
   },
   {
@@ -541,7 +550,7 @@
    "id": "6d6e04d9",
    "metadata": {},
    "source": [
-    "### Data movement in `remotecall` / `fetch`\n",
+    "### Explicit data movement in `remotecall` / `fetch`\n",
     "\n",
     "When usig `remotecall` we send to the remote process a function and its arguments. In this example, we send function name `+` and matrices `a` and `b` to proc 4. When fetching the result we receive a copy of the matrix from proc 4."
    ]
@@ -556,8 +565,8 @@
     "proc = 4\n",
     "a = rand(10,10)\n",
     "b = rand(10,10)\n",
-    "ftr = remotecall(+,proc,a,b)\n",
-    "fetch(ftr);"
+    "ftr = remotecall(+,proc,a,b) # Send\n",
+    "fetch(ftr); # Receive"
    ]
   },
   {
@@ -581,8 +590,8 @@
     "a = rand(10,10)\n",
     "b = rand(10,10)\n",
     "fun = () -> a+b\n",
-    "ftr = remotecall(fun,proc)\n",
-    "fetch(ftr);"
+    "ftr = remotecall(fun,proc) # Send\n",
+    "fetch(ftr); # Receive"
    ]
   },
   {
@@ -592,7 +601,7 @@
    "source": [
     "### Data movement with remote channels\n",
     "\n",
-    "Another way of moving data between processes is to use remote channels. Their usage is very similar to conventional channels for moving data between tasks, but there are some important differences. In the next cell, we create a remote channel. Process 4 puts several values and closes the channel. Like for conventional channels, calls to `put!` are blocking, but next cell is not blocking the master process since the call to `put!` runs asynchronously on process 4."
+    "Another way of moving data between processes is to use remote channels. Their usage is very similar to conventional channels for moving data between tasks, but there are some important differences. In the next cell, we create a remote channel. Process 4 puts several values and closes the channel. Like for conventional channels, calls to `put!` might block, but next cell is not blocking the master process since the call to `put!` runs asynchronously on process 4."
    ]
   },
   {
@@ -727,7 +736,12 @@
    "source": [
     "### Remote channels are also iterable\n",
     "\n",
-    "As with conventional channels, remote channels can be iterated. Let's repeat the example above."
+    "As with conventional channels, remote channels can be iterated. Let's repeat the example above.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-info\">\n",
+    "<b>Note:</b> In old Julia versions, it was not possible to iterate over remote channels. If the cells below do not work, update Julia to a recent version.\n",
+    "</div>\n",
+    "\n"
    ]
   },
   {