bluuebunny/crossref_metadata_2025 huggingface dataset:
Association between clinical characteristics and risk‐reduction interventions in women who underwent BRCA1 and BRCA2 testing
Authors: Uyei Anne , Peterson Susan K. , Erlichman Julie , Broglio Kristine , Yekell Sandra , Schmeler Kathkeen , Lu Karen , Meric‐Bernstam Funda , Amos Chris , Strong Louise , Arun Banu
Published: November 2006

BACKGROUND.

Women who are at increased risk for breast and ovarian cancers, especially BRCA1 and BRCA2 mutation carriers, face a myriad of risk‐reduction options, including increased surveillance, chemoprevention, prophylactic oophorectomy, and prophylactic mastectomy. However, little is known about which clinical, demographic, or cancer‐related factors are associated with risk‐reduction interventions.

METHODS.

The authors conducted a retrospective review of records for 554 women who had undergone testing at The University of Texas M. D. Anderson Cancer Center between 2000 and 2006 for deleterious BRCA1 and BRCA2 gene mutations. Data were collected on the risk‐reduction interventions these women adopted after they underwent genetic testing. These data were tested for associations with demographic and clinical characteristics.

RESULTS.

Among the 554 women who underwent genetic testing for BRCA mutation, 78 were found to have a deleterious mutation in the BRCA1 gene, and 54 had a mutation in the BRCA 2 gene. Of the 554 women, 85 underwent prophylactic mastectomy, 30 prophylactic oophorectomy, and 52 both surgeries; 387 women opted for surveillance. Women who had BRCA mutations, a history of breast cancer or ductal carcinoma in situ (DCIS), or previous breast biopsies were more likely to have prophylactic surgery. Women with a family history of ovarian cancer were more likely to undergo prophylactic oophorectomy. Women with a personal history of ovarian cancer or advanced breast cancer were more likely to undergo surveillance only. Women with breast cancer who had had a total mastectomy as part of their prior breast cancer treatment underwent prophylactic mastectomy more frequently than women who either had breast‐conserving surgery or no history of breast cancer. In multivariate analysis, only positive BRCA mutation carrier status was associated with having had prophylactic surgery. In addition, breast cancer history was significantly associated with prophylactic mastectomy.

CONCLUSIONS.

Women who were BRCA carriers, women who had a history of breast cancer, DCIS, or breast biopsy, or had a family history of ovarian cancer were more likely to have undergone surgery for cancer risk reduction. Women with ovarian cancer or advanced breast cancer were more likely to have undergone surveillance. Cancer 2006. © 2006 American Cancer Society.
Metastatic disease of screen‐detected prostate cancer
Authors: Roemeling Stijn , Kranse Ries , Vis André N. , Gosselaar Claartje , van der Kwast Theo H. , Schröder Fritz H.
Published: November 2006

BACKGROUND.

Screening for prostate cancer has not only led to a stage migration, but also to a higher incidence of the disease. A decrease in mortality has occurred in several countries during the same time period. Risk stratification of screen‐detected cancers at diagnosis has become more important for the anticipation and interpretation of changing incidence/mortality ratios.

METHODS.

From 1993 to 1998, 633 men were diagnosed with nonmetastatic prostate cancer in the prevalence screen of the Rotterdam section of the European Randomized study of Screening for Prostate Cancer (ERSPC). The characteristics at diagnosis of men who developed metastatic disease were compared with men without evidence of metastases during follow‐up.

RESULTS.

During the median follow‐up of 7.5 years, 41 men developed metastatic disease. After 10 years the metastasis‐free survival rate was 89.6%, the overall survival 64.7%. In a Cox‐model 2logPSA (prostate‐specific antigen), biopsy Gleason score and the number of biopsy cores with prostate cancer were independent predictors for the development of metastases; the latter only predicted metastases that presented within 60 months of follow‐up.

CONCLUSIONS.

The metastasis‐free survival of men with prostate cancer detected in a prevalence screening was very high. Whether this was related to the beneficial effects of screening or to overdiagnosis due to screening (or both) remains unclear. The prognostic factors known for clinically diagnosed disease also hold for screen‐detected disease. Cancer 2006. © 2006 American Cancer Society.
Immunohistochemical localization of CNTFRα in adult mouse retina and optic nerve following intraorbital nerve crush: Evidence for the axonal loss of a trophic factor receptor after injury
Authors: Miotke Jill A. , MacLennan A. John , Meyer Ronald L.
Published: November 2006

