Documentation - User contributions [en]

Deploying a web server

2018-05-29T16:50:56Z

Preney: Preney moved page Deploying a web server. to Deploying a web server over redirect: Removing dot in title.

=Dependencies - Launch Cloud Instance=
Before deploying a web server, first a cloud instance must be lauched. The instruction to do this can be found [[Carpet|here]].
For the remainder of the instructions the ip address used is 199.241.164.95, this is for demonstration purposes and you should replace
it with your assigned floating IP address.

# login to cloud.sharcnet.ca
# Don’t forget volume size
# Choose Debian 9.2.2 (not required, but the remaining instructions are Debian centric).
# Choose persistent (ephemeral is for shorter jobs) (4C-8GB)
# Setup keypair
# Associate floating ip

==(Optional) Apply IP Address to your name server==
If you have a registered domain name you should apply your floating IP address to it so that you can use the "let's encrypt" service to
enable the secure socket layer without client side warnings. It is often best to do this at the beginning as there is typically a delay
in updating the name service.

= Server Setup =

==Login to Server & perform preliminaries==
At this point log into the server to ensure that the service is up and running. There are a number of steps you can perform that will make
the remaining steps easier. First loging to the server. Then setup a user prompt to make navigation easier. Switch to root (or use sudo in
from of the remaining commands). Update and upgrade the system. Last install the manual pages.
$ ssh debian@199.241.164.95
$ echo 'export PS1="\[\e[33m\]\w\[\e[0m\]\n\[\e[32m\]\u@\h$ \[\e[0m\]"' >> .bash_aliases
$ sudo su root
$ apt update
$ apt upgrade
$ apt install man

==Apt error==
If you receive the "apt error" mesage put "nameserver 8.8.8.8" in /etc/resolve.conf.
$ echo 'nameserver 8.8.8.8 >>' /etc/resolve.conf

