doc: fix bash code blocks 66/5066/3
authorMatthias Diener <mdiener@illinois.edu>
Tue, 9 Apr 2019 18:44:14 +0000 (13:44 -0500)
committerMatthias Diener <mdiener@illinois.edu>
Tue, 9 Apr 2019 20:59:20 +0000 (15:59 -0500)
- tag them with the correct code-blocks statement
- consistently use '$' instead of '>' as the prompt

Change-Id: I354b6cb65af62687e6a98b4df7693bc688f59d60

12 files changed:
doc/README.rst
doc/ampi/manual.rst
doc/armci/manual.rst
doc/bigsim/manual.rst
doc/charisma/manual.rst
doc/charm++/manual.rst
doc/debugger/manual.rst
doc/f90charm/manual.rst
doc/fem/manual.rst
doc/jade/manual.rst
doc/pose/manual.rst
doc/projections/manual.rst

index 2a0340a23d193dc50ce0c513ef7bede7680fbcec..e4f51104aedb1ef547ab1003f948b4ca379ac6c2 100644 (file)
@@ -207,4 +207,4 @@ Footnotes
 
   This text has a footnote [1]_
 
-  .. [1] Text of the footnote.
\ No newline at end of file
+  .. [1] Text of the footnote.
index cfcf3f9fd2250a873e23d5af5cc5ba3f42f133b3..172aea928dbd2b94ae198fc358e5c06c325682de 100644 (file)
@@ -420,7 +420,7 @@ compile and link time:
 
 .. code-block:: bash
 
-   ampicxx -o example example.C -tlsglobals
+   ampicxx -o example example.C -tlsglobals
 
 Automatic Global Offset Table Swapping
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1131,9 +1131,9 @@ option). In the above case, suppose one wants to create 128 ranks of
 Solids and 64 ranks of Fluids on 32 physical processors, one would
 specify those with multiple ``+vp`` options on the command line as:
 
-::
+.. code-block:: bash
 
-   > ./charmrun gen1.x +p 32 +vp 128 +vp 64
+   $ ./charmrun gen1.x +p 32 +vp 128 +vp 64
 
 This will ensure that multiple modules representing different complete
 applications can co-exist within the same executable. They can also
@@ -1219,17 +1219,17 @@ processors. To activate the feature, build AMPI module with variable
 (Linking with zlib "-lz" might be required with this, for generating
 compressed log file.)
 
-::
+.. code-block:: bash
 
-   > ./build AMPI netlrts-linux-x86_64 -DAMPIMSGLOG
+   $ ./build AMPI netlrts-linux-x86_64 -DAMPIMSGLOG
 
 The feature is used in two phases: writing (logging) the environment and
 repeating the run. The first logging phase is invoked by a parallel run
 of the AMPI program with some additional command line options.
 
-::
+.. code-block:: bash
 
-   > ./charmrun ./pgm +p4 +vp4 +msgLogWrite +msgLogRank 2 +msgLogFilename "msg2.log"
+   $ ./charmrun ./pgm +p4 +vp4 +msgLogWrite +msgLogRank 2 +msgLogFilename "msg2.log"
 
 In the above example, a parallel run with 4 worker threads and 4 AMPI
 ranks will be executed, and the changes in the MPI environment of worker
@@ -1240,9 +1240,9 @@ Unlike the first run, the re-run is a sequential program, so it is not
 invoked by charmrun (and omitting charmrun options like +p4 and +vp4),
 and additional command line options are required as well.
 
-::
+.. code-block:: bash
 
-   > ./pgm +msgLogRead +msgLogRank 2 +msgLogFilename "msg2.log"
+   $ ./pgm +msgLogRead +msgLogRank 2 +msgLogFilename "msg2.log"
 
 User Defined Initial Mapping
 ----------------------------
@@ -1261,7 +1261,7 @@ Round Robin
 
    .. code-block:: bash
 
-      > ./charmrun ./hello +p2 +vp8 +mapping RR_MAP
+      $ ./charmrun ./hello +p2 +vp8 +mapping RR_MAP
 
 Block Mapping
    This mapping scheme maps virtual processors to physical processor in
@@ -1272,7 +1272,7 @@ Block Mapping
 
    .. code-block:: bash
 
-      > ./charmrun ./hello +p2 +vp8 +mapping BLOCK_MAP
+      $ ./charmrun ./hello +p2 +vp8 +mapping BLOCK_MAP
 
 Proportional Mapping
    This scheme takes the processing capability of physical processors
@@ -1285,8 +1285,8 @@ Proportional Mapping
 
    .. code-block:: bash
 