Ciliary neurotrophic factor (CNTF) is important for the survival and outgrowth of retinal ganglion cells (RGCs) in vitro. However, in vivo adult RGCs fail to regenerate and subsequently die following axotomy, even though there are high levels of CNTF in the optic nerve. To address this discrepancy, we used immunohistochemistry to analyze the expression of CNTF receptor α (CNTFRα) in mouse retina and optic nerve following intraorbital nerve crush. In normal mice, RGC perikarya and axons were intensely labeled for CNTFRα. At 24 hours after crush, the immunoreactivity normally seen on axons in the nerve was lost near the lesion. This loss radiated from the crush site with time. At 2 days postlesion, labeled axons were not detected in the proximal nerve, and at 2 weeks were barely detectable in the retina. In the distal nerve, loss of axonal staining progressed to the optic chiasm by 7 days and remained undetectable at 2 weeks. Interfascicular glia in the normal optic nerve were faintly labeled, but by 24 hours after crush they became intensely labeled near the lesion. Double labeling showed these to be both astrocytes and oligodendrocytes. At 7 days postlesion, darkly labeled glia were seen throughout the optic nerve, but at 14 days labeling returned to normal. It is suggested that the loss of CNTFRα from axons renders RGCs unresponsive to CNTF, thereby contributing to regenerative failure and death, while its appearance on glia may promote glial scarring. J. Comp. Neurol. 500:384–400, 2007. © 2006 Wiley‐Liss, Inc.
The folate metabolic enzyme ALDH1L1 is restricted to the midline of the early CNS, suggesting a role in human neural tube defects
Authors: Anthony Todd E. , Heintz Nathaniel
Published: November 2006

Folate supplementation prevents up to 70% of human neural tube defects (NTDs), although the precise cellular and metabolic sites of action remain undefined. One possibility is that folate modulates the function of metabolic enzymes expressed in cellular populations involved in neural tube closure. Here we show that the folate metabolic enzyme ALDH1L1 is cell‐specifically expressed in PAX3‐negative radial glia at the midline of the neural tube during early murine embryogenesis. Midline restriction is not a general property of this branch of folate metabolism, as MTHFD1 displays broad and apparently ubiquitous expression throughout the neural tube. Consistent with previous work showing antiproliferative effects in vitro, ALDH1L1 upregulation during central nervous system (CNS) development correlates with reduced proliferation and most midline ALDH1L1+ cells are quiescent. These data provide the first evidence for localized differences in folate metabolism within the early neural tube and suggest that folate might modulate proliferation via effects on midline Aldh1l1+ cells. To begin addressing its role in neurulation, we analyzed a microdeletion mouse strain lacking Aldh1l1 and observed neither increased failure of neural tube closure nor detectable proliferation defects. Although these results indicate that loss‐of‐function Aldh1l1 mutations do not impair these processes in mice, the specific midline expression of ALDH1L1 and its ability to dominantly suppress proliferation in a folate responsive manner may suggest that mutations contributing to disease are gain‐of‐function, rather than loss‐of‐function. Moreover, a role for loss‐of‐function mutations in human NTDs remains possible, as Mthfr null mice do not develop NTDs even though MTHFR mutations increase human NTD risk. J. Comp. Neurol. 500:368–383, 2007. © 2006 Wiley‐Liss, Inc.
MyCoG.NET: a multi‐language CoG toolkit
Authors: Paventhan A. , Takeda Kenji , Cox Simon J. , Nicole Denis A.
Published: November 2006

Grid application developers utilize Commodity Grid (CoG) toolkits to access Globus Grid services. Existing CoG toolkits are language‐specific and have, for example, been developed for Java, Python and the Matlab scripting environment. In this paper we describe MyCoG.NET, a CoG toolkit supporting multi‐language programmability under the Microsoft .NET framework. MyCoG.NET provides a set of classes and APIs to access Globus Grid services from languages supported by the .NET Common Language Runtime. We demonstrate its programmability using FORTRAN, C++, C# and Java, and discuss its performance over LAN and WAN infrastructures. We present a Grid application, in the field of experimental aerodynamics, as a case study to show how MyCoG.NET can be exploited. We demonstrate how scientists and engineers can create and use domain‐specific workflow activity sets for rapid application development using Windows Workflow Foundation. We also show how users can easily extend and customize these activities. Copyright © 2006 John Wiley & Sons, Ltd.
Towards an autonomic approach for edge computing
Authors: Desertot Mikael , Escoffier Clement , Donsez Didier
Published: November 2006

Nowadays, one of the biggest challenges for companies is to cope with the high cost of their information technologies infrastructure. Edge computing is a new computing paradigm designed to allocate on‐demand computing and storage resources. Those resources are Web cache servers scattered over the ISP backbones. We argue that this paradigm could be applied for on‐demand full application hosting, helping to reduce costs. In this paper, we present a J2EE (Java Enterprise Edition) dynamic server able to deploy/host J2EE applications on demand and its autonomic manager. For this, we reengineer and experiment with JOnAS, an open‐source J2EE static server. Two management policies of the autonomic manager were stressed by a simulation of a worldwide ISP network. Copyright © 2006 John Wiley & Sons, Ltd.
Benchmarking the iPSC/2 hypercube multiprocessor
Authors: Bomans Luc , Roose Dirk
Published: November 2006

