bluuebunny/crossref_metadata_2025 huggingface dataset:
The Fortran‐P Translator: Towards Automatic Translation of Fortran 77 Programs for Massively Parallel Processors
Authors: O′keefe Matthew , Parr Terence , Edgar B. Kevin , Anderson Steve , Woodward Paul , Dietz Hank
Published: January 2015

Massively parallel processors (MPPs) hold the promise of extremely high performance that, if realized, could be used to study problems of unprecedented size and complexity. One of the primary stumbling blocks to this promise has been the lack of tools to translate application codes to MPP form. In this article we show how applications codes written in a subset of Fortran 77, called Fortran‐P, can be translated to achieve good performance on several massively parallel machines. This subset can express codes that are self‐similar, where the algorithm applied to the global data domain is also applied to each subdomain. We have found many codes that match the Fortran‐P programming style and have converted them using our tools. We believe a self‐similar coding style will accomplish what a vectorizable style has accomplished for vector machines by allowing the construction of robust, user‐friendly, automatic translation systems that increase programmer productivity and generate fast, efficient code for MPPs.
Parallel Performance of a Combustion Chemistry Simulation
Authors: Skinner Gregg , Eigenmann Rudolf
Published: January 2015

We used a description of a combustion simulation′s mathematical and computational methods to develop a version for parallel execution. The result was a reasonable performance improvement on small numbers of processors. We applied several important programming techniques, which we describe, in optimizing the application. This work has implications for programming languages, compiler design, and software engineering.
Simulation of Compressible Flow on a Massively Parallel Architecture
Authors: Williams Dan , Bauwens Luc
Published: January 2015

This article describes the porting and optimization of an explicit, time‐dependent, computational fluid dynamics code on an 8,192‐node MasPar MP‐1. The MasPar is a very fine‐grained, single instruction, multiple data parallel computer. The code uses the flux‐corrected transport algorithm. We describe the techniques used to port and optimize the code, and the behavior of a test problem. The test problem used to benchmark the flux‐corrected transport code on the MasPar was a two‐dimensional exploding shock with periodic boundary conditions. We discuss the performance that our code achieved on the MasPar, and compare its performance on the MasPar with its performance on other architectures. The comparisons show that the performance of the code on the MasPar is slightly better than on a CRAY Y‐MP for a functionally equivalent, optimized two‐dimensional code.
Low Latency Messages on Distributed Memory Multiprocessors
Authors: Rosing Matt , Saltz Joel
Published: January 2015

This article describes many of the issues in developing an efficient interface for communication on distributed memory machines. Although the hardware component of message latency is less than 1 ws on many distributed memory machines, the software latency associated with sending and receiving typed messages is on the order of 50 μs. The reason for this imbalance is that the software interface does not match the hardware. By changing the interface to match the hardware more closely, applications with fine grained communication can be put on these machines. This article describes several tests performed and many of the issues involved in supporting low latency messages on distributed memory machines.
All‐to‐All Communication on the Connection Machine CM‐200
Authors: Mathur Kapil K. , Johnsson S. Lennart
Published: January 2015

Detailed algorithms for all‐to‐all broadcast and reduction are given for arrays mapped by binary or binary‐reflected Gray code encoding to the processing nodes of binary cube networks. Algorithms are also given for the local computation of the array indices for the communicated data, thereby reducing the demand for the communications bandwidth. For the Connection Machine system CM‐200, Hamiltonian cycle‐based all‐to‐all communication algorithms yield a performance that is a factor of 2 to 10 higher than the performance offered by algorithms based on trees, butterfly networks, or the Connection Machine router. The peak data rate achieved for all‐to‐all broadcast on a 2,048‐node Connection Machine system CM‐200 is 5.4 Gbyte/s. The index order of the data in local memory depends on implementation details of the algorithms, but it is well defined. If a linear ordering is desired, then including the time for local data reordering reduces the effective peak data rate to 2.5 Gbyte/s.
Language Constructs for Data Partitioning and Distribution
Authors: Crooks P. , Perrott R. H.
Published: January 2015

This article presents a survey of language features for distributed memory multiprocessor systems (DMMs), in particular, systems that provide features for data partitioning and distribution. In these systems the programmer is freed from consideration of the low‐level details of the target architecture in that there is no need to program explicit processes or specify interprocess communication. Programs are written according to the shared memory programming paradigm but the programmer is required to specify, by means of directives, additional syntax or interactive methods, how the data of the program are decomposed and distributed.
A Case Study of Some Issues in the Optimization of Fortran 90 Array Notation
Authors: McCalpin John D.
Published: January 2015