-      > ./charmrun ./hello +p2 +vp8 +mapping PROP_MAP
-      > ./charmrun ./hello +p2 +vp8 +mapping PROP_MAP +balancer GreedyLB +LBTestPESpeed
+      $ ./charmrun ./hello +p2 +vp8 +mapping PROP_MAP
+      $ ./charmrun ./hello +p2 +vp8 +mapping PROP_MAP +balancer GreedyLB +LBTestPESpeed
 
 If you want to define your own mapping scheme, please contact us for
 assistance.
@@ -1354,11 +1354,11 @@ AMPI Example Applications
 
 Most benchmarks can be compiled with the provided top-level Makefile:
 
-::
+.. code-block:: bash
 
-       > git clone ssh://charm.cs.illinois.edu:9418/benchmarks/ampi-benchmarks
-       > cd ampi-benchmarks
-       > make -f Makefile.ampi
+       $ git clone ssh://charm.cs.illinois.edu:9418/benchmarks/ampi-benchmarks
+       $ cd ampi-benchmarks
+       $ make -f Makefile.ampi
 
 Mantevo project v3.0
 ~~~~~~~~~~~~~~~~~~~~
@@ -1505,16 +1505,16 @@ Kripke v1.1
 
    .. code-block:: bash
 
-      > mkdir build; cd build;
-      > cmake .. -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchain/linux-gcc-ampi.cmake
+      $ mkdir build; cd build;
+      $ cmake .. -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchain/linux-gcc-ampi.cmake
       -DENABLE_OPENMP=OFF
-      > make
+      $ make
 
    Run with:
 
    .. code-block:: bash
 
-      > ./charmrun +p8 ./src/tools/kripke +vp8 --zones 64,64,64 --procs 2,2,2 --nest ZDG
+      $ ./charmrun +p8 ./src/tools/kripke +vp8 --zones 64,64,64 --procs 2,2,2 --nest ZDG
 
 MCB v1.0.3 (2013)
 ^^^^^^^^^^^^^^^^^
@@ -1528,7 +1528,7 @@ MCB v1.0.3 (2013)
 
    .. code-block:: bash
 
-      > OMP_NUM_THREADS=1 ./charmrun +p4 ./../src/MCBenchmark.exe --weakScaling
+      $ OMP_NUM_THREADS=1 ./charmrun +p4 ./../src/MCBenchmark.exe --weakScaling
        --distributedSource --nCores=1 --numParticles=20000 --multiSigma --nThreadCore=1 +vp16
 
 .. _not-yet-ampi-zed-reason-1:
@@ -1732,16 +1732,16 @@ HYPRE-2.11.1
 
 -  Hypre-2.11.1 builds on top of AMPI using the configure command:
 
-   ::
+   .. code-block:: bash
 
-      > ./configure --with-MPI
-            CC=~/charm/bin/ampicc
-            CXX=~/charm/bin/ampicxx
-            F77=~/charm/bin/ampif77
-            --with-MPI-include=~/charm/include
-            --with-MPI-lib-dirs=~/charm/lib
+      $ ./configure --with-MPI \
+            CC=~/charm/bin/ampicc \
+            CXX=~/charm/bin/ampicxx \
+            F77=~/charm/bin/ampif77 \
+            --with-MPI-include=~/charm/include \
+            --with-MPI-lib-dirs=~/charm/lib \
             --with-MPI-libs=mpi --without-timing --without-print-errors
-      > make -j8
+      $ make -j8
 
 -  All HYPRE tests and examples pass tests with virtualization,
    migration, etc. except for those that use Hypre’s timing interface,
@@ -1846,9 +1846,9 @@ and follow the download links. Then build Charm++ and AMPI from source.
 The build script for Charm++ is called ``build``. The syntax for this
 script is:
 
-::
+.. code-block:: bash
 
-   > build <target> <version> <opts>
+   $ build <target> <version> <opts>
 
 For building AMPI (which also includes building Charm++ and other
 libraries needed by AMPI), specify ``<target>`` to be ``AMPI``. And
@@ -1865,34 +1865,34 @@ programs. See the charm/README file for details on picking the proper
 version. Here is an example of how to build a debug version of AMPI in a
 linux and ethernet environment:
 
-::
+.. code-block:: bash
 
-   build AMPI netlrts-linux-x86_64 -g
+   $ ./build AMPI netlrts-linux-x86_64 -g
 
 And the following is an example of how to build a production version of
 AMPI on a Cray XC system, with MPI-level error checking in AMPI turned
 off:
 
-::
+.. code-block:: bash
 
-   build AMPI gni-crayxc --with-production --disable-ampi-error-checking
+   $ ./build AMPI gni-crayxc --with-production --disable-ampi-error-checking
 
 AMPI can also be built with support for shared memory on any
 communication layer by adding "smp" as an option after the build target.
 For example, on an Infiniband Linux cluster:
 
-::
+.. code-block:: bash
 
