#
# Makefile (Make.MPICH2141p1_GCC412) used to compile HPCC 
# on HPC clusters running NPACI Rocks (5.4.2) with CentOS (5.5)
# at Michigan Technological University.
# 
# Disclaimer:
# Please note that you are using these instructions 
# at your very own risk and that Michigan Technological
# University is not responsible for any/all damage caused to 
# your property, intellectual or otherwise.
# 
# For additional help and/or comments, questions, suggestions,
# please contact 
#
# Gowtham
# Information Technology Services & Security
# Michigan Technological University
# g@mtu.edu
#
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
#
#
#  -- High Performance Computing Linpack Benchmark (HPL)                
#     HPL - 2.0 - September 10, 2008                          
#     Antoine P. Petitet                                                
#     University of Tennessee, Knoxville                                
#     Innovative Computing Laboratory                                 
#     (C) Copyright 2000-2008 All Rights Reserved                       
#                                                                       
#  -- Copyright notice and Licensing terms:                             
#                                                                       
#  Redistribution and use in source and binary forms, with or without
#  modification, are permitted provided that the following conditions
#  are met:                                                             
#                                                                       
#  1. Redistributions of source code must retain the above copyright
#  notice, this list of conditions and the following disclaimer.        
#                                                                       
#  2. Redistributions in binary form must reproduce the above copyright
#  notice, this list of conditions, and the following disclaimer in the
#  documentation and/or other materials provided with the distribution. 
#                                                                       
#  3. All advertising materials mentioning features or use of this
#  software must display the following acknowledgement:                 
#  This product includes software developed at the University of
#  Tennessee, Knoxville, Innovative Computing Laboratory.             
#                                                                       
#  4. The name of the University, the name of the Laboratory, or the
#  names of its contributors may not be used to endorse or promote
#  products derived from this software without specific written
#  permission.
#
#  -- Disclaimer:
#                                                                       
#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
#  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
#  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
#  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY
#  OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
#  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
#  DATA OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
#  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
#  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
#  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#  
 
#
# Shell Details
SHELL        = /bin/sh
CD           = cd
CP           = cp
LN_S         = ln -s
MKDIR        = mkdir
RM           = /bin/rm -f
TOUCH        = touch
 
#
# Platform Identifier
ARCH         = MPICH2141p1_GCC412
 
#
# HPL Directory Structure / HPL library
TOPdir       = ../../..
INCdir       = $(TOPdir)/include
BINdir       = $(TOPdir)/bin/$(ARCH)
LIBdir       = $(TOPdir)/lib/$(ARCH)
HPLlib       = $(LIBdir)/libhpl.a 
 
#
# Message Passing library (MPI)
MPdir        = /share/apps/mpich2/1.4.1p1/gcc/4.1.2
MPinc        = -I$(MPdir)/include
MPlib        = $(MPdir)/lib/libmpich.a
 
#
# Linear Algebra library (BLAS)
LAlib        = /share/apps/gotoblas2/1.13/gcc/4.1.2/libgoto2.a
 
#
# F77 / C Interface
# You can skip this section if and only if you are not planning to use
# a BLAS library featuring a Fortran 77 interface. Otherwise, it is
# necessary to fill out the F2CDEFS variable with the appropriate
# options. **One and only one** option should be chosen in **each** of
# the 3 following categories:
#
# 1) name space (How C calls a Fortran 77 routine)
#
# -DAdd_              : all lower case and a suffixed underscore (Suns,
#                       Intel, ...) [default]
# -DNoChange          : all lower case (IBM RS6000)
# -DUpCase            : all upper case (Cray)
# -DAdd__             : the FORTRAN compiler in use is f2c
#
# 2) C and Fortran 77 integer mapping
#
# -DF77_INTEGER=int   : Fortran 77 INTEGER is a C int [default]
# -DF77_INTEGER=long  : Fortran 77 INTEGER is a C long
# -DF77_INTEGER=short : Fortran 77 INTEGER is a C short
#
# 3) Fortran 77 string handling
#
# -DStringSunStyle    : The string address is passed at the string location
#                       on the stack, and the string length is then
#                       passed as an F77_INTEGER after all explicit
#                       stack arguments [default]
# -DStringStructPtr   : The address of a structure is passed by a
#                       Fortran 77 string, and the structure is of the
#                       form: struct {char *cp; F77_INTEGER len;}
# -DStringStructVal   : A structure is passed by value for each Fortran
#                       77 string, and the structure is of the form:
#                       struct {char *cp; F77_INTEGER len;}
# -DStringCrayStyle   : Special option for Cray machines, which uses
#                       Cray fcd (fortran character descriptor) for
#                       interoperation
F2CDEFS      =  -DAdd_
 
#
# HPL Includes / Libraries / Specifics
HPL_INCLUDES = -I$(INCdir) -I$(INCdir)/$(ARCH) $(LAinc) $(MPinc)
HPL_LIBS     = $(HPLlib) $(LAlib) $(MPlib)
 
#
# HPL Compile Time Options
# -DHPL_COPY_L           force the copy of the panel L before bcast
# -DHPL_CALL_CBLAS       call the cblas interface
# -DHPL_CALL_VSIPL       call the vsip library
# -DHPL_DETAILED_TIMING  enable detailed timers
#
# By default HPL will:
#    *) not copy L before broadcast
#    *) call the BLAS Fortran 77 interface
#    *) not display detailed timing information
HPL_OPTS     = -DHPL_COPY_L -DHPL_CALL_CBLAS -DHPL_DETAILED_TIMING 
 
#
# HPL Definitions
HPL_DEFS     = $(F2CDEFS) $(HPL_OPTS) $(HPL_INCLUDES)
 
#
# Compilers / linkers - Optimization Flags
CC           = mpicc
CCNOOPT      = $(HPL_DEFS)
CCFLAGS      = $(HPL_DEFS) -fomit-frame-pointer -O3 -funroll-loops -W -Wall
 
#
# On some platforms, it is necessary to use the Fortran linker 
# to find the Fortran internals used in the BLAS library
LINKER       = mpif77
LINKFLAGS    = $(CCFLAGS)
ARCHIVER     = ar
ARFLAGS      = r
RANLIB       = echo
#

#! /bin/bash
#
# install_hpcc.sh
# BASH script to install HPCC 1.4.1 (compiled against MPICH2 1.4.1p1) on a
# Rocks 5.4.2 cluster's front end
# Must be root (or at least have sudo privilege) to run this script
 
# Begin root-check IF
if [ $UID != 0 ];
then
  clear
  echo
  echo "  You must be logged in as root!"
  echo "  Exiting..."
  echo
  exit
else
  # Set necessary variables
  export HPCC_VERSION="1.4.1"
  export MPICH2_VERSION="1.4.1p1"
  export GCC_VERSION="4.1.2"
  export HPCC_INSTALL="/share/apps/hpcc/${HPCC_VERSION}/mpich2/${MPICH2_VERSION}/gcc/${GCC_VERSION}"
  export MAKEFILE_ARCH="MPICH2141p1_GCC412"
 
  # Begin HPCC-${HPCC_VERSION}.tar.gz check IF
  if [ -e "/share/apps/tmp/hpcc-${HPCC_VERSION}.tar.gz" ]
  then
 
    mkdir /share/apps/hpcc/${HPCC_VERSION}/mpich2/${MPICH2_VERSION}/gcc/
    cd /share/apps/hpcc/${HPCC_VERSION}/mpich2/${MPICH2_VERSION}/gcc/
    tar -zxvf /share/apps/tmp/hpcc-${HPCC_VERSION}.tar.gz
    mv hpcc-${HPCC_VERSION} ${GCC_VERSION}
 
    echo
    echo "  Step #0: copy the makefile, make clean and make"
    cd ${HPCC_INSTALL}
    cp /share/apps/tmp/Make.${MAKEFILE_ARCH}.HPCC ./hpl/Make.${MAKEFILE_ARCH}
 
    make clean arch=${MAKEFILE_ARCH}
    make arch=${MAKEFILE_ARCH}
 
    echo
    echo "  Step #1: Update $HOME/.bashrc"
    cat <<EOF
 
  Add the following lines to $HOME/.bashrc and remember to source it
 
  # HPCC (${HPCC_VERSION}) settings
  export HPCC="${HPCC_INSTALL}"
  export PATH="\${PATH}:\${HPCC}/bin/${MAKEFILE_ARCH}"
  export LD_LIBRARY_PATH="\${LD_LIBRARY_PATH}:\${HPCC}/${MAKEFILE_ARCH}"
 
EOF
 
  fi
  # End hpcc-${HPCC_VERSION}.tar.gz check IF
  echo
 
fi 
# End root-check IF

#! /bin/bash
#
# install_mpich2.sh
# BASH script to install MPICH2 (compiled against GCC 4.1.2) on a
# Rocks 5.4.2 cluster's front end
# Must be root (or at least have sudo privilege) to run this script
 
# Begin root-check IF
if [ $UID != 0 ];
then
  clear
  echo
  echo "  You must be logged in as root!"
  echo "  Exiting..."
  echo
  exit
else
  # Set necessary variables
  export CC="gcc"
  export CXX="g++"
  export FC="gfortran"
  export F77="gfortran"
  export MPICH2_VERSION="1.4.1p1"
  export GCC_VERSION="4.1.2"
  export MPICH2_INSTALL="/share/apps/mpich2/${MPICH2_VERSION}/gcc/${GCC_VERSION}"
  export ANL="http://www.mcs.anl.gov/research/projects/mpich2/downloads/tarballs"
 
  echo
  echo "  Step #0: Download MPICH2 to /share/apps/tmp"
  cd /share/apps/tmp/
  wget ${ANL}/${MPICH2_VERSION}/mpich2-${MPICH2_VERSION}.tar.gz
 
  # Begin mpich2-${MPICH2_VERSION}.tar.gz check IF
  if [ -e "mpich2-${MPICH2_VERSION}.tar.gz" ]
  then
    echo
    echo "  Step #1: configure, make clean, make and make install"
 
    tar -zxpf mpich2-${MPICH2_VERSION}.tar.gz
    cd mpich2-${MPICH2_VERSION}/
    ./configure --prefix=${MPICH2_INSTALL}
    make clean
    make
    make install
 
    echo
    echo "  Step #2: Update $HOME/.bashrc"
    cat <<EOF
 
  Add the following lines to $HOME/.bashrc and remember to source it
 
  # MPICH2 (${MPICH2_VERSION}) settings
  export MPICH2="${MPICH2_INSTALL}"
  export PATH="\${PATH}:\${MPICH2}/bin:\${MPICH2}/sbin"
  export MANPATH="\${MANPATH}:\${MPICH2}/man"
  export LD_LIBRARY_PATH="\${LD_LIBRARY_PATH}:\${MPICH2}/lib"
 
EOF
 
  fi
  # End mpich2-${MPICH2_VERSION}.tar.gz check IF
  echo
 
fi 
# End root-check IF

#! /bin/bash
#
# install_gotoblas2.sh
# BASH script to install Goto BLAS2 (compiled against GCC 4.1.2) on a
# Rocks 5.4.2 cluster's front end
# Must be root (or at least have sudo privilege) to run this script
 
# Begin root-check IF
if [ $UID != 0 ];
then
  clear
  echo
  echo "  You must be logged in as root!"
  echo "  Exiting..."
  echo
  exit
else
  # Set necessary variables
  export CC="gcc"
  export CXX="g++"
  export FC="gfortran"
  export F77="gfortran"
  export GOTOBLAS2_VERSION="1.13"
  export GCC_VERSION="4.1.2"
  export GOTOBLAS2_INSTALL="/share/apps/gotoblas2/${GOTOBLAS2_VERSION}/gcc/${GCC_VERSION}"
 
  # Begin GotoBLAS2-${GOTOBLAS2_VERSION}.tar.gz check IF
  if [ -e "/share/apps/tmp/GotoBLAS2-${GOTOBLAS2_VERSION}.tar.gz" ]
  then
 
    mkdir /share/apps/gotoblas2/${GOTOBLAS2_VERSION}/gcc/
    cd /share/apps/gotoblas2/${GOTOBLAS2_VERSION}/gcc/
    tar -zxvf /share/apps/tmp/GotoBLAS2-${GOTOBLAS2_VERSION}.tar.gz
    mv GotoBLAS2 ${GCC_VERSION}
 
    echo
    echo "  Step #0: make clean and make"
    cd ${GOTOBLAS2_INSTALL}
    make clean
    make BINARY=64
 
    echo
    echo "  Step #1: Update $HOME/.bashrc"
    cat <<EOF
 
  Add the following lines to $HOME/.bashrc and remember to source it
 
  # GOTOBLAS2 (${GOTOBLAS2_VERSION}) settings
  export GOTOBLAS2="${GOTOBLAS2_INSTALL}"
  export LD_LIBRARY_PATH="\${LD_LIBRARY_PATH}:\${GOTOBLAS2}"
 
EOF
 
  fi
  # End GotoBLAS2-${GOTOBLAS2_VERSION}.tar.gz check IF
  echo
 
fi 
# End root-check IF

#
# Makefile (Make.MPICH2141p1_GCC412) used to compile HPL 
# on HPC clusters running NPACI Rocks (5.4.2) with CentOS (5.5)
# at Michigan Technological University.
# 
# Disclaimer:
# Please note that you are using these instructions 
# at your very own risk and that Michigan Technological
# University is not responsible for any/all damage caused to 
# your property, intellectual or otherwise.
# 
# For additional help and/or comments, questions, suggestions,
# please contact 
#
# Gowtham
# Information Technology Services & Security
# Michigan Technological University
# g@mtu.edu
#
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
#
#
#  -- High Performance Computing Linpack Benchmark (HPL)                
#     HPL - 2.0 - September 10, 2008                          
#     Antoine P. Petitet                                                
#     University of Tennessee, Knoxville                                
#     Innovative Computing Laboratory                                 
#     (C) Copyright 2000-2008 All Rights Reserved                       
#                                                                       
#  -- Copyright notice and Licensing terms:                             
#                                                                       
#  Redistribution and use in source and binary forms, with or without
#  modification, are permitted provided that the following conditions
#  are met:                                                             
#                                                                       
#  1. Redistributions of source code must retain the above copyright
#  notice, this list of conditions and the following disclaimer.        
#                                                                       
#  2. Redistributions in binary form must reproduce the above copyright
#  notice, this list of conditions, and the following disclaimer in the
#  documentation and/or other materials provided with the distribution. 
#                                                                       
#  3. All advertising materials mentioning features or use of this
#  software must display the following acknowledgement:                 
#  This product includes software developed at the University of
#  Tennessee, Knoxville, Innovative Computing Laboratory.             
#                                                                       
#  4. The name of the University, the name of the Laboratory, or the
#  names of its contributors may not be used to endorse or promote
#  products derived from this software without specific written
#  permission.
#
#  -- Disclaimer:
#                                                                       
#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
#  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
#  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
#  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY
#  OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
#  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
#  DATA OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
#  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
#  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
#  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#  
 
