Update Lab1 DAXPY and Select Exercise numbers to start at 1

Author: gonzalobg

README.md

@@ -6,12 +6,9 @@ C++ HPC Tutorial
 ### Pre-requisites
 
 To build the container locally, a properly configured container runtime is required. 
-Both Docker and Singularity are supported.
+Both Docker and Singularity containers are supported. 
 
-Building the container requires the Docker or Singularity container descriptions.
-This project uses [HPC Container Maker] to generate these descriptions from a single portable container description.
-[HPPCM] is a Python application.
-Running it requires Python, and it can be installed using Python's package manager `pip`:
+The containers are generated from a single single description at [`/ci/recipe.py`](./ci/recipe.py) using the [HPC Container Maker][HPCCM] Python application, which requires a Python installation and can be installed with `pip`:
 
 ```
 pip3 install --user hpccm
@@ -32,7 +29,7 @@ PATH=$PATH:$PYTHONPATH
 
 ### Building container and serving Jupyter Notebooks
 
-To build the container and start the Jupter notebook webserver locally here are the instructions for `Docker` and `Singularity`.
+To build the container and start the Jupter notebook webserver locally here are the instructions for `Docker` and `Singularity`. The Jupyter notebook webserver provides an URL that can be used to connect to it from a webbrowser. When running it on a cluster, one might need to use SSH port forwarding to forward a local port to the compute node.
 
 [HPCCM]:
 

labs/lab1_daxpy/daxpy.ipynb

@@ -112,13 +112,13 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Exercise 0: from raw DAXPY loop to serial C++ transform algorithm\n",
+    "## Exercise 1: from raw DAXPY loop to serial C++ transform algorithm\n",
     "\n",
     "The goal of this first exercise is to re-write the raw DAXPY loop using the C++ standard library `transform` algorithms (see the documentation of [transform] to pick the right overload - number (3)).\n",
     "\n",
     "[transform]: https://en.cppreference.com/w/cpp/algorithm/transform\n",
     "\n",
-    "A template for the solution is provided in [exercise0.cpp]. The `TODO`s indicate the parts of the template that must be completed.\n",
+    "A template for the solution is provided in [exercise1.cpp]. The `TODO`s indicate the parts of the template that must be completed.\n",
     "To complete this first exercise, the `daxpy` function needs to be rewritten to use the C++ standatd library algorithms and this will require adding some headers:\n",
     "\n",
     "```c++\n",
@@ -133,7 +133,7 @@
     "}\n",
     "```\n",
     "\n",
-    "[exercise0.cpp]: ./exercise0.cpp\n",
+    "[exercise1.cpp]: ./exercise1.cpp\n",
     "\n",
     "The example compiles and runs as provided, but it produces incorrect results due to the incomplete `daxpy` implementation.\n",
     "Once you fix it, the following blocks should compile and run correctly:\n"
@@ -145,7 +145,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!g++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy exercise0.cpp\n",
+    "!g++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy exercise1.cpp\n",
     "!./daxpy 1000000"
    ]
   },
@@ -155,7 +155,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!clang++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy exercise0.cpp\n",
+    "!clang++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy exercise1.cpp\n",
     "!./daxpy 1000000"
    ]
   },
@@ -165,25 +165,25 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!nvc++ -std=c++20 -O4 -fast -march=native -Mllvm-fast -DNDEBUG -o daxpy exercise0.cpp\n",
+    "!nvc++ -std=c++20 -O4 -fast -march=native -Mllvm-fast -DNDEBUG -o daxpy exercise1.cpp\n",
     "!./daxpy 1000000"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Solutions Exercise 0\n",
+    "### Solutions Exercise 1\n",
     "\n",
     "The solutions for each example are available in the [`solutions/`] sub-directory.\n",
     "\n",
     "[`solutions/`]: ./solutions\n",
     "\n",
-    "The solution for this first exercise is in [`solutions/exercise0.cpp`].\n",
+    "The solution for this first exercise is in [`solutions/exercise1.cpp`].\n",
     "\n",
