bluuebunny/crossref_metadata_2025 huggingface dataset:
ADIFOR–Generating Derivative Codes from Fortran Programs
Authors: Bischof Christian , Carle Alan , Corliss George , Griewank Andreas , Hovland Paul
Published: January 2015

The numerical methods employed in the solution of many scientific computing problems require the computation of derivatives of a function f Rn→Rm. Both the accuracy and the computational requirements of the derivative computation are usually of critical importance for the robustness and speed of the numerical solution. Automatic Differentiation of FORtran (ADIFOR) is a source transformation tool that accepts Fortran 77 code for the computation of a function and writes portable Fortran 77 code for the computation of the derivatives. In contrast to previous approaches, ADIFOR views automatic differentiation as a source transformation problem. ADIFOR employs the data analysis capabilities of the ParaScope Parallel Programming Environment, which enable us to handle arbitrary Fortran 77 codes and to exploit the computational context in the computation of derivatives. Experimental results show that ADIFOR can handle real‐life codes and that ADIFOR‐generated codes are competitive with divided‐difference approximations of derivatives. In addition, studies suggest that the source transformation approach to automatic differentiation may improve the time to compute derivatives by orders of magnitude.
Assessing Programming Costs of Explicit Memory Localization on a Large Scale Shared Memory Multiprocessor
Authors: Picano Silvio , Brooks Eugene D. , Hoag Joseph E.
Published: January 2015

We present detailed experimental work involving a commercially available large scale shared memory multiple instruction stream‐multiple data stream (MIMD) parallel computer having a software controlled cache coherence mechanism. To make effective use of such an architecture, the programmer is responsible for designing the program′s structure to match the underlying multiprocessors capabilities. We describe the techniques used to exploit our multiprocessor (the BBN TC2000) on a network simulation program, showing the resulting performance gains and the associated programming costs. We show that an efficient implementation relies heavily on the user′s ability to explicitly manage the memory system.
A Class‐Specific Optimizing Compiler
Authors: Sharp Michael D. , Otto Steve W.
Published: January 2015

Class‐specific optimizations are compiler optimizations specified by the class implementor to the compiler. They allow the compiler to take advantage of the semantics of the particular class so as to produce better code. Optimizations of interest include the strength reduction of class:: array address calculations, elimination of large temporaries, and the placement of asynchronous send/recv calls so as to achieve computation/communication overlap. We will outline our progress towards the implementation of a C++ compiler capable of incorporating class‐specific optimizations.
Distributed pC++ Basic Ideas for an Object Parallel Language
Authors: Bodin François , Beckman Peter , Gannon Dennis , Narayana Srinivas , Yang Shelby X.
Published: January 2015

pC++ is an object‐parallel extension to the C++ programming language. This paper describes the current language definition and illustrates the programming style. Exampies of parallel linear algebra operations are presented and a fast Poisson solver is described in complete detail.
FastScatTM: An Object‐Oriented Program for Fast Scattering Computation
Authors: Hamilton Lisa , Stalzer Mark , Turley R. Steven , Visher John , Wandzura Stephen
Published: January 2015

FastScat is a state‐of‐the‐art program for computing electromagnetic scattering and radiation. Its purpose is to support the study of recent algorithmic advancements, such as the fast multipole method, that promise speed‐ups of several orders of magnitude over conventional algorithms. The complexity of these algorithms and their associated data structures led us to adopt an object‐oriented methodology for FastScat. We discuss the program′s design and several lessons learned from its C++ implementation including the appropriate level for object‐orientedness in numeric software, maintainability benefits, interfacing to Fortran libraries such as LAPACK, and performance issues.
Scientific Computing in the CH Programming Language
Authors: Cheng Harry H.
Published: January 2015

We have developed a general‐purpose block‐structured interpretive programming Ianguage. The syntax and semantics of this language called CH are similar to C. CH retains most features of C from the scientific computing point of view. In this paper, the extension of C to CH for numerical computation of real numbers will be described. Metanumbers of −0.0, 0.0, Inf, −Inf, and NaN are introduced in CH. Through these metanumbers, the power of the IEEE 754 arithmetic standard is easily available to the programmer. These metanumbers are extended to commonly used mathematical functions in the spirit of the IEEE 754 standard and ANSI C. The definitions for manipulation of these metanumbers in I/O; arithmetic, relational, and logic operations; and built‐in polymorphic mathematical functions are defined. The capabilities of bitwise, assignment, address and indirection, increment and decrement, as well as type conversion operations in ANSI C are extended in CH. In this paper, mainly new linguistic features of CH in comparison to C will be described. Example programs programmed in CH with metanumbers and polymorphic mathematical functions will demonstrate capabilities of CH in scientific computing.
Handling of Complex Numbers in the CH Programming Language
Authors: Cheng Harry H.
Published: January 2015