#
# Shell Details
SHELL        = /bin/sh
CD           = cd
CP           = cp
LN_S         = ln -s
MKDIR        = mkdir
RM           = /bin/rm -f
TOUCH        = touch
 
#
# Platform Identifier
ARCH         = MPICH2141p1_GCC412
 
#
# HPL Directory Structure / HPL library
TOPdir       = /share/apps/hpl/2.0/mpich2/1.4.1p1/gcc/4.1.2
INCdir       = $(TOPdir)/include
BINdir       = $(TOPdir)/bin/$(ARCH)
LIBdir       = $(TOPdir)/lib/$(ARCH)
HPLlib       = $(LIBdir)/libhpl.a 
 
#
# Message Passing library (MPI)
MPdir        = /share/apps/mpich2/1.4.1p1/gcc/4.1.2
MPinc        = -I$(MPdir)/include
MPlib        = $(MPdir)/lib/libmpich.a
 
#
# Linear Algebra library (BLAS)
LAlib        = /share/apps/gotoblas2/1.13/gcc/4.1.2/libgoto2.a
 
#
# F77 / C Interface
# You can skip this section if and only if you are not planning to use
# a BLAS library featuring a Fortran 77 interface. Otherwise, it is
# necessary to fill out the F2CDEFS variable with the appropriate
# options. **One and only one** option should be chosen in **each** of
# the 3 following categories:
#
# 1) name space (How C calls a Fortran 77 routine)
#
# -DAdd_              : all lower case and a suffixed underscore (Suns,
#                       Intel, ...) [default]
# -DNoChange          : all lower case (IBM RS6000)
# -DUpCase            : all upper case (Cray)
# -DAdd__             : the FORTRAN compiler in use is f2c
#
# 2) C and Fortran 77 integer mapping
#
# -DF77_INTEGER=int   : Fortran 77 INTEGER is a C int [default]
# -DF77_INTEGER=long  : Fortran 77 INTEGER is a C long
# -DF77_INTEGER=short : Fortran 77 INTEGER is a C short
#
# 3) Fortran 77 string handling
#
# -DStringSunStyle    : The string address is passed at the string location
#                       on the stack, and the string length is then
#                       passed as an F77_INTEGER after all explicit
#                       stack arguments [default]
# -DStringStructPtr   : The address of a structure is passed by a
#                       Fortran 77 string, and the structure is of the
#                       form: struct {char *cp; F77_INTEGER len;}
# -DStringStructVal   : A structure is passed by value for each Fortran
#                       77 string, and the structure is of the form:
#                       struct {char *cp; F77_INTEGER len;}
# -DStringCrayStyle   : Special option for Cray machines, which uses
#                       Cray fcd (fortran character descriptor) for
#                       interoperation
F2CDEFS      =  -DAdd_
 
#
# HPL Includes / Libraries / Specifics
HPL_INCLUDES = -I$(INCdir) -I$(INCdir)/$(ARCH) $(LAinc) $(MPinc)
HPL_LIBS     = $(HPLlib) $(LAlib) $(MPlib)
 
#
# HPL Compile Time Options
# -DHPL_COPY_L           force the copy of the panel L before bcast
# -DHPL_CALL_CBLAS       call the cblas interface
# -DHPL_CALL_VSIPL       call the vsip library
# -DHPL_DETAILED_TIMING  enable detailed timers
#
# By default HPL will:
#    *) not copy L before broadcast
#    *) call the BLAS Fortran 77 interface
#    *) not display detailed timing information
HPL_OPTS     = -DHPL_COPY_L -DHPL_CALL_CBLAS -DHPL_DETAILED_TIMING 
 
#
# HPL Definitions
HPL_DEFS     = $(F2CDEFS) $(HPL_OPTS) $(HPL_INCLUDES)
 
#
# Compilers / linkers - Optimization Flags
CC           = mpicc
CCNOOPT      = $(HPL_DEFS)
CCFLAGS      = $(HPL_DEFS) -fomit-frame-pointer -O3 -funroll-loops -W -Wall
 
#
# On some platforms, it is necessary to use the Fortran linker 
# to find the Fortran internals used in the BLAS library
LINKER       = mpif77
LINKFLAGS    = $(CCFLAGS)
ARCHIVER     = ar
ARFLAGS      = r
RANLIB       = echo
#

#! /bin/bash
#
# install_hpl.sh
# BASH script to install HPL 2.0 (compiled against MPICH2 1.4.1p1) on a
# Rocks 5.4.2 cluster's front end
# Must be root (or at least have sudo privilege) to run this script
 
# Begin root-check IF
if [ $UID != 0 ];
then
  clear
  echo
  echo "  You must be logged in as root!"
  echo "  Exiting..."
  echo
  exit
else
  # Set necessary variables
  export HPL_VERSION="2.0"
  export MPICH2_VERSION="1.4.1p1"
  export GCC_VERSION="4.1.2"
  export HPL_INSTALL="/share/apps/hpl/${HPL_VERSION}/mpich2/${MPICH2_VERSION}/gcc/${GCC_VERSION}"
  export MAKEFILE_ARCH="MPICH2141p1_GCC412"
 
  # Begin hpl-${HPL_VERSION}.tar.gz check IF
  if [ -e "/share/apps/tmp/hpl-${HPL_VERSION}.tar.gz" ]
  then
 
    mkdir /share/apps/hpl/${HPL_VERSION}/mpich2/${MPICH2_VERSION}/gcc/
    cd /share/apps/hpl/${HPL_VERSION}/mpich2/${MPICH2_VERSION}/gcc/
    tar -zxvf /share/apps/tmp/hpl-${HPL_VERSION}.tar.gz
    mv hpl-${HPL_VERSION} ${GCC_VERSION}
 
    echo
    echo "  Step #0: copy the makefile, make clean and make"
    cd ${HPL_INSTALL}
    cp /share/apps/tmp/Make.${MAKEFILE_ARCH}.HPC ./Make.${MAKEFILE_ARCH}
 
    if [ -d "${HPL_INSTALL}/bin/${MAKEFILE_ARCH}"]
    then
      make clean arch=${MAKEFILE_ARCH}
    fi
 
    if [ "$(ls -A ${HPL_INSTALL}/bin)"];
    then
      make clean_arch_all arch=${MAKEFILE_ARCH} 
    fi
 
    make arch=${MAKEFILE_ARCH}
 
    echo
    echo "  Step #1: Update $HOME/.bashrc"
    cat <<EOF
 
  Add the following lines to $HOME/.bashrc and remember to source it
 
  # HPL (${HPL_VERSION}) settings
  export HPL="${HPL_INSTALL}"
  export PATH="\${PATH}:\${HPL}/bin/${MAKEFILE_ARCH}"
  export LD_LIBRARY_PATH="\${LD_LIBRARY_PATH}:\${HPL}/${MAKEFILE_ARCH}"
 
EOF
 
  fi
  # End hpl-${HPL_VERSION}.tar.gz check IF
  echo
 
fi 
# End root-check IF

#! /bin/bash
#
# update_web_firewall.sh
# BASH script to run necessary 'rocks' commands to update the firewall rules on a
# Rocks 5.4.2 cluster's front end to make the web interface accessible from anywhere
# Must be root (or at least have sudo privilege) to run this script
 
# Begin root-check IF
if [ $UID != 0 ];
then
  clear
  echo
  echo "  You must be logged in as root!"
  echo "  Exiting..."
  echo
  exit
else
  echo
  echo "  Step #0: display current firewall rules"
  /opt/rocks/bin/rocks report host firewall localhost
 
  echo "  Step #1: removing the current rule for www"
  /opt/rocks/bin/rocks remove host firewall localhost chain=INPUT \
    flags="-m state --state NEW --source &Kickstart_PublicNetwork;/&Kickstart_PublicNetmask;" \
    protocol=tcp service=www action=ACCEPT network=public
 
  /opt/rocks/bin/rocks sync host firewall localhost
 
  echo "  Step #2: removing the current rule for https"
  /opt/rocks/bin/rocks remove host firewall localhost chain=INPUT \
    flags="-m state --state NEW --source &Kickstart_PublicNetwork;/&Kickstart_PublicNetmask;" \
    protocol=tcp service=https action=ACCEPT network=public
 
  /opt/rocks/bin/rocks sync host firewall localhost
 
  echo "  Step #3: adding new rule for www"
  /opt/rocks/bin/rocks add host firewall localhost chain=INPUT \
    flags="-m state --state NEW --source 0.0.0.0/0.0.0.0" \
    protocol=tcp service=www action=ACCEPT network=public
 
  /opt/rocks/bin/rocks sync host firewall localhost
 
  echo "  Step #4: adding new rule for https"
  /opt/rocks/bin/rocks add host firewall localhost chain=INPUT \
    flags="-m state --state NEW --source 0.0.0.0/0.0.0.0" \
    protocol=tcp service=https action=ACCEPT network=public
 
  /opt/rocks/bin/rocks sync host firewall localhost
 
  echo "  Step #5: display current firewall rules"
  /opt/rocks/bin/rocks report host firewall localhost
  echo
 
fi 
# End root-check IF

#! /bin/bash
#
# update_rocks_distribution.sh
# BASH script to download python-ctypes-1.0.2-2.el5.x86_64.rpm from 
# http://ftp.osuosl.org/pub/fedora-epel/5/x86_64/ and rebuild the
# rocks distribution
# Must be root (or at least have sudo privilege) to run this script
 
# Begin root-check IF
if [ $UID != 0 ];
then
  clear
  echo
  echo "  You must be logged in as root!"
  echo "  Exiting..."
  echo
  exit
else
  echo
  cd /export/rocks/install/contrib/5.4/x86_64/RPMS/
  wget http://ftp.osuosl.org/pub/fedora-epel/5/x86_64/python-ctypes-1.0.2-2.el5.x86_64.rpm
 
  cd /export/rocks/install/
  rocks create distro
 
fi
# End root-check IF

#! /bin/bash
#
# install_nvidia_driver.sh
# BASH script to install NVIDIA driver in compute node(s) - save this in /share/apps/bin/
# Assumes that NVIDIA-Linux-x86_64-285.05.33.run is located in /share/apps/src/nvidia_cuda/
# Also, assumes that CUDA SDK 4.1.28 has been installed on front end in /share/apps/cuda/
# Must be root to run this script and run this in all compute nodes from the front end via
# the command
#
# rocks run host '/share/apps/bin/install_nvidia_driver.sh'
#
 
# Begin root-check IF
if [ $UID != 0 ];
then
  clear
  echo
  echo "  You must be logged in as root!"
  echo "  Exiting..."
  echo
  exit
else
  echo
  # 1. Install NVIDIA driver
  /share/apps/src/nvidia_cuda/NVIDIA-Linux-x86_64-285.05.33.run --silent
 
  # 2: Updating /etc/ld.so.config
  echo "/share/apps/cuda/lib64" >> /etc/ld.so.conf
  echo "/share/apps/cuda/lib" >> /etc/ld.so.conf
  /sbin/ldconfig
 
  # 3: Creating missing symbolic links to necessary libraries
  cd /usr/lib64/
  ln -sf libXmu.so.6.2.0 libXmu.so
  ln -sf libXi.so.6.0.0  libXi.so
 
fi
# End root-check IF

#! /bin/bash
#
# install_python_nvml_bindings.sh
# BASH script to install Python Bindings for the NVML in compute node(s) - save this in /share/apps/bin/
# Assumes that nvidia-ml-py-2.285.01.tar.gz is in /share/apps/src/nvidia_ganglia/
# Must be root to run this script and run this in all compute nodes from the front end via the command
#
# rocks run host '/share/apps/bin/install_python_nvml_bindings.sh'
#
 
# Begin root-check IF
if [ $UID != 0 ];
then
  clear
  echo
  echo "  You must be logged in as root!"
  echo "  Exiting..."
  echo
  exit
else
  #
  # Download and install
  cd /tmp/
  cp /share/apps/src/nvidia_ganglia/nvidia-ml-py-2.285.01.tar.gz .
 
  tar -zxvpf nvidia-ml-py-2.285.01.tar.gz
  cd nvidia-ml-py-2.285.01
  python setup.py install
 
  # Copy nvidia_smi.py & pynvml.py to /opt/ganglia/lib64/ganglia/python_modules/
  cp nvidia_smi.py /opt/ganglia/lib64/ganglia/python_modules/
  cp pynvml.py /opt/ganglia/lib64/ganglia/python_modules/
 
fi
# End root-check IF

#! /bin/bash
#
# copy_ganglia_gmond_python_computenodes.sh
# BASH script to copy relevant files from ganglia-gmond_python_modules to Ganglia, 
# and restart gmond - save this in /share/apps/bin/
# Assumes that ganglia-gmond_python_modules-3dfa553.tar.gz is in /share/apps/src/nvidia_ganglia/
# Must be root to run this script and run this in all compute nodes from the front end via the command
#
# rocks run host '/share/apps/bin/copy_ganglia_gmond_python_computenodes.sh'
#
 
 
# Begin root-check IF
if [ $UID != 0 ];
then
  clear
  echo
  echo "  You must be logged in as root!"
  echo "  Exiting..."
  echo
  exit
else
 
  # Copy relevant files to Ganglia
  cd /tmp/
  tar -zxvpf /share/apps/src/nvidia_ganglia/ganglia-gmond_python_modules-3dfa553.tar.gz
  cd ganglia-gmond_python_modules-3dfa553/gpu/nvidia/
  cp python_modules/nvidia.py /opt/ganglia/lib64/ganglia/python_modules/
  cp conf.d/nvidia.pyconf /etc/ganglia/conf.d/
 
  #
  # Restart gmond
  /etc/init.d/gmond restart
 
fi
# End root-check IF

#! /bin/bash
#
# copy_ganglia_gmond_python_frontend.sh
# BASH script to copy relevant files from ganglia-gmond_python_modules to Ganglia, 
# apply patch for Ganglia web interface and restart necessary services 
# Assumes that ganglia-gmond_python_modules-3dfa553.tar.gz is in /share/apps/src/nvidia_ganglia/
# Must be root (or at least have sudo privilege) to run this script and run this only on front end
 
# Begin root-check IF
if [ $UID != 0 ];
then
  clear
  echo
  echo "  You must be logged in as root!"
  echo "  Exiting..."
  echo
  exit
