diff --git a/dev/.documenter-siteinfo.json b/dev/.documenter-siteinfo.json index 3a98eb7..6f07d3d 100644 --- a/dev/.documenter-siteinfo.json +++ b/dev/.documenter-siteinfo.json @@ -1 +1 @@ -{"documenter":{"julia_version":"1.10.4","generation_timestamp":"2024-08-22T08:36:00","documenter_version":"1.6.0"}} \ No newline at end of file +{"documenter":{"julia_version":"1.10.4","generation_timestamp":"2024-08-26T11:01:02","documenter_version":"1.6.0"}} \ No newline at end of file diff --git a/dev/LEQ/index.html b/dev/LEQ/index.html index a35b589..4c0642e 100644 --- a/dev/LEQ/index.html +++ b/dev/LEQ/index.html @@ -14,4 +14,4 @@ var myIframe = document.getElementById("notebook"); iFrameResize({log:true}, myIframe); }); - + diff --git a/dev/asp/index.html b/dev/asp/index.html index e60e04d..8d2bf3e 100644 --- a/dev/asp/index.html +++ b/dev/asp/index.html @@ -14,4 +14,4 @@ var myIframe = document.getElementById("notebook"); iFrameResize({log:true}, myIframe); }); - + diff --git a/dev/getting_started_with_julia/index.html b/dev/getting_started_with_julia/index.html index b0e71f2..f5c8da7 100644 --- a/dev/getting_started_with_julia/index.html +++ b/dev/getting_started_with_julia/index.html @@ -1,5 +1,5 @@ -Getting started · XM_40017

Getting started

Introduction

The programming of this course will be done using the Julia programming language. Thus, we start by explaining how to get up and running with Julia. After studying this page, you will be able to:

  • Use the Julia REPL,
  • Run serial and parallel code,
  • Install and manage Julia packages.

Why Julia?

Courses related with high-performance computing (HPC) often use languages such as C, C++, or Fortran. We use Julia instead to make the course accessible to a wider set of students, including the ones that have no experience with C/C++ or Fortran, but are willing to learn parallel programming. Julia is a relatively new programming language specifically designed for scientific computing. It combines a high-level syntax close to interpreted languages like Python with the performance of compiled languages like C, C++, or Fortran. Thus, Julia will allow us to write efficient parallel algorithms with a syntax that is convenient in a teaching setting. In addition, Julia provides easy access to different programming models to write distributed algorithms, which will be useful to learn and experiment with them.

Tip

You can run the code in this link to learn how Julia compares to other languages (C and Python) in terms of performance.

Installing Julia

This is a tutorial-like page. Follow these steps before you continue reading the document.

The Julia REPL

Starting Julia

There are several ways of opening Julia depending on your operating system and your IDE, but it is usually as simple as launching the Julia app. With VSCode, open a folder (File > Open Folder). Then, press Ctrl+Shift+P to open the command bar, and execute Julia: Start REPL. If this does not work, make sure you have the Julia extension for VSCode installed. Independently of the method you use, opening Julia results in a window with some text ending with:

julia>

You have just opened the Julia read-evaluate-print loop, or simply the Julia REPL. Congrats! You will spend most of time using the REPL, when working in Julia. The REPL is a console waiting for user input. Just as in other consoles, the string of text right before the input area (julia> in the case) is called the command prompt or simply the prompt.

Basic usage

The usage of the REPL is as follows:

  • You write some input
  • press enter
  • you get the output

For instance, try this

julia> 1 + 1

A "Hello world" example looks like this in Julia

julia> println("Hello, world!")

Try to run it in the REPL.

Help mode

Curious about what the function println does? Enter into help mode to look into the documentation. This is done by typing a question mark (?) into the input field:

julia> ?

After typing ?, the command prompt changes to help?>. It means we are in help mode. Now, we can type a function name to see its documentation.

help?> println

Package and shell modes

The REPL comes with two more modes, namely package and shell modes. To enter package mode type

julia> ]

Package mode is used to install and manage packages. We are going to discuss the package mode in greater detail later. To return back to normal mode press the backspace key several times.

To enter shell mode type semicolon (;)

julia> ;

The prompt should have changed to shell> indicating that we are in shell mode. Now you can type commands that you would normally do on your system command line. For instance,

shell> ls

will display the contents of the current folder in Mac or Linux. Using shell mode in Windows is not straightforward, and thus not recommended for beginners.

Running Julia code

Running more complex code

Real-world Julia programs are not typed in the REPL in practice. They are written in one or more files and included in the REPL. To try this, create a new file called hello.jl, write the code of the "Hello world" example above, and save it. If you are using VSCode, you can create the file using File > New File > Julia File. Once the file is saved with the name hello.jl, execute it as follows

julia> include("hello.jl")
Warning

Make sure that the file "hello.jl" is located in the current working directory of your Julia session. You can query the current directory with function pwd(). You can change to another directory with function cd() if needed. Also, make sure that the file extension is .jl.

The recommended way of running Julia code is using the REPL as we did. But it is also possible to run code directly from the system command line. To this end, open a terminal and call Julia followed by the path to the file containing the code you want to execute.

$ julia hello.jl

The previous line assumes that you have Julia properly installed in the system and that it's usable from the terminal. In UNIX systems (Linux and Mac), the Julia binary needs to be in one of the directories listed in the PATH environment variable. To check that Julia is properly installed, you can use

$ julia --version

If this runs without error and you see a version number, you are good to go!

Note

In this tutorial, when a code snipped starts with $, it should be run in the terminal. Otherwise, the code is to be run in the Julia REPL.

Tip

Avoid calling Julia code from the terminal, use the Julia REPL instead! Each time you call Julia from the terminal, you start a fresh Julia session and Julia will need to compile your code from scratch. This can be time consuming for large projects. In contrast, if you execute code in the REPL, Julia will compile code incrementally, which is much faster. Running code in a cluster (like in DAS-5 for the Julia assignment) is among the few situations you need to run Julia code from the terminal. Visit this link (Julia workflow tips) from the official Julia documentation for further information about how to develop Julia code effectivelly.

Running parallel code

Since we are in a parallel computing course, let's run a parallel "Hello world" example in Julia. Open a Julia REPL and write

julia> using Distributed
+Getting started · XM_40017
Getting started
Introduction
The programming of this course will be done using the Julia programming language. Thus, we start by explaining how to get up and running with Julia. After studying this page, you will be able to:
  • Use the Julia REPL,
  • Run serial and parallel code,
  • Install and manage Julia packages.
Why Julia?
Courses related with high-performance computing (HPC) often use languages such as C, C++, or Fortran. We use Julia instead to make the course accessible to a wider set of students, including the ones that have no experience with  C/C++ or Fortran, but are willing to learn parallel programming. Julia is a relatively new programming language specifically designed for scientific computing. It combines a high-level syntax close to interpreted languages like Python with the performance of compiled languages like C, C++, or Fortran. Thus, Julia will allow us to write efficient parallel algorithms with a syntax that is convenient in a teaching setting. In addition, Julia provides easy access to different programming models to write distributed algorithms, which will be useful to learn and experiment with them.
Tip
You can run the code in this link to learn how Julia compares to other languages (C and Python) in terms of performance.
Installing Julia
This is a tutorial-like page. Follow these steps before you continue reading the document.
The Julia REPL
Starting Julia
There are several ways of opening Julia depending on your operating system and your IDE, but it is usually as simple as launching the Julia app. With VSCode, open a folder (File > Open Folder). Then,  press Ctrl+Shift+P to open the command bar, and execute Julia: Start REPL. If this does not work, make sure you have the Julia extension for VSCode installed. Independently of the method you use, opening Julia results in a window with some text ending with:
julia>
You have just opened the Julia read-evaluate-print loop, or simply the Julia REPL. Congrats! You will spend most of time using the REPL, when working in Julia. The REPL is a console waiting for user input. Just as in other consoles, the string of text right before the input area (julia> in the case) is called the command prompt or simply the prompt.
Basic usage
The usage of the REPL is as follows:
  • You write some input
  • press enter
  • you get the output
For instance, try this
julia> 1 + 1
A "Hello world" example looks like this in Julia
julia> println("Hello, world!")
Try to run it in the REPL.
Help mode
Curious about what the function println does? Enter into help mode to look into the documentation. This is done by typing a question mark (?) into the input field:
julia> ?
After typing ?, the command prompt changes to help?>. It means we are in help mode. Now, we can type a function name to see its documentation.
help?> println
Package and shell modes
The REPL comes with two more modes, namely package and shell modes. To enter package mode type
julia> ]
Package mode is used to install and manage packages. We are going to discuss the package mode in greater detail later. To return back to normal mode press the backspace key several times.
To enter shell mode type semicolon (;)
julia> ;
The prompt should have changed to shell> indicating that we are in shell mode. Now you can type commands that you would normally do on your system command line. For instance,
shell> ls
will display the contents of the current folder in Mac or Linux. Using shell mode in Windows is not straightforward, and thus not recommended for beginners.
Running Julia code
Running more complex code
Real-world Julia programs are not typed in the REPL in practice. They are written in one or more files and included in the REPL. To try this, create a new file called hello.jl, write the code of the "Hello world" example above, and save it. If you are using VSCode, you can create the file using File > New File > Julia File. Once the file is saved with the name hello.jl, execute it as follows
julia> include("hello.jl")
Warning
Make sure that the file "hello.jl" is located in the current working directory of your Julia session. You can query the current directory with function pwd(). You can change to another directory with function cd() if needed.  Also, make sure that the file extension is .jl.
The recommended way of running Julia code is using the REPL as we did. But it is also possible to run code directly from the system command line. To this end, open a terminal and call Julia followed by the path to the file containing the code you want to execute.
$ julia hello.jl
The previous line assumes that you have Julia properly installed in the system and that it's usable from the terminal. In UNIX systems (Linux and Mac), the Julia binary needs to be in one of the directories listed in the PATH environment variable. To check that Julia is properly installed, you can use
$ julia --version
If this runs without error and you see a version number, you are good to go!
You can also run julia code from the terminal using the -e flag:
$ julia -e 'println("Hello, world!")'
Note
In this tutorial, when a code snipped starts with $, it should be run in the terminal. Otherwise, the code is to be run in the Julia REPL.
Tip
Avoid calling Julia code from the terminal, use the Julia REPL instead! Each time you call Julia from the terminal, you start a fresh Julia session and Julia will need to compile your code from scratch. This can be time consuming for large projects. In contrast, if you execute code in the REPL, Julia will compile code incrementally, which is much faster. Running code in a cluster (like in DAS-5 for the Julia assignment) is among the few situations you need to run Julia code from the terminal. Visit this link (Julia workflow tips) from the official Julia documentation for further information about how to develop Julia code effectivelly.
Running parallel code
Since we are in a parallel computing course, let's run a parallel "Hello world" example in Julia. Open a Julia REPL and write
julia> using Distributed
 julia> @everywhere println("Hello, world! I am proc $(myid()) from $(nprocs())")
Here, we are using the Distributed package, which is part of the Julia standard library that provides distributed memory parallel support. The code prints the process id and the number of processes in the current Julia session.
You will probably only see output from 1 process. We need to add more processes to run the example in parallel. This is done with the addprocs function.
julia> addprocs(3)
We have added 3 new processes. Plus the old one, we have 4 processes. Run the code again.
julia> @everywhere println("Hello, world! I am proc $(myid()) from $(nprocs())")
Now, you should see output from 4 processes.
It is possible to specify the number of processes when starting Julia from the terminal with the -p argument (useful, e.g., when running in a cluster).  If you launch Julia from the terminal as
$ julia -p 3
and then run
julia> @everywhere println("Hello, world! I am proc $(myid()) from $(nprocs())")
You should get output from 4 processes as before.
Installing packages
One of the most useful features of Julia is its package manager. It allows one to install Julia packages in a straightforward and platform independent way. To illustrate this, let us consider the following parallel "Hello world" example. This example uses the Message Passing Interface (MPI). We will learn more about MPI later in the course.
Copy the following block of code into a new file named "hello_mpi.jl"
# file hello_mpi.jl
 using MPI
 MPI.Init()
@@ -13,4 +13,6 @@ julia> DataFrame(a=[1,2],b=[3,4])
You should get an error or a
 BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
 DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
 MPI = "da04e1cc-30fd-572f-bb4f-1f8673147195"

Copy the contents of previous code block into a file called Project.toml and place it in an empty folder named newproject. It is important that the file is named Project.toml. You can create a new folder from the REPL with

julia> mkdir("newproject")

To install all the packages registered in this file you need to activate the folder containing your Project.toml file

(@v1.10) pkg> activate newproject

and then instantiating it

(newproject) pkg> instantiate

The instantiate command will download and install all listed packages and their dependencies in just one click.

Getting help in package mode

You can get help about a particular package operator by writing help in front of it

(@v1.10) pkg> help activate

You can get an overview of all package commands by typing help alone

(@v1.10) pkg> help

Package operations in Julia code

In some situations it is required to use package commands in Julia code, e.g., to automatize installation and deployment of Julia applications. This can be done using the Pkg package. For instance

julia> using Pkg
-julia> Pkg.status()

is equivalent to calling status in package mode.

(@v1.10) pkg> status

Conclusion

We have learned the basics of how to work with Julia. If you want to further dig into the topics we have covered here, you can take a look at the following links:

+julia> Pkg.status()

is equivalent to calling status in package mode.

(@v1.10) pkg> status

Creating you own package

In many situations is useful to create your own package, for instance, when working with a large code base, when you want to reduce compilation latency using Revise.jl, or if you want to eventually register your package and share it with others.

The simplest way of generating a package (called MyPackage) is as follows. Open Julia go to package mode and type

(@v1.10) pkg> generate MyPackage

This will crate a minimal package consisting of a new folder MyPackage with two files:

Tip

This approach only generates a very minimal package. To create a more sophisticated package skeleton (including unit testing, code coverage, readme file, licence, etc.) use PkgTemplates.jl or BestieTemplate.jl. The later one is developed in Amsterdam at the Netherlands eScience Center.

You can add dependencies to the package by activating the MyPackage folder in package mode and adding new dependencies as always:

(@v1.10) pkg> activate MyPackage
+(MyPackage) pkg> add MPI

This will add MPI to your package dependencies.

Using your own package

To use your package you first need to add it to a package environment of your choice. This is done with develop path/to/the/package/folder in package mode. For instance:

(@v1.10) pkg> develop MyPackage
Note

You do not need to "develop" your package if you activated the package folder MyPackage.

Now, we can go back to standard Julia mode and use it as any other package:

using MyPackage
+MyPackage.greet()

Here, we just called the example function defined in MyPackage/src/MyPackage.jl.

Conclusion

We have learned the basics of how to work with Julia, including how to run serial and parallel code, and how to manage, create, and use Julia packages. This knowledge will allow you to follow the course effectively! If you want to further dig into the topics we have covered here, you can take a look at the following links:

diff --git a/dev/index.html b/dev/index.html index 839a46e..67ac256 100644 --- a/dev/index.html +++ b/dev/index.html @@ -2,4 +2,4 @@ Home · XM_40017

Programming Large-Scale Parallel Systems (XM_40017)

Welcome to the interactive lecture notes of the Programming Large-Scale Parallel Systems course at VU Amsterdam!

What

This page contains part of the course material of the Programming Large-Scale Parallel Systems course at VU Amsterdam. We provide several lecture notes in jupyter notebook format, which will help you to learn how to design, analyze, and program parallel algorithms on multi-node computing systems. Further information about the course is found in the study guide (click here) and our Canvas page (for registered students).

Note

Material will be added incrementally to the website as the course advances.

Warning

This page will eventually contain only a part of the course material. The rest will be available on Canvas. In particular, the material in this public webpage does not fully cover all topics in the final exam.

How to use this page

You have two main ways of studying the notebooks:

  • Download the notebooks and run them locally on your computer (recommended). At each notebook page you will find a green box with links to download the notebook.
  • You also have the static version of the notebooks displayed in this webpage for quick reference.

How to run the notebooks locally

To run a notebook locally follow these steps:

  • Install Julia (if not done already). More information in Getting started.
  • Download the notebook.
  • Launch Julia. More information in Getting started.
  • Execute these commands in the Julia command line:
julia> using Pkg
 julia> Pkg.add("IJulia")
 julia> using IJulia