Some issues in the relationship of coding style and compiler optimization are discussed with regard to Fortran 90 array notation. A review of several important Fortran 90 array constructs and their performance on vector and scalar hardware sets the stage for a more detailed example based on the kernel of a finite difference computational fluid dynamics model, specifically the nonlinear shallow water equations. Special attention is paid to the optimization of memory use and memory traffic. It is shown that the style of coding interacts with the rules of Fortran 90 and the current state of the art of Fortran 90 compilers to produce a fairly wide range of performance levels. Although performance degradations are typically small, a few cases of more serious loss of effciency are identified and discussed.
Programming Environment for a High‐Performance Parallel Supercomputer with Intelligent Communication
Authors: Gunzinger A. , BÄumle B. , Frey M. , Klebl M. , Kocheisen M. , Kohler P. , Morel R. , Müller U. , Rosenthal M.
Published: January 2015

At the Electronics Laboratory of the Swiss Federal Institute of Technology (ETH) in Zürich, the high‐performance parallel supercomputer MUSIC (MUlti processor System with Intelligent Communication) has been developed. As applications like neural network simulation and molecular dynamics show, the Electronics Laboratory supercomputer is absolutely on par with those of conventional supercomputers, but electric power requirements are reduced by a factor of 1,000, weight is reduced by a factor of 400, and price is reduced by a factor of 100. Software development is a key issue of such parallel systems. This article focuses on the programming environment of the MUSIC system and on its applications.
Massively Parallel Searching for Better Algorithms or How to Do a Cross Product with Five Multiplications
Authors: Gustafson John , Aluru Srinivas
Published: January 2015

A number of "tricks" are known that trade multiplications for additions. The term "tricks" reflects the way these methods seem not to proceed from any general theory, but instead jump into existence as recipes that work. The Strassen method for 2 × 2 matrix product with seven multiplications is a well‐known example, as is the method for finding a complex number product in three multiplications. We have created a practical computer program for finding such tricks automatically, where massive parallelism makes the combinatorially explosive search tolerable for small problems. One result of this program is a method for cross products of three‐vectors that requires only five multiplications.
Pattern‐Driven Automatic Parallelization
Authors: Kessler Christoph W.
Published: January 2015

This article describes a knowledge‐based system for automatic parallelization of a wide class of sequential numerical codes operating on vectors and dense matrices, and for execution on distributed memory message‐passing multiprocessors. Its main feature is a fast and powerful pattern recognition tool that locally identifies frequently occurring computations and programming concepts in the source code. This tool also works for dusty deck codes that have been "encrypted" by former machine‐specific code transformations. Successful pattern recognition guides sophisticated code transformations including local algorithm replacement such that the parallelized code need not emerge from the sequential program structure by just parallelizing the loops. It allows access to an expert′s knowledge on useful parallel algorithms, available machine‐specific library routines, and powerful program transformations. The partially restored program semantics also supports local array alignment, distribution, and redistribution, and allows for faster and more exact prediction of the performance of the parallelized target code than is usually possible.
The Design of Data‐Structure‐Neutral Libraries for the Iterative Solution of Sparse Linear Systems
Authors: Smith Barry F. , Gropp William D.
Published: January 2015

Over the past few years several proposals have been made for the standardization of sparse matrix storage formats in order to allow for the development of portable matrix libraries for the iterative solution of linear systems. We believe that this is the wrong approach. Rather than define one standard (or a small number of standards) for matrix storage, the community should define an interface (i.e., the calling sequences) for the functions that act on the data. In addition, we cannot ignore the interface to the vector operations because, in many applications, vectors may not be stored as consecutive elements in memory. With the acceptance of shared memory, distributed memory, and cluster memory parallel machines, the flexibility of the distribution of the elements of vectors is also extremely important. This issue is ignored in most proposed standards. In this article we demonstrate how such libraries may be written using data encapsulation techniques.
Implementing O(N) N‐Body Algorithms Efficiently in Data‐Parallel Languages
Authors: Hu Yu , Johnsson S. Lennart
Published: January 2015

The optimization techniques for hierarchical O(N) N‐body algorithms described here focus on managing the data distribution and the data references, both between the memories of different nodes and within the memory hierarchy of each node. We show how the techniques can be expressed in data‐parallel languages, such as High Performance Fortran (HPF) and Connection Machine Fortran (CMF). The effectiveness of our techniques is demonstrated on an implementation of Anderson′s hierarchical O(N) N‐body method for the Connection Machine system CM‐5/5E. Of the total execution time, communication accounts for about 10–20% of the total time, with the average efficiency for arithmetic operations being about 40% and the total efficiency (including communication) being about 35%. For the CM‐5E, a performance in excess of 60 Mflop/s per node (peak 160 Mflop/s per node) has been measured.
Compiler‐Enforced Cache Coherence Using a Functional Language
Authors: Wolski Rich , Cann David
Published: January 2015

The cost of hardware cache coherence, both in terms of execution delay and operational cost, is substantial for scalable systems. Fortunately, compiler‐generated cache management can reduce program serialization due to cache contention; increase execution performance; and reduce the cost of parallel systems by eliminating the need for more expensive hardware support. In this article, we use the Sisal functional language system as a vehicle to implement and investigate automatic, compiler‐based cache management. We describe our implementation of Sisal for the IBM Power/4. The Power/4, briefly available as a product, represents an early attempt to build a shared memory machine that relies strictly on the language system for cache coherence. We discuss the issues associated with deterministic execution and program correctness on a system without hardware coherence, and demonstrate how Sisal (as a functional language) is able to address those issues.
An Extended Two‐Phase Method for Accessing Sections of Out‐of‐Core Arrays
Authors: Thakur Rajeev , Choudhary Alok
Published: January 2015