else
 
  #
  # Apply web patch for Ganglia to display custom graphs
  cd /tmp/
  tar -zxvpf /share/apps/src/nvidia_ganglia/ganglia-gmond_python_modules-3dfa553.tar.gz
  cd ganglia-gmond_python_modules-3dfa553/gpu/nvidia/
  cp graph.d/*.php /var/www/html/ganglia/graph.d/
 
  cd /var/www/html/ganglia/
  patch -p0 < /tmp/ganglia-gmond_python_modules-3dfa553/gpu/nvidia/ganglia_web.patch
 
  #
  # Restart necessary services
  /etc/init.d/gmetad restart
  /etc/init.d/gmond restart
 
fi
# End root-check IF

/* hello_world_cuda.cu
   A CUDA C PROGRAM TO PRINT 'HELLO, WORLD!' TO THE SCREEN
 
   TESTED SUCCESSFULLY WITH CUDA SDK 4.1.28 AND NVIDIA GPU DRIVER 
   VERSION 290.10 RUNNING ON NVIDIA GeForce GTX 270
 
   COMPILATION:
   #1: NON-MAKEFILE APPROACH
       nvcc -g hello_world_cuda.cu -o hello_world_cuda.x
 
   #2. MAKEFILE APPROACH (USE THE ASSOCIATED Makefile)
       make
 
   EXECUTION:
   ./hello_world_cuda.x
 
   PORTIONS OF THE COMMENTS ARE ADOPTED FROM
 
     NVIDIA CUDA C
     PROGRAMMING GUIDE
     VERSION 4.0 (5/6/2011)
 
   FIRST WRITTEN: GOWTHAM; Mon, 13 Feb 2012 14:06:30 -0500
   LAST MODIFIED: GOWTHAM; Mon, 13 Feb 2012 14:15:30 -0500
*/
 
/* STANDARD HEADERS AND DEFINITIONS 
   REFERENCE: http://en.wikipedia.org/wiki/C_standard_library
*/
#include <stdio.h>  /* Core input/output operations                         */
#include <stdlib.h> /* Conversions, random numbers, memory allocation, etc. */
#include <math.h>   /* Common mathematical functions                        */
#include <time.h>   /* Converting between various date/time formats         */
#include <cuda.h>   /* CUDA related stuff                                   */
 
 
/* KERNEL DEFINITION
   CUDA C EXTENDS C BY ALLOWING THE PROGRAMMER TO DEFINE C FUNCTIONS,
   CALLED KERNELS, THAT, WHEN CALLED, ARE EXECUTED N TIMES IN PARALLEL
   BY N DIFFERENT CUDA THREADS, AS OPPOSED TO ONLY ONCE LIKE REGULAR
   C FUNCTIONS
 
   A KERNEL IS DEFINED USING THE __global__ DECLARATION SPECIFIER.
   THE NUMBER OF CUDA THREADS THAT EXECUTE THAT KERNEL FOR A GIVEN
   KERNEL CALL IS SPECIFIED USING <<< >>> (EXECUTION CONFIGURATION)
   SYNTAX. EXECUTION CONFIGURATION DEFINES THE DIMENSION OF THE
   GRIDS AND BLOCKS THAT WILL BE USED TO EXECUTE THE FUNCTION ON THE 
   DEVICE AS WELL AS THE ASSOCIATED STREAM
 
   EACH THREAD THAT EXECUTES THE KERNEL IS GIVEN A UNIQUE 'THREAD ID'
   THAT IS ACCESSIBLE WITHIN THE KERNEL THROUGH THE BUILT-IN
   threadIdx VARIABLE
 
   A FUNCTION DECLARED AS
 
     __global__ void Function(float* parameter);
 
   MUST BE CALLED AS FOLLOWS:
 
     Function<<< Dg, Db, Ns >>>(parameter);
 
   WHERE
 
   -- Dg : OF TYPE dim3, IT SPECIFIES THE DIMENSION AND SIZE OF THE GRID
           SUCH THAT Dg.x * Dg.y * Dg.z EQUALS THE NUMBER OF BLOCKS BEING
           LAUNCHED
 
   -- Db : OF TYPE dim3, IT SPECIFIES THE DIMENSION AND SIZE OF EACH BLOCK
           SUCH THAT Db.x * Db.y * Db.z EQUALS THE NUMBER OF THREADS PER
           BLOCK
 
   -- Ns : OF TYPE size_t, IT SPECIFIES THE NUMBER OF BYTES IN SHARED MEMORY
           THAT IS DYNAMICALLY ALLOCATED PER BLOCK FOR THIS CALL IN ADDITION
           TO THE STATICALLY ALLOCATED MEMORY. THIS DYNAMICALLY ALLOCATED
           MEMORY IS USED BY ANY OF THE VARIABLES DECLARED AS AN EXTERNAL
           ARRAY. NOTE THAT THIS IS AN OPTIONAL ARGUMENT THAT DEFAULTS TO 0
 
   -- S  : OF TYPE cudaStream_t, IT SPECIFIES THE ASSOCIATED STREAM. THIS
           TOO IS AN OPTIONAL ARGUMENT THAT DEFAULTS TO 0
*/
__global__ void kernel(void) {
}
 
/* MAIN PROGRAM BEGINS */
int main(void) {
 
  /* Dg = 1; Db = 1; Ns = 0; S = 0 */
  kernel<<<1,1>>>();
 
  /* PRINT 'HELLO, WORLD!' TO THE SCREEN */
  printf("\n  Hello, World!\n\n");
 
  /* INDICATE THE TERMINATION OF THE PROGRAM */
  return 0;
}
/* MAIN PROGRAM ENDS */

# Simple version of the Makefile used to systematically compile
# one of many CUDA C programs, taking into account respective dependencies
# 
# First written: Gowtham; Mon, 13 Feb 2012 14:32:36 -0500
# Last modified: Gowtham; Mon, 13 Feb 2012 15:00:42 -0500
# 
 
# Necessary variables
CC        = nvcc
CFLAGS    = -g -c
OFLAGS    = -O3
MYPROGRAM = $(CPROGRAM)
 
# If CPROGRAM is not defined (and hence MYPROGRAM is empty), 
# display help message
ifndef CPROGRAM
help:
endif
 
# Default target
all: $(MYPROGRAM).x
 
# Print help message
help:
	@echo
	@echo "  To compile, choose one of the following:"
	@echo
	@echo "    make CPROGRAM=hello_world_cuda"
	@echo
	@echo
	@echo "  To clean, choose one of the following:"
	@echo
	@echo "    make clean-all-programs"
	@echo "    make clean CPROGRAM=hello_world_cuda"
	@echo
 
 
# $(MYPROGRAM).x (depends on $(MYPROGRAM).o)
$(MYPROGRAM).x: $(MYPROGRAM).o
	$(CC) $(MYPROGRAM).o -o $(MYPROGRAM).x
 
 
# $(MYPROGRAM).o (depends on $(MYPROGRAM).cu)
$(MYPROGRAM).o: $(MYPROGRAM).cu
	$(CC) $(CFLAGS) $(OFLAGS) $(MYPROGRAM).cu
 
 
# Remove the appropriate object file and executable
clean:
	@echo
	@echo "Deleting $(MYPROGRAM).o and $(MYPROGRAM).x"
	rm -f $(MYPROGRAM).o $(MYPROGRAM).x
	@echo
 
# Remove all object files and executables
clean-all-programs:
	@echo
	@echo "Deleting *.o and *.x files"
	rm -f *.o *.x
	@echo

#! /bin/bash
#
# install_ganglia.sh
# BASH script to install Ganglia on RHEL 6.2
# Must be root (or at least have sudo privilege) to run this script
 
# Begin root-check IF
if [ $UID != 0 ];
then
  clear
  echo
  echo "  You must be logged in as root!"
  echo "  Exiting..."
  echo
  exit
else
  #
  # Enable EPEL repository
  # EPEL: Extra Packages for Enterprise Linux
  cd /tmp/
  wget http://download.fedoraproject.org/pub/epel/6/i386/epel-release-6-5.noarch.rpm
  rpm -ivh epel-release-6-5.noarch.rpm
 
  #
  # Install Ganglia
  yum install ganglia ganglia-gmetad ganglia-gmond ganglia-web ganglia-gmond-python
 
  #
  # Make sure httpd, gmond and gmetad automatically start after each reboot
  chkconfig --level 345 httpd on
  chkconfig --level 345 gmond on
  chkconfig --level 345 gmetad on
 
fi 
# End root-check IF

data_source "dirac.dcs" localhost:8649

/*
 * The cluster attributes specified will be used as part of the <CLUSTER>
 * tag that will wrap all hosts collected by this instance.
 */
cluster {
  name = "dirac.dcs"
  owner = "Michigan Technological University"
  latlong = "N47.11 W88.57"
  url = "http://www.it.mtu.edu/"
}
 
/* Feel free to specify as many udp_send_channels as you like.
 * Gmond used to only support having a single channel 
*/
udp_send_channel {
  bind_hostname = yes  # Highly recommended, soon to be default.
                       # This option tells gmond to use a source address
                       # that resolves to the machine's hostname.  Without
                       # this, the metrics may appear to come from any
                       # interface and the DNS names associated with
                       # those IPs will be used to create the RRDs.
  mcast_join = 239.2.11.71
  host = dirac.dcs.it.mtu.edu
  port = 8649
  ttl = 1
}
 
/* You can specify as many udp_recv_channels as you like as well. */
udp_recv_channel {
  mcast_join = 239.2.11.71
  port = 8649
  bind = 239.2.11.71
}
 
/* You can specify as many tcp_accept_channels as you like to share
 * an xml description of the state of the cluster 
*/
tcp_accept_channel {
  port = 8649
  acl {
    default = "deny"
 
    access {
      ip = 127.0.0.1
      mask = 32
      action = "allow"
    }
  }
}

  #
  # Ganglia monitoring system php web frontend
  #
 
  Alias /ganglia /usr/share/ganglia
 
  <Location /ganglia>
    Order deny,allow
    # Deny from all
    # Allow from 127.0.0.1
    # Allow from ::1
    # # Allow from .example.com
    Allow from all
  </Location>

# Ganglia gmond/gmetad
-A INPUT -m udp -p udp --dport 8649 -j ACCEPT
-A INPUT -m tcp -p tcp --dport 8649 -j ACCEPT
#

/etc/init.d/iptables restart
/etc/init.d/gmetad restart
/etc/init.d/gmond restart
/etc/init.d/httpd restart

# This file controls the state of SELinux on the system.
# SELINUX= can take one of these three values:
#     enforcing - SELinux security policy is enforced.
#     permissive - SELinux prints warnings instead of enforcing.
#     disabled - No SELinux policy is loaded.
SELINUX=disabled
# SELINUXTYPE= can take one of these two values:
#     targeted - Targeted processes are protected,
#     mls - Multi Level Security protection.
SELINUXTYPE=targeted

#! /bin/bash
#
# install_python_nvml_bindings.sh
# BASH script to download and install Python Bindings for the NVML
# Must be root (or at least have sudo privilege) to run this script
# Does not work with Python 2.4 - needs higher/more recent version
 
# Begin root-check IF
if [ $UID != 0 ];
then
  clear
  echo
  echo "  You must be logged in as root!"
  echo "  Exiting..."
  echo
  exit
else
  #
  # Download and install
  cd /tmp/
  wget http://pypi.python.org/packages/source/n/nvidia-ml-py/nvidia-ml-py-2.285.01.tar.gz
 
  tar -zxvpf nvidia-ml-py-2.285.01.tar.gz
  cd nvidia-ml-py-2.285.01
  python setup.py install
 
fi
# End root-check IF

#! /bin/bash
#
# copy_ganglia_gmond_python.sh
# BASH script to copy Copy nvidia_smi.py & pynvml.py to 
# /usr/lib64/ganglia/python_modules/, relevant files from 
# ganglia-gmond_python_modules to Ganglia, apply patch
# for Ganglia web interface and restart necessary services
# Must be root (or at least have sudo privilege) to run this script
 
# Begin root-check IF
if [ $UID != 0 ];
then
  clear
  echo
  echo "  You must be logged in as root!"
  echo "  Exiting..."
  echo
  exit