-    "[`solutions/exercise0.cpp`]: ./solutions/exercise0.cpp\n",
+    "[`solutions/exercise1.cpp`]: ./solutions/exercise1.cpp\n",
     "\n",
-    "The following blocks compile and run the solutions for Exercise 0 using different compilers."
+    "The following blocks compile and run the solutions for Exercise 1 using different compilers."
    ]
   },
   {
@@ -192,7 +192,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!g++ -std=c++17 -Ofast -march=native -DNDEBUG -o daxpy solutions/exercise0.cpp\n",
+    "!g++ -std=c++17 -Ofast -march=native -DNDEBUG -o daxpy solutions/exercise1.cpp\n",
     "!./daxpy 1000000"
    ]
   },
@@ -202,7 +202,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!clang++ -std=c++17 -Ofast -march=native -DNDEBUG -o daxpy solutions/exercise0.cpp\n",
+    "!clang++ -std=c++17 -Ofast -march=native -DNDEBUG -o daxpy solutions/exercise1.cpp\n",
     "!./daxpy 1000000"
    ]
   },
@@ -212,20 +212,20 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!nvc++ -std=c++17 -O4 -fast -march=native -Mllvm-fast -DNDEBUG -o daxpy solutions/exercise0.cpp\n",
+    "!nvc++ -std=c++17 -O4 -fast -march=native -Mllvm-fast -DNDEBUG -o daxpy solutions/exercise1.cpp\n",
     "!./daxpy 1000000"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Exercise 1\n",
+    "# Exercise 2: from raw initialization to `std::fill_n` and `std::for_each_n`\n",
     "\n",
-    "In Exercise 2 we will parallelize `daxpy` to allow it to run on accelerator devices like a GPUs.\n",
+    "In Exercise 3 we will parallelize `daxpy` to allow it to run on accelerator devices like a GPUs.\n",
     "When doing so, it is important to avoid unnecessary memory migrations across devices.\n",
     "\n",
-    "The goal of this exercise is to initialize the memory using the standard library algorithms, so that when we parallelize the initialization in Exercise 2, it will happen on the accelerator device itself.\n",
+    "The goal of this exercise is to initialize the memory using the standard library algorithms, so that when we parallelize the initialization in Exercise 3, it will happen on the accelerator device itself.\n",
     "\n",
     "Since we need to initialize two vectors - `x` and `y` - lets use a different approach to initialize each:\n",
     "\n",
@@ -236,9 +236,7 @@
     "[for_each_n]: https://en.cppreference.com/w/cpp/algorithm/for_each_n \n",
     "[iota_view]: https://en.cppreference.com/w/cpp/ranges/iota_view\n",
     "\n",
-    "* `std::for_each_n` algorithms with `std::views::iota` for ind (see [for_each\n",
-    "\n",
-    "A template for the solution is provided in [exercise1.cpp]. The `TODO`s indicate the parts of the template that must be completed.\n",
+    "A template for the solution is provided in [exercise2.cpp]. The `TODO`s indicate the parts of the template that must be completed.\n",
     "To complete this first exercise, the `initialize` function needs to be rewritten to use the C++ standatd library algorithms and this will require adding some headers for accessing `std::views::iota`:\n",
     "\n",
     "```c++\n",
@@ -253,7 +251,7 @@
     "}\n",
     "```\n",
     "\n",
-    "[exercise1.cpp]: ./exercise1.cpp\n",
+    "[exercise2.cpp]: ./exercise2.cpp\n",
     "\n",
     "The example compiles and runs as provided, but it produces incorrect results due to the incomplete `initialize` implementation.\n",
     "In the compilation commands below, the C++ standard version is now C++20, to enable the use of `views::iota`.\n",
@@ -267,7 +265,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!g++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy exercise1.cpp\n",
+    "!g++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy exercise2.cpp\n",
     "!./daxpy 1000000"
    ]
   },
@@ -277,7 +275,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!clang++ -std=c++20 -Ofast -march=native -DNDEBUG -isystem/usr/local/range-v3/include -o daxpy exercise1.cpp\n",
+    "!clang++ -std=c++20 -Ofast -march=native -DNDEBUG -isystem/usr/local/range-v3/include -o daxpy exercise2.cpp\n",
     "!./daxpy 1000000"
    ]
   },