The handling of complex numbers in the CH programming language will be described in this paper. Complex is a built‐in data type in CH. The I/O, arithmetic and relational operations, and built‐in mathematical functions are defined for both regular complex numbers and complex metanumbers of ComplexZero, Complexlnf, and ComplexNaN. Due to polymorphism, the syntax of complex arithmetic and relational operations and built‐in mathematical functions are the same as those for real numbers. Besides polymorphism, the built‐in mathematical functions are implemented with a variable number of arguments that greatly simplify computations of different branches of multiple‐valued complex functions. The valid lvalues related to complex numbers are defined. Rationales for the design of complex features in CH are discussed from language design, implementation, and application points of views. Sample CH programs show that a computer language that does not distinguish the sign of zeros in complex numbers can also handle the branch cuts of multiple‐valued complex functions effectively so long as it is appropriately designed and implemented.
Object‐Oriented Support for Adaptive Methods on Paranel Machines
Authors: Bhatt Sandeep , Chen Marina , Cowie James , Lin Cheng-Yee , Liu Pangfeng
Published: January 2015

This article reports on experiments from our ongoing project whose goal is to develop a C++ library which supports adaptive and irregular data structures on distributed memory supercomputers. We demonstrate the use of our abstractions in implementing "tree codes" for large‐scale N‐body simulations. These algorithms require dynamically evolving treelike data structures, as well as load‐balancing, both of which are widely believed to make the application difficult and cumbersome to program for distributed‐memory machines. The ease of writing the application code on top of our C++ library abstractions (which themselves are application independent), and the low overhead of the resulting C++ code (over hand‐crafted C code) supports our belief that object‐oriented approaches are eminently suited to programming distributed‐memory machines in a manner that (to the applications programmer) is architecture‐independent. Our contribution in parallel programming methodology is to identify and encapsulate general classes of communication and load‐balancing strategies useful across applications and MIMD architectures. This article reports experimental results from simulations of half a million particles using multiple methods.
A Framework‐Based Environment for Object‐Oriented Scientific Codes
Authors: Ballance Robert A. , Giancola Anthony J. , Luger George F. , Ross Timothy J.
Published: January 2015

Frameworks are reusable object‐oriented designs for domain‐specific programs. In our estimation, frameworks are the key to productivity and reuse. However, frameworks require increased support from the programming environment. A framework‐based environment must include design aides and project browsers that can mediate between the user and the framework. A framework‐based approach also places new requirements on conventional tools such as compilers. This article explores the impact of object‐oriented frameworks upon a programming environment, in the context of object‐oriented finite element and finite difference codes. The role of tools such as design aides and project browsers is discussed, and the impact of a framework‐based approach upon compilers is examined. Examples are drawn from our prototype C++ based environment.
Object‐Oriented Implementation of Adaptive Mesh Refinement Algorithms
Authors: Crutchfield William Y. , Welcome Michael L.
Published: January 2015

We describe C++ classes that simplify development of adaptive mesh refinement (AMR) algorithms. The classes divide into two groups, generic classes that are broadly useful in adaptive algorithms, and application‐specific classes that are the basis for our AMR algorithm. We employ two languages, with C++ responsible for the high‐level data structures, and Fortran responsible for low‐level numerics. The C++ implementation is as fast as the original Fortran implementation. Use of inheritance has allowed us to extend the original AMR algorithm to other problems with greatly reduced development time.
Flexible Language Constructs for Large Parallel Programs
Authors: Rosing Matt , Schnabel Robert
Published: January 2015

The goal of the research described in this article is to develop flexible language constructs for writing large data parallel numerical programs for distributed memory (multiple instruction multiple data [MIMD]) multiprocessors. Previously, several models have been developed to support synchronization and communication. Models for global synchronization include single instruction multiple data (SIMD), single program multiple data (SPMD), and sequential programs annotated with data distribution statements. The two primary models for communication include implicit communication based on shared memory and explicit communication based on messages. None of these models by themselves seem sufficient to permit the natural and efficient expression of the variety of algorithms that occur in large scientific computations. In this article, we give an overview of a new language that combines many of these programming models in a clean manner. This is done in a modular fashion such that different models can be combined to support large programs. Within a module, the selection of a model depends on the algorithm and its efficiency requirements. In this article, we give an overview of the language and discuss some of the critical implementation details.
Methods for Precise Submesh Allocation
Authors: Morgenstern Craig
Published: January 2015

In this article we describe and compare several recently proposed algorithms for precise submesh allocation in a two‐dimensional mesh connected system. The methods surveyed include various frame sliding strategies, the maximum boundary value heuristic, and interval set scan techniques. In addition, a new enhancement to the interval set scan method is described. This enhancement results in an algorithm that has better allocation and run‐time performance under a FCFS scheduling policy than any of the other proposed methods. We present results drawn from an extensive simulation study to illustrate the relative efficiency of the various methods.
PDS: A Performance Database Server
Authors: Berry Michael W. , Dongarra Jack J. , Larose Brian H. , Letsche Todd A.
Published: January 2015