else
  #
  # Copy nvidia_smi.py & pynvml.py to /usr/lib64/ganglia/python_modules/
  cp /tmp/nvidia-ml-py-2.285.01/nvidia_smi.py /usr/lib64/ganglia/python_modules/
  cp /tmp/nvidia-ml-py-2.285.01/pynvml.py /usr/lib64/ganglia/python_modules/
 
  #
  # Copy relevant files to Ganglia
  cd /tmp/
  tar -zxvpf ganglia-gmond_python_modules-3dfa553.tar.gz
  cd ganglia-gmond_python_modules-3dfa553
 
  cd gpu/nvidia/
  cp python_modules/nvidia.py /usr/lib64/ganglia/python_modules/
  cp conf.d/nvidia.pyconf /etc/ganglia/conf.d/
  cp graph.d/*.php /usr/share/ganglia/graph.d/
 
  #
  # Apply web patch for Ganglia to display custom graphs
  cd /usr/share/ganglia/
  patch -p0 < /tmp/ganglia-gmond_python_modules-3dfa553/gpu/nvidia/ganglia_web.patch
 
  #
  # Restart necessary services
  /etc/init.d/gmetad restart
  /etc/init.d/gmond restart
 
fi
# End root-check IF

#! /bin/bash
#
# BASH script to automagically uncompress different kinds of compressed files/folders
#
# Usage: extract.sh [COMPRESSED_FILENAME]
# First written: Wed, 04 May 2011 05:14:10 -0400
# Last modified: Wed, 04 May 2011 05:14:10 -0400
#
 
E_BADARGS=65
 
if [ $# != 1 ];
then
  echo
  echo "  Usage: `basename $0` [COMPRESSED_FILENAME]"
  echo
  exit $E_BADARGS
else
  if [ -f $1 ];
  then
    case $1 in
      *.tar)       tar -xvf  $1  ;;
      *.tgz)       tar -xvzf $1  ;;
      *.tar.gz)    tar -xvzf $1  ;;
      *.tbz2)      tar -xvjf $1  ;;
      *.tar.bz2)   tar -xvjf $1  ;;
      *.gz)        gunzip    $1  ;;
      *.bz2)       bunzip2   $1  ;;
      *.zip)       unzip     $1  ;;
      *)           echo "  '$1' file type unknown" ;;
    esac
  else
    echo "  '$1' is not a regular file"
    echo
  fi
fi

# Smart extract function
extract () {
  if [ $# != 1 ];
  then
    echo
    echo "  Usage: extract [COMPRESSED_FILENAME]"
    echo
  else
    if [ -f $1 ];
    then
      case $1 in
        *.tar)       tar -xvf  $1  ;;
        *.tgz)       tar -xvzf $1  ;;
        *.tar.gz)    tar -xvzf $1  ;;
        *.tbz2)      tar -xvjf $1  ;;
        *.tar.bz2)   tar -xvjf $1  ;;
        *.gz)        gunzip    $1  ;;
        *.bz2)       bunzip2   $1  ;;
        *.zip)       unzip     $1  ;;
        *)           echo "  '$1' file type unknown" ;;
      esac
    else
      echo "  '$1' is not a regular file"
      echo
    fi
  fi
}

/* heat_equation_2d.c
 * PARALLEL [MPI] C PROGRAM TO SOLVE THE 2 DIMENSIONAL HEAT EQUATION.
 * THE INITIAL TEMPERATURE IS COMPUTED TO BE HIGH IN THE MIDDLE OF THE
 * DOMAIN UNDER CONSIDERATION AND ZERO AT THE BOUNDARIES. THE BOUNDARIES
 * ARE HELD AT ZERO TEMPERATURE THROUGH OUT THE SIMULATION.
 *
 * THE GIVEN GRID IS DECOMPOSED BY THE MASTER AND THEN DISTRIBUTED BY
 * COLUMNS TO WORKERS. A GRID POINT'S CURRENT TEMPERATURE DEPENDS UPON 
 * ITS PREVIOUS TIME STEP VALUE AS WELL AS THE VALUES OF THE NEIGHBORING
 * GRID POINTS. AS SUCH, AT EACH TIME STEP, WORKERS EXCHANGE BORDER/BOUNDARY
 * DATA WITH NEIGHBORS. ONCE ALL THE TIME STEPS ARE COMPLETED, WORKERS
 * SEND THEIR RESULTS TO MASTER.
 *
 * THE PROGRAM GENERATES A DATA FILE THAT CAN BE VISUALIZED WITH THIRD 
 * PARTY PROGRAMS [GNUPLOT, MATLAB, ETC.]
 *
 * TESTED SUCCESSFULLY WITH MPICH2 (1.3.1) COMPILED AGAINST GCC (4.1.2) 
 * IN A LINUX BOX WITH QUAD CORE INTEL XEON PROCESSOR (1.86 GHz) & 4GB OF RAM.
 *
 * ORIGINAL AUTHOR : BLAISE BARNEY; 2009/12/11
 *                   LAWRENCE LIVERMORE NATIONAL LABORATORY
 * FIRST COPIED    : GOWTHAM; Fri, 26 Nov 2010 21:30:30 -0500
 * LAST MODIFIED   : GOWTHAM; Fri, 10 Dec 2010 01:34:52 -0500
 *
 * URL:
 * http://sgowtham.net/blog/2010/12/11/mpi-c-2-dimensional-heat-equation/
 *
 * COMPILATION:
 * mpicc -g -Wall -lm heat_equation_2d.c -o heat_equation_2d.x 
 *
 * EXECUTION:
 * mpirun -np NPROC -machinefile MACHINEFILE ./heat_equation_2d.x
 *
 * NPROC       : NUMBER OF PROCESSORS ALLOCATED TO RUNNING THIS PROGRAM;
 *               NXY [GRID SIZE] MUST BE DIVISIBLE BY [NPROC - 1]
 * MACHINEFILE : FILE LISTING THE HOSTNAMES OF PROCESSORS ALLOCATED TO
 *               RUNNING THIS PROGRAM
 *
 * OUTPUT      : DATA FILE 'heat_equation_2d.dat' WITH THE FOLLOWING
 *               FORMAT
 *
 *               TSTEPS=#TSTEPS
 *               U(x, y) AT t = 0         [NXY x NXY]
 *               U(x, y) AT t = 1         [NXY x NXY]
 *               ...
 *               U(x, y) AT t = TSTEP     [NXY x NXY]
 *
 *               TOTAL NUMBER OF LINES IN 'heat_equation_2d.dat'
 *               (NXY * (TSTEPS + 1)) + 1
 *
*/
 
/* STANDARD HEADERS AND DEFINITIONS 
 * REFERENCE: http://en.wikipedia.org/wiki/C_standard_library
*/
#include <stdio.h>  /* Core input/output operations                         */
#include <stdlib.h> /* Conversions, random numbers, memory allocation, etc. */
#include <math.h>   /* Common mathematical functions                        */
#include <time.h>   /* Converting between various date/time formats         */
#include <mpi.h>    /* MPI functionality                                    */
 
#define NXY          20          /* Number of (x or y) grids in U(x,y) */
                                 /* NXY must be divisible by NPROC - 1 */
#define TSTEPS      500          /* Number of time steps               */
#define MASTER        0          /* Process ID for MASTER              */
#define BEGIN         1          /* Message tag                        */
#define DONE          2          /* Message tag                        */
#define LNEIGHBOR     3          /* Left neighbor tag                  */
#define RNEIGHBOR     4          /* Right neigbor tag                  */
#define NONE          5          /* Indicates no neighbor              */
 
struct ThermalDiffusivity {      /* Parameters used in difference      */
  double cx;                     /* equations - refer to class         */
  double cy;                     /* notes. Physically, these refer to  */
} parameters = {0.25, 0.25};     /* thermal diffusivity                */
 
 
/* MAIN PROGRAM BEGINS */
int main (int argc, char *argv[]) {
 
  /* VARIABLE DECLARATION & INITIALIZATION */
  double U[NXY][NXY],      /* 2D array to hold current values        */
         Unew[NXY][NXY],   /* 2D array to hold new values            */
         start_time,       /* Wall clock - start time                */
         end_time;         /* Wall clock - end time                  */
 
  int    proc_id,          /* Process ID                             */
         n_procs,          /* Number of processors                   */
         n_workers,        /* Number of WORKERS [nprocs - 1]         */
         cols_per_worker,  /* Number of columns of U(x,y) per WORKER */ 
         offset,           /* Offset                                 */
         source,           /* Source for a message                   */
         destination,      /* Destination for a message              */
         lneighbor,        /* Process ID of left neighbor            */
         rneighbor,        /* Process ID of right neighbor           */
         start,            /* Starting # for columns in WORKERS      */
         end,              /* Ending # for columns in WORKERS        */
         i,                /* Dummy/Running index                    */
         j,                /* Dummy/Running index                    */
         h;                /* Dummy/Running index for TSTEPS         */
 
  FILE   *output;          /* File pointer                           */
 
  MPI_Status status;       /* MPI structure containing return codes
                              for message passing operations         */
 
  MPI_Datatype cvector;    /* A custom MPI data type defined to 
                              contain column vectors                 */
 
 
  /* INITIALIZE MPI */
  MPI_Init(&argc, &argv);
 
  /* GET THE PROCESSOR ID AND NUMBER OF PROCESSORS */
  MPI_Comm_rank(MPI_COMM_WORLD, &proc_id);
  MPI_Comm_size(MPI_COMM_WORLD, &n_procs);
 
  /* NUMBER OF WORKERS [NPROC - 1] */
  n_workers = n_procs - 1;
 
  /* MPI DATA TYPE [CUSTOM] - TO SEND BLOCKS OF U(x,y) TO WORKERS AS COLUMNS
   * THANKS TO DR. STEVEN SEIDEL [http://www.cs.mtu.edu/~steve/] 
   * FOR INFORMING/TEACHING ME THE POSSIBILITY OF DEFINING CUSTOM DATA TYPES 
   * IN MPI, DURING A PREVIOUS DISCUSSION ABOUT MATRIX MULTIPILICATION
  */
  MPI_Type_vector(NXY, 1, NXY, MPI_DOUBLE, &cvector);
  MPI_Type_commit (&cvector);
 
  /* IF MASTER, THEN DO THE FOLLOWING:
   * PRINT GENERAL INFORMATION ABOUT THE PROGRAM
   * CHECK IF NPROCS MEETS THE PROGRAM REQUIREMENTS
   * POPULATE THE U(x,y) TO SIMULATE INITIAL TEMPERATURE DISTRIBUTION
   * SEND RELEVANT INFORMATION ABOUT NEIGHBORS, OF U(x,y) TO WORKERS
   * RECEIVE RELAVANT INFORMATION FROM WORKERS, AT EVERY TIME STEP
   * DISPLAY U(x,y) AT INITIAL AND FINAL STEPS
   * PRINT U(x,y) AT EVERY TIME STEP SO THAT IT CAN BE PLOTTED/ANIMATED
  */
  if (proc_id == MASTER) {
 
    printf("\n  2D Heat Equation [MPI/C]\n\n");
    printf("    Number of x-grids        : %d\n", NXY);
    printf("    Number of y-grids        : %d\n", NXY);
    printf("    Number of processors     : %d\n", n_procs);
    printf("    Number of workers        : %d\n", n_workers);
    printf("    Number of time steps     : %d\n", TSTEPS);
    printf("    Thermal diffusivity (Cx) : %4.3lf\n", parameters.cx);
    printf("    Thermal diffusivity (Cy) : %4.3lf\n\n", parameters.cy);
 
    /* CHECK IF NXY IS DIVISIBLE BY [NPROC + 1]
     * IF NOT, PRINT AN ERROR MESSAGE AND QUIT THE PROGRAM 
    */
    if (NXY%(n_procs - 1) != 0) {
      printf("    ERROR:\n");
      printf("    NXY not divisible by (NPROC + 1)\n\n");
 
      exit(1);
    }
 
    /* OPEN THE FILE FOR WRITING [OVER-WRITE, IF EXISTS]
     * PRINT ERROR MESSAGE, IF ANY & TERMINATE THE PROGRAM
    */
    if(!(output = fopen("heat_equation_2d.dat", "w"))) {
      fprintf(stderr, "\n\n    ERROR:\n");
      fprintf(stderr, "    Unable to open the output file\n\n");
 
      exit(1);
    }
 
    /* START THE CLOCK */
    start_time = MPI_Wtime();
 
    /* INITIALIZE THE GRID */
    printf("    Temperature distribution (at time t=0)\n\n");
 
    /* HEADER LINE INDICATING TOTAL NUMBER OF TIME STEPS
     * NEEDED BY MATLAB (&/OR OTHER) FOR PLOTTING
    */ 
    fprintf(output, "TSTEPS=%d\n", TSTEPS + 1);
 
    /* POPULATE THE ARRAY, U(x,y) 
     * BORDER ELEMENTS ARE ALL ZERO & HIGH VALUE IN THE MIDDLE
     * PRINT THE ARRAY - TO THE SCREEN AND TO THE FILE
    */
    for (i = 0; i < NXY; i++) {
      for (j = 0; j < NXY; j++) {
        U[i][j] = 100 * i * (NXY - i - 1) * j * (NXY - j - 1);
        printf("    %08.0lf", U[i][j]);
        fprintf(output, "%012.4lf  ", U[i][j]);
      }
      printf("\n");
      fprintf(output, "\n");
    }
 
    /* NUMBER OF COLUMNS PER WORKER 
     * IT'S IMPORTANT TO ALLOCATE EQUAL NUMBER OF COLUMNS TO
     * EACH WORKER - ELSE, SOME MIGHT FINISH FASTER WITHOUT
     * ADDITIONAL WORK
     */
    cols_per_worker = NXY/n_workers;
 
    /* INITIALIZE offset */
    offset = 0;
 
    for (i = 1; i <= n_workers; i++) {
 
      /* INFORM EACH WORKER OF ITS NEIGHBORS */
      if (i == 1) {
        lneighbor = NONE;
      } else {
        lneighbor = i - 1;
      }
 
      if (i == n_workers) {
        rneighbor = NONE;
      } else {
        rneighbor = i + 1;
      }
 
      /* DESTINATION PROCESSOR */
      destination = i;
 
      /* SEND INFORMATION TO EACH WORKER
       * OFFSET
       * NUMBER OF COLUMNS EACH WORKER HAS TO WORK WITH 
       * LEFT & RIGHT NEIGHBORS FOR EACH WORKER
       * RELEVANT PORTION OF U(x,y) TO EACH WORKER
      */
      MPI_Send(&offset,    1, MPI_INT, destination, BEGIN, MPI_COMM_WORLD);
      MPI_Send(&cols_per_worker, 1, MPI_INT, destination, BEGIN, MPI_COMM_WORLD);
      MPI_Send(&lneighbor, 1, MPI_INT, destination, BEGIN, MPI_COMM_WORLD);
      MPI_Send(&rneighbor, 1, MPI_INT, destination, BEGIN, MPI_COMM_WORLD);
 
      for(j=0; j < cols_per_worker; j++) {
        MPI_Send(&U[0][offset+j], 1, cvector, destination, BEGIN, MPI_COMM_WORLD);
      }
 
      /* INCREMENT THE offset */
      offset = offset + cols_per_worker;
    }
 
    /* RECEIVE RELEVANT INFORMATION FROM WORKERS  FOR EVERY TIME STEP */
    for(h = 1; h <= TSTEPS; h++) {
 
      for(i = 1; i <= n_workers; i++) {
 
        /* SOURCE PROCESSOR */
        source = i;
 
        MPI_Recv(&offset, 1, MPI_INT, source, DONE, MPI_COMM_WORLD, &status); 
        MPI_Recv(&cols_per_worker, 1, MPI_INT, source, DONE, MPI_COMM_WORLD, &status); 
 
        for(j=0; j < cols_per_worker; j++) {
          MPI_Recv(&U[0][offset+j], 1, cvector, source, h*DONE, MPI_COMM_WORLD, &status);
        }
 
      }
 
      /* PRINT U(x,y), THE TEMPERATURE DISTRIBUTION AFTER EVERY TIME STEP TO THE FILE */
      for (i = 0; i < NXY; i++) {
        for (j = 0; j < NXY; j++) {
          fprintf(output, "%012.4lf  ", U[i][j]);
        }
        fprintf(output, "\n");
      }
 
    }
 
    /* CLOSE THE FILE */
    fclose(output);
 
    /* PRINT U(x,y), THE TEMPERATURE DISTRIBUTION AFTER 'TSTEPS' STEPS TO THE SCREEN */
    printf("\n\n    Temperature distribution (after %d time steps)\n\n", h-1);
    for (i = 0; i < NXY; i++) {
      for (j = 0; j < NXY; j++) {
        printf("    %08.0lf", U[i][j]);
      }
      printf("\n");
    }
 
    printf("\n\n");
 
    /* STOP THE CLOCK */
    end_time = MPI_Wtime();
 
    /* PRINT TIMING INFORMATION */
    printf("    Time elapsed (sec)   : %6.4f\n\n", end_time - start_time);
 
  } /* MASTER LOOP ENDS */
 
 
  /* IF WORKER, THEN DO THE FOLLOWING:
   * INITIALIZE U(x,y) & Unew(x,y) TO ZERO
   * RECEIVE RELEVANT INFORMATION FROM MASTER
   * CALCULATE U(x, y, t+1) BY COMMUNICATING APPROPRIATELY WITH NEIGHBORING WORKERS
   * SEND RELEVANT INFORMATION TO MASTER 
  */
  if (proc_id != MASTER) {
 
    /* INITIALIZE ALL ELEMENTS OF U(x,y) & Unew(x,y) TO ZERO */
    for(i = 0; i < NXY; i++) {
      for(j = 0; j < NXY; j++) {
        U[i][j] = 0.0;
        Unew[i][j] = 0.0;
      }
    }
 
    /* RECEIVE THE COLUMNS, NEIGHBORS AND GRID INFORMATION FROM MASTER */
    MPI_Recv(&offset,    1, MPI_INT, MASTER, BEGIN, MPI_COMM_WORLD, &status);
    MPI_Recv(&cols_per_worker, 1, MPI_INT, MASTER, BEGIN, MPI_COMM_WORLD, &status);
    MPI_Recv(&lneighbor, 1, MPI_INT, MASTER, BEGIN, MPI_COMM_WORLD, &status);
    MPI_Recv(&rneighbor, 1, MPI_INT, MASTER, BEGIN, MPI_COMM_WORLD, &status);
 
    for(j=0; j < cols_per_worker; j++) {
      MPI_Recv(&U[0][offset+j], 1, cvector, MASTER, BEGIN, MPI_COMM_WORLD, &status);
    }
 
    /* FOR DEBUGGING PURPOSES ONLY 
     * RUN WITH NPROC = 3 WITH NXY = 16
     * THERE SHOULD BE TWO BLOCKS OF COMPLEMENTARY MATRICES
 
    if (proc_id == 1) {
    printf("\n");
      for (i = 0; i < NXY; i++) {
        for (j = 0; j < cols_per_worker; j++) {
          printf(" %08.0lf", U[0][i][j]);
        }
        printf("\n");
      }
    }
 
    if (proc_id == 2) {
    printf("\n");
      for (i = 0; i < NXY; i++) {
        for (j = cols_per_worker; j < 2*cols_per_worker; j++) {
          printf(" %08.0lf", U[0][i][j]);
        }
        printf("\n");
      }
    }
    */ 
 
 
    /* DETERMINE BORDER ELEMENTS - FIRST & LAST COLUMNS NEED EXTRA CARE:
     * ROW 0 CANNOT EXCHANGE INFORMATION WITH 0-1
     * ROW N CANNOT EXCHANGE INFORMATION WITH N+1
    */
    if (offset == 0) {
      /* DO NOT INCLUDE ZEROTH COLUMN */
      start = 1;
    } else {
      start = offset;
    }
 
    if ((offset + cols_per_worker) == NXY) {
      /* DO NOT INCLUDE THE LAST COLUMN */
      end = offset + cols_per_worker - 2;
    } else {
      end = offset + cols_per_worker - 1;
    }
 
    /* PERFORM TIME STEP [TSTEPS] ITERATIONS.
     * MUST COMMUNICATE BORDER COLUMNS WITH NEIGHBORS.
     * IF IT'S THE FIRST OR THE LAST COLUMN, THEN THE COMMUNICATION TAKES 
     * PLACE ONLY WITH ONE NEIGHBOR
    */
    for(h = 1; h <= TSTEPS; h++) {
      if (lneighbor != NONE) {
        MPI_Send(&U[0][offset], 1, cvector, lneighbor, RNEIGHBOR, MPI_COMM_WORLD);
 
        MPI_Recv(&U[0][offset-1], 1, cvector, lneighbor, LNEIGHBOR, MPI_COMM_WORLD, 
                 &status);
      }
 
      if (rneighbor != NONE) {
        MPI_Send(&U[0][offset+cols_per_worker-1], 1, cvector, rneighbor,
                 LNEIGHBOR, MPI_COMM_WORLD);
 
        MPI_Recv(&U[0][offset+cols_per_worker], 1, cvector, rneighbor,
                 RNEIGHBOR, MPI_COMM_WORLD, &status);
      }
 
      /* UPDATE THE VALUE OF GRID POINTS 
       * REFER TO THE SLIDES FROM WEEK #14 [PART #02]
      */
      for(i = 1; i <= NXY-2; i++) {
        for(j = start; j <= end; j++) {
          Unew[i][j] = U[i][j] + 
                       parameters.cx * (U[i-1][j] + U[i+1][j] - 2 * (U[i][j])) +
                       parameters.cy * (U[i][j-1] + U[i][j+1] - 2 * (U[i][j]));
        }
      }
 
      /* SET U(x,y) TO Unew(x,y) */
      for(i = 1; i <= NXY-2; i++) {
        for(j = start; j <= end; j++) {
          U[i][j] = Unew[i][j];
        }
      }
 
      /* SEND RELEVANT INFORMATION TO MASTER */
      MPI_Send(&offset, 1, MPI_INT, MASTER, DONE, MPI_COMM_WORLD);
      MPI_Send(&cols_per_worker, 1, MPI_INT, MASTER, DONE, MPI_COMM_WORLD);
 
      for(j=0; j < cols_per_worker; j++) {
        MPI_Send(&U[0][offset+j], 1, cvector, MASTER, h*DONE, MPI_COMM_WORLD);
      }
    }
 
  } /* WORKER LOOP ENDS */
 
 
  /* FINALIZE MPI */
  MPI_Finalize();
 
  /* INDICATE THE TERMINATION OF THE PROGRAM */
  return 0;
 
} /* MAIN PROGRAM ENDS */

