Comment blocks

Author: Denis Jelovina

ALP_Transition_Path_Tutorial.tex

@@ -24,7 +24,7 @@ \subsection{Installation on Linux}
 Then enter the repository directory.
 
 \item Build ALP: Create a build directory and invoke the provided bootstrap script to configure the project with CMake, then compile and install:
-\begin{lstlisting}[language=bash]
+\begin{lstlisting}[language=bash, basicstyle=\ttfamily\small, showstringspaces=false]
 $ cd ALP && mkdir build && cd build
 $ ../bootstrap.sh --prefix=../install # configure the build
 $ make -j # compile the ALP library
@@ -35,19 +35,19 @@ \subsection{Installation on Linux}
 (You can choose a different installation prefix as needed.)
 
 \item Set up environment: After installation, activate the ALP environment by sourcing the script setenv in the install directory:
-\begin{lstlisting}[language=bash]
+\begin{lstlisting}[language=bash, basicstyle=\ttfamily\small, showstringspaces=false]
 $ source ../install/bin/setenv
 \end{lstlisting}
 This script updates paths to make ALP's compiler wrapper and libraries available.
 
 \item Compile an example: ALP provides a compiler wrapper \texttt{grbcxx} to compile programs that use the ALP/GraphBLAS API. This wrapper automatically adds the correct include paths and links against the ALP library and its dependencies. For example, to compile the provided sp.cpp sample:
-\begin{lstlisting}[language=bash]
+\begin{lstlisting}[language=bash, basicstyle=\ttfamily\small, showstringspaces=false]
 $ grbcxx ../examples/sp.cpp -o sp_example
 \end{lstlisting}
 By default this produces a sequential program; you can add the option \texttt{-b reference\_omp} to use the OpenMP parallel backend (shared-memory parallelism). The wrapper \texttt{grbcxx} accepts other backends as well (e.g.\ \texttt{-b hybrid} for distributed memory).
 
 \item Run the program: Use the provided runner \texttt{grbrun} to execute the compiled binary. For a simple shared-memory program, running with \texttt{grbrun} is similar to using \texttt{./program} directly. For example:
-\begin{lstlisting}[language=bash]
+\begin{lstlisting}[language=bash, basicstyle=\ttfamily\small, showstringspaces=false]
 $ grbrun ./sp_example
 \end{lstlisting}
 (The \texttt{grbrun} tool is more relevant when using distributed backends or controlling the execution environment; for basic usage, the program can also be run directly.)
@@ -58,7 +58,7 @@ \subsection{Installation on Linux}
 
 \textbf{Direct linking option}: If you prefer to compile with your usual compiler, you need to include ALP's headers and link against the ALP libraries manually. For the CG solver transition path, that typically means linking against the sparse solver library (e.g. libspsolver\_shmem\_parallel for the parallel version) and any core ALP libraries it depends on. For example, if ALP is installed in /opt/alp , you might compile with:
 
-\begin{lstlisting}[language=bash]
+\begin{lstlisting}[language=bash, basicstyle=\ttfamily\small, showstringspaces=false]
 gcc -I/opt/alp/include -L/opt/alp/lib \
 -lspsolver_shmem_parallel -lalp_cspblas_shmem_parallel \
 my_program.c -o my_program
@@ -106,7 +106,7 @@ \section{Example: Solving a Linear System with ALP’s CG Solver}
 Below is a complete program using ALP’s CG solver to solve for $x$. We include the necessary ALP header
 for the solver API, set up the matrix and vectors, call the API functions in order, and then print the result.
 