The process of gathering, archiving, and distributing computer benchmark data is a cumbersome task usually performed by computer users and vendors with little coordination. Most important, there is no publicly available central depository of performance data for all ranges of machines from personal computers to supercomputers. We present an Internet‐accessible performance database server (PDS) that can be used to extract current benchmark data and literature. As an extension to the X‐Windows‐based user interface (Xnetlib) to the Netlib archival system, PDS provides an on‐line catalog of public domain computer benchmarks such as the LINPACK benchmark, Perfect benchmarks, and the NAS parallel benchmarks. PDS does not reformat or present the benchmark data in any way that conflicts with the original methodology of any particular benchmark; it is thereby devoid of any subjective interpretations of machine performance. We believe that all branches (research laboratories, academia, and industry) of the general computing community can use this facility to archive performance metrics and make them readily available to the public. PDS can provide a more manageable approach to the development and support of a large dynamic database of published performance metrics.
The Efficiency of Linda for General Purpose Scientific Programming
Authors: Mattson Timothy G.
Published: January 2015

Linda (Linda is a registered trademark of Scientific Computing Associates, Inc.) is a programming language for coordinating the execution and interaction of processes. When combined with a language for computation (such as C or Fortran), the resulting hybrid language can be used to write portable programs for parallel and distributed multiple instruction multiple data (MIMD) computers. The Linda programming model is based on operations that read, write, and erase a virtual shared memory. It is easy to use, and lets the programmer code in a very expressive, uncoupled programming style. These benefits, however, are of little value unless Linda programs execute efficiently. The goal of this article is to demonstrate that Linda programs are efficient making Linda an effective general purpose tool for programming MIMD parallel computers. Two arguments for Linda′s efficiency are given; the first is based on Linda′s implementation and the second on a range of case studies spanning a complete set of parallel algorithm classes.
The CRAFT Fortran Programming Model
Authors: Pase Douglas M. , MacDonald Tom , Meltzer Andrew
Published: January 2015

Many programming models for massively parallel machines exist, and each has its advantages and disadvantages. In this article we present a programming model that combines features from other programming models that (1) can be efficiently implemented on present and future Cray Research massively parallel processor (MPP) systems and (2) are useful in constructing highly parallel programs. The model supports several styles of programming: message‐passing, data parallel, global address (shared data), and work‐sharing. These styles may be combined within the same program. The model includes features that allow a user to define a program in terms of the behavior of the system as a whole, where the behavior of individual tasks is implicit from this systemic definition. (In general, features marked as shared are designed to support this perspective.) It also supports an opposite perspective, where a program may be defined in terms of the behaviors of individual tasks, and a program is implicitly the sum of the behaviors of all tasks. (Features marked as private are designed to support this perspective). Users can exploit any combination of either set of features without ambiguity and thus are free to define a program from whatever perspective is most appropriate to the problem at hand.
Overview of the Force Scientific Parallel Language
Authors: Alaghband Gita , Jordan Harry F.
Published: January 2015

The Force parallel programming language designed for large‐scale shared‐memory multiprocessors is presented. The language provides a number of parallel constructs as extensions to the ordinary Fortran language and is implemented as a two‐level macro preprocessor to support portability across shared memory multiprocessors. The global parallelism model on which the Force is based provides a powerful parallel language. The parallel constructs, generic synchronization, and freedom from process management supported by the Force has resulted in structured parallel programs that are ported to the many multiprocessors on which the Force is implemented. Two new parallel constructs for looping and functional decomposition are discussed. Several programming examples to illustrate some parallel programming approaches using the Force are also presented.
Explaining the Gap between Theoretical Peak Performance and Real Performance for Supercomputer Architectures
Authors: Schönauer W. , Häfner H.
Published: January 2015

The basic architectures of vector and parallel computers and their properties are presented followed by a discussion of memory size and arithmetic operations in the context of memory bandwidth. For a single operation micromeasurements of the vector triad for the IBM 3090 VF and the CRAY Y‐MP/8 are presented, revealing in detail the losses for this operation. The global performance of a whole supercomputer is then considered by identifying reduction factors that reduce the theoretical peak performance to the poor real performance. The responsibilities of the manufacturer and of the user for these losses are discussed. The price‐performance ratio for different architectures as of January 1991 is briefly mentioned. Finally a user‐friendly architecture for a supercomputer is proposed.
Benchmark Tests on the New IBM RISC System/6000 590 Workstation
Authors: Wasserman Harvey J.
Published: January 2015