% heat_equation_2d.m
% MATLAB 'SCRIPT m' FILE TO READ THE FILE 'heat_equation_2d.dat', 
% ONE DATA SET AT A TIME AND PLOT IT REPEATEDLY TO SIMULATE AN ANIMATION.
%
% TESTED SUCCESSFULLY WITH MATLAB (v7.8.0.347 R2009a; STUDENT VERSION) IN A MACBOOK PRO 
% (OS X 10.6.5) WITH INTEL CORE 2 DUO PROCESSOR (2.4 GHz) & 4GB OF RAM.
%
% FIRST WRITTEN: GOWTHAM; Fri, 10 Dec 2010 23:12:18 -0500
% LAST MODIFIED: GOWTHAM; Sun, 12 Dec 2010 09:34:23 -0500
%
% INPUT:
% 'heat_equation_2d.dat' PRODUCED BY RUNNING 'heat_equation_2d.c'
% AND IT HAS THE FOLLOWING FORMAT:
% 
% TSTEPS=# 
% U(x,y) AT t = 0         [NXY x NXY]
% U(x,y) AT t = 1         [NXY x NXY]
% U(x,y) AT t = 2         [NXY x NXY]
% ...
% U(x,y) AT t = TSTEPS    [NXY x NXY]
%
% FOR AN EXPLANATION OF 'NXY', 'TSTEPS', ETC., PLEASE REFER TO 'heat_equation_2d.c'.
% 
% OUTPUT:
% IF 'mencoder' [AND OTHER REQUIRED UTILITIES] IS AVAILABLE, THIS SCRIP WILL PRODUCE 
% 'heat_equation_2d.avi'. IF NOT, 'New Screen Recording' OPTION MAY BE USED IN
% 'QuickTime Player' TO CREATE THE ANIMATION.
%
 
% CLEAR THE PREVIOUSLY SET VARIABLES
clear
 
% CLEAR THE COMMAND WINDOW
clc
 
% PAUSE FOR 15 SECONDS
% USEFUL WHEN 'mencoder' IS NOT AVAILABLE AS THIS WILL GIVE JUST ENOUGH TIME TO HIDE 
% UNWANTED SCREENS / WINDOWS AND START RECORDING VIA QuickTime Player.
% COMMENT IT OUT IF NOT NEEDED.
pause(15);
 
% OPEN THE DATA FILE FOR READING. 
% SAME BASENAME WILL BE USED FOR THE ANIMATION FILE
filename   = 'heat_equation_2d';
filehandle = fopen(filename '.dat', 'r');
 
% COUNT THE NUMBER OF TIME STEPS - GIVEN IN THE FIRST LINE
TSTEPS = fscanf(filehandle, 'TSTEPS=%d\n', 1);
 
% VARIABLE DECLARATION AND INITIALIZATION
% THIS IS THE NUMBER OF ROWS & COLUMNS IN EACH BLOCK OF DATA
NXY = 20;
 
% x & y GRIDS FOR THE MESH [3D] PLOT
x = 1:1:NXY;
y = 1:1:NXY;
 
% GENERATE X & Y ARRAYS FOR 3D PLOT
% TRANSFORMS THE DOMAIN SPECIFIED BY VECTORS x & y INTO ARRAYS X and Y, 
% WHICH CAN BE USED TO EVALUATE FUNCTIONS OF TWO VARIABLES AND 3D
% MESH/SURFACE PLOTS. THE ROWS OF THE OUTPUT ARRAY X ARE COPIES OF THE
% VECTOR x; COLUMNS OF THE OUTPUT ARRAY Y ARE COPIES OF THE VECTOR y.
% http://www.mathworks.com/help/techdoc/ref/meshgrid.html
[X, Y] = meshgrid(x,y);
 
% LOOP THROUGH THE DATA FILE TO READ 'NXY x NXY' ELEMENTS AT ONCE
% AND IMPORT THEM INTO 'TSTEPS' NUMBER OF MATRICES OF ORDER NXY.
for i = 1:TSTEPS
 
  % INITIALIZE ALL ELEMENTS OF MATRIX [OF ORDER NXY] TO ZERO
  Temperature(i).Z = zeros(NXY, NXY);
 
  % SCAN THE DATA FILE, READ 'NXY x NXY' ELEMENTS, TREAT THEM
  % AS DOUBLE PRECISION AND STORE THEM IN THE MATRIX.
  % SYNTAX:
  % Z = fscanf(filehandle, 'FORMAT', [COLS, ROWS]);
  Temperature(i).Z = fscanf(filehandle, '%f', [NXY, NXY]);
 
  % PLOT THE DATA IN THE ABOVE MATRIX AS A FUNCTION OF X & Y
  figure1 = figure(1);
  mesh(X, Y, Temperature(i).Z)
 
  % HANDLE FOR AXIS PROPERTY SO THAT IT CAN BE MODIFIED TO
  % FIT OUR REQUIREMENS
  ap = gca;
 
  % MODIFY CERTAIN AXIS PROPERTIES APPROPRIATELY
  set(ap, 'XLimMode', 'manual', 'YLimMode', 'manual', ...
          'ZLimMode', 'manual', ...
          'Xlim', [0 20], 'Ylim', [0 20], 'Zlim', [0 1000000], ...
          'FontSize', 14)
 
  % CHANGE THE COLORMAP FROM 'default' TO 'hsv'
  % THE hsv COLORMAP IS CREATED WITH 65536 COLORS
  % http://www.mathworks.com/help/techdoc/ref/colormap.html
  colormap(hsv(65536))
 
  % DISPLAY A COLOR BAR THAT WILL SERVE AS A LEGEND
  colorbar
 
  % AXES LABELS FOR THE PLOT
  xlabel('Grid points along x-axis');
  ylabel('Grid points along y-axis');
  zlabel('U(x, y), Temperature distribution');
 
  % TITLE FOR THE PLOT
  title(['TSTEP= ' num2str(i)]);
 
  % CAPTURE MOVIE FRAME AS AN ARRAY FOR LATER USE.
  % COMMENT THIS LINE IF 'mencoder' IS NOT AVAILABLE.
  % http://www.mathworks.com/help/techdoc/ref/getframe.html
  M(i) = getframe;
 
  % TIME LAG BETWEEN SUCCESSIVE PLOTS
  pause(0.00001);
 
end 
% LOOP THROUGH DATA FILE ENDS
 
% CLOSE THE DATA FILE
fclose(datafilename);
 
 
% CREATE AN ANIMATION USING THE MOVIE FRAMES.
% COMMENT THIS SECTION IF 'mencoder' IS NOT AVAILABLE
 
% CREATE AN AVI [AUDIO/VIDEO INTERLEAVED] FILE FROM THE MOVIE FRAMES ARRAY
% 'None' IS THE ONLY COMPRESSION AVAILABLE OPTION ON UNIX (LIKE) OS.
% http://www.mathworks.com/help/techdoc/ref/movie2avi.html
movie2avi(M, [filename '.avi'], 'compression', 'None', 'fps', 25);
 
% USE 'mencoder' TO COMPRESS THE MOVIE SO THAT IT CAN BE PLAYED ON 
% QuickTime Player OR SOME OTHER SUCH APPLICATION.
% USE eval TO RUN THE MAC/LINUX COMMAND
% http://www.mplayerhq.hu/DOCS/HTML/en/menc-feat-selecting-codec.html
avicompression = ['!mencoder -oac copy -ovc xvid -xvidencopts bitrate=1000 ' filename '.avi -o ' filename '_compressed.avi'];
eval(avicompression);
 
% RENAME THE COMPRESSED AVI
% USE eval TO RUN THE MAC/LINUX COMMAND
avirename = ['!mv ' filename '_compressed.avi ' filename '.avi'];
eval(avirename);

/* pi_montecarlo.c
 * PARALLEL [MPI] C PROGRAM TO COMPUTE THE VALUE OF 'PI' USING MONTE CARLO 
 * [DARTBOARD ALGORITHM] METHOD. MASTER COLLECTS THE RESULTS FROM THE WORKERS 
 * USING MPI_Reduce AND AVERAGES THEM.
 *
 * TESTED SUCCESSFULLY WITH MPICH2 (1.3.1) COMPILED AGAINST GCC (4.1.2) 
 * IN A LINUX BOX WITH QUAD CORE INTEL XEON PROCESSOR (1.86 GHz) & 4GB OF RAM.
 *
 * FIRST WRITTEN : GOWTHAM; Fri, 19 Nov 2010 01:11:34 -0500
 * LAST MODIFIED : GOWTHAM; Fri, 19 Nov 2010 03:53:31 -0500
 *
 * URL:
 * http://sgowtham.net/blog/2010/12/02/mpi-c-monte-carlo-method-of-finding-pi/ 
 *
 * COMPILATION:
 * mpicc -g -Wall -lm pi_montecarlo.c -o pi_montecarlo.x 
 *
 * EXECUTION:
 * mpirun -np NPROC -machinefile MACHINEFILE ./pi_montecarlo.x
 *
 * NPROC       : NUMBER OF PROCESSORS ALLOCATED TO RUNNING THIS PROGRAM
 * MACHINEFILE : FILE LISTING THE HOSTNAMES OF PROCESSORS ALLOCATED TO
 *               RUNNING THIS PROGRAM
 *
*/
 
 
/* STANDARD HEADERS AND DEFINITIONS 
 * REFERENCE: http://en.wikipedia.org/wiki/C_standard_library
*/
#include <stdio.h>  /* Core input/output operations                         */
#include <stdlib.h> /* Conversions, random numbers, memory allocation, etc. */
#include <math.h>   /* Common mathematical functions                        */
#include <time.h>   /* Converting between various date/time formats         */
#include <mpi.h>    /* MPI functionality                                    */
 
