High Performance Computing

Coarray Fortran 2.0 in Supercomputing 2011

2011-12-05T12:39:00.001-06:00

Taken from Rice University news http://compsci.rice.edu/news.cfm?doc_id=14042 :

In a competition held at SC11—the International Conference for High Performance Computing, Networking, Storage, and Analysis—in Seattle, Washington in November 2011, Rice University's Coarray Fortran (CAF) 2.0 language, compiler, and runtime system received an award as as one of three finalists in the HPC Challenge Class II Awards Competition. The CAF 2.0 project is led by Professor John Mellor-Crummey.

At SC11, Dr. Laksono Adhianto delivered a presentation about CAF 2.0, a set of language extensions that support scientific programming on scalable parallel systems in a session devoted to the HPC Challenge Awards Competition. The presentation described the implementation and performance of several CAF 2.0 programs that solve problems in the HPC Challenge Benchmark suite. These programs were then run on up to 8,192 cores of several Department of Energy supercomputers. Other members of the Rice Coarray Fortran 2.0 project team include Guohua Jin, Mark Krentel, Karthik Murthy, Dung Nguyen, William Scherer III, Scott Warren, and Chaoran Yang

Exascale programming: Won't be and will be

2011-04-15T11:36:00.003-05:00

There is a very interesting article in hpcwire written by Michael Wolfe (PGI) on the "emerging" of exascale programming: http://www.hpcwire.com/features/Compilers-and-More-Programming-at-Exascale-117593783.html?viewAll=y There are some interesting points we can learn: Exascale Programming: What It Won't Be

It's not a library: it hides the algorithm, data structures, and performance aspects
It's not a C++ class hierarchy or template library: Too much abstraction
It's not a domain-specific language: DSL don't have a large enough user community, not enough support.
It's not OpenCL: very low level, too complicated.
It's not a whole new language: most programmers avoid adopting a new language for fear that it will die
It's not easy. The idea of making parallel programming easy is silly (?)
It's not just parallelism: the key isn't parallelism, it's performance

Exascale Programming: What It Is

It supports all levels of parallelism, from node parallelism down to vector and pipeline parallelism, effectively.
It can map an expression of program parallelism (a parallel loop, say) to different levels of hardware parallelism (across nodes, or to a vector unit) depending on the target.
It supports the programmer with lots of feedback.
It supports dynamic parallelism, creating parallel tasks and threads when needed.
It efficiently composes abstract operations
It is self-balancing and self-tuning.
It must be resilient.

I agree most of the above points, except for the exascale programming won't be easy. Yes, effective parallel programming is not easy, and easy parallel programming is not effective. But this does not mean there is no way to be both easy and effective. I think the main key is about productivity. It is okay to be not efficient as long as we can tolerate the performance.

Creating customized toolbar in Eclipse view

2007-11-15T09:13:00.000-06:00

By default, Eclipse view toolbar appears on the right side of the view as shown in the image below: This is fine when we the actions are not visually associated in any columns. However, one we need to associate a button or toolitem to a table column or a column header, we need to place the toolbar as closed as possible to the table column. Here is the trick: we need to design a layout, preferably a GridLayout, then place the toolbar on top of the tree view or table view.

    private Composite createCoolBar(Composite aParent) {
     // make the parent with grid layout
     GridLayout grid = new GridLayout(1,false);
     aParent.setLayout(grid);
     CoolBar coolBar = new CoolBar(aParent, SWT.FLAT);
        GridData data = new GridData(GridData.FILL_HORIZONTAL);
     coolBar.setLayoutData(data);
     // prepare the toolbar
     ToolBar toolbar = new ToolBar(coolBar, SWT.FLAT);
     
     // ------------- prepare the items
     // flatten
     ToolItem tiFlatten = new ToolItem(toolbar, SWT.PUSH);
     tiFlatten.setToolTipText("Flatten the node");
        ....
 return aParent; // no changes, reuse the parent
     }
    public void createPartControl(Composite aParent) {
     Composite parent = this.createCoolBar(aParent);
        treeViewer = new TreeViewer(parent, 
               SWT.SINGLE|SWT.FULL_SELECTION | SWT.BORDER);
        ....
        // tricky: needed to expand the tree
        GridData data = new GridData(GridData.FILL_BOTH);
        treeViewer.getTree().setLayoutData(data);

    }