-   build AMPI verbs-linux-x86_64 smp --with-production
+   $ ./build AMPI verbs-linux-x86_64 smp --with-production
 
 AMPI ranks are implemented as user-level threads with a stack size
 default of 1MB. If the default is not correct for your program, you can
 specify a different default stack size (in bytes) at build time. The
 following build command illustrates this for an Intel Omni-Path system:
 
-::
+.. code-block:: bash
 
-   build AMPI ofi-linux-x86_64 --with-production -DTCHARM_STACKSIZE_DEFAULT=16777216
+   $ ./build AMPI ofi-linux-x86_64 --with-production -DTCHARM_STACKSIZE_DEFAULT=16777216
 
 The same can be done for AMPI’s RDMA messaging threshold using
 ``AMPI_RDMA_THRESHOLD_DEFAULT`` and, for messages sent within the same
@@ -1916,19 +1916,19 @@ other compilers like cc. All the command line flags that you would use
 for other compilers can be used with the AMPI compilers the same way.
 For example:
 
-::
+.. code-block:: bash
 
-   > ampicc -c pgm.c -O3
-   > ampif90 -c pgm.f90 -O0 -g
-   > ampicc -o pgm pgm.o -lm -O3
+   $ ampicc -c pgm.c -O3
+   $ ampif90 -c pgm.f90 -O0 -g
+   $ ampicc -o pgm pgm.o -lm -O3
 
 To use Isomalloc for transparently migrating user heap data, link with
 *-memory isomalloc*. To use a Charm++ load balancer, link a strategy or
 a suite of strategies in with *-module <LB>*. For example:
 
-::
+.. code-block:: bash
 
-   > ampicc pgm.c -o pgm -O3 -memory isomalloc -module CommonLBs
+   $ ampicc pgm.c -o pgm -O3 -memory isomalloc -module CommonLBs
 
 Running AMPI programs
 ---------------------
@@ -1949,9 +1949,9 @@ and the stack size of every user-level thread) and the program
 arguments. A typical invocation of an AMPI program ``pgm`` with
 ``charmrun`` is:
 
-::
+.. code-block:: bash
 
-   > ./charmrun +p16 ./pgm +vp64
+   $ ./charmrun +p16 ./pgm +vp64
 
 Here, the AMPI program ``pgm`` is run on 16 physical processors with 64
 total virtual ranks (which will be mapped 4 per processor initially).
@@ -1964,9 +1964,9 @@ using the ``+tcharm_stacksize`` option, which can be used to decrease
 the size of the stack that must be migrated, as in the following
 example:
 
-::
+.. code-block:: bash
 
-   > ./charmrun +p16 ./pgm +vp128 +tcharm_stacksize 32K +balancer RefineLB
+   $ ./charmrun +p16 ./pgm +vp128 +tcharm_stacksize 32K +balancer RefineLB
 
 Running with ampirun
 ~~~~~~~~~~~~~~~~~~~~
@@ -1979,9 +1979,9 @@ with ``ampicc``.
 
 The basic usage of ampirun is as follows:
 
-::
+.. code-block:: bash
 
-   > ./ampirun -np 16 --host h1,h2,h3,h4 ./pgm
+   $ ./ampirun -np 16 --host h1,h2,h3,h4 ./pgm
 
 This command will create 16 (non-virtualized) ranks and distribute them
 on the hosts h1-h4.
@@ -1990,16 +1990,16 @@ When using the ``-vr`` option, AMPI will create the number of ranks
 specified by the ``-np`` parameter as virtual ranks, and will create
 only one process per host:
 
-::
+.. code-block:: bash
 
-   > ./ampirun -np 16 --host h1,h2,h3,h4 -vr ./pgm
+   $ ./ampirun -np 16 --host h1,h2,h3,h4 -vr ./pgm
 
 Other options (such as the load balancing strategy), can be specified in
 the same way as for charmrun:
 
-::
+.. code-block:: bash
 
-   > ./ampirun -np 16 ./pgm +balancer RefineLB
+   $ ./ampirun -np 16 ./pgm +balancer RefineLB
 
 Other options
 ~~~~~~~~~~~~~
@@ -2007,9 +2007,9 @@ Other options
 Note that for AMPI programs compiled with gfortran, users may need to
 set the following environment variable to see program output to stdout:
 
-::
+.. code-block:: bash
 
-   > export GFORTRAN_UNBUFFERED_ALL=1
+   $ export GFORTRAN_UNBUFFERED_ALL=1
 
 .. [1]
    Currently, AMPI supports the MPI-2.2 standard, and the MPI-3.1
index 0acdc8dba75b8f8a6c93f94f4aa9dd883789baea..67206412d44003ebb840830350b93679e219406a 100644 (file)
@@ -54,10 +54,10 @@ Building ARMCI Support under The Charm++ Runtime System
 
 Build charm target ARMCI (instead of charm or AMPI):
 
-::
+.. code-block:: bash
 