The results of benchmark tests on the superscalar IBM RISC System/6000 Model 590 are presented. A set of well‐characterized Fortran benchmarks spanning a range of computational characteristics was used for the study. The data from the 590 system are compared with those from a single‐processor CRAY C90 system as well as with other microprocessor‐based systems, such as the Digital Equipment Corporation AXP 3000/500X and the Hewlett‐Packard HP/735.
The Graphical Benchmark Information Service
Authors: Papiani Mark , Hey Anthony J. G. , Hockney Roger W.
Published: January 2015

Unlike single‐processor benchmarks, multiprocessor benchmarks can yield tens of numbers for each benchmark on each computer, as factors such as the number of processors and problem size are varied. A graphical display of performance surfaces therefore provides a satisfactory way of comparing results. The University of Southampton has developed the Graphical Benchmark Information Service (GBIS) on the World Wide Web (WWW) to display interactively graphs of user‐selected benchmark results from the GENESIS and PARKBENCH benchmark suites.
A Static Approach for Compiling Communications in Paranel Scientific Programs
Authors: De Lahaut Damien Gautier , Germain CÉcile
Published: January 2015

On most massively parallel architectures, the actual communication performance remains much less than the hardware capabilities. The main reason for this difference lies in the dynamic routing, because the software mechanisms for managing the routing represent a large overhead. This article presents experimental studies on benchmark programs concerning scientific computing; the results show that most communication patterns in application programs are predictable at compile‐time. An execution model is proposed that utilizes this knowledge such that predictable communications are directly compiled and dynamic communications are emulated by scheduling an appropriate set of compiled communications. The performance of the model is evaluated, showing that performance is better in static cases and gracefully degrades with the growing complexity and dynamic aspect of the communication patterns.
Determining Mental State from EEG Signals Using Parallel Implementations of Neural Networks
Authors: Anderson Charles W. , Devulapalli Saikumar V. , Stolz Erik A.
Published: January 2015

EEG analysis has played a key role in the modeling of the brain′s cortical dynamics, but relatively little effort has been devoted to developing EEG as a limited means of communication. If several mental states can be reliably distinguished by recognizing patterns in EEG, then a paralyzed person could communicate to a device such as a wheelchair by composing sequences of these mental states. EEG pattern recognition is a difficult problem and hinges on the success of finding representations of the EEG signals in which the patterns can be distinguished. In this article, we report on a study comparing three EEG representations, the unprocessed signals, a reduced‐dimensional representation using the Karhunen – Loève transform, and a frequency‐based representation. Classification is performed with a two‐layer neural network implemented on a CNAPS server (128 processor, SIMD architecture) by Adaptive Solutions, Inc. Execution time comparisons show over a hundred‐fold speed up over a Sun Sparc 10. The best classification accuracy on untrained samples is 73% using the frequency‐based representation.
An Introduction to High Performance Fortran
Authors: Merlin John , Hey Anthony
Published: January 2015

High Performance Fortran (HPF) is an informal standard for extensions to Fortran 90 to assist its implementation on parallel architectures, particularly for data‐parallel computation. Among other things, it includes directives for specifying data distribution across multiple memories, and concurrent execution features. This article provides a tutorial introduction to the main features of HPF.
A Tensor Product Formulation of Strassen′s Matrix Multiplication Algorithm with Memory Reduction
Authors: Kumar B. , Huang C.-H. , Sadayappan P. , Johnson R.W.
Published: January 2015

In this article, we present a program generation strategy of Strassen′s matrix multiplication algorithm using a programming methodology based on tensor product formulas. In this methodology, block recursive programs such as the fast Fourier Transforms and Strassen′s matrix multiplication algorithm are expressed as algebraic formulas involving tensor products and other matrix operations. Such formulas can be systematically translated to high‐performance parallel/vector codes for various architectures. In this article, we present a nonrecursive implementation of Strassen′s algorithm for shared memory vector processors such as the Cray Y‐MP. A previous implementation of Strassen′s algorithm synthesized from tensor product formulas required working storage of size O(7n) for multiplying 2n × 2n matrices. We present a modified formulation in which the working storage requirement is reduced to O(4n). The modified formulation exhibits sufficient parallelism for efficient implementation on a shared memory multiprocessor. Performance results on a Cray Y‐MP8/64 are presented.
Unfavorable Strides in Cache Memory Systems (RNR Technical Report RNR‐92‐015)
Authors: Bailey David H.
Published: January 2015

An important issue in obtaining high performance on a scientific application running on a cache‐based computer system is the behavior of the cache when data are accessed at a constant stride. Others who have discussed this issue have noted an odd phenomenon in such situations: A few particular innocent‐looking strides result in sharply reduced cache efficiency. In this article, this problem is analyzed, and a simple formula is presented that accurately gives the cache efficiency for various cache parameters and data strides.
Expert Programmer versus Parallelizing Compiler: A Comparative Study of Two Approaches for Distributed Shared Memory
Authors: O′Boyle M. F. P. , Bull J. M.
Published: January 2015