-\begin{lstlisting}[ label=lst:example, showstringspaces=false]
+\begin{lstlisting}[language=C++, label=lst:example, showstringspaces=false, basicstyle=\ttfamily\small, caption={Example program using ALP's CG solver API}]s
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -193,7 +193,7 @@ \section{Example: Solving a Linear System with ALP’s CG Solver}
 
 \section*{Building and Running the Example}
 To compile the above code with ALP, we will use the direct linking option as discussed. 
-\begin{lstlisting}[language=bash]
+\begin{lstlisting}[language=bash, basicstyle=\ttfamily\small, showstringspaces=false]
 g++ example.cpp -o cg_demo \
   -I install/include \
   -L install/lib \

ALP_Tutorial.tex

@@ -107,7 +107,7 @@ \subsubsection{Exercise: Allocating Vectors and Matrices in ALP}
 
 When you run this program, ALP will print informational messages about initialization and finalization, and you will see lines reporting each container’s capacity. In particular, you should observe output similar to:
 
-\begin{lstlisting}
+\begin{lstlisting} [language=bash, basicstyle=\ttfamily\small, showstringspaces=false]
 Info: grb::init (reference) called.
 Capacity of x: 100
 Capacity of y: 1000
@@ -138,7 +138,7 @@ \subsection{Semirings and Algebraic Operations}
 A semiring is a combination of a multiplicative operator and an additive monoid. Many common semirings are provided or can be constructed. For instance, the plus-times semiring uses standard addition as the accumulation (monoid) and multiplication as the combination operator – this yields ordinary linear algebra over real numbers. One can also define a \texttt{min-plus} semiring (useful for shortest path algorithms, where "addition" is min and "multiplication" is numeric addition). ALP’s design allows an “almost unlimited variety of operators and types” in semirings.
 
 In code, ALP provides templates to construct these. For example, one can define:
-\begin{lstlisting}
+\begin{lstlisting} [language=C++, basicstyle=\ttfamily\small, showstringspaces=false ]
 using Add = grb::operators::add<double>;
 using AddMonoid = grb::Monoid<Add, grb::identities::zero>;
 using Mul = grb::operators::mul<double>;
@@ -204,7 +204,7 @@ \section{Simple Example}\label{sec:simple_example}
 
 Below is the code for this example, with commentary:
 
-\begin{lstlisting}[caption={Example program using ALP/GraphBLAS primitives in C++}, label=lst:example, showstringspaces=false]
+\begin{lstlisting}[ language=C++, basicstyle=\ttfamily\small, caption={Example program using ALP/GraphBLAS primitives in C++}, label=lst:example, showstringspaces=false]
 
 /*
  * example.cpp - Corrected minimal ALP (GraphBLAS) example.
@@ -391,7 +391,7 @@ \section{Simple Example}\label{sec:simple_example}
 
 When you run the example, the program first prints each step of the computation (building the matrix, creating the vector, etc.). In particular, you will see lines like
 
-\begin{lstlisting}
+\begin{lstlisting} [language=bash, basicstyle=\ttfamily\small, showstringspaces=false]
 Step 1: Constructing a 3x3 sparse matrix A.
 Step 2: Creating vector x = [1, 2, 3]^T.
 Step 3: Computing y = A·x under plus‐times semiring.
@@ -420,7 +420,7 @@ \section{Simple Example}\label{sec:simple_example}
 \mathrm{dot}(\mathbf{x},\mathbf{x}) \;=\; 14.
 \]
 Hence, immediately after the step‐headings, the console will display something like:
-\begin{lstlisting}
+\begin{lstlisting} [language=bash, basicstyle=\ttfamily\small, showstringspaces=false]
 // Step 4: Computing z = x ⊙ x (element‐wise multiply).
 x = [ 1, 2, 3 ]
 y = A·x = [ 7, 18, 17 ]
@@ -466,7 +466,7 @@ \subsection*{Using a custom build (Make/CMake)}
 
 If you are using CMake for your own project, you can integrate ALP as follows. There may not be an official CMake package for ALP, but you can use \texttt{find\_library} or hard-code the path. For instance, in your \texttt{CMakeLists.txt}:
 
-\begin{lstlisting}
+\begin{lstlisting}[caption={Example CMakeLists.txt for an ALP project}]
     cmake_minimum_required(VERSION 3.13)
     project(ALPExample CXX)
     find_package(OpenMP REQUIRED) # find OpenMP for -fopenmp