==Secure the SSH login==
The following changes will disable logging into the server by using a password on any account and prevent logging into root remotly. Root can
still be accessed by logging into a ''sudo'' enabled account and using the command ''su root''. For more information on the sshd_config file
options, go [https://man.openbsd.org/sshd_config here]. The unattended-upgrades package is used to keep they server up to date automatically.
$ sudo vim /etc/ssh/sshd_config
ChallengeResponseAuthentication no
PasswordAuthentication no
PermitRootLogin no
$ service ssh reload
$ apt install unattended-upgrades
$ dpkg-reconfigure --priority=low unattended-upgrades
$ sudo unattended-upgrade -d

=Install webserver and suppporting packages=
==MYSQL==
$ apt install mysql-server
$ mysql_secure_installation #password=password

==Apache==
Installing the Apache webserver will allow you to access a default page at your ip address. (ex http://199.241.164.95, or http://frar.ca).
Note that https will not yet work. httpd is the Apache HyperText Transfer Protocol (HTTP) server program. It is designed to be run as a standalone daemon process. When used like this it will create a pool of child processes or threads to handle requests. In general, httpd should not be invoked directly, but rather should be invoked via apachectl on Unix-based systems or as a service on Windows NT, 2000 and XP and as a console application on Windows 9x and ME.

$ apt install apache2
$ service apache2 start #add 80, 443 to default security group rules
$ a2enmod cgid.load #(optional) enable cgi scripting, a2dismod to remove

===Basic information & settings===
# Document root Directory: /var/www/html or /var/www
# Main Configuration file:
## /etc/httpd/conf/httpd.conf (RHEL/CentOS/Fedora)
## /etc/apache2/apache2.conf (Debian/Ubuntu).
# Default HTTP Port: 80 TCP
# Default HTTPS Port: 443 TCP
# Access Log files of Web Server: /var/log/apache2/access_log
# Error Log files of Web Server: /var/log/apache2/error_log
# service apache2 {start|stop|graceful-stop|restart|reload|force-reload}
# apachectl -v
## [https://httpd.apache.org/docs/2.4/programs/apachectl.html see]

===Secure Apache with SSL certificates===
Going to https is now possible but will trigger a warning.
$ a2enmod ssl
$ a2ensite default-ssl.conf
$ service apache2 restart

===Enable let's encrypt (requires a domain name)===
$ apt install git
$ sudo git clone https://github.com/letsencrypt/letsencrypt /opt/letsencrypt
$ cd /opt/letsencrypt
$ ./certbot-auto --authenticator webroot --installer apache
www.frar.ca
/var/www/html

===Add basic user-password verfication===
$ mkdir /var/www/passwd
$ htpasswd -c /var/www/passwd/passwords user
$ vim /etc/apache2/apache2.conf
<Directory /var/www/html>
Require valid-user
AuthType basic
AuthName "Restricted Files"
AuthUserFile "/var/www/passwd/passwords"
</Directory>
$ service apache2 restart

==Helper packages==
===Install PHP===
$ apt -y install php7.0 libapache2-mod-php7.0 php7.0-mysql php7.0-gd php7.0-opcache
$ echo ‘<?php phpinfo(); ?>’ > /var/www/html/test.php

===Give www-data an ssh key and ownership of home directory===
$ chmod 774 /var/www/html
$ chown www-data:www-data -R /var/www
$ mkdir /var/www/.ssh
$ chown www-data:www-data /var/www/.ssh
$ sudo -u www-data ssh-keygen -C www-data #no passphrase for now

File:Dice 0p9 Makefile.txt

2017-10-24T19:04:36Z

Preney: Patchfile for Makefile in Dice v0.9.

Patchfile for Makefile in Dice v0.9.

BOOST

2017-07-25T19:43:39Z

Preney:

{{Software
|package_name=BOOST
|package_description=free peer-reviewed portable C++ source libraries
|package_idnumber=137
}}

{{Template:GrahamUpdate}}

== Which Versions of Boost are Available? ==

SHARCNET has a number of Boost versions available as special modules. The available versions can be viewed by running:
<pre>
module avail boost
</pre>
and/or by viewing the [https://www.sharcnet.ca/my/software/show/137 BOOST software page in the web portal].

When you look up the available boost modules you will see output similar tossh-:
<pre>
$ module avail boost

------------------------------------------------ /opt/sharcnet/modules -------------------------------------------------
boost/gcc482-openmpi183/1.53.0 boost/gcc510-openmpi187/1.59.0 boost/intel1503-openmpi187/1.59.0
boost/gcc482-openmpi183/1.55.0 boost/gcc510-openmpi187debug/1.59.0 boost/intel1503-openmpi187debug/1.59.0
boost/gcc492-openmpi187/1.59.0 boost/intel12-openmpi162/1.53.0
boost/gcc492-openmpi187debug/1.59.0 boost/intel12-openmpi162/1.55.0
$
</pre>

i.e., the following versions of Boost are available:
# versions 1.53 and 1.55 built with GCC v4.8.2 and OpenMPI v1.8.3
#* i.e., boost/gcc482-openmpi183/1.53.0 and boost/gcc482-openmpi183/1.55.0
# version 1.59 built with GCC v4.9.2 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e.,, boost/gcc492-openmpi187/1.59.0 and boost/gcc492-openmpi187debug/1.59.0
# version 1.59 built with GCC v5.1.0 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e., boost/gcc510-openmpi187/1.59.0 and boost/gcc510-openmpi187debug/1.59.0
# versions 1.53 and 1.55 built with Intel v12 and OpenMPI v1.6.2
#* i.e., boost/intel12-openmpi162/1.53.0 and boost/intel12-openmpi162/1.55.0
# version 1.59 built with Intel v15.0.3 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e., boost/intel1503-openmpi187/1.59.0 and boost/intel1503-openmpi187debug/1.59.0

'''NOTE:''' You may experience problems compiling Boost codes with the Intel v12 compiler (e.g., some incompatible headers). If you do, try the GCC compiler to see if that works.

All of the aforementioned versions of Boost have been built with the operating system's installed Python. You can see which version of Python it will use by running:
<pre>
rpm -qi python
</pre>

'''NOTE:''' If you need a specific version of Boost compiled for a specific C++ compiler, version of OpenMPI, and/or a specific version of Python, then submit a ticket requesting such. Be sure to mention all required software packages and which versions are needed.

=== Loading a module ===

To load a specific module of Boost simply use "module load" followed by the module name, e.g.,

<pre>module load boost/intel1503-openmpi187debug/1.59.0</pre>

If an error occurs, ensure that you load all pre-requisite modules first. Often it is easier to remove all modules, load the required ldwrapper module (which is needed for your programs to work when submitted using sqsub), and the the modules you need to use, e.g.,

<pre>$ module purge
$ module load ldwrapper
$ module load gcc/5.1.0
$ module load openmpi/gcc-5.1.0/std/1.8.7
$ module load boost/gcc510-openmpi187/1.59.0</pre>

== Compiling Programs Using CMake With Boost ==

With CMake you will want code similar to the following to properly load Boost:

<pre>find_package(
Boost 1.56.0 REQUIRED
COMPONENTS
filesystem
system
)</pre>

where:

# 1.56.0 is the MINIMUM version that can be used by your program. You should replace this with the version you are using, e.g., 1.59.0. (Know that omitting the minimum version setting can cause issues with CMake not finding Boost.)
# REQUIRED means that if the minimum version is not about to be used, an error will occur and compilation will be aborted. Generally it is a good idea to use REQUIRED to avoid cryptic compilation error messages when an incompatible version of Boost is used.
# If you use any Boost components that have library code that must be linked into your program, you will need to specify COMPONENTS followed by the names of those components.

If CMake finds the wrong version of boost. Try telling CMake to not use the built in boost system path:

<pre>
set(Boost_NO_SYSTEM_PATHS ON)
</pre>

This will cause CMake to look at the BOOST_ROOT environment variable, instead of the default locations.

You can view the names of all required-to-be-linked-to-a-library components for the version of Boost you are using by running the following command (after using "module load" to load the version of Boost you want to use):

<pre>ls -1 $BOOST_ROOT/lib/libboost*{so,a}* | xargs -n 1 basename | sed -e 's/^libboost_//' -e 's/\.so.*$//' -e 's/\.a.*$//' | sort -u</pre>

which will output something similar to this:

<pre>$ ls -1 $BOOST_ROOT/lib/libboost*{so,a}* | xargs -n 1 basename | sed -e 's/^libboost_//' -e 's/\.so.*$//' -e 's/\.a.*$//' | sort -u
atomic
chrono
context
coroutine
date_time
exception
filesystem
graph
graph_parallel
iostreams
locale
log
log_setup
math_c99
math_c99f
math_c99l
math_tr1
math_tr1f
math_tr1l
mpi
prg_exec_monitor
program_options
python
random
regex
serialization
signals
system
test_exec_monitor
thread
timer
unit_test_framework
wave
wserialization
$</pre>

Some of the library components depend on other components. For example, the "filesystem" component depends on the "system" component --so both of these must be specified in the find_package() CMake function call.

You also will need lines similar to the follwing in your CMakeLists.txt:

<pre>add_executable(
program.exe
src/somecode.cxx
)

target_link_libraries(
program.exe
${Boost_LIBRARIES}
)</pre>

where:

# program.exe is the executable being produced.
# ${Boost_LIBRARIES} is set by the find_package() function and contains all of the libraries it discovered (for the listed COMPONENTS section above).

'''NOTE:''' With the target_link_libraries() set, you do not need or want to set LD_LIBRARY_PATH at all for Boost to work, i.e., if you are loading the SHARCNET module, everything is properly set. (With CMake you must tell it which libraries must be linked in to your executable --it is not automatic.)

== Using a Specific Version of Boost ==

To use a specific version of Boost, do the following:
* Unload any loaded OpenMPI modules that will conflict.
* Unload any loaded C++ compiler modules that will conflict.
* Load any required C++ and OpenMPI modules.
* Load the required version of Boost.
e.g.,
<pre>
$ module list # View which modules are currently loaded
$ module unload openmpi/intel/1.6.2 # Unload the OpenMPI (for Intel)
$ module unload intel/12.1.3 # Unload the Intel C++ compiler
$ module load gcc/4.8.2 # Load GCC v4.8.2
$ module load openmpi/gcc/1.8.3 # Load OpenMPI (for GCC)
$ module load boost/gcc482-openmpi183/1.57.0 # Load Boost v1.57 for GCC 4.8.2 and OpenMPI v1.8.3
</pre>

Once this is done, you may use Boost (e.g., write #include <boost/filesystem.hpp> in your code, etc.). No special compiler options will be required.

If you want to start with NO modules loaded, then you can do the same by purging first, loading ldwrapper, followed by what you need, e.g.,
<pre>
$ module purge
$ module load ldwrapper
$ module load gcc/4.8.2 # Load GCC v4.8.2
$ module load openmpi/gcc/1.8.3 # Load OpenMPI (for GCC)
$ module load boost/gcc482-openmpi183/1.57.0 # Load Boost v1.57 for GCC 4.8.2 and OpenMPI v1.8.3
</pre>

== If Special Compiler Options are Required ==

If you are not having success building your code using Boost (e.g., in a Makefile), you might need to manually specify the INCLUDE and LIB directories. You can get these paths by running the following command (replacing the full Boost module name with the one you've loaded), e.g.,
<pre>
$ module show boost/gcc482-openmpi183/1.57.0
-------------------------------------------------------------------
/opt/sharcnet/modules/boost/gcc482-openmpi183/1.57.0:

module-whatis Provides boost 1.57.0 (flavor gcc482-openmpi183) built using gcc/4.8.2, openmpi/gcc/1.8.3 on centos64.
conflict intel
conflict pgi
conflict python
prereq gcc/4.8.2
prereq openmpi/gcc/1.8.3
prepend-path --delim CPPFLAGS -I/opt/sharcnet/boost/1.57.0/gcc482-openmpi183/include
prepend-path --delim LDFLAGS -L/opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib
prepend-path LD_RUN_PATH /opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib
-------------------------------------------------------------------
$
</pre>
i.e., for Boost 1.57.0 (flavour gcc482-openmpi183) you could explicitly invoke the compiler with:
<pre>
g++ $CPPFLAGS $CXXFLAGS $LDFLAGS yoursourcecode.cxx
</pre>

Also be aware that you must specify any Boost-required libraries for linking purposes using the -l option. You can see the actual available library names for any given Boost installation by running:

<pre>
$ for a in `ls $BLIBS` ; do basename $a ; done
</pre>

where $BLIBS is the directory you see with LDFLAGS in the module show output, thus, to see all libraries available with the gcc482-openmpi183/lib module, you would write:

<pre>
$ for a in `ls /opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib/libboost_*` ; do basename $a ; done
</pre>

'''NOTE:''' Using the -l option is important when using any non-header-only Boost library, e.g., MPI, serialization, program_options, etc.

== Building an Example Boost Program ==

First create/write/copy your program somewhere suitable (this example is from the Boost.MPI documentation):
<pre>
$ cd
$ mkdir boost-test
$ cat >boost-mpi-eg.cxx
#include <iostream>
#include <string>
#include <boost/mpi.hpp>
#include <boost/serialization/string.hpp>

namespace mpi = boost::mpi;

int main(int argc, char *argv[])
{
mpi::environment env(argc, argv);
mpi::communicator world;

if (world.rank() == 0) {
world.send(1, 0, std::string("Hello"));
std::string msg;
world.recv(1, 1, msg);
std::cout << msg << "!" << std::endl;
} else {
std::string msg;
world.recv(0, 0, msg);
std::cout << msg << ", ";
std::cout.flush();
world.send(0, 1, std::string("world"));
}

return 0;
}
$
</pre>
compile it:
<pre>
$ mpic++ $CPPFLAGS $CXXFLAGS $LDFLAGS -lboost_mpi -lboost_serialization boost-mpi-eg.cxx
</pre>
and run it (as it is very fast and short, sqsub is not used here):
<pre>
$ mpirun -np 2 ./a.out
</pre>

== A Header-Only Example ==

Many libraries in Boost are header-only (i.e., the program does not need to be linked to a library). With header-only libraries one does not specify any linking options when compiling/linking the code.

Consider the following Boost.Multiprecision program:

<pre>
// This program's code combines code from the following Boost.Multiprecision documentation's pages:
// 1) http://www.boost.org/doc/libs/1_63_0/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/cpp_int.html
// 2) http://www.boost.org/doc/libs/1_63_0/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_bin_float.html
// 3) http://www.boost.org/doc/libs/1_63_0/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_dec_float.html

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <iostream>

void mp_int()
{
// For integer type docs see:
// http://www.boost.org/doc/libs/1_63_0/libs/multiprecision/doc/html/boost_multiprecision/tut/ints.html

// Example Boost docs code follows...

using namespace boost::multiprecision;

// Do some fixed precision arithmetic:
int128_t v = 1;
for (unsigned i = 1; i <= 20; ++i)
v *= i;
std::cout << v << std::endl; // prints 20

// Repeat at arbitrary precision:
cpp_int u = 1;
for (unsigned i = 1; i <= 100; ++i)
u *= i;
std::cout << u << std::endl; // prints 100
}

void mp_bin_float()
{
// For floating-point type docs see:
// http://www.boost.org/doc/libs/1_63_0/libs/multiprecision/doc/html/boost_multiprecision/tut/floats.html

// Example Boost docs code follows...

using namespace boost::multiprecision;

// Operations at fixed precision and full numeric_limits support:
cpp_bin_float_100 b = 2;
std::cout << std::numeric_limits<cpp_bin_float_100>::digits << std::endl;
std::cout << std::numeric_limits<cpp_bin_float_100>::digits10 << std::endl;

// We can use any C++ std lib function, lets print all the digits as well:
std::cout << std::setprecision(std::numeric_limits<cpp_bin_float_100>::max_digits10)
<< log(b) << std::endl; // print log(2)

// We can also use any function from Boost.Math:
std::cout << boost::math::tgamma(b) << std::endl;

// These even work when the argument is an expression template:
std::cout << boost::math::tgamma(b * b) << std::endl;

// And since we have an extended exponent range we can generate some really large
// numbers here (4.0238726007709377354370243e+2564):
std::cout << boost::math::tgamma(cpp_bin_float_100(1000)) << std::endl;
}

void mp_dec_float()
{
using namespace boost::multiprecision;

// Operations at fixed precision and full numeric_limits support:
cpp_dec_float_100 b = 2;
std::cout << std::numeric_limits<cpp_dec_float_100>::digits << std::endl;

// Note that digits10 is the same as digits, since we're base 10! :
std::cout << std::numeric_limits<cpp_dec_float_100>::digits10 << std::endl;

// We can use any C++ std lib function, lets print all the digits as well:
std::cout << std::setprecision(std::numeric_limits<cpp_dec_float_100>::max_digits10)
<< log(b) << std::endl; // print log(2)

// We can also use any function from Boost.Math:
std::cout << boost::math::tgamma(b) << std::endl;

// These even work when the argument is an expression template:
std::cout << boost::math::tgamma(b * b) << std::endl;

// And since we have an extended exponent range we can generate some really large
// numbers here (4.0238726007709377354370243e+2564):
std::cout << boost::math::tgamma(cpp_dec_float_100(1000)) << std::endl;
}

int main()
{
mp_int();
mp_bin_float();
mp_dec_float();
}
</pre>

It be compiled and run using GCC v6.3.0 as follows:

<pre>
$ module unload gcc intel openmpi mkl boost
$ module load gcc/6.3.0 boost/gcc630/1.63.0
$ g++ -I$BOOST_ROOT/include boost-multiprecision.cxx
$ ./a.out
</pre>

or with Intel v17.0.1:

<pre>
$ module unload gcc intel openmpi mkl boost
$ module load intel/17.0.1 boost/intel1701/1.63.0
$ icpc -I$BOOST_ROOT/include boost-multiprecision.cxx
$ ./a.out
</pre>

== Operating System Installed Boost ==

If you don't load a SHARCNET boost module, your program will most likely link to the operating system's installed version of Boost. To determine which version(s) of boost and boost-devel are installed run the following commands:
<pre>
rpm -qi boost
rpm -qi boost-devel
</pre>

'''NOTE:''' System versions are rather old and won't be upgraded or maintained by SHARCNET staff unless something in the operating system requires it to be updated. Therefore we '''strongly encourag''' using the SHARCNET provided Boost modules discussed above on this page.

==References==

o Boost Homepage 
http://www.boost.org/

BOOST

2017-03-17T18:44:35Z

Preney: /* Building an Example Boost Program */

{{Software
|package_name=BOOST
|package_description=free peer-reviewed portable C++ source libraries
|package_idnumber=137
}}

== Which Versions of Boost are Available? ==

SHARCNET has a number of Boost versions available as special modules. The available versions can be viewed by running:
<pre>
module avail boost
</pre>
and/or by viewing the [https://www.sharcnet.ca/my/software/show/137 BOOST software page in the web portal].

When you look up the available boost modules you will see output similar tossh-:
<pre>
$ module avail boost

------------------------------------------------ /opt/sharcnet/modules -------------------------------------------------
boost/gcc482-openmpi183/1.53.0 boost/gcc510-openmpi187/1.59.0 boost/intel1503-openmpi187/1.59.0
boost/gcc482-openmpi183/1.55.0 boost/gcc510-openmpi187debug/1.59.0 boost/intel1503-openmpi187debug/1.59.0
boost/gcc492-openmpi187/1.59.0 boost/intel12-openmpi162/1.53.0
boost/gcc492-openmpi187debug/1.59.0 boost/intel12-openmpi162/1.55.0
$
</pre>

i.e., the following versions of Boost are available:
# versions 1.53 and 1.55 built with GCC v4.8.2 and OpenMPI v1.8.3
#* i.e., boost/gcc482-openmpi183/1.53.0 and boost/gcc482-openmpi183/1.55.0
# version 1.59 built with GCC v4.9.2 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e.,, boost/gcc492-openmpi187/1.59.0 and boost/gcc492-openmpi187debug/1.59.0
# version 1.59 built with GCC v5.1.0 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e., boost/gcc510-openmpi187/1.59.0 and boost/gcc510-openmpi187debug/1.59.0
# versions 1.53 and 1.55 built with Intel v12 and OpenMPI v1.6.2
#* i.e., boost/intel12-openmpi162/1.53.0 and boost/intel12-openmpi162/1.55.0
# version 1.59 built with Intel v15.0.3 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e., boost/intel1503-openmpi187/1.59.0 and boost/intel1503-openmpi187debug/1.59.0

'''NOTE:''' You may experience problems compiling Boost codes with the Intel v12 compiler (e.g., some incompatible headers). If you do, try the GCC compiler to see if that works.

All of the aforementioned versions of Boost have been built with the operating system's installed Python. You can see which version of Python it will use by running:
<pre>
rpm -qi python
</pre>

'''NOTE:''' If you need a specific version of Boost compiled for a specific C++ compiler, version of OpenMPI, and/or a specific version of Python, then submit a ticket requesting such. Be sure to mention all required software packages and which versions are needed.

=== Loading a module ===

To load a specific module of Boost simply use "module load" followed by the module name, e.g.,

<pre>module load boost/intel1503-openmpi187debug/1.59.0</pre>

If an error occurs, ensure that you load all pre-requisite modules first. Often it is easier to remove all modules, load the required ldwrapper module (which is needed for your programs to work when submitted using sqsub), and the the modules you need to use, e.g.,

<pre>$ module purge
$ module load ldwrapper
$ module load gcc/5.1.0
$ module load openmpi/gcc-5.1.0/std/1.8.7
$ module load boost/gcc510-openmpi187/1.59.0</pre>

== Compiling Programs Using CMake With Boost ==

With CMake you will want code similar to the following to properly load Boost:

<pre>find_package(
Boost 1.56.0 REQUIRED
COMPONENTS
filesystem
system
)</pre>

where:

# 1.56.0 is the MINIMUM version that can be used by your program. You should replace this with the version you are using, e.g., 1.59.0. (Know that omitting the minimum version setting can cause issues with CMake not finding Boost.)
# REQUIRED means that if the minimum version is not about to be used, an error will occur and compilation will be aborted. Generally it is a good idea to use REQUIRED to avoid cryptic compilation error messages when an incompatible version of Boost is used.
# If you use any Boost components that have library code that must be linked into your program, you will need to specify COMPONENTS followed by the names of those components.

If CMake finds the wrong version of boost. Try telling CMake to not use the built in boost system path:

<pre>
set(Boost_NO_SYSTEM_PATHS ON)
</pre>

This will cause CMake to look at the BOOST_ROOT environment variable, instead of the default locations.

You can view the names of all required-to-be-linked-to-a-library components for the version of Boost you are using by running the following command (after using "module load" to load the version of Boost you want to use):

<pre>ls -1 $BOOST_ROOT/lib/libboost*{so,a}* | xargs -n 1 basename | sed -e 's/^libboost_//' -e 's/\.so.*$//' -e 's/\.a.*$//' | sort -u</pre>

which will output something similar to this:

<pre>$ ls -1 $BOOST_ROOT/lib/libboost*{so,a}* | xargs -n 1 basename | sed -e 's/^libboost_//' -e 's/\.so.*$//' -e 's/\.a.*$//' | sort -u
atomic
chrono
context
coroutine
date_time
exception
filesystem
graph
graph_parallel
iostreams
locale
log
log_setup
math_c99
math_c99f
math_c99l
math_tr1
math_tr1f
math_tr1l
mpi
prg_exec_monitor
program_options
python
random
regex
serialization
signals
system
test_exec_monitor
thread
timer
unit_test_framework
wave
wserialization
$</pre>

Some of the library components depend on other components. For example, the "filesystem" component depends on the "system" component --so both of these must be specified in the find_package() CMake function call.

You also will need lines similar to the follwing in your CMakeLists.txt:

<pre>add_executable(
program.exe
src/somecode.cxx
)

target_link_libraries(
program.exe
${Boost_LIBRARIES}
)</pre>

where:

# program.exe is the executable being produced.
# ${Boost_LIBRARIES} is set by the find_package() function and contains all of the libraries it discovered (for the listed COMPONENTS section above).

'''NOTE:''' With the target_link_libraries() set, you do not need or want to set LD_LIBRARY_PATH at all for Boost to work, i.e., if you are loading the SHARCNET module, everything is properly set. (With CMake you must tell it which libraries must be linked in to your executable --it is not automatic.)

== Using a Specific Version of Boost ==

To use a specific version of Boost, do the following:
* Unload any loaded OpenMPI modules that will conflict.
* Unload any loaded C++ compiler modules that will conflict.
* Load any required C++ and OpenMPI modules.
* Load the required version of Boost.
e.g.,
<pre>
$ module list # View which modules are currently loaded
$ module unload openmpi/intel/1.6.2 # Unload the OpenMPI (for Intel)
$ module unload intel/12.1.3 # Unload the Intel C++ compiler
$ module load gcc/4.8.2 # Load GCC v4.8.2
$ module load openmpi/gcc/1.8.3 # Load OpenMPI (for GCC)
$ module load boost/gcc482-openmpi183/1.57.0 # Load Boost v1.57 for GCC 4.8.2 and OpenMPI v1.8.3
</pre>

Once this is done, you may use Boost (e.g., write #include <boost/filesystem.hpp> in your code, etc.). No special compiler options will be required.

If you want to start with NO modules loaded, then you can do the same by purging first, loading ldwrapper, followed by what you need, e.g.,
<pre>
$ module purge
$ module load ldwrapper
$ module load gcc/4.8.2 # Load GCC v4.8.2
$ module load openmpi/gcc/1.8.3 # Load OpenMPI (for GCC)
$ module load boost/gcc482-openmpi183/1.57.0 # Load Boost v1.57 for GCC 4.8.2 and OpenMPI v1.8.3
</pre>

== If Special Compiler Options are Required ==

If you are not having success building your code using Boost (e.g., in a Makefile), you might need to manually specify the INCLUDE and LIB directories. You can get these paths by running the following command (replacing the full Boost module name with the one you've loaded), e.g.,
<pre>
$ module show boost/gcc482-openmpi183/1.57.0
-------------------------------------------------------------------
/opt/sharcnet/modules/boost/gcc482-openmpi183/1.57.0:

module-whatis Provides boost 1.57.0 (flavor gcc482-openmpi183) built using gcc/4.8.2, openmpi/gcc/1.8.3 on centos64.
conflict intel
conflict pgi
conflict python
prereq gcc/4.8.2
prereq openmpi/gcc/1.8.3
prepend-path --delim CPPFLAGS -I/opt/sharcnet/boost/1.57.0/gcc482-openmpi183/include
prepend-path --delim LDFLAGS -L/opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib
prepend-path LD_RUN_PATH /opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib
-------------------------------------------------------------------
$
</pre>
i.e., for Boost 1.57.0 (flavour gcc482-openmpi183) you could explicitly invoke the compiler with:
<pre>
g++ $CPPFLAGS $CXXFLAGS $LDFLAGS yoursourcecode.cxx
</pre>

Also be aware that you must specify any Boost-required libraries for linking purposes using the -l option. You can see the actual available library names for any given Boost installation by running:

<pre>
$ for a in `ls $BLIBS` ; do basename $a ; done
</pre>

where $BLIBS is the directory you see with LDFLAGS in the module show output, thus, to see all libraries available with the gcc482-openmpi183/lib module, you would write:

<pre>
$ for a in `ls /opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib/libboost_*` ; do basename $a ; done
</pre>

'''NOTE:''' Using the -l option is important when using any non-header-only Boost library, e.g., MPI, serialization, program_options, etc.

== Building an Example Boost Program ==

First create/write/copy your program somewhere suitable (this example is from the Boost.MPI documentation):
<pre>
$ cd
$ mkdir boost-test
$ cat >boost-mpi-eg.cxx
#include <iostream>
#include <string>
#include <boost/mpi.hpp>
#include <boost/serialization/string.hpp>

namespace mpi = boost::mpi;

int main(int argc, char *argv[])
{
mpi::environment env(argc, argv);
mpi::communicator world;

if (world.rank() == 0) {
world.send(1, 0, std::string("Hello"));
std::string msg;
world.recv(1, 1, msg);
std::cout << msg << "!" << std::endl;
} else {
std::string msg;
world.recv(0, 0, msg);
std::cout << msg << ", ";
std::cout.flush();
world.send(0, 1, std::string("world"));
}

return 0;
}
$
</pre>
compile it:
<pre>
$ mpic++ $CPPFLAGS $CXXFLAGS $LDFLAGS -lboost_mpi -lboost_serialization boost-mpi-eg.cxx
</pre>
and run it (as it is very fast and short, sqsub is not used here):
<pre>
$ mpirun -np 2 ./a.out
</pre>

== A Header-Only Example ==

Many libraries in Boost are header-only (i.e., the program does not need to be linked to a library). With header-only libraries one does not specify any linking options when compiling/linking the code.

Consider the following Boost.Multiprecision program:

<pre>
// This program's code combines code from the following Boost.Multiprecision documentation's pages:
// 1) http://www.boost.org/doc/libs/1_63_0/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/cpp_int.html
// 2) http://www.boost.org/doc/libs/1_63_0/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_bin_float.html
// 3) http://www.boost.org/doc/libs/1_63_0/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_dec_float.html

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <iostream>

void mp_int()
{
// For integer type docs see:
// http://www.boost.org/doc/libs/1_63_0/libs/multiprecision/doc/html/boost_multiprecision/tut/ints.html

// Example Boost docs code follows...

using namespace boost::multiprecision;

// Do some fixed precision arithmetic:
int128_t v = 1;
for (unsigned i = 1; i <= 20; ++i)
v *= i;
std::cout << v << std::endl; // prints 20

// Repeat at arbitrary precision:
cpp_int u = 1;
for (unsigned i = 1; i <= 100; ++i)
u *= i;
std::cout << u << std::endl; // prints 100
}

void mp_bin_float()
{
// For floating-point type docs see:
// http://www.boost.org/doc/libs/1_63_0/libs/multiprecision/doc/html/boost_multiprecision/tut/floats.html

// Example Boost docs code follows...

using namespace boost::multiprecision;

// Operations at fixed precision and full numeric_limits support:
cpp_bin_float_100 b = 2;
std::cout << std::numeric_limits<cpp_bin_float_100>::digits << std::endl;
std::cout << std::numeric_limits<cpp_bin_float_100>::digits10 << std::endl;

// We can use any C++ std lib function, lets print all the digits as well:
std::cout << std::setprecision(std::numeric_limits<cpp_bin_float_100>::max_digits10)
<< log(b) << std::endl; // print log(2)

// We can also use any function from Boost.Math:
std::cout << boost::math::tgamma(b) << std::endl;

// These even work when the argument is an expression template:
std::cout << boost::math::tgamma(b * b) << std::endl;

// And since we have an extended exponent range we can generate some really large
// numbers here (4.0238726007709377354370243e+2564):
std::cout << boost::math::tgamma(cpp_bin_float_100(1000)) << std::endl;
}

void mp_dec_float()
{
using namespace boost::multiprecision;

// Operations at fixed precision and full numeric_limits support:
cpp_dec_float_100 b = 2;
std::cout << std::numeric_limits<cpp_dec_float_100>::digits << std::endl;

// Note that digits10 is the same as digits, since we're base 10! :
std::cout << std::numeric_limits<cpp_dec_float_100>::digits10 << std::endl;

// We can use any C++ std lib function, lets print all the digits as well:
std::cout << std::setprecision(std::numeric_limits<cpp_dec_float_100>::max_digits10)
<< log(b) << std::endl; // print log(2)

// We can also use any function from Boost.Math:
std::cout << boost::math::tgamma(b) << std::endl;

// These even work when the argument is an expression template:
std::cout << boost::math::tgamma(b * b) << std::endl;

// And since we have an extended exponent range we can generate some really large
// numbers here (4.0238726007709377354370243e+2564):
std::cout << boost::math::tgamma(cpp_dec_float_100(1000)) << std::endl;
}

int main()
{
mp_int();
mp_bin_float();
mp_dec_float();
}
</pre>

It be compiled and run using GCC v6.3.0 as follows:

<pre>
$ module unload gcc intel openmpi mkl boost
$ module load gcc/6.3.0 boost/gcc630/1.63.0
$ g++ -I$BOOST_ROOT/include boost-multiprecision.cxx
$ ./a.out
</pre>

or with Intel v17.0.1:

<pre>
$ module unload gcc intel openmpi mkl boost
$ module load intel/17.0.1 boost/intel1701/1.63.0
$ icpc -I$BOOST_ROOT/include boost-multiprecision.cxx
$ ./a.out
</pre>

== Operating System Installed Boost ==

If you don't load a SHARCNET boost module, your program will most likely link to the operating system's installed version of Boost. To determine which version(s) of boost and boost-devel are installed run the following commands:
<pre>
rpm -qi boost
rpm -qi boost-devel
</pre>

'''NOTE:''' System versions are rather old and won't be upgraded or maintained by SHARCNET staff unless something in the operating system requires it to be updated. Therefore we '''strongly encourag''' using the SHARCNET provided Boost modules discussed above on this page.

==References==

o Boost Homepage 
http://www.boost.org/

BOOST

2017-03-17T18:33:19Z

Preney: /* Compiling Programs Using CMake With Boost */

{{Software
|package_name=BOOST
|package_description=free peer-reviewed portable C++ source libraries
|package_idnumber=137
}}

== Which Versions of Boost are Available? ==

SHARCNET has a number of Boost versions available as special modules. The available versions can be viewed by running:
<pre>
module avail boost
</pre>
and/or by viewing the [https://www.sharcnet.ca/my/software/show/137 BOOST software page in the web portal].

When you look up the available boost modules you will see output similar tossh-:
<pre>
$ module avail boost

------------------------------------------------ /opt/sharcnet/modules -------------------------------------------------
boost/gcc482-openmpi183/1.53.0 boost/gcc510-openmpi187/1.59.0 boost/intel1503-openmpi187/1.59.0
boost/gcc482-openmpi183/1.55.0 boost/gcc510-openmpi187debug/1.59.0 boost/intel1503-openmpi187debug/1.59.0
boost/gcc492-openmpi187/1.59.0 boost/intel12-openmpi162/1.53.0
boost/gcc492-openmpi187debug/1.59.0 boost/intel12-openmpi162/1.55.0
$
</pre>

i.e., the following versions of Boost are available:
# versions 1.53 and 1.55 built with GCC v4.8.2 and OpenMPI v1.8.3
#* i.e., boost/gcc482-openmpi183/1.53.0 and boost/gcc482-openmpi183/1.55.0
# version 1.59 built with GCC v4.9.2 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e.,, boost/gcc492-openmpi187/1.59.0 and boost/gcc492-openmpi187debug/1.59.0
# version 1.59 built with GCC v5.1.0 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e., boost/gcc510-openmpi187/1.59.0 and boost/gcc510-openmpi187debug/1.59.0
# versions 1.53 and 1.55 built with Intel v12 and OpenMPI v1.6.2
#* i.e., boost/intel12-openmpi162/1.53.0 and boost/intel12-openmpi162/1.55.0
# version 1.59 built with Intel v15.0.3 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e., boost/intel1503-openmpi187/1.59.0 and boost/intel1503-openmpi187debug/1.59.0

'''NOTE:''' You may experience problems compiling Boost codes with the Intel v12 compiler (e.g., some incompatible headers). If you do, try the GCC compiler to see if that works.

All of the aforementioned versions of Boost have been built with the operating system's installed Python. You can see which version of Python it will use by running:
<pre>
rpm -qi python
</pre>

'''NOTE:''' If you need a specific version of Boost compiled for a specific C++ compiler, version of OpenMPI, and/or a specific version of Python, then submit a ticket requesting such. Be sure to mention all required software packages and which versions are needed.

=== Loading a module ===

To load a specific module of Boost simply use "module load" followed by the module name, e.g.,

<pre>module load boost/intel1503-openmpi187debug/1.59.0</pre>

If an error occurs, ensure that you load all pre-requisite modules first. Often it is easier to remove all modules, load the required ldwrapper module (which is needed for your programs to work when submitted using sqsub), and the the modules you need to use, e.g.,

<pre>$ module purge
$ module load ldwrapper
$ module load gcc/5.1.0
$ module load openmpi/gcc-5.1.0/std/1.8.7
$ module load boost/gcc510-openmpi187/1.59.0</pre>

== Compiling Programs Using CMake With Boost ==

With CMake you will want code similar to the following to properly load Boost:

<pre>find_package(
Boost 1.56.0 REQUIRED
COMPONENTS
filesystem
system
)</pre>

where:

# 1.56.0 is the MINIMUM version that can be used by your program. You should replace this with the version you are using, e.g., 1.59.0. (Know that omitting the minimum version setting can cause issues with CMake not finding Boost.)
# REQUIRED means that if the minimum version is not about to be used, an error will occur and compilation will be aborted. Generally it is a good idea to use REQUIRED to avoid cryptic compilation error messages when an incompatible version of Boost is used.
# If you use any Boost components that have library code that must be linked into your program, you will need to specify COMPONENTS followed by the names of those components.

If CMake finds the wrong version of boost. Try telling CMake to not use the built in boost system path:

<pre>
set(Boost_NO_SYSTEM_PATHS ON)
</pre>

This will cause CMake to look at the BOOST_ROOT environment variable, instead of the default locations.

You can view the names of all required-to-be-linked-to-a-library components for the version of Boost you are using by running the following command (after using "module load" to load the version of Boost you want to use):

<pre>ls -1 $BOOST_ROOT/lib/libboost*{so,a}* | xargs -n 1 basename | sed -e 's/^libboost_//' -e 's/\.so.*$//' -e 's/\.a.*$//' | sort -u</pre>

which will output something similar to this:

<pre>$ ls -1 $BOOST_ROOT/lib/libboost*{so,a}* | xargs -n 1 basename | sed -e 's/^libboost_//' -e 's/\.so.*$//' -e 's/\.a.*$//' | sort -u
atomic
chrono
context
coroutine
date_time
exception
filesystem
graph
graph_parallel
iostreams
locale
log
log_setup
math_c99
math_c99f
math_c99l
math_tr1
math_tr1f
math_tr1l
mpi
prg_exec_monitor
program_options
python
random
regex
serialization
signals
system
test_exec_monitor
thread
timer
unit_test_framework
wave
wserialization
$</pre>

Some of the library components depend on other components. For example, the "filesystem" component depends on the "system" component --so both of these must be specified in the find_package() CMake function call.

You also will need lines similar to the follwing in your CMakeLists.txt:

<pre>add_executable(
program.exe
src/somecode.cxx
)

target_link_libraries(
program.exe
${Boost_LIBRARIES}
)</pre>

where:

# program.exe is the executable being produced.
# ${Boost_LIBRARIES} is set by the find_package() function and contains all of the libraries it discovered (for the listed COMPONENTS section above).

'''NOTE:''' With the target_link_libraries() set, you do not need or want to set LD_LIBRARY_PATH at all for Boost to work, i.e., if you are loading the SHARCNET module, everything is properly set. (With CMake you must tell it which libraries must be linked in to your executable --it is not automatic.)

== Using a Specific Version of Boost ==

To use a specific version of Boost, do the following:
* Unload any loaded OpenMPI modules that will conflict.
* Unload any loaded C++ compiler modules that will conflict.
* Load any required C++ and OpenMPI modules.
* Load the required version of Boost.
e.g.,
<pre>
$ module list # View which modules are currently loaded
$ module unload openmpi/intel/1.6.2 # Unload the OpenMPI (for Intel)
$ module unload intel/12.1.3 # Unload the Intel C++ compiler
$ module load gcc/4.8.2 # Load GCC v4.8.2
$ module load openmpi/gcc/1.8.3 # Load OpenMPI (for GCC)
$ module load boost/gcc482-openmpi183/1.57.0 # Load Boost v1.57 for GCC 4.8.2 and OpenMPI v1.8.3
</pre>

Once this is done, you may use Boost (e.g., write #include <boost/filesystem.hpp> in your code, etc.). No special compiler options will be required.

If you want to start with NO modules loaded, then you can do the same by purging first, loading ldwrapper, followed by what you need, e.g.,
<pre>
$ module purge
$ module load ldwrapper
$ module load gcc/4.8.2 # Load GCC v4.8.2
$ module load openmpi/gcc/1.8.3 # Load OpenMPI (for GCC)
$ module load boost/gcc482-openmpi183/1.57.0 # Load Boost v1.57 for GCC 4.8.2 and OpenMPI v1.8.3
</pre>

== If Special Compiler Options are Required ==

If you are not having success building your code using Boost (e.g., in a Makefile), you might need to manually specify the INCLUDE and LIB directories. You can get these paths by running the following command (replacing the full Boost module name with the one you've loaded), e.g.,
<pre>
$ module show boost/gcc482-openmpi183/1.57.0
-------------------------------------------------------------------
/opt/sharcnet/modules/boost/gcc482-openmpi183/1.57.0:

module-whatis Provides boost 1.57.0 (flavor gcc482-openmpi183) built using gcc/4.8.2, openmpi/gcc/1.8.3 on centos64.
conflict intel
conflict pgi
conflict python
prereq gcc/4.8.2
prereq openmpi/gcc/1.8.3
prepend-path --delim CPPFLAGS -I/opt/sharcnet/boost/1.57.0/gcc482-openmpi183/include
prepend-path --delim LDFLAGS -L/opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib
prepend-path LD_RUN_PATH /opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib
-------------------------------------------------------------------
$
</pre>
i.e., for Boost 1.57.0 (flavour gcc482-openmpi183) you could explicitly invoke the compiler with:
<pre>
g++ $CPPFLAGS $CXXFLAGS $LDFLAGS yoursourcecode.cxx
</pre>

Also be aware that you must specify any Boost-required libraries for linking purposes using the -l option. You can see the actual available library names for any given Boost installation by running:

<pre>
$ for a in `ls $BLIBS` ; do basename $a ; done
</pre>

where $BLIBS is the directory you see with LDFLAGS in the module show output, thus, to see all libraries available with the gcc482-openmpi183/lib module, you would write:

<pre>
$ for a in `ls /opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib/libboost_*` ; do basename $a ; done
</pre>

'''NOTE:''' Using the -l option is important when using any non-header-only Boost library, e.g., MPI, serialization, program_options, etc.

== Building an Example Boost Program ==

First create/write/copy your program somewhere suitable (this example is from the Boost.MPI documentation):
<pre>
$ cd
$ mkdir boost-test
$ cat >boost-mpi-eg.cxx
#include <iostream>
#include <string>
#include <boost/mpi.hpp>
#include <boost/serialization/string.hpp>

namespace mpi = boost::mpi;

int main(int argc, char *argv[])
{
mpi::environment env(argc, argv);
mpi::communicator world;

if (world.rank() == 0) {
world.send(1, 0, std::string("Hello"));
std::string msg;
world.recv(1, 1, msg);
std::cout << msg << "!" << std::endl;
} else {
std::string msg;
world.recv(0, 0, msg);
std::cout << msg << ", ";
std::cout.flush();
world.send(0, 1, std::string("world"));
}

return 0;
}
$
</pre>
compile it:
<pre>
$ mpic++ $CPPFLAGS $CXXFLAGS $LDFLAGS -lboost_mpi -lboost_serialization boost-mpi-eg.cxx
</pre>
and run it (as it is very fast and short, sqsub is not used here):
<pre>
$ mpirun -np 2 ./a.out
</pre>

== Operating System Installed Boost ==

If you don't load a SHARCNET boost module, your program will most likely link to the operating system's installed version of Boost. To determine which version(s) of boost and boost-devel are installed run the following commands:
<pre>
rpm -qi boost
rpm -qi boost-devel
</pre>

'''NOTE:''' System versions are rather old and won't be upgraded or maintained by SHARCNET staff unless something in the operating system requires it to be updated. Therefore we '''strongly encourag''' using the SHARCNET provided Boost modules discussed above on this page.

==References==

o Boost Homepage 
http://www.boost.org/

BOOST

2015-12-19T15:57:04Z

Preney: /* Loading a module */

{{Software
|package_name=BOOST
|package_description=free peer-reviewed portable C++ source libraries
|package_idnumber=137
}}

== Which Versions of Boost are Available? ==

SHARCNET has a number of Boost versions available as special modules. The available versions can be viewed by running:
<pre>
module avail boost
</pre>
and/or by viewing the [https://www.sharcnet.ca/my/software/show/137 BOOST software page in the web portal].

When you look up the available boost modules you will see output similar tossh-:
<pre>
$ module avail boost

------------------------------------------------ /opt/sharcnet/modules -------------------------------------------------
boost/gcc482-openmpi183/1.53.0 boost/gcc510-openmpi187/1.59.0 boost/intel1503-openmpi187/1.59.0
boost/gcc482-openmpi183/1.55.0 boost/gcc510-openmpi187debug/1.59.0 boost/intel1503-openmpi187debug/1.59.0
boost/gcc492-openmpi187/1.59.0 boost/intel12-openmpi162/1.53.0
boost/gcc492-openmpi187debug/1.59.0 boost/intel12-openmpi162/1.55.0
$
</pre>

i.e., the following versions of Boost are available:
# versions 1.53 and 1.55 built with GCC v4.8.2 and OpenMPI v1.8.3
#* i.e., boost/gcc482-openmpi183/1.53.0 and boost/gcc482-openmpi183/1.55.0
# version 1.59 built with GCC v4.9.2 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e.,, boost/gcc492-openmpi187/1.59.0 and boost/gcc492-openmpi187debug/1.59.0
# version 1.59 built with GCC v5.1.0 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e., boost/gcc510-openmpi187/1.59.0 and boost/gcc510-openmpi187debug/1.59.0
# versions 1.53 and 1.55 built with Intel v12 and OpenMPI v1.6.2
#* i.e., boost/intel12-openmpi162/1.53.0 and boost/intel12-openmpi162/1.55.0
# version 1.59 built with Intel v15.0.3 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e., boost/intel1503-openmpi187/1.59.0 and boost/intel1503-openmpi187debug/1.59.0

'''NOTE:''' You may experience problems compiling Boost codes with the Intel v12 compiler (e.g., some incompatible headers). If you do, try the GCC compiler to see if that works.

All of the aforementioned versions of Boost have been built with the operating system's installed Python. You can see which version of Python it will use by running:
<pre>
rpm -qi python
</pre>

'''NOTE:''' If you need a specific version of Boost compiled for a specific C++ compiler, version of OpenMPI, and/or a specific version of Python, then submit a ticket requesting such. Be sure to mention all required software packages and which versions are needed.

=== Loading a module ===

To load a specific module of Boost simply use "module load" followed by the module name, e.g.,

<pre>module load boost/intel1503-openmpi187debug/1.59.0</pre>

If an error occurs, ensure that you load all pre-requisite modules first. Often it is easier to remove all modules, load the required ldwrapper module (which is needed for your programs to work when submitted using sqsub), and the the modules you need to use, e.g.,

<pre>$ module purge
$ module load ldwrapper
$ module load gcc/5.1.0
$ module load openmpi/gcc-5.1.0/std/1.8.7
$ module load boost/gcc510-openmpi187/1.59.0</pre>

== Compiling Programs Using CMake With Boost ==

With CMake you will want code similar to the following to properly load Boost:

<pre>find_package(
Boost 1.56.0 REQUIRED
COMPONENTS
filesystem
system
)</pre>

where:

# 1.56.0 is the MINIMUM version that can be used by your program. You should replace this with the version you are using, e.g., 1.59.0. (Know that omitting the minimum version setting can cause issues with CMake not finding Boost.)
# REQUIRED means that if the minimum version is not about to be used, an error will occur and compilation will be aborted. Generally it is a good idea to use REQUIRED to avoid cryptic compilation error messages when an incompatible version of Boost is used.
# If you use any Boost components that have library code that must be linked into your program, you will need to specify COMPONENTS followed by the names of those components.

You can view the names of all library components for the version of Boost you are using by running the following command (after using "module load" to load the version of Boost you want to use):

<pre>ls -1 $BOOST_ROOT/lib/libboost*{so,a}* | xargs -n 1 basename | sed -e 's/^libboost_//' -e 's/\.so.*$//' -e 's/\.a.*$//' | sort -u</pre>

which will output something similar to this:

<pre>$ ls -1 $BOOST_ROOT/lib/libboost*{so,a}* | xargs -n 1 basename | sed -e 's/^libboost_//' -e 's/\.so.*$//' -e 's/\.a.*$//' | sort -u
atomic
chrono
context
coroutine
date_time
exception
filesystem
graph
graph_parallel
iostreams
locale
log
log_setup
math_c99
math_c99f
math_c99l
math_tr1
math_tr1f
math_tr1l
mpi
prg_exec_monitor
program_options
python
random
regex
serialization
signals
system
test_exec_monitor
thread
timer
unit_test_framework
wave
wserialization
$</pre>

Some of the library components depend on other components. For example, the "filesystem" component depends on the "system" component --so both of these must be specified in the find_package() CMake function call.

You also will need lines similar to the follwing in your CMakeLists.txt:

<pre>add_executable(
program.exe
src/somecode.cxx
)

target_link_libraries(
program.exe
${Boost_LIBRARIES}
)</pre>

where:

# program.exe is the executable being produced.
# ${Boost_LIBRARIES} is set by the find_package() function and contains all of the libraries it discovered (for the listed COMPONENTS section above).

'''NOTE:''' With the target_link_libraries() set, you do not need or want to set LD_LIBRARY_PATH at all for Boost to work, i.e., if you are loading the SHARCNET module, everything is properly set. (With CMake you must tell it which libraries must be linked in to your executable --it is not automatic.)

== Using a Specific Version of Boost ==

To use a specific version of Boost, do the following:
* Unload any loaded OpenMPI modules that will conflict.
* Unload any loaded C++ compiler modules that will conflict.
* Load any required C++ and OpenMPI modules.
* Load the required version of Boost.
e.g.,
<pre>
$ module list # View which modules are currently loaded
$ module unload openmpi/intel/1.6.2 # Unload the OpenMPI (for Intel)
$ module unload intel/12.1.3 # Unload the Intel C++ compiler
$ module load gcc/4.8.2 # Load GCC v4.8.2
$ module load openmpi/gcc/1.8.3 # Load OpenMPI (for GCC)
$ module load boost/gcc482-openmpi183/1.57.0 # Load Boost v1.57 for GCC 4.8.2 and OpenMPI v1.8.3
</pre>

Once this is done, you may use Boost (e.g., write #include <boost/filesystem.hpp> in your code, etc.). No special compiler options will be required.

If you want to start with NO modules loaded, then you can do the same by purging first, loading ldwrapper, followed by what you need, e.g.,
<pre>
$ module purge
$ module load ldwrapper
$ module load gcc/4.8.2 # Load GCC v4.8.2
$ module load openmpi/gcc/1.8.3 # Load OpenMPI (for GCC)
$ module load boost/gcc482-openmpi183/1.57.0 # Load Boost v1.57 for GCC 4.8.2 and OpenMPI v1.8.3
</pre>

== If Special Compiler Options are Required ==

If you are not having success building your code using Boost (e.g., in a Makefile), you might need to manually specify the INCLUDE and LIB directories. You can get these paths by running the following command (replacing the full Boost module name with the one you've loaded), e.g.,
<pre>
$ module show boost/gcc482-openmpi183/1.57.0
-------------------------------------------------------------------
/opt/sharcnet/modules/boost/gcc482-openmpi183/1.57.0:

module-whatis Provides boost 1.57.0 (flavor gcc482-openmpi183) built using gcc/4.8.2, openmpi/gcc/1.8.3 on centos64.
conflict intel
conflict pgi
conflict python
prereq gcc/4.8.2
prereq openmpi/gcc/1.8.3
prepend-path --delim CPPFLAGS -I/opt/sharcnet/boost/1.57.0/gcc482-openmpi183/include
prepend-path --delim LDFLAGS -L/opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib
prepend-path LD_RUN_PATH /opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib
-------------------------------------------------------------------
$
</pre>
i.e., for Boost 1.57.0 (flavour gcc482-openmpi183) you could explicitly invoke the compiler with:
<pre>
g++ $CPPFLAGS $CXXFLAGS $LDFLAGS yoursourcecode.cxx
</pre>

Also be aware that you must specify any Boost-required libraries for linking purposes using the -l option. You can see the actual available library names for any given Boost installation by running:

<pre>
$ for a in `ls $BLIBS` ; do basename $a ; done
</pre>

where $BLIBS is the directory you see with LDFLAGS in the module show output, thus, to see all libraries available with the gcc482-openmpi183/lib module, you would write:

<pre>
$ for a in `ls /opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib/libboost_*` ; do basename $a ; done
</pre>

'''NOTE:''' Using the -l option is important when using any non-header-only Boost library, e.g., MPI, serialization, program_options, etc.

== Building an Example Boost Program ==

First create/write/copy your program somewhere suitable (this example is from the Boost.MPI documentation):
<pre>
$ cd
$ mkdir boost-test
$ cat >boost-mpi-eg.cxx
#include <iostream>
#include <string>
#include <boost/mpi.hpp>
#include <boost/serialization/string.hpp>

namespace mpi = boost::mpi;

int main(int argc, char *argv[])
{
mpi::environment env(argc, argv);
mpi::communicator world;

if (world.rank() == 0) {
world.send(1, 0, std::string("Hello"));
std::string msg;
world.recv(1, 1, msg);
std::cout << msg << "!" << std::endl;
} else {
std::string msg;
world.recv(0, 0, msg);
std::cout << msg << ", ";
std::cout.flush();
world.send(0, 1, std::string("world"));
}

return 0;
}
$
</pre>
compile it:
<pre>
$ mpic++ $CPPFLAGS $CXXFLAGS $LDFLAGS -lboost_mpi -lboost_serialization boost-mpi-eg.cxx
</pre>
and run it (as it is very fast and short, sqsub is not used here):
<pre>
$ mpirun -np 2 ./a.out
</pre>

== Operating System Installed Boost ==

If you don't load a SHARCNET boost module, your program will most likely link to the operating system's installed version of Boost. To determine which version(s) of boost and boost-devel are installed run the following commands:
<pre>
rpm -qi boost
rpm -qi boost-devel
</pre>

'''NOTE:''' System versions are rather old and won't be upgraded or maintained by SHARCNET staff unless something in the operating system requires it to be updated. Therefore we '''strongly encourag''' using the SHARCNET provided Boost modules discussed above on this page.

==References==

o Boost Homepage 
http://www.boost.org/

BOOST

2015-12-19T15:56:13Z

Preney: /* Compiling Programs Using CMake With Boost */

{{Software
|package_name=BOOST
|package_description=free peer-reviewed portable C++ source libraries
|package_idnumber=137
}}

== Which Versions of Boost are Available? ==

SHARCNET has a number of Boost versions available as special modules. The available versions can be viewed by running:
<pre>
module avail boost
</pre>
and/or by viewing the [https://www.sharcnet.ca/my/software/show/137 BOOST software page in the web portal].

When you look up the available boost modules you will see output similar tossh-:
<pre>
$ module avail boost

------------------------------------------------ /opt/sharcnet/modules -------------------------------------------------
boost/gcc482-openmpi183/1.53.0 boost/gcc510-openmpi187/1.59.0 boost/intel1503-openmpi187/1.59.0
boost/gcc482-openmpi183/1.55.0 boost/gcc510-openmpi187debug/1.59.0 boost/intel1503-openmpi187debug/1.59.0
boost/gcc492-openmpi187/1.59.0 boost/intel12-openmpi162/1.53.0
boost/gcc492-openmpi187debug/1.59.0 boost/intel12-openmpi162/1.55.0
$
</pre>

i.e., the following versions of Boost are available:
# versions 1.53 and 1.55 built with GCC v4.8.2 and OpenMPI v1.8.3
#* i.e., boost/gcc482-openmpi183/1.53.0 and boost/gcc482-openmpi183/1.55.0
# version 1.59 built with GCC v4.9.2 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e.,, boost/gcc492-openmpi187/1.59.0 and boost/gcc492-openmpi187debug/1.59.0
# version 1.59 built with GCC v5.1.0 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e., boost/gcc510-openmpi187/1.59.0 and boost/gcc510-openmpi187debug/1.59.0
# versions 1.53 and 1.55 built with Intel v12 and OpenMPI v1.6.2
#* i.e., boost/intel12-openmpi162/1.53.0 and boost/intel12-openmpi162/1.55.0
# version 1.59 built with Intel v15.0.3 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e., boost/intel1503-openmpi187/1.59.0 and boost/intel1503-openmpi187debug/1.59.0

'''NOTE:''' You may experience problems compiling Boost codes with the Intel v12 compiler (e.g., some incompatible headers). If you do, try the GCC compiler to see if that works.

All of the aforementioned versions of Boost have been built with the operating system's installed Python. You can see which version of Python it will use by running:
<pre>
rpm -qi python
</pre>

'''NOTE:''' If you need a specific version of Boost compiled for a specific C++ compiler, version of OpenMPI, and/or a specific version of Python, then submit a ticket requesting such. Be sure to mention all required software packages and which versions are needed.

=== Loading a module ===

To load a specific module of Boost simply use "module load" followed by the module name, e.g.,

<pre>module load boost/intel1503-openmpi187debug/1.59.0</pre>

If an error occurs, ensure that you load all pre-requisite modules first. Often it is easier to remove all modules, load the required ldwrapper module (which is needed for your programs to work when submitted using sqsub), and the the modules you need to use, e.g.,

<pre>module purge
module load ldwrapper
module load gcc/5.1.0
module load openmpi/gcc-5.1.0/std/1.8.7
module load boost/gcc510-openmpi187/1.59.0</pre>

== Compiling Programs Using CMake With Boost ==

With CMake you will want code similar to the following to properly load Boost:

<pre>find_package(
Boost 1.56.0 REQUIRED
COMPONENTS
filesystem
system
)</pre>

where:

# 1.56.0 is the MINIMUM version that can be used by your program. You should replace this with the version you are using, e.g., 1.59.0. (Know that omitting the minimum version setting can cause issues with CMake not finding Boost.)
# REQUIRED means that if the minimum version is not about to be used, an error will occur and compilation will be aborted. Generally it is a good idea to use REQUIRED to avoid cryptic compilation error messages when an incompatible version of Boost is used.
# If you use any Boost components that have library code that must be linked into your program, you will need to specify COMPONENTS followed by the names of those components.

You can view the names of all library components for the version of Boost you are using by running the following command (after using "module load" to load the version of Boost you want to use):

<pre>ls -1 $BOOST_ROOT/lib/libboost*{so,a}* | xargs -n 1 basename | sed -e 's/^libboost_//' -e 's/\.so.*$//' -e 's/\.a.*$//' | sort -u</pre>

which will output something similar to this:

<pre>$ ls -1 $BOOST_ROOT/lib/libboost*{so,a}* | xargs -n 1 basename | sed -e 's/^libboost_//' -e 's/\.so.*$//' -e 's/\.a.*$//' | sort -u
atomic
chrono
context
coroutine
date_time
exception
filesystem
graph
graph_parallel
iostreams
locale
log
log_setup
math_c99
math_c99f
math_c99l
math_tr1
math_tr1f
math_tr1l
mpi
prg_exec_monitor
program_options
python
random
regex
serialization
signals
system
test_exec_monitor
thread
timer
unit_test_framework
wave
wserialization
$</pre>

Some of the library components depend on other components. For example, the "filesystem" component depends on the "system" component --so both of these must be specified in the find_package() CMake function call.

You also will need lines similar to the follwing in your CMakeLists.txt:

<pre>add_executable(
program.exe
src/somecode.cxx
)

target_link_libraries(
program.exe
${Boost_LIBRARIES}
)</pre>

where:

# program.exe is the executable being produced.
# ${Boost_LIBRARIES} is set by the find_package() function and contains all of the libraries it discovered (for the listed COMPONENTS section above).

'''NOTE:''' With the target_link_libraries() set, you do not need or want to set LD_LIBRARY_PATH at all for Boost to work, i.e., if you are loading the SHARCNET module, everything is properly set. (With CMake you must tell it which libraries must be linked in to your executable --it is not automatic.)

== Using a Specific Version of Boost ==

To use a specific version of Boost, do the following:
* Unload any loaded OpenMPI modules that will conflict.
* Unload any loaded C++ compiler modules that will conflict.
* Load any required C++ and OpenMPI modules.
* Load the required version of Boost.
e.g.,
<pre>
$ module list # View which modules are currently loaded
$ module unload openmpi/intel/1.6.2 # Unload the OpenMPI (for Intel)
$ module unload intel/12.1.3 # Unload the Intel C++ compiler
$ module load gcc/4.8.2 # Load GCC v4.8.2
$ module load openmpi/gcc/1.8.3 # Load OpenMPI (for GCC)
$ module load boost/gcc482-openmpi183/1.57.0 # Load Boost v1.57 for GCC 4.8.2 and OpenMPI v1.8.3
</pre>

Once this is done, you may use Boost (e.g., write #include <boost/filesystem.hpp> in your code, etc.). No special compiler options will be required.

If you want to start with NO modules loaded, then you can do the same by purging first, loading ldwrapper, followed by what you need, e.g.,
<pre>
$ module purge
$ module load ldwrapper
$ module load gcc/4.8.2 # Load GCC v4.8.2
$ module load openmpi/gcc/1.8.3 # Load OpenMPI (for GCC)
$ module load boost/gcc482-openmpi183/1.57.0 # Load Boost v1.57 for GCC 4.8.2 and OpenMPI v1.8.3
</pre>

== If Special Compiler Options are Required ==

If you are not having success building your code using Boost (e.g., in a Makefile), you might need to manually specify the INCLUDE and LIB directories. You can get these paths by running the following command (replacing the full Boost module name with the one you've loaded), e.g.,
<pre>
$ module show boost/gcc482-openmpi183/1.57.0
-------------------------------------------------------------------
/opt/sharcnet/modules/boost/gcc482-openmpi183/1.57.0:

module-whatis Provides boost 1.57.0 (flavor gcc482-openmpi183) built using gcc/4.8.2, openmpi/gcc/1.8.3 on centos64.
conflict intel
conflict pgi
conflict python
prereq gcc/4.8.2
prereq openmpi/gcc/1.8.3
prepend-path --delim CPPFLAGS -I/opt/sharcnet/boost/1.57.0/gcc482-openmpi183/include
prepend-path --delim LDFLAGS -L/opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib
prepend-path LD_RUN_PATH /opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib
-------------------------------------------------------------------
$
</pre>
i.e., for Boost 1.57.0 (flavour gcc482-openmpi183) you could explicitly invoke the compiler with:
<pre>
g++ $CPPFLAGS $CXXFLAGS $LDFLAGS yoursourcecode.cxx
</pre>

Also be aware that you must specify any Boost-required libraries for linking purposes using the -l option. You can see the actual available library names for any given Boost installation by running:

<pre>
$ for a in `ls $BLIBS` ; do basename $a ; done
</pre>

where $BLIBS is the directory you see with LDFLAGS in the module show output, thus, to see all libraries available with the gcc482-openmpi183/lib module, you would write:

<pre>
$ for a in `ls /opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib/libboost_*` ; do basename $a ; done
</pre>

'''NOTE:''' Using the -l option is important when using any non-header-only Boost library, e.g., MPI, serialization, program_options, etc.

== Building an Example Boost Program ==

First create/write/copy your program somewhere suitable (this example is from the Boost.MPI documentation):
<pre>
$ cd
$ mkdir boost-test
$ cat >boost-mpi-eg.cxx
#include <iostream>
#include <string>
#include <boost/mpi.hpp>
#include <boost/serialization/string.hpp>

namespace mpi = boost::mpi;

int main(int argc, char *argv[])
{
mpi::environment env(argc, argv);
mpi::communicator world;

if (world.rank() == 0) {
world.send(1, 0, std::string("Hello"));
std::string msg;
world.recv(1, 1, msg);
std::cout << msg << "!" << std::endl;
} else {
std::string msg;
world.recv(0, 0, msg);
std::cout << msg << ", ";
std::cout.flush();
world.send(0, 1, std::string("world"));
}

return 0;
}
$
</pre>
compile it:
<pre>
$ mpic++ $CPPFLAGS $CXXFLAGS $LDFLAGS -lboost_mpi -lboost_serialization boost-mpi-eg.cxx
</pre>
and run it (as it is very fast and short, sqsub is not used here):
<pre>
$ mpirun -np 2 ./a.out
</pre>

== Operating System Installed Boost ==

If you don't load a SHARCNET boost module, your program will most likely link to the operating system's installed version of Boost. To determine which version(s) of boost and boost-devel are installed run the following commands:
<pre>
rpm -qi boost
rpm -qi boost-devel
</pre>

'''NOTE:''' System versions are rather old and won't be upgraded or maintained by SHARCNET staff unless something in the operating system requires it to be updated. Therefore we '''strongly encourag''' using the SHARCNET provided Boost modules discussed above on this page.

==References==

o Boost Homepage 
http://www.boost.org/

BOOST

2015-12-19T15:55:36Z

Preney: /* Which Versions of Boost are Available? */

{{Software
|package_name=BOOST
|package_description=free peer-reviewed portable C++ source libraries
|package_idnumber=137
}}

== Which Versions of Boost are Available? ==

SHARCNET has a number of Boost versions available as special modules. The available versions can be viewed by running:
<pre>
module avail boost
</pre>
and/or by viewing the [https://www.sharcnet.ca/my/software/show/137 BOOST software page in the web portal].

When you look up the available boost modules you will see output similar tossh-:
<pre>
$ module avail boost

------------------------------------------------ /opt/sharcnet/modules -------------------------------------------------
boost/gcc482-openmpi183/1.53.0 boost/gcc510-openmpi187/1.59.0 boost/intel1503-openmpi187/1.59.0
boost/gcc482-openmpi183/1.55.0 boost/gcc510-openmpi187debug/1.59.0 boost/intel1503-openmpi187debug/1.59.0
boost/gcc492-openmpi187/1.59.0 boost/intel12-openmpi162/1.53.0
boost/gcc492-openmpi187debug/1.59.0 boost/intel12-openmpi162/1.55.0
$
</pre>

i.e., the following versions of Boost are available:
# versions 1.53 and 1.55 built with GCC v4.8.2 and OpenMPI v1.8.3
#* i.e., boost/gcc482-openmpi183/1.53.0 and boost/gcc482-openmpi183/1.55.0
# version 1.59 built with GCC v4.9.2 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e.,, boost/gcc492-openmpi187/1.59.0 and boost/gcc492-openmpi187debug/1.59.0
# version 1.59 built with GCC v5.1.0 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e., boost/gcc510-openmpi187/1.59.0 and boost/gcc510-openmpi187debug/1.59.0
# versions 1.53 and 1.55 built with Intel v12 and OpenMPI v1.6.2
#* i.e., boost/intel12-openmpi162/1.53.0 and boost/intel12-openmpi162/1.55.0
# version 1.59 built with Intel v15.0.3 and non-debug and debug versions of OpenMPI v1.8.7
#* i.e., boost/intel1503-openmpi187/1.59.0 and boost/intel1503-openmpi187debug/1.59.0

'''NOTE:''' You may experience problems compiling Boost codes with the Intel v12 compiler (e.g., some incompatible headers). If you do, try the GCC compiler to see if that works.

All of the aforementioned versions of Boost have been built with the operating system's installed Python. You can see which version of Python it will use by running:
<pre>
rpm -qi python
</pre>

'''NOTE:''' If you need a specific version of Boost compiled for a specific C++ compiler, version of OpenMPI, and/or a specific version of Python, then submit a ticket requesting such. Be sure to mention all required software packages and which versions are needed.

=== Loading a module ===

To load a specific module of Boost simply use "module load" followed by the module name, e.g.,

<pre>module load boost/intel1503-openmpi187debug/1.59.0</pre>

If an error occurs, ensure that you load all pre-requisite modules first. Often it is easier to remove all modules, load the required ldwrapper module (which is needed for your programs to work when submitted using sqsub), and the the modules you need to use, e.g.,

<pre>module purge
module load ldwrapper
module load gcc/5.1.0
module load openmpi/gcc-5.1.0/std/1.8.7
module load boost/gcc510-openmpi187/1.59.0</pre>

== Compiling Programs Using CMake With Boost ==

With CMake you will want code similar to the following to properly load Boost:

<pre>find_package(
Boost 1.56.0 REQUIRED
COMPONENTS
filesystem
system
)</pre>

where:

# 1.56.0 is the MINIMUM version that can be used by your program. You should replace this with the version you are using, e.g., 1.59.0. (Know that omitting the minimum version setting can cause issues with CMake not finding Boost.)
# REQUIRED means that if the minimum version is not about to be used, an error will occur and compilation will be aborted. Generally it is a good idea to use REQUIRED to avoid cryptic compilation error messages when an incompatible version of Boost is used.
# If you use any Boost components that have library code that must be linked into your program, you will need to specify COMPONENTS followed by the names of those components.

You can view the names of all library components for the version of Boost you are using by running the following command (after using "module load" to load the version of Boost you want to use):

<pre>ls -1 $BOOST_ROOT/lib/libboost*{so,a}* | xargs -n 1 basename | sed -e 's/^libboost_//' -e 's/\.so.*$//' -e 's/\.a.*$//' | sort -u</pre>

which will output something similar to this:

<pre>$ ls -1 $BOOST_ROOT/lib/libboost*{so,a}* | xargs -n 1 basename | sed -e 's/^libboost_//' -e 's/\.so.*$//' -e 's/\.a.*$//' | sort -u
atomic
chrono
context
coroutine
date_time
exception
filesystem
graph
graph_parallel
iostreams
locale
log
log_setup
math_c99
math_c99f
math_c99l
math_tr1
math_tr1f
math_tr1l
mpi
prg_exec_monitor
program_options
python
random
regex
serialization
signals
system
test_exec_monitor
thread
timer
unit_test_framework
wave
wserialization
$</pre>

Some of the library components depend on other components. For example, the "filesystem" component depends on the "system" component --so both of these must be specified in the find_package() CMake function call.

You also will need lines similar to the follwing in your CMakeLists.txt:

add_executable(
program.exe
src/somecode.cxx
)

target_link_libraries(
program.exe
${Boost_LIBRARIES}
)

where:

# program.exe is the executable being produced.
# ${Boost_LIBRARIES} is set by the find_package() function and contains all of the libraries it discovered (for the listed COMPONENTS section above).

'''NOTE:''' With the target_link_libraries() set, you do not need or want to set LD_LIBRARY_PATH at all for Boost to work, i.e., if you are loading the SHARCNET module, everything is properly set. (With CMake you must tell it which libraries must be linked in to your executable --it is not automatic.)

== Using a Specific Version of Boost ==

To use a specific version of Boost, do the following:
* Unload any loaded OpenMPI modules that will conflict.
* Unload any loaded C++ compiler modules that will conflict.
* Load any required C++ and OpenMPI modules.
* Load the required version of Boost.
e.g.,
<pre>
$ module list # View which modules are currently loaded
$ module unload openmpi/intel/1.6.2 # Unload the OpenMPI (for Intel)
$ module unload intel/12.1.3 # Unload the Intel C++ compiler
$ module load gcc/4.8.2 # Load GCC v4.8.2
$ module load openmpi/gcc/1.8.3 # Load OpenMPI (for GCC)
$ module load boost/gcc482-openmpi183/1.57.0 # Load Boost v1.57 for GCC 4.8.2 and OpenMPI v1.8.3
</pre>

Once this is done, you may use Boost (e.g., write #include <boost/filesystem.hpp> in your code, etc.). No special compiler options will be required.

If you want to start with NO modules loaded, then you can do the same by purging first, loading ldwrapper, followed by what you need, e.g.,
<pre>
$ module purge
$ module load ldwrapper
$ module load gcc/4.8.2 # Load GCC v4.8.2
$ module load openmpi/gcc/1.8.3 # Load OpenMPI (for GCC)
$ module load boost/gcc482-openmpi183/1.57.0 # Load Boost v1.57 for GCC 4.8.2 and OpenMPI v1.8.3
</pre>

== If Special Compiler Options are Required ==

If you are not having success building your code using Boost (e.g., in a Makefile), you might need to manually specify the INCLUDE and LIB directories. You can get these paths by running the following command (replacing the full Boost module name with the one you've loaded), e.g.,
<pre>
$ module show boost/gcc482-openmpi183/1.57.0
-------------------------------------------------------------------
/opt/sharcnet/modules/boost/gcc482-openmpi183/1.57.0:

module-whatis Provides boost 1.57.0 (flavor gcc482-openmpi183) built using gcc/4.8.2, openmpi/gcc/1.8.3 on centos64.
conflict intel
conflict pgi
conflict python
prereq gcc/4.8.2
prereq openmpi/gcc/1.8.3
prepend-path --delim CPPFLAGS -I/opt/sharcnet/boost/1.57.0/gcc482-openmpi183/include
prepend-path --delim LDFLAGS -L/opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib
prepend-path LD_RUN_PATH /opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib
-------------------------------------------------------------------
$
</pre>
i.e., for Boost 1.57.0 (flavour gcc482-openmpi183) you could explicitly invoke the compiler with:
<pre>
g++ $CPPFLAGS $CXXFLAGS $LDFLAGS yoursourcecode.cxx
</pre>

Also be aware that you must specify any Boost-required libraries for linking purposes using the -l option. You can see the actual available library names for any given Boost installation by running:

<pre>
$ for a in `ls $BLIBS` ; do basename $a ; done
</pre>

where $BLIBS is the directory you see with LDFLAGS in the module show output, thus, to see all libraries available with the gcc482-openmpi183/lib module, you would write:

<pre>
$ for a in `ls /opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib/libboost_*` ; do basename $a ; done
</pre>

'''NOTE:''' Using the -l option is important when using any non-header-only Boost library, e.g., MPI, serialization, program_options, etc.

== Building an Example Boost Program ==

First create/write/copy your program somewhere suitable (this example is from the Boost.MPI documentation):
<pre>
$ cd
$ mkdir boost-test
$ cat >boost-mpi-eg.cxx
#include <iostream>
#include <string>
#include <boost/mpi.hpp>
#include <boost/serialization/string.hpp>

namespace mpi = boost::mpi;

int main(int argc, char *argv[])
{
mpi::environment env(argc, argv);
mpi::communicator world;

if (world.rank() == 0) {
world.send(1, 0, std::string("Hello"));
std::string msg;
world.recv(1, 1, msg);
std::cout << msg << "!" << std::endl;
} else {
std::string msg;
world.recv(0, 0, msg);
std::cout << msg << ", ";
std::cout.flush();
world.send(0, 1, std::string("world"));
}

return 0;
}
$
</pre>
compile it:
<pre>
$ mpic++ $CPPFLAGS $CXXFLAGS $LDFLAGS -lboost_mpi -lboost_serialization boost-mpi-eg.cxx
</pre>
and run it (as it is very fast and short, sqsub is not used here):
<pre>
$ mpirun -np 2 ./a.out
</pre>

== Operating System Installed Boost ==

If you don't load a SHARCNET boost module, your program will most likely link to the operating system's installed version of Boost. To determine which version(s) of boost and boost-devel are installed run the following commands:
<pre>
rpm -qi boost
rpm -qi boost-devel
</pre>

'''NOTE:''' System versions are rather old and won't be upgraded or maintained by SHARCNET staff unless something in the operating system requires it to be updated. Therefore we '''strongly encourag''' using the SHARCNET provided Boost modules discussed above on this page.

==References==

o Boost Homepage 
http://www.boost.org/

MPFUN90

2015-09-28T19:25:13Z

Preney:

{{Software
|package_name=MPFUN90
|package_description=A Fortran-90 arbitrary precision package
|package_idnumber=16
}}
===Introduction===

'''NOTE:''' This page is currently in the process of being edited.

MPFUN90 is a Fortran-90 arbitrary precision package (i.e. user specifies the desired precision). The library is written by David H. Bailey et. al from the Lawrence Berkeley National Laboratory. If 64 digits of precision are sufficient for an application then users should use QD instead of MPFUN which would run much faster.

=== Version Selection ===
* This page details how to use MPFUN90 (version 20100825) that is available as a SHARCNET module.
** '''NOTE:''' The only SHARCNET module currently available supports the Intel v15.0.3 Fortran compiler.
* There is an older MPFUN library version 6.1.23 for the intel compiler available on SHARCNET. See the [[MPFUN]] page for those details.

===Job Submission===
To compile an MPFUN90 job you need to have the intel/15.0.3 module loaded. After loading it, use the following
command to compile an MPFUN90 source file, my_mpfun.f90:

ifort my_mpfun.f90

To submit the job to the serial queue use:
sqsub -r 10m --mpp=2G -n 1 -o OUTPUT_MY_MPFUN ./a.out

===Testing the MPFUN90 functions===
This example shows how to compile the test program testmp90.f90 using the SHARCNET mpfun build. This program is used to verify DHB's multiprecision computation package MPFUN. It exercises most routines and verifies that they are working properly. Note that MPFUN was compiled with the intel compiler on each cluster shown in the availability table therefore its necessary to also compile the below example with the appropriate compiler. The environment variable $FC handles this automatically as follows:

Following commands copy the testmp90.f90 file into a user subdirectory and run the test.

[roberpj@hnd50:~/samples/mpfun] cp /opt/sharcnet/mpfun/6.1.23/f90/src/testmp90.f90 .

[roberpj@hnd50:~/samples/mpfun] $FC testmp90.f90 -I/opt/sharcnet/mpfun/6.1.23/f90/include \
-L/opt/sharcnet/mpfun/6.1.23/f90/lib -lmp

[roberpj@hnd50:~/samples/mpfun] ./a.out
Completed Test 1
Completed Test 2
etc
Completed Test 60
Completed Test 62

===Simple MPFUN example===

Here is a simple MPFUN90 example and the commands required to compile and execute it:

! file = factorial_100.f90

program factorial_100_pgm

use mpmodule
implicit none
integer, parameter :: Nmx = 100
integer :: AllocateStatus
integer :: J
type(mp_real) zero, one

type(mp_real), dimension (:), allocatable :: fac

call mpinit(800)
call mpsetprec(800)
call mpsetoutputprec(700)

zero='0.'
one ='1.'

allocate(fac(0:Nmx),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for fac "

fac(0)=one

do J=1,Nmx
fac(J)=fac(J-1)*J
end do

J=4
write(6,1001) J
1001 format(/"fac(",i3.3,") =",$)
call mpwrite(6,fac(J))

J=100
write(6,1001) J
call mpwrite(6,fac(J))

write(6,1005)
1005 format(/"DONE"//)

end

Compile (copy/paste the three lines)

$FC factorial_100.f90 \
-I/opt/sharcnet/mpfun/6.1.23/f90/include \
-L/opt/sharcnet/mpfun/6.1.23/f90/lib -lmp >& AOUT1

Execute code

./a.out

fac(004) =10 ^ 1 x 2.4,

fac(100) =10 ^ 157 x 9.3326215443944152681699238856266700490715968264381621468592
963895217599993229915608941463976156518286253697920827223758251185210916864,

DONE

===OpenMP with MPFUN and QD===

The Multi Precision packages MPFUN90 and QD use "user defined data type" for their variables.
Since the OpenMP reduction clause cannot be used for "user defined data types" to run MPFUN90 or QD
with OpenMP the reduction must be done manually in a PARALLEL OpenMP region.

Detailed documentation on how to use OpenMP with MPFUN90 and QD are presented in the following
document:

https://www.sharcnet.ca/help/index.php/OpenMP_Reduction_for_User_Defined_Data_Types

===Handling large arrays in an MPFUN program ===

Declaring large arrays in an MPFUN program often leads to compile
errors like:

"relocation truncated to fit r_x86_64_pc32 against .bss"

Even with the flag '-mcmodel large' in the compile command the error
will persist, because there is a limit to the amount of data you can
have allocated in static arrays for x86_64 architecture. This data
segment is limited to 2GB. The data in COMMON plus any other
statically declared arrays PLUS your code must fit in 2GB.

In order to overcome this problem use allocatable arrays declared in
a module together with a short subroutine which allocates the arrays.

We illustrate these concepts by starting with a program 'betax.f90'
which work fine for values of parameter 'Nsz' less than 37. Thus, if
you compile it with

integer, parameter :: Nsz=36

it works, but for any higher values it fails with error message:

"relocation truncated to fit: R_X86_64_PC32 against symbol '...'"

To overcome this problem, we first copy program betax.f90 into a new file,
say, betay.f90, and write a module called 'mp_data' and a subroutine called
'allocate_arrays' at the top of the new file. We move all the declarations
of large arrays into the module, and declare them as 'allocatable'.

In the subroutine 'allocate_arrays' we do the allocations and in the main
program we add the statements:

USE mp_data
...
call allocate_arrays
...

Below you will find the listings for the files 'betax.f90', 'betay.f90' and
the 'HIST' file containing the commands to compile these files and submit
jobs:

! file betax.f90

program BETAX

use mpmodule
implicit none
! integer, parameter :: Nsz=12 ! compilation fails for 37
integer, parameter :: Nsz=37

INTEGER :: I,J,K,L

type(mp_real) zero, one

type(mp_real) fac(0:Nsz),fci(0:Nsz)
type(mp_real) BETA2(Nsz,Nsz)
type(mp_real) BETA3(Nsz,Nsz,Nsz)
type(mp_real) BETA4(Nsz,Nsz,Nsz,Nsz)

call mpinit(800)
call mpsetprec(800)
call mpsetoutputprec(700)

zero='0.'
one ='1.'

fac(0)=one
fci(0)=one

do j=1,Nsz
fac(j)=fac(j-1)*j
fci(j)=one/fac(j)
end do

I=Nsz/2
J=I-1
K=J-1
L=K-1

write(6,1000) I,J,K,L
1000 format(/"I,J,K,L = ",4i3)

write(6,1001) I
1001 format(/"fac(",i3.3,") =",$)
call mpwrite(6,fac(I))

BETA2(I,J) =fac(I)*fac(J)*fci(I+J)
BETA3(I,J,K) =fac(I)*fac(J)*fac(K)*fci(I+J)*fci(J+K)
BETA4(I,J,K,L) =fac(I)*fac(J)*fac(K)*fac(L)* &
& fci(I+J)*fci(J+K)*fci(K+L)

write(6,1002) I,J
1002 format(/"BETA2(",i3.3,",",i3.3,") =")
call mpwrite(6,BETA2(I,J))

write(6,1003) I,J,K
1003 format(/"BETA3(",i3.3,",",i3.3,",",i3.3,") =")
call mpwrite(6,BETA3(I,J,K))

write(6,1004) I,J,K,L
1004 format(/"BETA4(",i3.3,",",i3.3,",",i3.3,",",i3.3,") =")
call mpwrite(6,BETA4(I,J,K,L))

write(6,1005)
1005 format(/"DONE"//)

stop
end

! file betay.f90

module mp_data

use mpmodule
use mpfunmod

implicit none

integer, parameter :: Nsz =48

integer :: AllocateStatus

! type(mp_real) zero, one
!
! type(mp_real) fac(0:Nsz),fci(0:Nsz)
! type(mp_real) BETA2(Nsz,Nsz)
! type(mp_real) BETA3(Nsz,Nsz,Nsz)
! type(mp_real) BETA4(Nsz,Nsz,Nsz,Nsz)

type(mp_real) zero, one

type(mp_real), dimension (:), allocatable :: fac,fci
type(mp_real), dimension (:,:), allocatable :: BETA2
type(mp_real), dimension (:,:,:), allocatable :: BETA3
type(mp_real), dimension (:,:,:,:), allocatable :: BETA4

end module mp_data

subroutine allocate_arrays

USE mp_data
implicit none

allocate(fac(0:Nsz),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for fac "

allocate(fci(0:Nsz),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for fci "

allocate(BETA2(Nsz,Nsz),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for BETA2"

allocate(BETA3(Nsz,Nsz,Nsz),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for BETA3"

allocate(BETA4(Nsz,Nsz,Nsz,Nsz),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for BETA4"

print *,"Done with allocations"

return
END

! ----------------------------------------------------------------------

program BETAY
USE mp_data

implicit none

INTEGER :: I,J,K,L

call mpinit(800)
call mpsetprec(800)
call mpsetoutputprec(700)

zero='0.'
one ='1.'

call allocate_arrays

fac(0)=one
fci(0)=one

do j=1,Nsz
fac(j)=fac(j-1)*j
fci(j)=one/fac(j)
end do

I=Nsz/2
J=I-1
K=J-1
L=K-1

write(6,1000) I,J,K,L
1000 format(/"I,J,K,L = ",4i3)

write(6,1001) I
1001 format(/"fac(",i3.3,") =",$)
call mpwrite(6,fac(I))

BETA2(I,J) =fac(I)*fac(J)*fci(I+J)
BETA3(I,J,K) =fac(I)*fac(J)*fac(K)*fci(I+J)*fci(J+K)
BETA4(I,J,K,L) =fac(I)*fac(J)*fac(K)*fac(L)* &
& fci(I+J)*fci(J+K)*fci(K+L)

write(6,1002) I,J
1002 format(/"BETA2(",i3.3,",",i3.3,") =")
call mpwrite(6,BETA2(I,J))

write(6,1003) I,J,K
1003 format(/"BETA3(",i3.3,",",i3.3,",",i3.3,") =")
call mpwrite(6,BETA3(I,J,K))

write(6,1004) I,J,K,L
1004 format(/"BETA4(",i3.3,",",i3.3,",",i3.3,",",i3.3,") =")
call mpwrite(6,BETA4(I,J,K,L))

write(6,1005)
1005 format(/"DONE"//)

stop
end

# file HIST
#
# Set Nsz=12

vi betax.f90

and set Nsz=12 in file betax.f90

# Compile (copy/paste the three lines)

ifort betax.f90 \
-I/opt/sharcnet/mpfun/6.1.23/f90/include \
-L/opt/sharcnet/mpfun/6.1.23/f90/lib -lmp >& AOUT1

# Execute code (it should work)

./a.out

# Set Nsz=40

vi betax.f90

and set Nsz=40 in file betax.f90

# Re-compile and look at file AOUT1

ifort betax.f90 \
-I/opt/sharcnet/mpfun/6.1.23/f90/include \
-L/opt/sharcnet/mpfun/6.1.23/f90/lib -lmp >& AOUT1

============================================================================

# File betay.f90 was copied from betax.f90 and modified as described earlier.

# Compile betay.f90

ifort betay.f90 -mcmodel medium -shared-intel \
-I/opt/sharcnet/mpfun/6.1.23/f90/include \
-L/opt/sharcnet/mpfun/6.1.23/f90/lib -lmp >& AOUT2

============================================================================

# The executable might require more than 2.0G of memory:

# This will pruduce an error:

sqsub -r 5m --mpp=4.0G -o OUTPUTFILE4 ./a.out

# This should work:

sqsub -r 5m --mpp=8.0G -o OUTPUTFILE8 ./a.out

============================================================================

 

===MPFUN's TOOLKIT===

This toolkit provides and extensive example of how the mpfun package can be used. Read the header of files
mathinit.f90
and
mathtool.f90
found under
/opt/sharcnet/mpfun/current/toolkit
for an explanation what the package does. The Makefile in this directory shows how the mpfun libraries were linked to compile this sample program pair. The following steps shows the first initialization step followed by actually running the mathtool program to perform some examples such as performing an integration and displaying the value of pie. Note that the displayed zero cputimes are due to a bug in the mpfun current build which will be fixed in future updates on the clusters.

====Initializing Mathtool====
To run Mathtool you must first generate following two input files
const.dat
and
quadts.dat

which can be accomplished by running following command:

<pre>
[roberpj@bal34:~/samples/mpfun] /opt/sharcnet/mpfun/current/toolkit/mathinit
mathinit: start
const complete
file const.dat written
cpu time = 0.E+0
initqts: Tanh-sinh quadrature initialization
0 18632
1000 18632
2000 18632
3000 18632
4000 18632
5000 18632
6000 18632
7000 18632
8000 18632
initqts: Table spaced used = 8177
initqts complete
file quadts.dat written
cpu time = 0.E+0
total cpu time = 0.E+0

[roberpj@bal34:~/samples/mpfun] ls
const.dat quadts.dat
</pre>

====Running Mathtool====
Use the files created in the previous section to run mathtool as follows:

<pre>
[roberpj@bal34:~/samples/mpfun] /opt/sharcnet/mpfun/current/toolkit/mathtool
Welcome to the Experimental Mathematician's Toolkit
Initializing...

Current settings:
Debug level = 2
Primary precision level = 100 digits
Secondary precision level = 200 digits
Primary epsilon = 10^ -100
Secondary epsilon = 10^ -200
PSLQ bound = 100
PSLQ level = 1
Quadrature level = 6
Quadrature type = 3 (Tanh-Sinh)
-- snip --

TYPE: integrate[1/(1+x^2), {x, 0, 1}] (hit enter)
quadts: Iteration 1 of 6; est error = 10^ 0; approx value =
7.853157298876894309110693190063938396203990510665917998384243e-1
quadts: Iteration 2 of 6; est error = 10^ 0; approx value =
7.853981605125528448099840689980111720633592558858121242731082e-1
quadts: Iteration 3 of 6; est error = 10^ -17; approx value =
7.853981633974483082028533923930157568609007576776270726821597e-1
quadts: Iteration 4 of 6; est error = 10^ -36; approx value =
7.853981633974483096156608458198757190586422063114153956005278e-1
quadts: Iteration 5 of 6; est error = 10^ -71; approx value =
7.853981633974483096156608458198757210492923498437764552437361e-1
quadts: Iteration 6 of 6; est error = 10^ -101; approx value =
7.853981633974483096156608458198757210492923498437764552437361e-1
Result[ 1] =
7.85398163397448309615660845819875721049292349843776455243736148076954e-1
CPU time = 0.0000

TYPE: functions (hit enter)
Abs Arccos Arcsin Arctan
Arctan2 Bessel Besselexp Binomial
Cos Erf Exp Factorial
Gamma Integrate Log Max
Min Polyroot Pslq Result
Sin Sqrt Sum Table
Tan Zeta Zetap Zetaz

TYPE: variables (hit enter)
E Log2 Log10 Pi
Catalan Eulergamma Infinity Arg1
Arg2 Arg3 Arg4 Arg5
Arg6 Arg7 Arg8 Arg9
Debug Digits Digits2 Epsilon
Epsilon2 Pslqbound Pslqlevel Quadlevel
Quadtype x

TYPE: Pi (hit enter)
Result[ 2] =
3.14159265358979323846264338327950288419716939937510582097494459230781e0
CPU time = 0.0000
</pre>

====More Mathtool commands====
To start mathtool (assuming you have issued the command /opt/sharcnet/mpfun/current/toolkit/mathinit and have these two files: const.dat HIST quadts.dat - you type:

/opt/sharcnet/mpfun/current/toolkit/mathtool

Then try following commands:
integrate[2*x,{x,0,1}]
sqrt[1600]
help Binomial
Binomial[3,2]
hypo[x,y] = sqrt[x^2+y^2]
z=hypo[3,4]
z
exit

This is what you should get from above commands:

integrate[2*x,{x,0,1}]
quadts: Iteration 1 of 6; est error = 10^ 0; approx value =
1.000003359570811224742398159504692881030640064061042259417294e0
quadts: Iteration 2 of 6; est error = 10^ 0; approx value =
1.000000000000036584185557611216071731517571134591404403031033e0
quadts: Iteration 3 of 6; est error = 10^ -27; approx value =
1.000000000000000000000000000001046972220803162709182580101627e0
quadts: Iteration 4 of 6; est error = 10^ -60; approx value =
1.000000000000000000000000000000000000000000000000000000000000e0
quadts: Iteration 5 of 6; est error = 10^ -101; approx value =
9.999999999999999999999999999999999999999999999999999999999999e-1
Result[ 1] =
9.99999999999999999999999999999999999999999999999999999999999999999999e-1
CPU time = 0.0000

sqrt[1600]
Result[ 2] =
4.00000000000000000000000000000000000000000000000000000000000000000000e1
CPU time = 0.0000

help Binomial
Binomial[m,n] computes the binomial coefficient of integers (m,n).

Binomial[3,2]
Result[ 3] =
3.00000000000000000000000000000000000000000000000000000000000000000000e0
CPU time = 0.0000

hypo[x,y] = sqrt[x^2+y^2]
parse: new function name = hypo
CPU time = 0.0000

z=hypo[3,4]
parse: new variable name = z
CPU time = 0.0000

z
Result[ 4] =
5.00000000000000000000000000000000000000000000000000000000000000000000e0
CPU time = 0.0000

exit

==References==

o High-Precision Software Directory 
http://crd.lbl.gov/~dhbailey/mpdist/index.html

MPFUN90

2015-09-28T19:24:41Z

Preney:

{{Software
|package_name=MPFUN90
|package_description=A Fortran-90 arbitrary precision package
|package_idnumber=16
}}
===Introduction===

MPFUN90 is a Fortran-90 arbitrary precision package (i.e. user specifies the desired precision). The library is written by David H. Bailey et. al from the Lawrence Berkeley National Laboratory. If 64 digits of precision are sufficient for an application then users should use QD instead of MPFUN which would run much faster.

=== Version Selection ===
* This page details how to use MPFUN90 (version 20100825) that is available as a SHARCNET module.
** '''NOTE:''' The only SHARCNET module currently available supports the Intel v15.0.3 Fortran compiler.
* There is an older MPFUN library version 6.1.23 for the intel compiler available on SHARCNET. See the [[MPFUN]] page for those details.

===Job Submission===
To compile an MPFUN90 job you need to have the intel/15.0.3 module loaded. After loading it, use the following
command to compile an MPFUN90 source file, my_mpfun.f90:

ifort my_mpfun.f90

To submit the job to the serial queue use:
sqsub -r 10m --mpp=2G -n 1 -o OUTPUT_MY_MPFUN ./a.out

===Testing the MPFUN90 functions===
This example shows how to compile the test program testmp90.f90 using the SHARCNET mpfun build. This program is used to verify DHB's multiprecision computation package MPFUN. It exercises most routines and verifies that they are working properly. Note that MPFUN was compiled with the intel compiler on each cluster shown in the availability table therefore its necessary to also compile the below example with the appropriate compiler. The environment variable $FC handles this automatically as follows:

Following commands copy the testmp90.f90 file into a user subdirectory and run the test.

[roberpj@hnd50:~/samples/mpfun] cp /opt/sharcnet/mpfun/6.1.23/f90/src/testmp90.f90 .

[roberpj@hnd50:~/samples/mpfun] $FC testmp90.f90 -I/opt/sharcnet/mpfun/6.1.23/f90/include \
-L/opt/sharcnet/mpfun/6.1.23/f90/lib -lmp

[roberpj@hnd50:~/samples/mpfun] ./a.out
Completed Test 1
Completed Test 2
etc
Completed Test 60
Completed Test 62

===Simple MPFUN example===

Here is a simple MPFUN90 example and the commands required to compile and execute it:

! file = factorial_100.f90

program factorial_100_pgm

use mpmodule
implicit none
integer, parameter :: Nmx = 100
integer :: AllocateStatus
integer :: J
type(mp_real) zero, one

type(mp_real), dimension (:), allocatable :: fac

call mpinit(800)
call mpsetprec(800)
call mpsetoutputprec(700)

zero='0.'
one ='1.'

allocate(fac(0:Nmx),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for fac "

fac(0)=one

do J=1,Nmx
fac(J)=fac(J-1)*J
end do

J=4
write(6,1001) J
1001 format(/"fac(",i3.3,") =",$)
call mpwrite(6,fac(J))

J=100
write(6,1001) J
call mpwrite(6,fac(J))

write(6,1005)
1005 format(/"DONE"//)

end

Compile (copy/paste the three lines)

$FC factorial_100.f90 \
-I/opt/sharcnet/mpfun/6.1.23/f90/include \
-L/opt/sharcnet/mpfun/6.1.23/f90/lib -lmp >& AOUT1

Execute code

./a.out

fac(004) =10 ^ 1 x 2.4,

fac(100) =10 ^ 157 x 9.3326215443944152681699238856266700490715968264381621468592
963895217599993229915608941463976156518286253697920827223758251185210916864,

DONE

===OpenMP with MPFUN and QD===

The Multi Precision packages MPFUN90 and QD use "user defined data type" for their variables.
Since the OpenMP reduction clause cannot be used for "user defined data types" to run MPFUN90 or QD
with OpenMP the reduction must be done manually in a PARALLEL OpenMP region.

Detailed documentation on how to use OpenMP with MPFUN90 and QD are presented in the following
document:

https://www.sharcnet.ca/help/index.php/OpenMP_Reduction_for_User_Defined_Data_Types

===Handling large arrays in an MPFUN program ===

Declaring large arrays in an MPFUN program often leads to compile
errors like:

"relocation truncated to fit r_x86_64_pc32 against .bss"

Even with the flag '-mcmodel large' in the compile command the error
will persist, because there is a limit to the amount of data you can
have allocated in static arrays for x86_64 architecture. This data
segment is limited to 2GB. The data in COMMON plus any other
statically declared arrays PLUS your code must fit in 2GB.

In order to overcome this problem use allocatable arrays declared in
a module together with a short subroutine which allocates the arrays.

We illustrate these concepts by starting with a program 'betax.f90'
which work fine for values of parameter 'Nsz' less than 37. Thus, if
you compile it with

integer, parameter :: Nsz=36

it works, but for any higher values it fails with error message:

"relocation truncated to fit: R_X86_64_PC32 against symbol '...'"

To overcome this problem, we first copy program betax.f90 into a new file,
say, betay.f90, and write a module called 'mp_data' and a subroutine called
'allocate_arrays' at the top of the new file. We move all the declarations
of large arrays into the module, and declare them as 'allocatable'.

In the subroutine 'allocate_arrays' we do the allocations and in the main
program we add the statements:

USE mp_data
...
call allocate_arrays
...

Below you will find the listings for the files 'betax.f90', 'betay.f90' and
the 'HIST' file containing the commands to compile these files and submit
jobs:

! file betax.f90

program BETAX

use mpmodule
implicit none
! integer, parameter :: Nsz=12 ! compilation fails for 37
integer, parameter :: Nsz=37

INTEGER :: I,J,K,L

type(mp_real) zero, one

type(mp_real) fac(0:Nsz),fci(0:Nsz)
type(mp_real) BETA2(Nsz,Nsz)
type(mp_real) BETA3(Nsz,Nsz,Nsz)
type(mp_real) BETA4(Nsz,Nsz,Nsz,Nsz)

call mpinit(800)
call mpsetprec(800)
call mpsetoutputprec(700)

zero='0.'
one ='1.'

fac(0)=one
fci(0)=one

do j=1,Nsz
fac(j)=fac(j-1)*j
fci(j)=one/fac(j)
end do

I=Nsz/2
J=I-1
K=J-1
L=K-1

write(6,1000) I,J,K,L
1000 format(/"I,J,K,L = ",4i3)

write(6,1001) I
1001 format(/"fac(",i3.3,") =",$)
call mpwrite(6,fac(I))

BETA2(I,J) =fac(I)*fac(J)*fci(I+J)
BETA3(I,J,K) =fac(I)*fac(J)*fac(K)*fci(I+J)*fci(J+K)
BETA4(I,J,K,L) =fac(I)*fac(J)*fac(K)*fac(L)* &
& fci(I+J)*fci(J+K)*fci(K+L)

write(6,1002) I,J
1002 format(/"BETA2(",i3.3,",",i3.3,") =")
call mpwrite(6,BETA2(I,J))

write(6,1003) I,J,K
1003 format(/"BETA3(",i3.3,",",i3.3,",",i3.3,") =")
call mpwrite(6,BETA3(I,J,K))

write(6,1004) I,J,K,L
1004 format(/"BETA4(",i3.3,",",i3.3,",",i3.3,",",i3.3,") =")
call mpwrite(6,BETA4(I,J,K,L))

write(6,1005)
1005 format(/"DONE"//)

stop
end

! file betay.f90

module mp_data

use mpmodule
use mpfunmod

implicit none

integer, parameter :: Nsz =48

integer :: AllocateStatus

! type(mp_real) zero, one
!
! type(mp_real) fac(0:Nsz),fci(0:Nsz)
! type(mp_real) BETA2(Nsz,Nsz)
! type(mp_real) BETA3(Nsz,Nsz,Nsz)
! type(mp_real) BETA4(Nsz,Nsz,Nsz,Nsz)

type(mp_real) zero, one

type(mp_real), dimension (:), allocatable :: fac,fci
type(mp_real), dimension (:,:), allocatable :: BETA2
type(mp_real), dimension (:,:,:), allocatable :: BETA3
type(mp_real), dimension (:,:,:,:), allocatable :: BETA4

end module mp_data

subroutine allocate_arrays

USE mp_data
implicit none

allocate(fac(0:Nsz),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for fac "

allocate(fci(0:Nsz),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for fci "

allocate(BETA2(Nsz,Nsz),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for BETA2"

allocate(BETA3(Nsz,Nsz,Nsz),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for BETA3"

allocate(BETA4(Nsz,Nsz,Nsz,Nsz),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for BETA4"

print *,"Done with allocations"

return
END

! ----------------------------------------------------------------------

program BETAY
USE mp_data

implicit none

INTEGER :: I,J,K,L

call mpinit(800)
call mpsetprec(800)
call mpsetoutputprec(700)

zero='0.'
one ='1.'

call allocate_arrays

fac(0)=one
fci(0)=one

do j=1,Nsz
fac(j)=fac(j-1)*j
fci(j)=one/fac(j)
end do

I=Nsz/2
J=I-1
K=J-1
L=K-1

write(6,1000) I,J,K,L
1000 format(/"I,J,K,L = ",4i3)

write(6,1001) I
1001 format(/"fac(",i3.3,") =",$)
call mpwrite(6,fac(I))

BETA2(I,J) =fac(I)*fac(J)*fci(I+J)
BETA3(I,J,K) =fac(I)*fac(J)*fac(K)*fci(I+J)*fci(J+K)
BETA4(I,J,K,L) =fac(I)*fac(J)*fac(K)*fac(L)* &
& fci(I+J)*fci(J+K)*fci(K+L)

write(6,1002) I,J
1002 format(/"BETA2(",i3.3,",",i3.3,") =")
call mpwrite(6,BETA2(I,J))

write(6,1003) I,J,K
1003 format(/"BETA3(",i3.3,",",i3.3,",",i3.3,") =")
call mpwrite(6,BETA3(I,J,K))

write(6,1004) I,J,K,L
1004 format(/"BETA4(",i3.3,",",i3.3,",",i3.3,",",i3.3,") =")
call mpwrite(6,BETA4(I,J,K,L))

write(6,1005)
1005 format(/"DONE"//)

stop
end

# file HIST
#
# Set Nsz=12

vi betax.f90

and set Nsz=12 in file betax.f90

# Compile (copy/paste the three lines)

ifort betax.f90 \
-I/opt/sharcnet/mpfun/6.1.23/f90/include \
-L/opt/sharcnet/mpfun/6.1.23/f90/lib -lmp >& AOUT1

# Execute code (it should work)

./a.out

# Set Nsz=40

vi betax.f90

and set Nsz=40 in file betax.f90

# Re-compile and look at file AOUT1

ifort betax.f90 \
-I/opt/sharcnet/mpfun/6.1.23/f90/include \
-L/opt/sharcnet/mpfun/6.1.23/f90/lib -lmp >& AOUT1

============================================================================

# File betay.f90 was copied from betax.f90 and modified as described earlier.

# Compile betay.f90

ifort betay.f90 -mcmodel medium -shared-intel \
-I/opt/sharcnet/mpfun/6.1.23/f90/include \
-L/opt/sharcnet/mpfun/6.1.23/f90/lib -lmp >& AOUT2

============================================================================

# The executable might require more than 2.0G of memory:

# This will pruduce an error:

sqsub -r 5m --mpp=4.0G -o OUTPUTFILE4 ./a.out

# This should work:

sqsub -r 5m --mpp=8.0G -o OUTPUTFILE8 ./a.out

============================================================================

 

===MPFUN's TOOLKIT===

This toolkit provides and extensive example of how the mpfun package can be used. Read the header of files
mathinit.f90
and
mathtool.f90
found under
/opt/sharcnet/mpfun/current/toolkit
for an explanation what the package does. The Makefile in this directory shows how the mpfun libraries were linked to compile this sample program pair. The following steps shows the first initialization step followed by actually running the mathtool program to perform some examples such as performing an integration and displaying the value of pie. Note that the displayed zero cputimes are due to a bug in the mpfun current build which will be fixed in future updates on the clusters.

====Initializing Mathtool====
To run Mathtool you must first generate following two input files
const.dat
and
quadts.dat

which can be accomplished by running following command:

<pre>
[roberpj@bal34:~/samples/mpfun] /opt/sharcnet/mpfun/current/toolkit/mathinit
mathinit: start
const complete
file const.dat written
cpu time = 0.E+0
initqts: Tanh-sinh quadrature initialization
0 18632
1000 18632
2000 18632
3000 18632
4000 18632
5000 18632
6000 18632
7000 18632
8000 18632
initqts: Table spaced used = 8177
initqts complete
file quadts.dat written
cpu time = 0.E+0
total cpu time = 0.E+0

[roberpj@bal34:~/samples/mpfun] ls
const.dat quadts.dat
</pre>

====Running Mathtool====
Use the files created in the previous section to run mathtool as follows:

<pre>
[roberpj@bal34:~/samples/mpfun] /opt/sharcnet/mpfun/current/toolkit/mathtool
Welcome to the Experimental Mathematician's Toolkit
Initializing...

Current settings:
Debug level = 2
Primary precision level = 100 digits
Secondary precision level = 200 digits
Primary epsilon = 10^ -100
Secondary epsilon = 10^ -200
PSLQ bound = 100
PSLQ level = 1
Quadrature level = 6
Quadrature type = 3 (Tanh-Sinh)
-- snip --

TYPE: integrate[1/(1+x^2), {x, 0, 1}] (hit enter)
quadts: Iteration 1 of 6; est error = 10^ 0; approx value =
7.853157298876894309110693190063938396203990510665917998384243e-1
quadts: Iteration 2 of 6; est error = 10^ 0; approx value =
7.853981605125528448099840689980111720633592558858121242731082e-1
quadts: Iteration 3 of 6; est error = 10^ -17; approx value =
7.853981633974483082028533923930157568609007576776270726821597e-1
quadts: Iteration 4 of 6; est error = 10^ -36; approx value =
7.853981633974483096156608458198757190586422063114153956005278e-1
quadts: Iteration 5 of 6; est error = 10^ -71; approx value =
7.853981633974483096156608458198757210492923498437764552437361e-1
quadts: Iteration 6 of 6; est error = 10^ -101; approx value =
7.853981633974483096156608458198757210492923498437764552437361e-1
Result[ 1] =
7.85398163397448309615660845819875721049292349843776455243736148076954e-1
CPU time = 0.0000

TYPE: functions (hit enter)
Abs Arccos Arcsin Arctan
Arctan2 Bessel Besselexp Binomial
Cos Erf Exp Factorial
Gamma Integrate Log Max
Min Polyroot Pslq Result
Sin Sqrt Sum Table
Tan Zeta Zetap Zetaz

TYPE: variables (hit enter)
E Log2 Log10 Pi
Catalan Eulergamma Infinity Arg1
Arg2 Arg3 Arg4 Arg5
Arg6 Arg7 Arg8 Arg9
Debug Digits Digits2 Epsilon
Epsilon2 Pslqbound Pslqlevel Quadlevel
Quadtype x

TYPE: Pi (hit enter)
Result[ 2] =
3.14159265358979323846264338327950288419716939937510582097494459230781e0
CPU time = 0.0000
</pre>

====More Mathtool commands====
To start mathtool (assuming you have issued the command /opt/sharcnet/mpfun/current/toolkit/mathinit and have these two files: const.dat HIST quadts.dat - you type:

/opt/sharcnet/mpfun/current/toolkit/mathtool

Then try following commands:
integrate[2*x,{x,0,1}]
sqrt[1600]
help Binomial
Binomial[3,2]
hypo[x,y] = sqrt[x^2+y^2]
z=hypo[3,4]
z
exit

This is what you should get from above commands:

integrate[2*x,{x,0,1}]
quadts: Iteration 1 of 6; est error = 10^ 0; approx value =
1.000003359570811224742398159504692881030640064061042259417294e0
quadts: Iteration 2 of 6; est error = 10^ 0; approx value =
1.000000000000036584185557611216071731517571134591404403031033e0
quadts: Iteration 3 of 6; est error = 10^ -27; approx value =
1.000000000000000000000000000001046972220803162709182580101627e0
quadts: Iteration 4 of 6; est error = 10^ -60; approx value =
1.000000000000000000000000000000000000000000000000000000000000e0
quadts: Iteration 5 of 6; est error = 10^ -101; approx value =
9.999999999999999999999999999999999999999999999999999999999999e-1
Result[ 1] =
9.99999999999999999999999999999999999999999999999999999999999999999999e-1
CPU time = 0.0000

sqrt[1600]
Result[ 2] =
4.00000000000000000000000000000000000000000000000000000000000000000000e1
CPU time = 0.0000

help Binomial
Binomial[m,n] computes the binomial coefficient of integers (m,n).

Binomial[3,2]
Result[ 3] =
3.00000000000000000000000000000000000000000000000000000000000000000000e0
CPU time = 0.0000

hypo[x,y] = sqrt[x^2+y^2]
parse: new function name = hypo
CPU time = 0.0000

z=hypo[3,4]
parse: new variable name = z
CPU time = 0.0000

z
Result[ 4] =
5.00000000000000000000000000000000000000000000000000000000000000000000e0
CPU time = 0.0000

exit

==References==

o High-Precision Software Directory 
http://crd.lbl.gov/~dhbailey/mpdist/index.html

MPFUN90

2015-09-28T19:16:45Z

Preney: Copy of MPFUN page before significant editing.

{{Software
|package_name=MPFUN90
|package_description=A Fortran-90 arbitrary precision package
|package_idnumber=16
}}
===Introduction===
MPFUN90 is a Fortran-90 arbitrary precision package (i.e. user specifies the desired precision). The library is written by David H. Bailey et. al from the Lawrence Berkeley National Laboratory. If 64 digits of precision are sufficient for an application then users should use QD instead of MPFUN which would run much faster.

=== Version Selection ===
Only version 6.1.23 of MPFUN for the intel compiler is available.

===Job Submission===
To compile an MPFUN job you need to have the intel module loaded. Then you use the following
command to compile an MPFUN source file, my_mpfun.f90:

$FC my_mpfun.f90 -I/opt/sharcnet/mpfun/6.1.23/f90/include \
-L/opt/sharcnet/mpfun/6.1.23/f90/lib -lmp
To submit the job to the serial queue use:
sqsub -r 10m --mpp=2G -n 1 -o OUTPUT_MY_MPFUN ./a.out

===Testing the MPFUN90 functions===
This example shows how to compile the test program testmp90.f90 using the SHARCNET mpfun build. This program is used to verify DHB's multiprecision computation package MPFUN. It exercises most routines and verifies that they are working properly. Note that MPFUN was compiled with the intel compiler on each cluster shown in the availability table therefore its necessary to also compile the below example with the appropriate compiler. The environment variable $FC handles this automatically as follows:

Following commands copy the testmp90.f90 file into a user subdirectory and run the test.

[roberpj@hnd50:~/samples/mpfun] cp /opt/sharcnet/mpfun/6.1.23/f90/src/testmp90.f90 .

[roberpj@hnd50:~/samples/mpfun] $FC testmp90.f90 -I/opt/sharcnet/mpfun/6.1.23/f90/include \
-L/opt/sharcnet/mpfun/6.1.23/f90/lib -lmp

[roberpj@hnd50:~/samples/mpfun] ./a.out
Completed Test 1
Completed Test 2
etc
Completed Test 60
Completed Test 62

===Simple MPFUN example===

Here is a simple MPFUN90 example and the commands required to compile and execute it:

! file = factorial_100.f90

program factorial_100_pgm

use mpmodule
implicit none
integer, parameter :: Nmx = 100
integer :: AllocateStatus
integer :: J
type(mp_real) zero, one

type(mp_real), dimension (:), allocatable :: fac

call mpinit(800)
call mpsetprec(800)
call mpsetoutputprec(700)

zero='0.'
one ='1.'

allocate(fac(0:Nmx),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for fac "

fac(0)=one

do J=1,Nmx
fac(J)=fac(J-1)*J
end do

J=4
write(6,1001) J
1001 format(/"fac(",i3.3,") =",$)
call mpwrite(6,fac(J))

J=100
write(6,1001) J
call mpwrite(6,fac(J))

write(6,1005)
1005 format(/"DONE"//)

end

Compile (copy/paste the three lines)

$FC factorial_100.f90 \
-I/opt/sharcnet/mpfun/6.1.23/f90/include \
-L/opt/sharcnet/mpfun/6.1.23/f90/lib -lmp >& AOUT1

Execute code

./a.out

fac(004) =10 ^ 1 x 2.4,

fac(100) =10 ^ 157 x 9.3326215443944152681699238856266700490715968264381621468592
963895217599993229915608941463976156518286253697920827223758251185210916864,

DONE

===OpenMP with MPFUN and QD===

The Multi Precision packages MPFUN90 and QD use "user defined data type" for their variables.
Since the OpenMP reduction clause cannot be used for "user defined data types" to run MPFUN90 or QD
with OpenMP the reduction must be done manually in a PARALLEL OpenMP region.

Detailed documentation on how to use OpenMP with MPFUN90 and QD are presented in the following
document:

https://www.sharcnet.ca/help/index.php/OpenMP_Reduction_for_User_Defined_Data_Types

===Handling large arrays in an MPFUN program ===

Declaring large arrays in an MPFUN program often leads to compile
errors like:

"relocation truncated to fit r_x86_64_pc32 against .bss"

Even with the flag '-mcmodel large' in the compile command the error
will persist, because there is a limit to the amount of data you can
have allocated in static arrays for x86_64 architecture. This data
segment is limited to 2GB. The data in COMMON plus any other
statically declared arrays PLUS your code must fit in 2GB.

In order to overcome this problem use allocatable arrays declared in
a module together with a short subroutine which allocates the arrays.

We illustrate these concepts by starting with a program 'betax.f90'
which work fine for values of parameter 'Nsz' less than 37. Thus, if
you compile it with

integer, parameter :: Nsz=36

it works, but for any higher values it fails with error message:

"relocation truncated to fit: R_X86_64_PC32 against symbol '...'"

To overcome this problem, we first copy program betax.f90 into a new file,
say, betay.f90, and write a module called 'mp_data' and a subroutine called
'allocate_arrays' at the top of the new file. We move all the declarations
of large arrays into the module, and declare them as 'allocatable'.

In the subroutine 'allocate_arrays' we do the allocations and in the main
program we add the statements:

USE mp_data
...
call allocate_arrays
...

Below you will find the listings for the files 'betax.f90', 'betay.f90' and
the 'HIST' file containing the commands to compile these files and submit
jobs:

! file betax.f90

program BETAX

use mpmodule
implicit none
! integer, parameter :: Nsz=12 ! compilation fails for 37
integer, parameter :: Nsz=37

INTEGER :: I,J,K,L

type(mp_real) zero, one

type(mp_real) fac(0:Nsz),fci(0:Nsz)
type(mp_real) BETA2(Nsz,Nsz)
type(mp_real) BETA3(Nsz,Nsz,Nsz)
type(mp_real) BETA4(Nsz,Nsz,Nsz,Nsz)

call mpinit(800)
call mpsetprec(800)
call mpsetoutputprec(700)

zero='0.'
one ='1.'

fac(0)=one
fci(0)=one

do j=1,Nsz
fac(j)=fac(j-1)*j
fci(j)=one/fac(j)
end do

I=Nsz/2
J=I-1
K=J-1
L=K-1

write(6,1000) I,J,K,L
1000 format(/"I,J,K,L = ",4i3)

write(6,1001) I
1001 format(/"fac(",i3.3,") =",$)
call mpwrite(6,fac(I))

BETA2(I,J) =fac(I)*fac(J)*fci(I+J)
BETA3(I,J,K) =fac(I)*fac(J)*fac(K)*fci(I+J)*fci(J+K)
BETA4(I,J,K,L) =fac(I)*fac(J)*fac(K)*fac(L)* &
& fci(I+J)*fci(J+K)*fci(K+L)

write(6,1002) I,J
1002 format(/"BETA2(",i3.3,",",i3.3,") =")
call mpwrite(6,BETA2(I,J))

write(6,1003) I,J,K
1003 format(/"BETA3(",i3.3,",",i3.3,",",i3.3,") =")
call mpwrite(6,BETA3(I,J,K))

write(6,1004) I,J,K,L
1004 format(/"BETA4(",i3.3,",",i3.3,",",i3.3,",",i3.3,") =")
call mpwrite(6,BETA4(I,J,K,L))

write(6,1005)
1005 format(/"DONE"//)

stop
end

! file betay.f90

module mp_data

use mpmodule
use mpfunmod

implicit none

integer, parameter :: Nsz =48

integer :: AllocateStatus

! type(mp_real) zero, one
!
! type(mp_real) fac(0:Nsz),fci(0:Nsz)
! type(mp_real) BETA2(Nsz,Nsz)
! type(mp_real) BETA3(Nsz,Nsz,Nsz)
! type(mp_real) BETA4(Nsz,Nsz,Nsz,Nsz)

type(mp_real) zero, one

type(mp_real), dimension (:), allocatable :: fac,fci
type(mp_real), dimension (:,:), allocatable :: BETA2
type(mp_real), dimension (:,:,:), allocatable :: BETA3
type(mp_real), dimension (:,:,:,:), allocatable :: BETA4

end module mp_data

subroutine allocate_arrays

USE mp_data
implicit none

allocate(fac(0:Nsz),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for fac "

allocate(fci(0:Nsz),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for fci "

allocate(BETA2(Nsz,Nsz),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for BETA2"

allocate(BETA3(Nsz,Nsz,Nsz),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for BETA3"

allocate(BETA4(Nsz,Nsz,Nsz,Nsz),STAT=AllocateStatus)
IF (AllocateStatus /= 0) STOP "Not enough memory for BETA4"

print *,"Done with allocations"

return
END

! ----------------------------------------------------------------------

program BETAY
USE mp_data

implicit none

INTEGER :: I,J,K,L

call mpinit(800)
call mpsetprec(800)
call mpsetoutputprec(700)

zero='0.'
one ='1.'

call allocate_arrays

fac(0)=one
fci(0)=one

do j=1,Nsz
fac(j)=fac(j-1)*j
fci(j)=one/fac(j)
end do

I=Nsz/2
J=I-1
K=J-1
L=K-1

write(6,1000) I,J,K,L
1000 format(/"I,J,K,L = ",4i3)

write(6,1001) I
1001 format(/"fac(",i3.3,") =",$)
call mpwrite(6,fac(I))

BETA2(I,J) =fac(I)*fac(J)*fci(I+J)
BETA3(I,J,K) =fac(I)*fac(J)*fac(K)*fci(I+J)*fci(J+K)
BETA4(I,J,K,L) =fac(I)*fac(J)*fac(K)*fac(L)* &
& fci(I+J)*fci(J+K)*fci(K+L)

write(6,1002) I,J
1002 format(/"BETA2(",i3.3,",",i3.3,") =")
call mpwrite(6,BETA2(I,J))

write(6,1003) I,J,K
1003 format(/"BETA3(",i3.3,",",i3.3,",",i3.3,") =")
call mpwrite(6,BETA3(I,J,K))

write(6,1004) I,J,K,L
1004 format(/"BETA4(",i3.3,",",i3.3,",",i3.3,",",i3.3,") =")
call mpwrite(6,BETA4(I,J,K,L))

write(6,1005)
1005 format(/"DONE"//)

stop
end

# file HIST
#
# Set Nsz=12

vi betax.f90

and set Nsz=12 in file betax.f90

# Compile (copy/paste the three lines)

ifort betax.f90 \
-I/opt/sharcnet/mpfun/6.1.23/f90/include \
-L/opt/sharcnet/mpfun/6.1.23/f90/lib -lmp >& AOUT1

# Execute code (it should work)

./a.out

# Set Nsz=40

vi betax.f90

and set Nsz=40 in file betax.f90

# Re-compile and look at file AOUT1

ifort betax.f90 \
-I/opt/sharcnet/mpfun/6.1.23/f90/include \
-L/opt/sharcnet/mpfun/6.1.23/f90/lib -lmp >& AOUT1

============================================================================

# File betay.f90 was copied from betax.f90 and modified as described earlier.

# Compile betay.f90

ifort betay.f90 -mcmodel medium -shared-intel \
-I/opt/sharcnet/mpfun/6.1.23/f90/include \
-L/opt/sharcnet/mpfun/6.1.23/f90/lib -lmp >& AOUT2

============================================================================

# The executable might require more than 2.0G of memory:

# This will pruduce an error:

sqsub -r 5m --mpp=4.0G -o OUTPUTFILE4 ./a.out

# This should work:

sqsub -r 5m --mpp=8.0G -o OUTPUTFILE8 ./a.out

============================================================================

 

===MPFUN's TOOLKIT===

This toolkit provides and extensive example of how the mpfun package can be used. Read the header of files
mathinit.f90
and
mathtool.f90
found under
/opt/sharcnet/mpfun/current/toolkit
for an explanation what the package does. The Makefile in this directory shows how the mpfun libraries were linked to compile this sample program pair. The following steps shows the first initialization step followed by actually running the mathtool program to perform some examples such as performing an integration and displaying the value of pie. Note that the displayed zero cputimes are due to a bug in the mpfun current build which will be fixed in future updates on the clusters.

====Initializing Mathtool====
To run Mathtool you must first generate following two input files
const.dat
and
quadts.dat

which can be accomplished by running following command:

<pre>
[roberpj@bal34:~/samples/mpfun] /opt/sharcnet/mpfun/current/toolkit/mathinit
mathinit: start
const complete
file const.dat written
cpu time = 0.E+0
initqts: Tanh-sinh quadrature initialization
0 18632
1000 18632
2000 18632
3000 18632
4000 18632
5000 18632
6000 18632
7000 18632
8000 18632
initqts: Table spaced used = 8177
initqts complete
file quadts.dat written
cpu time = 0.E+0
total cpu time = 0.E+0

[roberpj@bal34:~/samples/mpfun] ls
const.dat quadts.dat
</pre>

====Running Mathtool====
Use the files created in the previous section to run mathtool as follows:

<pre>
[roberpj@bal34:~/samples/mpfun] /opt/sharcnet/mpfun/current/toolkit/mathtool
Welcome to the Experimental Mathematician's Toolkit
Initializing...

Current settings:
Debug level = 2
Primary precision level = 100 digits
Secondary precision level = 200 digits
Primary epsilon = 10^ -100
Secondary epsilon = 10^ -200
PSLQ bound = 100
PSLQ level = 1
Quadrature level = 6
Quadrature type = 3 (Tanh-Sinh)
-- snip --

TYPE: integrate[1/(1+x^2), {x, 0, 1}] (hit enter)
quadts: Iteration 1 of 6; est error = 10^ 0; approx value =
7.853157298876894309110693190063938396203990510665917998384243e-1
quadts: Iteration 2 of 6; est error = 10^ 0; approx value =
7.853981605125528448099840689980111720633592558858121242731082e-1
quadts: Iteration 3 of 6; est error = 10^ -17; approx value =
7.853981633974483082028533923930157568609007576776270726821597e-1
quadts: Iteration 4 of 6; est error = 10^ -36; approx value =
7.853981633974483096156608458198757190586422063114153956005278e-1
quadts: Iteration 5 of 6; est error = 10^ -71; approx value =
7.853981633974483096156608458198757210492923498437764552437361e-1
quadts: Iteration 6 of 6; est error = 10^ -101; approx value =
7.853981633974483096156608458198757210492923498437764552437361e-1
Result[ 1] =
7.85398163397448309615660845819875721049292349843776455243736148076954e-1
CPU time = 0.0000

TYPE: functions (hit enter)
Abs Arccos Arcsin Arctan
Arctan2 Bessel Besselexp Binomial
Cos Erf Exp Factorial
Gamma Integrate Log Max
Min Polyroot Pslq Result
Sin Sqrt Sum Table
Tan Zeta Zetap Zetaz

TYPE: variables (hit enter)
E Log2 Log10 Pi
Catalan Eulergamma Infinity Arg1
Arg2 Arg3 Arg4 Arg5
Arg6 Arg7 Arg8 Arg9
Debug Digits Digits2 Epsilon
Epsilon2 Pslqbound Pslqlevel Quadlevel
Quadtype x

TYPE: Pi (hit enter)
Result[ 2] =
3.14159265358979323846264338327950288419716939937510582097494459230781e0
CPU time = 0.0000
</pre>

====More Mathtool commands====
To start mathtool (assuming you have issued the command /opt/sharcnet/mpfun/current/toolkit/mathinit and have these two files: const.dat HIST quadts.dat - you type:

/opt/sharcnet/mpfun/current/toolkit/mathtool

Then try following commands:
integrate[2*x,{x,0,1}]
sqrt[1600]
help Binomial
Binomial[3,2]
hypo[x,y] = sqrt[x^2+y^2]
z=hypo[3,4]
z
exit

This is what you should get from above commands:

integrate[2*x,{x,0,1}]
quadts: Iteration 1 of 6; est error = 10^ 0; approx value =
1.000003359570811224742398159504692881030640064061042259417294e0
quadts: Iteration 2 of 6; est error = 10^ 0; approx value =
1.000000000000036584185557611216071731517571134591404403031033e0
quadts: Iteration 3 of 6; est error = 10^ -27; approx value =
1.000000000000000000000000000001046972220803162709182580101627e0
quadts: Iteration 4 of 6; est error = 10^ -60; approx value =
1.000000000000000000000000000000000000000000000000000000000000e0
quadts: Iteration 5 of 6; est error = 10^ -101; approx value =
9.999999999999999999999999999999999999999999999999999999999999e-1
Result[ 1] =
9.99999999999999999999999999999999999999999999999999999999999999999999e-1
CPU time = 0.0000

sqrt[1600]
Result[ 2] =
4.00000000000000000000000000000000000000000000000000000000000000000000e1
CPU time = 0.0000

help Binomial
Binomial[m,n] computes the binomial coefficient of integers (m,n).

Binomial[3,2]
Result[ 3] =
3.00000000000000000000000000000000000000000000000000000000000000000000e0
CPU time = 0.0000

hypo[x,y] = sqrt[x^2+y^2]
parse: new function name = hypo
CPU time = 0.0000

z=hypo[3,4]
parse: new variable name = z
CPU time = 0.0000

z
Result[ 4] =
5.00000000000000000000000000000000000000000000000000000000000000000000e0
CPU time = 0.0000

exit

==References==

o High-Precision Software Directory 
http://crd.lbl.gov/~dhbailey/mpdist/index.html

BOOST

2015-04-07T21:28:07Z

Preney: /* Using a Specific Version of Boost */

BOOST

2015-03-26T19:15:57Z

Preney:

BOOST

2015-01-24T22:32:27Z

Preney:

BOOST

2015-01-24T21:18:57Z

Preney:

BOOST

2015-01-24T20:22:40Z

Preney:

{{Software
|package_name=BOOST
|package_description=free peer-reviewed portable C++ source libraries
|package_idnumber=137
}}

== SHARCNET-Provided Boost Modules ==

=== Which Versions of Boost are Available? ===

SHARCNET has a number of Boost versions available as special modules. The available versions can be viewed by running:
<pre>
module avail boost
</pre>
and/or by viewing the [https://www.sharcnet.ca/my/software/show/137 BOOST software page in the web portal].

At the present time, when you look up the available boost modules you will see output such as:
<pre>
$ module avail boost

------------------------------------ /opt/sharcnet/modules -------------------------------------
boost/gcc482-openmpi183/1.50.0 boost/intel12-openmpi162/1.50.0
boost/gcc482-openmpi183/1.53.0 boost/intel12-openmpi162/1.53.0
boost/gcc482-openmpi183/1.55.0 boost/intel12-openmpi162/1.55.0
boost/gcc482-openmpi183/1.57.0 boost/intel12-openmpi162/1.57.0
boost/intel/1.55.0 boost/intel15-noopenmpi/1.57.0

------------------------------------ /opt/sharcnet/modules -------------------------------------
boost/gcc482-openmpi183/1.50.0 boost/intel12-openmpi162/1.50.0
boost/gcc482-openmpi183/1.53.0 boost/intel12-openmpi162/1.53.0
boost/gcc482-openmpi183/1.55.0 boost/intel12-openmpi162/1.55.0
boost/gcc482-openmpi183/1.57.0 boost/intel12-openmpi162/1.57.0
boost/intel/1.55.0 boost/intel15-noopenmpi/1.57.0
$
</pre>

i.e., the following versions of Boost are available:
# Boost versions 1.50, 1.53, 1.55, and 1.57 for GCC v4.8.2 and OpenMPI v1.8.3
# Boost versions 1.50, 1.53, 1.55, and 1.57 for Intel v12 and OpenMPI v1.6.2
# Boost version 1.57 for Intel v15 without OpenMPI features (i.e., the "noopenmpi" item).

'''NOTE:''' The boost/intel/1.55.0 module should not be used --it is older and will be removed in the near future. Use one of the other Boost modules instead.

All of the aforementioned versions of Boost have been built with the operating system's installed Python. You can see which version of Python it will use by running:
<pre>
rpm -qi python
</pre>

'''NOTE:''' If you need a specific version of Boost compiled for a specific C++ compiler, version of OpenMPI, and/or a specific version of Python, then submit a ticket requesting such. Be sure to mention all required software packages and which versions are needed.

=== Using a Specific Version of Boost ===

To use a specific version of Boost, do the following:
* Unload any loaded OpenMPI modules that will conflict.
* Unload any loaded C++ compiler modules that will conflict.
* Load any required C++ and OpenMPI modules.
* Load the required version of Boost.
e.g.,
<pre>
$ module list # View which modules are currently loaded
$ module unload openmpi/intel/1.6.2 # Unload the OpenMPI (for Intel)
$ module unload intel/12.1.3 # Unload the Intel C++ compiler
$ module load gcc/4.8.2 # Load GCC v4.8.2
$ module load openmpi/gcc/1.8.3 # Load OpenMPI (for GCC)
$ module load boost/gcc482-openmpi183/1.57.0 # Load Boost v1.57 for GCC 4.8.2 and OpenMPI v1.8.3
</pre>

Once this is done, you may use Boost (e.g., write #include <boost/filesystem.hpp> in your code, etc.). No special compiler options will be required.

=== If Special Compiler Options are Required ===

If you are not having success building your code using Boost (e.g., in a Makefile), you might need to manually specify the INCLUDE and LIB directories. You can get these paths by running the following command (replacing the full Boost module name with the one you've loaded), e.g.,
<pre>
$ module show boost/gcc482-openmpi183/1.57.0
-------------------------------------------------------------------
/opt/sharcnet/modules/boost/gcc482-openmpi183/1.57.0:

module-whatis Provides boost 1.57.0 (flavor gcc482-openmpi183) built using gcc/4.8.2, openmpi/gcc/1.8.3 on centos64.
conflict intel
conflict pgi
conflict python
prereq gcc/4.8.2
prereq openmpi/gcc/1.8.3
prepend-path --delim CPPFLAGS -I/opt/sharcnet/boost/1.57.0/gcc482-openmpi183/include
prepend-path --delim LDFLAGS -L/opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib
prepend-path LD_RUN_PATH /opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib
-------------------------------------------------------------------

$
</pre>
The options you need to pass to the C++ compiler / linker follow CPPFLAGS and LDFLAGS in the above output, i.e., you will need to add these two options to your C++ compiler's command line:
* -I/opt/sharcnet/boost/1.57.0/gcc482-openmpi183/include
* -L/opt/sharcnet/boost/1.57.0/gcc482-openmpi183/lib

== Operating System Installed Boost ==
If you don't load any SHARCNET-provided Boost module, you will be using the operating system's installed version of Boost. To determine which version(s) of boost and boost-devel are installed run the following commands:
<pre>
rpm -qi boost
rpm -qi boost-devel
</pre>

'''NOTE:''' These versions may be very old, they won't be upgraded or maintained by SHARCNET staff unless something in the operating system requires it to be upgraded. You are therefore '''strongly encouraged''' to use the SHARCNET-provided Boost modules discussed earlier on this page.

==References==

o Boost Homepage 
http://www.boost.org/

BOOST

2014-07-08T19:11:31Z

Preney: /* Compiling Your Own Version Of Boost */

{{Software
|package_name=BOOST
|package_description=free peer-reviewed portable C++ source libraries
|package_idnumber=137
}}

== Operating System Installed Boost ==
The version of boost and boost-devel packages installed are provided with the native operating system and not provided by a SHARCNET module hence they are available by default.

To get the latest version information about the packages do:

<pre>
rpm -qi boost
rpm -qi boost-devel
</pre>

To get a listing of files for each package do:

<pre>
rpm -ql boost
rpm -ql boost-devel
</pre>

== Compiling Your Own Version Of Boost ==

Unfortunately, the operating system-installed version of the Boost libraries are usually out of date and programs relying on boost libraries may require a later version. Please check the documentation of the package you are trying to link to boost libraries to see which version is the minimum required. If this minimum is later than the native system libraries, you will have to install the newer boost libraries on your own.

=== Manually Building Boost ===

The following are the steps to manually build Boost from the command-line.

# Download Boost from http://www.boost.org
# Extract the file downloaded into an empty directory using one of these commands:
#* <code>unzip boost_VERSION.tar.gz</code>
#* <code>tar xvzf boost_VERSION.tar.gz</code>
#* <code>tar xvjf boost_VERSION.tar.bz2</code>
#* '''NOTE:''' This top directory holding the uncompressed Boost files will be called <code>$BOOST_SRC</code> below.
# Decide on which C++ compiler you are going to use (e.g., GCC, Intel, PGI). Once that is done, use SHARCNET's module system to unload any previous compiler and load the one you need:
#* Unload C++ compiler modules: <code>module unload gcc intel pgi</code>
#* Load the GCC v4.8.2 module example: <code>module load gcc/4.8.2</code>
# Decide on whether or not you want MPI support (and load the one suitable for the compiler you've chosen):
#* Unload the module: <code>module unload openmpi</code>
#* Load MPI for GCC example: <code>module load openmpi/gcc</code> '''(Omit this line if you don't need MPI.)'''
# Decide whether or not you need Python support (and load the one suitable for the compiler you've chosen).
#* Unload the module: <code>module unload python</code>
#* Load Python for GCC module: <code>module load python/gcc</code> '''(Omit this line if you don't need Python.)'''
#* '''NOTE:''' Boost will use the system's Python if you don't load the module which is okay if you don't need Python.
# Change the directory to <code>$BOOST_SRC</code>:
#* <code>cd $BOOST_SRC</code>
# '''NOTE:''' Because SHARCNET has many compilers and tools available, avoid using the shortcut method to building Boost --build Boost's <code>b2</code> program instead.
# Change the directory to build bjam:
#* <code>cd tools/build/v2</code>
# For the aforementioned selected C++ compiler, determine the correct <code>--with-toolset</code> option for <code>bootstrap.sh</code>:
#* <code>./bootstrap.sh --with-toolset=help</code> '''(This command is designed to fail.)'''
#* <code>less booststrap.log</code>
# Replace TOOLSET_NAME_FROM_FILE with the appropriate toolset mentioned in the <code>bootstrap.log</code> file and the run:
#* <code>./bootstrap.sh --with-toolset=TOOLSET_NAME_FROM_LOG_FILE</code>
#* e.g., <code>./bootstrap.sh --with-toolset=gcc</code>
#* e.g., <code>./bootstrap.sh --with-toolset=intel-linux</code>
#* e.g., <code>./bootstrap.sh --with-toolset=pgi</code>
# Decide on a directory you want to install Boost build into.
#* This directory will be referred to as <code>$BUILD_DIR</code> below.
# Run:
#* <code>./b2 install --prefix=$BUILD_DIR</code>
# Add <code>$BUILD_DIR/bin</code> to your PATH (in your shell):
#* PATH=$BUILD_DIR/bin:$PATH
#* export PATH
# If you need Boost MPI, then add the following text to a line of its own in <code>user-config.jam</code>:
#* <code>using mpi ;</code>
# Go back up to the <code>$BOOST_SRC</code> directory:
#* <code>cd ../../..</code>
# Decide on an empty directory where you want to install the Boost libraries.
#* This directory will be referred to as <code>$INSTALL_DIR</code> below.
# If you would like Boost to build its libraries in parallel, decide on the number of parallel processes.
#* This number will be referred to as <code>$NUM_PROCS</code> below.
# Although it is usually the same as the above, determine the toolset (referred to as $TOOLSET below) you need from the Boost documentation:
#* Version 1.55.0: http://www.boost.org/doc/libs/1_55_0/more/getting_started/unix-variants.html#toolset
#* Version 1.54.0: http://www.boost.org/doc/libs/1_54_0/more/getting_started/unix-variants.html#toolset
#* Version 1.53.0: http://www.boost.org/doc/libs/1_53_0/more/getting_started/unix-variants.html#toolset
#* Version 1.52.0: http://www.boost.org/doc/libs/1_52_0/more/getting_started/unix-variants.html#toolset
#* etc.
# Build the Boost libraries by running:
#* Normal sequential build: <code>b2 --prefix=$INSTALL_DIR --build-dir=$BUILD_DIR toolset=$TOOLSET install</code>
#* Parallel build: <code>b2 -j$NUM_PROCS --prefix=$INSTALL_DIR --build-dir=$BUILD_DIR toolset=$TOOLSET install</code>
# If all of the above went well, you're done building Boost!

'''NOTE:''' <code>b2</code> and the code in <code>$BUILD_DIR</code> is only needed to build Boost. You can delete <code>$BUILD_DIR</code> after Boost has been built by running <code>rm -rf $BOOST_DIR</code>.

=== Compiling and Linking to the Boost Libraries + Running Executables ===

Please note the following:
* <code>BOOST_HOME=$INSTALL_DIR</code>
* The INCLUDE directory for Boost is <code>$BOOST_HOME/include</code>.
* The LIBRARY directory for Boost is <code>$BOOST_HOME/lib</code>.

To build programs use the -I, -L, and -l options to specify the top include file directory, the top library directory and any specific libraries that must be linked in to your program, e.g.,
* A program that uses header-only libraries: <code>$CXX -I $BOOST_HOME/include program1.cxx</code>
* A program that uses the Boost regex library: <code>$CXX -I $BOOST_HOME/include -L $BOOST_HOME/lib -lboost_regex program2.cxx</code>
* etc.

If your <code>$BOOST_HOME</code> is not in a system-wide library directory, your compile program won't run. You can ensure it does run by adding <code>$BOOST_HOME/lib</code> to your <code>LD_LIBRARY_PATH</code> (once per shell) as follows:
* <code>LD_LIBRARY_PATH=$BOOST_HOME/lib:$LD_LIBRARY_PATH</code>
* <code>export LD_LIBRARY_PATH</code>
and now you will be able to sucessfully run your programs.

Finally remember to BEFORE running your programs you will ALWAYS need to "module unload" and "module load" the settings for any new shells you create. This can be a nuisance --you might prefer to place those unload and load commands at the bottom of your ~/.bashrc file.

==References==

o Boost Homepage 
http://www.boost.org/

BOOST

2014-07-08T19:11:04Z

Preney:

BOOST

2014-07-08T19:10:20Z

Preney: Mention about removing $BOOST_DIR when done building Boost.

BOOST

2014-07-08T19:07:50Z

Preney: Added information about LD_LIBRARY_PATH

{{Software
|package_name=BOOST
|package_description=free peer-reviewed portable C++ source libraries
|package_idnumber=137
}}

== Operating System Installed Boost ==
The version of boost and boost-devel packages installed are provided with the native operating system and not provided by a SHARCNET module hence they are available by default.

To get the latest version information about the packages do:

<pre>
rpm -qi boost
rpm -qi boost-devel
</pre>

To get a listing of files for each package do:

<pre>
rpm -ql boost
rpm -ql boost-devel
</pre>

== Compiling Your Own Version Of Boost ==

Unfortunately, the operating system-installed version of the Boost libraries are usually out of date and programs relying on boost libraries may require a later version. Please check the documentation of the package you are trying to link to boost libraries to see which version is the minimum required. If this minimum is later than the native system libraries, you will have to install the newer boost libraries on your own.

=== Manually Building Boost ===

The following are the steps to manually build Boost from the command-line.

# Download Boost from http://www.boost.org
# Extract the file downloaded into an empty directory using one of these commands:
#* <code>unzip boost_VERSION.tar.gz</code>
#* <code>tar xvzf boost_VERSION.tar.gz</code>
#* <code>tar xvjf boost_VERSION.tar.bz2</code>
#* '''NOTE:''' This top directory holding the uncompressed Boost files will be called <code>$BOOST_SRC</code> below.
# Decide on which C++ compiler you are going to use (e.g., GCC, Intel, PGI). Once that is done, use SHARCNET's module system to unload any previous compiler and load the one you need:
#* Unload C++ compiler modules: <code>module unload gcc intel pgi</code>
#* Load the GCC v4.8.2 module example: <code>module load gcc/4.8.2</code>
# Decide on whether or not you want MPI support (and load the one suitable for the compiler you've chosen):
#* Unload the module: <code>module unload openmpi</code>
#* Load MPI for GCC example: <code>module load openmpi/gcc</code> '''(Omit this line if you don't need MPI.)'''
# Decide whether or not you need Python support (and load the one suitable for the compiler you've chosen).
#* Unload the module: <code>module unload python</code>
#* Load Python for GCC module: <code>module load python/gcc</code> '''(Omit this line if you don't need Python.)'''
#* '''NOTE:''' Boost will use the system's Python if you don't load the module which is okay if you don't need Python.
# Change the directory to <code>$BOOST_SRC</code>:
#* <code>cd $BOOST_SRC</code>
# '''NOTE:''' Because SHARCNET has many compilers and tools available, avoid using the shortcut method to building Boost --build Boost's <code>b2</code> program instead.
# Change the directory to build bjam:
#* <code>cd tools/build/v2</code>
# For the aforementioned selected C++ compiler, determine the correct <code>--with-toolset</code> option for <code>bootstrap.sh</code>:
#* <code>./bootstrap.sh --with-toolset=help</code> '''(This command is designed to fail.)'''
#* <code>less booststrap.log</code>
# Replace TOOLSET_NAME_FROM_FILE with the appropriate toolset mentioned in the <code>bootstrap.log</code> file and the run:
#* <code>./bootstrap.sh --with-toolset=TOOLSET_NAME_FROM_LOG_FILE</code>
#* e.g., <code>./bootstrap.sh --with-toolset=gcc</code>
#* e.g., <code>./bootstrap.sh --with-toolset=intel-linux</code>
#* e.g., <code>./bootstrap.sh --with-toolset=pgi</code>
# Decide on a directory you want to install Boost build into.
#* This directory will be referred to as <code>$BUILD_DIR</code> below.
# Run:
#* <code>./b2 install --prefix=$BUILD_DIR</code>
# Add <code>$BUILD_DIR/bin</code> to your PATH (in your shell):
#* PATH=$BUILD_DIR/bin:$PATH
#* export PATH
# If you need Boost MPI, then add the following text to a line of its own in <code>user-config.jam</code>:
#* <code>using mpi ;</code>
# Go back up to the <code>$BOOST_SRC</code> directory:
#* <code>cd ../../..</code>
# Decide on an empty directory where you want to install the Boost libraries.
#* This directory will be referred to as <code>$INSTALL_DIR</code> below.
# If you would like Boost to build its libraries in parallel, decide on the number of parallel processes.
#* This number will be referred to as <code>$NUM_PROCS</code> below.
# Although it is usually the same as the above, determine the toolset (referred to as $TOOLSET below) you need from the Boost documentation:
#* Version 1.55.0: http://www.boost.org/doc/libs/1_55_0/more/getting_started/unix-variants.html#toolset
#* Version 1.54.0: http://www.boost.org/doc/libs/1_54_0/more/getting_started/unix-variants.html#toolset
#* Version 1.53.0: http://www.boost.org/doc/libs/1_53_0/more/getting_started/unix-variants.html#toolset
#* Version 1.52.0: http://www.boost.org/doc/libs/1_52_0/more/getting_started/unix-variants.html#toolset
#* etc.
# Build the Boost libraries by running:
#* Normal sequential build: <code>b2 --prefix=$INSTALL_DIR --build-dir=$BUILD_DIR toolset=$TOOLSET install</code>
#* Parallel build: <code>b2 -j$NUM_PROCS --prefix=$INSTALL_DIR --build-dir=$BUILD_DIR toolset=$TOOLSET install</code>
# If all of the above went well, you're done building Boost!

=== Compiling and Linking to the Boost Libraries + Running Executables ===

Please note the following:
* <code>BOOST_HOME=$INSTALL_DIR</code>
* The INCLUDE directory for Boost is <code>$BOOST_HOME/include</code>.
* The LIBRARY directory for Boost is <code>$BOOST_HOME/lib</code>.

To build programs use the -I, -L, and -l options to specify the top include file directory, the top library directory and any specific libraries that must be linked in to your program, e.g.,
* A program that uses header-only libraries: <code>$CXX -I $BOOST_HOME/include program1.cxx</code>
* A program that uses the Boost regex library: <code>$CXX -I $BOOST_HOME/include -L $BOOST_HOME/lib -lboost_regex program2.cxx</code>
* etc.

If your <code>$BOOST_HOME</code> is not in a system-wide library directory, your compile program won't run. You can ensure it does run by adding <code>$BOOST_HOME/lib</code> to your <code>LD_LIBRARY_PATH</code> (once per shell) as follows:
* <code>LD_LIBRARY_PATH=$BOOST_HOME/lib:$LD_LIBRARY_PATH</code>
* <code>export LD_LIBRARY_PATH</code>
and now you will be able to sucessfully run your programs.

Finally remember to BEFORE running your programs you will ALWAYS need to "module unload" and "module load" the settings for any new shells you create. This can be a nuisance --you might prefer to place those unload and load commands at the bottom of your ~/.bashrc file.

==References==

o Boost Homepage 
http://www.boost.org/

BOOST

2014-07-08T18:53:04Z

Preney: Updated page to detail how to install Boost.

{{Software
|package_name=BOOST
|package_description=free peer-reviewed portable C++ source libraries
|package_idnumber=137
}}

== Operating System Installed Boost ==
The version of boost and boost-devel packages installed are provided with the native operating system and not provided by a SHARCNET module hence they are available by default.

To get the latest version information about the packages do:

<pre>
rpm -qi boost
rpm -qi boost-devel
</pre>

To get a listing of files for each package do:

<pre>
rpm -ql boost
rpm -ql boost-devel
</pre>

== Compiling Your Own Version Of Boost ==

Unfortunately, the operating system-installed version of the Boost libraries are usually out of date and programs relying on boost libraries may require a later version. Please check the documentation of the package you are trying to link to boost libraries to see which version is the minimum required. If this minimum is later than the native system libraries, you will have to install the newer boost libraries on your own.

=== Manually Building Boost ===

The following are the steps to manually build Boost from the command-line.

# Download Boost from http://www.boost.org
# Extract the file downloaded into an empty directory using one of these commands:
#* <code>unzip boost_VERSION.tar.gz</code>
#* <code>tar xvzf boost_VERSION.tar.gz</code>
#* <code>tar xvjf boost_VERSION.tar.bz2</code>
#* '''NOTE:''' This top directory holding the uncompressed Boost files will be called <code>$BOOST_SRC</code> below.
# Decide on which C++ compiler you are going to use (e.g., GCC, Intel, PGI). Once that is done, use SHARCNET's module system to unload any previous compiler and load the one you need:
#* Unload C++ compiler modules: <code>module unload gcc intel pgi</code>
#* Load the GCC v4.8.2 module example: <code>module load gcc/4.8.2</code>
# Decide on whether or not you want MPI support (and load the one suitable for the compiler you've chosen):
#* Unload the module: <code>module unload openmpi</code>
#* Load MPI for GCC example: <code>module load openmpi/gcc</code> '''(Omit this line if you don't need MPI.)'''
# Decide whether or not you need Python support (and load the one suitable for the compiler you've chosen).
#* Unload the module: <code>module unload python</code>
#* Load Python for GCC module: <code>module load python/gcc</code> '''(Omit this line if you don't need Python.)'''
#* '''NOTE:''' Boost will use the system's Python if you don't load the module which is okay if you don't need Python.
# Change the directory to <code>$BOOST_SRC</code>:
#* <code>cd $BOOST_SRC</code>
# '''NOTE:''' Because SHARCNET has many compilers and tools available, avoid using the shortcut method to building Boost --build Boost's <code>b2</code> program instead.
# Change the directory to build bjam:
#* <code>cd tools/build/v2</code>
# For the aforementioned selected C++ compiler, determine the correct <code>--with-toolset</code> option for <code>bootstrap.sh</code>:
#* <code>./bootstrap.sh --with-toolset=help</code> '''(This command is designed to fail.)'''
#* <code>less booststrap.log</code>
# Replace TOOLSET_NAME_FROM_FILE with the appropriate toolset mentioned in the <code>bootstrap.log</code> file and the run:
#* <code>./bootstrap.sh --with-toolset=TOOLSET_NAME_FROM_LOG_FILE</code>
#* e.g., <code>./bootstrap.sh --with-toolset=gcc</code>
#* e.g., <code>./bootstrap.sh --with-toolset=intel-linux</code>
#* e.g., <code>./bootstrap.sh --with-toolset=pgi</code>
# Decide on a directory you want to install Boost build into.
#* This directory will be referred to as <code>$BUILD_DIR</code> below.
# Run:
#* <code>./b2 install --prefix=$BUILD_DIR</code>
# Add <code>$BUILD_DIR/bin</code> to your PATH (in your shell):
#* PATH=$BUILD_DIR/bin:$PATH
#* export PATH
# If you need Boost MPI, then add the following text to a line of its own in <code>user-config.jam</code>:
#* <code>using mpi ;</code>
# Go back up to the <code>$BOOST_SRC</code> directory:
#* <code>cd ../../..</code>
# Decide on an empty directory where you want to install the Boost libraries.
#* This directory will be referred to as <code>$INSTALL_DIR</code> below.
# If you would like Boost to build its libraries in parallel, decide on the number of parallel processes.
#* This number will be referred to as <code>$NUM_PROCS</code> below.
# Although it is usually the same as the above, determine the toolset (referred to as $TOOLSET below) you need from the Boost documentation:
#* Version 1.55.0: http://www.boost.org/doc/libs/1_55_0/more/getting_started/unix-variants.html#toolset
#* Version 1.54.0: http://www.boost.org/doc/libs/1_54_0/more/getting_started/unix-variants.html#toolset
#* Version 1.53.0: http://www.boost.org/doc/libs/1_53_0/more/getting_started/unix-variants.html#toolset
#* Version 1.52.0: http://www.boost.org/doc/libs/1_52_0/more/getting_started/unix-variants.html#toolset
#* etc.
# Build the Boost libraries by running:
#* Normal sequential build: <code>b2 --prefix=$INSTALL_DIR --build-dir=$BUILD_DIR toolset=$TOOLSET install</code>
#* Parallel build: <code>b2 -j$NUM_PROCS --prefix=$INSTALL_DIR --build-dir=$BUILD_DIR toolset=$TOOLSET install</code>
# If all of the above went well, you're done building Boost!

Please note the following:
* <code>BOOST_HOME=$INSTALL_DIR</code>
* The INCLUDE directory for Boost is <code>$BOOST_HOME/include</code>.
* The LIBRARY directory for Boost is <code>$BOOST_HOME/lib</code>.

To build programs use the -I, -L, and -l options to specify the top include file directory, the top library directory and any specific libraries that must be linked in to your program, e.g.,
* A program that uses header-only libraries: <code>$CXX -I $BOOST_HOME/include program1.cxx</code>
* A program that uses the Boost regex library: <code>$CXX -I $BOOST_HOME/include -L $BOOST_HOME/lib -lboost_regex program2.cxx</code>
* etc.

Finally remember to BEFORE running your programs you will ALWAYS need to "module unload" and "module load" the settings for any new shells you create. This can be a nuisance --you might prefer to place those unload and load commands at the bottom of your ~/.bashrc file.

==References==

o Boost Homepage 
http://www.boost.org/