#define MASTER             0   /* Process ID of MASTER                      */
#define PI      3.1415926535   /* Known vaue of PI                          */
#define NDARTS     100000000   /* Number of darts thrown                    */
 
/* FUNCTION 'pseudo_random' BEGINS
 * GIVEN TWO NUMBERS, llimit & ulimit, THIS FUNCTION GENERATES A RANDOM
 * NUMBER BETWEEN llimit & ulimit. SEED FOR rand() COMES FROM THE
 * PARENT FUNCTION, 'pi_dartboard'.
*/
double pseudo_random(double a, double b) {
 
  /* VARIABLE DECLARATION & INITIALIZATION */
  double r;  /* Random number */
 
  /* GENERATE RANDOM NUMBER BETWEEN llimit & ulimit
   * rand() IS USUALLY AN INTEGER & SO IS RAND_MAX
   * (double) rand() and (double) RAND_MAX CONVERTS THEM TO DOUBLE PRECISION
   * USING LINEAR SCALING [REFER TO CLASS NOTES/SLIDES], RANDOM NUMBER IS
   * SCALED TO LIE BETWEEN llimit & ulimit
  */
  r = ((b - a) * ((double) rand()/(double) RAND_MAX)) + a;
 
  /* RETURN THE VALUE OF RANDOM NUMBER
   * INDICATE THE TERMINATION OF THIS MODULE/FUNCTION
  */
  return r;
} /* FUNCTION 'pseudo_random' ENDS */
 
 
/* MAIN PROGRAM BEGINS */
int main (int argc, char *argv[]) {
 
  /* VARIABLE DECLARATION & INITIALIZATION */
  int    proc_id,       /* Process ID                           */
         n_procs,       /* Number of processors                 */
         llimit,        /* Lower limit for random numbers       */
         ulimit,        /* Upper limit for random numbers       */
         n_circle,      /* Number of darts that hit the circle  */
         i;             /* Dummy/Running index                  */
 
  double pi_current,    /* PI calculated by each WORKER         */
         pi_sum,        /* Sum of PI values from each WORKER    */
         x,             /* x coordinate, betwen -1 & +1         */
         y,             /* y coordinate, betwen -1 & +1         */
         z,             /* Sum of x^2 and y^2                   */
         error,         /* Error in calculation of PI           */
         start_time,    /* Wall clock - start time              */
         end_time;      /* Wall clock - end time                */
 
  struct timeval stime;
 
  llimit   = -1;
  ulimit   = 1;
  n_circle = 0;
 
  /* INITIALIZE MPI */
  MPI_Init(&argc, &argv);
 
  /* GET THE PROCESS ID AND NUMBER OF PROCESSORS */
  MPI_Comm_rank(MPI_COMM_WORLD, &proc_id);
  MPI_Comm_size(MPI_COMM_WORLD, &n_procs);
 
  /* IF MASTER, THEN DO THE FOLLOWING:
   * ACCEPT THE VALUE OF NDARTS FROM COMMAND LINE
   * PRINT THE MESSAGE TO THE SCREEN
   * START THE WALL CLOCK
  */ 
  if (proc_id == MASTER) {
    printf("\n  Monte Carlo method of finding PI\n\n");
    printf("    Number of processors : %d\n", n_procs);
    printf("    Number of darts      : %d\n\n", NDARTS);
 
    /* START THE CLOCK */
    start_time = MPI_Wtime();
  }
 
 
  /* ALL PROCESSORS, INCLUDING MASTER, DO THE FOLLOWING:
   * SEED THE RANDOM NUMBER GENERATOR
   * THROW DARTS AT THE BOARD [FOR LOOP]
   *   COORDINATES OF THE DART [x, y] ARE GENERATED AT RANDOM
   *   CHECK IF THE DART LANDED IN THE CIRCLE
   *   IF YES, INCREMENT THE COUNT
   * CALCULATE THE VALUE OF PI
  */
 
  /* SEED FOR RANDOM NUMBER GENERATOR */
  /* RESULTS IN THE FOLLOWING WARNING - MAY BE IGNORED
   * warning: implicit declaration of function ‘gettimeofday’
  */
  gettimeofday(&stime, NULL);
  srand(stime.tv_usec * stime.tv_usec * stime.tv_usec * stime.tv_usec);
 
  /* THROW NDARTS LOOP BEGINS */
  for (i = 1; i <= NDARTS; i++) {
 
    /* GENERATE RANDOM NUMBERS x & y BETWEEN -1 & +1 */
    x = pseudo_random(llimit, ulimit);
    y = pseudo_random(llimit, ulimit);
 
    /* CALCULATE x^2 + y^2 */
    z = pow(x, 2) + pow(y, 2);
 
    /* IF THE DART IS IN THE CIRCLE, INCREMENT n_circle */
    if (z <= 1.0) {
       n_circle++;
    }
 
  } /* THROW NDARTS LOOP ENDS */
 
  /* CALCULATE THE VALUE OF PI */
  pi_current = 4.0 * (double)n_circle/(double)NDARTS;
 
 
  /* USE MPI_Reduce TO SUM VALUES OF pi_current ACROSS ALL WORKERS
   * THIS HAPPENS ONLY ON MASTER
  */ 
  MPI_Reduce(&pi_current, &pi_sum, 1, MPI_DOUBLE, MPI_SUM, MASTER, MPI_COMM_WORLD);
 
 
  /* IF MASTER, THEN DO THE FOLLOWING
   * CALCULATE THE AVERAGE VALUE OF PI 
   * CALCULATE THE ERROR ASSOCIATED WITH THE COMPUTED VALUE OF PI
   * STOP THE WALL CLOCK
   * PRINT THE RESULTS TO THE SCREEN
  */
  if (proc_id == MASTER) {
 
    /* AVERAGE VALUE OF COMPUTED PI */
    pi_sum = pi_sum / n_procs;
 
    /* % ERROR ASSOCIATED WITH COMPUTED VALUE OF PI */
    error = fabs((pi_sum - PI)/PI) * 100;
 
    /* STOP THE CLOCK */
    end_time = MPI_Wtime();
 
    /* PRINT THE RESULTS TO THE SCREEN */
    printf("    Known value of  PI   : %11.10f\n", PI);
    printf("    Average value of PI  : %11.10f\n", pi_sum);
    printf("    Percentage Error     : %10.8f\n", error);
    printf("    Time elapsed (sec)   : %10.8f\n\n", end_time - start_time);
  }
 
  /* FINALIZE MPI */
  MPI_Finalize();
 
  /* INDICATE THE TERMINATION OF THE PROGRAM */
  return 0;
 
} /* MAIN PROGRAM ENDS */

/* matrix_multiply.c
 * PARALLEL [MPI] C PROGRAM TO PERFORM MATRIX MULTIPLICATION. 
 * DISPLAY OF MATRIX ELEMENTS IS SET FOR 'INTEGER-LIKE'. IF [SOME/ALL OF] 
 * THE MATRIX ELEMENTS ARE NON-INTEGERS, MODIFY THE DISPLAY IN PRINTF 
 * STATEMENTS APPROPRIATELY.
 *
 * TESTED SUCCESSFULLY WITH MPICH2 (1.3.1) COMPILED AGAINST GCC (4.1.2) 
 * IN A LINUX BOX WITH QUAD CORE INTEL XEON PROCESSOR (1.86 GHz) & 4GB OF RAM.
 *
 * STAGE #01:
 * SQUARE MATRICES ONLY
 * MATRIX ELEMENTS GENERATED WITHIN THE PROGRAM
 *
 * STAGE #02: (PROPOSED)
 * SQUARE MATRICES ONLY
 * MATRIX ELEMENTS READ FROM EXTERNAL DATA FILES - USEFUL
 * WHEN A THIRD PARTY PROGRAM GENERATES DATA. ALSO REMOVES
 * THE NEED FOR RECOMPILING THE PROGRAM EVERY TIME ORDER OF
 * MATRICES CHANGE. WRITE THE PRODUCT MATRIX TO A FILE.
 *
 * STAGE #03: (PROPOSED)
 * NOT NECESSARILY SQUARE MATRICES, i.e.
 * A(I x J) * B (J x K) = C(I x K)
 * READ MATRICES FROM EXTERNAL DATA FILES
 * CHECK TO MAKE SURE 'COLS(A) = ROWS(B)' BEFORE
 * ATTEMPTING TO PERFORM THE ACTUAL MULTIPLICATION.
 * WRITE THE PRODUCT MATRIX TO A FILE.
 *
 * FIRST WRITTEN: GOWTHAM; Fri, 10 Sep 2010 23:33:28 -0400
 * LAST MODIFIED: GOWTHAM; Sat, 20 Nov 2010 02:19:38 -0500
 *
 * URL:
 * http://sgowtham.net/blog/2010/11/30/mpi-c-matrix-multiplication-order-n/
 *
 * COMPILATION:
 * mpicc -g -Wall -lm matrix_multiply.c -o matrix_multiply.x
 *
 * EXECUTION:
 * mpirun -machinefile MACHINEFILE -np NPROC ./matrix_multiply.x
 *
 * NPROC       : NUMBER OF PROCESSORS ALLOCATED TO RUNNING THIS PROGRAM;
 *               MUST BE LESS THAN OR EQUAL TO THE ORDER OF THE 
 *               MATRICES INVOLVED. 
 * MACHINEFILE : FILE LISTING THE HOSTNAMES OF PROCESSORS ALLOCATED TO
 *               RUNNING THIS PROGRAM
 *
*/
 
 
/* STANDARD HEADERS AND DEFINITIONS 
 * REFERENCE: http://en.wikipedia.org/wiki/C_standard_library
*/
#include <stdio.h>  /* Core input/output operations                         */
#include <stdlib.h> /* Conversions, random numbers, memory allocation, etc. */
#include <math.h>   /* Common mathematical functions                        */
#include <time.h>   /* Converting between various date/time formats         */
#include <mpi.h>    /* MPI functionality                                    */
 
#define MASTER   0  /* Process ID for MASTER                                */
#define N      128  /* Order of the matrices                                */
 
 
/* FUNCTION TO MAP THE PROCESSOR ID
 * 'dest' OPTION IN MPI_Send MUST BE AN INTEGER BETWEEN 0 AND 'n_proc - 1' 
*/
int map_processors(int i, int n_procs) {
  n_procs = n_procs - 1;
  int r = (int) ceil( (double) N / (double) n_procs);
  int processor = i / r;
 
  /* RETURN THE VALUE 'processor + 1' */
  return processor + 1;
}
 
 
/* MAIN PROGRAM BEGINS */
int main(int argc, char **argv) {
 
  /* VARIABLE DECLARATION */
  int    n_procs,        /* Number of processors                   */
         proc_id,        /* Process identifier                     */
         proc_source,    /* Mapped processor ID of the source      */
         proc_dest,      /* Mapped processor ID of the destination */
         proc_current,   /* Mapped processor ID                    */
         i, j, k;        /* Dummy / running indices                */
 
  double A[N][N],        /* Matrix A - N x N                       */
         B[N][N],        /* Matrix B - N x N                       */
         C[N][N],        /* Matrix C - N x N                       */ 
         sum,            /* Cumulated sum of matrix product        */
         Abuf[N],        /* 1D array to hold the value of relevant 
                            portion of A received from MASTER      */
         Cbuf[N];        /* 1D array to hold the value of 'sum' 
                            so that it can be sent to MASTER       */
 
  MPI_Status status;     /* MPI structure containing return codes
                            for message passing operations         */
 
  /* INITIALIZE MPI */
  MPI_Init(&argc, &argv);
 
  /* GET THE PROCESSOR ID AND NUMBER OF PROCESSORS */
  MPI_Comm_rank(MPI_COMM_WORLD, &proc_id);
  MPI_Comm_size(MPI_COMM_WORLD, &n_procs);
 
  /* IF MASTER, THEN DO THE FOLLOWING:
   * POPULATE THE MATRICES A & B
   * SEND FULL MATRIX B TO ALL WORKERS
   * SEND RELEVANT PORTIONS OF MATRIX A TO ALL WORKERS
   * RECEIVE MATRIX C FROM WORKERS
   * DISPLAY MATRIX C
  */
  if (proc_id == MASTER) {
 
    /* POPULATE MATRIX A */
    printf("\n  Matrix A:\n\n");
    for (i = 0; i < N; i++) {
      for (j = 0; j < N; j++) {
        /* EACH MATRIX ELEMENT IS THE SUM OF INDICES */
        A[i][j] = i + j;
        printf(" %4.0lf", A[i][j]);
      }
      printf("\n");
    }
 
    /* POPULATE MATRIX B */
    printf("\n  Matrix B:\n\n");
    for (i = 0; i < N; i++) {
      for (j = 0; j < N; j++) {
        /* EACH MATRIX ELEMENT IS THE PRODUCT OF INDICES */
        B[i][j] = i * j;
        printf(" %4.0lf", B[i][j]);
      }
      printf("\n");
    }
 
    /* CONVERT MATRIX B INTO 1D BUFFERS;
     * SEND ALL THOSE 1D BUFFERS TO ALL WORKERS 
    */
    for (i = 1; i < n_procs; i++) {
      for (j = 0; j < N; j++) {
        /* MPI_Send(buf, count, datatype, dest, tag, comm) */
        MPI_Send(&B[j], N, MPI_DOUBLE, i, j + 1000, MPI_COMM_WORLD);
      }
    }
 
    /* SEND RELEVANT PORTIONS OF A [SPLIT ROW-WISE] TO ALL WORKERS */
    for (i = 0; i < N; i++) {
 
      /* ID OF THE PROCESSOR THAT'S RECEIVING THE INFORMATION (dest) */
      proc_dest = map_processors(i, n_procs);
 
      /* MPI_Send(buf, count, datatype, dest, tag, comm) */
      MPI_Send(&A[i], N, MPI_DOUBLE, proc_dest, i + 10000, MPI_COMM_WORLD);
    }
 
    /* RECEIVE RESULT FROM WORKERS */
    for (i = 0; i < N; i++) {
 
      /* ID OF THE PROCESSOR THAT'S SENDING THE INFORMATION (source) */
      proc_source = map_processors(i, n_procs);
 
      /* MPI_Recv(buf, count, datatype, source, tag, comm, status) */
      MPI_Recv(&C[i], N, MPI_DOUBLE, proc_source, i, MPI_COMM_WORLD, &status);
    }
 
    /* PRINT MATRIX C */
    printf("\n  Matrix C:\n\n");
    for (i = 0; i < N; i++) {
      for (j = 0; j < N; j++) {
        printf(" %4.0lf", C[i][j]);
      }
      printf("\n");
    }
    printf("\n");
 
  } /* MASTER LOOP ENDS */
 
 
 
  /* IF WORKER, THEN DO THE FOLLOWING:
   * RECEIVE ENTIRE MATRIX B FROM MASTER
   * RECEIVE RELEVANT PORTION OF MATRIX A FROM MASTER
   * PERFORM RELEVANT PORTION OF A * B CALCULATION
   * SEND RELEVANT PORTION OF MATRIX C TO MASTER 
  */
  if (proc_id > MASTER) {
 
    /* RECEIVE THE ENTIRE MATRIX B FROM MASTER AS A SET OF 1D BUFFERS */
    /* MPI_Recv(buf, count, datatype, source, tag, comm, status) */
    for (i = 0; i < N; i++) {
      MPI_Recv(&B[i], N, MPI_DOUBLE, 0, i + 1000, MPI_COMM_WORLD, &status);
    }
 
    /* FOR LOOP - MATRIX MULTIPLICATION - BEGINS */
    for (i = 0; i < N; i++) {
 
      /* ID OF THE PROCESSOR THAT'S SENDING THE INFORMATION (source) */
      proc_current = map_processors(i, n_procs);
 
      /* IF LOOP - CHECK CURRENT PROCESSOR ID - BEGINS */
      if (proc_current == proc_id) {
 
        /* RECEIVE RELEVANT PORTIONS OF A [SPLIT ROW-WISE] FROM MASTER */
        MPI_Recv(&Abuf, N, MPI_DOUBLE, 0, i + 10000, MPI_COMM_WORLD, &status);
 
        for (j = 0; j < N; j++) {
 
          /* sum NEEDS TO BE SET TO ZERO FOR EVERY VALUE OF j */
          sum = 0;
 
          /* CALCULATE THE sum, CUMULATIVE SUM OF PRODUCT OF 
           * Abuf[i] & B[j][k]
          */
          for (k = 0; k < N; k++) {
            sum = sum + (Abuf[k] * B[k][j]);
          }
 
          /* ASSIGN THE VALUE OF 'sum' to Cbuf[j] SO THAT MPI_Send CAN 
           * SEND IT TO MASTER
          */ 
          Cbuf[j] = sum;
        }
 
        /* SEND Cbuf[j] TO MASTER */
        MPI_Send(&Cbuf, N, MPI_DOUBLE, 0, i, MPI_COMM_WORLD);
 
      } /* IF LOOP - CHECK CURRENT PROCESSOR ID - ENDS */
 
    } /* FOR LOOP - MATRIX MULTIPLICATION - ENDS */
 
  } /* WORKER LOOP ENDS */
 
  /* FINALIZE MPI */
  MPI_Finalize();
 
  /* INDICATE THE TERMINATION OF THE PROGRAM */
  return 0;
 
} /* MAIN PROGRAM ENDS */

