The instructions/steps given below worked for me (and Michigan Technological University) running NPACI Rocks 5.4.2 (with CentOS 5.5) – as has been a common practice for several years now, a full version of Operating System was installed. These instructions may very well work for you (or your institution), on Rocks-like or other linux clusters. Please note that if you decide to use these instructions on your machine, you are doing so entirely at your very own discretion and that neither this site, sgowtham.net, nor its author (or Michigan Technological University) is responsible for any/all damage – intellectual and/or otherwise.

A Bit About HPL

LINPACK is a software library for performing numerical linear algebra on computers. It was written in FORTRAN by Jack Dongarra, Jim Bunch, Cleve Moler and Gilbert Stewart. LINPACK makes use of the BLAS libraries for performing basic vector and matrix operations. It has largely been superseded by LAPACK, which runs more efficiently on modern architectures.

The LINPACK benchmarks are a measure of a system’s floating point computing power. Introduced by Jack Dongarra, they measure how fast a computer solves a dense N * N system of linear equations, Ax = b. The solution is obtained by Gaussian Elimination with Partial Pivoting, with

floating point iterations. The result is often expressed in billions of floating point operations per second (GFLOPS). HPL, a portable implementation of High Performance LINPACK Benchmark, is used as a performance measure for ranking the supercomputers in the Top500 list.

Pre-requisite #1: MPI

Following Rocks recommendations, this and other pre-requisites will be installed under /share/apps/; software installed by me, in clusters at Michigan Tech, have the following template for their folder structure:

/share/apps/Software/Software_Version/Compiler/Compiler_Version

Rocks 5.4.2 installation has an instance (of few flavors) of MPI but I prefer to compile MPICH2 using GCC 4.1.2. At the time of writing this post, the latest stable version of MPICH2 is 1.4.1p1 and it may be downloaded from here. Following folder structure/template mentioned above, it will be installed under

/share/apps/mpich2/1.4.1p1/gcc/4.1.2

To avoid confusion and/or missed steps leading to undesired results, steps associated with installation of MPICH2 have been put in the following script:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

#! /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

A good test of a successful installation is that which mpicc, which mpif77, etc. return the respective commands located in ${MPICH2_INSTALL}.

Pre-requisite #2: Goto BLAS

As in the case of pre-requisite #1, this one will be installed under

/share/apps/gotoblas2/1.13/gcc/4.1.2

The following script, used in installation, will assume that one has downloaded Goto BLAS2 1.13 from here and placed it in
/share/apps/tmp/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#! /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

HPL Installation/Compilation

With MPICH2 and Goto BLAS2 in place, HPL 2.0 will be installed under

/share/apps/hpl/2.0/mpich2/1.4.1p1/gcc/4.1.2

The following script, used in installation, will assume that one has downloaded HPL 2.0 from here & the necessary Make.MPICH2141p1_GCC412.HPL (listed below) and placed them in /share/apps/tmp/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

#
# 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
#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

#! /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

Running HPL Benchmark

The amount of memory used by HPL is essentially the size of the co-efficient matrix, A. Following standard binary definition, 1 GB is 1024 * 1024 * 1024 bytes (TOTAL_MEMORY_BYTES). Most scientific/engineering computations use double precision numbers, with each such double precision number taking 8 bytes of memory. Thus, 1 GB can accommodate 134,217,728 double precision entities (TOTAL_DP_ELEMENTS = TOTAL_MEMORY_BYTES/8). Theoretically, sqrt(TOTAL_DP_ELEMENTS) represents the maximum possible value of N. However, operating system needs some memory to perform some necessary operations. As such, HPL benchmark is usually performed for the following values of N – with m representing the fraction of total memory – making sure that swapping did not occur (which would result in reduced performance).

HPL uses the block size (NB) for the data distribution as well as for the computational granularity. From a data distribution perspective, the smaller NB, the better the load balance. From a computational perspective, too small of a value for NB may limit the computational performance by a large factor since almost no data re-use will occur in the highest level of the memory hierarchy. The number of messages will also increase. In my case, this benchmark was performed for NB values of 128, 256 and 512.

The results so obtained are compared with the theoretical peak value, , computed as follows:

For e.g., for a cluster with 16 identical recent Intel architecture compute nodes, each compute node with dual hex cores @ 3.00 GHz, will be

If each of these nodes had 24 GB RAM, then TOTAL_MEMORY_BYTES = 1024 * 1024 * 1024 * 24 * 16 = 412316860416
and TOTAL_DP_ELEMENTS = 412316860416/8 = 51539607552.

As such, N values will be

What if the cluster has heterogeneous compute nodes?

Computing isn’t easy in this case; becomes even more so when these compute nodes belong to different generations as one has to account for aging factor. It has been a practice at Michigan Tech, in such cases, to split the cluster into different queues – one for each generation/type of compute nodes – and run the HPL benchmark separately.

Thanks be to

Rocks mailing list and its participants.

The instructions/steps given below worked for me (and Michigan Technological University) running NPACI Rocks 5.4.2 (with CentOS 5.5) – as has been a common practice for several years now, a full version of Operating System was installed. These instructions may very well work for you (or your institution), on Rocks-like or other linux clusters. Please note that if you decide to use these instructions on your machine, you are doing so entirely at your very own discretion and that neither this site, sgowtham.net, nor its author (or Michigan Technological University) is responsible for any/all damage – intellectual and/or otherwise.

A Bit About Ganglia (gmond & gmetad)

Citing Ganglia website,

Ganglia is a scalable distributed monitoring system for high-performance computing systems such as clusters and Grids. It is based on a hierarchical design targeted at federations of clusters. It leverages widely used technologies such as XML for data representation, XDR for compact, portable data transport, and RRD tool for data storage and visualization. It uses carefully engineered data structures and algorithms to achieve very low per-node overheads and high concurrency. The implementation is robust, has been ported to an extensive set of operating systems and processor architectures, and is currently in use on thousands of clusters around the world. It has been used to link clusters across university campuses and around the world and can scale to handle clusters with 2000 nodes.

Further, citing Wikipedia,

gmond (Ganglia Monitoring Daemon) is a multi-threaded daemon which runs on each cluster node that needs to be monitored. Installation does not require having a common NFS file system or a database back-end, install special accounts or maintain configuration files. It has four main responsibilities: monitor changes in host state; announce relevant changes; listen to the state of all other ganglia nodes via a unicast or multicast channel; answer requests for an XML description of the cluster state.

Each gmond transmits in information in two different ways: unicasting or multicasting host state in external data representation (XDR) format using UDP messages OR sending XML over a TCP connection.

Federation in Ganglia is achieved using a tree of point-to-point connections amongst representative cluster nodes to aggregate the state of multiple clusters. At each node in the tree, a Ganglia Meta Daemon (gmetad) periodically polls a collection of child data sources, parses the collected XML, saves all numeric, volatile metrics to round-robin databases and exports the aggregated XML over a TCP sockets to clients. Data sources may be either gmond daemons, representing specific clusters, or other gmetad daemons, representing sets of clusters. Data sources use source IP addresses for access control and can be specified using multiple IP addresses for fail over. The latter capability is natural for aggregating data from clusters since each gmond daemon contains the entire state of its cluster.

The Ganglia web front-end provides a view of the gathered information via real-time dynamic web pages. Most importantly, it displays Ganglia data in a meaningful way for system administrators and computer users. Although the web front-end to ganglia started as a simple HTML view of the XML tree, it has evolved into a system that keeps a colourful history of all collected data. The Ganglia web front-end caters to system administrators and users (for e.g., one can view the CPU utilization over the past hour, day, week, month, or year). The web front-end shows similar graphs for memory usage, disk usage, network statistics, number of running processes, and all other Ganglia metrics. The web front-end depends on the existence of the gmetad which provides it with data from several Ganglia sources.

Specifically, the web front-end will open the local port 8651 (by default) and expects to receive a Ganglia XML tree. The web pages themselves are highly dynamic; any change to the Ganglia data appears immediately on the site. This behaviour leads to a very responsive site, but requires that the full XML tree be parsed on every page access. Therefore, the Ganglia web front-end should run on a fairly powerful, dedicated machine if it presents a large amount of data. The Ganglia web front-end is written in the PHP scripting language, and uses graphs generated by gmetad to display history information.

Installation & Configuration

Rocks 5.4.2 installation in itself takes care of almost everything pertaining to installing and configuring Ganglia, gmond, gmetad and Ganglia web interface. However, by default & design, a Rocks cluster’s web interface is not publicly accessible. To fix this, following commands were run:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

#! /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

Upon pointing the browser to the http://FQDN/ganglia/, the web page should display the relevant information.

Monitoring NVIDIA GPU

The aforementioned set up works fine and as expected but it doesn’t necessarily provide any information about GPU(s) that may be part of the hardware. For e.g., the cluster used in this case has two NVIDIA GeForce GTX 260 cards in each compute node. For testing purposes, only one compute node was installed – also, one of the GTX 260 cards was replaced with a NVIDIA Quadro 6000. With more and more scientific & engineering computations tending towards GPU based computing, it’d be useful to include their status/usage information in Ganglia’s web portal. To this effect, NVIDIA released gmond Python module for GPUs (made aware of it by one of Michigan Tech ITSS directors). The instructions given in the NVIDIA-linked pages do work as described – however, Rocks 5.4.2 uses python 2.4 while one requires python 2.5 (or higher) to get the GPU metrics to show up in Ganglia.

Rebuilding Rocks Distribution with Python ctypes Library

I downloaded python-ctypes-1.0.2-2.el5.x86_64.rpm from http://ftp.osuosl.org/pub/fedora-epel/5/x86_64/ and placed it in
/export/rocks/install/contrib/5.4/x86_64/RPMS/ – rebuilding of the distribution, with following commands as usual, was uneventful.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#! /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

Re-install the compute node(s) [in this case, compute-0-0]. Without and with ctypes library, gmond (when run in debug mode, i.e. gmond -d9 -f), results in the following message.

NVIDIA Driver Installation

Once the compute node(s) are re-installed, NVIDIA driver, NVIDIA-Linux-x86_64-285.05.33.run, was installed using the following script.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#! /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

Python Bindings for the NVIDIA Management Library

This provides Python access to static information and monitoring data for NVIDIA GPUs, as well as management capabilities. It exposes the functionality of the NVML and one may download these from here – as before, the necessary steps are included in a BASH script.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#! /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

gmond Python Module For Monitoring NVIDIA GPUs using NVML