A number of applications on parallel computers deal with very large data sets that cannot fit in main memory. In such applications, data must be stored in files on disks and fetched into memory during program execution. Parallel programs with large out‐of‐core arrays stored in files must read/write smaller sections of the arrays from/to files. In this article, we describe a method for accessing sections of out‐of‐core arrays efficiently. Our method, the extended two‐phase method, uses collective l/O: Processors cooperate to combine several l/O requests into fewer larger granularity requests, to reorder requests so that the file is accessed in proper sequence, and to eliminate simultaneous l/O requests for the same data. In addition, the l/O workload is divided among processors dynamically, depending on the access requests. We present performance results obtained from two real out‐of‐core parallel applications – matrix multiplication and a Laplace′s equation solver – and several synthetic access patterns, all on the Intel Touchstone Delta. These results indicate that the extended two‐phase method significantly outperformed a direct (noncollective) method for accessing out‐of‐core array sections.
SPINET: A Parallel Computing Approach to Spine Simulations
Authors: Kropf Peter G. , Lederer Edgar F. A. , Steffen Thomas , Guggisberg Karl , Schneider Jean-Guy , Schwab Peter
Published: January 2015

Research in scientitic programming enables us to realize more and more complex applications, and on the other hand, application‐driven demands on computing methods and power are continuously growing. Therefore, interdisciplinary approaches become more widely used. The interdisciplinary SPINET project presented in this article applies modern scientific computing tools to biomechanical simulations: parallel computing and symbolic and modern functional programming. The target application is the human spine. Simulations of the spine help us to investigate and better understand the mechanisms of back pain and spinal injury. Two approaches have been used: the first uses the finite element method for high‐performance simulations of static biomechanical models, and the second generates a simulation developmenttool for experimenting with different dynamic models. A finite element program for static analysis has been parallelized for the MUSIC machine. To solve the sparse system of linear equations, a conjugate gradient solver (iterative method) and a frontal solver (direct method) have been implemented. The preprocessor required for the frontal solver is written in the modern functional programming language SML, the solver itself in C, thus exploiting the characteristic advantages of both functional and imperative programming. The speedup analysis of both solvers show very satisfactory results for this irregular problem. A mixed symbolic‐numeric environment for rigid body system simulations is presented. It automatically generates C code from a problem specification expressed by the Lagrange formalism using Maple.
Functional Implementations of the Jacobi Eigensolver
Authors: Böhm A. P. W. , Hiromoto R. E.
Published: January 2015

In this article we describe the systematic development of two implementations of the Jacobi eigensolver and give their initial performance results for the MIT/Motorola Monsoon dataflow machine. Our study is carried out using MINT, the MIT Monsoon simulator. The functional semantics with respect to array updates, which cause excessive array copying, have led us to an implementation of a parallel "group rotations" algorithm first described by Sameh. Our version of this algorithm requires O(n3) operations, whereas Sameh′s original version requires O(n4) operations. The convergence of the group algorithm is briefly treated. We discuss the issues involved in rewriting the algorithm in Sisal, a strict, purely functional language without explicit l‐structures.
The Giga View Multiprocessor Multidisk Image Server
Authors: Gennart B. A. , Krummenacher B. , Landron L. , Hersch R. D. , Saugy B. , Hadorn J.-C. , Müller D.
Published: January 2015

Professionals in various fields such as medical imaging, biology, and civil engineering require rapid access to huge amounts of pixmap image data. Multimedia interfaces further increase the need for large image databases. To fulfill these requirements, the GigaView parallel image server architecture relies on arrays of intelligent disk nodes, each disk node being composed of one processor and one disk. This contribution reviews the design of the GigaView hardware and file system, compares it to other storage servers available on the market, and evaluates fields of applications for the architecture.
PDDP, A Data Parallel Programming Model
Authors: Warren Karen H.
Published: January 2015

PDDP, the parallel data distribution preprocessor, is a data parallel programming model for distributed memory parallel computers. PDDP implements high‐performance Fortran‐compatible data distribution directives and parallelism expressed by the use of Fortran 90 array syntax, the FORALL statement, and the WHERE construct. Distributed data objects belong to a global name space; other data objects are treated as local and replicated on each processor. PDDP allows the user to program in a shared memory style and generates codes that are portable to a variety of parallel machines. For interprocessor communication, PDDP uses the fastest communication primitives on each platform.
A Hybrid Imperative and Functional Molecular Mechanics Application
Authors: Deboni Thomas , Feo John , Peters Doug
Published: January 2015

