Last few tweaks for miniforge

Author: kah3f

content/courses/fortran-introduction/array_intrinsics.md

@@ -25,6 +25,7 @@ These create new arrays from old. `PACK` and `UNPACK` can be used to "flatten" m
 
 ```fortran
 ! Convert an array from one shape to another (total size must match)
+! SHAPE must be a rank-one array whose elements are sizes in each dimension
 RESHAPE(SOURCE,SHAPE[,PAD][,ORDER])
 ! Combine two arrays of same shape and size according to MASK
 !   Take from ARR1 where MASK is .true., ARR2 where it is .false.
@@ -37,8 +38,10 @@ SPREAD(SOURCE,DIM,NCOPIES)
 ```
 **Example**
 ```fortran
+!Array and mask are of size NxM
 mask=A<0
 merge(A,0,mask)
+B=reshape(A,(/M,N/))
 ! for C=1, D=[1,2]
 print *, spread(C, 1, 2)            ! "1 1"
 print *, spread(D, 1, 2)            ! "1 1 2 2"

content/courses/parallel-computing-introduction/codes/a.out

@@ -7,9 +7,10 @@ program sendrows
 
    integer            :: nr, nc
    integer            :: rank, nprocs, tag=0
-   integer            :: errcode
-   type(MPI_Status)   :: recv_status
+   integer            :: err, errcode
    integer            :: ncount, blocklength, stride
+   type(MPI_Status),  dimension(:), allocatable  :: mpi_status_arr
+   type(MPI_Request), dimension(:), allocatable  :: mpi_requests
    type(MPI_Datatype) :: rows
 
    integer, parameter :: root=0
@@ -25,13 +26,19 @@ program sendrows
    nc=nprocs
 
    allocate(u(nr,nc),w(nr,nc))
+   allocate(mpi_requests(2*nprocs),mpi_status_arr(2*nprocs))
    u=0.0d0
    w=0.0d0
 
    !Cyclic sending
-   if (rank /= nprocs-1) then
+   if (rank == nprocs-1) then
+       src=rank-1
        dest=0
+   else if (rank==0) then
+       src=nprocs-1
+       dest=rank+1
    else
+       src=rank-1
        dest=rank+1
    endif
 
@@ -46,11 +53,23 @@ program sendrows
    do i=0,nprocs-1
        if (rank==i) then
            tag=i
-           call MPI_Recv(w(i+2,1),1,rows,source,tag,MPI_COMM_WORLD,recv_status)
-           call MPI_Send(u(i+1,1),1,rows,dest,tag,MPI_COMM_WORLD)
+           print *, i,i+1,i+nprocs+1
+           if (i==0) then
+               call MPI_Irecv(w(nprocs,1),1,rows,src,tag,MPI_COMM_WORLD,mpi_requests(i+1))
+               call MPI_Isend(u(i+1,1),1,rows,dest,tag,MPI_COMM_WORLD,mpi_requests(i+nprocs+1))
+            else if (i==nprocs-1) then
+               call MPI_Irecv(w(1,1),1,rows,src,tag,MPI_COMM_WORLD,mpi_requests(i+1))
+               call MPI_Isend(u(nprocs,1),1,rows,dest,tag,MPI_COMM_WORLD,mpi_requests(i+nprocs+1))
+            else
+               call MPI_Irecv(w(i+2,1),1,rows,src,tag,MPI_COMM_WORLD,mpi_requests(i+1))
+               call MPI_Isend(u(i+1,1),1,rows,dest,tag,MPI_COMM_WORLD,mpi_requests(i+nprocs+1))
+            endif
         endif
    enddo
 
+   call MPI_Waitall(size(mpi_requests),mpi_requests,mpi_status_arr)
+
+
    call MPI_TYPE_FREE(rows)
 
    !Print neatly

content/courses/parallel-computing-introduction/codes/mpi_vector_type.f90

@@ -9,11 +9,18 @@ menu:
         parent: Distributed-Memory Programming
 ---
 
+Using MPI requires access to a computer with at least one node with multiple cores.  The Message Passing Interface is a standard and there are multiple implementations of it, so a choice of distribution must be made.  Popular implementations include [MPICH](https://www.mpich.org/), [OpenMPI](https://www.open-mpi.org/), [MVAPICH2](https://mvapich.cse.ohio-state.edu/), and [IntelMPI](https://www.intel.com/content/www/us/en/developer/tools/oneapi/mpi-library.html#gs.gdkhva).  MPICH, OpenMPI, and MVAPICH2 must be built for a system, so a compiler must be chosen as well.  IntelMPI is typically used with the Intel compiler and is provided by the vendor as part of their [HPC Toolkit](https://www.intel.com/content/www/us/en/developer/tools/oneapi/hpc-toolkit.html#gs.gdkm8y).  MVAPICH2 is a version of MPICH that is specialized for high-speed [Infiniband](https://en.wikipedia.org/wiki/InfiniBand) networks on high-performance clusters, so would generally not be appropriate for installation on individual computers.
+
 ### On a Remote Cluster
 
-Refer to the instructions from your site, for example [UVA Research Computing](https://www.rc.virginia.edu/userinfo/howtos/rivanna/mpi-howto/) for our local environment.  Nearly always, you will be required to prepare your code and run it through a _resource manager_ such as [Slurm](https://www.rc.virginia.edu/userinfo/rivanna/slurm/).
+Refer to the instructions from your site, for example [UVA Research Computing](https://www.rc.virginia.edu/userinfo/howtos/rivanna/mpi-howto/) for our local environment.  Nearly always, you will be required to prepare your code and run it through a _resource manager_ such as [Slurm](https://www.rc.virginia.edu/userinfo/rivanna/slurm/).  Most HPC sites use a _modules_ system, so generally you will need to load modules for an MPI version and usually the corresponding compiler.  It is important to be sure that you use a version of MPI that can communicate correctly with your resource manager.
+```bash
+module load gcc
+module load openmpi
+```
+is an example setup for compiled-language users. 
 
-It is generally preferable, and may be required, that mpi4py be installed from the conda-forge repository.  On a cluster, mpi4py will need to link to a locally-built version of MPI that can communicate with the resource manager.  The conda-forge maintainers provide instructions for this [here]((https://conda-forge.org/docs/user/tipsandtricks/#using-external-message-passing-interface-mpi-libraries). In our example, we will use openmpi.  First we must load the modules for the compiler and MPI version:
+For Python, the mpi4py package is most widely available. It is generally preferable, and may be required, that mpi4py be installed from the conda-forge repository.  On a cluster, mpi4py will need to link to a locally-built version of MPI that can communicate with the resource manager.  The conda-forge maintainers provide instructions for this [here](https://conda-forge.org/docs/user/tipsandtricks/#using-external-message-passing-interface-mpi-libraries). In our example, we will use openmpi.  First we must load the modules for the compiler and MPI version:
 
 ```bash
 module load gcc openmpi