In this paper the performance of the Intel iPSC/2 hypercube multiprocessor is analyzed. Computation and communication performance for a number of benchmarks are presented. We derive some fundamental performance parameters of the machine. Further, we investigate the difference between several communication schemes. Using the results of our measurements we can highlight some features and peculiarities in the iPSC/2 hardware and software. Where possible we make a comparison with the iPSC/1 and Ncube hypercubes.
The performance of a distributed combat simulation with the time warp operating system
Authors: Wieland Frederick , Hawley Lawrence , Feinberg Abe , Loreto Mike Di , Blume Leo , Ruffles Joseph , Reiher Peter , Beckman Brian , Hontalas Philip , Bellenot Steven , Jefferson David
Published: November 2006

This paper analyzes the performance of a discrete‐event combat simulation executed on a parallel processor under control of the Time Warp Operating System. Time Warp is in a class of distributed simulation methods called Optimistic methods which have proven to be useful over a wide range of simulations. The combat simulation used for this performance study, called STB88, is a division‐corps model incorporating a number of different types of computations. The speed‐up for three versions of this model on the Caltech/JPL Mark III Hypercube and the BBN Butterfly parallel processors was measured relative to an efficient sequential execution of the same model on the same hardware. The results indicate that STB88 version 1 achieves a speed‐up of 28.6 on 60 Mark III processors, while STB88 version 2 achieves a speed‐up of 36.8 on 100 Butterfly processors. Version 3 of STB88 achieved a speed‐up of 38.5 on 128 Mark III processors. The versions differed only in their interface to Time Warp. On the Butterfly, the sequential execution completed in 2 hours, while the 100 processor execution completed in 3.2 minutes.
Translating from PARLOG to occam2: A methodology
Authors: Scott Robert B. , Trehan Rajiv
Published: November 2006

We describe a novel methodology for translating some PARLOG programs to occam2. Our methodology directs the translation based on a process level description generated from the PARLOG program. The translation of several example PARLOG programs is included. These examples feature: dynamic creation of processes; the one‐to‐many communication capabilities of PARLOG; and use of unbounded, asynchronous communication. The examples are then used to consider the translation of a previously developed programming application from the field of Artificial Intelligence, namely a PARLOGchart parser.

We see two main interests in such a methodology: firstly, as a means of obtaining high‐performance execution of PARLOG programs–PARLOG programs translated to occam2 can be executed on the high‐performance Transputer device; secondly, PARLOG may have a use as a declarative specification language for the development of occam2 programs.
What price regularity?
Authors: Prior Dominic M. N. , Norman Michael G. , Radcliffe Nicholas J. , Clarke Lyndon J.
Published: November 2006

We review various properties of irregular graphs and suggest that they may provide useful maps for connecting processors together in distributed‐memory MIMD machines. In particular, for many applications the performance of a system in an irregular configuration can be expected to exceed by far that of systems in standard configurations such as hypercubes and tori, which are poor over many performance measures. Techniques are discussed which allow the construction of near‐optimal or optimal graphs with respect to various measures of goodness, including diameter, mean interprocessor distance and worst through‐routing load. We conclude that where regularity is not important, irregular graphs will almost always outperform standard, regular ones.
Declarative languages and program transformation for programming parallel systems: A case study
Authors: Darlington John , Reeve Mike , Wright Sue
Published: November 2006

There are many problems associated with current methodologies employed for the development and maintenance of efficient computer systems. This has lead to an interest in both declarative programming languages and parallel computer architectures. These two areas can be combined to produce effective systems by the use of new program development philosophies. In particular, the mathematical basis and inherent parallelism of declarative languages enable formal techniques to be adopted for the development of programs tailored towards parallel machines. This paper provides an overview of one such methodology developed at Imperial College (IC) and presents a case study that illustrates its operation, using the IC Programming/Transformation Environment, and quantifies its benefits using performance prediction equations together with the results of experiments carried out on the ALICE parallel machine.
Exception handling for a communicating‐sequential‐processes‐based extension of C++
Authors: Adamo Jean‐Marc
Published: November 2006

An exception handling system for a language defined as a CSP/OCCAM‐based extension of C++ is presented. This language is part of a project we are developing which aims at constructing a high level programming environment for transputer‐based multiprocessors. In this proposal, the replacement model of Yemini and Berry (1985) is considered, parallelism and exception handling are closely combined, making process pre‐emption available but raising problems of atomicity and non‐determinism. These problems are discussed, a solution is suggested and an efficient implementation we have carried out is presented.
Implementation of Apply on a transputer array
Authors: Wang Han , Dew Peter M. , Webb Jon A.
Published: November 2006

Apply is a machine‐independent, low‐level image processing language for expressing local window operations. It has two main advantages: (1) it significantly reduces the programming effort, and (2) it can be mapped onto a wide range of parallel computers. In this paper we report our recent experience on implementing Apply on a Meiko Computing Surface (transputer array machine) using a farmer/gather model. The performance of the Meiko implementation on a number of edge detection algorithms including the popular Canny operator is analysed. Results suggest that the performance of Apply generated code represents peak performance and it is likely to be as efficient as hand‐written code.
Execution time support for adaptive scientific algorithms on distributed memory machines
Authors: Berryman Harry , Saltz Joel , Scroggs Jeffrey
Published: November 2006