This article critically examines current parallel programming practice and optimizing compiler development. The general strategies employed by compiler and programmer to optimize a Fortran program are described, and then illustrated for a specific case by applying them to a well‐known scientific program, TRED2, using the KSR‐1 as the target architecture. Extensive measurement is applied to the resulting versions of the program, which are compared with a version produced by a commercial optimizing compiler, KAP. The compiler strategy significantly outperforms KAP and does not fall far short of the performance achieved by the programmer. Following the experimental section each approach is critiqued by the other. Perceived flaws, advantages, and common ground are outlined, with an eye to improving both schemes.
Design, Implementation, and Test of a Multi‐Model Systolic Neural‐Network Accelerator
Authors: Cornu Thierry , Ienne Paolo , Niebur Dagmar , Thiran Patrick , Viredaz Marc A.
Published: January 2015

A multi‐model neural‐network computer has been designed and built. A compute‐intensive application in the field of power‐system monitoring, using the Kohonen neural network, has then been ported onto this machine. After a short description of the system, this article focuses on the programming paradigm adopted. The performance of the machine is also evaluated and discussed.
Static Mapping of Functional Programs: An Example in Signal Processing
Authors: Dennis Jack B.
Published: January 2015

Complex signal‐processing problems are naturally described by compositions of program modules that process streams of data. In this article we discuss how such compositions may be analyzed and mapped onto multiprocessor computers to effectively exploit the massive parallelism of these applications. The methods are illustrated with an example of signal processing for an optical surveillance problem. Program transformation and analysis are used to construct a program description tree that represents the given computation as an acyclic interconnection of stream‐processing modules. Each module may be mapped to a set of threads run on a group of processing elements of a target multiprocessor. Performance is considered for two forms of multiprocessor architecture, one based on conventional DSP technology and the other on a multithreaded‐processing element design.
Software Tools for High‐Performance Computiing: Survey and Recommendations
Authors: Appelbe Bill , Bergmark Donna
Published: January 2015

Applications programming for high‐performance computing is notoriously difficult. Al‐though parallel programming is intrinsically complex, the principal reason why high‐performance computing is difficult is the lack of effective software tools. We believe that the lack of tools in turn is largely due to market forces rather than our inability to design and build such tools. Unfortunately, the poor availability and utilization of parallel tools hurt the entire supercomputing industry and the U.S. high performance computing initiative which is focused on applications. A disproportionate amount of resources is being spent on faster hardware and architectures, while tools are being neglected. This article introduces a taxonomy of tools, analyzes the major factors that contribute to this situation, and suggests ways that the imbalance could be redressed and the likely evolution of tools.
Design and Implementation of the ScaLAPACK LU, QR, and Cholesky Factorization Routines
Authors: Choi Jaeyoung , Dongarra Jack J. , Ostrouchov L. Susan , Petitet Antoine P. , Walker David W. , Whaley R. Clint
Published: January 2015

This article discusses the core factorization routines included in the ScaLAPACK library. These routines allow the factorization and solution of a dense system of linear equations via LU, QR, and Cholesky. They are implemented using a block cyclic data distribution, and are built using de facto standard kernels for matrix and vector operations (BLAS and its parallel counterpart PBLAS) and message passing communication (BLACS). In implementing the ScaLAPACK routines, a major objective was to parallelize the corresponding sequential LAPACK using the BLAS, BLACS, and PBLAS as building blocks, leading to straightforward parallel implementations without a significant loss in performance. We present the details of the implementation of the ScaLAPACK factorization routines, as well as performance and scalability results on the Intel iPSC/860, Intel Touchstone Delta, and Intel Paragon System.
Update‐in‐Place Analysis for True Multidimensional Arrays
Authors: Fitzgerald Steven M. , Oldehoeft Rodney R.
Published: January 2015

Applicative languages have been proposed for defining algorithms for parallel architectures because they are implicitly parallel and lack side effects. However, straightforward implementations of applicative‐language compilers may induce large amounts of copying to preserve program semantics. The unnecessary copying of data can increase both the execution time and the memory requirements of an application. To eliminate the unnecessary copying of data, the Sisal compiler uses both build‐in‐place and update‐in‐place analyses. These optimizations remove unnecessary array copy operations through compile‐time analysis. Both build‐in‐place and update‐in‐place are based on hierarchical ragged arrays, i.e., the vector‐of‐vectors array model. Although this array model is convenient for certain applications, many optimizations are precluded, e.g., vectorization. To compensate for this deficiency, new languages, such as Sisal 2.0, have extended array models that allow for both high‐level array operations to be performed and efficient implementations to be devised. In this article, we introduce a new method to perform update‐in‐place analysis that is applicable to arrays stored either in hierarchical or in contiguous storage. Consequently, the array model that is appropriate for an application can be selected without the loss of performance. Moreover, our analysis is more amenable for distributed memory and large software systems.
High‐Performance Functional Computing: Guest Editor′s Introduction
Authors: Page R. L. , Oldehoeft R. R.
Published: January 2015