Molecular mechanics applications model the interactions among large ensembles of discrete particles. They are used where probabilistic methods are inadequate, such as drug chemistry. This methodology is difficult to parallelize with good performance, due to its poor locality, uneven partitions, and dynamic behavior. Imperative programs have been written that attempt this on shared and distributed memory machines. Given such a program, the computational kernel can be rewritten in Sisal, a functional programming language, and integrated with the rest of the imperative program under the Sisal Foreign Language Interface. This allows minimal effort and maximal return from parallelization work, and leaves the work appropriate to imperative implementation in its original form. We describe such an effort, focusing on the parts of the application that are appropriate for Sisal implementation, the specifics of mixed‐language programming, and the complex performance behavior of the resulting hybrid code.
A New Language Design for Prototyping Numerical Computation
Authors: Derby Thomas , Schnabel Robert , Zorn Benjamin
Published: January 2015

To naturally and conveniently express numerical algorithms, considerable expressive power is needed in the languages in which they are implemented. The language Matlab is widely used by numerical analysts for this reason. Expressiveness or ease‐of‐use can also result in a loss of efficiency, as is the case with Matlab. In particular, because numerical analysts are highly interested in the performance of their algorithms, prototypes are still often implemented in languages such as Fortran. In this article we describe a language design that is intended to both provide expressiveness for numerical computation, and at the same time provide performance guarantees. In our language, EQ, we attempt to include both syntactic and semantic features that correspond closely to the programmer′s model of the problem, including unordered equations, large‐granularity state transitions, and matrix notation. The resulting language does not fit into standard language categories such as functional or imperative but has features of both paradigms. We also introduce the notion of language dependability, which is the idea that a language should guarantee that certain program transformations are performed by all implementations. We first describe the interesting features of EQ, and then present three examples of algorithms written using it. We also provide encouraging performance results from an initial implementation of our language.
Automatic Data Distribution for Composite Grid Applications
Authors: Liebrock Lorie M. , Kennedy Ken
Published: January 2015

Problem topology is the key to efficient parallelization support for partially regular applications. Specifically, problem topology provides the information necessary for automatic data distribution and regular application optimization of a large class of partially regular applications. Problem topology is the connectivity of the problem. This research focuses on composite grid applications and strives to take advantage of their partial regularity in the parallelization and compilation process. Composite grid problems arise in important application areas, e.g., reactor and aerodynamic simulation. Related physical phenomena are inherently parallel and their simulations are computationally intensive. We present algorithms that automatically determine data distributions for composite grid problems. Our algorithm′s alignment and distribution specifications may be used as input to a High Performance Fortran program to apply the mapping for execution of the simulation code. These algorithms eliminate the need for user‐specified data distribution for this large class of complex topology problems. We test the algorithms using a number of topological descriptions from aerodynamic and water‐cooled nuclear reactor simulations. Speedup‐bound predictions with and without communication, based on the automatically generated distributions, indicate that significant speedups are possible using these algorithms.
Expression of Three Cell Adhesion Molecules in Bladder Carcinomas: Correlation with Pathological Features
Authors: Mialhe Agnès , Louis Josette , Pasquier Dominique , Rambeaud Jean‐Jacques , Seigneurin Daniel
Published: January 2015

Recently, independent studies have shown that the expression of two integrin chains, β4 and α2, plus the epithelial cadherin are related to tumour progression in human bladder carcinomas. For the first time, we compare the expression of these three cell adhesion molecules using immunohistochemical analysis of consecutive cryosections from a series of 50 bladder tumours. E‐cadherin, β4, and α2 were strongly expressed in normal urothelium. A majority of non‐invasive bladder cancers stained positively for E‐cadherin (62%), whereas only 29% expressed normal positivity for α2, and only 35% for β4. However, most invasive tumours presented an aberrant expression of α2 (81%), β4 (100%), and E‐cadherin (75%). We studied the correlation of immunoreactivity with histological grade and stage. The α2 pattern was not correlated with stage and grade. In contrast, loss of normal β4 expression was significantly related to increasing tumour grade and deep invasion with a higher correlation for grade. Finally, E‐cadherin expression was highly correlated with stage, but not with grade. Thus our results indicate that, although many invasive bladder tumours presented a disorder in expression of the two integrins α2 and β4, E‐cadherin appeared to be a better marker of invasiveness in bladder carcinomas.

Erratum of
“Expression of Three Cell Adhesion Molecules in Bladder Carcinomas: Correlation with Pathological Features”dx.doi.org/10.1155/1997/585174
Experiences in Data‐Parallel Programming
Authors: Clark Terry W. , v. Hanxleden Reinhard , Kennedy Ken
Published: January 2015