/* send_receive_advanced.c
 * PARALLEL [MPI] C PROGRAM TO DEMONSTRATE MPI_Send & MPI_Recv FUNCTIONS.
 * MASTER [proc_id = 0] SENDS SOME DATA TO A WORKER [proc_id = 1].
 * WORKER PERFORMS SOME MATHEMATICAL OPERATION AND RETURNS THE
 * 'NEW INFORMATION' TO MASTER.
 *
 * TESTED SUCCESSFULLY WITH MPICH2 (1.3.1) COMPILED AGAINST GCC (4.1.2) 
 * IN A LINUX BOX WITH QUAD CORE INTEL XEON PROCESSOR (1.86 GHz) & 4GB OF RAM.
 *
 * FIRST WRITTEN: GOWTHAM; Sat, 27 Nov 2010 17:10:10 -0500
 * LAST MODIFIED: GOWTHAM; Sat, 27 Nov 2010 18:15:23 -0500
 *
 * URL:
 * http://sgowtham.net/blog/2010/11/28/mpi-c-an-advanced-send-receive/
 *
 * COMPILATION:
 * mpicc -g -Wall -lm send_receive_advanced.c -o send_receive_advanced.x
 *
 * EXECUTION:
 * mpirun -machinefile MACHINEFILE -np NPROC ./send_receive_advanced.x
 *
 * NPROC       : NUMBER OF PROCESSORS ALLOCATED TO RUNNING THIS PROGRAM;
 *               MUST BE EQUAL TO 2
 * MACHINEFILE : FILE LISTING THE HOSTNAMES OF PROCESSORS ALLOCATED TO
 *               RUNNING THIS PROGRAM
 *
*/
 
/* STANDARD HEADERS AND DEFINITIONS 
 * REFERENCE: http://en.wikipedia.org/wiki/C_standard_library
*/
#include <stdio.h>  /* Core input/output operations                         */
#include <stdlib.h> /* Conversions, random numbers, memory allocation, etc. */
#include <math.h>   /* Common mathematical functions                        */
#include <time.h>   /* Converting between various date/time formats         */
#include <mpi.h>    /* MPI functionality                                    */
 
#define MASTER  0   /* Process ID for MASTER                                */
#define WORKER  1   /* Process ID for WORKER                                */
#define N      10   /* Array size                                           */
 
/* MAIN PROGRAM BEGINS */
int main(int argc, char **argv) {
 
  /* VARIABLE DECLARATION */
  int    proc_id,       /* Process identifier                    */
         n_procs,       /* Number of processors                  */
         i;             /* Dummy/Running index                   */
 
  double x[N],          /* 1D array of size N
                           Information sent from MASTER
                           Information received by WORKER        */
         y[N];          /* 1D array of size N
                           Information sent from WORKER
                           Information received by MASTER        */
 
  MPI_Status status;    /* MPI structure containing return codes
                           for message passing operations        */
 
  /* INITIALIZE MPI */
  MPI_Init(&argc, &argv);
 
  /* GET THE PROCESS ID AND NUMBER OF PROCESSORS */
  MPI_Comm_rank(MPI_COMM_WORLD, &proc_id);
  MPI_Comm_size(MPI_COMM_WORLD, &n_procs);
 
  /* IF MASTER, THEN DO THE FOLLOWING:
   * POPULATE x[N]
   * SEND x[N] TO WORKER 
   * RECEIVE y[N] FROM WORKER
   * DISPLAY y[N]
  */
  if (proc_id == MASTER) {
 
    /* POPULATE x[N] - EACH ARRAY ELEMENT IS JUST THE INDEX */
    for (i=0; i < N; i++) {
      x[i] = i;
    }
 
    /* SEND x[N] TO WORKER */
    /* MPI_Send(buf, count, datatype, dest, tag, comm) */
    printf("\n  Sending x[N] to WORKER [proc_id = 1] with TAG = 0\n");
    MPI_Send(x, N, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD);
 
    /* RECEIVE y[N] FROM WORKER */
    /* MPI_Recv(buf, count, datatype, source, tag, comm, status) */
    printf("\n  Receiving y[N] from WORKER [proc_id = 1] with TAG = 1\n");
    MPI_Recv(y, N, MPI_DOUBLE, 1, 1, MPI_COMM_WORLD, &status);
 
    /* DISPLAY y[N] */
    for (i=0; i < N; i++) {
      printf("    y[%d] = %2.0lf\n", i, y[i]);
    }
 
  } /* MASTER LOOP ENDS */
 
 
  /* IF WORKER, THEN DO THE FOLLOWING:
   * RECEIVE x[N] FROM MASTER 
   * CREATE y[N]
   * SEND y[N] TO MASTER
  */
  if (proc_id == WORKER) {
 
    /* RECEIVE x[N] FROM MASTER */
    printf("\n  Receiving x[N] from MASTER [proc_id = 0] with TAG = 0\n");
    MPI_Recv(x, N, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &status);
 
    /* CREATE A NEW ARRAY y[N]
     * A SIMPLE MATHEMATICAL MANIPULATION 
     * TAKE THE ELEMENTS OF x[N] AND SQUARE THEM
    */
    for (i=0; i < N; i++) {
      y[i] = x[i] * x[i];
    }
 
    /* SEND y[N] TO MASTER */
    printf("\n  Sending y[N] to MASTER [proc_id = 0] with TAG = 1\n");
    MPI_Send(y, N, MPI_DOUBLE, 0, 1, MPI_COMM_WORLD);
 
  } /* WORKER LOOP ENDS */
 
  /* FINALIZE MPI */
  MPI_Finalize();
 
  /* INDICATE THE TERMINATION OF THE PROGRAM */
  return 0;
 
} /* MAIN PROGRAM ENDS */

/* send_receive_simple.c
 * PARALLEL [MPI] C PROGRAM TO DEMONSTRATE MPI_Send & MPI_Recv FUNCTIONS.
 * MASTER [proc_id = 0] SENDS SOME DATA TO A WORKER [proc_id = 1].  
 * WORKER DISPLAYS THE DATA RECEIVED. 
 *
 * TESTED SUCCESSFULLY WITH MPICH2 (1.3.1) COMPILED AGAINST GCC (4.1.2) 
 * IN A LINUX BOX WITH QUAD CORE INTEL XEON PROCESSOR (1.86 GHz) & 4GB OF RAM.
 *
 * FIRST WRITTEN: GOWTHAM; Sat, 27 Nov 2010 16:01:01 -0500
 * LAST MODIFIED: GOWTHAM; Sat, 27 Nov 2010 16:49:11 -0500
 *
 * URL:
 * http://sgowtham.net/blog/2010/11/28/mpi-c-a-simple-send-receive/
 *
 * COMPILATION:
 * mpicc -g -Wall -lm send_receive_simple.c -o send_receive_simple.x
 *
 * EXECUTION:
 * mpirun -machinefile MACHINEFILE -np NPROC ./send_receive_simple.x
 *
 * NPROC       : NUMBER OF PROCESSORS ALLOCATED TO RUNNING THIS PROGRAM;
 *               MUST BE EQUAL TO 2
 * MACHINEFILE : FILE LISTING THE HOSTNAMES OF PROCESSORS ALLOCATED TO
 *               RUNNING THIS PROGRAM
 *
*/
 
/* STANDARD HEADERS AND DEFINITIONS 
 * REFERENCE: http://en.wikipedia.org/wiki/C_standard_library
*/
#include <stdio.h>  /* Core input/output operations                         */
#include <stdlib.h> /* Conversions, random numbers, memory allocation, etc. */
#include <math.h>   /* Common mathematical functions                        */
#include <time.h>   /* Converting between various date/time formats         */
#include <mpi.h>    /* MPI functionality                                    */
 
#define MASTER  0   /* Process ID for MASTER                                */
#define WORKER  1   /* Process ID for WORKER                                */
 
/* MAIN PROGRAM BEGINS */
int main(int argc, char **argv) {
 
  /* VARIABLE DECLARATION */
  int    proc_id,       /* Process identifier                    */
         n_procs;       /* Number of processors                  */
 
  double x;             /* Information sent from MASTER
                           Information received by WORKER        */ 
 
  MPI_Status status;    /* MPI structure containing return codes
                           for message passing operations        */
 
  /* INITIALIZE MPI */
  MPI_Init(&argc, &argv);
 
  /* GET THE PROCESS ID AND NUMBER OF PROCESSORS */
  MPI_Comm_rank(MPI_COMM_WORLD, &proc_id);
  MPI_Comm_size(MPI_COMM_WORLD, &n_procs);
 
  /* IF MASTER, THEN DO THE FOLLOWING:
   * INITIALIZE x
   * SEND IT TO THE WORKER 
  */
  if (proc_id == MASTER) {
 
    /* INITIALIZE x */
    x = 100.001;
 
    /* SEND x TO WORKER */
    printf("\n  Sending x to WORKER [proc_id = 1] with TAG = 0\n");
 
    /* MPI_Send syntax:
     * MPI_Send(buf, count, datatype, dest, tag, comm)
     * [IN buf]      initial address of send buffer (choice)
     * [IN count]    number of elements in send buffer (nonnegative integer)
     * [IN datatype] datatype of each send buffer element (handle)
     * [IN dest]     rank of destination (integer)
     * [IN tag]      message tag (integer)
     *               must be unique for a pair of Send/Recv statements
     * [IN comm]     communicator (handle) 
    */
    MPI_Send(&x, 1, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD);
 
  } /* MASTER LOOP ENDS */
 
 
  /* IF WORKER, THEN DO THE FOLLOWING:
   * RECEIVE x FROM MASTER
   * DISPLAY IT 
  */
  if (proc_id == WORKER) {
 
    /* RECEIVE x FROM MASTER */
    printf("\n  Receiving x from MASTER [proc_id = 0] with TAG = 0\n");
 
    /* MPI_Recv syntax:
     * MPI_Recv(buf, count, datatype, source, tag, comm, status)
     * [OUT buf]     initial address of receive buffer (choice)
     * [IN count]    number of elements in receive buffer (integer)
     * [IN datatype] datatype of each receive buffer element (handle)
     * [IN source]   rank of source (integer)
     * [IN tag]      message tag (integer)
     *               must be same as the tag in Send statement
     * [IN comm]     communicator (handle)
     * [OUT status]  status object (Status) 
    */
    MPI_Recv(&x, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &status);
 
    /* DISPLAY x */
    printf("\n    x = %lf\n", x);
 
  } /* WORKER LOOP ENDS */
 
  /* FINALIZE MPI */
  MPI_Finalize();
 
  /* INDICATE THE TERMINATION OF THE PROGRAM */
  return 0;
 
} /* MAIN PROGRAM ENDS */

/* hello_world_oddeven.c
 * PARALLEL [MPI] C PROGRAM TO PRINT 'HELLO, WORLD!' TO THE SCREEN AS
 * WELL AS WHETHER THE PROCESSOR ID IS EITHER ODD OR EVEN.
 *
 * TESTED SUCCESSFULLY WITH MPICH2 (1.3.1) COMPILED AGAINST GCC (4.1.2) 
 * IN A LINUX BOX WITH QUAD CORE INTEL XEON PROCESSOR (1.86 GHz) & 4GB OF RAM.
 *
 * FIRST WRITTEN: GOWTHAM; Sat, 27 Nov 2010 10:30:11 -0500
 * LAST MODIFIED: GOWTHAM; Sat, 27 Nov 2010 11:25:34 -0500
 *
 * URL:
 * http://sgowtham.net/blog/2010/11/28/mpi-c-oddly-or-evenly-saying-ello/
 *
 * COMPILATION:
 * mpicc -g -Wall hello_world_oddeven.c -o hello_world_oddeven.x
 *
 * EXECUTION:
 * mpirun -machinefile MACHINEFILE -np NPROC ./hello_world_oddeven.x
 *
 * NPROC       : NUMBER OF PROCESSORS ALLOCATED TO RUNNING THIS PROGRAM
 * MACHINEFILE : FILE LISTING THE HOSTNAMES OF PROCESSORS ALLOCATED TO
 *               RUNNING THIS PROGRAM
 *
*/
 