Erratum to “High-Performance Functional Computing: Guest Editor's Introduction”dx.doi.org/10.1155/1996/913952
Irregular Coarse‐Grain Data Parallelism under LPARX
Authors: Kohn Scott R. , Baden Scott B.
Published: January 2015

LPARX is a software development tool for implementing dynamic, irregular scientific applications, such as multilevel finite difference and particle methods, on high‐performance multiple instruction multiple data (MIMD) parallel architectures. It supports coarse‐grain data parallelism and gives the application complete control over specifying arbitrary block decompositions. LPARX provides structural abstraction, representing data decompositions as first‐class objects that can be manipulated and modified at runtime. LPARX, implemented as a C++ class library, is currently running on diverse MIMD platforms, including the Intel Paragon, Cray C‐90, IBM SP2, and networks of workstations running under PVM. Software may be developed and debugged on a singe‐processor workstation.
Fast Digit‐Index Permutations
Authors: Bollman Dorothy , Seguel Jaime , Feo John
Published: January 2015

We introduce a tensor sum which is useful for the design and analysis of digit‐index permutations (DIPs) algorithms. Using this operation we obtain a new high‐performance algorithm for the family of DIPs. We discuss an implementation in the applicative language Sisal and show how different choices of parameters yield different DIPs. The efficiency of the special case of digit reversal is illustrated with performance results on a Cray C‐90.
Topographical Analysis of Spatial Patterns Generated by a Cellular Automaton Model of the Proliferation of a Cancer Cell Line In Vitro
Authors: Palmari Jacqueline , Lafon Bruno , Martin Pierre Marie , Dussert Christophe
Published: January 2015

A well‐suited model to simulate cellular population dynamics is the two‐dimensional cellular automaton model, which consists of a lattice of sites, the value ai,j of each site being updated in discrete time steps according to an identical deterministic rule depending on a neighbourhood of sites around it. A cellular automaton is described which mimics cell population proliferation by replacing the site values by the age and the cycle phase of cells. The model takes into account the size of the cells. It is used to simulate the proliferation of the human breast cancer cell line MCF‐7 and the results of the simulation are compared with experimental data obtained from a light microscopic image analysis of the proliferation process. The initial configuration of the cellular automaton is obtained from the discretization of the results of the initial stage of the image processing. After each day of proliferation the pattern obtained from the simulation is compared to the experimental result of the corresponding image analysis. The comparison is made from a topographical point of view through the concept of the minimal spanning tree graph. The agreement between experiment and model is a good starting point to complex models such as cell proliferation under growth effectors or drugs.
A Linear Algebra Framework for Static High Performance Fortran Code Distribution
Authors: Ancourt Corinne , Coelho Fabien , Irigoin FranÇois , Keryell Ronan
Published: January 2015

High Performance Fortran (HPF) was developed to support data parallel programming for single‐instruction multiple‐data (SIMD) and multiple‐instruction multiple‐data (MIMD) machines with distributed memory. The programmer is provided a familiar uniform logical address space and specifies the data distribution by directives. The compiler then exploits these directives to allocate arrays in the local memories, to assign computations to elementary processors, and to migrate data between processors when required. We show here that linear algebra is a powerful framework to encode HPF directives and to synthesize distributed code with space‐efficient array allocation, tight loop bounds, and vectorized communications for INDEPENDENT loops. The generated code includes traditional optimizations such as guard elimination, message vectorization and aggregation, and overlap analysis. The systematic use of an affine framework makes it possible to prove the compilation scheme correct.
Object‐Oriented Software Tools for the Construction of Preconditioners
Authors: Mossberg Eva , Otto Kurt , Thuné Michael
Published: January 2015

In recent years, there has been considerable progress concerning preconditioned iterative methods for large and sparse systems of equations arising from the discretization of differential equations. Such methods are particularly attractive in the context of high‐performance (parallel) computers. However, the implementation of a preconditioner is a nontrivial task. The focus of the present contribution is on a set of object‐oriented software tools that support the construction of a family of preconditioners based on fast transforms. By combining objects of different classes, it is possible to conveniently construct any preconditioner within this family.
Aneuploidy Mechanisms in Human Colorectal Preneoplastic Lesions and Barrett’s Esophagus. Is There a Role for K‐Ras and p53 Mutations?
Authors: Giaretti Walter
Published: January 2015