To efficiently parallelize a scientific application with a data‐parallel compiler requires certain structural properties in the source program, and conversely, the absence of others. A recent parallelization effort of ours reinforced this observation and motivated this correspondence. Specifically, we have transformed a Fortran 77 version of GROMOS, a popular dusty‐deck program for molecular dynamics, into Fortran D, a data‐parallel dialect of Fortran. During this transformation we have encountered a number of difficulties that probably are neither limited to this particular application nor do they seem likely to be addressed by improved compiler technology in the near future. Our experience with GROMOS suggests a number of points to keep in mind when developing software that may at some time in its life cycle be parallelized with a data‐parallel compiler. This note presents some guidelines for engineering data‐parallel applications that are compatible with Fortran D or High Performance Fortran compilers.
Significance of Apoptosis in the Process of Tumorigenesis in Colorectal Mucosa and Adenomas in FAP Patients
Authors: Weiß Hildegard , Jacobasch Karl‐Heinz , Haensch Wolfgang , Streller Brigitte , Hieke Brigitte
Published: January 2015

The relation between proliferation and apoptosis was studied in colorectal mucosal biopsies (N=41), tubular adenomas (TA) (N=104) and tubulovillous adenomas (TVA) (N=34) from 37 FAP patients. Proliferative activity was determined by cell cycle distribution analysis. In addition, transcriptional capacity was determined by chromatin in situ testing. For both, DNA flow cytometry was used. Cycling cells were identified by immunohistochemical staining with monoclonal antibody Ki67. The existence of subdiploid apoptotic cells was derived from DNA and/or DNA/protein patterns. In a follow‐up group, the mucosa is characterised by a balance between proliferation (S % + G2M % = 19) and apoptotic cells (% = 17). The percentage of Ki67 positive cells (16%) corresponds to the percentages mentioned above. In TA, the amount of apoptotic cells remains unaltered, in TVA it decreases to 8%. At the same time, the percentage of Ki67 positive cells increases significantly in both TA and TVA (39%, 42%). With patients who underwent surgery due to clinical signs without histological evidence for malignancy, apoptotic cells in TA continue to decrease significantly (9%), without any changes in cycling cells. Only in the carcinoma‐bearing bowel, cycling cells increase to 52%. Here, the percentage of apoptotic cells in TVA reaches the lowest level (5%). A connection between proliferation and apoptosis was observed in mucosa and TVA. The process of tumorigenesis is characterised by a stepwise increase in resistance to apoptosis followed by an increase in cycling cells.
The Reproducibility of Nuclear Morphometric Measurements in Invasive Breast Carcinoma
Authors: Kronqvist Pauliina , Kuopio Teijo , Collan Yrjö , Horvath Csaba , Tamm Ülle
Published: January 2015

The intraobserver and interobserver reproducibility of computerized nuclear morphometry was determined in repeated measurements of 212 samples of invasive breast cancer. The influence of biological variation and the selection of the measurement area was also tested. Morphometrically determined mean nuclear profile area (Pearson’s r 0.89, grading efficiency (GE) 0.95) and standard deviation (SD) of nuclear profile area (Pearson’s r 0.84, GE 0.89) showed high reproducibility. In this respect, nuclear morphometry equals with other established methods of quantitative pathology and exceeds the results of subjective grading of nuclear atypia in invasive breast cancer. A training period of eight days was sufficient to produce clear improvement in consistency of nuclear morphometry results. By estimating the sources of variation it could be shown that the variation associated with the measurement procedure itself is small. Instead, sample associated variation is responsible for the majority of variation in the measurements (82.9% in mean nuclear profile area and 65.9% in SD of nuclear profile area). This study points out that when standardized methods are applied computerized morphometry is a reproducible and reliable method of assessing nuclear atypia in invasive breast cancer. For further improvement special emphasize should be put on sampling rules of selecting the microscope fields and measurement areas.
Visualization of Distributed Data Structures for High Performance Fortran‐Like Languages
Authors: Koppler Rainer , Grabner Siegfried , Volkert Jens
Published: January 2015

This article motivates the usage of graphics and visualization for efficient utilization of High Performance Fortran′s (HPF′s) data distribution facilities. It proposes a graphical toolkit consisting of exploratory and estimation tools which allow the programmer to navigate through complex distributions and to obtain graphical ratings with respect to load distribution and communication. The toolkit has been implemented in a mapping design and visualization tool which is coupled with a compilation system for the HPF predecessor Vienna Fortran. Since this language covers a superset of HPF′s facilities, the tool may also be used for visualization of HPF data structures.
PCNA, Ki‐67, p53, bcl‐2 and Prognosis in Intraoral Squamous Cell Carcinoma of the Head and Neck
Authors: Nylander Karin , Schildt Elsy‐Britt , Eriksson Mikael , Roos Göran
Published: January 2015

Eighty patients with primary intraoral squamous cell carcinomas of the head and neck, with a follow‐up of 4–14 years were analysed for clinical outcome in relation to immunohistochemical expression of PCNA, Ki‐67, p53, bcl‐2 and presence of mutations in the p53 gene. The tumour site was not associated with the different parameters calculated. PCNA and Ki‐67 labelling showed median values of 56% and 32%, respectively, and neither antigen was of predictive value. Fiftyfive percent of the tumours expressed p53, and 38 (48%) had mutations in the p53 gene. No association between the presence of p53 protein or mutations in the p53 gene and clinical outcome was found. Bcl‐2 positivity was detected in a minor fraction (10%) of the tumours.
An Algebraic Machinery for Optimizing Data Motion for HPF
Authors: Wu Jan-Jan , Chen Marina C.
Published: January 2015