We consider optimizations that are required for efficient execution of code segments that consist of loops over distributed data structures. The PARTI execution time primitives are designed to perform these optimizations and can be used to Implement a wide range of scientific algorithms on distributed memory machines.

These primitives allow the user to control array mappings in a way that gives an appearance of shared memory. Computations can be based on a global index set. Primitives are used to perform gather and scatter operations on distributed arrays. Communications patterns are derived at run time, and the appropriate send and receive messages are automatically generated.
The parallel computation of eigenvalues and eigenvectors of large Hermitian matrices using the AMT DAP 510
Authors: Weston J. S. , Clint M. , Bleakney C. W.
Published: November 2006

The solution of the algebraic eigenvalue problem is an important component of many applications in science and engineering. With the advent of novel architecture machines, much research effort is now being expended in the search for parallel algorithms for the computation of eigensystems which can gainfully exploit the processing power which these machines provide. Among important recent work References 1‐4 address the real symmetric eigenproblem in both its dense and sparse forms, Reference 5 treats the unsymmetric eigenproblem, and Reference 6 investigates the solution of the generalized eigenproblem. In this paper two algorithms for the parallel computation of the eigensolution of Hermitian matrices on an array processor are presented. These algorithms are based on the Parallel Orthogonal Transformation algorithm (POT) for the solution of real symmetric matrices[7,8]. POT was developed to exploit the SIMD parallelism supported by array processors such as the AMT DAP 510. The new algorithms use the highly efficient implementation strategies devised for use in POT. The implementations of the algorithms permit the computation of the eigensolution of matrices whose order exceeds the mesh size of the array processor used. A comparison of the efficiency of the two algorithms for the solution of a variety of matrices is given.
A network multi‐processor for experiments in parallelism
Authors: Marsland T. A. , Breitkreutz T. , Sutphen S.
Published: November 2006

Although both shared memory and loosely coupled parallel computing systems are now common, many still do not offer an easy way to design, implement, and test parallel algorithms. Our system provides software tools that make possible a variety of connection structures between processes. These structures are said to form a 'Network Multi‐Processor', which is implemented on a local area network of heterogeneous UNIX‐based timesharing computers, plus a set of processor boards dedicated to an application so that accurate timing measurements can be made. We explain how these tools have been used both to aid parallel algorithm development and to explore the properties of different computer interconnection methods.
Evaluating the basic performance of the Intel iPSC/860 parallel computer
Authors: Berrendorf Rudolf , Helin Jukka
Published: November 2006

We evaluate the basic performance of the Intel iPSC/860 computer, which can have up to 128 Intel i860‐based nodes connected together with a hypercube network topology. After giving a brief overview of the system, the properties and bottlenecks of the hardware architecture and software environment are discussed. Basic memory, scalar and vector performance of a single node is evaluated, and the communication performance and the overlap of computation and communication are analysed.
The MPE toolkit for supporting distributed applications
Authors: Barak Amnon , Guday Shai , Laor Roy
Published: November 2006

This paper presents a toolkit for supporting the execution of coarse‐grain, parallel (distributed) applications under the MOSIX multicomputer operating system. These tools use standard UNIX System V process control and message‐passing facilities, as well as the dynamic process migration mechanisms of MOSIX. The MPE tools can be used to modify sequential applications that were originally written for execution in a uniprocessor environment, to run efficiently in a distributed environment, consisting of several loosely coupled independent computers that communicate by messages. After presenting the MPE tools, the paper gives examples of several sequential algorithms that have been modified for execution in such a distributed multicomputer, as well as the resulting execution speed‐ups that were obtained.
An experiment in concurrent software evaluation
Authors: Perrott R. H. , Ramasubbu A.
Published: November 2006

This paper considers a method for evaluating the concurrent programming language available on a multiprocessor system – in particular, a shared‐memory multiprocessor system. The method is based on the consideration of well‐known algorithms which have been used as a means of demonstrating the expressive power of new concurrent language constructs. The algorithms considered are the Readers and Writers Problem and the Drinking Philosophers Problem. Both algorithms are coded using features that are widely regarded as being state‐of‐the‐art for shared‐memory systems and are then recoded in the language available on an actual multiprocessor system in order to carry out a comparison and evaluation. Several observations and conclusions are drawn.
Allocating data to multicomputer nodes by physical optimization algorithms for loosely synchronous computations
Authors: Mansour Nashat , Fox Geoffrey C.
Published: November 2006