/* STANDARD HEADERS AND DEFINITIONS 
 * REFERENCE: http://en.wikipedia.org/wiki/C_standard_library
*/
#include <stdio.h>  /* Core input/output operations                         */
#include <stdlib.h> /* Conversions, random numbers, memory allocation, etc. */
#include <math.h>   /* Common mathematical functions                        */
#include <time.h>   /* Converting between various date/time formats         */
#include <mpi.h>    /* MPI functionality                                    */
 
/* MAIN PROGRAM BEGINS */
int main(int argc, char **argv) {
 
  /* VARIABLE DECLARATION */
  int proc_id,       /* Process identifier   */
      n_procs;       /* Number of processors */
 
  /* INITIALIZE MPI */
  MPI_Init(&argc, &argv);
 
  /* GET THE PROCESS ID AND NUMBER OF PROCESSORS */
  MPI_Comm_rank(MPI_COMM_WORLD, &proc_id);
  MPI_Comm_size(MPI_COMM_WORLD, &n_procs);
 
  /* PRINT 'HELLO, WORLD!' FROM EVERY PROCESSOR 
   * ALSO INDICATE WHETHER THE PROCESSOR ID IS ODD OR EVEN
  */
  if (proc_id % 2 == 0) {
    printf("Hello, World! From %d [e] out of %d processors\n", proc_id, n_procs);
  } else {
    printf("Hello, World! From %d [o] out of %d processors\n", proc_id, n_procs);
  }
 
  /* FINALIZE MPI */
  MPI_Finalize();
 
  /* INDICATE THE TERMINATION OF THE PROGRAM */
  return 0;
 
} /* MAIN PROGRAM ENDS */

/* hello_world.c
 * PARALLEL [MPI] C PROGRAM TO PRINT 'HELLO, WORLD!' TO THE SCREEN.
 *
 * TESTED SUCCESSFULLY WITH MPICH2 (1.3.1) COMPILED AGAINST GCC (4.1.2) 
 * IN A LINUX BOX WITH QUAD CORE INTEL XEON PROCESSOR (1.86 GHz) & 4GB OF RAM.
 *
 * FIRST WRITTEN: GOWTHAM; Sat, 27 Nov 2010 08:32:34 -0500
 * LAST MODIFIED: GOWTHAM; Sat, 27 Nov 2010 09:15:23 -0500
 *
 * URL: 
 * http://sgowtham.net/blog/2010/11/28/mpi-c-saying-ello/
 *
 * COMPILATION:
 * mpicc -g -Wall hello_world.c -o hello_world.x
 *
 * EXECUTION:
 * mpirun -machinefile MACHINEFILE -np NPROC ./hello_world.x
 *
 * NPROC       : NUMBER OF PROCESSORS ALLOCATED TO RUNNING THIS PROGRAM
 * MACHINEFILE : FILE LISTING THE HOSTNAMES OF PROCESSORS ALLOCATED TO
 *               RUNNING THIS PROGRAM
 *
*/
 
/* STANDARD HEADERS AND DEFINITIONS 
 * REFERENCE: http://en.wikipedia.org/wiki/C_standard_library
*/
#include <stdio.h>  /* Core input/output operations                         */
#include <stdlib.h> /* Conversions, random numbers, memory allocation, etc. */
#include <math.h>   /* Common mathematical functions                        */
#include <time.h>   /* Converting between various date/time formats         */
#include <mpi.h>    /* MPI functionality                                    */
 
/* MAIN PROGRAM BEGINS */
int main(int argc, char **argv) {
 
  /* VARIABLE DECLARATION */
  int proc_id,       /* Process identifier   */
      n_procs;       /* Number of processors */
 
  /* INITIALIZE MPI */
  MPI_Init(&argc, &argv);
 
  /* GET THE PROCESS ID AND NUMBER OF PROCESSORS */
  MPI_Comm_rank(MPI_COMM_WORLD, &proc_id);
  MPI_Comm_size(MPI_COMM_WORLD, &n_procs);
 
  /* PRINT 'HELLO, WORLD!' FROM EVERY PROCESSOR */
  printf("Hello, World! From %d out of %d processors\n", proc_id, n_procs);
 
  /* FINALIZE MPI */
  MPI_Finalize();
 
  /* INDICATE THE TERMINATION OF THE PROGRAM */
  return 0;
 
} /* MAIN PROGRAM ENDS */

cd /scratch/$USER/
svnadmin --fs-type fsfs create /scratch/$USER/svn_repo
svnadmin load /scratch/$USER/svn_repo < /tmp/svnrepo.dump

grep --binary-files=text -v '^* Dumped revision' /tmp/svnrepo.dump > /tmp/svnrepo_1.dump

svnadmin load /scratch/$USER/svn_repo < /tmp/svnrepo_1.dump

cd /scratch/$USER/svn_work
cd PROJECT
svn switch --relocate svn+ssh://hostname/${HOME}/svn_repo \
                      svn+ssh://hostname/scratch/$USER/svn_repo
svn up

#! /bin/bash
 
# svn_switchrepo.sh
# BASH script to inform the subversion client about the change in repository location.
# Automagically generates the list of projects
# 
# USAGE: svn_switchrepo.sh
#
# First written: Gowtham; Wed, 17 Nov 2010 12:40:04 -0500
# Last modified: Gowtham; Wed, 17 Nov 2010 12:40:04 -0500
 
# Automagical generation of the project list
export MYPROJECTS=`svn list svn+ssh://hostname/scratch/$USER/svn_repo \
                   | sort | awk -F '/' '{print $1}'`
 
echo 
for x in $MYPROJECTS
do
  clear
  cd /scratch/$USER/svn_work/
  echo "  Switching repository for project ${x}"
  cd ${x}
  # svn switch --relocate OLD_REPO_URL/PATH NEW_REPO_URL/PATH
  svn switch --relocate svn+ssh://hostname/${HOME}/svn_repo \
                        svn+ssh://hostname/scratch/$USER/svn_repo
  svn up
  echo "  Done"
done
 
echo

#! /bin/bash
#
# BASH script to generate SVN repository log
# Refer to http://svnbook.red-bean.com/en/1.1/ch05s03.html for details
#
# Usage: svn_log.sh [REPO_PATH]
# First written: Thu, 28 Jan 2010 12:19:37 -0500
# Last modified: Thu, 28 Jan 2010 12:19:37 -0500
 
 
if [ $# != 1 ];
then
  echo
  echo "  ERROR : REPOSITORY PATH missing"
  echo "  Usage : svn_log.sh [REPO_PATH]"
  echo
  exit
else
  export REPO=$1
 
  # Determine the youngest/newest/latest revision number
  export REVISION=`svnlook youngest $REPO`
 
  echo "----------------------------------------------------------------------------------------------------------------"
  echo " Rev #  Date/Time                                    Message"
  echo "----------------------------------------------------------------------------------------------------------------"
 
  while [ $REVISION -ge 1 ];
  do
    # Extract all information about the given revision
    svnlook info $REPO -r $REVISION > /tmp/sg_svnlook.tmp
 
    # Pick out relevant information from the above
    export DATETIME=`cat /tmp/sg_svnlook.tmp | head -2 | tail -1`
    export MESSAGE=`cat /tmp/sg_svnlook.tmp | tail -1`
 
    # Print them to the screen
    printf "%6s %45s %s\n"  "$REVISION" "$DATETIME" "$MESSAGE"
 
    # Decrement the revision number by 1
    export REVISION=`expr $REVISION - 1`
  done
 
  echo "----------------------------------------------------------------------------------------------------------------"
fi

#! /bin/bash
 
# BASH script to display the IP Address - one that the machine has, 
# as well as router's public IP Address, if any.
# Tested on Apple Mac Snow Leopard 10.6.2
 
# First written : Gowtham, Thu Dec 31 12:05:35 EST 2005
# Last modified : Gowtham, Thu Dec 31 12:05:35 EST 2005
 
# en1 is the wireless interface. 
# Change appropriately, if different
export WIFI_INTERFACE="en1"
 
# Details about the ${WIFI_INTERFACE}
ifconfig ${WIFI_INTERFACE} > public_ip.txt
export STATUS=`cat public_ip.txt | grep "status" | awk '{print $4}'`
 
# Analyze the details and display appropriate information
if [ "$STATUS" = "active" ];
then
  export IPADDRESS=`cat public_ip.txt | grep broadcast | awk '{print $2}'`
  export SSID=`system_profiler SPAirPortDataType | \
               grep -A1 "Current Network Information:" | \
               tail -1 | awk -F ':' '{print $1}' | \
               sed 's/^[ \t]*//;s/[ \t]*$//'`
else
  echo
  echo " `date`"
  echo " You are not connected to the internet"
  echo
  exit 0
fi
 
# Get the public IP address, $NSIP
export NSIP=`curl -s http://checkip.dyndns.org | awk '{print $6}' | \
             awk -F '<' '{print $1}'`
 
# Compare $IPADDRESS & $NSIP
# Display appropriate information along with SSID
if [ "$IPADDRESS" = "$NSIP" ];
then
  echo
  echo "  `date`"
  echo "  SSID       : $SSID"
  echo "  IP Address : $IPADDRESS"
  echo
else
  echo
  echo "  `date`"
  echo "  SSID                        : $SSID"
  echo "  Machine's static IP Address : $IPADDRESS"
  echo "  Router's  public IP Address : $NSIP"
  echo
fi
 
# Delete the scratch file
rm -f public_ip.txt

#! /bin/bash
 
# Script to extract the atomic positions (xyz) from 
# POSCAR & OUTCAR files of VASP and write them to a 
# file, to be used with Jmol, MolDen and such other
# third party programs
 
# First written: Gowtham, Tue, 22 Dec 2009 11:11:12 -0500
# Last modified: Gowtham, Tue, 22 Dec 2009 16:29:36 -0500
 
# Essential VASP Files
# If missing, quit the program
export POSCAR="POSCAR"
export OUTCAR="OUTCAR"
 
if [[ -e $POSCAR || -e $OUTCAR ]];
then
  echo
  echo "  $POSCAR & $OUTCAR found"
else
  echo
  echo "  ERROR : POSCAR &/or OUTCAR missing"
  echo
  exit
fi
 
# Output Filename 
# If missing, quit the program
export OUTPUT=$1
 
if [ $# != 1 ];
then
  echo
  echo "  ERROR : OUTPUT_FILENAME Missing"
  echo "  Usage : vasp2xyz.sh OUTPUT_FILENAME"
  echo
  exit
fi
 
# Delete scratch files
rm -f Final.tmp.*
rm -f $OUTPUT.xyz
 
# Atoms related information
# Extracted from POSCAR & OUTCAR
 
# Total number of atom types
# Pat Krogel: Tue, 22 Dec 2009 13:13:48 -050
declare -a ATOM_TYPE=(`sed -n '6 p' $POSCAR`)
export ATOM_TYPE_TOTAL=${#ATOM_TYPE[@]}
 
# Total number of atoms
export ATOMS_TOTAL=0
export i=0
while [[ "$i" -lt "$ATOM_TYPE_TOTAL" ]];
do
  export iATOM_TYPE=${ATOM_TYPE[$i]}
  export ATOMS_TOTAL=`expr $ATOMS_TOTAL + $iATOM_TYPE`
  export i=`expr $i + 1`
done
 
# Atom labels
declare -a ATOM_LABEL=(`grep "POTCAR:" $OUTCAR | head -$ATOM_TYPE_TOTAL | awk '{print $3}' | sed -e 's/_.*//g'`)
export ATOM_LABEL_TOTAL=${#ATOM_LABEL[@]}
 
# Print2Screen
if [[ "$ATOM_TYPE_TOTAL" != "$ATOM_LABEL_TOTAL" ]];
then
  echo
  echo "  ERROR : Atom Type Total ($ATOM_TYPE_TOTAL) does NOT"
  echo "          match Atom Label Count ($ATOM_LABEL_COUNT)"
  echo "  Please make sure OUTCAR & POSCAR are from the same"
  echo "  system and calculation"
  echo 
  exit
else
  echo
  echo "  Number of Atom Types   :" $ATOM_TYPE_TOTAL
  echo "  Atom Type              :" ${ATOM_LABEL[@]}
  echo "  Atom Type Count        :" ${ATOM_TYPE[@]}
  echo "  Total Number of Atoms  :" $ATOMS_TOTAL
 
  # ATOM_LABEL_2 is an array of atom labels
  # with each atom label appearing an appropriate
  # number of times, to a total of $ATOMS_TOTAL
  declare -a ATOM_LABEL_2
  export REPEAT=0
  export j=0
 
  while [[ "$j" -lt "$ATOM_TYPE_TOTAL" ]]; 
  do
    export k=1
 
    while [[ "$k" -le "${ATOM_TYPE[$j]}" ]]; 
    do
      export REPEAT=`expr $REPEAT + 1`
      export k=`expr $k + 1`
      ATOM_LABEL_2[$REPEAT]=${ATOM_LABEL[$j]}
    done
 
    export j=`expr $j + 1`
  done
# echo ${ATOM_LABEL_2[@]}
# echo ${#ATOM_LABEL_2[@]}
 
  # Record the line numbers where coordinates are written
  # in OUTCAR. Actual coordinates begin 2 lines below
  # the recorded numbers
  grep -n "POSITION" $OUTCAR | sed -e 's/:/ /g' | sed -e 's/POSITION.*//g' > LINE_NUMBERS.tmp
 
  export FRAME_NUMBER=1
  while read START
  do
    export START_HERE=`expr $START + 2`
    export END_HERE=`expr $START_HERE + $ATOMS_TOTAL - 1`
 
    echo "$ATOMS_TOTAL" >> $OUTPUT.xyz
    echo "# Frame Number: $FRAME_NUMBER" >> $OUTPUT.xyz
    sed -n "$START_HERE,$END_HERE p" $OUTCAR | awk '{printf "%12.8f %12.8f %12.8f\n", $1, $2, $3}' > Final.tmp.$FRAME_NUMBER
 
    export l=1
    while read X Y Z
    do
      echo ${ATOM_LABEL_2[$l]} $X $Y $Z > Final.tmp.$FRAME_NUMBER.$l
      awk '{ printf "%-3s %12.8f %12.8f %12.8f\n", $1, $2, $3, $4 }' Final.tmp.$FRAME_NUMBER.$l >> $OUTPUT.xyz
      export l=`expr $l + 1`
    done<Final.tmp.$FRAME_NUMBER
 
    export FRAME_NUMBER=`expr $FRAME_NUMBER + 1`
  done<LINE_NUMBERS.tmp
 
  export FRAMES_TOTAL=`expr $FRAME_NUMBER - 1`
  echo "  Total Number of Frames :" $FRAMES_TOTAL
  echo
fi
 
# Delete scratch files
rm -f LINE_NUMBERS.tmp 
rm -f Final.tmp.*