@@ -42,8 +49,6 @@ After this completes, we can install mpi4py
 conda install -c conda-forge mpi4py
 ```
 
-
-
 ### On a Local Computer
 
 If you have access to a multicore computer, you can run MPI programs on it.
@@ -56,7 +61,7 @@ The author of mpi4py [recommends](https://mpi4py.readthedocs.io/en/stable/instal
 ```no-highlight
 python -m pip install mpi4py
 ```
-This may avoid some issues that occasionally arise in prebuilt mpi4py packages. Be sure that an appropriate `mpicc` executable is in the path.  Alternatively, use the `conda-forge` channel (recommended in general for most scientific software). 
+This may avoid some issues that occasionally arise in prebuilt mpi4py packages. Be sure that an appropriate `mpicc` executable is in the path.  Alternatively, use the `conda-forge` channel (recommended in general for most scientific software).  Most of the time, if you are installing mpi4py from conda-forge, you can simply install the package.  MPICH is the default when installed as a prerequisite for conda-forge.
 
 #### Linux
 
@@ -71,7 +76,7 @@ Installing the HPC Toolkit will also install IntelMPI.
 _NVIDIA HPC SDK_
 The NVIDIA software ships with a precompiled version of OpenMPI.
 
-The headers and libraries for MPI _must_ match.  Using a header from one MPI and libraries from another, or using headers from a version from one compiler and libraries from a different compiler, usually results in some difficult-to-interpret bugs.  Moreover, the process manager must be compatible with the MPI used to compile the code.  Because of this, if more than one compiler and especially more than one MPI version is installed, the use of _modules_ ([environment modules](http://modules.sourceforge.net/) or [lmod](https://lmod.readthedocs.io/en/latest/)) becomes particularly beneficial.  Both Intel and NVIDIA provide scripts for the environment modules package (lmod can also read these), with possibly some setup required.  If you plan to use mpi4py as well as compiled-language versions, creating a module for your Python distribution would also be advisable.
+The headers and libraries for MPI _must_ match.  Using a header from one MPI and libraries from another, or using headers from a version from one compiler and libraries from a different compiler, usually results in some difficult-to-interpret bugs.  Moreover, the process manager must be compatible with the MPI used to compile the code.  Because of this, if more than one compiler and especially more than one MPI version is installed, the use of _modules_ ([environment modules](http://modules.sourceforge.net/) or [lmod](https://lmod.readthedocs.io/en/latest/)) becomes particularly beneficial.  Both Intel and NVIDIA provide scripts for the environment modules package (lmod can also read these), with possibly some setup required.  If you plan to use mpi4py as well as compiled-language versions, creating a module for your Python distribution would also be advisable. Installation of a module system on an individual Linux system is straightforward for an administrator with some experience.
 
 #### Mac OS
 
@@ -87,7 +92,7 @@ The NVIDIA suite is not available for Mac OS.
 #### Windows
 
 _GCC_
-The simplest way to use OpenMPI on Windows is through [Cygwin](https://www.cygwin.com/).  In this case, the gcc compiler suite would first be installed, with g++ and/or gfortran added.  Then the openmpi package could also be installed through the cygwin package manager.
+The easiest way to use OpenMPI on Windows is through [Cygwin](https://www.cygwin.com/).  In this case, the gcc compiler suite would first be installed, with g++ and/or gfortran added.  Then the openmpi package could also be installed through the cygwin package manager.
 
 _Intel oneAPI_
 Install the HPC Toolkit. 
@@ -98,4 +103,3 @@ Download the package when it is available.
 MPI codes must generally be compiled and run through a command line on Windows.  Cygwin users can find a variety of tutorials online, for example [here](https://www.youtube.com/watch?v=ENH70zSaztM). 
 
 The Intel oneAPI Basic Toolkit includes a customized command prompt in its folder in the Apps menu.
-

content/courses/parallel-computing-introduction/distributed_mpi_setup.md

@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

content/courses/parallel-computing-introduction/imgs/Jupyterlab-Desktop_change_kernel.png

@@ -0,0 +1,3 @@
+def hello():
+    print("Hello")
+    return None

content/courses/parallel-computing-introduction/imgs/Jupyterlab-Desktop_select_kernel.png

@@ -0,0 +1,61 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "6b7fb079-d472-4e57-aa65-ca9363bfc563",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import hello_func"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "319ee56c-7d85-47ef-adf8-6927cebf3b5d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hello\n"
+     ]
+    }
+   ],
+   "source": [
+    "hello_func.hello()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "624b0850-81eb-4035-bc8a-1dc6bfdb9d4d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

content/courses/parallel-computing-introduction/imgs/Jupyterlab_new_kernel.png

@@ -0,0 +1,3 @@
+def hello():
+    print("Hello")
+    return None