After downloading ganglia-gmond_python_modules-3dfa553.tar.gz from GitHub for ganglia / gmond_python_modules to
/share/apps/src/nvidia_ganglia/, the following steps need to be performed:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#! /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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#! /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

Upon pointing the browser to the http://FQDN/ganglia/ (e.g., http://paracuda.math.mtu.edu/ganglia/ – the link will probably die or be changed to something else in due course), the display should include information about GPU as well, as shown in screenshots below:

With little more work, the rather unaesthetic looking Ganglia web interface can be made to look like a given institution’s theme:

Thanks be to

Dr. Allan Struthers for letting his paracuda.math be used for this purpose; my friendly neighbors for their kindness in letting me borrow a NVIDIA Quadro 6000 card; Robert Alexander of NVIDIA (http://developer.nvidia.com/ganglia-monitoring-system/), Bernard Li of Lawrence Berkeley National Laboratory and Jeremy Enos of National Center for Supercomputing Applications for developing this gmond Python module as well as making time to answer my questions.

Near Future Work

Work is currently underway to include all of the compute node related steps in the above described procedure in the local Rocks distribution, so that the compute nodes get them as soon as they are installed.

The instructions/steps/programs given below worked for me (and Michigan Technological University) running site licensed Red Hat Enterprise Linux 6.2, with NVIDIA CUDA SDK 4.1.28, NVIDIA GPU Driver v290.10 & two NVIDIA GeForce GTX 570 cards – as has been a common practice for several years now, a full version of Operating System was installed and all necessary patches/upgrades have been applied. These instructions may very well work for you (or your institution), on Red Hat-like or other linux distributions. Please note that if you decide to use these instructions on your machine, you are doing so entirely at your very own discretion and that neither this site, sgowtham.net, nor its author (or Michigan Technological University) is responsible for any/all damage – intellectual and/or otherwise.

The Program

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

/* 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 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

# 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

The instructions/steps given below worked for me (and Michigan Technological University) running site licensed Red Hat Enterprise Linux 6.2 – as has been a common practice for several years now, a full version of Operating System was installed and all necessary patches/upgrades have been applied. These instructions may very well work for you (or your institution), on Red Hat-like or other linux distributions. Please note that if you decide to use these instructions on your machine, you are doing so entirely at your very own discretion and that neither this site, sgowtham.net, nor its author (or Michigan Technological University) is responsible for any/all damage – intellectual and/or otherwise.

A Bit About Ganglia (gmond & gmetad)

Citing Ganglia website,

Ganglia is a scalable distributed monitoring system for high-performance computing systems such as clusters and Grids. It is based on a hierarchical design targeted at federations of clusters. It leverages widely used technologies such as XML for data representation, XDR for compact, portable data transport, and RRD tool for data storage and visualization. It uses carefully engineered data structures and algorithms to achieve very low per-node overheads and high concurrency. The implementation is robust, has been ported to an extensive set of operating systems and processor architectures, and is currently in use on thousands of clusters around the world. It has been used to link clusters across university campuses and around the world and can scale to handle clusters with 2000 nodes.

Further, citing Wikipedia,

gmond (Ganglia Monitoring Daemon) is a multi-threaded daemon which runs on each cluster node that needs to be monitored. Installation does not require having a common NFS file system or a database back-end, install special accounts or maintain configuration files. It has four main responsibilities: monitor changes in host state; announce relevant changes; listen to the state of all other ganglia nodes via a unicast or multicast channel; answer requests for an XML description of the cluster state.

Each gmond transmits in information in two different ways: unicasting or multicasting host state in external data representation (XDR) format using UDP messages OR sending XML over a TCP connection.

Federation in Ganglia is achieved using a tree of point-to-point connections amongst representative cluster nodes to aggregate the state of multiple clusters. At each node in the tree, a Ganglia Meta Daemon (gmetad) periodically polls a collection of child data sources, parses the collected XML, saves all numeric, volatile metrics to round-robin databases and exports the aggregated XML over a TCP sockets to clients. Data sources may be either gmond daemons, representing specific clusters, or other gmetad daemons, representing sets of clusters. Data sources use source IP addresses for access control and can be specified using multiple IP addresses for fail over. The latter capability is natural for aggregating data from clusters since each gmond daemon contains the entire state of its cluster.

The Ganglia web front-end provides a view of the gathered information via real-time dynamic web pages. Most importantly, it displays Ganglia data in a meaningful way for system administrators and computer users. Although the web front-end to ganglia started as a simple HTML view of the XML tree, it has evolved into a system that keeps a colourful history of all collected data. The Ganglia web front-end caters to system administrators and users (for e.g., one can view the CPU utilization over the past hour, day, week, month, or year). The web front-end shows similar graphs for memory usage, disk usage, network statistics, number of running processes, and all other Ganglia metrics. The web front-end depends on the existence of the gmetad which provides it with data from several Ganglia sources.

Specifically, the web front-end will open the local port 8651 (by default) and expects to receive a Ganglia XML tree. The web pages themselves are highly dynamic; any change to the Ganglia data appears immediately on the site. This behaviour leads to a very responsive site, but requires that the full XML tree be parsed on every page access. Therefore, the Ganglia web front-end should run on a fairly powerful, dedicated machine if it presents a large amount of data. The Ganglia web front-end is written in the PHP scripting language, and uses graphs generated by gmetad to display history information.

Installation

In order to make sure that none of the required steps are missed when performing similar installation on other machines (or repeating on the same machine), a BASH script was written.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#! /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

Configuration

Assuming all went well so far, one can expect to have the following files: /etc/ganglia/gmetad.conf, /etc/ganglia/gmond.conf and
/etc/httpd/conf.d/ganglia.conf

Edit /etc/ganglia/gmetad.conf to have the following line:

1

data_source "dirac.dcs" localhost:8649

/etc/ganglia/gmond.conf will have the following edits:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

/*
 * 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"
    }
  }
}

/etc/httpd/conf.d/ganglia.conf will have the following edits:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

  #
  # 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>

The firewall needs to be modified so that it accepts UDP & TCP requests on port 8649. To that effect, /etc/sysconfig/iptables will have the following lines:

1
2
3
4

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

(Re)Start the necessary services:

1
2
3
4

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

After a few minutes of collecting the data and upon pointing the browser to the http://FQDN/ganglia/, the web page should display the relevant information.

If, instead of relevant information, the web page displays the following error message

There was an error collecting ganglia data (127.0.0.1:8652): fsockopen error: Permission denied

then, more often than not, it hints to a selinux related issue. Edit the file, /etc/sysconfig/selinux, to look like:

1
2
3
4
5
6
7
8
9
10

# 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

Restart the machine and point the browser to the http://FQDN/ganglia/, the web page should display the relevant information.

Monitoring NVIDIA GPU

The aforementioned set up works fine and as expected but it doesn’t necessarily provide any information about GPU(s) that may be part of the hardware. For e.g., the test machine used in our case has two NVIDIA GeForce GTX 570 cards. With more and more scientific & engineering computations tending towards GPU based computing, it’d be useful to include their status/usage information in Ganglia’s web portal. To this effect, NVIDIA released gmond Python module for GPUs (made aware of it by one of Michigan Tech ITSS directors). The instructions given in the NVIDIA-linked pages do work as described and are included here for the sake of completeness.

Python Bindings for the NVIDIA Management Library

This provides Python access to static information and monitoring data for NVIDIA GPUs, as well as management capabilities. It exposes the functionality of the NVML and one may download these from here – as before, the necessary steps are included in a BASH script.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#! /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

gmond Python Module For Monitoring NVIDIA GPUs using NVML

After downloading ganglia-gmond_python_modules-3dfa553.tar.gz from GitHub for ganglia / gmond_python_modules to /tmp/, the following steps need to be performed:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#! /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

Upon pointing the browser to the http://FQDN/ganglia/ (e.g., http://dirac.dcs.it.mtu.edu/ganglia/ – the link will probably die or be changed to something else in due course), the display should include information about GPU as well, as shown in screenshots below:

With little more work, the rather unaesthetic looking Ganglia web interface can be made to look like a given institution’s theme:

Near Future Work

Work is currently underway, most certainly with help from the ever-awesome Rocks mailing list, to integrate the above into a NPACI Rocks 5.4.2 cluster with compute nodes having one or more GPUs. Another post will come along as and when this work has been completed and tested.

And here we are little over a year later, sitting in the same general area in The Downtowner Lounge, celebrating that Next One – albeit for a short amount of time, thanks to numerous great souls that have helped us/me understand & appreciate the value of the opportunity we have earned – our second successive perfect season.

The festivities in 2009 lasted about six hours and the following week saw us look for replacements – to fill in the void to be left later on by some good [and really smart & committed as well, to say the least] players [Leslie, Russ, and so on] to graduation.

While we didn’t want to care any less about the rumors prevailing in the community that our team is/was stacked with good players and that it was a fluke that we won the championship and that our success in championship games was only 50% [the only non-rumor] and so on, it was [and still is] hard to ignore such preposterous remarks. There are few things in life that come close to matching the feeling of proving your detractors wrong, to do something that someone [or no one] thought you could do or didn’t give you the deserved credit for doing what you did. And it was 15th October 2009, about SIX months before the tentative start of 2010 season, that some of the core members of this wonderful team started our off-season work outs, almost in a religious fashion. Regiment [as in its usage as a verb] included runs, weights and attempts to be smarter, patient & mature about things that needed to be done on the field in clutch situations.

With weather being unseasonably warm by middle of March of 2010 and much of snow having disappeared, we hit the fields for early practice sessions. Many countless hours of practice and organized team activity over next 20 some weeks or so brought us – with several new faces – closer and made us better, a lot better – to understand and appreciate what each one brought to the table and come up with a plan to best utilize those resources to win games, one at a time. Just like last season, I could write about what we did right and we did wrong in each of the 15 games but it would sound more like a broken record – as such, I will just tabulate the results and talk about reasons later.

We are the first ones to concede – concede the fact that not everything we did was perfect and there is plenty of room for improvement. But we did put up the best offense and best defense – with a league high of 251 (-27 compared to 2009) runs scored and allowing only 60 (+13 compared to 2009), for a league’s best run differential of +191 (-14 compared to 2009). More importantly, most of us had fun [it might not have seemed like it but trust me, fun is a very relative/subjective entity], we got better as an individual & as a team, and even more importantly, most of the teams we played seemed to have fun too. And while there are many smaller reasons behind our success, the most notable ones have remained the same as in 2009 and many a years before. It’s noteworthy to mention that continuing to stick with/use Lagrangian / Hamiltonian Mechanics has continued to yield (very) rich dividends.

While it’s not the first time that someone initiated the smack talk against this very proud team, we respect three of the four that did so, including the one that we played when all the marbles were at stake – for they showed up to defend their words by being physically present at the game and as such, shall remain nameless. However, there was one that does need a specific mention:

Not In Picture: Dr. Robert Weidman, Kelsey Cox, Laura Hess

While there are teams [calling them a team, in the true sense of the word, is an atrocity in itself] and some individuals [local and non-local] have had [and will continue to have] issues with the success of our team [see one such assault via facebook below], we have very strong reasons to believe that the league is better off because we are a part of it. Like a team-mate phrased it effortlessly in so few words, the rising tides lifts all ships; for now, we are the big ship. And when a team that does come along to beat us fair and square, trust me, we will be happy for them – albeit a momentary disappointment.

We take a lot of pride in the way we build in our team, train the players that have never played the game before [yours-truly was one of them, eight years ago] or haven’t played in quite a while, practice at least once a week, learn the rules and regulations and follow them religiously so that we keep the game safe for everyone involved, not be the first one to initiate any kind of smack talk against any team, be humble in victory and graceful in defeat [while it might not seem so from reading this post], get better and smarter with each week/season, put in an enviable performance week in & week out and year in & year out. As a by-product of all this, we are insanely proud of our 86-7-1 record over the last seven years. There is no magic to what we do &/or achieve as a team but there sure as hell is plenty of hard work, dedication and sacrifice by everyone involved.

I believe what we do is a microcosm of progress and of what causes progress; to be not wanting to be better tomorrow than what we are today, to settle for something good instead of pursuing greatness, to hope that the competition gets lower so that we can look better and not having the ability to generalize this to almost every other aspect of our lives … is, according to us, a crime against ourselves, and making a mockery of all the wonderful opportunities that life has sent our way.

Along with being just good enough is not good enough (a Lake Superior Walk realization) and failing to plan is planning to fail (a friendly advice from undergraduate days), [settling for] good is the enemy of great is as invaluable a lesson as I have ever learned in my life – thanks to a book that a dear friend, Ian Marks, graciously let me borrow over Christmas 2009 break and it has come to be, sort of, mission statement / guiding light of our team & lives. I’m pretty sure that the double play opportunities we missed in the championship game — 6-4-3 and 4-6-3, with latter having had the more serious impact had the game been closer — will haunt us [our Short Stop and yours truly] for times to come, at least until we get another opportunity to get it right. And just to remind ourselves of the consequences of missing out on opportunities, we imposed on ourselves an eight mile run as a moderate punishment. And just like 2009, the festivities lasted about six hours or less and we are on the look out for replacements players to fill in the void that will be left by some good [and really smart & committed as well, to say the least] players [Josh Carlson, Eric Winder and so on] to graduation.

Thus begins an earnest & humble attempt to be better tomorrow, as an individual and as a team, than we are today.

Many countless hours of practice and organized team activity over next 15+ weeks or so brought us closer and made us better, a lot better – to understand and appreciate what each one brought to the table and come up with a plan to best utilize those resources to win games, one at a time. I could write about what we did right and we did wrong in each of the 13 games but it would sound more like a broken record – as such, I will just tabulate the results and talk about reasons later.

While not everything did was perfect, we did put up the best offense and best defense – with a league high of 278 runs scored and allowing only 73, for a league’s best run differential of +205. More importantly, most of us had fun [it might not have seemed like it but trust me, fun is a very relative/subjective entity] and even more importantly, most of the teams we played seemed to have fun too. And while there are many smaller reasons behind our success, following are probably the most notable ones [in no/some particular order]:

1. A manager who knows how to run the show.
2. A clean and consistent roster of players.
3. A set of unselfish players who are committed to the concept of team and show up for practice.
4. Teach new players the rules and regulations of the game so that they play the game the right way, don’t get hurt and importantly, don’t hurt others.
5. Players who understand their role(s) and execute it – almost every time – to the best of their ability.
6. At least two practice sessions a week, irrespective of weather conditions, to hone individual & team skills.
7. A unified understanding that we are a work in progress and that we haven’t done anything worth talking about yet.
8. A unified understanding that we shall not speak of the L word.
9. A trash talker (or two).
10. An awesome set of supporters and die hard fans.
11. A designated driver.
12. A variety of characters to keep it fun and real.

While these have been a constant fixture of our team for many years, we unanimously decided to add a thing or two to this routine:

1. Team work outs three times a week [involved running and lifting a variety of weights - to help build strength/stamina and reduce fatigue during crunch game scenarios].
2. Our inability to properly resolve the forces involved into appropriate components & confusion created as a result had cost us dearly in previous few championship games. As such, we abandoned the usage of Newtonian Mechanics completely and resorted to Lagrangian/Hamiltonian Mechanics – based on players’ level of comfort. It seemed to pay (very) rich dividends as we only had to worry about the initial and final potentials of the system rather than zillion force components.

Like a good [bad] old saying goes, there are many ways of doing the same thing to get the same result, and I am sure there are other ways of winning championships but trust me, I wouldn’t want to experience it any other team’s way.

The first 12 hours or so after the championship game had been pretty euphoric and celebratory [thanks in part to Mr. League Commissioner, Dave Fritz and Mr. President, Randy Harrison - for getting us the trophy the same day], the last 6 or so have been pretty disappointing and depressing – may be because the mind (and the body) knows that there are no more practices, no more games and that I wouldn’t get to see / hang out with my teammates as regularly as I had found myself doing so.

Huskies blew away Wildcats in Marquette’s Superior Dome (NMU’s home field) in a nationally televised Division II Football Game of the Week (thanks to CBS College Sports Network and FSN Detroit) to lay claim to the Miner’s Cup. During my recent trip up north, a bunch of these football players had promised to break my jinx and true to their words, that JINX is history now

God bless the internet and Skype, I got to watch this with buddy Kyle in Alaska. Honestly, I don’t think I have ever watched a game on TV (or any other program for that matter), in which I could claim personal acquaintance to so many – athletes, coaching staff and fans included. In spite of being over a thousand miles away from the venue, I couldn’t forget my usual role in such events and as such, ended up shooting some pictures:

These and rest of the pictures from this game are here.

• The only way I could be considered to be in shape is if random shapes were also considered to be shapes.
• New found respect for folks who do water sports and shoot pictures of water sports. Although not by much, I would like to think I am slightly better at shooting than participating in them.
• New found respect for ROTC Officers and Cadets who do a cumulative number of push-ups every time Michigan Tech football team scores points. I suck at doing push-ups
• One of my New Year’s Resolution for the last two years was resolved, without my own knowledge, nearly a year ago. In a nutshell, it was to be a Bad A$$ and the way to achieve it (as I had explained to my neighbors in NJ) was to be called that (or Jerk, or something to that effect – you get the idea) by a girl in public (prettier the better). It didn’t take too long – the very first evening, some one I have known for a long time and admired, called me that near the Green House. Thank you, LJW, for stepping up and doing the honors
• There is a difference between being Bad A$$ and plain mean (thank you Robby).
• Practice, Preparation, Planning, Patience and Perseverance are useful tools to have and more the better.

If a picture’s worth a thousand words, the ones in the collage below should provide a bird’s eye view of my stay:

These and other pictures from this trip are here:

NCAA DII Football Winona State Warriors @ Michigan Tech Huskies :: Hillsdale Chargers @ Michigan Tech Huskies

These instructions/steps worked for me and it may very well work for you on Sun OS / linux distributions. Please note that if you decide to use these instructions on your machine (either for this particular application and/or for other kind of information), you are doing so entirely at your very own discretion and that neither this site, sgowtham.net, nor its author is responsible for any/all damage – intellectual or otherwise.

During the Christmas break of 2005-06 (while I was a graduate student in Michigan Technological University), I thought it would be nice to have a tool to store details pertaining to our research group publications in a MySQL database (instead of a flat HTML file). Some underlying motives were as follows:

1. List all publications in a year – helps when generating annual progress reports
2. List all publications by any given author(s)
3. A combination of the above two possibilities

The server which served our research group website used Sun OS 5.6 and for security-related reasons, it did not have PHP. As such, it became necessary (a good thing!) that this utility had to be written using PERL CGI (Common Gateway Interface). List of required features (implemented over a period of time) included:

1. User Side
   1. Display all publications when no query is submitted (default display) – include a search form
   2. Searchable by year of publication
   3. Searchable by two authors
   4. Searchable by a combination of #2 and #3
   5. When displaying queried results, include Abstract
2. Admin Side:
   1. Adding a new publication to the database, with PDF upload option (GUI)
   2. Updating details for an entry that already exists in a database (GUI)
   3. Deleting an entry from the database (GUI)
   4. Restricted access

Starting with MySQL database/table structure, these requirements are described one by one in following subsections.

#0. Preliminary Settings

Let us assume that:

1. The web documents are stored under /var/www/html and will henceforth be referred to as $DocumentRoot (if you are trying to implement this in your research group in a university/academic institution, please check with your systems administrator for the appropriate value of $DocumentRoot).
2. The page (with search form) which users will interact is called publications.cgi and is stored under $DocumentRoot.
3. The folder that contains PDF version of publications is called pdf and is located under $DocumentRoot. Make sure this folder has 777 permission.
4. The folder that contains administrative CGI scripts is called admin and is located under $DocumentRoot. This folder must have restricted access.

#1. MySQL Database

1. Create a database. If einstein is userid of the group’s principal investigator, then einstein_research would be just fine a name for the database.
2. Create a dummy user (within MySQL), einstein_webuser, with at least INSERT, UPDATE, SELECT and DELETE previliges on einstein_research database.
3. Set a (strong enough) password for this dummy user.
4. Create a table within einstein_research database, publications, with following structure:

   1 2 3 4 5 6 7 8 9 10 11 12 13

   CREATE TABLE `publications` ( `PubID` INT( 11 ) NOT NULL AUTO_INCREMENT , `BibID` VARCHAR( 15 ) DEFAULT NULL , `Title` VARCHAR( 255 ) NOT NULL, `Authors` VARCHAR( 150 ) NOT NULL, `JName` VARCHAR( 30 ) NOT NULL, `JVolume` INT( 8 ) NOT NULL, `JYear` YEAR( 4 ) NOT NULL, `JPage` INT( 11 ) NOT NULL, `Abstract` text, UNIQUE KEY `BibID` ( `BibID` ) , KEY `PubID` ( `PubID` ) ) ENGINE = MYISAM DEFAULT CHARSET = latin1;

It is generally a good idea to back up these databases on a regular basis – to save oneself from the pain of re-entering everything if something were to go wrong. You may refer to one of my previous posts that discusses backing up and restoring MySQL databases in detail.

#2. User Side: publications.cgi

Following one of the requirements as mentioned before, this page must display all publications when no query is submitted (default view) and display only those publications (with abstract) when a query is submitted. The part below is the code for default view.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

#! /usr/bin/perl
 
# publications.cgi (PART #1)
# CGI script to search the database
 
# Modules being used
use DBI;
use CGI;
 
# Make a CGI object and retrieve information from the form
$inputform = new CGI;
print $inputform->header;
 
# Get values from the form
$year    = $inputform->param("year");
$title   = $inputform->param("title");
$author1 = $inputform->param("author1");
$author2 = $inputform->param("author2");
$bo1     = $inputform->param("BO1");
$bo2     = $inputform->param("BO2");
$bo3     = $inputform->param("BO3");
$ffill   = $inputform->param("ffill");
 
# If the variable 'ffill' is empty, then display the form
if ((!($ffill)))
{
print << "EOF";
<!-- www.w3c.org standard -->
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
<!-- HTML begins -->
<html>
 
<!-- HEAD section -->
<head>
 
<!-- TITLE section -->
<title>
Your Research Group, Your Academic Institution
</title>
 
</head>
 
<!-- BODY section -->
<body>
 
<!-- Group Header -->
<h1>YOUR GROUP NAME</h1>
 
<h2>Publications</h2>
 
<!-- FORM -->
<form method="POST" action="/publications.cgi">
<table border="0" cellpadding="5" cellspacing="3" align="center">
 
<tr>
<td><b>Year</b> &nbsp; &nbsp;</td>
<td>
  <select name="year">
    <option value='%'>Any</option>
    <option value='2008'>2008</option>
    <option value='2007'>2007</option>
    <option value='2006'>2006</option>
    <option value='2005'>2005</option>
    <option value='2004'>2004</option>
    <option value='2003'>2003</option>
    <option value='2002'>2002</option>
    <option value='2001'>2001</option>
    <option value='2000'>2000</option>
  </select>
</td>
<td>
  <select name="BO1">
    <option value='AND'>AND</option>
    <option value='OR'>OR</option>
  </select>
</td>
<td><b>Title</b></td>
<td>
  <input type="text" name="title" size="15"> &nbsp; &nbsp;
</td>
<td>
  <select name="BO2">
    <option value='AND'>AND</option>
    <option value='OR'>OR</option>
  </select>
</td>
</tr>
 
<tr>
<td><b>Author</b></td>
<td>
  <input type="text" name="author1" size="15">
</td>
<td>
  <select name="BO3">
    <option value='AND'>AND</option>
    <option value='OR'>OR</option>
  </select>
</td>
<td><b>Author</b></td>
<td>
  <input type="text" name="author2" size="15">
</td>
<td>
&nbsp;
</td>
</tr>
 
<tr>
<td colspan="6">
  <input type="hidden" name="ffill" value="filled" size="15">
  <input type="submit" value="Search">
  <input type="reset"  value="Clear">
</td>
</tr>
 
<tr>
<td colspan="6">
<br>** All fields are optional
</td>
</tr>
 
</table>
</form>
EOF
 
# Connect to the database and perform the SQL query
$dbh      = DBI->connect('dbi:mysql:einstein_research:localhost','einstein_web','PASSWORD') or die "Error";
$sql1     = "SELECT * FROM publications ORDER BY JYear DESC, ";
$sql      = $sql1 . "JName ASC, JVolume DESC, JPage DESC, Title";
 
$query    = $dbh->prepare($sql);
$query->execute;
$nresults = $query->rows;
 
# Display the results
if ( $nresults > 0 ) {
print << "EOF";
<table width="100%" cellpadding="5" cellspacing="5" border="0">
<tr>
<td valign="top"><b>#</b></td>
<td><b>BibID / Title / Authors / Citation</b> 
	(Last-to-first, with Journals alphabetically sorted)</td>
</tr>
EOF
 
$id=1;
  while(($PubID,$BibID,$Title,$Authors,$JName,$JVolume,$JYear,$JPage,$Abstract)=$query->fetchrow()) {
print << "EOF";
  <tr>
  <td valign="top">
  $id
  </td>
  <td valign="top">
  $BibID | 
  <a href="/pdf/$BibID.pdf" target="_blank">PDF</a><br>
  $Title<br>
  $Authors<br>
  <i>$JName</i>, <b>$JVolume</b>, $JPage ($JYear)
  </td>
  </tr>
EOF
  $id++;
}
 
print << "EOF";
</table>
EOF
} else {
 
print "<h3>Search Results</h3>\n";
print "<font color=red>Sorry, no records were found!</font>";
}
 
print << "EOF";
<!-- Body ends -->
</body>
 
<!-- HTML ends -->
</html>
EOF
exit;
}

The part below contains the code that takes care of search-results part.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

# publications.cgi (PART #2)
 
# If the variable 'ffill' is not empty, then query the database
# and display results
print << "EOF";
<!-- www.w3c.org standard -->
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
<!-- HTML begins -->
<html>
 
<!-- HEAD section -->
<head>
 
<!-- TITLE section -->
<title>
Your Research Group, Your Academic Institution
</title>
 
</head>
 
<!-- BODY section -->
<body>
 
<!-- Group Header -->
<h1>YOUR GROUP NAME</h1>
 
<h2>Publications</h2>
 
<!-- FORM -->
<form method="POST" action="/publications.cgi">
<table border="0" cellpadding="5" cellspacing="3" align="center">
 
<tr>
<td><b>Year</b> &nbsp; &nbsp;</td>
<td>
  <select name="year">
    <option value='%'>Any</option>
    <option value='2008'>2008</option>
    <option value='2007'>2007</option>
    <option value='2006'>2006</option>
    <option value='2005'>2005</option>
    <option value='2004'>2004</option>
    <option value='2003'>2003</option>
    <option value='2002'>2002</option>
    <option value='2001'>2001</option>
    <option value='2000'>2000</option>
  </select>
</td>
<td>
  <select name="BO1">
    <option value='AND'>AND</option>
    <option value='OR'>OR</option>
  </select>
</td>
<td><b>Title</b></td>
<td>
  <input type="text" name="title" size="15"> &nbsp; &nbsp;
</td>
<td>
  <select name="BO2">
    <option value='AND'>AND</option>
    <option value='OR'>OR</option>
  </select>
</td>
</tr>
 
<tr>
<td><b>Author</b></td>
<td>
  <input type="text" name="author1" size="15">
</td>
<td>
  <select name="BO3">
    <option value='AND'>AND</option>
    <option value='OR'>OR</option>
  </select>
</td>
<td><b>Author</b></td>
<td>
  <input type="text" name="author2" size="15">
</td>
<td>
&nbsp;
</td>
</tr>
 
<tr>
<td colspan="6">
  <input type="hidden" name="ffill" value="filled" size="15">
  <input type="submit" value="Search">
  <input type="reset"  value="Clear">
</td>
</tr>
 
<tr>
<td colspan="6">
<br>** All fields are optional
</td>
</tr>
 
</table>
</form>
EOF
 
# If the variable 'ffill' is not empty, display the search results
# Connect to the database and perform the SQL query
$dbh      = DBI->connect('dbi:mysql:einstein_research:localhost','einstein_web','PASSWORD') or die "Error";
$sql1     = "SELECT * FROM publications WHERE JYear LIKE \"$year\" $bo1 ";
$sql2     = $sql1 . "Title LIKE \"%$title%\" $bo2 Authors LIKE \"%$author1%\" $bo3 ";
$sql3     = $sql2 . "Authors LIKE \"%$author2%\" ORDER BY JYear DESC, JName ASC, ";
$sql      = $sql3 . "JVolume DESC, JPage DESC, Title";
 
$query    = $dbh->prepare($sql);
$query->execute;
$nresults = $query->rows;
 
# Display the results
if ( $nresults > 0 ) {
print << "EOF";
<h3>Search Results</h3>
Your query matched <b>$nresults</b> result(s)<br><br>
<table width="100%" cellpadding="5" cellspacing="5" border="0">
<tr>
<td valign="top"><b>#</b></td>
<td><b>BibID / Title / Authors / Citation / Abstract</b> 
	(Last-to-first, with Journals alphabetically sorted)</td>
</tr>
EOF
 
$id=1;
  while(($PubID,$BibID,$Title,$Authors,$JName,$JVolume,$JYear,$JPage,$Abstract)=$query->fetchrow()) {
print << "EOF";
  <tr>
  <td valign="top">
  $id
  </td>
  <td valign="top">
  $BibID |
  <a href="/pdf/$BibID.pdf" target="_blank">PDF</a><br>
  $Title<br>
  $Authors<br>
  <i>$JName</i>, <b>$JVolume</b>, $JPage ($JYear)
  <br><br>
  <p align="justify">
  $Abstract
  </p>
  <br><br>
  </td>
  </tr>
EOF
  $id++;
}
 
print << "EOF";
</table>
EOF
} else {
 
print "<h3>Search Results</h3>\n";
print "<font color=red>Sorry, no records were found!</font>";
}
 
print << "EOF";
<!-- Body ends -->
</body>
 
<!-- HTML ends -->
</html>
EOF
 
# Close database connection
$dbh->disconnect;

#3. Admin Side: pub_entry.cgi

Guidelines for using this are as follows:

1. BibID
   1. Cannot be empty
   2. Maximum of 15 characters
   3. Must be UNIQUE
   4. Cannot be changed later
   5. Good way to compose this is by using first letters of authors’ last names along with year
      (i.e., if R. J. Smith, A. S. Young and B. L. Spring published an article in 2006, BibID would be SYS2006.
      
      In case of single author, use Smith2006)
   6. If you expect to have more than one publication in a year by the same set of authors,
      use SYS2006_0, SYS2006_1, and so on OR Smith2006_0, Smith2006_1, etc.
   7. Required to delete/update an entry, if such a need arises
2. Title
   1. Cannot be empty
   2. Maximum of 255 characters
   3. Can contain some HTML tags (<b>, <em>, <sup>, <sub>, etc)
   4. Use backslash ( \ ) to escape single-quotes ( ‘ )
3. Authors
   1. Cannot be empty
   2. Maximum of 150 characters
   3. Separate authors by using ‘,’ (comma)
   4. Do not use ‘and’
4. Journal :: Name
   1. Cannot be empty
   2. Maximum of 30 characters
   3. Can contain some HTML tags (<sup>, <sub>, etc)
5. Journal :: Volume
   1. Cannot be empty
   2. Must be an integer
6. Journal :: Year
   1. Cannot be empty
   2. Must be an integer
   3. Use all four digits to specify (like ’2006′ instead of ’06′)
7. Journal :: Starting Page
   1. Cannot be empty
   2. Must be an integer
8. Abstract
   1. Can be empty
   2. Maximum of 255 characters
   3. Can contain some HTML tags
      (<b>, <em>, <sup>, <sub>, etc)
   4. Use backslash ( \ ) to escape single-quotes ( ‘ )
9. Journal :: PDF Version
   1. Cannot be empty
   2. PDF document MUST have the SAME name as BibID
   3. MUST be PDF (not just the filename extension)
   4. Process DOES NOT check to make sure it is PDF

The code is split into two parts – default view is to just display a form. When properly submitted, it makes an entry into the database. Code for default view is below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

#! /usr/bin/perl
 
# pub_entry.cgi (PART #1)
# CGI script to make an entry into publication
 
# Modules being used
use DBI;
use CGI;
use CGI::Carp qw ( fatalsToBrowser );
use File::Basename;
 
# Make a CGI object and retrieve information from the form
$inputform = new CGI;
print $inputform->header;
 
# Assign form-values to local variables
$bibid    = $inputform->param("bibid");
$title    = $inputform->param("title");
$authors  = $inputform->param("authors");
$jname    = $inputform->param("jname");
$jvolume  = $inputform->param("jvolume");
$jyear    = $inputform->param("jyear");
$jpage    = $inputform->param("jpage");
$abstract = $inputform->param("abstract");
$jpdfdoc  = $inputform->param("jpdfdoc");
$efill    = $inputform->param("efill");
 
# If variable 'efill' is empty, then display the form
if (!($efill)) {
print << "EOF";
<!-- www.w3c.org standard -->
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
<!-- HTML begins -->
<html>
 
<!-- HEAD section -->
<head>
 
<!-- TITLE section -->
<title>
Your Research Group, Your Academic Institution
</title>
 
</head>
 
<!-- BODY section -->
<body>
 
<!-- Group Header -->
<h1>YOUR GROUP NAME</h1>
 
<h2>Publications :: Database Management :: Entry</h2>
 
<!-- Database Entry Form -->
<form method="POST" action="./pub_entry.cgi" enctype="multipart/form-data">
<table border="0" cellpadding="5" cellspacing="3" align="left">
 
<tr>
<td valign="top"><b>BibID</b></td>
 
<td><input type="text" name="bibid" size="15"></td>
</tr>
 
<tr>
<td valign="top"><b>Title</b></td>
<td><input type="text" name="title" size="35">&nbsp;</td>
</tr>
 
<tr>
<td valign="top"><b>Authors</b></td>
<td><input type="text" name="authors" size="35"></td>
</tr>
 
<tr>
<td valign="top"><b>Journal :: Name</b></td>
<td><input type="text" name="jname" size="35"></td>
</tr>
 
<tr>
<td valign="top"><b>Journal :: Volume</b></td>
<td><input type="text" name="jvolume" size="15"></td>
</tr>
 
<tr>
<td valign="top"><b>Journal :: Year</b></td>
<td><input type="text" name="jyear" size="15"></td>
</tr>
 
<tr>
<td valign="top"><b>Journal :: Starting Page</b> &nbsp; </td>
<td><input type="text" name="jpage" size="15"></td>
</tr>
 
<tr>
<td valign="top"><b>Journal :: Abstract</b></td>
<td>
<textarea name="abstract" rows="5" cols="40"></textarea>
</td>
</tr>
 
<tr>
<td valign="top"><b>Journal :: PDF Version</b> &nbsp; </td>
<td><input type="file" name="jpdfdoc" size="15"></td>
</tr>
 
<tr>
<td colspan="6">
  <input type="hidden" name="efill" value="filled" size="15">
  <input type="submit" value="Make An Entry">
  <input type="reset"  value="Clear Values">
</td>
</tr>
 
</table>
</form>
 
<br clear="all">
<hr>
 
<!-- Body ends -->
</body>
 
<!-- HTML ends -->
</html>
 
EOF
exit;
}

The details regarding uploading a document via PERL & CGI are contained in one of my previous posts. Code for entering the above information into the database follows below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

# pub_entry.cgi (PART #2)
 
# If variable 'efill' is not empty, then insert the data
# into the database
print << "EOF";
<!-- www.w3c.org standard -->
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
<!-- HTML begins -->
<html>
 
<!-- HEAD section -->
<head>
 
<!-- TITLE section -->
<title>
Your Research Group, Your Academic Institution
</title>
 
</head>
 
<!-- BODY section -->
<body>
 
<!-- Group Header -->
<h1>YOUR GROUP NAME</h1>
 
<h2>Publications :: Database Management :: Entry</h2>
<hr>
EOF
 
# Connect to the database and perform the SQL query
$db    = DBI->connect('dbi:mysql:einstein_research:localhost','einstein_web','PASSWORD') or die "Error";
$sql1  = "INSERT INTO publications VALUES ('', '$bibid', '$title', ";
$sql2  = $sql1 . "'$authors', '$jname', '$jvolume', '$jyear', '$jpage', ";
$sql   = $sql2 . "'$abstract')";
$query = $db->prepare($sql);
$query->execute;
 
# PDF upload part
# 5MB limit on the size of the document
$CGI::POST_MAX = 1024 * 1024 * 5;
 
# Characters that are allowed to be part of the filename
my $safe_characters = "a-zA-Z0-9_.-";
 
# Update location
my $upload_location = "/var/www/html/pdf";
 
my $filename = $inputform->param("jpdfdoc");
if ( !$filename ) {
 print $inputform->header ( );
 print << "EOF";
 <p align="justify">
 There was a problem uploading the PDF
 </p>
EOF
 exit;
}
 
# Clean up the filename - remove any 'path' and split the filename into
# basename and extension
my ( $name, $path, $extension ) = fileparse ( $filename, '\..*' );
$filename = $name . $extension;
 
# Replace blank space in filename with 'underscore'
$filename =~ tr/ /_/;
 
# Remove any 'not safe' characters
$filename =~ s/[^$safe_characters]//g;
 
# Untaint the filename
if ( $filename =~ /^([$safe_characters]+)$/ ) {
 $filename = $1;
} else {
 die "Filename contains invalid characters";
}
 
my $upload_filehandle = $inputform->upload("jpdfdoc");
 
open ( UPLOADFILE, ">$upload_location/$filename" ) or die "$!";
binmode UPLOADFILE;
 
while ( <$upload_filehandle> ) {
 print UPLOADFILE;
}
 
close UPLOADFILE;
 
print << "EOF";
<p align="justify">
Data was successfully entered into the database. Click
<a href="./pub_entry.cgi">here</a> to make another entry.
</p>
 
<!-- Body ends -->
</body>
 
<!-- HTML ends -->
</html>
EOF
 
# Close Database Connection
$db->disconnect;

#4. Admin Side: pub_update.cgi and pub_updated.cgi

Often times, it becomes necessary to update an entry (author names, citation, abstract, etc.) and to do so, the appropriate entry must be retrieved from the database. Code for pub_update.cgi follows:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190

#! /usr/bin/perl
 
# pub_update.cgi
# CGI script to retrieve a publication from the database
# for update
 
# Modules being used
use DBI;
use CGI;
 
# Make a CGI object and retrieve information from the form
$inputform = new CGI;
print $inputform->header;
 
# Assign form-values to local variables
$bibid = $inputform->param("bibid");
$rfill = $inputform->param("rfill");
 
# If variable 'rfill' is empty, then display the form
if (!($rfill)) {
print << "EOF";
<!-- www.w3c.org standard -->
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
<!-- HTML begins -->
<html>
 
<!-- HEAD section -->
<head>
 
<!-- TITLE section -->
<title>
Your Research Group, Your Academic Institution
</title>
 
</head>
 
<!-- BODY section -->
<body>
 
<!-- Group Header -->
<h1>YOUR GROUP NAME</h1>
 
<h2>Publications :: Database Management :: Retrieve</h2>
<hr>
 
<!-- Retrieval For Update Form -->
<form method="POST" action="./dbretrieve.cgi">
<table border="0" cellpadding="5" cellspacing="3" align="left">
 
<tr>
<td valign="top"><b>BibID</b></td>
<td><input type="text" name="bibid" size="15"></td>
</tr>
 
<tr>
<td colspan="6">
  <input type="hidden" name="rfill" value="filled" size="15">
  <input type="submit" value="Retrieve An Entry">
  <input type="reset"  value="Clear">
</td>
</tr>
 
</table>
</form>
 
<br clear="all">
<hr>
 
<!-- Body ends -->
</body>
 
<!-- HTML ends -->
</html>
EOF
exit;
}
 
 
# If variable 'rfill' is not empty, retrieve data from the database
print << "EOF";
<!-- www.w3c.org standard -->
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
<!-- HTML begins -->
<html>
 
<!-- HEAD section -->
<head>
 
<!-- TITLE section -->
<title>
Your Research Group, Your Academic Institution
</title>
 
</head>
 
<!-- BODY section -->
<body>
 
<!-- Group Header -->
<h1>YOUR GROUP NAME</h1>
 
<h2>Publications :: Database Management :: Retrieve</h2>
<hr>
EOF
 
# Connect to the database and perform the SQL query
$db    = DBI->connect('dbi:mysql:einstein_research:localhost','einstein_web','PASSWORD') or die "Error";
$sql   = "SELECT * FROM publications WHERE BibID='$bibid' LIMIT 1";
$query = $db->prepare($sql) or die "Error";
$query->execute;
 
while(($PubID,$BibID,$Title,$Authors,$JName,$JVolume,$JYear,$JPage,$Abstract)=$query->fetchrow()) {
print << "EOF";
 
<!-- Database Entry Form -->
<form method="POST" action="./pub_updated.cgi">
<table border="0" cellpadding="5" cellspacing="3" align="left">
 
<tr>
<td valign="top" width="25%"><b>BibID</b></td>
<td>$BibID</td>
</tr>
 
<tr>
<td valign="top"><b>Title</b></td>
<td><input type="text" name="title" size="35" value='$Title'>&nbsp;</td>
</tr>
 
<tr>
<td valign="top"><b>Authors</b></td>
<td><input type="text" name="authors" size="35" value='$Authors'></td>
</tr>
 
<tr>
<td valign="top"><b>Journal :: Name</b></td>
<td><input type="text" name="jname" size="35" value='$JName'></td>
</tr>
 
<tr>
<td valign="top"><b>Journal :: Volume</b></td>
<td><input type="text" name="jvolume" size="15" value='$JVolume'></td>
</tr>
 
<tr>
<td valign="top"><b>Journal :: Year</b></td>
<td><input type="text" name="jyear" size="15" value='$JYear'></td>
</tr>
 
<tr>
<td valign="top"><b>Journal :: Starting Page</b> &nbsp; </td>
<td><input type="text" name="jpage" size="15" value='$JPage'></td>
</tr>
 
<tr>
<td valign="top"><b>Journal :: Abstract</b></td>
<td>
<blockquote>
$Abstract
</blockquote>
<textarea name="abstract" rows="5" cols="40" value='$Abstract'>
Type in new abstract OR copy the existing one from above</textarea>
</td>
</tr>
 
<tr>
<td colspan="6">
  <input type="hidden" name="bibid" value='$bibid'>
  <input type="hidden" name="rfill" value="filled" size="15">
  <input type="submit" value="Update An Entry">
  <input type="reset"  value="Clear Values">
</td>
</tr>
 
</table>
</form>
EOF
}
 
print << "EOF";
<!-- Body ends -->
</body>
 
<!-- HTML ends -->
</html>
EOF
 
# Close Database Connection
$db->disconnect;

pub_update.cgi takes all the information and passes it over to pub_updated.cgi, which updates the record. Code for pub_updated.cgi follows below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

#! /usr/bin/perl
 
# pub_updated.cgi
# CGI script to update an entry in the database
 
# Modules being used
use DBI;
use CGI;
 
# Make a CGI object and retrieve information from the form
$inputform = new CGI;
print $inputform->header;
 
# Assign form-values to local variables
$bibid    = $inputform->param("bibid");
$title    = $inputform->param("title");
$authors  = $inputform->param("authors");
$jname    = $inputform->param("jname");
$jvolume  = $inputform->param("jvolume");
$jyear    = $inputform->param("jyear");
$jpage    = $inputform->param("jpage");
$abstract = $inputform->param("abstract");
 
print << "EOF";
<!-- www.w3c.org standard -->
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
<!-- HTML begins -->
<html>
 
<!-- HEAD section -->
<head>
 
<!-- TITLE section -->
<title>
Your Research Group, Your Academic Institution
</title>
 
</head>
 
<!-- BODY section -->
<body>
 
<!-- Group Header -->
<h1>YOUR GROUP NAME</h1>
 
<h2>Publications :: Database Management :: Retrieve</h2>
<hr>
EOF
 
# Connect to the database and perform the SQL query
$db    = DBI->connect('dbi:mysql:einstein_research:localhost','einstein_web','PASSWORD') or die "Error";
$sql1  = "UPDATE publications SET Title='$title',Authors='$authors',";
$sql2  = $sql1 . "JName='$jname',JVolume='$jvolume',JYear='$jyear',";
$sql   = $sql2 . "JPage='$jpage',Abstract='$abstract' WHERE BibID='$bibid' ";
 
$query = $db->prepare($sql);
$query->execute;
 
print << "EOF";
<p align="justify">
Data was successfully updated in the database. Click
<a href="./pub_update.cgi">here</a> to update another entry.
</p>
 
<!-- Body ends -->
</body>
 
<!-- HTML ends -->
</html>
EOF
 
# Close Database Connection
$db->disconnect;

#5. Admin Side: pub_delete.cgi

Seldom it becomes necessary to delete an entry from the database (a reference article entered in by mistake as a publication, etc.) and the code for pub_delete.cgi follows:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

#! /usr/bin/perl
 
# pub_delete.cgi
# CGI script to delete an entry from the database
 
# Modules being used
use DBI;
use CGI;
 
# Make a CGI object and retrieve information from the form
$inputform = new CGI;
print $inputform->header;
 
# Assign form-values to local variables
$bibid = $inputform->param("bibid");
$dfill = $inputform->param("dfill");
 
# If variable 'dfill' is empty, then display the form
if (!($dfill)) {
print << "EOF";
<!-- www.w3c.org standard -->
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
<!-- HTML begins -->
<html>
 
<!-- HEAD section -->
<head>
 
<!-- TITLE section -->
<title>
Your Research Group, Your Academic Institution
</title>
 
</head>
 
<!-- BODY section -->
<body>
 
<!-- Group Header -->
<h1>YOUR GROUP NAME</h1>
 
<h2>Publications :: Database Management :: Delete</h2>
<hr>
 
<!-- Database Deletion Form -->
<form method="POST" action="./pub_delete.cgi">
<table border="0" cellpadding="5" cellspacing="3" align="left">
 
<tr>
<td valign="top"><b>BibID</b></td>
<td><input type="text" name="bibid" size="15"></td>
</tr>
 
<tr>
<td colspan="6">
  <input type="hidden" name="dfill" value="filled" size="15">
  <input type="submit" value="Delete An Entry">
  <input type="reset"  value="Clear">
</td>
</tr>
 
</table>
</form>
 
<br clear="all">
<hr>
 
<!-- Body ends -->
</body>
 
<!-- HTML ends -->
</html>
EOF
exit;
}
 
# If variable 'dfill' is not empty, then delete an entry
# from the database
print << "EOF";
<!-- www.w3c.org standard -->
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
<!-- HTML begins -->
<html>
 
<!-- HEAD section -->
<head>
 
<!-- TITLE section -->
<title>
Your Research Group, Your Academic Institution
</title>
 
</head>
 
<!-- BODY section -->
<body>
 
<!-- Group Header -->
<h1>YOUR GROUP NAME</h1>
 
<h2>Publications :: Database Management :: Delete</h2>
<hr>
EOF
 
# Connect to the database and perform the SQL query
$db    = DBI->connect('dbi:mysql:einstein_research:localhost','einstein_web','PASSWORD') or die "Error";
$sql   = "DELETE FROM publications WHERE BibID='$bibid' LIMIT 1";
$query = $db->prepare($sql) or die "Error";
$query->execute;
 
print << "EOF";
<p align="justify">
Entry was successfully deleted from the database. Click
<a href="./pub_delete.cgi">here</a> to delete another entry.
</p>
 
<!-- Body ends -->
</body>
 
<!-- HTML ends -->
</html>
EOF
 
# Close Database Connection
$db->disconnect;

#6. Admin Side: Restricting Access To Admin Interface

There are some ways of achieving this – to prevent unauthorized personnel from messing with databases and files.

1. Password protect the admin folder – allow only a certain user from any machine
2. IP address/Hostname based restriction – allow any user (preferably a group member) to access the admin interface from certain machine(s).
3. Combination of #1 & #2 – allow only certain users from certain machines.

A simple Google!ing for password protection .htaccess .htpasswd should result in a good number of decent documents. But do check/discuss your approach with your systems administrator(s) – to make sure that it can be applied, is feasible and less mis-usable under existing circumstances.

Screenshots

The screenshots below were generated after incorporating the style sheets (CSS) that are in-line with Michigan Tech theme. The code in the above sections, however, results in very plain, bare-bone HTML pages. With a basic, working knowledge of CSS, it should not be too difficult to spice up the appearance:

Publications – Default View

Publications – When a query is performed

Making a new entry

Deleting an entry

Retrieval for update

Updating an entry

Demonstration

Live demo of this code, only the publications.cgi, is here. Others, as can be expected, are hidden in a secure folder.

Red Bank, NJ → Houghton, MI

It would be an understatement if I said I was excited for this trip – so much so that I could not sleep the entire previous night. Also, I had to abandon any thoughts of driving up amidst such excitement – to keep myself (and other fellas on road) safe. Cutting the long story short, both segments of the journey, Newark → Minneapolis/St. Paul and Minneapolis/St. Paul → Houghton, were pretty smooth and on time. Fellow travelers and the flight attendants probably felt the brunt of much my yapping but they seemed to understand my excitement – so, it was all ok

The Paradise

I can’t seem to express nor find words to express the excitement of just being here, amidst so many people – that have helped make my graduate student days very very memorable. Naming each one of them is beyond the scope this post but trust me, I appreciate anything and everything they have done for me. To sum up this trip (thanks to my buddy Kyle for putting me up and lending his tripod):

Rest of the pictures are here: ROTC Commissioning | Commencement

As much as I enjoyed being there, hanging out with friends, and as much as I might have painted a picture of myself (in recent years) as the cold-hearted, emotionless animal, leaving the town (I don’t yet know when I will return next) was probably the toughest to deal with. I was under the impression that it wouldn’t be as difficult as it was the first time but believe me, my impression was completely wrong. And I am not alone on this boat either – quite many of my friends are experiencing the same inexplicable torturous feeling that surfaces while leave this town.

Houghton, MI → Red Bank, NJ

Amidst the aforementioned feeling, it wasn’t easy coming back but the flights were pretty smooth and on time. I feel pretty relaxed and my batteries are well charged up for the daily grind of next few months

Instructions given in this page are what I used to configure my Sony Vaio VGN-S360 notebook and DELL Dimension 3000 desktop. These may very well be applicable to your computer, of other brand/model. However, note that you are using these instructions at your very own risk and this website, sgowtham.net, is not responsible for any/all damage caused to your property, intellectual or otherwise. Additionally, using PINE to access MTU Email and certain features (like accessing LDAP) automatically binds you to Internet/Email usage policies of Michigan Technological University. You are advised to read this document.

What is PINE, etc.

PINE® – a Program for Internet News & Email – is a tool for reading, sending, and managing electronic messages. PINE was developed by Computing & Communications at the University of Washington. Though originally designed for inexperienced email users, PINE has evolved to support many advanced features, and an ever-growing number of configuration and personal-preference options. PINE is available for Unix as well as for personal computers running a Microsoft operating system (PC-PINE). General User Guide is here and this article discusses the following :

1. Getting PINE and installing it (Linux)
2. Configuring it :
   1. Making it work from off-campus, especially with Charter Communications connection
   2. Adding MTU Address Book (LDAP) search feature
3. Generating a GPG Public-Private Key pair (Not in detail)
4. Embedding Digital Signature/Message Encryption feature
5. Setting up multiple roles (different From addresses; Not in detail)
6. Using it from commandline (Not in detail)
7. Entry without password? (Not in detail)

1. Installation

1. Visit PINE for Linux site and download the latest version of appropriate package. I recommend getting the source package and compiling it yourself. Moreover, pre-compiled rpm does not have the ssl feature which is required for accessing MTU mail from off-campus.
2. Compile the source (as root) by executing the command

   rpmbuild --rebuild pine-4.6x-1.i386.src.rpm 2>&1 | tee pine-4.6x-1.rpmbuild.log

3. Get into /usr/src/redhat/RPMS/i386/ and run

   rpm -ivh pine4.6x-1.i386.rpm

   and

   rpm -ivh pine-debuginfo-4.6x-1.i386.rpm

   to install PINE.

2 Configuring PINE

2.1 Making it work from off-campus

Tips and tricks suggested by CEC personnel in MTU, have been of great help in this step (especially PORT 2525 stuff) when I dealt with PINE 4.61 – I have used them again and included some more in this version. You can configure either by choosing (M) MAIN MENU » (S) SETUP » (C) Config, or edit .pinerc file, located probably in your $HOME directory. If you choose to use the second option, here is my .pinerc file. Use it as reference, if you like.

1
2
3
4
5
6
7
8
9
10
11

personal-name=Your Name
 
user-domain=mtu.edu
 
smtp-server=email.mtu.edu:2525/tls/user=your-user-id
# use Port 2525 for outgoing mails since Charter blocks Port 25
 
inbox-path={email.mtu.edu/ssl/user=your-user-id}INBOX
 
folder-collections={email.mtu.edu/ssl/user=your-user-id}[]
# This is to prevent messages from being stored locally on your computer

That’s it! However, PINE will prompt for your password before sending the first message but it will won’t prompt again during the rest of the session. Messages read/sent out will not be saved on your local machine.

2.2 Adding MTU Address Book (LDAP) search feature

Thanks again to CEC personnel, I could configure PINE to look-up the MTU Address Book while composing messages. Procedure is quite simple and is as follows :

1. Start PINE and (M) MAIN MENU » (S) SETUP » SETUP » (D) Directory » (A) Add Dir to add a new directory server.
2. The cursor should be on the first option, ldap-server. Press Enter and enter the following :

   ldap.mtu.edu

3. For the next option, search-base, enter

   dc=mtu,dc=edu

4. Leave the third option as it is and for the last option, nickname, choose a name by which you want to recognize this directory server. I chose MTU Address Look Up
5. Under the Features option, check use-implicitly-from-composer so that PINE will look-up the MTU Address Book when you type just a user-id while composing a message.
6. Under the search-type option, you may choose to go with the default option or choose something that suits you. With the default option (sur-or-given-or-name-or-email), PINE will return all the results that matches the surname associated with the user-id and gives you the option to choose the one you want.

If you wish to save the search results to your local .addressbook, you may do so by selecting ldap-result-to-addrbook-add under Address Book Preferences in (M) MAIN MENU » SETUP » (C) Config

Steps (1)-(5) used to add MTU Address Book Search feature to PINE can also be achieved by editing your $HOME/.pinerc file. Search for the string ldap-servers in my .pinerc file and observe that line.

3. Generating GPG Public-Private Key pair

There are several methods (built-in gpg command is one of them) to generate Public-Private Key pair and lot of online documents to help you out. Generate a pair for yourself using a method that’s convenient to you.

4. Embedding Digital Signature / Message Encryption feature into PINE

Method One

1. Download these scripts to $HOME/.gnupg folder

   verify | sign | encrypt

   These are just gpg command with different options.

2. In the .pinerc, search for display-filters and make that line look as follows:

   1	display-filters=_LEADING("-----BEGIN PGP")_ $HOME/.gnupg/verify

3. In the .pinerc, search for sending-filters and make that line look as follows:

   sending-filters=$HOME/.gnupg/sign
   $HOME/.gnupg/encrypt
   

Method Two (One which I am currently using)

1. Find out where gpg command is stored and create the following symbolic links in $HOME/.gnupg folder.

   ln -s /usr/bin/gpg ~/.gnupg/gverify
   ln -s /usr/bin/gpg ~/.gnupg/gsign
   ln -s /usr/bin/gpg ~/.gnupg/gencrypt

2. In the .pinerc, search for display-filters and make that line look as follows:

   1	display-filters=_LEADING("-----BEGIN ")_ ~/.gnupg/gverify

3. In the .pinerc, search for sending-filters and make that line look as follows:

   1 2	sending-filters=~/.gnupg/gsign --clearsign, ~/.gnupg/gencrypt -eas -r _RECIPIENTS_

You are all set – when you are done writing a message and press Ctrl+X to send it, PINE offers options to send it unfiltered or sign and/or encrypt. You can switch between these options using Ctrl+N and Ctrl+P. If you choose not to send it as unfiltered, you will be prompted to enter the passphrase. When you receive a message encrypted using your Public Key, PINE will automatically decrypt it for you.

5. Multiple Roles (Different From Addresses)

You can read/learn about it here. I have used the instructions give there to setup four different From addresses with just one instance of PINE.

6. Using PINE from command-line

You can read/learn about it here. I use this feature, every once in a while, when mail command decides to trouble me.

7. Entry without password

Needless to say that this feature should be enabled (preferably) iff (iff = if and only if, a mathematical notation) PINE is being used in a single user environment and as to how to do it, instructions are here (under Defining a Password File section).

#2 making a jump shot for a 2-pointer.

#4 had the game of his career at Tech

Sometime between I went into the Michigan Tech Gym (not to work out, but to watch these games) and came out of it, somebody had gone out and had convinced winter – to come into the Yooper land. And by the time I woke up this morning, there was white stuff everywhere. I still wasn’t getting anywhere with the compilation process and so, after a short stop at Victoria’s Kitchen, I headed off to the northern Keweenaw Peninsula to check out the frest stock of snow

Somewhere in the vicinity of mining relics on Quincy Hill

In the vicinity of mining relics on Quincy Hill

In the vicinity of mining relics on Quincy Hill

Snow covered trees along US-41

Camp Ground along 7 Mile Point Road – locked entrance didn’t stop me from getting in…

Wavy L. Superior on a windy day … 7 Mile Point Road

In the sideyard of Sand Hills Light House … 5 Mile Point Road

Eagle River Falls – off of M26

Eagle River Community Center – shot from Lake Shore Drive Bridge

Semi-frozen Eagle River with L. Superior in the background

Apparently, weather got warmer as time went by but like you have seen in the above pics (rest of them are here), things were still quite pretty. This is the second time this season it has snowed so much in such a short time – but unlike first time, we only hope this one will stay for a while…

Fall foliage along M26

Porcupine Mountains

Lake of Clouds, Porcupine Mountains

M107, near Porcupine Mountains

Contrary to my last visit, Lake Superior was its quietest – nearly optically-flat surface all along the shore and the weather was a bit too chilly (guess it’s a trade off: need colors? get cold weather too…) Colors, needless to mention – as far as my eyesight could take. Overall, it was quite a nice trip – though I would have loved to do the Lake Superior Circle Tour – may be some day, hopefully….

After a good-night’s rest, I woke to the day after Houghton’s Hobo Parade – for the fourth successive year, I missed it, but Kyle shot some nicer pictures…I wandered about a bit and managed to get some left-over shots of that parade…

Remnants of Hobo Parade

Remnants of Hobo Parade

It was Home Coming Weekend and Tech was facing off Hillsdale in GLIAC Football. /me went to the game, met lot of friends and I fought hard (no, no… I *shot* hard with my camera) to make sure that Tech won its first game of the season – a pretty close one at that. If only I was allowed to shoot from the sidelines, I would have gotten better pictures. And this makes me seriously think about getting a *fake press ID* for myself…

Sherman Field, Michigan Tech

Michigan Tech Pep Band in Hobo Outlook

Die Hard Tech Fans

Michigan Tech Huskies

Huskies In Action against Hillsdale Chargers

Huskies In Action against Hillsdale Chargers

Huskies In Action against Hillsdale Chargers

Someday during the first part the new week, I squeezed sometime to shoot some more pictures – Houghton’s Cemetery, Sunset in McLain State Park, and such.

Houghton Cemetery

Light House near Breakers

McLain State Park

Sunset @ McLain State Park

Guess, we have just handful of days left before Fall ends and the looooooooong season starts – few of my friends have been planning something for the upcoming weekend. And if snow decides to make an early appearance, you can expect a variety of pictures in my next entry….

Week started off on a rather slow note but since we knew it would, we started off the workshop by surveying the kids – something to get them talking. First it was a survey of what they knew (turning a computer on & off, using the internet, downloading from the internet, checking emails, word-processing, excel, powerpoint, etc.) and how much they knew of it – in order to get an idea of the knowledge-spectrum of the class and more importantly, to know about those kids who needed extra attention. Then, they listed what they like about computers and what they don’t (annoyances) – and needless to mention, the latter list was much bigger. Some amount of time was dedicated to show them methods of graphing the data (by hand) and later in the afternoon, kids spent time at the SDC – shooting baskets. It was nice of some Tech Basketball players (and friends of mine – Bob Evans, Radayl Richardson, Robby Springborn and Josh) to give some shooting tips and watch while they were shooting. I am quite sure kids loved it. The act of shooting the basketball also served the purpose of collecting useful data – which they used to plot using Excel the next day.

So, the next few days rolled on with participants learning about different aspects of computers as well as science – methods of data collection, analysis and presentation. Syllabus also included combined sessions, often hands-on, where students shared their knowledge with their teachers. What impressed me the most was the dedication of teachers – they often came in early, sometimes skipped lunch and did everything possible to learn the material; and once students warmed-up, they had lot of fun too. Short field trips, techniques in digital photography, post-processing with Photoshop, making movies, principles of software design, etc… – gave the participants wide range of things to chew on. Some of the photos I shot during these days are here.

What did I learn, you ask? — lot of things to be honest. Importantly, I re-realized the fact that teaching can be lot of fun. Following is the excerpt from Surely You’re Joking, Mr. Feynman (Dignified Professor chapter) – a book that one should read, if haven’t already. But don’t get me wrong, I have my highest respect for those who do research all the time as they expand the frontiers of knowledge by pushing the barriers far and wide than we ever imagined – society also needs some who can teach the pass such knowledge onto students.

I don’t believe I can really do without teaching. The reason is, I have to have something so that when I don’t have any ideas and I’m not getting anywhere I can say to myself, “At least I’m living; at least I’m doing something; I’m making some contribution” — it’s just psychological.

When I was at Princeton in the 1940s I could see what happened to those great minds at the Institute for Advanced Study, who had been specially selected for their tremendous brains and were now given this opportunity to sit in this lovely house by the woods there, with no classes to teach, with no obligations whatsoever. These poor bastards could now sit and think clearly all by themselves, OK? So they don’t get any ideas for a while: they have every opportunity to do something, and they’re not getting any ideas. I believe that in a situation like this a kind of guilt or depression forms inside of you, and you begin to worry about not getting any ideas. And nothing happens. Still no ideas come.

Nothing happens because there’s not enough real activity and challenge: You’re not in contact with the experimental guys. You don’t have to think how to answer questions from the students. Nothing!

In any thinking process there are moments when everything is going good and you’ve got wonderful ideas. Teaching is an interruption, and so it’s the greatest pain in the neck in the world. And then there are the longer periods of time when not much is coming to you. You’re not getting any ideas, and if you’re doing nothing at all, it drives you nuts! You can’t even say “I’m teaching my class.”

If you’re teaching a class, you can think about the elementary things that you know very well. These things are kind of fun and delightful. It doesn’t do any harm to think them over again. Is there a better way to present them? Are there any new problems associated with them? Are there any new thoughts you can make about them? The elementary things are easy to think about; if you can’t think of a new thought, no harm done; what you thought about it before is good enough for the class. If you do think of something new, you’re rather pleased that you have a new way of looking at it.

The questions of the students are often the source of new research. They often ask profound questions that I’ve thought about at times and then given up on, so to speak, for a while. It wouldn’t do me any harm to think about them again and see if I can go any further now. The students may not be able to see the thing I want to answer, or the subtleties I want to think about, but they remind me of a problem by asking questions in the neighborhood of that problem. It’s not so easy to remind yourself of these things.

So I find that teaching and the students keep life going, and I would never accept any position in which somebody has invented a happy situation for me where I don’t have to teach. Never.

Thanks to Dr. P, our department (esp. Beth who did all the required paper-work), organizers and fellow instructors, I was very fortunate to have had this opportunity to work with kids for a week. I got to know of fellow instructors (Erin K and Karen K), many more known/previously-unknown people in the Humanities (Matt Hill, Jim Oliver, Michael, …) and 23 people from down-state. I have kinda started liking the CCLI (a.k.a computer lab) in Humanities – for one, it’s air-conditioned (or at least, it feels like it is) and second, it has a separate Mac section, which is really very cool. I am glad that kids got to use Macs too – as many of them later admitted that they would never want to use a Windows machine again. With the help of Erin and Karens (S and K), I will probably learn more about Photoshop, get tips to improve my manual-writing skills, and enhance my website. Wish I was part of something like this long time ago – I would have known these people for long, would have shared (and gained) information, written better manuals (which our users actually READ), …

But such is life – nothing ever happens before its time and beyond one’s destiny. I am just glad that it was finally my turn Here’s a template (sample) of the certificates (designed by Erin) kids got at the end of this 5-day workshop. Pretty cool, heh?

There are some things that I don’t like about such short-duration workshops. It usually takes about 2-3 days for participants to get warmed up & get used to the new environment & instructors. By the time we really start to jell together as a team, it’s about time for them to leave. To see participants call their instructors not-so-entertaining on day one and regard them as cool by day five can and does bring about lot of satisfaction, and hints at a job well done. To me, like every other instructor, it was very heart-warming to be hugged by almost every participant and to be asked to sign in their books.

But again, such is life – things happen, people come and go, but memories just (sometimes) stay forever…

Couple of fellow graduate students did their prelims and our Department, as it has been the tradition, hosted Spring Feedback Pizza Party. Many of the new students complained about weather conditions and qualifiers, while yours truly, as usual, brought up physerver disk usage and aging issues. During this meeting, it was also mentioned that some old machines in the Physics Grad Lab would be replaced with new ones. Upon hearing this, after the meeting, I proposed to the department about using them to set up a Cluster Work Bench. When built, this cluster work bench will serve as good instructional resource, and other reasons for this proposal are as follows:

1. CPU cylces can be used instead of the machines sitting idle in some closet
2. People (faculty and students alike) who would like to learn building a clusters (a.k.a. getting their hands dirty), can do so
3. Research groups planning to have a cluster of their own, can learn proper usage techniques
4. Research groups that have a cluster already, may use it as a not-so-risky platform to test new compilations
5. Some others, who may not be in a position to afford a cluster, can get their research done
6. This set up can also be used for small Summer projects, course-work projects, etc
7. Since we (dept) need to pay for disposal, part of that disposal money can be used to pay for network connection

For the last few days, I have been somewhat occupied with preparing slides for the upcoming APS meeting in Baltimore, and we have couple of practice talks scheduled in the next week. Almost all preparations from my side are done – request for leave of absence, transportaion (air and local), list of talks to attend, list of other (non-research) things to do, complete mailing address of all people I am planning to visit (I still have to print driving directions though), … Hopefully, everything will go according to the plan. Preparations are also underway (thanks to Kyle Schneider) for attending the PenguiCon 4.0, in Livonia, just the weekend before Tech finals. I have nothing to worry about as I have no finals to take I am about to complete planning for the conference in Cochin (India), later this year – should be fun times, to meet my teachers and friends….

Coming to other things, Tech basketball teams (both men and women) lost in the GLIAC quarter-finals. David Otokpa has promised me to send his comments/suggestions about my photos and I am eagerly looking forward to that. I have also been planning to find a new place to live – not that there is anything wrong with the current place, but with quite a few friends planning to visit me in the next three semesters or so, it will be a good idea to have a separate place. I had signed a contract too, for a place in Hancock, but have requested them to cancel it as a result of some unforeseen circumstances. Over the last few days, I was informed about this website, kalyanvarma.net and the wildlife photos (in and around Karnataka, India) are just too good. I modified certain parts of my website, mostly related to photo gallery, to make them more user-friendly. After some struggle, searching around and LUG members’ help, I have managed to get Kannada fonts in Mozilla Firefox under Linux (Red Hat Enterprise). This means that I no longer have to boot my laptop in Windows just to read some of my friends’ blogs. A fellow graduate student told me the best computer-related joke ever….

When Microsoft finally makes a product that doesn’t suck, it will be a Vacuum Cleaner!

Until next time, have fun

I got in touch with few of Intel’s authorized resellers (one in Bloomington, MN – who transferred the call to someone else in Boston, MA) to see if I can get a copy of version 8.x of FORTRAN and C compilers. Though the latter person promised to get back to me with some favorable information soon, I got directly in touch with an Intel Support Technician – hoping that he/she wouldn’t be from a call center in some other country. Fortunately, it was somebody in California and unfortunately, he redirected me back to their re-sellers. Last call, pretty much out of desperation, did what I wanted : I just had to register the non-commercially downloaded products for Premier Support and I would be entitled for previous versions too. If only Intel explicitly mentioned what Premier Support actually is, my worries would have ended a long time ago. By the way, if you are now wondering what the error message was (running on 2 processors), here it is:

1
2
3
4
5
6
7
8
9
10
11
12
13

running on    2 nodes
distr:  one band on    1 nodes,    2 groups
vasp.4.6.28 25Jul05 complex
POSCAR found :  4 types and   18 ions
LDA part: xc-table for Ceperly-Alder, standard interpolation
found WAVECAR, reading the header
POSCAR, INCAR and KPOINTS ok, starting setup
WARNING: wrap around errors must be expected
FFT: planning ...           1
reading WAVECAR
the WAVECAR file was read sucessfully
LAPACK: Routine ZPOTRF failed!           8
LAPACK: Routine ZPOTRF failed!           8

Having managed to get version 8.x and 7.x of Intel compilers, situation only got worse as the error message remained the same At this point, I must thank the help offered by VASP Tech Support and Andri Arnaldsson (from University of Washington) – they have been pretty quick in their responses, sent their copies of Makefiles along with several tips and tricks. Changing compiler versions, using a previous version of MPICH (1.2.7p1 to be precise), repeating compilation many times with different BLAS, LAPACK libraries … nothing helped.

Taking a break for an hour and watching an episode of South Park seemed to have helped. A modification in the key words used for Google! search and reading some discussion forum lot more carefully, I found that adding three lines at the end of VASP Makefile (what this does is to reduce the level of optimization for mpi.F), the error vanished and the calculations started running smoothly. I repeated the same calculation using 2, 4, 6 and 8 processors and noticed a slightly strange behavior – when the number of processors was 2, 4 or 8, energy optimization is exactly same as in a serial calculation but when the number of processors is 2*N (N=3 in this case), energy optimization route is different – final result is still exactly the same. Though I have to do more trials (say 3, 5, 7, 9, 10 processors) to completely convince myself, it appears to me that using 2^N processors does the trick. Like Dave Kraus mentioned once before – knowing what trick works is certainly important, but knowing why that trick works is even more important.

As if my strike-out wasn’t enough to put me down, Pistons lost their first game in the NBA finals too, to completely turn me off… Well, this is definitely a good day to forget.

Finals, against IT : I was, from the match against the same team last week, under the impression that EE would be a our opponent in this game. But as things had turned out on Field #2, IT had beaten EE with home-team advantage . The poster was about half ready and I guess being home-team gave us some advantage. After holding IT for zero, we scored 8 in the first and again, 7 of these came after we were two down and the innings came to a halt as a result of my poor shot. This IT was not the same which had beaten us 18 – 31 in the first game. If batting was at it’s brutal best and base running lightning fast, defence was at its greatest. Hardly anything that went up in air reached ground and IT running was no match for our solid defence. We made plenty of plays at the first and second bases and effected a double play too, to make it spicy. Home runs flowed and with everybody (Patrick, Mary, Tilvi, Haiying, Marg, Daniel and many more) cheering us all along, we beat IT 20 – 5 (yes, twenty to five) by the bottom of sixth (call this the sweetest revenge!) and celebrations began soon – on the field and carried over to the Downtowner for rest of the evening… All the hard work we had put in under scorching Sun on Sundays had paid off.

• Dress – probably the event required very smart turn out, like a blazer and a tie or so.
• Topic of research and presentation – it’s a theory and more of computationally oriented; not many will appreciate the significance of my numbers. OR my inability to make general audience understand what these numbers mean.
• General audience can picturise, understand and appreciate the technological applications more easily than it does of some set of numbers and pretty looking molecules.
• My way (posture, etc) of presenting my research.
• Time constraint – choosing what to present and what not to present; how to present and how not to present – I
  will have to work on it.

I did learn some very important lessons from this colloquium and I am glad that the organizers will send us judges’ comments.