This paper describes a general compiler optimization technique that reduces communica tion over‐head for FORTRAN‐90 (and High Performance FORTRAN) implementations on massively parallel machines.
Detection of Malignancy Associated Changes in Cervical Cell Nuclei Using Feed‐Forward Neural Networks
Authors: Kemp Roger A. , MacAulay Calum , Garner David , Palcic Branko
Published: January 2015

Normal cells in the presence of a precancerous lesion undergo subtle changes of their DNA distribution when observed by visible microscopy. These changes have been termed Malignancy Associated Changes (MACs). Using statistical models such as neural networks and discriminant functions it is possible to design classifiers that can separate these objects from truly normal cells. The correct classification rate using feed‐forward neural networks is compared to linear discriminant analysis when applied to detecting MACs. Classifiers were designed using 53 nuclear features calculated from images for each of 25,360 normal appearing cells taken from 344 slides diagnosed as normal or containing severe dysplasia. A linear discriminant function achieved a correct classification rate of 61.6% on the test data while neural networks scored as high as 72.5% on a cell‐by‐cell basis. The cell classifiers were applied to a library of 93,494 cells from 395 slides, and the results were jackknifed using a single slide feature. The discriminant function achieved a correct classification rate of 67.6% while the neural networks managed as high as 76.2%.
Data‐Parallel Programming in a Multithreaded Environment
Authors: Haines Matthew , Mehrotra Piyush , Cronk David
Published: January 2015

Research on programming distributed memory multiprocessors has resulted in a well‐understood programming model, namely data‐parallel programming. However, data‐parallel programming in a multithreaded environment is far less understood. For example, if multiple threads within the same process belong to different data‐parallel computations, then the architecture, compiler, or run‐time system must ensure that relative indexing and collective operations are handled properly and efficiently. We introduce a run‐time‐based solution for data‐parallel programming in a distributed memory environment that handles the problems of relative indexing and collective communications among thread groups. As a result, the data‐parallel programming model can now be executed in a multithreaded environment, such as a system using threads to support both task and data parallelism.
DNA Histogram Interpretation Based on Statistical Approaches
Authors: Haroske G. , Dimmer V. , Meyer W. , Kunze K. D.
Published: January 2015

Image cytometric DNA measurements provide data which are most often interpreted as equivalent to the chromosomal ploidy although the chromosomal and the DNA ploidy are not identical. The common link between them is the cell cycle. Therefore, if destined for DNA ploidy interpretations, the DNA cytometry should be performed on a population‐oriented stochastic basis. Using stochastic sampling the data can be interpreted by applying the rules of stochastic processes. A set of statistical methods is given that enables a DNA histogram to be interpreted objectively and without human interaction. These statistics analyse the precision and accuracy of the entire measurement process. They give in error probabilities for accepting a measurement as reliable, for recognition of stemlines, stemline aneuploidy, and for evaluating so‐called rare events. Nearly 300 image cytometric DNA measurements from breast cancers and rat liver imprints examples have been selected to demonstrate the efficiency of the statistics in each step of interpreting DNA histograms.
Nuclear and Nucleolar Image Analysis of Human Breast Epithelial Cells Transformed by benzo[a]pyrene and Transfected with the c‐Ha‐ras oncogene
Authors: Barbisan Luís Fernando , Russo Jose , Mello Maria Luiza S.
Published: January 2015

Changes in nuclear and nucleolar morphometric parameters were investigated by image analysis procedures in human breast MCF‐10F epithelial cells expressing different stages of the tumourigenic progression after benzo[a]pyrene (BP) transformation (BP1, BP1‐E, and BP1‐E1 cell lines), and additionally transfected with the c‐Ha‐ras oncogene (BP1‐Tras cell line). Nuclear pleomorphism was evident in all the transformed cells. The analysis of different morphometric parameters did not show a clear relationship between specific nuclear and nucleolar changes and the expression of the different stages of the tumourigenesis, with the exception of the nucleolar size, which could be associated to the expression of the tumourigenic phenotype, and a nucleolar area/nuclear area ratio, which discriminated the immortalized, the transformed, and the tumourigenic phenotypes from one another. The nuclear morphometric data established for the BP‐transformed cells and for the cells additionally transfected with the c‐Ha‐ras oncogene were suggestive of complex and distinct morphofunctional mechanisms involving the in vitro transformation of the MCF‐10F cells. The nuclear changes found in the BP1‐Tras cell line were assumed to be related to the additional effects and/or enhanced genomic instability induced by transfection with the ras oncogene.
Apoptotic Cell Death and the Proliferative Capacity of Human Breast Cancers
Authors: Losa Gabriele A. , Graber Riccardo
Published: January 2015

