removed jupyter checkpoints

hpc/miniprofiler/Dockerfile

@@ -39,7 +39,7 @@ RUN apt-get update -y && \
 
 RUN apt-get update -y
 
-# NVIDIA nsight-systems-2020.1.1 nsight-compute-2020.1.1
+# NVIDIA nsight-systems-2020.2.1 nsight-compute-2020.1.1
 RUN DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends nsight-systems-2020.2.1 nsight-compute-2020.1.1
 
 RUN apt-get install --no-install-recommends -y build-essential

hpc/miniprofiler/English/.ipynb_checkpoints/profiling_start-checkpoint.ipynb

@@ -1,101 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Profiling Tutorial\n",
-    "\n",
-    "### Learning objectives\n",
-    "Learn how to profile your application with NVIDIA Nsight Systems and NVTX API calls to find performance limiters and bottlenecks and apply incremental parallelization strategies using OpenACC programming model. In this lab, you will:\n",
-    "\n",
-    "- Understand what a profiler is and which NVIDIA Nsight tool to choose in order to profile your application\n",
-    "- Profile a sequential weather modeling application (integrated with NVIDIA Tools Extension (NVTX) APIs) with NVIDIA Nsight Systems to capture and trace CPU events and time ranges\n",
-    "- Understand how to use NVIDIA Nsight Systems profiler’s report to detect hotspots and apply OpenACC compute constructs to the serial application to parallelise it on the GPU\n",
-    "- Learn how to use Nsight Systems to identify issues such as underutilized GPU device and unnecessary data movements in the application and to apply optimization strategies steps by steps to expose more parallelism and utilize computer’s CPU and GPU\n",
-    "- Learn how to use occupancy to address performance limitations\n",
-    "- Learn to follow cyclical process (analyze, parallelize, optimize) to help you identify the portions of the code that would benefit from GPU acceleration and apply parallelisation strategies and optimization techniques to see additional speedups and improve performance\n",
-    "\n",
-    "In this lab, we will be optimizing the serial Weather Simulation application written in both C and Fortran programming language. You are welcome to have a look at the mini weather lab and follow the steps to familiarize yourself with the application. \n",
-    "\n",
-    "An optional exercise on how to use Nsight Compute profiler is available for advanced users. This exercise covers basics on how and when to use the Nsight Compute profiler to get you started. Steps to unravel performance limiters will be presented through a simple exercise.\n",
-    "\n",
-    "\n",
-    "### Tutorial Outline\n",
-    "- Introduction ([C](C/jupyter_notebook/profiling-c.ipynb) , [Fortran](Fortran/jupyter_notebook/profiling-fortran.ipynb))\n",
-    "    - Overview of Nsight profiler tools\n",
-    "    - How to use NVTX APIs\n",
-    "    - Overview of [Mini Weather application](C/jupyter_notebook/miniweather.ipynb)\n",
-    "    - Optimization Steps to parallel programming with OpneACC\n",
-    "- Lab 1 ([C](C/jupyter_notebook/profiling-c-lab1.ipynb) , [Fortran](Fortran/jupyter_notebook/profiling-fortran-lab1.ipynb))\n",
-    "    - How to compile a serial application with PGI compiler\n",
-    "    - How to profile a serial application with Nsight Systems and NVTX APIs\n",
-    "    - How to use profiler's report to find hotspots\n",
-    "    - Scaling and Amdahl's law and why it matters\n",
-    "- Lab 2 ([C](C/jupyter_notebook/profiling-c-lab2.ipynb) , [Fortran](Fortran/jupyter_notebook/profiling-fortran-lab2.ipynb))\n",
-    "    - Parallelise the serial application using OpenACC compute directives\n",
-    "    - How to compile a parallel application with PGI compiler\n",
-    "    - What does the compiler feedback tell us\n",
-    "    - Profile with Nsight Systems\n",
-    "    - Finding bottlenecks from Nsight Systems report\n",
-    "- Lab 3 ([C](C/jupyter_notebook/profiling-c-lab3.ipynb) , [Fortran](Fortran/jupyter_notebook/profiling-fortran-lab3.ipynb))\n",
-    "    - How to combine the knowledge from compiler feedback and profiler to optimize the application\n",
-    "    - What is occupancy\n",
-    "    - Demystifying Gangs, Workers, and Vectors\n",
-    "    - Apply collapse clause to optimize the application further\n",
-    "- Lab 4 ([C](C/jupyter_notebook/profiling-c-lab4.ipynb) , [Fortran](Fortran/jupyter_notebook/profiling-fortran-lab4.ipynb))\n",
-    "    - Inspect data movement from the profiler's report\n",
-    "    - Data management with OpenACC\n",
-    "    - Apply incremental parallelization strategies and use profiler's report for the next step\n",
-    "- Lab 5 ([C](C/jupyter_notebook/profiling-c-lab5.ipynb) , [Fortran](Fortran/jupyter_notebook/profiling-fortran-lab5.ipynb))\n",
-    "    - Overview of Nsight Compute\n",
-    "    - When and How to use Nsight Compute\n",
-    "    - What does the profiler tell us, where is the bottleneck\n",
-    "    - How to use baselines with Nsight Compute\n",
-    "    \n",
-    "\n",
-    "### Tutorial Duration\n",
-    "The lab material will be presented in a 2hr session. Link to material is available for download at the end of the lab.\n",
-    "\n",
-    "### Content Level\n",
-    "Beginner, Intermediate\n",
-    "\n",
-    "### Target Audience and Prerequisites\n",
-    "The target audience for this lab is researchers/graduate students and developers who are interested in getting hands on experience with the NVIDIA Nsight System through profiling a real life parallel application using OpenACC programming model and NVTX.\n",
-    "\n",
-    "While this tutorial does not assume any expertise in CUDA experience, basic knowledge of OpenACC programming (e.g: compute constructs), GPU architecture, and programming experience with C/C++ or Fortran is desirable.\n",
-    "\n",
-    "### Start Here\n",
-    "You can choose between a [C-based code](C/jupyter_notebook/profiling-c.ipynb) and a [Fortran-based code](Fortran/jupyter_notebook/profiling-fortran.ipynb).\n",
-    "\n",
-    "--- \n",
-    "\n",
-    "## Licensing \n",
-    "\n",
-    "This material is released by NVIDIA Corporation under the Creative Commons Attribution 4.0 International (CC BY 4.0). \n"
-   ]
-  }
- ],
- "metadata": {
-  "anaconda-cloud": {},
-  "kernelspec": {
-   "display_name": "Python 3",
-   "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.7.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}

hpc/miniprofiler/English/C/jupyter_notebook/.ipynb_checkpoints/miniweather-checkpoint.ipynb

@@ -1,114 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# A MINI-WEATHER APPLICATION\n",
-    "\n",
-    "In this lab we will accelerate a Fluid Simulation in the context of atmosphere and weather simulation.\n",
-    "The mini weather code mimics the basic dynamics seen in the atmspheric weather and climate.\n",
-    "\n",
-    "The figure below demonstrates how a narrow jet of fast and slightly cold wind is injected into a balanced, neutral atmosphere at rest from the left domain near the model.\n",
-    "\n",
-    "<img src=\"images/Time.jpg\" width=\"80%\" height=\"80%\">\n",
-    "\n",
-    "Simulation is a repetitive process from 0 to the desired simulated time, increasing by Δt on every iteration.\n",
-    "Each Δt step is practically the same operation. Each simulation is solving a differential equation that represents how the flow of the atmosphere (fluid) changes according to small perturbations. To simplify this solution the code uses dimensional splitting: Each dimension X and Z are treated independently.\n",
-    "\n",
-    "<img src=\"images/X_Y.jpg\" width=\"80%\" height=\"80%\">\n",
-    "\n",
-    "The differential equation has a time derivative that needs integrating, and a simple low-storage Runge-Kutta ODE solver is used to integrate the time derivative. Each time step, the order in which the dimentions are solved is reversed, giving second-order accuracy. \n",
-    "\n",
-    "<img src=\"images/Range-Kutta.jpg\" width=\"70%\" height=\"70%\">\n",
-    "\n",
-    "### The objective of this exercise is not to dwell into the Maths part of it but to make use of OpenACC to parallelize and improve the performance.\n",
-    "\n",
-    "The general flow of the code is as shown in diagram below. For each time step the differential equations are solved.\n",
-    "\n",
-    "<img src=\"images/Outer_Loop.jpg\" width=\"70%\" height=\"70%\">\n",
-    "\n",
-    "\n",
-    "```cpp\n",
-    "while (etime < sim_time) {\n",
-    "    //If the time step leads to exceeding the simulation time, shorten it for the last step\n",
-    "    if (etime + dt > sim_time) { dt = sim_time - etime; }\n",
-    "    //Perform a single time step\n",
-    "    perform_timestep(state,state_tmp,flux,tend,dt);\n",
-    "    //Inform the user\n",
-    "    if (masterproc) { printf( \"Elapsed Time: %lf / %lf\\n\", etime , sim_time ); }\n",
-    "    //Update the elapsed time and output counter\n",
-    "    etime = etime + dt;\n",
-    "    output_counter = output_counter + dt;\n",
-    "    //If it's time for output, reset the counter, and do output\n",
-    "    if (output_counter >= output_freq) {\n",
-    "      output_counter = output_counter - output_freq;\n",
-    "      output(state,etime);\n",
-    "    }\n",
-    "  }\n",
-    "  \n",
-    "```\n",
-    "\n",
-    "At every time step the direction is reversed to get second order derivative.\n",
-    "\n",
-    "\n",
-    "<img src=\"images/Time_Step.jpg\" width=\"70%\" height=\"70%\">\n",
-    "\n",
-    "```cpp\n",
-    "void perform_timestep( double *state , double *state_tmp , double *flux , double *tend , double dt ) {\n",
-    "  if (direction_switch) {\n",
-    "    //x-direction first\n",
-    "    semi_discrete_step( state , state     , state_tmp , dt / 3 , DIR_X , flux , tend );\n",
-    "    semi_discrete_step( state , state_tmp , state_tmp , dt / 2 , DIR_X , flux , tend );\n",
-    "    semi_discrete_step( state , state_tmp , state     , dt / 1 , DIR_X , flux , tend );\n",
-    "    //z-direction second\n",
-    "    semi_discrete_step( state , state     , state_tmp , dt / 3 , DIR_Z , flux , tend );\n",
-    "    semi_discrete_step( state , state_tmp , state_tmp , dt / 2 , DIR_Z , flux , tend );\n",
-    "    semi_discrete_step( state , state_tmp , state     , dt / 1 , DIR_Z , flux , tend );\n",
-    "  } else {\n",
-    "    //z-direction second\n",
-    "    semi_discrete_step( state , state     , state_tmp , dt / 3 , DIR_Z , flux , tend );\n",
-    "    semi_discrete_step( state , state_tmp , state_tmp , dt / 2 , DIR_Z , flux , tend );\n",
-    "    semi_discrete_step( state , state_tmp , state     , dt / 1 , DIR_Z , flux , tend );\n",
-    "    //x-direction first\n",
-    "    semi_discrete_step( state , state     , state_tmp , dt / 3 , DIR_X , flux , tend );\n",
-    "    semi_discrete_step( state , state_tmp , state_tmp , dt / 2 , DIR_X , flux , tend );\n",
-    "    semi_discrete_step( state , state_tmp , state     , dt / 1 , DIR_X , flux , tend );\n",
-    "  }\n",
-    "  if (direction_switch) { direction_switch = 0; } else { direction_switch = 1; }\n",
-    "}\n",
-    "```\n",
-    "\n",
-    "<img src=\"images/Semi_Discrete.jpg\" width=\"70%\" height=\"70%\">\n",
-    "\n",
-    "--- \n",
-    "\n",
-    "## Licensing \n",
-    "\n",
-    "This material is released by NVIDIA Corporation under the Creative Commons Attribution 4.0 International (CC BY 4.0). "
-   ]
-  }
- ],
- "metadata": {
-  "anaconda-cloud": {},
-  "kernelspec": {
-   "display_name": "Python 3",
-   "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.7.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}

hpc/miniprofiler/English/C/jupyter_notebook/.ipynb_checkpoints/profiling-c-lab2-checkpoint.ipynb

@@ -1,184 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In this lab, we will optimize the weather simulation application written in C++ (if you prefer to use Fortran, click [this link](../../Fortran/jupyter_notebook/profiling-fortran.ipynb)). \n",
-    "\n",
-    "Let's execute the cell below to display information about the GPUs running on the server by running the pgaccelinfo command, which ships with the PGI compiler that we will be using. To do this, execute the cell block below by giving it focus (clicking on it with your mouse), and hitting Ctrl-Enter, or pressing the play button in the toolbar above. If all goes well, you should see some output returned below the grey cell."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!pgaccelinfo"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Exercise 2 \n",
-    "\n",
-    "### Learning objectives\n",
-    "Learn how to identify and parallelise the computationally expensive routines in your application using OpenACC compute constructs (A compute construct is a parallel, kernels, or serial construct.). In this exercise you will:\n",
-    "\n",
-    "- Implement OpenACC parallelism using parallel directives to parallelise the serial application\n",
-    "- Learn how to compile your parallel application with PGI compiler\n",
-    "- Benchmark and compare the parallel version of the application with the serial version\n",
-    "- Learn how to interpret PGI compiler feedback to ensure the applied optimization were successful"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "From the top menu, click on *File*, and *Open* `miniWeather_openacc.cpp` and `Makefile` from the current directory at `C/source_code/lab2` directory and inspect the code before running below cells. We have already added OpenACC compute directives (`#pragma acc parallel`) around the expensive routines (loops) in the code.\n",
-    "\n",
-    "Once done, compile the code with `make`. View the PGI compiler feedback (enabled by adding `-Minfo=accel` flag) and investigate the compiler feedback for the OpenACC code. The compiler feedback provides useful information about applied optimizations."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!cd ../source_code/lab2 && make clean && make"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's inspect part of the compiler feedback and see what it's telling us.\n",
-    "\n",
-    "<img src=\"images/cfeedback1.png\">\n",
-    "\n",
-    "- Using `-ta=tesla:managed`, instruct the compiler to build for an NVIDIA Tesla GPU using \"CUDA Managed Memory\"\n",
-    "- Using `-Minfo` command-line option, we will see all output from the compiler. In this example, we use `-Minfo=accel` to only see the output corresponding to the accelerator (in this case an NVIDIA GPU).\n",
-    "- The first line of the output, `compute_tendencies_x`, tells us which function the following information is in reference to.\n",
-    "- The line starting with 227, shows we created a parallel OpenACC loop. This loop is made up of gangs (a grid of blocks in CUDA language) and vector parallelism (threads in CUDA language) with the vector size being 128 per gang. `277, #pragma acc loop gang, vector(128) /* blockIdx.x threadIdx.x */`\n",
-    "- The rest of the information concerns data movement. Compiler detected possible need to move data and handled it for us. We will get into this later in this lab.\n",
-    "\n",
-    "It is very important to inspect the feedback to make sure the compiler is doing what you have asked of it.\n",
-    "\n",
-    "Now, let's **Run** the application for small values of `nx_glob`,`nz_glob`, and `sim_time`: **40, 20, 1000**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!cd ../source_code/lab2 && nsys profile -t nvtx,openacc --stats=true --force-overwrite true -o miniWeather_3 ./miniWeather 40 20 1000"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "You can see that the changes made actually slowed down the code and it runs slower compared to the non-accelerated CPU only version. Let's checkout the profiler's report. [Download the profiler output](../source_code/lab2/miniWeather_3.qdrep) and open it via the GUI. \n",
-    "\n",
-    "From the \"timeline view\" on the top pane, double click on the \"CUDA\" from the function table on the left and expand it. Zoom in on the timeline and you can see a pattern similar to the screenshot below. The blue boxes are the compute kernels and each of these groupings of kernels is surrounded by purple and teal boxes (annotated with red color) representing data movements. **Screenshots represents profiler report for the values of 400,200,1500.**\n",
-    "\n",
-    "<img src=\"images/nsys_slow.png\" width=\"80%\" height=\"80%\">\n",
-    "\n",
-    "Let's hover your mouse over kernels (blue boxes) one by one from each row and checkout the provided information.\n",
-    "\n",
-    "<img src=\"images/occu-1.png\" width=\"60%\" height=\"60%\">\n",
-    "\n",
-    "**Note**: In the next two exercises, we start optimizing the application by improving the occupancy and reducing data movements."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Post-Lab Summary\n",
-    "\n",
-    "If you would like to download this lab for later viewing, it is recommend you go to your browsers File menu (not the Jupyter notebook file menu) and save the complete web page.  This will ensure the images are copied down as well. You can also execute the following cell block to create a zip-file of the files you've been working on, and download it with the link below."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%bash\n",
-    "cd ..\n",
-    "rm -f openacc_profiler_files.zip\n",
-    "zip -r openacc_profiler_files.zip *"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**After** executing the above zip command, you should be able to download the zip file [here](../openacc_profiler_files.zip)."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "-----\n",
-    "\n",
-    "# <p style=\"text-align:center;border:3px; border-style:solid; border-color:#FF0000  ; padding: 1em\"> <a href=../../profiling_start.ipynb>HOME</a>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span style=\"float:center\"> <a href=profiling-c-lab3.ipynb>NEXT</a></span> </p>\n",
-    "\n",
-    "-----"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Links and Resources\n",
-    "\n",
-    "[OpenACC API Guide](https://www.openacc.org/sites/default/files/inline-files/OpenACC%20API%202.6%20Reference%20Guide.pdf)\n",
-    "\n",
-    "[NVIDIA Nsight System](https://docs.nvidia.com/nsight-systems/)\n",
-    "\n",
-    "[CUDA Toolkit Download](https://developer.nvidia.com/cuda-downloads)\n",
-    "\n",
-    "**NOTE**: To be able to see the Nsight System profiler output, please download Nsight System latest version from [here](https://developer.nvidia.com/nsight-systems).\n",
-    "\n",
-    "Don't forget to check out additional [OpenACC Resources](https://www.openacc.org/resources) and join our [OpenACC Slack Channel](https://www.openacc.org/community#slack) to share your experience and get more help from the community.\n",
-    "\n",
-    "--- \n",
-    "\n",
-    "## Licensing \n",
-    "\n",
-    "This material is released by NVIDIA Corporation under the Creative Commons Attribution 4.0 International (CC BY 4.0). "
-   ]
-  }
- ],
- "metadata": {
-  "anaconda-cloud": {},
-  "kernelspec": {
-   "display_name": "Python 3",
-   "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.7.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}

hpc/miniprofiler/English/Fortran/jupyter_notebook/.ipynb_checkpoints/profiling-fortran-lab2-checkpoint.ipynb

@@ -1,201 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In this lab, we will optimize the weather simulation application written in Fortran (if you prefer to use C++, click [this link](../../C/jupyter_notebook/profiling-c.ipynb)). \n",
-    "\n",
-    "Let's execute the cell below to display information about the GPUs running on the server by running the pgaccelinfo command, which ships with the PGI compiler that we will be using. To do this, execute the cell block below by giving it focus (clicking on it with your mouse), and hitting Ctrl-Enter, or pressing the play button in the toolbar above. If all goes well, you should see some output returned below the grey cell."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!pgaccelinfo"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Exercise 2 \n",
-    "\n",
-    "### Learning objectives\n",
-    "Learn how to identify and parallelise the computationally expensive routines in your application using OpenACC compute constructs (A compute construct is a parallel, kernels, or serial construct.). In this exercise you will:\n",
-    "\n",
-    "- Implement OpenACC parallelism using parallel directives to parallelise the serial application\n",
-    "- Learn how to compile your parallel application with PGI compiler\n",
-    "- Benchmark and compare the parallel version of the application with the serial version\n",
-    "- Learn how to interpret PGI compiler feedback to ensure the applied optimization were successful\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "From the top menu, click on *File*, and *Open* `miniWeather_openacc.f90` and `Makefile` from the current directory at `Fortran/source_code/lab2` directory and inspect the code before running below cells.We have already added OpenACC compute directives (`!$acc parallel loop`) around the expensive routines (loops) in the code.\n",
-    "\n",
-    "Once done, compile the code with `make`. View the PGI compiler feedback (enabled by adding `-Minfo=accel` flag) and investigate the compiler feedback for the OpenACC code. The compiler feedback provides useful information about applied optimizations."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!cd ../source_code/lab2 && make clean && make"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's inspect part of the compiler feedback and see what it's telling us.\n",
-    "\n",
-    "<img src=\"images/ffeedback1-0.png\">\n",
-    "\n",
-    "- Using `-ta=tesla:managed`, instruct the compiler to build for an NVIDIA Tesla GPU using \"CUDA Managed Memory\"\n",
-    "- Using `-Minfo` command-line option, we will see all output from the compiler. In this example, we use `-Minfo=accel` to only see the output corresponding to the accelerator (in this case an NVIDIA GPU).\n",
-    "- The first line of the output, `compute_tendencies_x`, tells us which function the following information is in reference to.\n",
-    "- The line starting with 247 and 252, shows we created a parallel OpenACC loop. This loop is made up of gangs (a grid of blocks in CUDA language) and vector parallelism (threads in CUDA language) with the vector size being 128 per gang. \n",
-    "- The line starting with 249 and 252, `Loop is parallelizable` of the output tells us that on these lines in the source code, the compiler found loops to accelerate.\n",
-    "- The rest of the information concerns data movement. Compiler detected possible need to move data and handled it for us. We will get into this later in this lab.\n",
-    "\n",
-    "It is very important to inspect the feedback to make sure the compiler is doing what you have asked of it.\n",
-    "\n",
-    "Now, **Run** the application for small values of `nx_glob`,`nz_glob`, and `sim_time`: **40, 20, 1000**. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!cd ../source_code/lab2 && ./miniWeather"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Profile** it with Nsight Systems command line `nsys`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!cd ../source_code/lab2 && nsys profile -t nvtx,openacc --stats=true --force-overwrite true -o miniWeather_3 ./miniWeather"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "You can see that the changes made actually slowed down the code and it runs slower compared to the non-accelerated CPU only version. Let's checkout the profiler's report. [Download the profiler output](../source_code/lab2/miniWeather_3.qdrep) and open it via the GUI. \n",
-    "\n",
-    "From the \"timeline view\" on the top pane, double click on the \"CUDA\" from the function table on the left and expand it. Zoom in on the timeline and you can see a pattern similar to the screenshot below. The blue boxes are the compute kernels and each of these groupings of kernels is surrounded by purple and teal boxes (annotated with red color) representing data movements. **Screenshots represents profiler report for the values of 400,200,1500.**\n",
-    "\n",
-    "<img src=\"images/nsys_slow.png\" width=\"80%\" height=\"80%\">\n",
-    "\n",
-    "Let's hover your mouse over kernels (blue boxes) one by one from each row and checkout the provided information.\n",
-    "\n",
-    "<img src=\"images/occu-1.png\" width=\"60%\" height=\"60%\">\n",
-    "\n",
-    "**Note**: In the next two exercises, we start optimizing the application by improving the occupancy and reducing data movements."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Post-Lab Summary\n",
-    "\n",
-    "If you would like to download this lab for later viewing, it is recommend you go to your browsers File menu (not the Jupyter notebook file menu) and save the complete web page.  This will ensure the images are copied down as well. You can also execute the following cell block to create a zip-file of the files you've been working on, and download it with the link below."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%bash\n",
-    "cd ..\n",
-    "rm -f openacc_profiler_files.zip\n",
-    "zip -r openacc_profiler_files.zip *"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**After** executing the above zip command, you should be able to download the zip file [here](../openacc_profiler_files.zip)."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "-----\n",
-    "\n",
-    "# <p style=\"text-align:center;border:3px; border-style:solid; border-color:#FF0000  ; padding: 1em\"> <a href=../../profiling_start.ipynb>HOME</a>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span style=\"float:center\"> <a href=profiling-fortran-lab3.ipynb>NEXT</a></span> </p>\n",
-    "\n",
-    "-----"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Links and Resources\n",
-    "\n",
-    "[OpenACC API Guide](https://www.openacc.org/sites/default/files/inline-files/OpenACC%20API%202.6%20Reference%20Guide.pdf)\n",
-    "\n",
-    "[NVIDIA Nsight System](https://docs.nvidia.com/nsight-systems/)\n",
-    "\n",
-    "[CUDA Toolkit Download](https://developer.nvidia.com/cuda-downloads)\n",
-    "\n",
-    "**NOTE**: To be able to see the Nsight System profiler output, please download Nsight System latest version from [here](https://developer.nvidia.com/nsight-systems).\n",
-    "\n",
-    "Don't forget to check out additional [OpenACC Resources](https://www.openacc.org/resources) and join our [OpenACC Slack Channel](https://www.openacc.org/community#slack) to share your experience and get more help from the community.\n",
-    "\n",
-    "--- \n",
-    "\n",
-    "## Licensing \n",
-    "\n",
-    "This material is released by NVIDIA Corporation under the Creative Commons Attribution 4.0 International (CC BY 4.0). "
-   ]
-  }
- ],
- "metadata": {
-  "anaconda-cloud": {},
-  "kernelspec": {
-   "display_name": "Python 3",
-   "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.7.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}

hpc/miniprofiler/Singularity

@@ -30,7 +30,7 @@ FROM: nvcr.io/hpc/pgi-compilers:ce
 
     apt-get install --no-install-recommends -y build-essential 
 
-# NVIDIA nsight-systems-2020.1.1 nsight-compute-2020.1.1
+# NVIDIA nsight-systems-2020.2.1 nsight-compute-2020.1.1
     apt-get update -y 
     DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends apt-transport-https ca-certificates gnupg wget
     echo "deb https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/ /" >> /etc/apt/sources.list.d/nsight.list 

hpc/openacc/English/.ipynb_checkpoints/START HERE-checkpoint.ipynb

@@ -1,45 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Welcome to the OpenACC Online Course Labs\n",
-    "\n",
-    "Welcome to the lab portion of the OpenACC online course, sposored by NVIDIA. Please select the appropriate lab below.\n",
-    "\n",
-    "* [Lab 1](./Lab1.ipynb)\n",
-    "* [Lab 2](./Lab2.ipynb)\n",
-    "* [Lab 3](./Lab3.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "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.7.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

hpc/openacc/English/.ipynb_checkpoints/openacc_start-checkpoint.ipynb

@@ -1,70 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Introduction to OpenACC Tutorial\n",
-    "\n",
-    "### Learning Objectives\n",
-    "\n",
-    "Learn how to program GPUs with OpenACC though hands on experience.\n",
-    "\n",
-    "### Tutorial Outline\n",
-    "- Lab 1: Introduction to OpenACC ([Lab 1](./Lab1.ipynb))\n",
-    "    - What is OpenACC and Why Should You Care?\n",
-    "    - Profile-driven Development\n",
-    "    - First Steps with OpenACC\n",
-    "    - Introduction to Parallel directive\n",
-    "    - How to compile a serial application with PGI compiler\n",
-    "- Lab 2: OpenACC Data Management ([Lab 2](./Lab2.ipynb))\n",
-    "    * OpenACC Data Management\n",
-    "    * OpenACC data directive/clauses\n",
-    "    * OpenACC update directive\n",
-    "- Lab 3 : Loop Optimizations with OpenACC ([Lab 3](./Lab3.ipynb))\n",
-    "    * Collapse clause\n",
-    "    * Tile clause\n",
-    "    * Gang Worker Vector\n",
-    "\n",
-    "\n",
-    "### Tutorial Duration\n",
-    "The lab material will be presented in a 3hr session. Link to material is available for download at the end of the lab.\n",
-    "\n",
-    "### Content Level\n",
-    "Beginner, Intermediate\n",
-    "\n",
-    "### Target Audience and Prerequisites\n",
-    "The target audience for this lab is researchers/graduate students and developers who are interested in learning about programming GPUs with OpenACC.\n",
-    "\n",
-    "Programming experience with C/C++ or Fortran is desirable.\n",
-    "\n",
-    "--- \n",
-    "\n",
-    "## Licensing \n",
-    "\n",
-    "This material is released by NVIDIA Corporation under the Creative Commons Attribution 4.0 International (CC BY 4.0). "
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "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.7.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}