-   > cd charm
-   > ./build ARMCI netlrts-linux -O3
+   $ cd charm
+   $ ./build ARMCI netlrts-linux -O3
 
 .. _sec::simple program:
 
@@ -125,19 +125,19 @@ Compiling the code with:
 
 .. code-block:: bash
 
-   > charm/bin/charmc -c hello.c /$(OPTS)
+   $ charm/bin/charmc -c hello.c /$(OPTS)
 
 Linking the program with:
 
 .. code-block:: bash
 
-   > charm/bin/charmc hello.o -o hello -swapglobals -memory isomalloc -language armci $(OPTS)
+   $ charm/bin/charmc hello.o -o hello -swapglobals -memory isomalloc -language armci $(OPTS)
 
 Run the program:
 
 .. code-block:: bash
 
-   > ./charmrun ./hello +p2 +vp8
+   $ ./charmrun ./hello +p2 +vp8
 
 .. _sec::data structures:
 
index d5782174d88b0899032f9602dfc351097716f059..beb7c4523c141ade568dfe35f4fc0e8f2b920e3e 100644 (file)
@@ -88,23 +88,23 @@ compile Charm++. In short, the “build” script is the main tool for
 compiling Charm++. One needs to provide *target* and *platform*
 selections:
 
-::
+.. code-block:: bash
 
-    ./build <target> <platform> [options ...] [charmc-options ...]
+   $ ./build <target> <platform> [options ...] [charmc-options ...]
 
 For example, to compile on a 64-bit Linux machine, one would type:
 
-::
+.. code-block:: bash
 
-   ./build charm++ netlrts-linux-x86_64 -O2
+   ./build charm++ netlrts-linux-x86_64 -O2
 
 which builds essential Charm++ kernel using UDP sockets as the
 communication method; alternatively, it is possible to build the Charm++
 kernel on MPI using:
 
-::
+.. code-block:: bash
 
-   ./build charm++ mpi-linux-x86_64 -O2
+   ./build charm++ mpi-linux-x86_64 -O2
 
 For other platforms, netlrts-linux-x86_64 should be replaced by whatever
 platform is being used. See the charm/README file for a complete list of
@@ -117,9 +117,9 @@ The BigSim Emulator is implemented on top of Converse in Charm++. To
 compile the BigSim Emulator, one can compile Emulator libraries directly
 on top of normal Charm++ using “bgampi” as the compilation target, like
 
-::
+.. code-block:: bash
 
-   ./build bgampi netlrts-linux-x86_64 -O2
+   ./build bgampi netlrts-linux-x86_64 -O2
 
 With Emulator libraries, one can write BigSim applications using its low
 level machine API (defined in  :numref:`bgemulator`).
@@ -131,9 +131,9 @@ In order to build Charm++ or AMPI on top of BigSim Emulator (which
 itself is implemented on top of Converse), a special build option
 “bigemulator” needs to be specified:
 
-::
+.. code-block:: bash
 
-   ./build bgampi netlrts-linux-x86_64 bigemulator -O2
+   ./build bgampi netlrts-linux-x86_64 bigemulator -O2
 
 The “bgampi” option is the compilation *target* that tells “build” to
 compile BigSim Emulator libraries in addition to Charm++ kernel
@@ -172,9 +172,9 @@ In order to link against the BigSim library, one must specify
 ``-language bigsim`` as an argument to the ``charmc`` command, for
 example:
 
-::
+.. code-block:: bash
 
-   charmc -o hello hello.C -language bigsim
+   charmc -o hello hello.C -language bigsim
 
 Sample applications in low level machine API can be found in the
 directory charm/examples/bigsim/emulator/.
@@ -192,9 +192,9 @@ To compile a program written in Charm++ on the BigSim Emulator, one
 specifies ``-language charm++`` as an argument to the ``charmc``
 command:
 
-::
+.. code-block:: bash
 
-   charmc -o hello hello.C -language charm++
+   charmc -o hello hello.C -language charm++
 
 This will link both Charm++ runtime libraries and BigSim Emulator
 libraries.
@@ -221,9 +221,9 @@ link against the AMPI library as well as the BigSim Charm++ runtime
 libraries by specifying ``-language ampi`` as an argument to the
 ``charmc`` command:
 
-::
+.. code-block:: bash
 
-   charmc -o hello hello.C -language ampi
+   charmc -o hello hello.C -language ampi
 
 Sample applications in AMPI can be found in the directory
 charm/examples/ampi, specifically charm/examples/ampi/pingpong.
@@ -272,16 +272,16 @@ with one worker processor and one communication processor on each node,
 and use 100 real processors to run the simulation, the command to be
 issued should be:
 
-::
+.. code-block:: bash
 