The proliferative capacity (%S‐phase fraction), DNA ploidy, apoptosis frequency (DNA fragmentation) and steroid hormone receptor status (estrogen receptor, ER; progesterone receptor, PR) of 110 samples of human breast tissues with ductal invasive carcinoma were measured using biochemical and cytofluorimetric procedures. The DNA fragmentation had a left‐skewed frequency distribution and an overall median value of 1.64%, whilst the median %S‐phase fraction was 8%. The median %DNA fragmentation and %S‐phase fraction were 1.96% and 16% in hyperdiploid tumours (n=29; DNA index >1.1) higher than in hypodiploid tumors (n=10; DNA index 0.96), 0.38% and 7.5%. DNA diploid tumours (n=71) had median %DNA fragmentation and %S‐phase values of 1.68% and 6%, consistently lower than the median values of DNA hyperdiploid tumours. The ER content of hypodiploid tumours was about one half (median: 5.9 fmol/mg) the median values in hyperdiploid (10.6 fmol/mg) and diploid tumours (14.6 fmol/mg). This may correlate with the lowest frequency of apoptosis in hypodiploid tumours, at least when measured by biochemical methods which only detect cells in the late phases of apoptosis. In contrast, the median PR was lowest in hyperdiploid tumours than in hypo and/or diploid tumours. The %S‐phase/%fragmented DNA ratio for the hypodiploid tumours was 19.7, significantly higher than the ratios for hyperdiploid (8.2) and diploid tumours (3.6). These findings indicated that there is an imbalance between proliferative capacity and cell death or growth arrest in human breast tumours. This imbalance may well be linked to a loss of steroid hormone control.
JLAPACK – Compiling LAPACK FORTRAN to Java
Authors: Doolin David M. , Dongarra Jack , Seymour Keith
Published: January 2015

The JLAPACK project provides the LAPACK numerical subroutines translated from their subset Fortran 77 source into class files, executable by the Java Virtual Machine (JVM) and suitable for use by Java programmers. This makes it possible for Java applications or applets, distributed on the World Wide Web (WWW) to use established legacy numerical code that was originally written in Fortran. The translation is accomplished using a special purpose Fortran‐to‐Java (source‐to‐source) compiler. The LAPACK API will be considerably simplified to take advantage of Java’s object‐oriented design. This report describes the research issues involved in the JLAPACK project, and its current implementation and status.
Heterogeneity of DNA Distribution in Diploid Cells: A New Predicitive Discriminant Factor for Solid Tumour Behaviour
Authors: Assailly Jacques , Desgrippes Arnaud , Loridon‐Rosa Brigitte , Piron Dominique , Dachez Roger , Beurton Daniel
Published: January 2015

Spatial nuclear DNA heterogeneity distribution of Feulgen‐stained DNA diploid cells was studied by image cytometry in voided urine of 119 patients without bladder tumour (n=20) and with initial (n=23) or previous (n=76) diagnosed bladder tumour. For each patient, repetitive DNA measurements were performed during 1–4 years of follow up. Only cells of diploid DNA histograms and diploid subpopulations of aneuploid DNA histograms were used for analysis. DNA heterogeneity distribution of these diploid cells was quantified by statistical parameters of each nuclear optical density distribution. Discriminant analysis was performed on three groups of DNA histograms. Group A (n=44): aneuploid DNA histograms of patients with bladder tumour. Group D (n=55): 38 diploid DNA histograms of the 20 patients without bladder tumour (subgroup D1) and 17 diploid DNA histograms of patients with a non‐recurrent bladder tumour (subgroup D2). Group R (n=27): diploid DNA histograms of patients with bladder tumour recurrence. No statistically significant discriminant function was found to separate D1 and D2. However, the first canonical discriminant function C1 differentiated diploid cells of diploid DNA histograms (group D and group R) from diploid cell subpopulations of aneuploid DNA histograms (group A). Mean C1 values were 1.06, 0.84 and –1.45 for groups R, D and A, respectively. The second canonical discriminant function C2 differentiated diploid DNA histograms of patients with bladder tumour recurrence (group R) from diploid DNA histograms of patients without bladder tumour or without bladder tumour recurrence (group D). Mean C2 values were 1.78 and –0.76 for groups R and D, respectively. In 95% confidence limit, the rate of rediscrimination using the two first canonical discriminant functions C1 and C2 were 86.4, 74.5 and 74.1% for groups A, D and R, respectively. Percent of “grouped” cases correctly classified was 78.6%. Thus spatial DNA heterogeneity distribution of diploid cells seems to quantitate probable genetic instability as a function of clinical evolution such as tumour recurrence, and suggests the possible presence of aneuploid stemlines in a heterogeneous tumour, even if a diploid DNA histogram is observed in a single sample. From standardized C1 and C2 canonical discriminant function coefficients, a DNA heterogeneity index (2c‐HI) is proposed to characterize diploid cells providing a descriptive and predictive discriminant factor for solid tumour behaviour.
VFC: The Vienna Fortran Compiler
Authors: Benkner Siegfried
Published: January 2015