@@ -287,19 +285,19 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!nvc++ -std=c++20 -O4 -fast -march=native -Mllvm-fast -o daxpy exercise1.cpp\n",
+    "!nvc++ -std=c++20 -O4 -fast -march=native -Mllvm-fast -DNDEBUG -o daxpy exercise2.cpp\n",
     "!./daxpy 1000000"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Solutions Exercise 1\n",
+    "### Solutions Exercise 2\n",
     "\n",
-    "The solution for this exercise is in [`solutions/exercise1.cpp`].\n",
+    "The solution for this exercise is in [`solutions/exercise2.cpp`].\n",
     "\n",
-    "[`solutions/exercise1.cpp`]: ./solutions/exercise1.cpp\n",
+    "[`solutions/exercise2.cpp`]: ./solutions/exercise2.cpp\n",
     "\n",
     "The following compiles and runs the solutions for Exercise 1 using different compilers."
    ]
@@ -311,7 +309,7 @@
    "outputs": [],
    "source": [
     "# Using iota range for initialize \n",
-    "!g++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy solutions/exercise1.cpp\n",
+    "!g++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy solutions/exercise2.cpp\n",
     "!./daxpy 1000000"
    ]
   },
@@ -321,7 +319,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!clang++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy solutions/exercise1.cpp\n",
+    "!clang++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy solutions/exercise2.cpp\n",
     "!./daxpy 1000000"
    ]
   },
@@ -331,19 +329,19 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!nvc++ -std=c++20 -O4 -fast -march=native -Mllvm-fast -o daxpy solutions/exercise1.cpp\n",
+    "!nvc++ -std=c++20 -O4 -fast -march=native -Mllvm-fast -DNDEBUG -o daxpy solutions/exercise2.cpp\n",
     "!./daxpy 1000000"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Exercise 2: parallelizing DAXPY using C++ parallel algorithms\n",
+    "## Exercise 3: parallelizing DAXPY and Initialization using C++ parallel algorithms\n",
     "\n",
     "The goal of this final exercise in this section is to parallelize the `initialize` and `daxpy` functions to compute the results in parallel using CPUs or GPUs.\n",
     "\n",
-    "A template for the solution is provided in [exercise2.cpp].\n",
+    "A template for the solution is provided in [exercise3.cpp].\n",
     "\n",
     "```c++\n",
     "#include <ranges>\n",
@@ -368,7 +366,7 @@
     "}\n",
     "```\n",
     "\n",
-    "[exercise2.cpp]: ./exercise2.cpp\n",
+    "[exercise3.cpp]: ./exercise3.cpp\n",
     "\n",
     "Compiling with support for the parallel algorithms requires:\n",
     "* `g++` and `clang++`: link against Intel TBB with `-ltbb`\n",
@@ -387,7 +385,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!g++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy exercise2.cpp -ltbb\n",
+    "!g++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy exercise3.cpp -ltbb\n",
     "!./daxpy 1000000"
    ]
   },
@@ -397,7 +395,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!clang++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy exercise2.cpp -ltbb\n",
+    "!clang++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy exercise3.cpp -ltbb\n",
     "!./daxpy 1000000"
    ]
   },
@@ -407,7 +405,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!nvc++ -stdpar=multicore -std=c++20 -O4 -fast -march=native -Mllvm-fast -o daxpy exercise2.cpp\n",
+    "!nvc++ -stdpar=multicore -std=c++20 -O4 -fast -march=native -Mllvm-fast -DNDEBUG -o daxpy exercise3.cpp\n",
     "!./daxpy 1000000"
    ]
   },