The link of aneuploidy and heteroploidy in human solid tumours with early genetic events is poorly understood. The study of human preneoplastic precursor lesions, i.e., colorectal adenomas, chronic ulcerative colitis lesions, and Barrett’s esophagus, as considered in this review, appears particularly useful to achieve this aim. Literature data examined here on aneuploidy were obtained by image and flow cytometry, classical cytogenetics, and in situ hybridization based cytogenetics. It appears that aneuploidy is linked with specific gene mutations, i.e., of the tumour suppressor gene p53 in chronic ulcerative colitis and in Barrett’s esophagus, and of the protooncogene K‐ras in colorectal adenomas. These data and data from experiments using in vitro and mouse models, suggest that chromosome instability, tetraploidization, and asymmetrical chromosome segregation during cell division are the result of deregulated cell cycle genes with multiple functions that normally exert active checks on the cell cycle processes including apoptosis and chromosome stability.
Signal Amplification of FISH for Automated Detection Using Image Cytometry
Authors: Truong Khuong , Boenders Jack , Maciorowski Zofia , Vielh Philippe , Dutrillaux Bernard , Malfoy Bernard , Bourgeois Claire A.
Published: January 2015

The purpose of this study was to improve the detection of FISH signals, in order that spot counting by a fully automated image cytometer be comparable to that obtained visually under the microscope. Two systems of spot scoring, visual and automated counting, were investigated in parallel on stimulated human lymphocytes with FISH using a biotinylated centromeric probe for chromosome 3. Signal characteristics were first analyzed on images recorded with a coupled charge device (CCD) camera. Number of spots per nucleus were scored visually on these recorded images versus automatically with a DISCOVERY image analyzer. Several fluochromes, amplification systems and pretreatments were tested. Our results for both visual and automated scoring show that the tyramide amplification system (TSA) gives the best amplification of signal if pepsin treatment is applied prior to FISH. Accuracy of the automated scoring, however, remained low (58% of nuclei containing two spots) compared to the visual scoring because of the high intranuclear variation between FISH spots.
A New Method for Segmentation of Colour Images Applied to Immunohistochemically Stained Cell Nuclei
Authors: Ranefall Petter , Egevad Lars , Nordin Bo , Bengtsson Ewert
Published: January 2015

A new method for segmenting images of immunohistochemically stained cell nuclei is presented. The aim is to distinguish between cell nuclei with a positive staining reaction and other cell nuclei, and to make it possible to quantify the reaction. First, a new supervised algorithm for creating a pixel classifier is applied to an image that is typical for the sample. The training phase of the classifier is very user friendly since only a few typical pixels for each class need to be selected. The classifier is robust in that it is non‐parametric and has a built‐in metric that adapts to the colour space. After the training the classifier can be applied to all images from the same staining session. Then, all pixels classified as belonging to nuclei of cells are grouped into individual nuclei through a watershed segmentation and connected component labelling algorithm. This algorithm also separates touching nuclei. Finally, the nuclei are classified according to their fraction of positive pixels.
Abstract Level Parallelization of Finite Difference Methods
Authors: Vollebregt Edwin
Published: January 2015

A formalism is proposed for describing finite difference calculations in an abstract way. The formalism consists of index sets and stencils, for characterizing the structure of sets of data items and interactions between data items (“neighbouring relations”). The formalism provides a means for lifting programming to a more abstract level. This simplifies the tasks of performance analysis and verification of correctness, and opens the way for automaticcode generation. The notation is particularly useful in parallelization, for the systematic construction of parallel programs in a process/channel programming paradigm (e.g., message passing). This is important because message passing, unfortunately, still is the only approach that leads to acceptable performance for many more unstructured or irregular problems on parallel computers that have non‐uniform memory access times. It will be shown that the use of index sets and stencils greatly simplifies the determination of which data must be exchanged between different computing processes.
Implementation and Performance of DSMPI
Authors: Silva Luis M. , Silva JoÃo Gabriel , Chapple Simon
Published: January 2015

Distributed shared memory has been recognized as an alternative programming model to exploit the parallelism in distributed memory systems because it provides a higher level of abstraction than simple message passing. DSM combines the simple programming model of shared memory with the scalability of distributed memory machines. This article presents DSMPI, a parallel library that runs atop of MPI and provides a DSM abstraction. It provides an easy‐to‐use programming interface, is fully, portable, and supports heterogeneity. For the sake of flexibility, it supports different coherence protocols and models of consistency. We present some performance results taken in a network of workstations and in a Cray T3D which show that DSMPI can be competitive with MPI for some applications.
A Novel Image Cytometric Method for Quantitation of Immunohistochemical Staining of Cytoplasmic Antigens
Authors: Guillaud M. , Matthews J. B. , Harrison A. , MacAulay C. , Skov K.
Published: January 2015