High Performance Fortran (HPF) offers an attractive high‐level language interface for programming scalable parallel architectures providing the user with directives for the specification of data distribution and delegating to the compiler the task of generating an explicitly parallel program. Available HPF compilers can handle regular codes quite efficiently, but dramatic performance losses may be encountered for applications which are based on highly irregular, dynamically changing data structures and access patterns. In this paper we introduce the Vienna Fortran Compiler (VFC), a new source‐to‐source parallelization system for HPF+, an optimized version of HPF, which addresses the requirements of irregular applications. In addition to extended data distribution and work distribution mechanisms, HPF+ provides the user with language features for specifying certain information that decisively influence a program’s performance. This comprises data locality assertions, non‐local access specifications and the possibility of reusing runtime‐generated communication schedules of irregular loops. Performance measurements of kernels from advanced applications demonstrate that with a high‐level data parallel language such as HPF+ a performance close to hand‐written message‐passing programs can be achieved even for highly irregular codes.
U‐Net/SLE: A Java‐Based User‐Customizable Virtual Network Interface
Authors: Welsh Matt , Oppenheimer David , Culler David
Published: January 2015

We describe U‐Net/SLE (Safe Language Extensions), a user‐level network interface architecture which enables per‐application customization of communication semantics through downloading of user extension applets, implemented as Java classfiles, to the network interface. This architecture permits applications to safely specify code to be executed within the NI on message transmission and reception. By leveraging the existing U‐Net model, applications may implement protocol code at the user level, within the NI, or using some combination of the two. Our current implementation, using the Myricom Myrinet interface and a small Java Virtual Machine subset, allows host communication overhead to be reduced and improves the overlap of communication and computation during protocol processing.
Integrated Task and Data Parallel Support for Dynamic Applications
Authors: Rehg James M. , Knobe Kathleen , Ramachandran Umakishore , Nikhil Rishiyur S. , Chauhan Arun
Published: January 2015

There is an emerging class of real‐time interactive applications that require the dynamic integration of task and data parallelism. An example is the Smart Kiosk, a free‐standing computer device that provides information and entertainment to people in public spaces. The kiosk interface is computationally demanding: It employs vision and speech sensing and an animated graphical talking face for output. The computational demands of an interactive kiosk can vary widely with the number of customers and the state of the interaction. Unfortunately this makes it difficult to apply current techniques for integrated task and data parallel computing, which can produce optimal decompositions for static problems. Using experimental results from a color‐based people tracking module, we demonstrate the existence of a small number of distinct operating regimes in the kiosk application. We refer to this type of program behavior as constrained dynamism. An application exhibiting constrained dynamism can execute efficiently by dynamically switching among a small number of statically determined fixed data parallel strategies. We present a novel framework for integrating task and data parallelism for applications that exhibit constrained dynamism. Our solution has been implemented using Stampede, a cluster programming system developed at the Cambridge Research Laboratory.
Incorporating IntelⓇ MMXTM Technology into a JavaTM JIT Compiler
Authors: Bik Aart J.C. , Girkar Milind , Haghighat Mohammad R.
Published: January 2015

IntelⓇ MMXTM technology can be exploited by a JavaTM JIT compiler to speedup the execution of integer operations. While translating bytecode into Intel machine code, the compiler identifies innermost loops that allow the same integer operations to be applied to multiple data elements in parallel and generates code that uses IntelⓇ MMXTM technology to execute these loops in SIMD fashion. In the context of JIT compilation, compile‐time directly contributes to the run‐time of the application. Therefore, limiting program analysis‐time and synthesis‐time is even more important than in a static compilation model. The compiler must also ensure that arithmetic precision and the exception handling semantics specified by the JVM are preserved.
Combining Compile‐Time and Run‐Time Parallelization
Authors: Moon Sungdo , So Byoungro , Hall Mary W.
Published: January 2015

This paper demonstrates that significant improvements to automatic parallelization technology require that existing systems be extended in two ways: (1) they must combine high‐quality compile‐time analysis with low‐cost run‐time testing; and (2) they must take control flow into account during analysis. We support this claim with the results of an experiment that measures the safety of parallelization at run time for loops left unparallelized by the Stanford SUIF compiler’s automatic parallelization system. We present results of measurements on programs from two benchmark suites – SPECFP95 and NAS sample benchmarks – which identify inherently parallel loops in these programs that are missed by the compiler. We characterize remaining parallelization opportunities, and find that most of the loops require run‐time testing, analysis of control flow, or some combination of the two. We present a new compile‐time analysis technique that can be used to parallelize most of these remaining loops. This technique is designed to not only improve the results of compile‐time parallelization, but also to produce low‐cost, directed run‐time tests that allow the system to defer binding of parallelization until run‐time when safety cannot be proven statically. We call this approach predicated array data‐flow analysis. We augment array data‐flow analysis, which the compiler uses to identify independent and privatizable arrays, by associating predicates with array data‐flow values. Predicated array data‐flow analysis allows the compiler to derive “optimistic” data‐flow values guarded by predicates; these predicates can be used to derive a run‐time test guaranteeing the safety of parallelization.