Three optimization methods derived from natural sciences are considered for allocating data to multicomputer nodes. These are simulated annealing, genetic algorithms and neural networks. A number of design choices and the addition of preprocessing and postprocessing steps lead to versions of the algorithms which differ in solution qualities and execution times. In this paper the performances of these versions are critically evaluated and compared for test cases with different features. The performance criteria are solution quality, execution time, robustness, bias and parallelizability. Experimental results show that the physical algorithms produce better solutions than those of recursive bisection methods and that they have diverse properties. Hence, different algorithms would be suitable for different applications. For example, the annealing and genetic algorithms produce better solutions and do not show a bias towards particular problem structures, but they are slower than the neural network algorithms. Preprocessing graph contraction is one of the additional steps suggested for the physical methods. It produces a significant reduction in execution time, which is necessary for their applicability to large problems.
Porting a dusty deck Fortran program to a shared‐memory multiprocessor
Authors: Beavis Andy , Phillips Chris
Published: November 2006

We describe an attempt to improve the performance of a sequential Fortran code on a shared memory multiprocessor. The only parallelism employed is that provided by a set of parallel BLAS. The code is modified to make maximum use of the BLAS and, in particular, to use an appropriate LAPACK routine. Comparisons are made with automatically generated parallel code.
Parallel language developments in Europe: An overview
Authors: Perrott R. H.
Published: November 2006

This article is concerned with the topic of parallel programming language design and implementation, with particular emphasis on the developments which are, and have been, taking place in Europe. Consideration is given to specific approaches to parallel programming with illustrative examples taken from projects which have been carried out in Europe. The paper is based on a report prepared for the European Commission during 1990.
Parallel distributed seismic migration
Authors: Almasi G. S. , Hale D. , McLuckie T. , Bell J. , Gordon A.
Published: November 2006

We report significant speed‐up for seismic migration running in parallel on networkconnected IBM RISC/6000 workstations, A sustained performance of 15 MFLOP is obtained on a single‐entry‐level model 320, and speed‐ups as high as 5 are obtained for six workstations connected by Ethernet or token ring. Our parallel software uses remote procedure calls provided by NCS (Network Computing System). We have run over a dozen workstations in parallel, but speed‐ups become limited by network data rate. Fiber‐optic communication should allow much greater speed‐ups, and we describe our preliminary results with the fiberoptic serial link adapter of the RISC/6000. We also present a simple theoretical model that agrees well with our measurements and allows speed‐up to be predicted from a knowledge of the ratio of computation to communication, which can be determined empirically before the program is parallellzed. We conclude with a brief discussion of alternative software approaches and programming models for network‐connected parallel systems. In particular, our program was recently ported to PVM and Linda, and preliminary measurements yield speed‐ups very close to those described here.
Experience with multi‐transputer Ada
Authors: Bishop Judy M. , Thomas Ken S.
Published: November 2006

The transputer is one of the most cost‐effective multicomputer components to buy, but still one of the hardest to program. Even if the parts of a program that are destined for individual transputers are programmed in a familiar high‐level language (Ada or Fortran or C), users are forced to be aware of occam when connecting transputers together with harnesses. Moreover, the design of parallel and distributed algorithms is in itself a challenging field. This paper describes experience with using the Alsys Ada compiler on single and multiple transputer configurations, and considers whether Ada makes it any easier to gain access to the power of multi‐transputers. Early performance figures indicate that Ada running on transputer arrays compares favourably with the speed of other languages. An assessment of the impact of the proposed Ada 9X support for distribution is made.
Kernel‐Kernel communication in a shared‐memory multiprocessor
Authors: Chaves Eliseu M. , Das Prakash Ch. , Leblanc Thomas J. , Marsh Brian D. , Scott Michael L.
Published: November 2006

In the standard kernel organization on a bus‐based multiprocessor, all processors share the code and data of the operating system; explicit synchronization is used to control access to kernel data structures. Distributed‐memory multicomputers use an alternative approach, in which each instance of the kernel performs local operations directly and uses remote invocation to perform remote operations. Either approach to interkernel communication can be used in a large‐scale shared‐memory multiprocessor.

In the paper we discuss the issues and architectural features that must be considered when choosing between remote memory access and remote invocation. We focus in particular on experience with the Psyche multiprocessor operating system on the BBN Butterfly Plus. We find that the Butterfly architecture is biased towards the use of remote invocation for kernel operations that perform a significant number of memory references, and that current architectural trends are likely to increase this bias in future machines. This conclusion suggests that straightforward parallelization of existing kernels (e.g. by using semaphores to protect shared data) is unlikely in the future to yield acceptable performance. We note, however, that remote memory access is useful for small, frequently‐executed operations, and is likely to remain so.
Levels of atomic action in the Flagship parallel system
Authors: Mayes K. R. , Keane J. A.
Published: November 2006

The Flagship system is a graph reduction machine having a distributed physical architecture. Although Flagship sits firmly in the declarative world, explicit state is supported to express the behaviour of the operating system. This state not only has to be isolated from the declarative aspects of the Flagship machine, but also has to be supported with respect to distribution. The mechanisms provided for maintaining consistency of state are discussed with respect to atomic actions at levels in the Flagship system. This approach is used to demonstrate how the software environment was supported by the basic execution mechanism of the machine. The nature, construction and creation of system software components are described and the structure of the system software is discussed with particular reference to optimising access to distributed resources.
Region‐to‐region visibility analysis using data parallel machines
Authors: Teng Y. Ansel , Dementhon Daniel , Davis Larry S.
Published: November 2006