Evaluation of molecular markers by immunohistochemical labelling of tissue sections has traditionally been performed by qualitative assessment by trained pathologists. For those markers with a staining component present outside of the nucleus, there has been no image histometric method available to reliably and consistently define cell interfaces within the tissue. We present a new method of approximating cellular boundaries to define cellular regions within which quantitative measurements of staining intensity may be made. The method is based upon Voronoi tessellation of a defined region of interest (ROI), and requires only the position of the nuclear centroids within the ROI.

Here we describe the VORSTAIN software which has been developed based on the Oncometrics CytoSavant Automated Image Cytometry System. To demonstrate this technique, human breast cancer sections immunohistochemically stained for bcl‐2 protein and counter‐stained with nuclear methyl green stain were evaluated. Intra‐observer variation in the measured values was between 1.5–2.6% and inter‐observer variation was between 1.8–4.4%. The primary source of variability was due to difficulties in interpreting the exact position of the nuclear centroids. Analysis of mean staining densities for each slide correlated well with subjective scoring performed by two independent pathologists. Using VORSTAIN, significant variation of staining intensities between regions within the same slide was measured for some sections, indicating a large degree of heterogeneity within the tumours. The ability to accurately quantitate the degree of heterogeneity of molecular marker expression within tumours may be a valuable tool in prognostication.
Nuclear DNA Content of Fine Needle Aspirates of Invasive Ductal Carcinomas of the Breast
Authors: Sarker Sudip , Spigelman Allan , Walker Marjorie , Coleman Dulcie
Published: January 2015

Patients with aggressive breast cancers benefit from chemotherapy prior to surgery. If the biology of the breast cancers were better characterised pre‐operatively, more patients at risk could be offered chemotherapy. We have assessed nuclear DNA content of fine needle aspirates (FNA) of 103 invasive ductal breast cancers and compared this to tumour size, node status and histological grade. Median follow‐up was 18 months so no prognostic studies were made. Diploid and non‐diploid tumours were distributed equally in node negative and positive patients. However non‐diploidy status increased in line with known prognostic markers of tumour size and histological grade. This suggests that ploidy might contribute to the pre‐operative assessment of prognosis. We conclude that nuclear DNA of breast cancer FNAs may be of value in the pre‐operative biological assessment of breast cancer patients.
F--: A Parallel Extension to Cray Fortran
Authors: Numrich Robert W.
Published: January 2015

F-- is a parallel extension to Cray Fortran 77 for distributed memory computers. It adds exactly one new symbol to the language, a vertical line that separates two sets of indices. The first set contains the coordinates for data in a local data grid. The second set contains the coordinates for processors in a global processor grid. A statement such as x(i,j)=y(i,j| p,q) generates a load from remote address y(i,j) in the data grid on processor (p,q) followed by a store to local address x(i,j) in the local data grid. F-- syntax requires an explicit statement of the relationship between data layout and processor layout. It assumes that good performance on a distributed memory computer requires the programmer to understand and to exploit data locality. Programmers use the F-- syntax only when it is needed. 0therwise all data are local and all code is local. Compiler and library developers concentrate on generating well‐optimized local code.
Scientific Programming with High Performance Fortran: A Case Study Using the xHPF Compiler
Authors: De Sturler Eric , Strumpen Volker
Published: January 2015

Recently, the first commercial High Performance Fortran (HPF) subset compilers have appeared. This article reports on our experiences with the xHPF compiler of Applied Parallel Research, version 1.2, for the Intel Paragon. At this stage, we do not expect very High Performance from our HPF programs, even though performance will eventually be of paramount importance for the acceptance of HPF. Instead, our primary objective is to study how to convert large Fortran 77 (F77) programs to HPF such that the compiler generates reasonably efficient parallel code. We report on a case study that identifies several problems when parallelizing code with HPF; most of these problems affect current HPF compiler technology in general, although some are specific for the xHPF compiler. We discuss our solutions from the perspective of the scientific programmer, and presenttiming results on the Intel Paragon. The case study comprises three programs of different complexity with respect to parallelization. We use the dense matrix‐matrix product to show that the distribution of arrays and the order of nested loops significantly influence the performance of the parallel program. We use Gaussian elimination with partial pivoting to study the parallelization strategy of the compiler. There are various ways to structure this algorithm for a particular data distribution. This example shows how much effort may be demanded from the programmer to support the compiler in generating an efficient parallel implementation. Finally, we use a small application to show that the more complicated structure of a larger program may introduce problems for the parallelization, even though all subroutines of the application are easy to parallelize by themselves. The application consists of a finite volume discretization on a structured grid and a nested iterative solver. Our case study shows that it is possible to obtain reasonably efficient parallel programs with xHPF, although the compiler needs substantial support from the programmer.