-   ./charmrun +p100 ./hello +x40 +y40 +z40 +cth1 +wth1
+   ./charmrun +p100 ./hello +x40 +y40 +z40 +cth1 +wth1
 
 To run an AMPI program, one may also want to specify the number of
 virtual processors to run the MPI code by using ``+vp``. As an example,
 
-::
+.. code-block:: bash
 
-   ./charmrun +p100 ./hello +x40 +y40 +z40 +cth1 +wth1 +vp 128000
+   ./charmrun +p100 ./hello +x40 +y40 +z40 +cth1 +wth1 +vp 128000
 
 starts the simulation of a machine of size 40x40x40 with one worker
 processor in each node, running 128000 MPI tasks (2 MPI tasks on each
index e4eb74ecd33dee62af73df818d072b0551d30a2b..692826a6770a91672cc966c63cadca61983ff0fb 100644 (file)
@@ -465,7 +465,7 @@ command for this step is as follows.
 
 .. code-block:: bash
 
-       > orchc [modulename].or
+   $ orchc [modulename].or
 
 2) Charm++ compiler, ``charmc``, is used to parse the Charm++ Interface
 (``.ci``) file, compile C/C++ code, and link and build the executable. The
@@ -473,9 +473,9 @@ typical commands are:
 
 .. code-block:: bash
 
-       > charmc [modulename].ci
-       > charmc [modulename].C -c
-       > charmc [modulename].o -o pgm -language charm++
+   $ charmc [modulename].ci
+   $ charmc [modulename].C -c
+   $ charmc [modulename].o -o pgm -language charm++
 
 Running the Charisma program is the same as running a Charm++ program,
 using Charm++'s job launcher ``charmrun`` (on some platforms like CSE's
@@ -483,7 +483,7 @@ Turing Cluster, use the customized job launcher ``rjq`` or ``rj``).
 
 .. code-block:: bash
 
-       > charmrun pgm +p4
+   $ charmrun pgm +p4
 
 Please refer to Charm++'s manual and tutorial for more details of
 building and running a Charm++ program.
@@ -617,9 +617,9 @@ At run-time, the load balancer is specified in command line after the
 launcher will automatically print out all available load balancers. For
 instance, the following command uses ``RefineLB``.
 
-::
+.. code-block:: bash
 
-       > ./charmrun ./pgm +p16 +balancer RefineLB
+   $ ./charmrun ./pgm +p16 +balancer RefineLB
 
 .. _secsparse:
 
@@ -739,7 +739,7 @@ The user compile these input files with the following command:
 
 .. code-block:: bash
 
-     > orchc jacobi.or
+   $ orchc jacobi.or
 
 The compiler generates the parallel code for sending out messages,
 organizing flow of control, and then it looks for sequential code files
index 648a9b87d7b80a7838899a4d6f90a7652ea3b44c..5785a6b3a37f3033dce43173675d4c434eed1223 100644 (file)
@@ -7731,9 +7731,9 @@ i.e., restarting execution from a previously-created checkpoint. The
 command line option ``+restart DIRNAME`` is required to invoke this
 mode. For example:
 
-::
+.. code-block:: bash
 
-     > ./charmrun hello +p4 +restart log
+     $ ./charmrun hello +p4 +restart log
 
 Restarting is the reverse process of checkpointing. Charm++ allows
 restarting the old checkpoint on a different number of physical
@@ -8140,8 +8140,8 @@ for example:
 
 .. code-block:: bash
 
-   $CHARM_DIR/build charm++ multicore-linux64 omp
-   $CHARM_DIR/build charm++ netlrts-linux-x86_64 smp omp
+   $ $CHARM_DIR/build charm++ multicore-linux64 omp
+   $ $CHARM_DIR/build charm++ netlrts-linux-x86_64 smp omp
 
 This library is based on the LLVM OpenMP runtime library. So it supports
 the ABI used by clang, intel and gcc compilers.
@@ -8180,12 +8180,12 @@ to avoid the error:
    # When you want to compile Integrated OpenMP on Ubuntu where the pre-installed clang
    # is older than 3.7, you can use integrated openmp with the following instructions.
    # e.g.) Ubuntu 14.04, the version of default clang is 3.4.
-   sudo apt-get install clang-3.8 //you can use any version of clang higher than 3.8
-   sudo ln -svT /usr/bin/clang-3.8 /usr/bin/clang
-   sudo ln -svT /usr/bin/clang++-3.8 /usr/bin/clang
+   sudo apt-get install clang-3.8 //you can use any version of clang higher than 3.8
+   sudo ln -svT /usr/bin/clang-3.8 /usr/bin/clang
+   sudo ln -svT /usr/bin/clang++-3.8 /usr/bin/clang
 