We propose an algorithm for solving region‐to‐region visibility problems on digital terrain models using data parallel machines. Since global communication is the bottleneck in this kind of algorithm, the algorithm we propose focuses on the reduction of global communication. The algorithm analyses a strip of the source region at a time and sweeps through the source strip by strip. At most four sweeps are needed for the analysis. By exploring the coherence properties in the processor structure, global communication is minimized and complexity is substantially improved. Furthermore, all global write operations are exclusive and concurrency in global read operations is minimized. Since the problem size is usually large, we also designed rules of decomposition to efficiently handle the cases where the required number of processors is greater than available. The algorithm has been implemented on a Connection Machine CM‐2, and results of computational experiments are presented.
Pyramid mappings onto hypercubes for computer vision: Connection machine comparative study
Authors: Ziavras Sotirios G. , Siddiqui Muhammad A.
Published: November 2006

The paper presents a comparative analysis for algorithms that map pyramids onto hypercubes. The analysis is based on some important performance measures from graph theory and actual results from a Connection Machine system CM‐2 containing 16K processors. Connection Machine results are presented for pyramid algorithms that compute the perimeter of objects, apply 2‐dimensional convolution, and segment images.
Macromolecular electron density averaging on distributed memory MIMD systems
Authors: Marinescu Dan C. , Rice John R. , Cornea‐Hasegan Marius A. , Lynch Robert E. , Rossmann Michael G.
Published: November 2006

The paper discusses algorithms and programs for electron density averaging using a distributed memory MIMD system. Electron density averaging is a computationally intensive step needed for phase refinement and extension in the computation of the 3‐D structure of macromolecules like proteins and viruses. The determination of a single structure may require thousands of hours of CPU time for traditional supercomputers. The approach discussed in this paper leads to a reduction by one to two orders of magnitude of the computing time. The program runs on an Intel iPSC/860 and on the Touchstone Delta system and uses a user controlled shared virtual memory and a dynamic load‐balancing mechanism.
Dependence analysis for outer loop parallelization of existing Fortran‐77 programs
Authors: Stein Josef , Fox Geoffrey C.
Published: November 2006

We have used six static parallelization tools on four Fortran‐77 programs used in physics simulations. We indicate areas where current tools have difficulties in recognizing parallelism, and illustrate these issues with simple examples. We suggest that a dynamic dependency analysis tool is needed to aid the user in the parallelization of dusty decks.
Experiments with Program unification on the Cray Y‐MP
Authors: Chuang Ling‐Yu , Rego Vernon , Mathur Aditya
Published: November 2006

Program unification is a technique for source‐to‐source transformation of code for enhanced execution performance on vector and SIMD architectures. This work focuses on simple examples of program unification to explain the methodology and demonstrate its promise as a practical technique for improved performance. Using simple examples to explain how unification is done, we outline two experiments in the simulation domain that benefit from unification, namely Monte Carlo and discrete‐event simulation. Empirical tests of unified code on a Cray Y‐MP multiprocessor show that unification improves execution performance by a factor of roughly 8 for given application. The technique is general in that it can be applied to computation‐intensive programs in various data‐parallel application domains.
A parallel block row‐action method for solving large sparse linear systems on distributed memory multiprocessors
Authors: D'apuzzo Marco , De Rosa Maria Assunta
Published: November 2006

Recently developed block‐iterative versions of some row‐action algorithms for solving general systems of sparse linear equations allow parallelism in the computations when the underlying problem is appropriately decomposed. However, problems associated with the parallel implementation of these algorithms have to be addressed.

In this paper we present an implementation on distributed memory multiprocessors of a block version of the Kaczmarz row‐action method. One of the main issues related to the efficient implementation of this method on a concurrent environment is to develop suitable communication schemes in order to reduce the amount of communication needed at each iteration.

We propose two data distribution strategies which lead to different computation and communication schemes.

To verify and compare the effectiveness of the proposed strategies, numerical experiments have been carried out on a Symult S2010 and a Meiko Computing Surface. The performance evaluation has been done using a scaled efficiency model.
Allocating data to distributed‐memory multiprocessors by genetic algorithms
Authors: Mansour Nashat , Fox Geoffrey C.
Published: November 2006

We present three genetic algorithms (GAs) for allocating irregular data sets to multiprocessors. These are a sequential hybrid GA, a coarse‐grain GA and a fine‐grain GA. The last two are based on models of natural evolution that are suitable for parallel implementation; they have been implemented on a hypercube and a Connection Machine. Experimental results show that the three GAs evolve good suboptimal solutions which are better than those produced by other methods. The GAs are also robust and do not show a bias towards particular problem configurations. The two parallel GAs have reasonable execution times, with the coarse‐grain GA producing better solutions for the allocation of loosely synchronous computations.
Dynamo ‐ a portable tool for dynamic load balancing on distributed memory multicomputers
Authors: Tarnvik Erik
Published: November 2006

