{"type":"doc","content":[{"type":"paragraph","content":[{"text":"This year, we will have a coding exercise challenge!","type":"text"}]},{"type":"paragraph"},{"type":"extension","attrs":{"layout":"default","extensionType":"com.atlassian.confluence.macro.core","extensionKey":"toc","parameters":{"macroParams":{},"macroMetadata":{"macroId":{"value":"31e9aaf6-6fea-43f0-ad89-6bf81494b81f"},"schemaVersion":{"value":"1"},"title":"Table of Contents"}}}},{"type":"heading","attrs":{"level":1},"content":[{"text":"High Level Overview ","type":"text"}]},{"type":"paragraph","content":[{"text":"For this exercise, you will write a part of the code that simulates particles moving in a predefined manner within a two-dimensional space (bounding box). The bounding box is divided into a two dimensional grid of cells. The particles will be moving around in the bounding box with double precision floating point coordinates and belong to one of the cells based on their coordinates. In each cell, the particles are stored as a vector. The size of each cell is 1 X 1, making the entire bounding box have a size of n * n, where n is the number of cells per dimension. For your simulation, we will have a simulation size of 35 * 35, with 35 cells along each dimension. The coordinates of the particles in the simulation box will be between 0 and 35 along each dimension (0 <= x, y <= 35).","type":"text"}]},{"type":"paragraph","content":[{"type":"hardBreak"},{"text":"The entire simulation is written using the Charm++ parallel programming model and uses the power of the adaptive Charm++ runtime system to parallelize, automatically overlap computation and communication and balance imbalanced load. Your programming assignment is to write the serial (non-parallel) part of the program that moves each particle and then based on the movement of each particle, sends it to their adjacent cells. Your code will be called from the already written portions that parallelize the program and move the simulation forward. In addition to this, if you wish to answer the bonus question, you would also be writing some code to find out the cell with maximum and minimum number of particles and the values of the maximum and minimum particles across the bounding box using Charm++ custom reduction functions.","type":"text"}]},{"type":"paragraph","content":[{"text":"Expected output:","type":"text","marks":[{"type":"strong"}]},{"text":" Correctly send the particles to their right homes and ensure that no particle is lost in the simulation of the entire system. The bounding box is wrapped around i.e. the particles that leave a corner or edge loop back into the opposite corner or edge (explained clearly below). You can verify that no particle is being lost by making sure that the sum of all the particles, which is printed periodically, remains constant across iterations. Additionally, for answering the bonus question, determine the cell with the maximum and minimum particles and their values at the end of simulation. On submission, to ensure correctness, all of your output (particle positions, min value, min cell indices, max value, max cell indices) will be compared against our output that we have obtained from previous runs. We will use the total time taken by the simulation (also printed at the end of the simulation) to evaluate your team.","type":"text"}]},{"type":"paragraph","content":[{"text":"Note","type":"text","marks":[{"type":"strong"}]},{"text":": There might be multiple particles having the same x and y coordinates. You do not need to handle this case separately; it is a valid case assumption.","type":"text"}]},{"type":"heading","attrs":{"level":1},"content":[{"text":"Tasks","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Task 1: Compile charm++ and run simple programs","type":"text"}]},{"type":"paragraph","content":[{"text":"You can select one among several machine layers (or networking layers) to serve as your networking backend.","type":"text"}]},{"type":"bulletList","content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Consider using the flag ‘--with-production’ for the best optimizations","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Build with the smp mode to take advantage of shared memory optimizations ( ./build charm++ smp --with-production)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"After building successfully, try a simple program like tests/charm++/simplearrayhello to ensure that programs run successfully.","type":"text"}]}]}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Task 2: Complete the first section of the programming assignment","type":"text"}]},{"type":"paragraph","content":[{"text":"Untar the programming assignment tar file and then understand the coding assignment. After that, write code for the ","type":"text"},{"text":"Cell::updateParticles","type":"text","marks":[{"type":"strong"}]},{"text":" function in the ","type":"text"},{"text":"src/exercise.cpp","type":"text","marks":[{"type":"strong"}]},{"text":" file. You will be required to iterate through the particles vector and move each particle. After moving them, you will determine the particles that do not belong in my cell and then send them to the appropriate neighbor cells using helper methods. Run the simplistic version of the program using ","type":"text"},{"text":"‘make test’","type":"text","marks":[{"type":"strong"}]},{"text":".","type":"text"},{"type":"hardBreak"},{"type":"hardBreak"},{"text":"Note","type":"text","marks":[{"type":"strong"}]},{"text":": If you run ‘","type":"text"},{"text":"make test","type":"text","marks":[{"type":"strong"}]},{"text":"' before writing the code in ","type":"text"},{"text":"Cell::updateParticles","type":"text","marks":[{"type":"strong"}]},{"text":", your application will hang since it calls Cell::updateParticles (which is required to be filled in by you).","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Task 3: Debugging, testing and profiling","type":"text"}]},{"type":"paragraph","content":[{"text":"For debugging, you can compile your program with -g (and optionally -O0) and debug the program using gdb . Ensure that the program runs successfully with one rank ( or process) before debugging the multiple process case. While using gdb in the multiple process case, you can use an xterm to launch multiple gdb windows.","type":"text"}]},{"type":"paragraph","content":[{"text":"For testing, there is a C++ method in the simulation code named ","type":"text"},{"text":"Cell::verifyCorrectness","type":"text","marks":[{"type":"strong"}]},{"text":" that is called after the simulation. This method will read the data from the pre-computed output (which is known to be correct) and will compare it against your results. (NOTE that before version 3, there was a script called ","type":"text"},{"text":"scripts/evaluateOutput.sh ","type":"text","marks":[{"type":"strong"}]},{"text":"that was provided. However, with the verification integrated into the simulation, from version 3 onwards that script is not provided and is considered obsolete). ","type":"text"}]},{"type":"paragraph","content":[{"text":"For profiling, you can use the tool called ‘","type":"text"},{"text":"projections","type":"text","marks":[{"type":"strong"}]},{"text":"’ to analyze the performance of the charm++ program. The usage profile view is especially useful to view the load on each processor.","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Task 4: Bonus Question","type":"text"}]},{"type":"paragraph","content":[{"text":"For your bonus question, learn to use Charm++ custom reduction functions and add code to calculate the cell with the maximum number of particles and the minimum number of particles and their respective values. This will execute at the end of the simulation. On running the program with the bonus question, make sure to set ","type":"text"},{"text":"BONUS_QUESTION","type":"text","marks":[{"type":"strong"}]},{"text":" to ","type":"text"},{"text":"1","type":"text","marks":[{"type":"strong"}]},{"text":" in your makefile.","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Task 5: Benchmarking and Output submission","type":"text"}]},{"type":"paragraph","content":[{"text":"After you’ve verified the correctness of your code using the small target (","type":"text"},{"text":"make test","type":"text","marks":[{"type":"strong"}]},{"text":"), you can now run the actual full-sized simulation using the '","type":"text"},{"text":"make testbench","type":"text","marks":[{"type":"strong"}]},{"text":"' target. Optionally, you can use the ","type":"text"},{"text":"`+balancer `","type":"text","marks":[{"type":"strong"}]},{"text":" option in your run command to apply a load balancer to balance the imbalanced load. ","type":"text"},{"type":"hardBreak"},{"type":"hardBreak"},{"text":"Note","type":"text","marks":[{"type":"strong"}]},{"text":": Ensure that ","type":"text"},{"text":"LIVEVIZ_RUN ","type":"text","marks":[{"type":"strong"}]},{"text":"is set to 0 during your benchmarking run to avoid performance loss because of any visualization component.","type":"text"},{"type":"hardBreak"},{"type":"hardBreak"},{"text":"This year, since we are conducting the competition remotely, we will reproduce your results in order to validate your submission. After the completion of your run, when you are ready for submission, create a tar file (named ","type":"text"},{"text":"cc_.tar.gz) ","type":"text","marks":[{"type":"strong"}]},{"text":"with the following files and folders: ","type":"text"}]},{"type":"orderedList","attrs":{"order":1},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"A folder called ","type":"text"},{"text":"cc_src ","type":"text","marks":[{"type":"strong"}]},{"text":"with all the particle simulation source code files that were modified by you (including src/exercise.cpp). ","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"A folder called ","type":"text"},{"text":"cc_output","type":"text","marks":[{"type":"strong"}]},{"text":" with all the final simulation output files (should include all the sim_output_* files including sim_output_main). Also include the program output that is displayed to ","type":"text"},{"text":"stdout","type":"text","marks":[{"type":"code"}]},{"text":" in a file called sim_output_stdout. ","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"A file called ","type":"text"},{"text":"cc_jobscript.sh. ","type":"text","marks":[{"type":"strong"}]},{"text":"This is essentially your job script file that you used to run the final ","type":"text"},{"text":"‘testbench’","type":"text","marks":[{"type":"strong"}]},{"text":" target of the particle simulation. ","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"[OPTIONAL] A folder called ","type":"text"},{"text":"cc_charm_src ","type":"text","marks":[{"type":"strong"}]},{"text":"with the charm directory source code changes that were made by you. If you didn’t make any changes to the charm directory source code, you ","type":"text"},{"text":"do not","type":"text","marks":[{"type":"strong"}]},{"text":" have to submit this directory. ","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"A file called ","type":"text"},{"text":"cc_instructions.txt ","type":"text","marks":[{"type":"strong"}]},{"text":"with the following details: ","type":"text"}]},{"type":"orderedList","attrs":{"order":1},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Charm version: You can obtain this using the ‘VERSION’ file inside your charm directory. ","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Command used to build charm++ (Include any other commands used to build dependent libraries)","type":"text"}]}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"[OPTIONAL] A folder called ","type":"text"},{"text":"cc_additionals ","type":"text","marks":[{"type":"strong"}]},{"text":"with any other scripts or files that you think are relevant for reproducing your results. If you don’t have any other additional files, you ","type":"text"},{"text":"do not ","type":"text","marks":[{"type":"strong"}]},{"text":"have to submit this directory. ","type":"text"}]}]}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Task 6: Visualization and video","type":"text"}]},{"type":"paragraph","content":[{"text":"Install the Charm++ visualization tool called ","type":"text"},{"text":"liveViz","type":"text","marks":[{"type":"strong"}]},{"text":" on your laptop. Build a netlrts version of Charm++ (on your laptop) and compile the particle simulation program with ","type":"text"},{"text":"LIVEVIZ_RUN","type":"text","marks":[{"type":"strong"}]},{"text":" set to ","type":"text"},{"text":"1.","type":"text","marks":[{"type":"strong"}]},{"text":" Run the particle simulation with the ‘","type":"text"},{"text":"make testviz","type":"text","marks":[{"type":"strong"}]},{"text":"’ target and in a separate window, connect the liveViz client to the running program to visualize the particle simulation. Capture your screen and generate a video showing the movement of particles in the 2D space. ","type":"text"}]},{"type":"paragraph","content":[{"text":"Note: ","type":"text","marks":[{"type":"strong"}]},{"text":"You have to use the ","type":"text"},{"text":"netlrts ","type":"text","marks":[{"type":"strong"}]},{"text":"machine layer for this part of the exercise, since this functionality is not supported on other machine layers. It is highly recommended to do all of this task on a smaller machine like a laptop/desktop.","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Task 7: Let others know","type":"text"}]},{"type":"paragraph","content":[{"text":"Add a team name-tag or a team photo in small into the video (to mark it) and post to your team’s twitter account if you have, or linkedIn account with the hashtags ","type":"text"},{"text":"#ISC20","type":"text","marks":[{"type":"strong"}]},{"text":" ","type":"text"},{"text":"#ISC20_SCC","type":"text","marks":[{"type":"strong"}]},{"text":" ","type":"text"},{"text":"@Charmplusplus","type":"text","marks":[{"type":"strong"}]},{"text":". If you don’t use social media, you can submit the file using a flash drive.","type":"text"}]},{"type":"paragraph"},{"type":"heading","attrs":{"level":1},"content":[{"text":"Details ","type":"text","marks":[{"type":"strong"}]}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Charm++ Introduction","type":"text","marks":[{"type":"strong"}]}]},{"type":"paragraph","content":[{"text":"Charm++ is a C++-based parallel programming system, founded on the migratable-objects programming model, and supported by a novel and powerful adaptive runtime system. It supports both irregular as well as regular applications, and can be used to specify task-parallelism as well as data parallelism in a single application. It automates dynamic load balancing for task-parallel as well as data-parallel applications, via separate suites of load-balancing strategies. Via its message-driven execution model, it supports automatic latency tolerance, modularity, and parallel composition. Charm++ also supports automatic checkpoint/restart, as well as fault tolerance based on distributed checkpoints.","type":"text"}]},{"type":"paragraph","content":[{"type":"hardBreak"},{"text":"Charm++ is a production-quality parallel programming system used by multiple applications in science and engineering on supercomputers as well as smaller clusters around the world. Currently the parallel platforms supported by Charm++ are the IBM BlueGene/Q and OpenPOWER systems, Cray XE, XK, and XC systems, Omni-Path and Infiniband clusters, single workstations and networks of workstations (including x86 (running Linux, Windows, MacOS)), etc. The communication protocols and infrastructures supported by Charm++ are UDP, MPI, OFI, UCX, Infiniband, uGNI, and PAMI. Charm++ programs can run without changing the source on all these platforms. Notable Charm++ applications that are regularly run on leading supercomputers across the world are NAMD (molecular dynamics), ChaNGa (n-body cosmological simulations), Episimdemics (contagion in social networks) and OpenAtom (Ab initio Molecular Dynamics) among many others.","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Particle Simulation Introduction","type":"text","marks":[{"type":"strong"}]}]},{"type":"paragraph","content":[{"text":"The particle simulation is written using the Charm++ parallel programming model and it simulates a set of particles moving in a 2-dimensional space within a bounding box. The bounding box is divided into a two dimensional grid of cells. The particles moving around in the bounding box have (x,y) floating point coordinates and belong to one of the cells based on their coordinates. In each cell, the particles are stored as vector. The size of each cell is 1 X 1, making it n X n for a simulation involving n cells in each dimension. In the code, the variable '","type":"text"},{"text":"numCellsPerDim","type":"text","marks":[{"type":"em"}]},{"text":"' represents the number of cells along each dimension of the bounding box.","type":"text"}]},{"type":"paragraph","content":[{"text":"Each cell also has many particles that move around in a specific manner and in that process could go to the ","type":"text"},{"text":"8 neighboring cells","type":"text","marks":[{"type":"strong"}]},{"text":", which are Top-Left, Top, Top-Right, Left, Right, Bottom-Left, Bottom, and Bottom-Right.","type":"text"}]},{"type":"mediaSingle","attrs":{"layout":"center"},"content":[{"type":"media","attrs":{"width":263,"id":"e03d37bd-6d8f-4a2c-b651-5d656eff0a5d","collection":"contentId-1326645310","type":"file","height":252}}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"The bounding box (i.e. the simulation space) ","type":"text"},{"text":"is wrapped around","type":"text","marks":[{"type":"strong"}]},{"text":", i.e. all the edge cells and corner cells loop","type":"text"}]},{"type":"paragraph","content":[{"text":"back along each edge and corner.","type":"text"}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"For example, In a 5x5 grid, cell (4,2) will have the following neighbors:","type":"text"}]},{"type":"bulletList","content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Top Left Neighbor : (3,1)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Top Neighbor : (3,2)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Top Right Neighbor : (3,3)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Left Neighbor : (4,1)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Right Neighbor : (4,3)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Bottom Left Neighbor : (0,1)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Bottom Neighbor : (0,2)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Bottom Right Neighbor : (0,3)","type":"text"}]}]}]},{"type":"mediaSingle","attrs":{"layout":"center"},"content":[{"type":"media","attrs":{"width":519,"id":"670a1110-6a72-4055-be24-297e06b1aec3","collection":"contentId-1326645310","type":"file","height":466}}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"Similarly, cell (0,4) will have the following neighbors:","type":"text"}]},{"type":"bulletList","content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Top Left Neighbor : (4,3)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Top Neighbor : (4,4)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Top Right Neighbor : (4,0)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Left Neighbor : (0,3)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Right Neighbor : (0,0)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Bottom Left Neighbor : (1,3)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Bottom Neighbor : (1,4)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Bottom Right Neighbor : (1,0)","type":"text"}]}]}]},{"type":"mediaSingle","attrs":{"layout":"center"},"content":[{"type":"media","attrs":{"width":529,"id":"ccb54d48-7ebf-4541-8cb0-2e4247ec8e72","collection":"contentId-1326645310","type":"file","height":524}}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Input Parameters","type":"text"}]},{"type":"paragraph","content":[{"text":"The simulation takes the following input parameters","type":"text"}]},{"type":"orderedList","attrs":{"order":1},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Grid Size (Creates a grid of cells of Grid Size X Grid Size, same as the 'n' parameter explained above)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Particles per cell seed value","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Number of Iterations","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Green Particles (Lower Triangular Half) distribution ratio","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Blue Particles (Upper Triangular Half) distribution ratio","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Red Particles (Diagonal) distribution ratio","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Red Particles (Central Box) distribution ratio","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Velocity Reduction Factor","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Log Output","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Load Balancing Frequency","type":"text"}]}]}]},{"type":"paragraph","content":[{"type":"hardBreak"},{"text":"The simulation consists of three types of particles: Green, Blue and Red. Green particles are added to the lower triangular half of the bounding box. Blue particles are added to the upper triangular half of the bounding box. Red particles are added to the diagonal and a central box in the middle of the bounding box. The particle color plays a role in affecting the speed of the particle ( Red > Blue > Green).","type":"text"}]},{"type":"paragraph","content":[{"text":"The distribution ratios are used to populate the bounding box with the particles before the beginning of simulation. The velocity reduction factor is used to slow the speed of particles by a constant factor.","type":"text"}]},{"type":"paragraph","content":[{"text":"The ","type":"text"},{"text":"log output","type":"text","marks":[{"type":"strong"}]},{"text":" (accepts 'yes' or 'no') determines if the output of the program should be written to files or not. Setting it to 'yes' will cause the simulation output to be logged to files inside the ","type":"text"},{"text":"output","type":"text","marks":[{"type":"code"}]},{"text":" directory. Setting it to 'no' will cause the program to not write the output to files. This is an input parameter that can be used by the users for debugging. It is important to note that the time taken for writing the output to files, is not counted in the total simulation time and hence, will not affect your score. (Also NOTE that this variable was earlier called ","type":"text"},{"text":"outputprompt","type":"text","marks":[{"type":"strong"}]},{"text":". However, with the change in the verification process i.e. with output verification integrated inside the program, the previous variable was no longer required and hence modified to ","type":"text"},{"text":"logoutput","type":"text","marks":[{"type":"strong"}]},{"text":"). ","type":"text"}]},{"type":"paragraph","content":[{"text":"The ","type":"text"},{"text":"load balancing frequency","type":"text","marks":[{"type":"strong"}]},{"text":" is the number of iterations for which load balancing occurs in the runtime system. During load balancing, parallel objects are migrated from the overloaded processors to the underloaded processes. For this assignment, it is a tunable parameter to get better performance from the application. Note that for load balancing frequency to play a part in the application, '","type":"text"},{"text":"+balancer ","type":"text","marks":[{"type":"strong"}]},{"text":"' should be passed to the application.","type":"text"}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"In the particle simulation, the simulation begins after the initial population of cells with particles based on the particle distribution ratios. Particles move in a pre-defined manner (when you call the perturb function). Based on the particle's new position, it is your responsibility to determine if the particle is still in the same cell or if it has to be transferred to one of the adjacent cells. In the case of the particle not belonging to the same cell, you need to send the particle to the new cell, where it belongs. For each iteration, every particle in each cell is moved (perturbed) and then, the cell sends 8 messages to 8 of its neighboring cells (TL, T, TR, L, R, BL, B, BR, as explained above). After sending the 8 messages, each cell waits for 8 incoming messages from its neighbors, consisting of particles that belong to it. These new particles that belong to the cell are added to the existing particles of the cell. Note that, it is your task to only move and send the particles (the 8 outgoing messages) to 8 neighboring cells. The already written skeleton code takes care of waiting for the 8 incoming messages and adding them to the cell. This process of moving the particle, sending 8 outgoing messages and waiting for 8 incoming messages is repeated for every cell, for every iteration of the simulation. The simulation completes when the ongoing count of iterations reaches the total number of iterations.","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Charm++ Setup","type":"text"}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"1. Download the latest Charm++ release","type":"text"}]},{"type":"codeBlock","content":[{"text":"$ wget https://github.com/UIUC-PPL/charm/archive/v6.10.1.tar.gz\n...\n$ tar xzf v6.10.1.tar.gz","type":"text"}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"2. Build charm++ using a suitable machine layer (or networking layer)","type":"text"}]},{"type":"paragraph","content":[{"text":"On a commodity ethernet cluster, use the netlrts build. For proprietary networks, use the appropriate machine layer (Eg - gni for Cray gemini interconnect, pami for IBM pami interconnect, ucx for Infiniband, ofi for Intel Omnipath). Since charm has a MPI backend, optionally, you can also build Charm++ with an MPI backend and compare its performance against the native machine layer.","type":"text"}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"Consider using the '--with-production' flag for the best optimizations.","type":"text"}]},{"type":"codeBlock","content":[{"text":"$ ./build charm++ -linux-x86_64 --with-production -j4","type":"text"}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"Build with the smp mode to take advantage of shared memory optimizations:","type":"text"}]},{"type":"codeBlock","content":[{"text":"$ ./build charm++ -linux-x86_64 smp -j4","type":"text"}]},{"type":"paragraph","content":[{"type":"hardBreak"}]},{"type":"paragraph","content":[{"text":"Refer ","type":"text"},{"text":"https://charm.readthedocs.io/en/latest/charm++/manual.html#installing-charm","type":"text","marks":[{"type":"link","attrs":{"href":"https://charm.readthedocs.io/en/latest/charm++/manual.html#installing-charm"}}]},{"text":" for more information","type":"text"}]},{"type":"paragraph","content":[{"text":"on building Charm++","type":"text"}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"3. After building successfully, try a simple program like ","type":"text"},{"text":"tests/charm++/simplearrayhello","type":"text","marks":[{"type":"strong"}]},{"text":" to ensure that","type":"text"}]},{"type":"paragraph","content":[{"text":"programs run successfully.","type":"text"}]},{"type":"codeBlock","content":[{"text":"$ make test\n$ ../../../bin/charmc hello.ci\n$ ../../../bin/charmc -c hello.C\n$ ../../../bin/charmc -language charm++ -o hello hello.o\n$ ../../../bin/testrun ./hello +p4 10\n$ Charmrun> scalable start enabled.\n$ Warning: No xauth data; using fake authentication data for X11 forwarding.\n$ X11 forwarding request failed on channel 1\n$ Charmrun> started all node programs in 1.147 seconds.\n$ Charm++> Running in non-SMP mode: 4 processes (PEs)\n$ Converse/Charm++ Commit ID: v6.10.1-0-gcc60a79\n$ Charm++> scheduler running in netpoll mode.\n$ CharmLB> Load balancer assumes all CPUs are same.\n$ Charm++> Running on 1 hosts (1 sockets x 4 cores x 2 PUs = 8-way SMP)\n$ Charm++> cpu topology info is gathered in 0.001 seconds.\n$ Running Hello on 4 processors for 10 elements\n$ [0] Hello 0 created\n$ [0] Hello 1 created\n$ [0] Hello 2 created\n$ [0] Hi[17] from element 0\n$ [0] Hi[18] from element 1\n$ [0] Hi[19] from element 2\n$ [2] Hello 6 created\n$ [2] Hello 7 created\n$ [3] Hello 8 created\n$ [3] Hello 9 created\n$ [1] Hello 3 created\n$ [1] Hello 4 created\n$ [1] Hello 5 created\n$ [1] Hi[20] from element 3\n$ [1] Hi[21] from element 4\n$ [1] Hi[22] from element 5\n$ [2] Hi[23] from element 6\n$ [2] Hi[24] from element 7\n$ [3] Hi[25] from element 8\n$ [3] Hi[26] from element 9\n$ All done\n$ [Partition 0][Node 0] End of program\n$\n$ real 0m1.184s\n$ user 0m0.015s\n$ sys 0m0.016s","type":"text"}]},{"type":"paragraph"},{"type":"heading","attrs":{"level":2},"content":[{"text":"Coding Assignment (Particle Simulation) Setup","type":"text","marks":[{"type":"strong"}]}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"1. Untar the charm-exercise.tar.gz that will be provided to you","type":"text"}]},{"type":"codeBlock","content":[{"text":"$ MacBook-Pro-37:~ nitinbhat$ tar -xvf charm-exercise.tar.gz\n...\n","type":"text"}]},{"type":"paragraph","content":[{"text":"2. cd into charm-exercise (the recently tar-ed folder) and set CHARM_HOME in the Makefile to","type":"text"}]},{"type":"paragraph","content":[{"text":"point to your charm installation directory.","type":"text"}]},{"type":"codeBlock","content":[{"text":"$ CHARM_HOME=/Users/nitinbhat/Work/software/charm/netlrts-darwin-x86_64-prod","type":"text"}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"3. Run '","type":"text"},{"text":"make test'","type":"text","marks":[{"type":"strong"}]},{"text":" to ensure that all files compile and the executable is launched. The program","type":"text"}]},{"type":"paragraph","content":[{"text":"will hang because ","type":"text"},{"text":"Cell::updateParticles(int iter) ","type":"text","marks":[{"type":"strong"}]},{"text":"is empty currently (and requires you to code","type":"text"}]},{"type":"paragraph","content":[{"text":"the remaining parts).","type":"text"},{"type":"hardBreak"}]},{"type":"paragraph","content":[{"text":"4. Run ","type":"text"},{"text":"make testbench","type":"text","marks":[{"type":"strong"}]},{"text":" to test it on a larger size, Check the Makefile.","type":"text"},{"type":"hardBreak"}]},{"type":"codeBlock","content":[{"text":"$ make test\n./charmrun +p4 ./particle 100 4 100 1,2,3,10 5 yes 5\n\nRunning on 4 processors: ./particle 100 4 100 1,2,3,10 5 yes 5\n./charmrun: line 106: mvapich2-start-mpd: command not found\nCharm++> Running in non-SMP mode: 4 processes (PEs)\nConverse/Charm++ Commit ID: v6.10.1-0-gcc60a792d\nWarning> Randomization of virtual memory (ASLR) is turned on in the kernel, thread migration may not work! Run 'echo 0 > /proc/sys/kernel/randomize_va_space' as root to disable it, or try running with '+isomalloc_sync'.\nCharmLB> Load balancer assumes all CPUs are same.\nCharm++> Running on 1 hosts (2 sockets x 12 cores x 1 PUs = 24-way SMP)\nCharm++> cpu topology info is gathered in 0.005 seconds.\n================================ Input Params ===============================\n====================== Particles In A Box Simulation ========================\nGrid Size = 4 X 4\nParticles/Cell seed value = 100\nNumber of Iterations = 100\nGreen Particles (Lower Triangular Half) distribution ratio = 1\nBlue Particles (Upper Triangular Half) distribution ratio = 2\nRed Particles (Diagonal) distribution ratio = 3\nRed Particles (Central Box) distribution ratio = 10\nVelocity Reduction Factor = 5\nLog Output = 1\nLoad Balancing Frequency = 5\n=============================================================================\n======================= Launching Particle Simulation =======================\nIteration: 5, Outgoing Particles Sum: 543, Total Particles: 4000\nIteration: 10, Outgoing Particles Sum: 707, Total Particles: 4000\n...\n...\n...\nIteration: 100, Outgoing Particles Sum: 870, Total Particles: 4000\n======================= Particle Simulation Complete ========================\nSimulation Complete, total time taken is 0.061054 seconds\n=============================================================================\n=============================================================================\nSuccess! Simulation correctness verified across all cells\n=============================================================================\nFinal summarized output has been written to: output/sim_output_15-55-59-789815-4-100-100/sim_output_main\nAll particle output has been written to files in directory : output/sim_output_15-55-59-789815-4-100-100\nExiting program\n[Partition 0][Node 0] End of program\n\n\n\n\n$ ./charmrun +p96 ./particle 10000 35 1000 1,2,30,10 5 no 5\n\nRunning on 96 processors: ./particle 10000 35 1000 1,2,30,10 5 no 5\n./charmrun: line 106: mvapich2-start-mpd: command not found\nCharm++> Running in non-SMP mode: 96 processes (PEs)\nConverse/Charm++ Commit ID: v6.10.1-0-gcc60a792d\nWarning> Randomization of virtual memory (ASLR) is turned on in the kernel, thread migration may not work! Run 'echo 0 > /proc/sys/kernel/randomize_va_space' as root to disable it, or try running with '+isomalloc_sync'.\nCharmLB> Load balancer assumes all CPUs are same.\nCharm++> Running on 4 hosts (2 sockets x 12 cores x 1 PUs = 24-way SMP)\nCharm++> cpu topology info is gathered in 0.062 seconds.\n================================ Input Params ===============================\n====================== Particles In A Box Simulation ========================\nGrid Size = 35 X 35\nParticles/Cell seed value = 10000\nNumber of Iterations = 1000\nGreen Particles (Lower Triangular Half) distribution ratio = 1\nBlue Particles (Upper Triangular Half) distribution ratio = 2\nRed Particles (Diagonal) distribution ratio = 30\nRed Particles (Central Box) distribution ratio = 10\nVelocity Reduction Factor = 5\nLog Output = 0\nLoad Balancing Frequency = 5\n=============================================================================\n======================= Launching Particle Simulation =======================\nIteration: 5, Outgoing Particles Sum: 5399671, Total Particles: 34750000\nIteration: 10, Outgoing Particles Sum: 5436386, Total Particles: 34750000\nIteration: 15, Outgoing Particles Sum: 5696982, Total Particles: 34750000\nIteration: 20, Outgoing Particles Sum: 5727058, Total Particles: 34750000\nIteration: 25, Outgoing Particles Sum: 5602325, Total Particles: 34750000\nIteration: 30, Outgoing Particles Sum: 5579097, Total Particles: 34750000\n...\n...\n...\nIteration: 980, Outgoing Particles Sum: 2331920, Total Particles: 34750000\nIteration: 985, Outgoing Particles Sum: 2325854, Total Particles: 34750000\nIteration: 990, Outgoing Particles Sum: 2322346, Total Particles: 34750000\nIteration: 995, Outgoing Particles Sum: 2320412, Total Particles: 34750000\nIteration: 1000, Outgoing Particles Sum: 2315199, Total Particles: 34750000\n======================= Particle Simulation Complete ========================\nSimulation Complete, total time taken is 226.429119 seconds\n=============================================================================\n=============================================================================\nSuccess! Simulation correctness verified across all cells\n=============================================================================\nFinal summarized output has been written to: output/sim_output_17-10-44-916566-35-10000-1000/sim_output_main\nExiting program\n[Partition 0][Node 0] End of program","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Coding Assignment Task","type":"text"}]},{"type":"paragraph","content":[{"text":"Your exercise is to add code for two functions:","type":"text"}]},{"type":"bulletList","content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"The main part of the exercise is to add code in ","type":"text"},{"text":"Cell::updateParticles","type":"text","marks":[{"type":"strong"}]},{"text":".","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"The bonus part of the exercise is to add code in ","type":"text"},{"text":"Cell::contributeToReduction","type":"text","marks":[{"type":"strong"}]},{"text":", ","type":"text"},{"text":"Main::receiveMinMaxReductionData","type":"text","marks":[{"type":"strong"}]},{"text":", and global ","type":"text"},{"text":"function:calculateMaxMin","type":"text","marks":[{"type":"strong"}]},{"text":". For this part, you would need to understand how custom reduction functions are written in Charm++ in order to write the reduction function for calculating the min value, the min cell indices, the max value, and the max cell indices.","type":"text"}]}]}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Main task:","type":"text"}]},{"type":"paragraph","content":[{"text":"The ","type":"text"},{"text":"Cell::updateParticles","type":"text","marks":[{"type":"strong"}]},{"text":" function is called for each cell in the grid. It is called for each iteration of the","type":"text"}]},{"type":"paragraph","content":[{"text":"simulation to perform the following functionalities:","type":"text"}]},{"type":"bulletList","content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Move (or Perturb) the particles","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Determine the cell location of the newly moved particles i.e. determine if the particle still belongs to me or does it belong to one of my 8 neighboring cells.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Make sure that particles that go outside the bounding box are wrapped back.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Send particles that belong to my neighboring cells using the Cell::sendParticles function.","type":"text"}]}]}]},{"type":"paragraph","content":[{"text":"Your assignment is to add code into Cell::updateParticles in the file ","type":"text"},{"text":"src/exercise.cpp","type":"text","marks":[{"type":"strong"}]},{"text":" to add the functionalities described above. It is important to note that sendParticles is called 8 times to send outgoing messages to the 8 adjacent cells or neighbors, since they are waiting on messages from all their neighbors. Failing to send messages to the neighbors will cause a hang.","type":"text"},{"type":"hardBreak"},{"text":" ","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"type":"hardBreak"},{"text":"Bonus exercise","type":"text"}]},{"type":"paragraph","content":[{"text":"Understand custom reductions from the manual, refer to ","type":"text"},{"text":"https://charm.readthedocs.io/en/latest/charm++/manual.html#defining-a-new-reduction-type","type":"text","marks":[{"type":"link","attrs":{"href":"https://charm.readthedocs.io/en/latest/charm++/manual.html#defining-a-new-reduction-type"}}]},{"text":".","type":"text"}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"The","type":"text"},{"text":" Cell::contributeToReduction","type":"text","marks":[{"type":"strong"}]},{"text":" function is called for each cell in the grid. It is called at the end of the simulation i.e. after all iterations, to contribute to the custom reduction operation (as specified in the global reduction function calculateMaxMin). ","type":"text"},{"text":"calculateMaxMin ","type":"text","marks":[{"type":"strong"}]},{"text":"is the custom reduction function that gets reduction msgs from the contributors and needs to perform the reduction operation on the received data. Finally, on completion of the reduction operation, the callback pointing to ","type":"text"},{"text":"Main::receiveMinMaxReductionData","type":"text","marks":[{"type":"strong"}]},{"text":" will be invoked with the final reduction data.","type":"text"}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"Your coding assignment bonus exercise is to","type":"text"}]},{"type":"bulletList","content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Add code in ","type":"text"},{"text":"Cell::contributeToReduction","type":"text","marks":[{"type":"strong"}]},{"text":" in the file ","type":"text"},{"text":"src/exercise.cpp","type":"text","marks":[{"type":"strong"}]},{"text":" to declare the reduction data and assign the declared data with the different values being reduced (min value, min x index, min y index, max value, max x index and max y index). Following the data declaration, declare a callback to Main::receiveMinMaxReductionData and call contribute passing the size, data, reduction type i.e minMaxType and the declared callback. Note that the custom reduction type, 'minMaxType' has already been declared to use calculateMaxMin.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Add code in ","type":"text"},{"text":"calculateMinMax ","type":"text","marks":[{"type":"strong"}]},{"text":"to implement the reduction operations for the data being received.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Add code in ","type":"text"},{"text":"Main::receiveMinMaxReductionData ","type":"text","marks":[{"type":"strong"}]},{"text":"to initialize the variables with the final reduction values. These variables are maxParticles, maxCellX, maxCellY, minParticles, minCellX and minCellY. Note that, Main::receiveMinMaxReductionData is called after the reduction operation is complete.","type":"text"},{"type":"hardBreak"}]}]}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Testing your program","type":"text"},{"type":"hardBreak"}]},{"type":"paragraph","content":[{"text":"On completing the main task (and optionally the bonus task), run the small target '","type":"text"},{"text":"make test","type":"text","marks":[{"type":"strong"}]},{"text":"' and ensure that the value of the total particles in the simulation is not changing across iterations. The unchanged value indicates that no particles are lost in the simulation. A changing value indicates a bug in your code. ","type":"text"}]},{"type":"paragraph","content":[{"text":"After you have verified the unchanging value of the total number of particles, the correctness verification is performed inside the ","type":"text"},{"text":"Cell::verifyCorrectness","type":"text","marks":[{"type":"strong"}]},{"text":" method after the simulation. (Note that the previous method of running ","type":"text"},{"text":"src/evaluteOutput.sh ","type":"text","marks":[{"type":"strong"}]},{"text":"is now obsolete). ","type":"text"},{"type":"hardBreak"},{"type":"hardBreak"},{"text":"Note that the previous script ","type":"text"},{"text":"src/evaluateOutput.sh ","type":"text","marks":[{"type":"strong"}]},{"text":"was comparing coordinates using a naive diff between the simulation output and the pre-computed output. The current method is an improved method that compares the coordinate values using ","type":"text"},{"text":"fabs(precomputeParticles[i].x - reorgParticles[i].x) < 1e-6","type":"text","marks":[{"type":"code"}]},{"text":". In terms of precision, the previous method was printing doubles with 6 decimal places and comparing for an exact match. With the new method, although the printing of pre-computed output is done with 14 decimal places, only 6 decimal places are accounted for precision in the comparison. This eliminates the effect of rounding which was earlier introduced and hence uses a more robust method for floating-point number comparison. ","type":"text"},{"type":"hardBreak"},{"type":"hardBreak"},{"text":"Additionally, previously, the comparison was done on a cell by cell basis i.e. ","type":"text"},{"text":"sim_output_0_0","type":"text","marks":[{"type":"code"}]},{"text":" of comparison output (or precomputed output) was compared for an exact match with ","type":"text"},{"text":"sim_output_0_0","type":"text","marks":[{"type":"code"}]},{"text":" of your output. However, because of the behavior in floating point numbers, since the particle itself can move to another box, this approach of validation was not entirely correct. The current approach uses a global sort of particles (using global particle id) after the simulation and compares particles at a global level irrespective of which box they may belong to. This phase is called reorganization of particles and is not included in the timed part of your simulation. It is entirely done for output verification. ","type":"text"},{"type":"hardBreak"},{"type":"hardBreak"},{"text":"Note that with the new approach, the output values of the bonus question ","type":"text"},{"text":"cannot","type":"text","marks":[{"type":"strong"}]},{"text":" be validated. For the bonus question, points will be awarded entirely based on your implementation. ","type":"text"},{"type":"hardBreak"},{"type":"hardBreak"},{"type":"hardBreak"},{"text":"Using benchmarking output for validation:","type":"text","marks":[{"type":"strong"}]},{"type":"hardBreak"},{"type":"hardBreak"},{"text":"You can download the benchmarking output (bench_compareOutput.tar.gz) from Box using this ","type":"text"},{"text":"link","type":"text","marks":[{"type":"link","attrs":{"href":"https://mellanox.app.box.com/s/qocqryr3yuxli7rb5oqrzxgluhdug2h0/folder/109273942252"}}]},{"text":". After downloading, you will need to untar the file in ","type":"text"},{"text":"scripts/compareOutput/","type":"text","marks":[{"type":"code"}]},{"text":". ","type":"text"},{"type":"hardBreak"}]},{"type":"codeBlock","content":[{"text":"cd scripts/compareOutput/\n\n\nmv ~/Downloads/bench_compareOutput.tar.gz ./\n\n\n$ tar -xvf ./bench_compareOutput.tar.gz\nx ./bench/$\nx ./bench/sim_output_21_17$\nx ./bench/sim_output_29_0$\n...\n...\n...\nx ./bench/sim_output_19_6$\nx ./bench/sim_output_5_12\nx ./bench/sim_output_21_12$\nx ./bench/sim_output_23_14$","type":"text"}]},{"type":"paragraph","content":[{"type":"hardBreak"},{"text":"This should create a folder ","type":"text"},{"text":"bench","type":"text","marks":[{"type":"strong"}]},{"text":" inside ","type":"text"},{"text":"/scripts/compareOutput","type":"text","marks":[{"type":"code"}]},{"text":". This will be used by your program during the runs to compare your benchmarking simulation output against. (testbench output). ","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"type":"hardBreak"},{"text":"Visualizing your run ","type":"text"}]},{"type":"paragraph","content":[{"text":"To visualize your program, you would need to build a ","type":"text"},{"text":"netlrts ","type":"text","marks":[{"type":"strong"}]},{"text":"build, either with or without smp support, since that is the only build that can support live visualization. Additionally, you would also need to install the visualization client ","type":"text"},{"text":"liveViz ","type":"text","marks":[{"type":"strong"}]},{"text":"to connect to your run. On completing your exercise, in order to visualize the particle simulation, perform the following steps on your local machine (like your desktop or laptop). For this exercise, you wouldn’t your cluster. ","type":"text"},{"type":"hardBreak"}]},{"type":"orderedList","attrs":{"order":1},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Download the latest Charm++ release ","type":"text"}]}]}]},{"type":"codeBlock","content":[{"text":"$ wget https://github.com/UIUC-PPL/charm/archive/v6.10.1.tar.gz\n...\n$ tar -xvf v6.10.1.tar.gz","type":"text"}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"2. Build charm++ using the netlrts machine layer ","type":"text"}]},{"type":"codeBlock","content":[{"text":"$ ./build charm++ netlrts-darwin-x86_64 --enable-error-checking --with-production -j16","type":"text"}]},{"type":"paragraph","content":[{"type":"hardBreak"},{"text":"3. Compile the liveViz library ","type":"text"}]},{"type":"codeBlock","content":[{"text":"$ cd netlrts-darwin-x86_64/tmp/libs/ck-libs/liveViz\n\n$ make\n../../../../bin/charmc -I../../.. liveViz.ci\n../../../../bin/charmc -I../../.. liveVizPoll.ci\n../../../../bin/charmc -I../../.. -c -DEXTERIOR_BLACK_PIXEL_ELIMINATION liveViz0.C\n../../../../bin/charmc -I../../.. -c -DEXTERIOR_BLACK_PIXEL_ELIMINATION liveViz.C\n../../../../bin/charmc -I../../.. -c -DEXTERIOR_BLACK_PIXEL_ELIMINATION liveVizPoll.C\n../../../../bin/charmc -I../../.. -c -DEXTERIOR_BLACK_PIXEL_ELIMINATION colorScale.C\n../../../../bin/charmc -I../../.. -c -DEXTERIOR_BLACK_PIXEL_ELIMINATION ImageData.C\n../../../../bin/charmc -I../../.. -c -DEXTERIOR_BLACK_PIXEL_ELIMINATION compat_float2rgb.C\ncp liveViz.h liveViz.decl.h liveVizPoll.decl.h liveViz0.h colorScale.h ImageData.h ../../../../include/\ntouch headers\n../../../../bin/charmc -I../../.. liveViz0.o liveViz.o liveVizPoll.o colorScale.o ImageData.o compat_float2rgb.o -o ../../../../lib/libmoduleliveViz.a\nar: creating archive ../../../../lib/libmoduleliveViz.a\necho -ljpeg > ../../../../lib/libmoduleliveViz.dep","type":"text"}]},{"type":"paragraph","content":[{"type":"hardBreak"},{"text":"4. Install the liveViz visualization client ","type":"text"}]},{"type":"codeBlock","content":[{"text":"$ git clone https://github.com/UIUC-PPL/ccs_tools\n\n$ cd ccs_tools/\n\n$ ant","type":"text"}]},{"type":"paragraph","content":[{"text":"After this, you should be able to see a tool called ","type":"text"},{"text":"‘liveViz' ","type":"text","marks":[{"type":"strong"}]},{"text":"in ","type":"text"},{"text":"ccs_tools/bin","type":"text","marks":[{"type":"code"}]},{"text":". If required, you can add the path to ‘liveViz’ to your ","type":"text"},{"text":"PATH ","type":"text","marks":[{"type":"strong"}]},{"text":"environment variable. ","type":"text"},{"type":"hardBreak"},{"type":"hardBreak"},{"type":"hardBreak"},{"text":"5. The visualization code is already added to your particle simulation code and it only needs to be recompiled after setting the ","type":"text"},{"text":"CHARM_HOME ","type":"text","marks":[{"type":"strong"}]},{"text":"variable to the recently built charm build and the Makefile variable ","type":"text"},{"text":"LIVEVIZ_RUN ","type":"text","marks":[{"type":"strong"}]},{"text":"set to 1. ","type":"text"},{"type":"hardBreak"}]},{"type":"codeBlock","content":[{"text":" 1 CHARM_HOME=/Users/nitinbhat/Work/software/charm-6.10.1/netlrts-darwin-x86_64$\n 2 CHARMC=${CHARM_HOME}/bin/charmc $(OPTS)$\n 3 MODE=solution$\n 4 $\n 5 BONUS_QUESTION=0# Set to 1 to compile bonus question part$\n 6 # make clean all after changing BONUS_QUESTION variable$\n 7 $\n 8 LIVEVIZ_RUN=1# Set to 1 to turn on visualization$\n 9 # make clean all after changing LIVEVIZ_RUN variable$\n 10 $","type":"text"}]},{"type":"paragraph"},{"type":"codeBlock","content":[{"text":"$ make clean all","type":"text"}]},{"type":"paragraph"},{"type":"codeBlock","content":[{"text":"$ make testviz\n./charmrun +p4 ./particle 10000 10 100000 1,2,3,10 100 no 5 ++server ++server-port 1234\n","type":"text"}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"6. As this is running, in a separate terminal tab, launch the liveViz Client connecting to the port 1234. ","type":"text"}]},{"type":"codeBlock","content":[{"text":"$ liveViz localhost 1234","type":"text"}]},{"type":"paragraph","content":[{"type":"hardBreak"},{"text":"With this, you should be able to see the visualization of moving particles. ","type":"text"}]},{"type":"mediaSingle","attrs":{"layout":"center","width":65.0},"content":[{"type":"media","attrs":{"width":1992,"id":"c23a3053-209f-4efc-b049-d2e16a83ecf1","collection":"contentId-1326645310","type":"file","height":2092}}]},{"type":"paragraph"},{"type":"heading","attrs":{"level":3},"content":[{"text":"Some Caveats to Understand","type":"text"}]},{"type":"orderedList","attrs":{"order":1},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"For the coding challenge, you will only need to add code to ","type":"text"},{"text":"exercise.cpp","type":"text","marks":[{"type":"code"}]},{"text":". However, if you wish, you can change the other source code files as long your result matches the pre-computed output. ","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Important- ","type":"text","marks":[{"type":"strong"}]},{"text":"While deciding to send particles to their correct homes (the 8 neighboring cells), ensure that a particle is sent over only if its coordinates have crossed the boundary. ","type":"text"},{"text":"Do not send particles that are still on the boundary of the current cell.","type":"text","marks":[{"type":"strong"}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Important - ","type":"text","marks":[{"type":"strong"}]},{"text":"Make sure that particles that go outside the bounding box are wrapped back as explained previously.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Use the totalParticles displayed in the output to validate that no particle in the simulation is being lost. The value of totalParticles displayed should not change across the periodically displayed iterations. ","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"If you’re attempting the bonus question, make sure to go into the Makefile and set the ","type":"text"},{"text":"BONUS_QUESTION ","type":"text","marks":[{"type":"strong"}]},{"text":"variable to ","type":"text"},{"text":"1. ","type":"text","marks":[{"type":"strong"}]},{"text":"Since this is a compiler macro, you will have to run ","type":"text"},{"text":"make clean all","type":"text","marks":[{"type":"code"}]},{"text":" to recompile your files. ","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"When you’re using the visualization feature and want to visualize using ","type":"text"},{"text":"liveViz","type":"text","marks":[{"type":"strong"}]},{"text":", make sure to go into the Makefile and set the ","type":"text"},{"text":"LIVEVIZ_RUN","type":"text","marks":[{"type":"strong"}]},{"text":" variable to ","type":"text"},{"text":"1","type":"text","marks":[{"type":"strong"}]},{"text":". Since this is also a compiler macro, you will have to run ","type":"text"},{"text":"make clean all","type":"text","marks":[{"type":"code"}]},{"text":" to recompile your files. ","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Among the input parameters listed in ","type":"text"},{"text":"this","type":"text","marks":[{"type":"link","attrs":{"href":"https://hpcadvisorycouncil.atlassian.net/wiki/spaces/HPCWORKS/pages/1326645310#Input-Parameters"}}]},{"text":" section, for your final benchmarking task, you can only modify logOutput, load balancing frequency, and the load balancer that you pass using ","type":"text"},{"text":"+balancer ","type":"text","marks":[{"type":"code"}]},{"text":". ","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"If you are running your program in the SMP mode, which takes advantage of shared memory communication for threads of a process, note that in this mode, for each process, you will be using one of the threads (and hence cores) of the process for a communication thread, whose exclusive job is to send and receive messages. This means that you will lose that core as your compute resource. In the SMP mode, it is required to specify ","type":"text"},{"text":"++ppn ","type":"text","marks":[{"type":"code"}]},{"text":" to specify the number of threads for the process. Additionally, you can specify cpu affinity to bind the threads to cores using ","type":"text"},{"text":"+pemap ","type":"text","marks":[{"type":"code"}]},{"text":" and ","type":"text"},{"text":"+commap ","type":"text","marks":[{"type":"code"}]},{"text":". These are described ","type":"text"},{"text":"here","type":"text","marks":[{"type":"link","attrs":{"href":"https://charm.readthedocs.io/en/latest/charm++/manual.html#smp-options"}}]},{"text":". ","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Note from Nitin Bhat:","type":"text"},{"type":"hardBreak"},{"text":"It was brought to my notice by a few participants on the ISC20-SCC slack (#isc20-scc) that the implementation and version of the math library ","type":"text"},{"text":"libm","type":"text","marks":[{"type":"code"}]},{"text":" could impact the final output of the particle simulation. For that reason, in order to ensure that your ","type":"text"},{"text":"libm","type":"text","marks":[{"type":"code"}]},{"text":" versions don’t lead to different results when compared with the pre-computed test results, I decided to provide the details about the ","type":"text"},{"text":"libm","type":"text","marks":[{"type":"code"}]},{"text":" version that I’ll be using for testing. I will be using the standard ","type":"text"},{"text":"libm","type":"text","marks":[{"type":"code"}]},{"text":" that is shipped as a part of GNU libc 2.12. This is also the default library in your Linux environment on the NSCC cluster. ","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Note that you ","type":"text"},{"text":"modify","type":"text","marks":[{"type":"strong"}]},{"text":" the number of processors in the testbench output. The current value is ","type":"text"},{"text":"+p96","type":"text","marks":[{"type":"strong"}]},{"text":". But, you’re free to play around with this value. ","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Parts of the code that cannot be modified:","type":"text","marks":[{"type":"strong"}]}]},{"type":"orderedList","attrs":{"order":1},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Do not change/remove the timer calls since that is used to evaluate the total execution time.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Do not change/remove asserts in the code since they are basic sanity checks for the simulation to proceed as required.","type":"text"}]},{"type":"orderedList","attrs":{"order":1},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"This includes the code inside ","type":"text"},{"text":"checkParticleBelongsToMe","type":"text","marks":[{"type":"code"}]},{"text":" and the places where ","type":"text"},{"text":"checkParticleBelongsToMe","type":"text","marks":[{"type":"code"}]},{"text":" is called.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"This also include the call to ","type":"text"},{"text":"verifyCorrectness","type":"text","marks":[{"type":"code"}]},{"text":" inside ","type":"text"},{"text":"recvParticlesPostSimulation","type":"text","marks":[{"type":"code"}]}]}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Ensure that the simulation is performed such that particles have coordinates that are spatially belonging to the cell. (The calls to ","type":"text"},{"text":"checkParticleBelongsToMe","type":"text","marks":[{"type":"code"}]},{"text":" will enforce this behavior).","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Do not change/remove the calls to ","type":"text"},{"text":"reduceTotalAndOutbound","type":"text","marks":[{"type":"code"}]},{"text":" since they will be performed during the simulation in order to print out the total particles and the total outgoing particles in the simulation.","type":"text"}]}]}]}]}]},{"type":"heading","attrs":{"level":1},"content":[{"type":"hardBreak"},{"type":"hardBreak"},{"text":"Download Files ","type":"text"}]},{"type":"paragraph","content":[{"text":"Click here to download the Coding Challenge Files ","type":"text","marks":[{"type":"link","attrs":{"href":"https://hpcadvisorycouncil.atlassian.net/wiki/download/attachments/1326645310/charm-exerciseV3.tar.gz?api=v2"}}]},{"text":" ","type":"text"}]},{"type":"paragraph","content":[{"type":"hardBreak"},{"text":"Good Luck Teams!!","type":"text"}]},{"type":"paragraph"},{"type":"heading","attrs":{"level":1},"content":[{"text":"References","type":"text","marks":[{"type":"strong"}]}]},{"type":"bulletList","content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Charm++ Manual: ","type":"text"},{"text":"https://charm.readthedocs.io/en/latest/index.html","type":"text","marks":[{"type":"link","attrs":{"href":"https://charm.readthedocs.io/en/latest/index.html"}}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Custom Reduction: ","type":"text"},{"text":"https://charm.readthedocs.io/en/latest/charm++/manual.html#defining-a-new-reduction-type","type":"text","marks":[{"type":"link","attrs":{"href":"https://charm.readthedocs.io/en/latest/charm++/manual.html#defining-a-new-reduction-type"}}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Projections Manual: ","type":"text"},{"text":"https://charm.readthedocs.io/en/latest/projections/manual.html","type":"text","marks":[{"type":"link","attrs":{"href":"https://charm.readthedocs.io/en/latest/projections/manual.html"}}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"LiveViz: ","type":"text"},{"text":"https://charm.readthedocs.io/en/latest/libraries/manual.html#liveviz-library","type":"text","marks":[{"type":"link","attrs":{"href":"https://charm.readthedocs.io/en/latest/libraries/manual.html#liveviz-library"}}]}]}]}]},{"type":"paragraph","content":[{"type":"hardBreak"}]}],"version":1}

Browser not supported