@@ -417,23 +415,25 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!nvc++ -stdpar=gpu -std=c++20 -O4 -fast -march=native -Mllvm-fast -o daxpy exercise2.cpp\n",
+    "!nvc++ -stdpar=gpu -std=c++20 -O4 -fast -march=native -Mllvm-fast -DNDEBUG -o daxpy exercise3.cpp\n",
     "!./daxpy 1000000"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "source": [
-    "### Solutions for Exercise 2\n",
+    "### Solutions for Exercise 3\n",
     "\n",
-    "The solution for this exercise is in [`solutions/exercise2.cpp`].\n",
+    "The solution for this exercise is in [`solutions/exercise3.cpp`].\n",
     "\n",
-    "[`solutions/exercise2.cpp`]: ./solutions/exercise2.cpp\n",
+    "[`solutions/exercise3.cpp`]: ./solutions/exercise3.cpp\n",
     "\n",
-    "The following blocks compile and run the solutions for Exercise 2 using different compilers on the CPU.\n",
+    "The following blocks compile and run the solutions for Exercise 3 using different compilers on the CPU.\n",
     "\n",
-    "The last block compiles and runs the solution for Exercise 2 on the GPU. If you get an error, make sure that the lambda captures are captiruing scalars by value, and that when capturing a vector to access its data, one captures a pointer to its data by value as well using `[x = x.data()]`."
+    "The last block compiles and runs the solution for Exercise 3 on the GPU. If you get an error, make sure that the lambda captures are captiruing scalars by value, and that when capturing a vector to access its data, one captures a pointer to its data by value as well using `[x = x.data()]`."
    ]
   },
   {
@@ -442,7 +442,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!g++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy solutions/exercise2.cpp -ltbb\n",
+    "!g++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy solutions/exercise3.cpp -ltbb\n",
     "!./daxpy 1000000"
    ]
   },
@@ -452,7 +452,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!clang++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy solutions/exercise2.cpp -ltbb\n",
+    "!clang++ -std=c++20 -Ofast -march=native -DNDEBUG -o daxpy solutions/exercise3.cpp -ltbb\n",
     "!./daxpy 1000000"
    ]
   },
@@ -462,7 +462,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!nvc++ -stdpar=multicore -std=c++20 -O4 -fast -march=native -Mllvm-fast -o daxpy solutions/exercise2.cpp\n",
+    "!nvc++ -stdpar=multicore -std=c++20 -O4 -fast -march=native -Mllvm-fast -DNDEBUG -o daxpy solutions/exercise3.cpp\n",
     "!./daxpy 1000000"
    ]
   },
@@ -472,7 +472,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!nvc++ -stdpar=gpu -std=c++20 -O4 -fast -march=native -Mllvm-fast -o daxpy solutions/exercise2.cpp\n",
+    "!nvc++ -stdpar=gpu -std=c++20 -O4 -fast -march=native -Mllvm-fast -DNDEBUG -o daxpy solutions/exercise3.cpp\n",
     "!./daxpy 1000000"
    ]
   }

labs/lab1_daxpy/exercise1.cpp

@@ -27,23 +27,23 @@
 #include <limits>
 #include <string>
 #include <vector>
-#include <algorithm>
 // TODO: add C++ standard library includes as necessary
 // #include <...>
 
 /// Intialize vectors `x` and `y`: raw loop sequential version
 void initialize(std::vector<double> &x, std::vector<double> &y) {
   assert(x.size() == y.size());
-  // TODO: Initialize `x` using SEQUENTIAL std::for_each_n algorithm with std::views::iota
-  // TODO: Initialize `y` using SEQUENTIAL std::fill_n algorithm
+  for (std::size_t i = 0; i < x.size(); ++i) {
+    x[i] = (double)i;
+    y[i] = 2.;
+  }
 }
 
-/// DAXPY: AX + Y: raw loop sequential version
+/// DAXPY: AX + Y: sequential algorithm version
 void daxpy(double a, std::vector<double> const &x, std::vector<double> &y) {
   assert(x.size() == y.size());
-  // DONE: Implement using SEQUENTIAL transform algorithm
-  std::transform(x.begin(), x.end(), y.begin(), y.begin(),
-                 [&](double x, double y) { return a * x + y; });
+  // TODO: Implement using SEQUENTIAL transform algorithm
+  // ...
 }
 
 // Check solution
@@ -99,4 +99,4 @@ bool check(double a, std::vector<double> const &y) {
       return false;
   }
   return true;
-}
+}