The result is shown below:

Eclipse RCP: Is it really easy ?

2007-11-05T10:21:00.000-06:00

Eclipse RCP supposed to be to easy and to help programmers not to reinvent the wheel. Unfortunately, its design to be as general as possible makes it hard to understand due its highly rich of features and complex. For simple RCP, as provided by some samples and snippets (can be checked out via eclipse's repository), Eclipse is fun and easy. This is true at the beginning, but as the time goes on, programmers will face very complex and intuitive way to build a rich application.

However, having search for a complete tutorial on Internet, a very interesting page written by Lars Vogel describes a step-by-step programming with Eclipse RCP from feature perspective. The article is accessible from this URL: http://www.vogella.de/articles/RichClientPlatform/article.html

This article although not very deep, but it covers functionalities that most programmers need. A high recommend article to read for those who have no time to read books.

cafc: Co-array Fortran Compiler from Rice

2007-09-26T11:25:00.000-05:00

Rice has their own Co-array Fortran source-to-source compiler named cafc. The source code can be downloaded from http://www.hipersoft.rice.edu/caf/download.html together with Open64/SL. It also needs third party libraries: ARMCI+MPI or Gasnet.

The libf90caf source code files are:

#----------------------------------------------------------------------
# List of Source files
#----------------------------------------------------------------------
COMMON_COM_TARG_SRC =     \
  c_a_to_q.c        \
  config_host.c     \
  config_platform.c 

CFILES=  \
  $(COMMON_COM_SRC) \
  $(COMMON_COM_TARG_SRC)

COMMON_COM_CXX_SRC =  \
  config.cxx  \
  config_elf_targ.cxx \
  const.cxx \
  cxx_memory.cxx \
  dwarf_DST.cxx \
  dwarf_DST_dump.cxx  \
  dwarf_DST_mem.cxx \
  glob.cxx  \
  ir_bcom.cxx \
  ir_bread.cxx  \
  ir_bwrite.cxx \
  ir_reader.cxx \
  irbdata.cxx \
  mtypes.cxx  \
  opcode.cxx  \
  opcode_core.cxx \
  pu_info.cxx \
  quadop.cxx      \
  strtab.cxx  \
  symtab.cxx  \
  symtab_verify.cxx \
  wn.cxx    \
  wn_map.cxx  \
  wn_pragmas.cxx  \
  wn_simp.cxx \
  wn_util.cxx \
  wutil.cxx \
  xstats.cxx  \
  upc_symtab_utils.cxx  \
  upc_wn_util.cxx \
  intrn_info.cxx



COMMON_COM_TARG_CXX_SRCS =  \
  config_targ.cxx \
  targ_const.cxx  \
  targ_sim.cxx

CXXFILES =                 \
  dummy-defines.cxx            \
  $(COMMON_COM_CXX_SRC)        \
  $(COMMON_COM_TARG_CXX_SRCS)

Pretty wierd, isn't it ?

Co-Array Fortran (CAF)

2007-09-25T11:41:00.002-05:00

CAF is one of the three partitioned global address space (PGAS). The other two are unified parallel C (UPC) and Titanium.

CAF is an SPMD based programming model created by created by Robert Numrich and John Reid (researchers from Cray, I suppose ?). The advantage of CAF is its simplicity compared to MPI but on the other hand provide almost the same flexibility and control to users. Furthermore, CAF is based on Fortran90, and therefore facilitate users to learn. However, it seems not possible in CAF to have dynamic processes where user can spawn or shrink processes. Another disadvantage is that it is based on "message" communication and therefore theoretically has no gain performance for multicore processors.

Rules:

– Normal rounded brackets ( ) to point to data in local memory. – Square brackets [ ] to point to data in remote memory.

Examples

(taken from [Numrich03]):

Variables decalaration:

real :: s[*]
real :: a(n)[*]
complex :: z[*]
integer :: index(n)[*]
real :: b(n)[p, *]
real :: c(n,m)[0:p, -7:q, 11:*]
real, allocatable :: w(:)[:]
type(field) :: maxwell[p,*]

Communication

x(:)[q] = x(:) + x(:)[p]

Which means x in the q processor will receive the sum of local x and x from the p processor.

Real examples

real,dimension(n,n)[p,*] :: a,b,c
do k=1,n
do q=1,p
c(i,j)[myP,myQ] = c(i,j)[myP,myQ]
+ a(i,k)[myP, q]*b(k,j)[q,myQ]
enddo
enddo

Refeences

[Numrich03] Co-Array Fortran What Is It? Why should you put it on BlueGene/L? Robert W. Numrich, Minnesota Supercomputing Institute University of Minnesota

Cilk

2007-09-21T10:43:00.001-05:00

Cilk [Blumofe95] is a coarse-grain parallel programming model based C. It is a faithful extension of C for multithreading that uses asynchronous parallelism and an efficient work-stealing schedule. Cilk is currently limited for shared memory architecture although some efforts for distributed memory have been published [Nikhil95].

Despite its simplicity, Cilk provides several advantages as mentioned in [Kuszmaul07]: simple, small, can use the best serial code, can express cache-efficient code, efficient (productivity), good performance on one processor and portable.

However, it also suffers some limitations, such as no direct support for fine-grained parallelism, synchronization flexibility, group team and lack of support for other languages such as Fortran and Java.

One famous Cilk example is as follows:

Original	Cilk version
int fib(int n) { if (n < 2) return n; else { int n1, n2; n1 = fib(n-1); n2 = fib(n-2); return; } }	cilk int fib(n) { if (n < 2) return n; else { int n1, n2; n1 = spawn fib(n-1); n2 = spawn fib(n-2); sync; return (n1 + n2); } }

Original

Cilk version

int fib(int n) {
 if (n < 2) return n; 
 else {
  int n1, n2;
  n1 = fib(n-1);
  n2 = fib(n-2);
  return;
 }
}

cilk int fib(n) {
 if (n < 2) return n;
 else {
  int n1, n2;
  n1 = spawn fib(n-1);
  n2 = spawn fib(n-2);
  sync;
  return (n1 + n2);
 }
}

The question is that if this language is good enough for multicore processors ? According to Charles Leisorson from MIT, the answer is yes. (See Multithreaded programming in Cilk). But not for general case I presume. Multicore processor architecture tends to encourage fine grain parallelism instead of coarse grain.

References

[Blumofe95] Blumofe, R. D., Joerg, C. F., Kuszmaul, B. C., Leiserson, C. E., Randall, K. H., and Zhou, Y. 1995. Cilk: an efficient multithreaded runtime system. In Proceedings of the Fifth ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (Santa Barbara, California, United States, July 19 - 21, 1995). R. L. Wexelblat, Ed. PPOPP '95. ACM Press, New York, NY, 207-216.
[Nikhil95] Nikhil, R. S. 1995. Cid: A Parallel, "Shared-Memory" C for Distributed-Memory Machines. In Proceedings of the 7th international Workshop on Languages and Compilers For Parallel Computing (August 08 - 10, 1994). K. Pingali, U. Banerjee, D. Gelernter, A. Nicolau, and D. A. Padua, Eds. Lecture Notes In Computer Science, vol. 892. Springer-Verlag, London, 376-390.
[Kuszmaul07] Kuszmaul, B. C. 2007. Cilk provides the "best overall productivity" for high performance computing: (and won the HPC challenge award to prove it). In Proceedings of the Nineteenth Annual ACM Symposium on Parallel Algorithms and Architectures (San Diego, California, USA, June 09 - 11, 2007). SPAA '07. ACM Press, New York, NY, 299-300.

Building CDT parser

2007-04-02T07:51:00.000-05:00

Eclipse and IBM website provide some very interesting and useful articles to extend CDT parser (or at least to build a new parser). The CDT FAQ gives a preliminary hint on how to develop a plugin. IBM has a more comprehensive and details information on extending CDT written by Matthew Scarpino. The articles are separated into 5 parts: - The C/C++ Development Tooling model - Presenting text in the CDT - Basic CDT parsing - Advanced CDT parsing and the Persisted Document Object Model - Using the PDOM for code completion

International Workshop on Performance Modeling and Evaluation 2007

2007-03-13T11:35:00.000-05:00

Currently I am a program committee in PMECT 2007: http://nets-www.lboro.ac.uk/pmect07/

Important dates

Submission Deadline:	April 1, 2007
Acceptance Notification:	May 11, 2007
Camera Ready Copy:	June 1, 2007
Author Registration due:	June 1, 2007
Workshop Day:	August 16, 2007

Submission

Authors are invited to submit manuscripts reporting original unpublished research and recent developments in the topics related to the workshop. The proceedings of the workshop program will be published, as the ICCCN 2007 main conference, by IEEE Communications Society and IEEE Digital Library. An accepted paper must be registered and presented at the conference venue and must be limited to 6 pages (with an allowance of up to two extra pages at additional cost) in standard IEEE camera-ready format (double-column, 10-pt font). Extended versions of selected high quality papers will appear in a Special Issue of Elsevier Journal of Simulation, Modeling, Practice and Theory. Any update will be posted on the ICCCN-07 Web site. Please contact the Workshop Co-Chair L.Guan@lboro.ac.uk with any questions. Paper Submission: EDAS (http://edas.info/) Deadline: April 1, 2007

How to time manually

2006-01-05T13:03:00.000-06:00

Although there is some profilers such as gprof and perfsuite, we can write our own time measurement. The HPCx user guide from HPCx website and Timing and Profiling NCSA website a very interesting way to write portable timers. Some of them: In Fortran 9x:

  integer :: clock0, clock1, clockmax, clockrate, ticks
  real    :: secs
  call system_clock(count_max=clockmax, count_rate=clockrate)
  call system_clock(clock0)

  ! code to be timed

  call system_clock(clock1)

  ticks = clock1-clock0
  ticks = mod(ticks+clockmax, clockmax)   ! reset negative numbers
  secs = float(ticks)/float(clockrate)
  write(*,*) 'Code took ', secs, ' seconds'

Using MPI_Wtime:

  DOUBLE PRECISION :: start, end
  start = MPI_Wtime()
 
  ! code to be timed
 
  end   = MPI_Wtime()
  print*,'That took ',end-start,' seconds'

In C:

#include 
struct timeval *Tps, *Tpf;
void *Tzp;
Tps = (struct timeval*) malloc(sizeof(struct timeval)):
Tpf = (struct timeval*) malloc(sizeof(struct timeval));
Tzp = 0;
gettimeofday (Tps, Tzp);
 
gettimeofday (Tpf, Tzp); 
printf("Total Time (usec): %ld\n",
(Tpf->tv_sec-Tps->tv_sec)*1000000
             + Tpf->tv_usec-Tps->rvr_usec);

Current information and news on high perfomance computer and the tools



Week 50th 2005 (12/11-12/17)
2005-12-19T14:07:00.000-06:00
   Investigate on MPI and hybrid MPI+OpenMP measurements on Sphinx. There are mainly two issues: measurements implemented by Bronis, and the original implementation from SKaMPI. The former is more reasonable and make sense, While the later is somewhat "strange" and need further investigation to understand. In summary, measuring MPI is not very different to measuring OpenMP: we still need auxiliary test.
   Develop a program to retrieve callgraph information from gprof. The tool is developed using Tcl/Tk as the user interface, and VCG to display a graph. The tool can be used to eliminate some routines so we can display the callgraph we interest. This tool helps me to understand how the Sphinx works, and what is the most consuming time in a program (in this case I used Sweep3D).
   Write down DOE report.
   Retouch the thesis. Make some corrections.
 
 
Current information and news on high perfomance computer and the tools


Computer and personal stuff
2005-12-12T10:29:00.000-06:00
I found an interesting blog about computer and stuff: http://adhianto.blogspot.com/
This blog apparently discuss more on tips and tricks using linux, latex and networking.Current information and news on high perfomance computer and the tools


Week 49th 2005 (12/5-12/11)
2005-12-12T05:23:00.000-06:00

Goal: to be able to work with perfsuite
   Able to use psinv and psrun
   Unable to run psprocess. Problem: Unable to integrate with tDOM
  
 
 Investigate MPI measurement in Sphinx
 investigate matrix multiplication and SWEEP3D mpi+openmp
    communication cost is extremely small (0.0xxxx) compared to computation (42)
    static vs dynamic vs guided is comparable and no many differences
  
 
  Need to investigate critical measurements. The result is always negative
  Discussed with rick kuffrin about perfsuite problem: Perfsuite does not support linux kernel 2.6. A new release to support this kernel will be available this month
Current information and news on high perfomance computer and the tools


Pointers to some tutorials
2005-12-09T11:21:00.000-06:00

High Performance Computing course at Turku Centre for Computer Science (TUCS) has interesting information on parallel computing. They provide examples for parallel heat transfer simulation using a 2-dimensional finite difference Gauss-Seidel successive over-relaxation (SOR) scheme, One-dimensional finite difference calculation and Mandebrot set visualizer and N-body simulation.

Scientific Computing and Visualization from Boston University has an excellent tutorial on MPI in Course 3085: Multiprocessing by Message Passing MPI. This course includes examples of MPI Numerical Integration both in C and Fortran, iterative solvers using SOR relaxation and matrix transpose
Current information and news on high perfomance computer and the tools


OpenMP for cluster computers
2005-12-08T13:55:00.000-06:00
IntroductionOpenMP is a easy, simple but powerful programming model for shared memory model such as SMP and cc-NUMA machines. OpenMP program can be run on cluster computers if and only if on top of software distributed shared memory such as Treadmarks and SCASH. However using SDSM can be very costly due to high overhead. A translation to distributed memory programming model such as message passing interface (MPI) is then more suitable and advantageous. This article describes some works on this issue.
Translation OpenMP to MPI
To the best of my knowledge, the only automatic translation from OpenMP to MPI work is done by [Basumallik2005]. They use the concept so called partial replication. Here is the key:
HPF-like approaches emphasize on data distribution: data partitioning, computation partitioning and message insertion. In this case, computation is performed by the owner of the data (owner-computes rule).
SDSM has different approach. It replicates all shared program data and also allocate management data structures (e.g.: shadow copies of shared data) on all CPUs.
[Basumallik2005] scheme: to replicate shared data on all processors, but no allocation on management structure. In the future, arrays with fully regular accesses will be distributed among processors.
The translation technique also considers irregular data accesses, overlapped communication and computation and recognition of transformed reduction idioms.
[Basumallik2005] experiments on seven OpenMP programs: NAS (CG, IS, EP, FT and LU) and SPEC OMP (ART and EQUAKE) benchmarks on Pentium III clusters and IBM SP. The result is very impressive: although the partial replication technique has less data scalable than data distribution scheme, but the good thing is this technique allows much larger data sets. The paper also mentions that their tranlation technique outperform both HPF programs and SDSM programs.
Application
 [Berger2005] proposes different a strategy to implement a hybrid MPI+OpenMP application. Instead of introducing OpenMP directives into an MPI application, it converts incremented OpenMP parallelization into MPI.
The application is a flow solver to solve the inviscid steady state euler equation on multi-level Cartesian grids with embedded boundaries. It uses space-filling curves to provide a one-dimensional ordering of a three-dimensional mesh. Using a general purpose partitioner such as METIS in this case would be too expensive.
Machine used: SGI Origin 3600
Result:
- OpenMP implementation is marginally faster than MPI due thanks to memory placement and locality.
- Greater MPI overhead for more than 320 CPUs
References
[Basumallik2005] Basumallik, A. and Eigenmann, R. 2005. Towards automatic translation of OpenMP to MPI. In Proceedings of the 19th Annual international Conference on Supercomputing (Cambridge, Massachusetts, June 20 - 22, 2005). ICS '05. ACM Press, New York, NY, 189-198. DOI= http://doi.acm.org/10.1145/1088149.1088174
[Berger2005] Berger, M. J., Aftosmis, M. J., Marshall, D. D., and Murman, S. M. 2005. Performance of a new CFD flow solver using a hybrid programming paradigm. J. Parallel Distrib. Comput. 65, 4 (Apr. 2005), 414-423. DOI= http://dx.doi.org/10.1016/j.jpdc.2004.11.010
Current information and news on high perfomance computer and the tools


Some experiences on hybrid MPI+OpenMP
2005-12-08T11:25:00.000-06:00
Current high performance computers are multiple node architecture where each node is a shared memory system (or also known symmetric multi-processor or SMP). This hierarchical architecture encourages hierarchical parallel programming model such as MPI and OpenMP.
 Coarse grain MPI + fine grain OpenMP
 [Majumdar2000] compares 3 different programming models: Tera Multi-Threaded Architecture (MTA), MPI and hybrid MPI+OpenMP. The hybrid implementation adopt hybrid simple strategy. That is, it inserts OpenMP loop level parallelization on the outermost loop, and MPI reduction outside the parallel region to enhance consistency among nodes. From this experiment, we see nearly linear speedup for all three programming paradigms.[Tai2005] works on parallelization of a multigrid solver by multigrid domain decomposition approach (MG-DD), using SPMD and MIMD programming paradigm (although it appears it is just a simple data decomposition instead of "real SPMD"). It proposes two strategies: one is a one-level parallelization using geometric domain decomposition; and the other one is a two-level parallelization that consists of a hybrid of both geometric domain decomposition with MPI and data decomposition using OpenMP. METIS is employed to produce the partitions of grids.
Result: poorer scalability in hybrid model due to less and less computation and more and more time for communication.
 A similar result is also achieved by [Mahinthakumar2002]. Although the authors use different optimization strategies, especially in OpenMP loop level (such as loop interchange, fusion, loop restructuring and thread decomposition), still pure MPI version outperforms the hybrid version. One cause of hybrid poor performance is OpenMP scalability. The OpenMP implementation is based on loop level parallelism and can cause false sharing. Another cause is poor MPI-OpenMP interaction, where only master thread that perform communication while others are idle.
An attempt improvement has been done by pushing parallelism in outer loop. This is reported has improved both OpenMP and MPI performance.
 Coarse grain MPI + coarse grain OpenMP[Oliker2002] investigates the effects of various ordering and partitioning strategies on the performance of CG (Aztec) and PCG (ILU BlockSolve95) of three different partitioner (METIS, SAW and RCM) from four different programming models: MPI, OpenMP, hybrid MPI+OpenMP and MTA. The Machines used: Cray T3E, SGI Origin 2000, IBM SP (clustered SMPs) and Cray MTA.
Model:
T = Tf + Tm + Tc
Where:
T is the total time
Tf time to perform floating-point operations
Tm time to service the cache misses
Tc time to communicate the x vector
Remark: this model may not be accurate since we cannot explicitely split between cache and arithmetic operation. But for raw estimation, it is acceptable.
What we can learn:
 METIS transfers the least amount of data, whereas RCM has the fewest messages
 Intelligent ordering schemes are extremely important for efficient sparse matrix computations regarless of whether the programming paradigm is OpenMP, MPI or hybrid.
    Hybrid implementation offers no noticeable advantage, and pure MPI is a more effective strategy
  RCM and SAW are faster than METIS due to better cache reuse
Translation into hybrid MPI+OpenMP
An interesting approach is done by [Benkner2003] to translate from HPF (with additional extension) into hybrid MPI and OpenMP. The proposed extension is necessary to control data across nodes and (inter-node) within the node (intra-node). They experimented with 2 applications: a kernel from a crash simulation and a kernel from numerical pricing module. Both kernels are based on iterative computational scheme with an outer time-step loop. The result is somewhat mix: the hybrid version of financial optimization kernel has much better speedup than the pure MPI version. While car crash simulation results similar scalability for both MPI and hybrid. The reason of this difference is due to the number of messages and memory requirement due to arrays replication. In the finance kernel, pure MPI has 4 times number of messages and more replicated arrays than the hybrid version.

References
[Benkner2003] Siegfried Benkner, Viera Sipková: Exploiting Distributed-Memory and Shared-Memory Parallelism on Clusters of SMPs with Data Parallel Programs. International Journal of Parallel Programming 31(1): 3-19 (2003)
   [Mahinthakumar2002] Mahinthakumar, G, Saied, F. A Hybrid MPI-OpenMP Implementation of an Implicit Finite-Element Code on Parallel Architectures. International Journal of High Performance Computing Applications 2002 16: 371-393
  
 [Majumdar2000] Amitava Majumdar: Parallel Performance Study of Monte Carlo Photon Transport Code on Shared-, Distributed-, and Distributed-Shared-Memory Architectures. IPDPS 2000: 93-
[Oliker2002] Oliker, L., Li, X., Husbands, P., and Biswas, R. 2002. Effects of Ordering Strategies and Programming Paradigms on Sparse Matrix Computations. SIAM Rev. 44, 3 (Mar. 2002), 373-393. DOI= http://dx.doi.org/10.1137/S00361445003820
[Tai2005] C.H. Tai, Y. Zhao and K.M. Liew, Parallel-multigrid computation of unsteady incompressible viscous flows using a matrix-free implicit method and high-resolution characteristics-based scheme, Computer Methods in Applied Mechanics and Engineering, Volume 194, Issues 36-38, 23 September 2005, Pages 3949-3983.
(http://www.sciencedirect.com/science/article/B6V29-4DW3937-3/2/fb22d5fa52e6791f816d90a770f9e5da)
Current information and news on high perfomance computer and the tools


Software for HPC
2005-12-08T10:36:00.000-06:00
Integrated Development Environment (IDE)
We can cite Eclipse as a powerful and extensible multi-platform IDE. Currently, there is a project to support parallel programming named Parallel Tools Platform (or PTP). Originally PTP more focus on MPI. The last news from Supercomputing, Beth Tibbitts reported that IBM also develop a plugin for OpenMP and it appears it will be integrated into PTP plugin.
Performance Tools
PerfSuite [1,2] is a collection of performance analysis software that can assist with a variety of methods and techniques useful for application software optimization.

The current release provides support for analysis with hardware performance counters on Linux with Intel and AMD-based systems (x86, x86-64, and ia64).

Support for the 2.6 kernel is not yet available in any released version of PerfSuite. According to Rick Kuffrin (via email conversation), this kernel should be supported in the next release in December 2005.

Perhaps one of the most known profiler is gprof. gprof is a statistical based profiler, it is not an event trace. As a statistical profiler, gprof is suitable for measuring frequently called routines. Another similar tool is oprofile. In contrast to gprof, oprofile does not need to recompile the source code, nor to patch the kernel (as perfsuite does).  One disadvantage of oprofile is it act as a monitor, so you need to run it like a "daemon", and in most machines, normal users cannot start or shutdown a daemon. This means oprofile is more suitable for root users.

Systemtap has very similar approach to oprofile. It is intended to spy the kernel events and report it as does Sun's dprobes.Current information and news on high perfomance computer and the tools