-   $(CHARM_DIR)/build charm++ multicore-linux64 clang omp --with-production -j8
-   echo '!<arch>' > $(CHARM_DIR)/lib/libomp.a  # Dummy library. This will make you avoid the error message.
+   $ $CHARM_DIR/build charm++ multicore-linux64 clang omp --with-production -j8
+   echo '!<arch>' > $(CHARM_DIR)/lib/libomp.a  # Dummy library. This will make you avoid the error message.
 
 On Mac, the Apple-provided clang installed in default doesn’t have
 OpenMP feature. We're working on the support of this library on Mac
@@ -8198,8 +8198,8 @@ to the invocation of the Charm++ build script. For example:
 
 .. code-block:: bash
 
-   $CHARM_DIR/build charm++ multicore-linux64 omp gcc-7
-   $CHARM_DIR/build charm++ netlrts-linux-x86_64 smp omp gcc-7
+   $ $CHARM_DIR/build charm++ multicore-linux64 omp gcc-7
+   $ $CHARM_DIR/build charm++ netlrts-linux-x86_64 smp omp gcc-7
 
 If this does not work, you should set environment variables so that the
 Charm++ build script uses the normal gcc installed from Homebrew or
@@ -8210,20 +8210,20 @@ MacPorts. The following is an example using Homebrew on Mac OS X
 
    # Install Homebrew from https://brew.sh
    # Install gcc using 'brew' */
-   brew install gcc
+   brew install gcc
 
    # gcc, g++ and other binaries are installed at /usr/local/Cellar/gcc/<version>/bin
    # You need to make symbolic links to the gcc binaries at /usr/local/bin
    # In this example, gcc 7.1.0 is installed at the directory.
-   cd /usr/local/bin
-   ln -sv /usr/local/Cellar/gcc/7.1.0/bin/gcc-7 gcc
-   ln -sv /usr/local/Cellar/gcc/7.1.0/bin/g++-7 g++
-   ln -sv /usr/local/Cellar/gcc/7.1.0/bin/gcc-nm-7 gcc-nm
-   ln -sv /usr/local/Cellar/gcc/7.1.0/bin/gcc-ranlib-7 gcc-ranlib
-   ln -sv /usr/local/Cellar/gcc/7.1.0/bin/gcc-ar-7 gcc-ar
+   cd /usr/local/bin
+   ln -sv /usr/local/Cellar/gcc/7.1.0/bin/gcc-7 gcc
+   ln -sv /usr/local/Cellar/gcc/7.1.0/bin/g++-7 g++
+   ln -sv /usr/local/Cellar/gcc/7.1.0/bin/gcc-nm-7 gcc-nm
+   ln -sv /usr/local/Cellar/gcc/7.1.0/bin/gcc-ranlib-7 gcc-ranlib
+   ln -sv /usr/local/Cellar/gcc/7.1.0/bin/gcc-ar-7 gcc-ar
 
    # Finally, you should set PATH variable so that these binaries are accessed first in the build script.
-   export PATH=/usr/local/bin:$PATH
+   export PATH=/usr/local/bin:$PATH
 
 In addition, this library will be supported on Windows in the next
 release of Charm++.
@@ -8801,16 +8801,16 @@ options:
 Here is an example which collects the data for a 1000 processor run of a
 program
 
-::
+.. code-block:: bash
 
-   ./charmrun pgm +p1000 +balancer RandCentLB +LBDump 2 +LBDumpSteps 4 +LBDumpFile lbsim.dat
+   ./charmrun pgm +p1000 +balancer RandCentLB +LBDump 2 +LBDumpSteps 4 +LBDumpFile lbsim.dat
 
 This will collect data on files lbsim.dat.2,3,4,5. We can use this data
 to analyze the performance of various centralized strategies using:
 
-::
+.. code-block:: bash
 
-   ./charmrun pgm +balancer <Strategy to test> +LBSim 2 +LBSimSteps 4 +LBDumpFile lbsim.dat
+   ./charmrun pgm +balancer <Strategy to test> +LBSim 2 +LBSimSteps 4 +LBDumpFile lbsim.dat
    [+LBSimProcs 900]
 
 Please note that this does not invoke the real application. In fact,
@@ -10054,25 +10054,25 @@ distribution.
 To enable shrink expand, Charm++ needs to be built with the
 ``--enable-shrinkexpand`` option:
 
-::
+.. code-block:: bash
 
-       ./build charm++ netlrts-linux-x86_64 --enable-shrinkexpand
+       ./build charm++ netlrts-linux-x86_64 --enable-shrinkexpand
 
 An example application launch command needs to include a load balancer,
 a nodelist file that contains all of the nodes that are going to be
 used, and a port number to listen the shrink/expand commands:
 
-::
+.. code-block:: bash
 
-       ./charmrun +p4 ./jacobi2d 200 20 +balancer GreedyLB ++nodelist ./mynodelistfile ++server ++server-port 1234
+       ./charmrun +p4 ./jacobi2d 200 20 +balancer GreedyLB ++nodelist ./mynodelistfile ++server ++server-port 1234
 
 The CCS client to send shrink/expand commands needs to specify the
 hostname, port number, the old(current) number of processor and the
 new(future) number of processors:
 