-julia> notebook()
  • These commands will open a jupyter in your web browser. Navigate in jupyter to the notebook file you have downloaded and open it.

Authors

This material is created by Francesc Verdugo with the help of Gelieza Kötterheinrich. Part of the notebooks are based on the course slides by Henri Bal.

License

All material on this page that is original to this course may be used under a CC BY 4.0 license.

Acknowledgment

This page was created with the support of the Faculty of Science of Vrije Universiteit Amsterdam in the framework of the project "Interactive lecture notes and exercises for the Programming Large-Scale Parallel Systems course" funded by the "Innovation budget BETA 2023 Studievoorschotmiddelen (SVM) towards Activated Blended Learning".

+julia> notebook()

Authors

This material is created by Francesc Verdugo with the help of Gelieza Kötterheinrich. Part of the notebooks are based on the course slides by Henri Bal.

License

All material on this page that is original to this course may be used under a CC BY 4.0 license.

Acknowledgment

This page was created with the support of the Faculty of Science of Vrije Universiteit Amsterdam in the framework of the project "Interactive lecture notes and exercises for the Programming Large-Scale Parallel Systems course" funded by the "Innovation budget BETA 2023 Studievoorschotmiddelen (SVM) towards Activated Blended Learning".

diff --git a/dev/jacobi_2D/index.html b/dev/jacobi_2D/index.html index 1968ebd..ef08b5c 100644 --- a/dev/jacobi_2D/index.html +++ b/dev/jacobi_2D/index.html @@ -14,4 +14,4 @@ var myIframe = document.getElementById("notebook"); iFrameResize({log:true}, myIframe); }); - + diff --git a/dev/jacobi_method.ipynb b/dev/jacobi_method.ipynb index f953933..754658b 100644 --- a/dev/jacobi_method.ipynb +++ b/dev/jacobi_method.ipynb @@ -27,9 +27,9 @@ "\n", "In this notebook, we will learn\n", "\n", - "- How to paralleize a Jacobi method\n", + "- How to paralleize the Jacobi method\n", "- How the data partition can impact the performance of a distributed algorithm\n", - "- How to use latency hiding\n", + "- How to use latency hiding to improve parallel performance\n", "\n" ] }, @@ -93,9 +93,12 @@ "id": "93e84ff8", "metadata": {}, "source": [ - "When solving a Laplace equation in 1D, the Jacobi method leads to the following iterative scheme: The entry $i$ of vector $u$ at iteration $t+1$ is computed as:\n", + "When solving a [Laplace equation](https://en.wikipedia.org/wiki/Laplace%27s_equation) in 1D, the Jacobi method leads to the following iterative scheme: The entry $i$ of vector $u$ at iteration $t+1$ is computed as:\n", "\n", - "$u^{t+1}_i = \\dfrac{u^t_{i-1}+u^t_{i+1}}{2}$" + "$u^{t+1}_i = \\dfrac{u^t_{i-1}+u^t_{i+1}}{2}$\n", + "\n", + "\n", + "This iterative is yet simple but shares fundamental challenges with many other algorithms used in scientific computing. This is why we are studying it here.\n" ] }, { @@ -130,6 +133,14 @@ "end" ] }, + { + "cell_type": "markdown", + "id": "432bd862", + "metadata": {}, + "source": [ + "If you run it for zero iterations, we will see the initial condition." + ] + }, { "cell_type": "code", "execution_count": null, @@ -140,14 +151,78 @@ "jacobi(5,0)" ] }, + { + "cell_type": "markdown", + "id": "c75cb9a6", + "metadata": {}, + "source": [ + "If you run it for enough iterations, you will see the expected solution of the Laplace equation: values that vary linearly form -1 to 1." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b52be374", + "metadata": {}, + "outputs": [], + "source": [ + "jacobi(5,100)" + ] + }, + { + "cell_type": "markdown", + "id": "22fda724", + "metadata": {}, + "source": [ + "In our version of the jacobi method, we return after a given number of iterations. Other stopping criteria are possible. For instance, iterate until the difference between u and u_new is below a tolerance:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "15de7bf5", + "metadata": {}, + "outputs": [], + "source": [ + "using LinearAlgebra: norm\n", + "function jacobi_with_tol(n,tol)\n", + " u = zeros(n+2)\n", + " u[1] = -1\n", + " u[end] = 1\n", + " u_new = copy(u)\n", + " increment = similar(u)\n", + " while true\n", + " for i in 2:(n+1)\n", + " u_new[i] = 0.5*(u[i-1]+u[i+1])\n", + " end\n", + " increment .= u_new .- u\n", + " if norm(increment)/norm(u_new) < tol\n", + " return u_new\n", + " end\n", + " u, u_new = u_new, u\n", + " end\n", + " u\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "697ad307", + "metadata": {}, + "outputs": [], + "source": [ + "n = 5\n", + "tol = 1e-9\n", + "jacobi_with_tol(n,tol)" + ] + }, { "cell_type": "markdown", "id": "6e085701", "metadata": {}, "source": [ - "
\n", - "Note: In our version of the jacobi method, we return after a given number of iterations. Other stopping criteria are possible. For instance, iterate until the difference between u and u_new is below a tolerance.\n", - "
" + "However, we are not going to parallelize this more complex in this notebook (we will consider it later in this course)." ] }, { @@ -156,7 +231,7 @@ "metadata": {}, "source": [ "\n", - "### Where can we exploit parallelism?\n", + "## Where can we exploit parallelism?\n", "\n", "Look at the two nested loops in the sequential implementation:\n", "\n", @@ -169,8 +244,8 @@ "end\n", "```\n", "\n", - "- The outer loop cannot be parallelized. The value of `u` at step `t+1` depends on the value at the previous step `t`.\n", - "- The inner loop can be parallelized.\n", + "- The outer loop over `t` cannot be parallelized. The value of `u` at step `t+1` depends on the value at the previous step `t`.\n", + "- The inner loop is trivially parallel. The loop iterations are independent (any order is possible).\n", "\n" ] }, @@ -386,19 +461,11 @@ "source": [ "### Communication overhead\n", "- We update $N/P$ entries in each process at each iteration, where $N$ is the total length of the vector and $P$ the number of processes\n", + "- Thus, computation complexity is $O(N/P)$\n", "- We need to get remote entries from 2 neighbors (2 messages per iteration)\n", "- We need to communicate 1 entry per message\n", - "- Communication/computation ration is $O(P/N)$ (potentially scalable if $P< + diff --git a/dev/jacobi_method_src/index.html b/dev/jacobi_method_src/index.html index 714a199..1d2e3a9 100644 --- a/dev/jacobi_method_src/index.html +++ b/dev/jacobi_method_src/index.html @@ -7543,9 +7543,9 @@ a.anchor-link {

Contents

In this notebook, we will learn

@@ -7621,8 +7621,9 @@ a.anchor-link {
@@ -7663,6 +7664,17 @@ a.anchor-link { + +
+
+
+ +
+ +
+
+ +
+ +
+ +
@@ -7697,7 +7791,7 @@ a.anchor-link {
@@ -7942,25 +8036,16 @@ d) The inner, but not the outer

Communication overhead

-
- -
@@ -8329,7 +8415,7 @@ d) 4
diff --git a/dev/julia_async/index.html b/dev/julia_async/index.html index 8d84f94..c375c9d 100644 --- a/dev/julia_async/index.html +++ b/dev/julia_async/index.html @@ -14,4 +14,4 @@ var myIframe = document.getElementById("notebook"); iFrameResize({log:true}, myIframe); }); - + diff --git a/dev/julia_basics/index.html b/dev/julia_basics/index.html index ded9cde..ff5de5e 100644 --- a/dev/julia_basics/index.html +++ b/dev/julia_basics/index.html @@ -14,4 +14,4 @@ var myIframe = document.getElementById("notebook"); iFrameResize({log:true}, myIframe); }); - + diff --git a/dev/julia_distributed/index.html b/dev/julia_distributed/index.html index cf99614..7bece87 100644 --- a/dev/julia_distributed/index.html +++ b/dev/julia_distributed/index.html @@ -14,4 +14,4 @@ var myIframe = document.getElementById("notebook"); iFrameResize({log:true}, myIframe); }); - + diff --git a/dev/julia_intro/index.html b/dev/julia_intro/index.html index 9baa57e..f1a5d99 100644 --- a/dev/julia_intro/index.html +++ b/dev/julia_intro/index.html @@ -14,4 +14,4 @@ var myIframe = document.getElementById("notebook"); iFrameResize({log:true}, myIframe); }); - + diff --git a/dev/julia_jacobi/index.html b/dev/julia_jacobi/index.html index 41567c7..b64b2b3 100644 --- a/dev/julia_jacobi/index.html +++ b/dev/julia_jacobi/index.html @@ -14,4 +14,4 @@ var myIframe = document.getElementById("notebook"); iFrameResize({log:true}, myIframe); }); - + diff --git a/dev/julia_mpi.ipynb b/dev/julia_mpi.ipynb index 1340ce6..f64b799 100644 --- a/dev/julia_mpi.ipynb +++ b/dev/julia_mpi.ipynb @@ -687,7 +687,12 @@ "* `rcvbuf` space to store the incoming data.\n", "* `source` rank of the sender.\n", "* `dest` rank of the receiver.\n", - "* `tag`. Might be used to distinguish between different kinds of messages from the same sender to the same receiver (similar to the \"subject\" in an email).\n" + "* `tag`. Might be used to distinguish between different kinds of messages from the same sender to the same receiver (similar to the \"subject\" in an email).\n", + "\n", + "\n", + "
\n", + "Note: Note that the C interface provides additional arguments `MPI_Datatype` (type of data to send/receive) and `count` (number of items to send/receive). In Julia, send and receive buffers are usually arrays or references, from which the data type and the count can be inferred. This is true for many other MPI functions.\n", + "
" ] }, { diff --git a/dev/julia_mpi/index.html b/dev/julia_mpi/index.html index c6f217a..a78ff61 100644 --- a/dev/julia_mpi/index.html +++ b/dev/julia_mpi/index.html @@ -14,4 +14,4 @@ var myIframe = document.getElementById("notebook"); iFrameResize({log:true}, myIframe); }); - + diff --git a/dev/julia_mpi_src/index.html b/dev/julia_mpi_src/index.html index 1076b31..1797ec1 100644 --- a/dev/julia_mpi_src/index.html +++ b/dev/julia_mpi_src/index.html @@ -8291,6 +8291,9 @@ a.anchor-link {
  • dest rank of the receiver.
  • tag. Might be used to distinguish between different kinds of messages from the same sender to the same receiver (similar to the "subject" in an email).
    • +
    +Note: Note that the C interface provides additional arguments `MPI_Datatype` (type of data to send/receive) and `count` (number of items to send/receive). In Julia, send and receive buffers are usually arrays or references, from which the data type and the count can be inferred. This is true for many other MPI functions. +
    diff --git a/dev/julia_tutorial/index.html b/dev/julia_tutorial/index.html index bacfd3c..81ba83e 100644 --- a/dev/julia_tutorial/index.html +++ b/dev/julia_tutorial/index.html @@ -14,4 +14,4 @@ var myIframe = document.getElementById("notebook"); iFrameResize({log:true}, myIframe); }); - + diff --git a/dev/matrix_matrix.ipynb b/dev/matrix_matrix.ipynb index 7efc0dc..eb7dd6c 100644 --- a/dev/matrix_matrix.ipynb +++ b/dev/matrix_matrix.ipynb @@ -29,7 +29,8 @@ "\n", "- Parallelize a simple algorithm\n", "- Study the performance of different parallelization strategies\n", - "- Implement them using Julia" + "- Learn the importance of \"grain size\" in a parallel algorithm\n", + "- Implement and measure the performance of parallel algorithms" ] }, { @@ -54,10 +55,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "2f8ba040", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🥳 Well done! \n" + ] + } + ], "source": [ "using Distributed\n", "using BenchmarkTools\n", @@ -79,7 +88,8 @@ "alg_2_complex_check(answer) = answer_checker(answer, \"b\")\n", "alg_2_deps_check(answer) = answer_checker(answer,\"d\")\n", "alg_3_deps_check(answer) = answer_checker(answer, \"c\")\n", - "alg_3_complex_check(answer) = answer_checker(answer, \"b\")" + "alg_3_complex_check(answer) = answer_checker(answer, \"b\")\n", + "println(\"🥳 Well done! \")" ] }, { @@ -89,6 +99,8 @@ "source": [ "## Problem Statement\n", "\n", + "We consider matrix-matrix multiplication as our first algorithm to parallelize. The problem we want so solve is defined as follows.\n", + "\n", "Given $A$ and $B$ two $N$-by-$N$ matrices, compute the matrix-matrix product $C=AB$. Compute it in parallel and efficiently." ] }, @@ -113,7 +125,7 @@ "\n", "- compute the product in parallel using more than one process (distributed implementation)\n", "- study the performance of different parallelization alternatives\n", - "- implement the algorithms using Julia\n" + "- implement the algorithms using Julia's task-based programming model\n" ] }, { @@ -124,7 +136,7 @@ "### Assumptions\n", "\n", "- All matrices `A`,`B`, and `C` are initially stored in the master process\n", - "- The result will be overwritten in `C`" + "- The result will be overwritten in `C` (in the master process)" ] }, { @@ -148,7 +160,8 @@ "\n", "- Identify the parts of the sequential algorithm that can be parallelized\n", "- Consider different parallelization strategies\n", - "- Discuss the (theoretical) performance of these implementations\n" + "- Discuss the (theoretical) performance of these implementations\n", + "- Measure the actual performance of these implementations\n" ] }, { @@ -222,7 +235,7 @@ "Note: The matrix-matrix multiplication naively implemented with 3 nested loops as above is known to be very inefficient (memory bound). Libraries such as BLAS provide much more efficient implementations, which are the ones used in practice (e.g., by the `*` operator in Julia). We consider our hand-written implementation as a simple way of expressing the algorithm we are interested in.\n", "\n", "\n", - "Run the following cell to compare the performance of our hand-written function with respect to the built in function `mul!`.\n" + "Just to satisfy your curiosity, run the following cell to compare the performance of our hand-written function with respect to the built in function `mul!`.\n" ] }, { @@ -272,9 +285,14 @@ "id": "0eedd28a", "metadata": {}, "source": [ - "### Where can we exploit parallelism?\n", + "## Where can we exploit parallelism?\n", "\n", - "Look at the three nested loops in the sequential implementation:\n", + "\n", + "The matrix-matrix multiplication is an example of [embarrassingly parallel algorithm](https://en.wikipedia.org/wiki/Embarrassingly_parallel). An embarrassingly parallel (also known as trivially parallel) algorithm is an algorithm that can be split in parallel tasks with no (or very few) dependences between them. Such algorithms are typically easy to parallelize.\n", + "\n", + "Which parts of an algorithm are completely independent and thus trivially parallel? To answer this question, it is useful to inspect the for loops, which are potential sources parallelism. If the iterations are independent of each other, then they are trivial to parallelize. An easy check to find out if the iterations are dependent or not is to change their order (for instance changing `for j in 1:n` by `for j in n:-1:1`, i.e. doing the loop in reverse). If the result changes, then the iterations are not independent.\n", + "\n", + "Look at the three nested loops in the sequential implementation of the matrix-matrix product:\n", "\n", "```julia\n", "for j in 1:n\n", @@ -287,8 +305,12 @@ " end\n", "end\n", "```\n", - "- Loops over `i` and `j` are trivially parallelizable.\n", - "- The loop over `k` can be parallelized but it requires a reduction." + "\n", + "Note that:\n", + "\n", + "- Loops over `i` and `j` are trivially parallel.\n", + "- The loop over `k` is not trivially parallel. The accumulation into the reduction variable `Cij` introduces extra dependences. In addition, remember that the addition of floating point numbers is not strictly associative due to rounding errors. Thus, the result of this loop may change with the loop order when using floating point numbers. In any case, this loop can also be parallelized, but it requires a parallel *fold* or a parallel *reduction*.\n", + "\n" ] }, { @@ -298,7 +320,7 @@ "source": [ "### Parallel algorithms\n", "\n", - "All the entries of matrix C can be potentially computed in parallel, but *is it the most efficient solution to solve all these entries in parallel in a distributed system?* To find this we will consider different parallelization strategies:\n", + "Parallelizing the loops over `i` and `j` means that all the entries of matrix C can be potentially computed in parallel. However, *which it the most efficient solution to solve all these entries in parallel in a distributed system?* To find this we will consider different parallelization strategies:\n", "\n", "- Algorithm 1: each worker computes a single entry of C\n", "- Algorithm 2: each worker computes a single row of C\n", @@ -330,7 +352,7 @@ "source": [ "### Data dependencies\n", "\n", - "Moving data through the network is expensive and reducing data movement is one of the key points in a distributed algorithm. To this end, we determine which is the minimum data needed by a worker to perform its computations.\n", + "Moving data through the network is expensive and reducing data movement is one of the key points in a distributed algorithm. To this end, we need to determine which is the minimum data needed by a worker to perform its computations. These are called the *data dependencies*. This will give us later information about the performance of the parallel algorithm.\n", "\n", "In algorithm 1, each worker computes only an entry of the result matrix C." ] @@ -380,7 +402,7 @@ "\n", "Taking into account the data dependencies, the parallel algorithm 1 can be efficiently implemented following these steps from the worker perspective:\n", "\n", - "1. The worker receives the corresponding row A[i,:] and column B[:,j] from the master process\n", + "1. The worker receives the data dependencies, i.e., the corresponding row A[i,:] and column B[:,j] from the master process\n", "2. The worker computes the dot product of A[i,:] and B[:,j]\n", "3. The worker sends back the result of C[i,j] to the master process" ] @@ -471,19 +493,19 @@ "source": [ "### Performance\n", "\n", - "Let us study the performance of this algorithm. To this end, we will analyze if algorithm 1 is able to achieve the optimal parallel *speedup*. The parallel speedup on $P$ processes is defined as \n", + "We have a first parallel algorithm, but how efficient is this algorithm? Let us study its performance. To this end we need to consider a performance baseline as reference. In this case, we will use the so-called optimal parallel *speedup*. The parallel speedup on $P$ processes is defined as \n", "\n", "$$\n", "S_P = \\frac{T_1}{T_P},\n", "$$\n", "\n", - "where $T_1$ denotes the runtime of the sequential algorithm on one node and $T_P$ denotes the runtime of the parallel algorithm on $P$ processes. If we run an optimal parallel algorithm with $P$ processes we expect it to run $p$ times faster than the sequential implementation. I.e., the *optimal* speedup of a parallel algorithm on $p$ processes is equal to $P$:\n", + "where $T_1$ denotes the runtime of the sequential algorithm and $T_P$ denotes the runtime of the parallel algorithm on $P$ processes. If we run an optimal parallel algorithm with $P$ processes we expect it to run $p$ times faster than the sequential implementation. I.e., the *optimal* speedup of a parallel algorithm on $p$ processes is equal to $P$:\n", "\n", "$$\n", "S^{*}_p = P.\n", "$$\n", "\n", - "The ratio of the actual speedup over the optimal one is called the parallel efficiency\n", + "The ratio of the actual speedup over the optimal one is called the parallel efficiency (the closer to one the better).\n", "\n", "$$\n", "E_p = \\frac{S_p}{S^{*}_p} = \\frac{T_1/T_P}{P}.\n", @@ -754,7 +776,9 @@ "id": "f1f30faf", "metadata": {}, "source": [ - "### Experimental speedup" + "### Experimental speedup\n", + "\n", + "Measure the speedup with the following cell. Is this time better?" ] }, { @@ -964,7 +988,9 @@ "\n", "- Matrix-matrix multiplication is trivially parallelizable (all entries in the result matrix can be computed in parallel, at least in theory)\n", "- However, we cannot exploit all the potential parallelism in a distributed system due to communication overhead\n", - "- We need a sufficiently large grain size to obtain a near optimal speedup\n" + "- We need a sufficiently large grain size to obtain a near optimal speedup\n", + "- We measured the theoretical parallel performance by computing the complexity of communication over computation\n", + "- We measured the actual performance using the parallel speedup and parallel efficiency\n" ] }, { diff --git a/dev/matrix_matrix/index.html b/dev/matrix_matrix/index.html index 0b831bc..b08f514 100644 --- a/dev/matrix_matrix/index.html +++ b/dev/matrix_matrix/index.html @@ -14,4 +14,4 @@ var myIframe = document.getElementById("notebook"); iFrameResize({log:true}, myIframe); }); - + diff --git a/dev/matrix_matrix_src/index.html b/dev/matrix_matrix_src/index.html index baac04b..e3be326 100644 --- a/dev/matrix_matrix_src/index.html +++ b/dev/matrix_matrix_src/index.html @@ -7545,7 +7545,8 @@ a.anchor-link { @@ -7577,12 +7578,12 @@ a.anchor-link { -
    +
    +
    @@ -7646,7 +7662,7 @@ a.anchor-link { @@ -7660,7 +7676,7 @@ a.anchor-link {

    Assumptions

    @@ -7690,6 +7706,7 @@ a.anchor-link {
  • Identify the parts of the sequential algorithm that can be parallelized
  • Consider different parallelization strategies
  • Discuss the (theoretical) performance of these implementations
    • +
  • Measure the actual performance of these implementations
    • @@ -7778,7 +7795,7 @@ a.anchor-link {
    Note: The matrix-matrix multiplication naively implemented with 3 nested loops as above is known to be very inefficient (memory bound). Libraries such as BLAS provide much more efficient implementations, which are the ones used in practice (e.g., by the `*` operator in Julia). We consider our hand-written implementation as a simple way of expressing the algorithm we are interested in.
    -

    Run the following cell to compare the performance of our hand-written function with respect to the built in function mul!.

    +

    Just to satisfy your curiosity, run the following cell to compare the performance of our hand-written function with respect to the built in function mul!.

    @@ -7841,7 +7858,9 @@ d) O(N³)
    @@ -7866,7 +7886,7 @@ d) O(N³)
    @@ -7965,7 +7985,7 @@ d) row A[i,:] and the whole matrix B

    Implementation

    Taking into account the data dependencies, the parallel algorithm 1 can be efficiently implemented following these steps from the worker perspective:

      -
    1. The worker receives the corresponding row A[i,:] and column B[:,j] from the master process
      2. +
    2. The worker receives the data dependencies, i.e., the corresponding row A[i,:] and column B[:,j] from the master process
    3. The worker computes the dot product of A[i,:] and B[:,j]
    4. The worker sends back the result of C[i,j] to the master process
    @@ -8074,15 +8094,15 @@ d) row A[i,:] and the whole matrix B
    @@ -8671,6 +8691,8 @@ d) O(N²/P) communication and O(N³/P) computation
  • Matrix-matrix multiplication is trivially parallelizable (all entries in the result matrix can be computed in parallel, at least in theory)
  • However, we cannot exploit all the potential parallelism in a distributed system due to communication overhead
  • We need a sufficiently large grain size to obtain a near optimal speedup
    • +
  • We measured the theoretical parallel performance by computing the complexity of communication over computation
    • +
  • We measured the actual performance using the parallel speedup and parallel efficiency
    • diff --git a/dev/mpi_collectives.ipynb b/dev/mpi_collectives.ipynb new file mode 100644 index 0000000..8faf97a --- /dev/null +++ b/dev/mpi_collectives.ipynb @@ -0,0 +1,901 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7606d30a", + "metadata": {}, + "source": [ + "\n", + "\n", + "### Programming large-scale parallel systems" + ] + }, + { + "cell_type": "markdown", + "id": "4ac1e5d9", + "metadata": {}, + "source": [ + "# Intro to MPI (collectives)" + ] + }, + { + "cell_type": "markdown", + "id": "a341be2e", + "metadata": {}, + "source": [ + "## Contents\n", + "\n", + "\n", + "In this notebook, we will continue learning the basics of parallel computing using the Message Passing Interface (MPI) from Julia. In particular, we will learn:\n", + "\n", + "- How to use basic collective communication directives\n", + "- How to use MPI communicators\n" + ] + }, + { + "cell_type": "markdown", + "id": "c87b3c82", + "metadata": {}, + "source": [ + "## Collective communication\n", + "\n", + "MPI provides collective communication functions for communication involving multiple processes. Some usual collective functions are:\n", + "\n", + "\n", + "- `MPI_Barrier`: Synchronize all processes\n", + "- `MPI_Bcase`: Send the same data from one to all processes\n", + "- `MPI_Gather`: Gather data from all processes to one\n", + "- `MPI_Scatter`: Scatter data from one to all all processes\n", + "- `MPI_Reduce`: Reduce data from all processes to a single one\n", + "- `MPI_Scan`: Scan (or prefix) reduction\n", + "- `MPI_Allgather`: Like a `MPI_Gather` but all processes receive the result\n", + "- `MPI_Allreduce`: Like `MPI_Reduce` but all processes receive the result\n", + "- `MPI_Alltoall`: Exchange data from all to all processes\n", + "\n", + "\n", + "We will discuss some of them in greater detail in this notebook." + ] + }, + { + "cell_type": "markdown", + "id": "4ffa5e56", + "metadata": {}, + "source": [ + "## Why collective primitives?\n", + "\n", + "Point-to-point communication primitives provide all the building blocks needed in parallel programs and could be used to implement the collective functions described above. Then, why does MPI provide collective communication directives? There are several reasons:\n", + "\n", + "- Ease of use: It is handy for users to have these functions readily available instead of having to implement them.\n", + "- Performance: Library implementations typically use efficient algorithms (such as reduction trees).\n", + "- Hardware support: Hardware vendors can optimize the MPI library for their machine and even develop hardware specially design to perform MPI operations efficiently. For instance, [IMB Blue Gene](https://en.wikipedia.org/wiki/IBM_Blue_Gene) was equipped with auxiliary networks for MPI collectives.\n" + ] + }, + { + "cell_type": "markdown", + "id": "53a0f5fa", + "metadata": {}, + "source": [ + "## Semantics of collective operations\n", + "\n", + "\n", + "- Completeness: All the collective communication directives above are *complete* operations. Thus, it is safe to use and reset the buffers once the function returns.\n", + "- Standard mode: Collective directives are in standard mode only, like `MPI_Send`. Assuming that they block is erroneous, assuming that they do not block is also erroneous.\n", + "- Synchronization: Completion of a call does not guarantee that other processes have completed the operation. A collective operation may or may not have the effect of synchronizing all processes, the only exception is `MPI_Barrier` of course.\n", + "\n", + "\n", + "
    \n", + "Note: Recent versions of the MPI standard also include non-blocking (incomplete) versions of collective operations (not covered in this notebook). A particularly funny one is the non-blocking barrier `MPI_Ibarrier`.\n", + "
    " + ] + }, + { + "cell_type": "markdown", + "id": "e9e2a219", + "metadata": {}, + "source": [ + "## MPI_Barrier\n", + "\n", + "This function is used to synchronizes a group of processes. All processes block until all have reached the barrier. It is often invoked at the end of for loops to make sure all processes have finished the current loop iteration to move to the next one. We will see an example later in another notebook when studying the traveling sales person problem (TSP).\n", + "\n", + "In Julia:\n", + "```julia\n", + "MPI.Barrier(comm)\n", + "```\n", + "\n", + "In C:\n", + "```c\n", + "int MPI_Barrier(MPI_Comm comm)\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "d9753e4b", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "In this example the ranks sleep for a random amount of time and then they call barrier. It is guaranteed that the message \"Done!\" will be printed after all processes printed \"I woke up\" since we used a barrier. Try also to comment out the call to `MPI.Barrier`. You will see that the message can be printed in any order in this case." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9a66c717", + "metadata": {}, + "outputs": [], + "source": [ + "code = quote\n", + " using MPI\n", + " MPI.Init()\n", + " comm = MPI.COMM_WORLD\n", + " rank = MPI.Comm_rank(comm)\n", + " sleep(rand(1:3))\n", + " println(\"[rank $rank] I woke up\")\n", + " MPI.Barrier(comm)\n", + " println(\"[rank $rank] Done!\")\n", + "end\n", + "run(`$(mpiexec()) -np 4 julia --project=. -e $code`);" + ] + }, + { + "cell_type": "markdown", + "id": "df0223ff", + "metadata": {}, + "source": [ + "## MPI_Reduce\n", + "\n", + "Combines values provided by different processors according to a given reduction operation. The result is received in a single process (called the root process).\n", + "\n", + "In Julia:\n", + "```julia\n", + "MPI.Reduce!(sendbuf, recvbuf, op, comm; root)\n", + "```\n", + "\n", + "In C:\n", + "```\n", + "int MPI_Reduce(const void *sendbuf, void *recvbuf, int count,\n", + " MPI_Datatype datatype, MPI_Op op, int root,\n", + " MPI_Comm comm)\n", + "```\n", + "\n", + "\n", + "\n", + "
    \n", + "Note: `MPI_Reduce` (and related functions like `MPI_Allreduce`) use operations that are *commutative* and *associative*, such as addition, multiplication, maximum, minimum, logical and, logical or. Otherwise the result will be undefined as it will depend in which order the operations are done.\n", + "
    \n" + ] + }, + { + "cell_type": "markdown", + "id": "2fc1aa28", + "metadata": {}, + "source": [ + "### Example\n", + "Each process generates a random integer. Compute the sum of all these integers. Receive the result on rank 0." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "341b8438", + "metadata": {}, + "outputs": [], + "source": [ + "code = quote\n", + " using MPI\n", + " MPI.Init()\n", + " comm = MPI.COMM_WORLD\n", + " rank = MPI.Comm_rank(comm)\n", + " value = rand(1:4)\n", + " root = 0\n", + " sndbuf = [value]\n", + " if rank == root\n", + " rcvbuf = [0]\n", + " else\n", + " # This can be anything as only the root process\n", + " # Will receive data\n", + " rcvbuf = nothing\n", + " end\n", + " println(\"[rank $rank] I am contributing with $sndbuf\")\n", + " MPI.Reduce!(sndbuf, rcvbuf, +, comm; root)\n", + " println(\"[rank $rank] The sum is $rcvbuf\")\n", + "end\n", + "run(`$(mpiexec()) -np 3 julia --project=. -e $code`);" + ] + }, + { + "cell_type": "markdown", + "id": "3ea77a8f", + "metadata": {}, + "source": [ + "## Reducing multiple values\n", + "\n", + "If more than one item is provided in the send buffers, `MPI_Reduce` does the reduction element by element.\n" + ] + }, + { + "cell_type": "markdown", + "id": "b26fd0b2", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "Each process generates 2 random integers. Take a look to the result of reduce. Note that the values have ben reduced \"element by element\". " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1a145948", + "metadata": {}, + "outputs": [], + "source": [ + "code = quote\n", + " using MPI\n", + " MPI.Init()\n", + " comm = MPI.COMM_WORLD\n", + " rank = MPI.Comm_rank(comm)\n", + " sndbuf = rand(1:4,2)\n", + " root = 0\n", + " if rank == root\n", + " rcvbuf = [0,0]\n", + " else\n", + " rcvbuf = nothing\n", + " end\n", + " println(\"[rank $rank] I am contributing with $sndbuf\")\n", + " MPI.Reduce!(sndbuf, rcvbuf, +, comm; root)\n", + " println(\"[rank $rank] The sum is $rcvbuf\")\n", + "end\n", + "run(`$(mpiexec()) -np 3 julia --project=. -e $code`);" + ] + }, + { + "cell_type": "markdown", + "id": "539df34f", + "metadata": {}, + "source": [ + "## MPI_Allreduce\n", + "\n", + "This is a variant of `MPI_Reduce` in which all processes get the result." + ] + }, + { + "cell_type": "markdown", + "id": "be0381bb", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "This is the same example as above, but all processes get the result." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1595f4f5", + "metadata": {}, + "outputs": [], + "source": [ + "code = quote\n", + " using MPI\n", + " MPI.Init()\n", + " comm = MPI.COMM_WORLD\n", + " rank = MPI.Comm_rank(comm)\n", + " sndbuf = rand(1:4,2)\n", + " # All ranks allocate a receive buffer\n", + " rcvbuf = [0,0]\n", + " println(\"[rank $rank] I am contributing with $sndbuf\")\n", + " MPI.Allreduce!(sndbuf, rcvbuf, +, comm)\n", + " println(\"[rank $rank] The sum is $rcvbuf\")\n", + "end\n", + "run(`$(mpiexec()) -np 3 julia --project=. -e $code`);" + ] + }, + { + "cell_type": "markdown", + "id": "97dc2886", + "metadata": {}, + "source": [ + "## MPI_Gather\n", + "\n", + "Each rank sends a message to the root rank (the root rank also sends a message to itself). The root rank receives all these values in a buffer (e.g. a vector). This function assumes that the amount of data sent from each rank is the same. The root process can be any process and it is rank 0 by default in Julia.\n", + "\n", + "In Julia:\n", + "```julia\n", + "MPI.Gather!(sendbuf, recvbuf, comm; root=0)\n", + "```\n", + "\n", + "In C:\n", + "```c\n", + "int MPI_Gather(const void *sendbuf, int sendcount, MPI_Datatype sendtype,\n", + " void *recvbuf, int recvcount, MPI_Datatype recvtype, int root,\n", + " MPI_Comm comm)\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "3d0a1e9d", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "Each process sends an integer to rank 0.\n" + ] + }, + { + "attachments": { + "g13884.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "4bdf9c02", + "metadata": {}, + "source": [ + "
    \n", + "\n", + "
    " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1f8a70c6", + "metadata": {}, + "outputs": [], + "source": [ + "code = quote\n", + " using MPI\n", + " MPI.Init()\n", + " comm = MPI.COMM_WORLD\n", + " rank = MPI.Comm_rank(comm)\n", + " msg = 10*(rank+2)\n", + " root = 0\n", + " sndbuf = [msg]\n", + " if rank == root\n", + " nranks = MPI.Comm_size(comm)\n", + " rcvbuf = zeros(Int,nranks)\n", + " else\n", + " # This can be anything as only the root process\n", + " # Will receive data\n", + " rcvbuf = nothing\n", + " end\n", + " println(\"[rank $rank] I am sending $sndbuf\")\n", + " MPI.Gather!(sndbuf, rcvbuf, comm; root)\n", + " println(\"[rank $rank] I received $rcvbuf\")\n", + "end\n", + "run(`$(mpiexec()) -np 3 julia --project=. -e $code`);" + ] + }, + { + "cell_type": "markdown", + "id": "0f85f08d", + "metadata": {}, + "source": [ + "## MPI_Allgather\n", + "\n", + "This is a variant of `MPI_Gather` in which all processes get the result." + ] + }, + { + "cell_type": "markdown", + "id": "4bf2ef34", + "metadata": {}, + "source": [ + "### Example" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "070e1fc1", + "metadata": {}, + "outputs": [], + "source": [ + "code = quote\n", + " using MPI\n", + " MPI.Init()\n", + " comm = MPI.COMM_WORLD\n", + " rank = MPI.Comm_rank(comm)\n", + " msg = 10*(rank+2)\n", + " sndbuf = [msg]\n", + " nranks = MPI.Comm_size(comm)\n", + " rcvbuf = zeros(Int,nranks)\n", + " println(\"[rank $rank] I am sending $sndbuf\")\n", + " MPI.Allgather!(sndbuf, rcvbuf, comm)\n", + " # All ranks receive the result\n", + " println(\"[rank $rank] I received $rcvbuf\")\n", + "end\n", + "run(`$(mpiexec()) -np 3 julia --project=. -e $code`);" + ] + }, + { + "cell_type": "markdown", + "id": "fb6a9034", + "metadata": {}, + "source": [ + "## MPI_Gatherv\n", + "\n", + "This function is similar to `MPI_Gather`, but it is used when there is a different amount of data sent from each process. There is also `MPI_Allgatherv` for which all processes will receive the result." + ] + }, + { + "cell_type": "markdown", + "id": "e0d2998c", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "Each processes sends `rank+1` integers to rank 0." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "23814278", + "metadata": {}, + "outputs": [], + "source": [ + "code = quote\n", + " using MPI\n", + " MPI.Init()\n", + " comm = MPI.COMM_WORLD\n", + " rank = MPI.Comm_rank(comm)\n", + " sndbuf = fill(10*rank,rank+1)\n", + " root = 0\n", + " if rank == root\n", + " nranks = MPI.Comm_size(comm)\n", + " # Define the amount of data to be received\n", + " # from each rank\n", + " counts = [ rank+1 for rank in 0:(nranks-1)]\n", + " # Total amount of receive data\n", + " ndata = sum(counts)\n", + " data = zeros(Int,ndata)\n", + " rcvbuf = MPI.VBuffer(data,counts)\n", + " else\n", + " # This can be anything as only the root process\n", + " # Will receive data\n", + " rcvbuf = nothing\n", + " end\n", + " println(\"[rank $rank] I am sending $sndbuf\")\n", + " MPI.Gatherv!(sndbuf, rcvbuf, comm; root)\n", + " if rank == root\n", + " println(\"[rank $rank] I received $data\")\n", + " end\n", + "end\n", + "run(`$(mpiexec()) -np 4 julia --project=. -e $code`);" + ] + }, + { + "cell_type": "markdown", + "id": "25c2fb1e", + "metadata": {}, + "source": [ + "## How to get the amount of data to be received?\n", + "\n", + "Remember that `MPI_Probe` allows you to query the amount of data to be received with `MPI_Recv`. Unfortunately, this mechanism does not work for MPI collectives. A workaround is to first communicate the amount of data to be gathered, allocate the receive buffer accordingly, and then communicate the actual message.\n" + ] + }, + { + "cell_type": "markdown", + "id": "12f9e2ca", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "Each process sends a random amount of integers to rank 0." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b10430a9", + "metadata": {}, + "outputs": [], + "source": [ + "code = quote\n", + " using MPI\n", + " MPI.Init()\n", + " comm = MPI.COMM_WORLD\n", + " rank = MPI.Comm_rank(comm)\n", + " # Get number of ints to send\n", + " count = rand(1:4)\n", + " # Generate data to send\n", + " sndbuf = fill(rank,count)\n", + " # Communicate counts\n", + " root = 0\n", + " if rank == root\n", + " nranks = MPI.Comm_size(comm)\n", + " counts = zeros(Int,nranks)\n", + " else\n", + " counts = nothing\n", + " end\n", + " MPI.Gather!([count], counts, comm; root)\n", + " # Allocate receive buffer\n", + " if rank == root\n", + " ndata = sum(counts)\n", + " data = zeros(Int,ndata)\n", + " rcvbuf = MPI.VBuffer(data,counts)\n", + " else\n", + " rcvbuf = nothing\n", + " end\n", + " # Communicate data\n", + " println(\"[rank $rank] I am sending $sndbuf\")\n", + " MPI.Gatherv!(sndbuf, rcvbuf, comm; root)\n", + " if rank == root\n", + " println(\"[rank $rank] I received $data\")\n", + " end\n", + "end\n", + "run(`$(mpiexec()) -np 4 julia --project=. -e $code`);" + ] + }, + { + "cell_type": "markdown", + "id": "8b4254d1", + "metadata": {}, + "source": [ + "## MPI_Scatter\n", + "\n", + "This is the inverse operation of `MPI_Gather`. The root rank sends a distinct message to each rank.\n", + "\n", + "In Julia:\n", + "```julia\n", + "MPI.Scatter!(sendbuf, recvbuf, comm; root=0)\n", + "```\n", + "\n", + "In C:\n", + "```c\n", + "int MPI_Scatter(const void *sendbuf, int sendcount, MPI_Datatype sendtype,\n", + " void *recvbuf, int recvcount, MPI_Datatype recvtype, int root,\n", + " MPI_Comm comm)\n", + "```\n", + "\n", + "
    \n", + "Note: `MPI_Scatter` sends the same amount of data to each rank. To send a variable amount of data there is `MPI_Scatterv` (`MPI.Scatterv!` in julia), which works similar to `MPI_Gatherv`. \n", + "
    \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "e55aa353", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "Rank 0 sends a unique integer to each rank. " + ] + }, + { + "attachments": { + "g13389.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "74d5b606", + "metadata": {}, + "source": [ + "
    \n", + "\n", + "
    " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5ea413fd", + "metadata": {}, + "outputs": [], + "source": [ + "code = quote\n", + " using MPI\n", + " MPI.Init()\n", + " comm = MPI.COMM_WORLD\n", + " nranks = MPI.Comm_size(comm)\n", + " rank = MPI.Comm_rank(comm)\n", + " root = 0\n", + " rcv = Ref(0) \n", + " if rank == root\n", + " snd = [10*(i+1) for i in 1:nranks]\n", + " println(\"[rank $rank] I am sending: $snd\")\n", + " else\n", + " # Only the root rank sends data\n", + " # so this can be anything\n", + " snd = nothing\n", + " end \n", + " MPI.Scatter!(snd,rcv,comm;root)\n", + " println(\"[rank $rank] I have received: $(rcv[])\")\n", + "end\n", + "run(`$(mpiexec()) -np 4 julia --project=. -e $code`);" + ] + }, + { + "cell_type": "markdown", + "id": "ed8da7f9", + "metadata": {}, + "source": [ + "## MPI_Bcast\n", + "\n", + "Similar to `MPI_Scatter`, but we send the same message to all processes.\n", + "\n", + "In Julia:\n", + "```julia\n", + "MPI.Bcast!(buf, comm; root)\n", + "```\n", + "\n", + "In C:\n", + "```c\n", + "int MPI_Bcast(void *buffer, int count, MPI_Datatype datatype,\n", + " int root, MPI_Comm comm)\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "id": "97369713", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "Rank 0 sends the same integer to all processes." + ] + }, + { + "attachments": { + "g1657.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "26b56c81", + "metadata": {}, + "source": [ + "
    \n", + "\n", + "
    " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4de15781", + "metadata": {}, + "outputs": [], + "source": [ + "code = quote\n", + " using MPI\n", + " MPI.Init()\n", + " comm = MPI.COMM_WORLD\n", + " nranks = MPI.Comm_size(comm)\n", + " rank = MPI.Comm_rank(comm)\n", + " root = 0\n", + " buffer = Ref(0)\n", + " if rank == root\n", + " buffer[] = 20\n", + " println(\"[rank $rank] I am sending: $(buffer[])\")\n", + " end \n", + " MPI.Bcast!(buffer,comm;root)\n", + " println(\"[rank $rank] I have received: $(buffer[])\")\n", + "end\n", + "run(`$(mpiexec()) -np 4 julia --project=. -e $code`);" + ] + }, + { + "cell_type": "markdown", + "id": "e83be96d", + "metadata": {}, + "source": [ + "## Communicators\n", + "\n", + "A key component in MPI programming are so-called communicators. A communicator object has to main purposes:\n", + "\n", + "\n", + "1. To provide an isolated communication context\n", + "2. To define a group of processes\n", + "\n", + "\n", + "### Communication context\n", + "\n", + "When you write an MPI program it is very likely that you are going to use libraries that also use MPI to send messages. Ideally, these libraries should not interfere with application messages. Using tags to isolate the messages send by your application does not solve the problem. MPI communicators fix this problem as they provided an isolated communication context. For instance, `MPI_SEND` and `MPI_RECV` specify a communicator. `MPI_RECV` can only receive messages sent to same communicator. The same is also true for collective communication directives. If two libraries use different communicators, their message will never interfere. In particular it is recommended to never use the default communicator, `MPI_COMM_WORLD`, directly when working with other libraries. A new isolated communicator can be created with `MPI_Comm_dup`.\n", + "\n", + "\n", + "### Process groups\n", + "\n", + "On the other hand, imagine that we want to use an MPI communication directive like `MPI_Gather`, but we only want a subset of the processes to participate in the operation. So far, we have used always the default communication `MPI_COMM_WORLD`, which represents all processes. Thus, by using this communicator, we are including all processes in the operation. We can create other communicators that contain only a subset of processes. To this end, we can use function `MPI_Comm_split`.\n" + ] + }, + { + "cell_type": "markdown", + "id": "556ca223", + "metadata": {}, + "source": [ + "## MPI_Comm_dup\n", + "\n", + "Duplicate a given communicator, creating a new one with an new communication context.\n", + "\n", + "\n", + "In Julia:\n", + "```julia\n", + "newcomm = MPI.Comm_dup(comm)\n", + "```\n", + "\n", + "In C:\n", + "```c\n", + "int MPI_Comm_dup(MPI_Comm comm, MPI_Comm *newcomm)\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "9acfb792", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "Send value 2 from rank 2 to rank 3. Then send value 1 also from rank 2 to rank 3. Note that we are using 2 different communicators for each send receive pair in such a way that we first receive value 1 and then value 2, even if this not was the other in which the data was sent. Try also to define `comm2 = comm` and see how the result will change." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e50d44f6", + "metadata": {}, + "outputs": [], + "source": [ + "code = quote\n", + " using MPI\n", + " MPI.Init()\n", + " comm = MPI.COMM_WORLD\n", + " # We create a new communicator\n", + " comm2 = MPI.Comm_dup(comm)\n", + " rank = MPI.Comm_rank(comm)\n", + " if rank == 2\n", + " sndbuf = [2]\n", + " MPI.Send(sndbuf, comm2; dest=3, tag=0)\n", + " sndbuf = [1]\n", + " MPI.Send(sndbuf, comm; dest=3, tag=0)\n", + " end\n", + " if rank == 3\n", + " rcvbuf = zeros(Int,1)\n", + " MPI.Recv!(rcvbuf, comm; source=2, tag=0)\n", + " @show rcvbuf\n", + " MPI.Recv!(rcvbuf, comm2; source=2, tag=0)\n", + " @show rcvbuf\n", + " end\n", + "end\n", + "run(`$(mpiexec()) -np 4 julia --project=. -e $code`);" + ] + }, + { + "cell_type": "markdown", + "id": "5e1b13eb", + "metadata": {}, + "source": [ + "## MPI_Comm_split\n", + "\n", + "Split a given communicator.\n", + "\n", + "\n", + "In Julia:\n", + "\n", + "```julia\n", + "newcomm = MPI.Comm_split(comm, color, key)\n", + "```\n", + "\n", + "In C:\n", + "```c\n", + "int MPI_Comm_split(MPI_Comm comm, int color, int key,\n", + " MPI_Comm *newcomm)\n", + "```\n", + "\n", + "There are two key parameters:\n", + "\n", + "- `color`: all processes with the same color will be grouped in the same communicator.\n", + "- `key`: The processes will be ranked in the new communicator according to key, breaking ties with the rank in the old communicator. \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "2b128840", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "Create two groups of processes, one for processes with rank id even, and another for the rest. Note that the rank id will be function of the given communicator." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b18cb74d", + "metadata": {}, + "outputs": [], + "source": [ + "code = quote\n", + " using MPI\n", + " MPI.Init()\n", + " comm = MPI.COMM_WORLD\n", + " rank = MPI.Comm_rank(comm)\n", + " color = mod(rank,2)\n", + " key = 0\n", + " newcomm = MPI.Comm_split(comm, color, key)\n", + " newrank = MPI.Comm_rank(newcomm)\n", + " println(\"Hello, I am rank $rank in world and rank $newrank in group $color.\")\n", + "end\n", + "run(`$(mpiexec()) -np 4 julia --project=. -e $code`);" + ] + }, + { + "cell_type": "markdown", + "id": "b22e4bf4", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "Processes with odd rank id generate a random integer. Sum all these integers and send them to the first process with odd rank id. Note that we are using a new communicator to perform the reduction." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4c0e504b", + "metadata": {}, + "outputs": [], + "source": [ + "code = quote\n", + " using MPI\n", + " MPI.Init()\n", + " comm = MPI.COMM_WORLD\n", + " rank = MPI.Comm_rank(comm)\n", + " color = mod(rank,2)\n", + " key = 0\n", + " newcomm = MPI.Comm_split(comm, color, key)\n", + " # Only odd rank ids will execute this\n", + " if color == 1\n", + " newrank = MPI.Comm_rank(newcomm)\n", + " newroot = 0\n", + " sndbuf = [rand(1:4)]\n", + " if newrank == newroot\n", + " rcvbuf = [0]\n", + " else\n", + " rcvbuf = nothing\n", + " end\n", + " println(\"[rank $rank, newrank $newrank] I am contributing with $sndbuf\")\n", + " MPI.Reduce!(sndbuf, rcvbuf, +, newcomm;root=newroot)\n", + " println(\"[rank $rank, newrank $newrank] The sum is $rcvbuf\")\n", + " end\n", + "end\n", + "run(`$(mpiexec()) -np 4 julia --project=. -e $code`);" + ] + }, + { + "cell_type": "markdown", + "id": "5e8f6e6a", + "metadata": {}, + "source": [ + "# License\n", + "\n", + "This notebook is part of the course [Programming Large Scale Parallel Systems](https://www.francescverdugo.com/XM_40017) at Vrije Universiteit Amsterdam and may be used under a [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) license." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.9.0", + "language": "julia", + "name": "julia-1.9" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/dev/mpi_collectives/index.html b/dev/mpi_collectives/index.html new file mode 100644 index 0000000..ca6d77b --- /dev/null +++ b/dev/mpi_collectives/index.html @@ -0,0 +1,17 @@ + +- · XM_40017
    +
    Tip
    +
    +
      +
    • + Download this notebook and run it locally on your machine [highly recommended]. Click here. +
      • +
    +
    +
    +
    diff --git a/dev/mpi_collectives_src/index.html b/dev/mpi_collectives_src/index.html new file mode 100644 index 0000000..6bcdb86 --- /dev/null +++ b/dev/mpi_collectives_src/index.html @@ -0,0 +1,8437 @@ + + + + + +mpi_collectives + + + + + + + + + + + + + + +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + + diff --git a/dev/mpi_tutorial/index.html b/dev/mpi_tutorial/index.html index 2d326ba..e4d146b 100644 --- a/dev/mpi_tutorial/index.html +++ b/dev/mpi_tutorial/index.html @@ -14,4 +14,4 @@ var myIframe = document.getElementById("notebook"); iFrameResize({log:true}, myIframe); }); - + diff --git a/dev/notebook-hello/index.html b/dev/notebook-hello/index.html index 9de1d19..109c017 100644 --- a/dev/notebook-hello/index.html +++ b/dev/notebook-hello/index.html @@ -14,4 +14,4 @@ var myIframe = document.getElementById("notebook"); iFrameResize({log:true}, myIframe); }); - + diff --git a/dev/objects.inv b/dev/objects.inv index a86aaa9..214e912 100644 Binary files a/dev/objects.inv and b/dev/objects.inv differ diff --git a/dev/pdes/index.html b/dev/pdes/index.html index bdc884f..9a9fc42 100644 --- a/dev/pdes/index.html +++ b/dev/pdes/index.html @@ -14,4 +14,4 @@ var myIframe = document.getElementById("notebook"); iFrameResize({log:true}, myIframe); }); - + diff --git a/dev/search_index.js b/dev/search_index.js index 281f3de..478ee03 100644 --- a/dev/search_index.js +++ b/dev/search_index.js @@ -1,3 +1,3 @@ var documenterSearchIndex = {"docs": -[{"location":"getting_started_with_julia/#Getting-started","page":"Getting started","title":"Getting started","text":"","category":"section"},{"location":"getting_started_with_julia/#Introduction","page":"Getting started","title":"Introduction","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The programming of this course will be done using the Julia programming language. Thus, we start by explaining how to get up and running with Julia. After studying this page, you will be able to:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Use the Julia REPL,\nRun serial and parallel code,\nInstall and manage Julia packages.","category":"page"},{"location":"getting_started_with_julia/#Why-Julia?","page":"Getting started","title":"Why Julia?","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Courses related with high-performance computing (HPC) often use languages such as C, C++, or Fortran. We use Julia instead to make the course accessible to a wider set of students, including the ones that have no experience with C/C++ or Fortran, but are willing to learn parallel programming. Julia is a relatively new programming language specifically designed for scientific computing. It combines a high-level syntax close to interpreted languages like Python with the performance of compiled languages like C, C++, or Fortran. Thus, Julia will allow us to write efficient parallel algorithms with a syntax that is convenient in a teaching setting. In addition, Julia provides easy access to different programming models to write distributed algorithms, which will be useful to learn and experiment with them.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"tip: Tip\nYou can run the code in this link to learn how Julia compares to other languages (C and Python) in terms of performance.","category":"page"},{"location":"getting_started_with_julia/#Installing-Julia","page":"Getting started","title":"Installing Julia","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"This is a tutorial-like page. Follow these steps before you continue reading the document.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Download and install Julia from julialang.org;\nFollow the specific instructions for your operating system: Windows, MacOS, or Linux\nDownload and install VSCode and its Julia extension;","category":"page"},{"location":"getting_started_with_julia/#The-Julia-REPL","page":"Getting started","title":"The Julia REPL","text":"","category":"section"},{"location":"getting_started_with_julia/#Starting-Julia","page":"Getting started","title":"Starting Julia","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"There are several ways of opening Julia depending on your operating system and your IDE, but it is usually as simple as launching the Julia app. With VSCode, open a folder (File > Open Folder). Then, press Ctrl+Shift+P to open the command bar, and execute Julia: Start REPL. If this does not work, make sure you have the Julia extension for VSCode installed. Independently of the method you use, opening Julia results in a window with some text ending with:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia>","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You have just opened the Julia read-evaluate-print loop, or simply the Julia REPL. Congrats! You will spend most of time using the REPL, when working in Julia. The REPL is a console waiting for user input. Just as in other consoles, the string of text right before the input area (julia> in the case) is called the command prompt or simply the prompt.","category":"page"},{"location":"getting_started_with_julia/#Basic-usage","page":"Getting started","title":"Basic usage","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The usage of the REPL is as follows:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You write some input\npress enter\nyou get the output","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"For instance, try this","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> 1 + 1","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"A \"Hello world\" example looks like this in Julia","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> println(\"Hello, world!\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Try to run it in the REPL.","category":"page"},{"location":"getting_started_with_julia/#Help-mode","page":"Getting started","title":"Help mode","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Curious about what the function println does? Enter into help mode to look into the documentation. This is done by typing a question mark (?) into the input field:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> ?","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"After typing ?, the command prompt changes to help?>. It means we are in help mode. Now, we can type a function name to see its documentation.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"help?> println","category":"page"},{"location":"getting_started_with_julia/#Package-and-shell-modes","page":"Getting started","title":"Package and shell modes","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The REPL comes with two more modes, namely package and shell modes. To enter package mode type","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> ]","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Package mode is used to install and manage packages. We are going to discuss the package mode in greater detail later. To return back to normal mode press the backspace key several times.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"To enter shell mode type semicolon (;)","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> ;","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The prompt should have changed to shell> indicating that we are in shell mode. Now you can type commands that you would normally do on your system command line. For instance,","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"shell> ls","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"will display the contents of the current folder in Mac or Linux. Using shell mode in Windows is not straightforward, and thus not recommended for beginners.","category":"page"},{"location":"getting_started_with_julia/#Running-Julia-code","page":"Getting started","title":"Running Julia code","text":"","category":"section"},{"location":"getting_started_with_julia/#Running-more-complex-code","page":"Getting started","title":"Running more complex code","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Real-world Julia programs are not typed in the REPL in practice. They are written in one or more files and included in the REPL. To try this, create a new file called hello.jl, write the code of the \"Hello world\" example above, and save it. If you are using VSCode, you can create the file using File > New File > Julia File. Once the file is saved with the name hello.jl, execute it as follows","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> include(\"hello.jl\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"warning: Warning\nMake sure that the file \"hello.jl\" is located in the current working directory of your Julia session. You can query the current directory with function pwd(). You can change to another directory with function cd() if needed. Also, make sure that the file extension is .jl.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The recommended way of running Julia code is using the REPL as we did. But it is also possible to run code directly from the system command line. To this end, open a terminal and call Julia followed by the path to the file containing the code you want to execute.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"$ julia hello.jl","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The previous line assumes that you have Julia properly installed in the system and that it's usable from the terminal. In UNIX systems (Linux and Mac), the Julia binary needs to be in one of the directories listed in the PATH environment variable. To check that Julia is properly installed, you can use","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"$ julia --version","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"If this runs without error and you see a version number, you are good to go!","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"note: Note\nIn this tutorial, when a code snipped starts with $, it should be run in the terminal. Otherwise, the code is to be run in the Julia REPL.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"tip: Tip\nAvoid calling Julia code from the terminal, use the Julia REPL instead! Each time you call Julia from the terminal, you start a fresh Julia session and Julia will need to compile your code from scratch. This can be time consuming for large projects. In contrast, if you execute code in the REPL, Julia will compile code incrementally, which is much faster. Running code in a cluster (like in DAS-5 for the Julia assignment) is among the few situations you need to run Julia code from the terminal. Visit this link (Julia workflow tips) from the official Julia documentation for further information about how to develop Julia code effectivelly.","category":"page"},{"location":"getting_started_with_julia/#Running-parallel-code","page":"Getting started","title":"Running parallel code","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Since we are in a parallel computing course, let's run a parallel \"Hello world\" example in Julia. Open a Julia REPL and write","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> using Distributed\njulia> @everywhere println(\"Hello, world! I am proc $(myid()) from $(nprocs())\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Here, we are using the Distributed package, which is part of the Julia standard library that provides distributed memory parallel support. The code prints the process id and the number of processes in the current Julia session.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You will probably only see output from 1 process. We need to add more processes to run the example in parallel. This is done with the addprocs function.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> addprocs(3)","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"We have added 3 new processes. Plus the old one, we have 4 processes. Run the code again.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> @everywhere println(\"Hello, world! I am proc $(myid()) from $(nprocs())\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Now, you should see output from 4 processes.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"It is possible to specify the number of processes when starting Julia from the terminal with the -p argument (useful, e.g., when running in a cluster). If you launch Julia from the terminal as","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"$ julia -p 3","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"and then run","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> @everywhere println(\"Hello, world! I am proc $(myid()) from $(nprocs())\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You should get output from 4 processes as before.","category":"page"},{"location":"getting_started_with_julia/#Installing-packages","page":"Getting started","title":"Installing packages","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"One of the most useful features of Julia is its package manager. It allows one to install Julia packages in a straightforward and platform independent way. To illustrate this, let us consider the following parallel \"Hello world\" example. This example uses the Message Passing Interface (MPI). We will learn more about MPI later in the course.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Copy the following block of code into a new file named \"hello_mpi.jl\"","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"# file hello_mpi.jl\nusing MPI\nMPI.Init()\ncomm = MPI.COMM_WORLD\nrank = MPI.Comm_rank(comm)\nnranks = MPI.Comm_size(comm)\nprintln(\"Hello world, I am rank $rank of $nranks\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"As you can see from this example, one can access MPI from Julia in a clean way, without type annotations and other complexities of C/C++ code.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Now, run the file from the REPL","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> include(\"hello_mpi.jl\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"It probably didn't work, right? Read the error message and note that the MPI package needs to be installed to run this code.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"To install a package, we need to enter package mode. Remember that we entered into help mode by typing ?. Package mode is activated by typing ] : ","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> ]","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"At this point, the prompt should have changed to (@v1.10) pkg> indicating that we are in package mode. The text between the parentheses indicates which is the active project, i.e., where packages are going to be installed. In this case, we are working with the global project associated with our Julia installation (which is Julia 1.10 in this example, but it can be another version in your case).","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"To install the MPI package, type","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> add MPI","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Congrats, you have installed MPI!","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"note: Note\nMany Julia package names end with .jl. This is just a way of signaling that a package is written in Julia. When using such packages, the .jl needs to be omitted. In this case, we have installed the MPI.jl package even though we have only typed MPI in the REPL.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"note: Note\nThe package you have installed is the Julia interface to MPI, called MPI.jl. Note that it is not a MPI library by itself. It is just a thin wrapper between MPI and Julia. To use this interface, you need an actual MPI library installed in your system such as OpenMPI or MPICH. Julia downloads and installs a MPI library for you, but it is also possible to use a MPI library already available in your system. This is useful, e.g., when running on HPC clusters. See the documentation of MPI.jl for further details.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"To check that the package was installed properly, exit package mode by pressing the backspace key several times, and run it again","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> include(\"hello_mpi.jl\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Now, it should work, but you probably get output from a single MPI rank only.","category":"page"},{"location":"getting_started_with_julia/#Running-MPI-code","page":"Getting started","title":"Running MPI code","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"To run MPI applications in parallel, you need a launcher like mpiexec. MPI codes written in Julia are not an exception to this rule. From the system terminal, you can run","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"$ mpiexec -np 4 julia hello_mpi.jl","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"But it will probably not work since the version of mpiexec needs to match with the MPI version we are using from Julia. Don't worry if you could not make it work! A more elegant way to run MPI code is from the Julia REPL directly, by using these commands:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> using MPI\njulia> run(`$(mpiexec()) -np 4 julia hello_mpi.jl`)","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Now, you should see output from 4 ranks.","category":"page"},{"location":"getting_started_with_julia/#Package-manager","page":"Getting started","title":"Package manager","text":"","category":"section"},{"location":"getting_started_with_julia/#Installing-packages-locally","page":"Getting started","title":"Installing packages locally","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"We have installed the MPI package globally and it will be available in all Julia sessions. However, in some situations, we want to work with different versions of the same package or to install packages in an isolated way to avoid potential conflicts with other packages. This can be done by using local projects.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"A project is simply a folder in your file system. To use a particular folder as your project, you need to activate it. This is done by entering package mode and using the activate command followed by the path to the folder you want to activate.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> activate .","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The previous command will activate the current working directory. Note that the dot . is indeed the path to the current folder.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The prompt has changed to (lessons) pkg> indicating that we are in the project within the lessons folder. The particular folder name can be different in your case.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"tip: Tip\nYou can activate a project directly when opening Julia from the terminal using the --project flag. The command $ julia --project=. will open Julia and activate a project in the current directory. You can also achieve the same effect by setting the environment variable JULIA_PROJECT with the path of the folder you want to activate.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"note: Note\nThe active project folder and the current working directory are two independent concepts! For instance, (@v1.10) pkg> activate folderB and then julia> cd(\"folderA\"), will activate the project in folderB and change the current working directory to folderA.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"At this point all package-related operations will be local to the new project. For instance, install the DataFrames package.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(lessons) pkg> add DataFrames","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Use the package to check that it is installed","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> using DataFrames\njulia> DataFrame(a=[1,2],b=[3,4])","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Now, we can return to the global project to check that DataFrames has not been installed there. To return to the global environment, use activate without a folder name.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(lessons) pkg> activate","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The prompt is again (@v1.10) pkg>","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Now, try to use DataFrames.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> using DataFrames\njulia> DataFrame(a=[1,2],b=[3,4])","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You should get an error or a warning unless you already had DataFrames installed globally.","category":"page"},{"location":"getting_started_with_julia/#Project-and-Manifest-files","page":"Getting started","title":"Project and Manifest files","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The information about a project is stored in two files Project.toml and Manifest.toml.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Project.toml contains the packages explicitly installed (the direct dependencies)\nManifest.toml contains direct and indirect dependencies along with the concrete version of each package.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"In other words, Project.toml contains the packages relevant for the user, whereas Manifest.toml is the detailed snapshot of all dependencies. The Manifest.toml can be used to reproduce the same environment in another machine.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You can see the path to the current Project.toml file by using the status operator (or st in its short form) while in package mode","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> status","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The information about the Manifest.toml can be inspected by passing the -m flag.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> status -m","category":"page"},{"location":"getting_started_with_julia/#Installing-packages-from-a-project-file","page":"Getting started","title":"Installing packages from a project file","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Project files can be used to install lists of packages defined by others. E.g., to install all the dependencies of a Julia application.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Assume that a colleague has sent to you a Project.toml file with this content:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"[deps]\nBenchmarkTools = \"6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf\"\nDataFrames = \"a93c6f00-e57d-5684-b7b6-d8193f3e46c0\"\nMPI = \"da04e1cc-30fd-572f-bb4f-1f8673147195\"","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Copy the contents of previous code block into a file called Project.toml and place it in an empty folder named newproject. It is important that the file is named Project.toml. You can create a new folder from the REPL with","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> mkdir(\"newproject\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"To install all the packages registered in this file you need to activate the folder containing your Project.toml file","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> activate newproject","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"and then instantiating it","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(newproject) pkg> instantiate","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The instantiate command will download and install all listed packages and their dependencies in just one click.","category":"page"},{"location":"getting_started_with_julia/#Getting-help-in-package-mode","page":"Getting started","title":"Getting help in package mode","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You can get help about a particular package operator by writing help in front of it","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> help activate","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You can get an overview of all package commands by typing help alone","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> help","category":"page"},{"location":"getting_started_with_julia/#Package-operations-in-Julia-code","page":"Getting started","title":"Package operations in Julia code","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"In some situations it is required to use package commands in Julia code, e.g., to automatize installation and deployment of Julia applications. This can be done using the Pkg package. For instance","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> using Pkg\njulia> Pkg.status()","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"is equivalent to calling status in package mode.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> status","category":"page"},{"location":"getting_started_with_julia/#Conclusion","page":"Getting started","title":"Conclusion","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"We have learned the basics of how to work with Julia. If you want to further dig into the topics we have covered here, you can take a look at the following links:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Julia Manual\nPackage manager","category":"page"},{"location":"tsp/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/tsp.ipynb\"","category":"page"},{"location":"tsp/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"tsp/","page":"-","title":"-","text":"\n","category":"page"},{"location":"jacobi_2D/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/jacobi_2D.ipynb\"","category":"page"},{"location":"jacobi_2D/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"jacobi_2D/","page":"-","title":"-","text":"\n","category":"page"},{"location":"julia_async/","page":"Asynchronous programming in Julia","title":"Asynchronous programming in Julia","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/julia_async.ipynb\"","category":"page"},{"location":"julia_async/","page":"Asynchronous programming in Julia","title":"Asynchronous programming in Julia","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"julia_async/","page":"Asynchronous programming in Julia","title":"Asynchronous programming in Julia","text":"\n","category":"page"},{"location":"solutions/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/solutions.ipynb\"","category":"page"},{"location":"solutions/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"solutions/","page":"-","title":"-","text":"\n","category":"page"},{"location":"pdes/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/pdes.ipynb\"","category":"page"},{"location":"pdes/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"pdes/","page":"-","title":"-","text":"\n","category":"page"},{"location":"LEQ/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/LEQ.ipynb\"","category":"page"},{"location":"LEQ/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"LEQ/","page":"-","title":"-","text":"\n","category":"page"},{"location":"julia_distributed/","page":"Distributed computing in Julia","title":"Distributed computing in Julia","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/julia_distributed.ipynb\"","category":"page"},{"location":"julia_distributed/","page":"Distributed computing in Julia","title":"Distributed computing in Julia","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"julia_distributed/","page":"Distributed computing in Julia","title":"Distributed computing in Julia","text":"\n","category":"page"},{"location":"julia_jacobi/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/julia_jacobi.ipynb\"","category":"page"},{"location":"julia_jacobi/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"julia_jacobi/","page":"-","title":"-","text":"\n","category":"page"},{"location":"julia_tutorial/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/julia_tutorial.ipynb\"","category":"page"},{"location":"julia_tutorial/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"julia_tutorial/","page":"-","title":"-","text":"\n","category":"page"},{"location":"mpi_tutorial/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/mpi_tutorial.ipynb\"","category":"page"},{"location":"mpi_tutorial/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"mpi_tutorial/","page":"-","title":"-","text":"\n","category":"page"},{"location":"notebook-hello/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/notebook-hello.ipynb\"","category":"page"},{"location":"notebook-hello/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"notebook-hello/","page":"-","title":"-","text":"\n","category":"page"},{"location":"julia_intro/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/julia_intro.ipynb\"","category":"page"},{"location":"julia_intro/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"julia_intro/","page":"-","title":"-","text":"\n","category":"page"},{"location":"jacobi_method/","page":"Jacobi method","title":"Jacobi method","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/jacobi_method.ipynb\"","category":"page"},{"location":"jacobi_method/","page":"Jacobi method","title":"Jacobi method","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"jacobi_method/","page":"Jacobi method","title":"Jacobi method","text":"\n","category":"page"},{"location":"solutions_for_all_notebooks/#Solutions","page":"Solutions","title":"Solutions","text":"","category":"section"},{"location":"solutions_for_all_notebooks/#Julia-Basics","page":"Solutions","title":"Julia Basics","text":"","category":"section"},{"location":"solutions_for_all_notebooks/#Exercise-1","page":"Solutions","title":"Exercise 1","text":"","category":"section"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"function ex1(a)\n j = 1\n m = a[j]\n for (i,ai) in enumerate(a)\n if m < ai\n m = ai\n j = i\n end\n end\n (m,j)\nend","category":"page"},{"location":"solutions_for_all_notebooks/#Exercise-2","page":"Solutions","title":"Exercise 2","text":"","category":"section"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"ex2(f,g) = x -> f(x) + g(x)","category":"page"},{"location":"solutions_for_all_notebooks/#Exercise-3","page":"Solutions","title":"Exercise 3","text":"","category":"section"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"using GLMakie\nmax_iters = 100\nn = 1000\nx = LinRange(-1.7,0.7,n)\ny = LinRange(-1.2,1.2,n)\nheatmap(x,y,(i,j)->mandel(i,j,max_iters))","category":"page"},{"location":"solutions_for_all_notebooks/#Asynchronous-programming-in-Julia","page":"Solutions","title":"Asynchronous programming in Julia","text":"","category":"section"},{"location":"solutions_for_all_notebooks/#Distributed-computing-in-Julia","page":"Solutions","title":"Distributed computing in Julia","text":"","category":"section"},{"location":"solutions_for_all_notebooks/#Exercise-1-2","page":"Solutions","title":"Exercise 1","text":"","category":"section"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"f = () -> Channel{Int}(1)\nchnls = [ RemoteChannel(f,w) for w in workers() ]\n@sync for (iw,w) in enumerate(workers())\n @spawnat w begin\n chnl_snd = chnls[iw]\n if w == 2\n chnl_rcv = chnls[end]\n msg = 2\n println(\"msg = $msg\")\n put!(chnl_snd,msg)\n msg = take!(chnl_rcv)\n println(\"msg = $msg\")\n else\n chnl_rcv = chnls[iw-1]\n msg = take!(chnl_rcv)\n msg += 1\n println(\"msg = $msg\")\n put!(chnl_snd,msg)\n end\n end\nend","category":"page"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"This is another possible solution.","category":"page"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"@everywhere function work(msg)\n println(\"msg = $msg\")\n if myid() != nprocs()\n next = myid() + 1\n @fetchfrom next work(msg+1)\n else\n @fetchfrom 2 println(\"msg = $msg\")\n end\nend\nmsg = 2\n@fetchfrom 2 work(msg)","category":"page"},{"location":"solutions_for_all_notebooks/#Matrix-matrix-multiplication","page":"Solutions","title":"Matrix-matrix multiplication","text":"","category":"section"},{"location":"solutions_for_all_notebooks/#Exercise-1-3","page":"Solutions","title":"Exercise 1","text":"","category":"section"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"function matmul_dist_3!(C,A,B)\n m = size(C,1)\n n = size(C,2)\n l = size(A,2)\n @assert size(A,1) == m\n @assert size(B,2) == n\n @assert size(B,1) == l\n @assert mod(m,nworkers()) == 0\n nrows_w = div(m,nworkers())\n @sync for (iw,w) in enumerate(workers())\n lb = 1 + (iw-1)*nrows_w\n ub = iw*nrows_w\n A_w = A[lb:ub,:]\n ftr = @spawnat w begin\n C_w = similar(A_w)\n matmul_seq!(C_w,A_w,B)\n C_w\n end\n @async C[lb:ub,:] = fetch(ftr)\n end\n C\nend\n\n@everywhere function matmul_seq!(C,A,B)\n m = size(C,1)\n n = size(C,2)\n l = size(A,2)\n @assert size(A,1) == m\n @assert size(B,2) == n\n @assert size(B,1) == l\n z = zero(eltype(C))\n for j in 1:n\n for i in 1:m\n Cij = z\n for k in 1:l\n @inbounds Cij = Cij + A[i,k]*B[k,j]\n end\n C[i,j] = Cij\n end\n end\n C\nend","category":"page"},{"location":"solutions_for_all_notebooks/#MPI-(Point-to-point)","page":"Solutions","title":"MPI (Point-to-point)","text":"","category":"section"},{"location":"solutions_for_all_notebooks/#Exercise-2-2","page":"Solutions","title":"Exercise 2","text":"","category":"section"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"using MPI\nMPI.Init()\ncomm = MPI.COMM_WORLD\nrank = MPI.Comm_rank(comm)\nnranks = MPI.Comm_size(comm)\nbuffer = Ref(0)\nif rank == 0\n msg = 2\n buffer[] = msg\n println(\"msg = $(buffer[])\")\n MPI.Send(buffer,comm;dest=rank+1,tag=0)\n MPI.Recv!(buffer,comm;source=nranks-1,tag=0)\n println(\"msg = $(buffer[])\")\nelse\n dest = if (rank != nranks-1)\n rank+1\n else\n 0\n end\n MPI.Recv!(buffer,comm;source=rank-1,tag=0)\n buffer[] += 1\n println(\"msg = $(buffer[])\")\n MPI.Send(buffer,comm;dest,tag=0)\nend","category":"page"},{"location":"solutions_for_all_notebooks/#Jacobi-method","page":"Solutions","title":"Jacobi method","text":"","category":"section"},{"location":"solutions_for_all_notebooks/#Exercise-1-4","page":"Solutions","title":"Exercise 1","text":"","category":"section"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"function jacobi_mpi(n,niters)\n comm = MPI.COMM_WORLD\n nranks = MPI.Comm_size(comm)\n rank = MPI.Comm_rank(comm)\n if mod(n,nranks) != 0\n println(\"n must be a multiple of nranks\")\n MPI.Abort(comm,1)\n end\n load = div(n,nranks)\n u = zeros(load+2)\n u[1] = -1\n u[end] = 1\n u_new = copy(u)\n for t in 1:niters\n reqs = MPI.Request[]\n if rank != 0\n neig_rank = rank-1\n req = MPI.Isend(view(u,2:2),comm,dest=neig_rank,tag=0)\n push!(reqs,req)\n req = MPI.Irecv!(view(u,1:1),comm,source=neig_rank,tag=0)\n push!(reqs,req)\n end\n if rank != (nranks-1)\n neig_rank = rank+1\n s = load+1\n r = load+2\n req = MPI.Isend(view(u,s:s),comm,dest=neig_rank,tag=0)\n push!(reqs,req)\n req = MPI.Irecv!(view(u,r:r),comm,source=neig_rank,tag=0)\n push!(reqs,req)\n end\n for i in 3:load\n u_new[i] = 0.5*(u[i-1]+u[i+1])\n end\n MPI.Waitall(reqs)\n for i in (2,load+1)\n u_new[i] = 0.5*(u[i-1]+u[i+1])\n end\n u, u_new = u_new, u\n\n end\n # Gather the results\n if rank !=0\n lb = 2\n ub = load+1\n MPI.Send(view(u,lb:ub),comm,dest=0)\n u_all = zeros(0) # This will nevel be used\n else\n u_all = zeros(n+2)\n # Set boundary\n u_all[1] = -1\n u_all[end] = 1\n # Set data for rank 0\n lb = 2\n ub = load+1\n u_all[lb:ub] = view(u,lb:ub)\n # Set data for other ranks\n for other_rank in 1:(nranks-1)\n lb += load\n ub += load\n MPI.Recv!(view(u_all,lb:ub),comm;source=other_rank)\n end\n end\n return u_all\nend","category":"page"},{"location":"julia_mpi/","page":"MPI (point-to-point)","title":"MPI (point-to-point)","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/julia_mpi.ipynb\"","category":"page"},{"location":"julia_mpi/","page":"MPI (point-to-point)","title":"MPI (point-to-point)","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"julia_mpi/","page":"MPI (point-to-point)","title":"MPI (point-to-point)","text":"\n","category":"page"},{"location":"julia_basics/","page":"Julia Basics","title":"Julia Basics","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/julia_basics.ipynb\"","category":"page"},{"location":"julia_basics/","page":"Julia Basics","title":"Julia Basics","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"julia_basics/","page":"Julia Basics","title":"Julia Basics","text":"\n","category":"page"},{"location":"matrix_matrix/","page":"Matrix-matrix multiplication","title":"Matrix-matrix multiplication","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/matrix_matrix.ipynb\"","category":"page"},{"location":"matrix_matrix/","page":"Matrix-matrix multiplication","title":"Matrix-matrix multiplication","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"matrix_matrix/","page":"Matrix-matrix multiplication","title":"Matrix-matrix multiplication","text":"\n","category":"page"},{"location":"asp/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/asp.ipynb\"","category":"page"},{"location":"asp/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"asp/","page":"-","title":"-","text":"\n","category":"page"},{"location":"","page":"Home","title":"Home","text":"CurrentModule = XM_40017","category":"page"},{"location":"#Programming-Large-Scale-Parallel-Systems-(XM_40017)","page":"Home","title":"Programming Large-Scale Parallel Systems (XM_40017)","text":"","category":"section"},{"location":"","page":"Home","title":"Home","text":"Welcome to the interactive lecture notes of the Programming Large-Scale Parallel Systems course at VU Amsterdam!","category":"page"},{"location":"#What","page":"Home","title":"What","text":"","category":"section"},{"location":"","page":"Home","title":"Home","text":"This page contains part of the course material of the Programming Large-Scale Parallel Systems course at VU Amsterdam. We provide several lecture notes in jupyter notebook format, which will help you to learn how to design, analyze, and program parallel algorithms on multi-node computing systems. Further information about the course is found in the study guide (click here) and our Canvas page (for registered students).","category":"page"},{"location":"","page":"Home","title":"Home","text":"note: Note\nMaterial will be added incrementally to the website as the course advances.","category":"page"},{"location":"","page":"Home","title":"Home","text":"warning: Warning\nThis page will eventually contain only a part of the course material. The rest will be available on Canvas. In particular, the material in this public webpage does not fully cover all topics in the final exam.","category":"page"},{"location":"#How-to-use-this-page","page":"Home","title":"How to use this page","text":"","category":"section"},{"location":"","page":"Home","title":"Home","text":"You have two main ways of studying the notebooks:","category":"page"},{"location":"","page":"Home","title":"Home","text":"Download the notebooks and run them locally on your computer (recommended). At each notebook page you will find a green box with links to download the notebook.\nYou also have the static version of the notebooks displayed in this webpage for quick reference.","category":"page"},{"location":"#How-to-run-the-notebooks-locally","page":"Home","title":"How to run the notebooks locally","text":"","category":"section"},{"location":"","page":"Home","title":"Home","text":"To run a notebook locally follow these steps:","category":"page"},{"location":"","page":"Home","title":"Home","text":"Install Julia (if not done already). More information in Getting started.\nDownload the notebook.\nLaunch Julia. More information in Getting started.\nExecute these commands in the Julia command line:","category":"page"},{"location":"","page":"Home","title":"Home","text":"julia> using Pkg\njulia> Pkg.add(\"IJulia\")\njulia> using IJulia\njulia> notebook()","category":"page"},{"location":"","page":"Home","title":"Home","text":"These commands will open a jupyter in your web browser. Navigate in jupyter to the notebook file you have downloaded and open it.","category":"page"},{"location":"#Authors","page":"Home","title":"Authors","text":"","category":"section"},{"location":"","page":"Home","title":"Home","text":"This material is created by Francesc Verdugo with the help of Gelieza Kötterheinrich. Part of the notebooks are based on the course slides by Henri Bal.","category":"page"},{"location":"#License","page":"Home","title":"License","text":"","category":"section"},{"location":"","page":"Home","title":"Home","text":"All material on this page that is original to this course may be used under a CC BY 4.0 license.","category":"page"},{"location":"#Acknowledgment","page":"Home","title":"Acknowledgment","text":"","category":"section"},{"location":"","page":"Home","title":"Home","text":"This page was created with the support of the Faculty of Science of Vrije Universiteit Amsterdam in the framework of the project \"Interactive lecture notes and exercises for the Programming Large-Scale Parallel Systems course\" funded by the \"Innovation budget BETA 2023 Studievoorschotmiddelen (SVM) towards Activated Blended Learning\".","category":"page"}] +[{"location":"getting_started_with_julia/#Getting-started","page":"Getting started","title":"Getting started","text":"","category":"section"},{"location":"getting_started_with_julia/#Introduction","page":"Getting started","title":"Introduction","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The programming of this course will be done using the Julia programming language. Thus, we start by explaining how to get up and running with Julia. After studying this page, you will be able to:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Use the Julia REPL,\nRun serial and parallel code,\nInstall and manage Julia packages.","category":"page"},{"location":"getting_started_with_julia/#Why-Julia?","page":"Getting started","title":"Why Julia?","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Courses related with high-performance computing (HPC) often use languages such as C, C++, or Fortran. We use Julia instead to make the course accessible to a wider set of students, including the ones that have no experience with C/C++ or Fortran, but are willing to learn parallel programming. Julia is a relatively new programming language specifically designed for scientific computing. It combines a high-level syntax close to interpreted languages like Python with the performance of compiled languages like C, C++, or Fortran. Thus, Julia will allow us to write efficient parallel algorithms with a syntax that is convenient in a teaching setting. In addition, Julia provides easy access to different programming models to write distributed algorithms, which will be useful to learn and experiment with them.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"tip: Tip\nYou can run the code in this link to learn how Julia compares to other languages (C and Python) in terms of performance.","category":"page"},{"location":"getting_started_with_julia/#Installing-Julia","page":"Getting started","title":"Installing Julia","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"This is a tutorial-like page. Follow these steps before you continue reading the document.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Download and install Julia from julialang.org;\nFollow the specific instructions for your operating system: Windows, MacOS, or Linux\nDownload and install VSCode and its Julia extension;","category":"page"},{"location":"getting_started_with_julia/#The-Julia-REPL","page":"Getting started","title":"The Julia REPL","text":"","category":"section"},{"location":"getting_started_with_julia/#Starting-Julia","page":"Getting started","title":"Starting Julia","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"There are several ways of opening Julia depending on your operating system and your IDE, but it is usually as simple as launching the Julia app. With VSCode, open a folder (File > Open Folder). Then, press Ctrl+Shift+P to open the command bar, and execute Julia: Start REPL. If this does not work, make sure you have the Julia extension for VSCode installed. Independently of the method you use, opening Julia results in a window with some text ending with:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia>","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You have just opened the Julia read-evaluate-print loop, or simply the Julia REPL. Congrats! You will spend most of time using the REPL, when working in Julia. The REPL is a console waiting for user input. Just as in other consoles, the string of text right before the input area (julia> in the case) is called the command prompt or simply the prompt.","category":"page"},{"location":"getting_started_with_julia/#Basic-usage","page":"Getting started","title":"Basic usage","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The usage of the REPL is as follows:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You write some input\npress enter\nyou get the output","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"For instance, try this","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> 1 + 1","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"A \"Hello world\" example looks like this in Julia","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> println(\"Hello, world!\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Try to run it in the REPL.","category":"page"},{"location":"getting_started_with_julia/#Help-mode","page":"Getting started","title":"Help mode","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Curious about what the function println does? Enter into help mode to look into the documentation. This is done by typing a question mark (?) into the input field:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> ?","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"After typing ?, the command prompt changes to help?>. It means we are in help mode. Now, we can type a function name to see its documentation.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"help?> println","category":"page"},{"location":"getting_started_with_julia/#Package-and-shell-modes","page":"Getting started","title":"Package and shell modes","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The REPL comes with two more modes, namely package and shell modes. To enter package mode type","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> ]","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Package mode is used to install and manage packages. We are going to discuss the package mode in greater detail later. To return back to normal mode press the backspace key several times.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"To enter shell mode type semicolon (;)","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> ;","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The prompt should have changed to shell> indicating that we are in shell mode. Now you can type commands that you would normally do on your system command line. For instance,","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"shell> ls","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"will display the contents of the current folder in Mac or Linux. Using shell mode in Windows is not straightforward, and thus not recommended for beginners.","category":"page"},{"location":"getting_started_with_julia/#Running-Julia-code","page":"Getting started","title":"Running Julia code","text":"","category":"section"},{"location":"getting_started_with_julia/#Running-more-complex-code","page":"Getting started","title":"Running more complex code","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Real-world Julia programs are not typed in the REPL in practice. They are written in one or more files and included in the REPL. To try this, create a new file called hello.jl, write the code of the \"Hello world\" example above, and save it. If you are using VSCode, you can create the file using File > New File > Julia File. Once the file is saved with the name hello.jl, execute it as follows","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> include(\"hello.jl\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"warning: Warning\nMake sure that the file \"hello.jl\" is located in the current working directory of your Julia session. You can query the current directory with function pwd(). You can change to another directory with function cd() if needed. Also, make sure that the file extension is .jl.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The recommended way of running Julia code is using the REPL as we did. But it is also possible to run code directly from the system command line. To this end, open a terminal and call Julia followed by the path to the file containing the code you want to execute.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"$ julia hello.jl","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The previous line assumes that you have Julia properly installed in the system and that it's usable from the terminal. In UNIX systems (Linux and Mac), the Julia binary needs to be in one of the directories listed in the PATH environment variable. To check that Julia is properly installed, you can use","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"$ julia --version","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"If this runs without error and you see a version number, you are good to go!","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You can also run julia code from the terminal using the -e flag:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"$ julia -e 'println(\"Hello, world!\")'","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"note: Note\nIn this tutorial, when a code snipped starts with $, it should be run in the terminal. Otherwise, the code is to be run in the Julia REPL.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"tip: Tip\nAvoid calling Julia code from the terminal, use the Julia REPL instead! Each time you call Julia from the terminal, you start a fresh Julia session and Julia will need to compile your code from scratch. This can be time consuming for large projects. In contrast, if you execute code in the REPL, Julia will compile code incrementally, which is much faster. Running code in a cluster (like in DAS-5 for the Julia assignment) is among the few situations you need to run Julia code from the terminal. Visit this link (Julia workflow tips) from the official Julia documentation for further information about how to develop Julia code effectivelly.","category":"page"},{"location":"getting_started_with_julia/#Running-parallel-code","page":"Getting started","title":"Running parallel code","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Since we are in a parallel computing course, let's run a parallel \"Hello world\" example in Julia. Open a Julia REPL and write","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> using Distributed\njulia> @everywhere println(\"Hello, world! I am proc $(myid()) from $(nprocs())\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Here, we are using the Distributed package, which is part of the Julia standard library that provides distributed memory parallel support. The code prints the process id and the number of processes in the current Julia session.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You will probably only see output from 1 process. We need to add more processes to run the example in parallel. This is done with the addprocs function.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> addprocs(3)","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"We have added 3 new processes. Plus the old one, we have 4 processes. Run the code again.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> @everywhere println(\"Hello, world! I am proc $(myid()) from $(nprocs())\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Now, you should see output from 4 processes.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"It is possible to specify the number of processes when starting Julia from the terminal with the -p argument (useful, e.g., when running in a cluster). If you launch Julia from the terminal as","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"$ julia -p 3","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"and then run","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> @everywhere println(\"Hello, world! I am proc $(myid()) from $(nprocs())\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You should get output from 4 processes as before.","category":"page"},{"location":"getting_started_with_julia/#Installing-packages","page":"Getting started","title":"Installing packages","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"One of the most useful features of Julia is its package manager. It allows one to install Julia packages in a straightforward and platform independent way. To illustrate this, let us consider the following parallel \"Hello world\" example. This example uses the Message Passing Interface (MPI). We will learn more about MPI later in the course.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Copy the following block of code into a new file named \"hello_mpi.jl\"","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"# file hello_mpi.jl\nusing MPI\nMPI.Init()\ncomm = MPI.COMM_WORLD\nrank = MPI.Comm_rank(comm)\nnranks = MPI.Comm_size(comm)\nprintln(\"Hello world, I am rank $rank of $nranks\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"As you can see from this example, one can access MPI from Julia in a clean way, without type annotations and other complexities of C/C++ code.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Now, run the file from the REPL","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> include(\"hello_mpi.jl\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"It probably didn't work, right? Read the error message and note that the MPI package needs to be installed to run this code.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"To install a package, we need to enter package mode. Remember that we entered into help mode by typing ?. Package mode is activated by typing ] : ","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> ]","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"At this point, the prompt should have changed to (@v1.10) pkg> indicating that we are in package mode. The text between the parentheses indicates which is the active project, i.e., where packages are going to be installed. In this case, we are working with the global project associated with our Julia installation (which is Julia 1.10 in this example, but it can be another version in your case).","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"To install the MPI package, type","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> add MPI","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Congrats, you have installed MPI!","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"note: Note\nMany Julia package names end with .jl. This is just a way of signaling that a package is written in Julia. When using such packages, the .jl needs to be omitted. In this case, we have installed the MPI.jl package even though we have only typed MPI in the REPL.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"note: Note\nThe package you have installed is the Julia interface to MPI, called MPI.jl. Note that it is not a MPI library by itself. It is just a thin wrapper between MPI and Julia. To use this interface, you need an actual MPI library installed in your system such as OpenMPI or MPICH. Julia downloads and installs a MPI library for you, but it is also possible to use a MPI library already available in your system. This is useful, e.g., when running on HPC clusters. See the documentation of MPI.jl for further details.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"To check that the package was installed properly, exit package mode by pressing the backspace key several times, and run it again","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> include(\"hello_mpi.jl\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Now, it should work, but you probably get output from a single MPI rank only.","category":"page"},{"location":"getting_started_with_julia/#Running-MPI-code","page":"Getting started","title":"Running MPI code","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"To run MPI applications in parallel, you need a launcher like mpiexec. MPI codes written in Julia are not an exception to this rule. From the system terminal, you can run","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"$ mpiexec -np 4 julia hello_mpi.jl","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"But it will probably not work since the version of mpiexec needs to match with the MPI version we are using from Julia. Don't worry if you could not make it work! A more elegant way to run MPI code is from the Julia REPL directly, by using these commands:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> using MPI\njulia> run(`$(mpiexec()) -np 4 julia hello_mpi.jl`)","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Now, you should see output from 4 ranks.","category":"page"},{"location":"getting_started_with_julia/#Package-manager","page":"Getting started","title":"Package manager","text":"","category":"section"},{"location":"getting_started_with_julia/#Installing-packages-locally","page":"Getting started","title":"Installing packages locally","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"We have installed the MPI package globally and it will be available in all Julia sessions. However, in some situations, we want to work with different versions of the same package or to install packages in an isolated way to avoid potential conflicts with other packages. This can be done by using local projects.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"A project is simply a folder in your file system. To use a particular folder as your project, you need to activate it. This is done by entering package mode and using the activate command followed by the path to the folder you want to activate.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> activate .","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The previous command will activate the current working directory. Note that the dot . is indeed the path to the current folder.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The prompt has changed to (lessons) pkg> indicating that we are in the project within the lessons folder. The particular folder name can be different in your case.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"tip: Tip\nYou can activate a project directly when opening Julia from the terminal using the --project flag. The command $ julia --project=. will open Julia and activate a project in the current directory. You can also achieve the same effect by setting the environment variable JULIA_PROJECT with the path of the folder you want to activate.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"note: Note\nThe active project folder and the current working directory are two independent concepts! For instance, (@v1.10) pkg> activate folderB and then julia> cd(\"folderA\"), will activate the project in folderB and change the current working directory to folderA.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"At this point all package-related operations will be local to the new project. For instance, install the DataFrames package.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(lessons) pkg> add DataFrames","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Use the package to check that it is installed","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> using DataFrames\njulia> DataFrame(a=[1,2],b=[3,4])","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Now, we can return to the global project to check that DataFrames has not been installed there. To return to the global environment, use activate without a folder name.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(lessons) pkg> activate","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The prompt is again (@v1.10) pkg>","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Now, try to use DataFrames.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> using DataFrames\njulia> DataFrame(a=[1,2],b=[3,4])","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You should get an error or a warning unless you already had DataFrames installed globally.","category":"page"},{"location":"getting_started_with_julia/#Project-and-Manifest-files","page":"Getting started","title":"Project and Manifest files","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The information about a project is stored in two files Project.toml and Manifest.toml.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Project.toml contains the packages explicitly installed (the direct dependencies)\nManifest.toml contains direct and indirect dependencies along with the concrete version of each package.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"In other words, Project.toml contains the packages relevant for the user, whereas Manifest.toml is the detailed snapshot of all dependencies. The Manifest.toml can be used to reproduce the same environment in another machine.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You can see the path to the current Project.toml file by using the status operator (or st in its short form) while in package mode","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> status","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The information about the Manifest.toml can be inspected by passing the -m flag.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> status -m","category":"page"},{"location":"getting_started_with_julia/#Installing-packages-from-a-project-file","page":"Getting started","title":"Installing packages from a project file","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Project files can be used to install lists of packages defined by others. E.g., to install all the dependencies of a Julia application.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Assume that a colleague has sent to you a Project.toml file with this content:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"[deps]\nBenchmarkTools = \"6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf\"\nDataFrames = \"a93c6f00-e57d-5684-b7b6-d8193f3e46c0\"\nMPI = \"da04e1cc-30fd-572f-bb4f-1f8673147195\"","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Copy the contents of previous code block into a file called Project.toml and place it in an empty folder named newproject. It is important that the file is named Project.toml. You can create a new folder from the REPL with","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> mkdir(\"newproject\")","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"To install all the packages registered in this file you need to activate the folder containing your Project.toml file","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> activate newproject","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"and then instantiating it","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(newproject) pkg> instantiate","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The instantiate command will download and install all listed packages and their dependencies in just one click.","category":"page"},{"location":"getting_started_with_julia/#Getting-help-in-package-mode","page":"Getting started","title":"Getting help in package mode","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You can get help about a particular package operator by writing help in front of it","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> help activate","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You can get an overview of all package commands by typing help alone","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> help","category":"page"},{"location":"getting_started_with_julia/#Package-operations-in-Julia-code","page":"Getting started","title":"Package operations in Julia code","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"In some situations it is required to use package commands in Julia code, e.g., to automatize installation and deployment of Julia applications. This can be done using the Pkg package. For instance","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"julia> using Pkg\njulia> Pkg.status()","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"is equivalent to calling status in package mode.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> status","category":"page"},{"location":"getting_started_with_julia/#Creating-you-own-package","page":"Getting started","title":"Creating you own package","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"In many situations is useful to create your own package, for instance, when working with a large code base, when you want to reduce compilation latency using Revise.jl, or if you want to eventually register your package and share it with others.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"The simplest way of generating a package (called MyPackage) is as follows. Open Julia go to package mode and type","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> generate MyPackage","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"This will crate a minimal package consisting of a new folder MyPackage with two files:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"MyPackage/Project.toml: Project file defining the direct dependencies of your package.\nMyPackage/src/MyPackage.jl: Main source file of your package. You can split your code in several files if needed, and include them in the package main file using function include.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"tip: Tip\nThis approach only generates a very minimal package. To create a more sophisticated package skeleton (including unit testing, code coverage, readme file, licence, etc.) use PkgTemplates.jl or BestieTemplate.jl. The later one is developed in Amsterdam at the Netherlands eScience Center.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"You can add dependencies to the package by activating the MyPackage folder in package mode and adding new dependencies as always:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> activate MyPackage\n(MyPackage) pkg> add MPI","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"This will add MPI to your package dependencies.","category":"page"},{"location":"getting_started_with_julia/#Using-your-own-package","page":"Getting started","title":"Using your own package","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"To use your package you first need to add it to a package environment of your choice. This is done with develop path/to/the/package/folder in package mode. For instance:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"(@v1.10) pkg> develop MyPackage","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"note: Note\nYou do not need to \"develop\" your package if you activated the package folder MyPackage.","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Now, we can go back to standard Julia mode and use it as any other package:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"using MyPackage\nMyPackage.greet()","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Here, we just called the example function defined in MyPackage/src/MyPackage.jl.","category":"page"},{"location":"getting_started_with_julia/#Conclusion","page":"Getting started","title":"Conclusion","text":"","category":"section"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"We have learned the basics of how to work with Julia, including how to run serial and parallel code, and how to manage, create, and use Julia packages. This knowledge will allow you to follow the course effectively! If you want to further dig into the topics we have covered here, you can take a look at the following links:","category":"page"},{"location":"getting_started_with_julia/","page":"Getting started","title":"Getting started","text":"Julia Manual\nPackage manager","category":"page"},{"location":"tsp/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/tsp.ipynb\"","category":"page"},{"location":"tsp/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"tsp/","page":"-","title":"-","text":"\n","category":"page"},{"location":"mpi_collectives/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/mpi_collectives.ipynb\"","category":"page"},{"location":"mpi_collectives/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"mpi_collectives/","page":"-","title":"-","text":"\n","category":"page"},{"location":"jacobi_2D/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/jacobi_2D.ipynb\"","category":"page"},{"location":"jacobi_2D/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"jacobi_2D/","page":"-","title":"-","text":"\n","category":"page"},{"location":"julia_async/","page":"Asynchronous programming in Julia","title":"Asynchronous programming in Julia","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/julia_async.ipynb\"","category":"page"},{"location":"julia_async/","page":"Asynchronous programming in Julia","title":"Asynchronous programming in Julia","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"julia_async/","page":"Asynchronous programming in Julia","title":"Asynchronous programming in Julia","text":"\n","category":"page"},{"location":"solutions/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/solutions.ipynb\"","category":"page"},{"location":"solutions/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"solutions/","page":"-","title":"-","text":"\n","category":"page"},{"location":"pdes/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/pdes.ipynb\"","category":"page"},{"location":"pdes/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"pdes/","page":"-","title":"-","text":"\n","category":"page"},{"location":"LEQ/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/LEQ.ipynb\"","category":"page"},{"location":"LEQ/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"LEQ/","page":"-","title":"-","text":"\n","category":"page"},{"location":"julia_distributed/","page":"Distributed computing in Julia","title":"Distributed computing in Julia","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/julia_distributed.ipynb\"","category":"page"},{"location":"julia_distributed/","page":"Distributed computing in Julia","title":"Distributed computing in Julia","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"julia_distributed/","page":"Distributed computing in Julia","title":"Distributed computing in Julia","text":"\n","category":"page"},{"location":"julia_jacobi/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/julia_jacobi.ipynb\"","category":"page"},{"location":"julia_jacobi/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"julia_jacobi/","page":"-","title":"-","text":"\n","category":"page"},{"location":"julia_tutorial/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/julia_tutorial.ipynb\"","category":"page"},{"location":"julia_tutorial/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"julia_tutorial/","page":"-","title":"-","text":"\n","category":"page"},{"location":"mpi_tutorial/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/mpi_tutorial.ipynb\"","category":"page"},{"location":"mpi_tutorial/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"mpi_tutorial/","page":"-","title":"-","text":"\n","category":"page"},{"location":"notebook-hello/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/notebook-hello.ipynb\"","category":"page"},{"location":"notebook-hello/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"notebook-hello/","page":"-","title":"-","text":"\n","category":"page"},{"location":"julia_intro/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/julia_intro.ipynb\"","category":"page"},{"location":"julia_intro/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"julia_intro/","page":"-","title":"-","text":"\n","category":"page"},{"location":"jacobi_method/","page":"Jacobi method","title":"Jacobi method","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/jacobi_method.ipynb\"","category":"page"},{"location":"jacobi_method/","page":"Jacobi method","title":"Jacobi method","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"jacobi_method/","page":"Jacobi method","title":"Jacobi method","text":"\n","category":"page"},{"location":"solutions_for_all_notebooks/#Solutions","page":"Solutions","title":"Solutions","text":"","category":"section"},{"location":"solutions_for_all_notebooks/#Julia-Basics","page":"Solutions","title":"Julia Basics","text":"","category":"section"},{"location":"solutions_for_all_notebooks/#Exercise-1","page":"Solutions","title":"Exercise 1","text":"","category":"section"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"function ex1(a)\n j = 1\n m = a[j]\n for (i,ai) in enumerate(a)\n if m < ai\n m = ai\n j = i\n end\n end\n (m,j)\nend","category":"page"},{"location":"solutions_for_all_notebooks/#Exercise-2","page":"Solutions","title":"Exercise 2","text":"","category":"section"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"ex2(f,g) = x -> f(x) + g(x)","category":"page"},{"location":"solutions_for_all_notebooks/#Exercise-3","page":"Solutions","title":"Exercise 3","text":"","category":"section"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"using GLMakie\nmax_iters = 100\nn = 1000\nx = LinRange(-1.7,0.7,n)\ny = LinRange(-1.2,1.2,n)\nheatmap(x,y,(i,j)->mandel(i,j,max_iters))","category":"page"},{"location":"solutions_for_all_notebooks/#Asynchronous-programming-in-Julia","page":"Solutions","title":"Asynchronous programming in Julia","text":"","category":"section"},{"location":"solutions_for_all_notebooks/#Distributed-computing-in-Julia","page":"Solutions","title":"Distributed computing in Julia","text":"","category":"section"},{"location":"solutions_for_all_notebooks/#Exercise-1-2","page":"Solutions","title":"Exercise 1","text":"","category":"section"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"f = () -> Channel{Int}(1)\nchnls = [ RemoteChannel(f,w) for w in workers() ]\n@sync for (iw,w) in enumerate(workers())\n @spawnat w begin\n chnl_snd = chnls[iw]\n if w == 2\n chnl_rcv = chnls[end]\n msg = 2\n println(\"msg = $msg\")\n put!(chnl_snd,msg)\n msg = take!(chnl_rcv)\n println(\"msg = $msg\")\n else\n chnl_rcv = chnls[iw-1]\n msg = take!(chnl_rcv)\n msg += 1\n println(\"msg = $msg\")\n put!(chnl_snd,msg)\n end\n end\nend","category":"page"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"This is another possible solution.","category":"page"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"@everywhere function work(msg)\n println(\"msg = $msg\")\n if myid() != nprocs()\n next = myid() + 1\n @fetchfrom next work(msg+1)\n else\n @fetchfrom 2 println(\"msg = $msg\")\n end\nend\nmsg = 2\n@fetchfrom 2 work(msg)","category":"page"},{"location":"solutions_for_all_notebooks/#Matrix-matrix-multiplication","page":"Solutions","title":"Matrix-matrix multiplication","text":"","category":"section"},{"location":"solutions_for_all_notebooks/#Exercise-1-3","page":"Solutions","title":"Exercise 1","text":"","category":"section"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"function matmul_dist_3!(C,A,B)\n m = size(C,1)\n n = size(C,2)\n l = size(A,2)\n @assert size(A,1) == m\n @assert size(B,2) == n\n @assert size(B,1) == l\n @assert mod(m,nworkers()) == 0\n nrows_w = div(m,nworkers())\n @sync for (iw,w) in enumerate(workers())\n lb = 1 + (iw-1)*nrows_w\n ub = iw*nrows_w\n A_w = A[lb:ub,:]\n ftr = @spawnat w begin\n C_w = similar(A_w)\n matmul_seq!(C_w,A_w,B)\n C_w\n end\n @async C[lb:ub,:] = fetch(ftr)\n end\n C\nend\n\n@everywhere function matmul_seq!(C,A,B)\n m = size(C,1)\n n = size(C,2)\n l = size(A,2)\n @assert size(A,1) == m\n @assert size(B,2) == n\n @assert size(B,1) == l\n z = zero(eltype(C))\n for j in 1:n\n for i in 1:m\n Cij = z\n for k in 1:l\n @inbounds Cij = Cij + A[i,k]*B[k,j]\n end\n C[i,j] = Cij\n end\n end\n C\nend","category":"page"},{"location":"solutions_for_all_notebooks/#MPI-(Point-to-point)","page":"Solutions","title":"MPI (Point-to-point)","text":"","category":"section"},{"location":"solutions_for_all_notebooks/#Exercise-2-2","page":"Solutions","title":"Exercise 2","text":"","category":"section"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"using MPI\nMPI.Init()\ncomm = MPI.COMM_WORLD\nrank = MPI.Comm_rank(comm)\nnranks = MPI.Comm_size(comm)\nbuffer = Ref(0)\nif rank == 0\n msg = 2\n buffer[] = msg\n println(\"msg = $(buffer[])\")\n MPI.Send(buffer,comm;dest=rank+1,tag=0)\n MPI.Recv!(buffer,comm;source=nranks-1,tag=0)\n println(\"msg = $(buffer[])\")\nelse\n dest = if (rank != nranks-1)\n rank+1\n else\n 0\n end\n MPI.Recv!(buffer,comm;source=rank-1,tag=0)\n buffer[] += 1\n println(\"msg = $(buffer[])\")\n MPI.Send(buffer,comm;dest,tag=0)\nend","category":"page"},{"location":"solutions_for_all_notebooks/#Jacobi-method","page":"Solutions","title":"Jacobi method","text":"","category":"section"},{"location":"solutions_for_all_notebooks/#Exercise-1-4","page":"Solutions","title":"Exercise 1","text":"","category":"section"},{"location":"solutions_for_all_notebooks/","page":"Solutions","title":"Solutions","text":"function jacobi_mpi(n,niters)\n comm = MPI.COMM_WORLD\n nranks = MPI.Comm_size(comm)\n rank = MPI.Comm_rank(comm)\n if mod(n,nranks) != 0\n println(\"n must be a multiple of nranks\")\n MPI.Abort(comm,1)\n end\n load = div(n,nranks)\n u = zeros(load+2)\n u[1] = -1\n u[end] = 1\n u_new = copy(u)\n for t in 1:niters\n reqs = MPI.Request[]\n if rank != 0\n neig_rank = rank-1\n req = MPI.Isend(view(u,2:2),comm,dest=neig_rank,tag=0)\n push!(reqs,req)\n req = MPI.Irecv!(view(u,1:1),comm,source=neig_rank,tag=0)\n push!(reqs,req)\n end\n if rank != (nranks-1)\n neig_rank = rank+1\n s = load+1\n r = load+2\n req = MPI.Isend(view(u,s:s),comm,dest=neig_rank,tag=0)\n push!(reqs,req)\n req = MPI.Irecv!(view(u,r:r),comm,source=neig_rank,tag=0)\n push!(reqs,req)\n end\n for i in 3:load\n u_new[i] = 0.5*(u[i-1]+u[i+1])\n end\n MPI.Waitall(reqs)\n for i in (2,load+1)\n u_new[i] = 0.5*(u[i-1]+u[i+1])\n end\n u, u_new = u_new, u\n\n end\n # Gather the results\n if rank !=0\n lb = 2\n ub = load+1\n MPI.Send(view(u,lb:ub),comm,dest=0)\n u_all = zeros(0) # This will nevel be used\n else\n u_all = zeros(n+2)\n # Set boundary\n u_all[1] = -1\n u_all[end] = 1\n # Set data for rank 0\n lb = 2\n ub = load+1\n u_all[lb:ub] = view(u,lb:ub)\n # Set data for other ranks\n for other_rank in 1:(nranks-1)\n lb += load\n ub += load\n MPI.Recv!(view(u_all,lb:ub),comm;source=other_rank)\n end\n end\n return u_all\nend","category":"page"},{"location":"julia_mpi/","page":"MPI (point-to-point)","title":"MPI (point-to-point)","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/julia_mpi.ipynb\"","category":"page"},{"location":"julia_mpi/","page":"MPI (point-to-point)","title":"MPI (point-to-point)","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"julia_mpi/","page":"MPI (point-to-point)","title":"MPI (point-to-point)","text":"\n","category":"page"},{"location":"julia_basics/","page":"Julia Basics","title":"Julia Basics","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/julia_basics.ipynb\"","category":"page"},{"location":"julia_basics/","page":"Julia Basics","title":"Julia Basics","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"julia_basics/","page":"Julia Basics","title":"Julia Basics","text":"\n","category":"page"},{"location":"matrix_matrix/","page":"Matrix-matrix multiplication","title":"Matrix-matrix multiplication","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/matrix_matrix.ipynb\"","category":"page"},{"location":"matrix_matrix/","page":"Matrix-matrix multiplication","title":"Matrix-matrix multiplication","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"matrix_matrix/","page":"Matrix-matrix multiplication","title":"Matrix-matrix multiplication","text":"\n","category":"page"},{"location":"asp/","page":"-","title":"-","text":"EditURL = \"https://github.com/fverdugo/XM_40017/blob/main/notebooks/asp.ipynb\"","category":"page"},{"location":"asp/","page":"-","title":"-","text":"
    \n
    Tip
    \n
    \n
      \n
    • \n Download this notebook and run it locally on your machine [highly recommended]. Click here.\n
      • \n
    \n
    \n
    ","category":"page"},{"location":"asp/","page":"-","title":"-","text":"\n","category":"page"},{"location":"","page":"Home","title":"Home","text":"CurrentModule = XM_40017","category":"page"},{"location":"#Programming-Large-Scale-Parallel-Systems-(XM_40017)","page":"Home","title":"Programming Large-Scale Parallel Systems (XM_40017)","text":"","category":"section"},{"location":"","page":"Home","title":"Home","text":"Welcome to the interactive lecture notes of the Programming Large-Scale Parallel Systems course at VU Amsterdam!","category":"page"},{"location":"#What","page":"Home","title":"What","text":"","category":"section"},{"location":"","page":"Home","title":"Home","text":"This page contains part of the course material of the Programming Large-Scale Parallel Systems course at VU Amsterdam. We provide several lecture notes in jupyter notebook format, which will help you to learn how to design, analyze, and program parallel algorithms on multi-node computing systems. Further information about the course is found in the study guide (click here) and our Canvas page (for registered students).","category":"page"},{"location":"","page":"Home","title":"Home","text":"note: Note\nMaterial will be added incrementally to the website as the course advances.","category":"page"},{"location":"","page":"Home","title":"Home","text":"warning: Warning\nThis page will eventually contain only a part of the course material. The rest will be available on Canvas. In particular, the material in this public webpage does not fully cover all topics in the final exam.","category":"page"},{"location":"#How-to-use-this-page","page":"Home","title":"How to use this page","text":"","category":"section"},{"location":"","page":"Home","title":"Home","text":"You have two main ways of studying the notebooks:","category":"page"},{"location":"","page":"Home","title":"Home","text":"Download the notebooks and run them locally on your computer (recommended). At each notebook page you will find a green box with links to download the notebook.\nYou also have the static version of the notebooks displayed in this webpage for quick reference.","category":"page"},{"location":"#How-to-run-the-notebooks-locally","page":"Home","title":"How to run the notebooks locally","text":"","category":"section"},{"location":"","page":"Home","title":"Home","text":"To run a notebook locally follow these steps:","category":"page"},{"location":"","page":"Home","title":"Home","text":"Install Julia (if not done already). More information in Getting started.\nDownload the notebook.\nLaunch Julia. More information in Getting started.\nExecute these commands in the Julia command line:","category":"page"},{"location":"","page":"Home","title":"Home","text":"julia> using Pkg\njulia> Pkg.add(\"IJulia\")\njulia> using IJulia\njulia> notebook()","category":"page"},{"location":"","page":"Home","title":"Home","text":"These commands will open a jupyter in your web browser. Navigate in jupyter to the notebook file you have downloaded and open it.","category":"page"},{"location":"#Authors","page":"Home","title":"Authors","text":"","category":"section"},{"location":"","page":"Home","title":"Home","text":"This material is created by Francesc Verdugo with the help of Gelieza Kötterheinrich. Part of the notebooks are based on the course slides by Henri Bal.","category":"page"},{"location":"#License","page":"Home","title":"License","text":"","category":"section"},{"location":"","page":"Home","title":"Home","text":"All material on this page that is original to this course may be used under a CC BY 4.0 license.","category":"page"},{"location":"#Acknowledgment","page":"Home","title":"Acknowledgment","text":"","category":"section"},{"location":"","page":"Home","title":"Home","text":"This page was created with the support of the Faculty of Science of Vrije Universiteit Amsterdam in the framework of the project \"Interactive lecture notes and exercises for the Programming Large-Scale Parallel Systems course\" funded by the \"Innovation budget BETA 2023 Studievoorschotmiddelen (SVM) towards Activated Blended Learning\".","category":"page"}] } diff --git a/dev/solutions/index.html b/dev/solutions/index.html index b753e98..9c144fa 100644 --- a/dev/solutions/index.html +++ b/dev/solutions/index.html @@ -14,4 +14,4 @@ var myIframe = document.getElementById("notebook"); iFrameResize({log:true}, myIframe); }); - + diff --git a/dev/solutions_for_all_notebooks/index.html b/dev/solutions_for_all_notebooks/index.html index 6d1b1cd..1b271e2 100644 --- a/dev/solutions_for_all_notebooks/index.html +++ b/dev/solutions_for_all_notebooks/index.html @@ -172,4 +172,4 @@ end

    « Jacobi method

    Powered by Documenter.jl and the Julia Programming Language.

    +end diff --git a/dev/tsp/index.html b/dev/tsp/index.html index 2ffb41b..580836b 100644 --- a/dev/tsp/index.html +++ b/dev/tsp/index.html @@ -14,4 +14,4 @@ var myIframe = document.getElementById("notebook"); iFrameResize({log:true}, myIframe); }); - +