Dynamic load balancing is an important technique when developing applications with unpredictable load distribution on distributed memory multicomputers. A tool, Dynamo, that can be used to utilize dynamic load balancing is presented. This tool separates the application from the load balancer and thus makes it possible to easily exchange the load balancer of a given application and experiment with different load balancing strategies. A prototype of Dynamo has been implemented in the C language on an Intel iPSC/2 Hypercube. Dynamo is demonstrated by two example programs. The first program solves the N queen problem using a backtracking algorithm and the second solves a 0‐1 knapsack problem using a depth‐first branch and bound algorithm.
A clock synchronization algorithm for the performance analysis of multicomputer systems
Authors: De Pietro Giuseppe , Villano Umberto
Published: November 2006

The paper deals with the implementation of global time in multicomputer systems. After a formalization of the synchronization problem, techniques to estimate the synchronization delay and to compensate the drift error are proposed. Then SYNC_WAVE, a clock synchronization algorithm where the values of a reference clock are diffused in a wave‐like manner, is described. SYNC_WAVE has no provision for fault‐tolerance and is specially designed to introduce low CPU and communication overhead, in order to support performance analysis applications efficiently. An implementation of the devised algorithm in a transputer‐based system is presented, showing the accuracy results obtained. Finally SYNC_WAVE is compared to other synchronization algorithms and several of its possible applications are suggested.
Experiences with networked parallel computing
Authors: Hoogerbrugge Peter , Mirchandaney Ravi
Published: November 2006

The performance and proliferation of workstations continues to increase at a rapid rate. However, the practical utilization of workstation networks for parallel computing is still in its infancy. This is due to the relative immaturity of programming tools, low bandwidth networks such as Ethernet, and high message latencies. However, programming tools are becoming more mature and network bandwidths are increasing rapidly. Hence, networks of commodity workstations may prove to be practical for certain classes of parallel applications.

This paper describes our experiences with two applications parallelized on a network of Sun workstations. The first application is from Shell's petroleum engineering department. This program quantitatively derives rock and porefill composition from well‐log data, using a compute‐intensive iterative optimization procedure. The second application is time filtering, which is a fundamental operation performed on seismic traces.

Through our experiments we identify the limits of networked parallel computing based on the current state of network technology. We also provide a discussion on the possible impact of future high speed networks on networked parallel computing.
Pipeline optimizations of the prime factor algorithm
Authors: Albrizio R. , Mazzone A. , Veneziani N. , Messina P. , Aloisio G. , Bochicchio M.
Published: November 2006

The prime factor algorithm (PFA) is an efficient discrete Fourier transform (DFT) computation algorithm used when the sequence length can be decomposed into mutually prime factors. Following our previous results on PFA decomposition carried out at Caltech on hypercube machines, we present in the paper a pipeline PFA implementation suitable for multiprocessor systems with distributed memory. This implementation achieves high values of efficiency and speed‐up when processing multiple sequences of data. The paper shows how an optimized structure can be obtained when the concurrency among computation and communications is exploited at each node of the pipe. Experimental results obtained on transputer‐based structures and on the IntelTouchstoneDelta system are also reported.
Evaluation of parallelization strategies for an incremental Delaunay triangulator in e3
Authors: Cignoni P. , Laforenza D. , Perego R. , Scopigno R. , Montani C.
Published: November 2006

The paper deals with the parallelization of Delaunay triangulation, a widely used space partitioning technique. Two parallel implementations of a three‐dimensional incremental construction algorithm are presented. The first is based on the decomposition of the spatial domain, while the second relies on the master‐slaves approach. Both parallelization strategies are evaluated, stressing practical issues rather than theoretical complexity. We report on the exploitation of two different parallel environments: a tightly coupled distributed memory MIMD architecture and a network of workstations co‐operating under the Linda environment Then, a third hybrid solution is proposed, specifically addressed to the exploitation of higher parallelism. It combines the other two solutions by grouping the processing nodes of the multicomputer into clusters and by exploiting parallelism at two different levels.
Computational similarity
Authors: Hockney Roger W.
Published: November 2006

The paper enunciates the principle of computational similarity, whereby calculations with the same values for certain dimensionless ratios are said to be ‘computationally similar’ and as a consequence have the same optimum self‐speed‐up and optimum number of processors. Based on a three‐parameter description of the computer hardware, two dimensionless ratios, which are only a function of the problem size and the hardware parameters, completely determine the scaling. Contours of constant self‐speed‐up can be drawn on a two‐dimensional dimensionless universal scaling diagram (DUSD). This diagram is for a particular class of timing expressions that can be shown to represent approximately the performance of a corresponding class of computer programs or benchmarks, but it applies to all computers describable by the three hardware parameters and to all problem sizes. Thus the dimensionless ratios play a similar role in the study of computer performance, as do the Reynolds and other dimensionless numbers in fluid dynamics. This dimensional analysis of computer performance is illustrated by the case of the FFT1 benchmark from the Southampton ‘Genesis’ distributed‐memory benchmarks.
PARADOX—a heterogeneous machine for the 3D vision algorithm
Authors: Wang Han , Brady Mike
Published: November 2006