-::
+.. code-block:: bash
 
-       ./client <hostname> <port> <oldprocs> <newprocs>
+       ./client <hostname> <port> <oldprocs> <newprocs>
        (./client valor 1234 4 8 //This will increase from 4 to 8 processors.)
 
 To make a Charm++ application malleable, first, pup routines for all of
@@ -11738,15 +11738,15 @@ single-process runs, it can be used directly:
 
 .. code-block:: bash
 
-   valgrind ...valgrind options... ./application_name ...application arguments...
+   valgrind ...valgrind options... ./application_name ...application arguments...
 
 When running in parallel, it is helpful to note a few useful adaptations
 of the above incantation, for various kinds of process launchers:
 
 .. code-block:: bash
 
-   ./charmrun +p2 `which valgrind` --log-file=VG.out.%p --trace-children=yes ./application_name ...application arguments...
-   aprun -n 2 `which valgrind` --log-file=VG.out.%p --trace-children=yes ./application_name ...application arguments...
+   ./charmrun +p2 `which valgrind` --log-file=VG.out.%p --trace-children=yes ./application_name ...application arguments...
+   aprun -n 2 `which valgrind` --log-file=VG.out.%p --trace-children=yes ./application_name ...application arguments...
 
 The first adaptation is to use :literal:`\`which valgrind\`` to obtain a
 full path to the valgrind binary, since parallel process launchers
index 88ba74f8ce42369a736201850a59b5012f6042e6..d8b6d652c3afec4e7eaaa5e488fa89b2d589e3c0 100644 (file)
@@ -55,9 +55,9 @@ directory and build the project.
 
 .. code-block:: bash
 
-   > git clone https://charm.cs.illinois.edu/gerrit/ccs_tools
-   > cd ccs_tools
-   > ant
+   $ git clone https://charm.cs.illinois.edu/gerrit/ccs_tools
+   $ cd ccs_tools
+   $ ant
 
 This will create the executable ``bin/charmdebug``.
 
@@ -72,7 +72,7 @@ Build Charm++ using ``--enable-charmdebug`` option. For example:
 
 .. code-block:: bash
 
-   > ./build charm++ netlrts-darwin-x86_64 --enable-charmdebug
+   $ ./build charm++ netlrts-darwin-x86_64 --enable-charmdebug
 
 No instrumentation is required to use the Charm++ debugger. Being CCS
 based, you can use it to set and step through entry point breakpoints
@@ -161,14 +161,14 @@ line options for your program (shown here as ``opt1 opt2``):
 
 .. code-block:: bash
 
-   > charmdebug pgm +p4 4 opt1 opt2
+   $ charmdebug pgm +p4 4 opt1 opt2
 
 If the application should be run in a remote cluster behind a firewall,
 the previous command line will become:
 
 .. code-block:: bash
 
-   > charmdebug -host cluster.inst.edu -user myname -sshtunnel pgm +p4 4 opt1 opt2
+   $ charmdebug -host cluster.inst.edu -user myname -sshtunnel pgm +p4 4 opt1 opt2
 
 CharmDebug can also be executed without any parameters. The user can
 then choose the application to launch and its command line parameters
@@ -188,7 +188,7 @@ To replay a previously recorded session:
 
 .. code-block:: bash
 
-   > charmdebug pgm +p4 opt1 opt2  +replay
+   $ charmdebug pgm +p4 opt1 opt2  +replay
 
 Charm Debugging Related Options
 -------------------------------
index 0caa70cb49c038213b9a20be5b85cedd2e661874..67da9124147c2f104062fb9f8dcb7dbf41ef27da 100644 (file)
@@ -334,25 +334,25 @@ runtime system as follows: (Let’s say you have written ``hellof.f90``, ``hello
 
 .. code-block:: bash
 
-     > charmc hello.ci -language f90charm
+   $ charmc hello.ci -language f90charm
 
 will create ``hello.decl.h`` and ``hello.def.h``.
 
 .. code-block:: bash
 
-     > charmc -c hello.C
+   $ charmc -c hello.C
 
 will compile ``hello.C`` with ``hello.decl.h`` and ``hello.def.h``.
 
 .. code-block:: bash
 
-     > charmc -c hellof.f90
+   $ charmc -c hellof.f90
 
 charmc will invoke the Fortran compiler:
 
 .. code-block:: bash
 
-     > charmc -o hello hello.o hellof.o -language f90charm
+   $ charmc -o hello hello.o hellof.o -language f90charm
 
 will link ``hellof.o`` and ``hello.o`` against Charm’s Fortran90 library to create
 a new executable program, ``hello``.
@@ -366,6 +366,6 @@ To run the program, type:
 
 .. code-block:: bash
 
-    > ./charmrun +p2 hello
+   $ ./charmrun +p2 hello
 
 which will run ``hello`` on two PEs.
index 352fc35eab8cc57e55670d0b1c4b3e28e292aba5..c0cbcc840dda048ccc1172313f62eba946b8ac94 100644 (file)
@@ -231,11 +231,11 @@ commands:
 
 .. code-block:: bash
 
-    > cd charm/
-    > ./src/libs/ck-libs/fem/make_fem_alone.sh
-    > cd fem_alone/
-    > mpicc -I. -DFEM_ALONE=1 -c *.c *.C
-    > ar cr libfem_alone.a *.o
+   $ cd charm/
+   $ ./src/libs/ck-libs/fem/make_fem_alone.sh
+   $ cd fem_alone/
+   $ mpicc -I. -DFEM_ALONE=1 -c *.c *.C
+   $ ar cr libfem_alone.a *.o
 
 You will then have to build your application with the MPI compilers, and
 manually point to this “fem_alone” directory to find include files and
@@ -243,7 +243,7 @@ the new FEM library. A typical compiler invocation would be:
 
 .. code-block:: bash
 
-    > mpif90 -I$HOME/charm/fem_alone -L$HOME/charm/fem_alone foo.f90 -lfem_alone -o foo
+   $ mpif90 -I$HOME/charm/fem_alone -L$HOME/charm/fem_alone foo.f90 -lfem_alone -o foo
 
 This “standalone”, non-Charm++ method of building the FEM framework
 prevents the use of load balancing or the other features of Charm++, so
index 487b5451ed15a6ee99ea95edac025b07c3021da2..423674d77582a8dea4115d30d6e2a79da5ab4c15 100644 (file)
@@ -140,9 +140,9 @@ source.
 The build script for Charm++ is called ``build``. The syntax for this
 script is:
 
-::
+.. code-block:: bash
 
-   > build <target> <version> <opts>
+   $ build <target> <version> <opts>
 
 For building Jade(which also includes building Charm++ and other
 libraries needed by Jade), specify ``<target>`` to be ``jade``. And
@@ -160,9 +160,9 @@ programs. See the ``charm/README`` file for details on picking the proper
 version. Following is an example of how to build Jade under linux and
 ethernet environment, with debugging info produced:
 
-::
+.. code-block:: bash
 
-   > build jade netlrts-linux -g
+   $ build jade netlrts-linux -g
 
 Compiling and Running Jade Programs
 ===================================
@@ -189,10 +189,10 @@ compilers like ``cc``. To build an Jade program, the command line option
 you would use for other compilers can be used with ``charmc`` the same
 way. For example:
 
-::
+.. code-block:: bash
 
-   > charmc -language jade -c pgm.java -O3
-   > charmc -language jade -o pgm pgm.o -lm -O3
+   $ charmc -language jade -c pgm.java -O3
+   $ charmc -language jade -o pgm pgm.o -lm -O3
 
 Running
 -------
@@ -206,9 +206,9 @@ number of processors to run on, and the name of the program followed by
 Jade options (such as TBD) and the program arguments. A typical
 invocation of Jade program ``pgm`` with ``charmrun`` is:
 
-::
+.. code-block:: bash
 
-   > charmrun pgm +p16 +vp32 +tcharm_stacksize 3276800
+   $ charmrun pgm +p16 +vp32 +tcharm_stacksize 3276800
 
 Here, the Jade program ``pgm`` is run on 16 physical processors with 32
 chunks (which will be mapped 2 per processor initially), where each
index 66ec753a0a474e85b5311f4903f55e71a5ed0382..eb8c9bee7fa70ec1f68c0f5e127a54ab61961d92 100644 (file)
@@ -131,9 +131,9 @@ To run the program in parallel, a ``charmrun`` executable was created by
 ``charmc``. The flag ``+p`` is used to specify a number of processors to
 run the program on. For example:
 
-::
+.. code-block:: bash
 
-   > ./charmrun pgm +p4
+   $ ./charmrun pgm +p4
 
 This runs the executable ``pgm`` on 4 processors. For more information
 on how to use ``charmrun`` and set up your environment for parallel
index e0b2c2ecf2731e1e70a2f950e4807c8e9af37a7c..cc372c0302fa63ac57d1d285a7d5613ca32c21f3 100644 (file)
@@ -481,7 +481,7 @@ Starting Up
 ~~~~~~~~~~~
 
 | From any location, type:
-| ``> PROJECTIONS_LOCATION/bin/projections [NAME.sts]``
+| ``$ PROJECTIONS_LOCATION/bin/projections [NAME.sts]``
 | where ``PROJECTIONS_LOCATION`` is the path to the main projections
   directory.