We present in the paper a heterogeneous machine, PARADOX, designed in Oxford for real time image processing. PARADOX consists of a Datacube pipelined image processor, a configurable network of 32 T800 transputers, a Sun‐4 workstation and a special‐purpose interface connecting the Datacube to the transputer network. Its programming style is a mixture of MIMD paradigm employing a processor farm and interrupts to control the image processing pipeline in the Datacube via a VME bus. A number of vision algorithms including the Canny edge detector have been implemented on this machine at video rate. In particular, a 3D vision algorithm, Droid, has been implemented to provide navigation data for an autonomous guided vehicle.
Implementation of a fully balanced periodic tridiagonal solver on a parallel distributed memory architecture
Authors: Eidson T. M. , Erlebacher G.
Published: November 2006

While parallel computers offer significant computational performance, it is generally necessary to evaluate several programming strategies. Two programming strategies for a fairly common problem—a periodic tridiagonal solver—are developed and evaluated. Simple model calculations as well as timing results are presented to evaluate these strategies.

The particular tridiagonal solver evaluated is used in many computational fluid dynamic simulation codes. The feature that makes this algorithm unique is that these simulation codes usually require simultaneous solution for multiple right‐hand‐sides (RHS) of the system of equations. Each RHS solutions is independent and thus can be computed in parallel. Thus, a Gaussian‐elimination‐type algorithm can be used in a parallel computation and more complicated approaches such as cyclic reduction are not required.

The two strategies are a transpose strategy and a distributed solver strategy. For the transpose strategy, the data are moved so that a subset of all the RHS problems is solved on each of the several processors. This usually requires significant data movement between processor memories across a network. The second strategy attempts to have the algorithm follow the data across processor boundaries in a chained manner. This usually requires significantly less data movement. An approach to accomplish this second strategy in a near‐perfect load‐balanced manner is developed. In addition, an algorithm will be shown to directly transform a sequential Gaussian‐elimination‐type algorithm into the parallel, chained, load‐balanced algorithm.
Partitioning of unstructured meshes for load balancing
Authors: Martin Olivier C. , Otto Steve W.
Published: November 2006

Many large‐scale engineering and scientific calculations involve repeated updating of variables on an unstructured mesh. To do these types of computations on distributed memory parallel computers, it is necessary to partition the mesh among the processors so that the load balance is maximized and interprocessor communication time is minimized. This can be approximated by the problem of partitioning a graph so as to obtain a minimum cut, a well‐studied combinatorial optimization problem. Graph partitioning is NP complete, so for real world applications one resorts to heuristics, i.e. algorithms that give good but not necessarily optimum solutions. These algorithms include recursive spectral bisection, local search methods such as Kernighan‐Lin, and more general purpose methods such as simulated annealing. We show that a general procedure enables us to combine simulating annealing with Kernighan‐Lin. The resulting algorithm is both very fast and extremely effective.
Programming pipelined CAD applications on message‐passing architectures
Authors: Kenyon P. , Seth S. , Clematis A. , Agrawal P. , Dodero G. , Gianuzzi V.
Published: November 2006

Programming applications in computer‐aided design of VLSI are difficult on parallel architectures, especially pipelined implementations derived from their sequential counterparts by algorithmic partitioning. The difficulty is primarily due to lack of good program development environments and tools. Our solution, applicable to message‐passing architectures, is based upon a definition of a broad class of non‐linear pipeline configurations and an asynchronous data‐driven model for pipeline stage interactions. It provides object‐oriented definitions of stages and interconnecting channels. These objects are embedded in C++ so that the correctness of application programs can be tested on a workstation in a simulated environment. The simulation is instrumented to provide data useful in assessing relative computational loading and balancing of stages. Thus a large part of program development can take place in the environment of a workstation familiar to the programmer. A non‐trivial application is developed to illustrate these ideas.
Parallel solution of large‐scale differential‐algebraic systems
Authors: Maier R. S. , Rath W. , Petzold L. R.
Published: November 2006

DASPK solves large‐scale systems of differential‐algebraic equations. It is based on the integration method in DASSL, but instead of a direct method for the associated linear systems which arise at each time step, the preconditioned GMRES iteration is applied in combination with an inexact Newton method. Two parallel versions of DASPK have been developed: DASPKF90, a Fortran 90 data parallel implementation, and DASPKMP, a message‐passing implementation written in Fortran 77 with extended BLAS. The parallel versions have been implemented for the Thinking Machines Corporation (TMC) CM‐5, a massively parallel multiprocessor, keeping the user interface relatively simple while allowing for portability to other massively parallel architectures. The codes have been demonstrated on several large‐scale test problems, including three‐dimensional formulations of the heat equation, the Cahn‐Hilliard equation and a multi‐species reaction‐diffusion problem. The formulations are described, including detail on preconditioning the Krylov iteration, timing results and performance analysis.