bluuebunny/crossref_metadata_2025 huggingface dataset:
The Genesis distributed‐memory benchmarks. Part 1: Methodology and general relativity benchmark with results for the SUPRENUM computer
Authors: Addison Cliff , Allwright James , Binsted Norman , Bishop Nigel , Carpenter Bryan , Dalloz Peter , Gee David , Getov Vladimir , Hey Tony , Hockney Roger , Lemke Max , Merlin John , Pinches Mark , Scott Chris , Wolton Ivan
Published: November 2006

This is the first of a series of papers on the Genesis distributed‐memory benchmarks, which were developed under the European ESPRIT research program. The benchmarks provide a standard reference Fortran77 uniprocessor version, a distributed memory. MIMD version, and in some cases a Fortran90 version suitable for SIMD computers. The problems selected all have a scientific origin (mostly from physics or theoretical chemistry), and range from synthetic code fragments designed to measure the basic hardware properties of the computer (especially communication and synchronisation overheads), through commonly used library subroutines, to full application codes. This first paper defines the methodology to be used to analyse the benchmark results, and gives an example of a fully analysed application benchmark from General Relativity (GR1). First, suitable absolute performance metrics are carefully defined, then the performance analysis treats the execution time and absolute performance as functions of at least two variables, namely the problem size and the number of proecssors. The theoretical predictions are compared with, or fitted to, the measured results, and then used to predict (with due caution) how the performance might scale for larger problems and more processors than were actually available during the benchmarking. Benchmark measurements are given primarily for the German SUPRENUM computer, but also for the IBM 3083J, Convex C210 and a Parsys Supernode with 32 T800‐20 transputers.
An overview of manifold and its implementation
Authors: Arbab F. , Herman I. , Spilling P.
Published: November 2006

Management of the communications among a set of concurrent processes arises in many applications and is a central concern in parallel computing. In this paper we introduce MANIFOLD: a co‐ordination language whose sole purpose is to describe and manage complex interconnections among independent, concurrent processes. In the underlying paradigm of this language the primary concern is not with what functionality the individual processes in a parallel system provide. Instead, the emphasis is on how these processes are interconnected and how their interaction patterns change during the execution life of the system. This paper also includes an overview of our implementation of MANIFOLD.

As an example of the application of MANIFOLD, we present a series of small manifold programs which describe the skeletons of some adaptive recursive algorithms that are of particular interest in computer graphics. Our concern in this paper is to show the expressiveness of MANIFOLD, the feasibility of its implementation and its usefulness in practice. Issues regarding performance and optimization are beyond the scope of this paper.
Performance analysis of the CM‐2, a massively parallel SIMD computer
Authors: Helin Jukka
Published: November 2006

The performance evaluation process for a massively parallel distributed‐memory SIMD computer is described generally. The performance in basic computation, grid communication, and computation with grid communication is analysed. A practical performance evaluation and analysis study is done for the Connection Machine 2, and conclusions about its performance are drawn.
Performance comparison of dynamic policies for remote caching
Authors: Pu Calton , Florissi Danilo , Scares Patricia , Yu Philip S. , Wu Kun‐Luno
Published: November 2006

In a distributed system, data servers (file systems and databases) can easily become bottlenecks. We propose an approach to offloading data access requests from overloaded data servers to nodes that are Idle or less busy. This approach is referred to asremote caching, and the idle or less busy nodes are calledmutual serversas they help out the busy server nodes on data accesses. In addition to server and client local caches, frequently accessed data are cached in the main memory of mutual servers, thus improving the data access time in the system. We evaluate several data propagation strategics among data servers and mutual servers. These include policies in which senders are active/passive and receivers are active/passive in initiating data propagation. For example, an active sender takes the initiative to offload data onto a passive receiver. Simulation results show that the active‐sender/passive‐receiver policy is the method of choice In most cases. Active‐Sender policies are best able to exploit the main memory of other Idle nodes in the expected normal condition where some nodes are overloaded and others are less loaded. AH active policies perform far better than the policy without remote caching even in the degenerated case where each node is equally loaded.
Data‐parallel programming on a network of heterogeneous workstations
Authors: Nedeljkovlc Nenad , Quinn Michael J.
Published: November 2006

We describe a compiler and run‐time system that allow data‐parallel programs to execute on a network of heterogeneous UNIX workstations. The programming language supported is Dataparallel C, a SIMD language with virtual processors and a global name space. This parallel programming environment allows the user to take advantage of the power of multiple workstations without adding any message‐passing calls to the source program. Because the performance of Individual workstations in a multi‐user environment may change during the execution of a Dataparallel C program, the run‐time system automatically performs dynamic load balancing. We present experimental results that demonstrate the usefulness of dynamic load‐balancing In a multi‐user environment These results suggest that initially allocating the same amount of work to each processor and letting the dynamic load balancing algorithm adjust the load during program execution yields very good performance. Hence neither the compiler nor the run‐time system need a priori knowledge of the speeds of the machines that will participate in a program execution.
ADAPTIVE: A dynamically assembled protocol transformation, integration and evaluation environment
Authors: Schmidt Douglas C. , Box Donald F. , Suda Tatsuya
Published: November 2006

Computer communication systems must undergo significant changes to keep pace with the increasingly demanding and diverse multimedia applications that will run on the next generation of high‐performance networks. To facilitate these changes, we are developing A Dynamically Assembled Protocol Transformation, Integration and evaluation Environment (ADAPTIVE). ADAPTIVE provides an integrated environment for developing and experimenting with flexible transport system architectures that support lightweight and adaptive communication protocols for diverse multimedia applications running on high‐performance networks. Our approach employs a collection of reusable ‘building‐block’ protocol mechanisms that may be composed together automatically based upon functional specifications. The resulting protocols execute in parallel on several target platforms including shared‐memory and message‐passing multiprocessors. ADAPTIVE provides a framework for (1) determining the functionality of customized lightweight protocol configurations that efficiently support multimedia applications and (2) mapping this functionality onto efficient parallel process architectures.
No pain and gain!—experiences with Mentat on a biological application
Authors: Grimshaw Andrew S. , West Emily A. , Pearson William R.
Published: November 2006

Throughout much of the parallel processing community there is the sense that writing software for distributed‐memory parallel processors Is subject to a ‘no pain—no gain’ rule: that In order to reap the benefits of parallel computation one must first suffer the pain of converting the application to run on a parallel machine. We believe this Is the result of Inadequate programming tools and not a problem Inherent to parallel processing. We will show that one can parallelize real scientific applications and obtain good performance with little effort If the right tools are used. Our vehicle for this demonstration is a 6000‐line DNA and protein sequence comparison application that we have implemented in Mental, an object‐oriented parallel processing system for both parallel and distributed architectures. We briefly describe the application and present performance information for both the Mentat version and a hand‐coded parallel version of the application.
Experiences with SLALOM on the distributed Pleiades/ESP system
Authors: Wilson Unda F. , Gonzalez Mario J. , Cruess Michael W.
Published: November 2006

The paper describes experiences gained during the process of Implementing a standard serial benchmark (SLALOM) on a distributed computing system (Pleiades running ESP/C++). Based on a real problem In computer graphics, SLALOM Is a timed benchmark that Includes problem set‐up and I/O costs. The purpose of our experiments has been to maximize the speedup of a distributed implementation of SLALOM when compared to Its serial implementation. As a result of these experiments, we have developed several guidelines for adapting algorithms for distributed systems.
Radiative Heat Transfer Simulation on a SPARCStation Farm
Authors: Minnich Ronald G. , Pryor Daniel V.
Published: November 2006

At the Supcrcomputing Research Center we have built a computing farm consisting of 16 SPARCStation. ELCs. The ELCs all support the Mother distributed shared memory, which has primitives to support efficient synchronization and use of the network and processors. Mother docs not support the traditional consistency semantics provided by, for example, Ivy or Mach external pagers.

The first parallel application we ran on the farm was a Monte Carlo radiative heat transfer simulation. The performance we achieved on the farm was within an order of magnitude of the performance we would expect to achieve on a 16‐processor model of the C90 supercomputer available from Cray Research.

With this application we found that the use of the Mother distributed shared memory allowed us to run the same code on the Cray as we ran on the SPARCStatlons, and we did not require the complex cache‐coherent memory semantics provided by, say, Ivy or Mach to run this application effectively.
Lattice Boltzmann method on a cluster of IBM RISC system/6000 workstations
Authors: Betello G. , Richelu G. , Succi S. , Ruello F.
Published: November 2006

An implementation of the lattice Boltzmann method on a homogeneous cluster of IBM RISC System/6000 superscalar workstations is presented.
Restructuring Fortran programs for Cedar
Authors: Eigenmann Rudolf , Hoeflinger Jay , Jaxon Greg , Li Zhiyuan , Padua David
Published: November 2006

The paper reports on the status of the Fortran translator for the Cedar computer at the end of March 1991. A brief description of the Cedar Fortran language is followed by a discussion of the Fortran‐77 to Cedar Fortran parallelizer that describes the techniques currently being implemented. A collection of experiments illustrate the effectiveness of the current implementation, and point toward new approaches to be incorporated into the system in the near future.
Engineering a data dependence test
Authors: Wolfe Michael
Published: November 2006

Many papers have been written dealing with the science of data dependence tests, particularly for dependence of arrays in loops; the techniques typically reduce the dependence problem to an algebraic problem, then solve the algebraic problem by an algorithm which has some desired blend of efficiency, generality or precision. While a sound theoretical basis is necessary for dependence‐based tools, these papers often leave out many implementation details. This paper addresses the engineering aspects of data dependence testing, particularly focusing on details that are necessary in any competent implementation of a data dependence test.
Massive MIMD neural network simulations: The connections dilemma
Authors: Tollenaere Tom , Saraiva J. Miguel , Van Hulle Marc M.
Published: November 2006

We present two strategies for the simulation of massive neural networks on message‐passing MIMD machines. In the first strategy all interconnections between neurons are stored explicitly in interconnection matrices. During simulation, every processor is responsible for certain submatrices of these interconnection matrices. The fact that message‐passing MIMD processors do not provide virtual memory seriously limits the size of the networks that can be simulated, since interconnection matrices require huge amounts of memory.

An alternative strategy is not to store the connections explicitly, but generate the interconnections as they are needed. This circumvents memory limitations, but because interconnections need to be generated multiple times, it is inherently slower than the first implementation.

This yields the connections dilemma: the choice between fast simulation of small networks as against slower simulation of massive networks.

We present, analyze and bench‐mark parallel implementations for both strategies. An efficient connection‐look‐up algorithm, which can be used for any network with static interconnections, ensures that simulation times for the second strategy are only marginally longer than for the first strategy. We show that for our users the connections dilemma is no longer a dilemma: by means of our look‐up algorithm the simulation of massive networks becomes possible; furthermore the time to design and construct a network, prior to simulation, is considerably shorter than it is for the matrix version, and in addition this time is independent of network size.

Although we have implemented both strategies on a parallel computer, the algorithms presented here can be used on any machine with memory limitations, such as personal computers.
Comparison of parallel Fortran environments on the AMT DAP510 for a linear algebra application
Authors: Clint M. , Bleakney C. W. , Weston J. S.
Published: November 2006

In the paper three distinct approaches to the implementation of an application in linear algebra on the AMT DAP 510 using the Fortran‐Plus Enhanced language and compiler are investigated. In the first the implementation is tailored to fit a virtual array processor whose edge size corresponds to that of the maximum dimension of matrix used in the application. The second approach is a special case of the first, and corresponds to a situation in which the virtual array processor is constrained to have the same dimensions as the AMT DAP 510. The third approach may be considered to be a hybrid approach. In this case an implementation of the application is constructed which incorporates the most efficient features of the first two. Finally, comparisons of the performances of the three implementations, all of which were compiled using the Fortran‐Plus Enhanced compiler, are presented.
Data management for a class of iterative computations on distributed‐memory MIMD systems
Authors: Cornea‐Hasegan M. C. , Marinescu Dan C. , Zhang Zhongyun
Published: November 2006

The paper discusses data management techniques for mapping a large data space onto the memory hierarchy of a distributed memory MIMD system. Experimental results for structural biology computations using the Molecular Replacement Method are presented.
Object‐based approach to programming distributed systems
Authors: Tanenbaum A. S. , Bal H. E. , Ben Hassen S. , Kaashoek M. Frans
Published: November 2006

Two kinds of parallel computers exist: those with shared memory and those without. The former are difficult to build but easy to program. The latter are easy to build but difficult to program. In this paper we present a hybrid model that combines the best properties of each by simulating a restricted object‐based shared memory on machines that do not share physical memory. In this model, objects can be replicated on multiple machines. An operation that does not change an object can then be done locally, without any network traffic. Update operations can be done using the reliable broadcast protocol described in the paper. We have constructed a prototype system, designed and implemented a new programming language for it, and programmed various applications using it. The model, algorithms, language, applications and performance will be discussed.
Communication system for high‐performance distributed computing
Authors: Hariri S. , Park J.‐B. , Parashar M. , Fox G. C.
Published: November 2006

With the current advances in computer and networking technology coupled with the availability of software tools for parallel and distributed computing, there has been increased interest in high‐performance distributed computing (HPDC). We envision that HPDC environments with supercomputing capabilities will be available in the near future. However, a number of issues have to be resolved before future network‐based applications can fully exploit the potential of the HPDC environment. In the paper we present an architecture for a high‐speed local area network and a communication system that provides HPDC applications with high bandwidth and low latency. We also characterize the message‐passing primitives required in HPDC applications and develop a communication protocol that implements these primitives efficiently.
Using Schooner to support distribution and heterogeneity in the Numerical Propulsion System Simulation project
Authors: Homer P. T. , Schlichting R. D.
Published: November 2006

The Numerical Propulsion System Simulation (NPSS) project has been initiated by NASA to explore the use of computer simulation in the development of new aircraft propulsion technology. With this approach, each engine component is modeled by a separate computational code, with a simulation executive connecting the codes and modeling component interactions. Since each code potentially executes on a different machine in a network, a simulation run is a heterogeneous distributed program in which diverse software and hardware elements are incorporated into a single computation. In the paper a prototype simulation executive that supports this type of programming is described. The two components of this executive are the AVS scientific visualization system and the Schooner heterogeneous remote procedure call (RPC) facility. In addition, the match between Schooner's capabilities and the needs of NPSS is evaluated based on our experience with a collection of test codes. The basic conclusion is that, while Schooner fared well in general, it exhibited certain deficiencies that dictated changes in its design and implementation. This discussion not only documents the evolution of Schooner, but also serves to highlight the practical problems that can be encountered when dealing with heterogeneity and distribution in such applications.
Configuration management in the Nexus distributed operating system
Authors: Tripathi A. , Karnik N. M. , Koneru S. P. , Nock C. , Tewari R. , Day K. , Noonan T.
Published: November 2006

The paper describes the approach taken for configuration management in the Nexus distributed operating system. Nexus uses kernel‐level support for monitoring the failure or termination status of distributed components of an application. Periodic user‐level messages are not required for status monitoring. Group and dependency relationships between such components can be defined by the programmer for the purpose of configuration monitoring and management. An object belonging to a distributed application can be monitored by its host kernel for system‐defined exception conditions. When any of these conditions arise, other objects are notified through signals or messages, as specified by the programmer.
Parallel transport subsystem implementation for high‐performance communication
Authors: Braun T. , Schmidt C.
Published: November 2006

Requirements of emerging applications together with rapid changes in networking technology towards gigabit speeds require new adequate transport systems. Integrated designs of transport services, protocol architecture and implementation platforms are required by forthcoming applications in high‐speed network environments. The transport subsystem PATROCLOS (parallel transport subsystem for cel/ based high‐speed networks) is designed with special emphasis on a high degree of inherent parallelism to allow efficient implementations on multiprocessor architectures combined with specialized hardware for very time critical functions. The paper presents the new parallel protocol architecture of PATROCLOS, an appropriate implementation architecture based on transputer networks, and performance evaluation results, which indicate high throughput values.
Pumma: Parallel universal matrix multiplication algorithms on distributed memory concurrent computers
Authors: Choi Jaeyoung , Walker David W. , Dongarra Jack J.
Published: November 2006

The paper describes Parallel Universal Matrix Multiplication Algorithms (PUMMA) on distributed memory concurrent computers. The PUMMA package includes not only the non‐transposed matrix multiplication routine C = A ⋅ B, but also transposed multiplication routines C = AT ⋅ B, C = A ⋅ BT, and C = AT ⋅ BT, for a block cyclic data distribution. The routines perform efficiently for a wide range of processor configurations and block sizes. The PUMMA together provide the same functionality as the Level 3 BLAS routine xGEMM. Details of the parallel implementation of the routines are given, and results are presented for runs on the Intel Touchstone Delta computer.
Partitioning and mapping in embedded multiprocessor architectures in the presence of constraints
Authors: Yalamanchili S. , Winkel L. Te , Perschbacher D. , Shenoy B.
Published: November 2006

The paper focuses on the problem of partitioning and mapping parallel programs onto heterogeneous embedded multiprocessor architectures for real‐time applications. Such applications present unique constraints and challenges. In addition to heterogeneity, the proposed partitioning and mapping algorithms satisfy memory, task throughput, task placement, intertask communication bandwidth, and co‐location constraints. They do so for architectures that utilize circuit‐switched (rather than packet‐switched) interprocessor communication and optimize latency and throughput in addition to load‐balancing. Finally, these mapping algorithms make use of knowledge of the local scheduling discipline to accommodate real‐time scheduling constraints. Our focus is on unstructured parallel programs that fall into one of two classes: (i) the class of computations characteristic of control applications in a real‐time environment where tasks execute concurrently, periodically exchanging information, and (ii) pipelined computation graphs found in sensor data processing applications. The algorithms are implemented in a set of tools that operate with commercial CASE tools at one end, and present an interface to multiprocessor simulators at the other end. Collectively, the algorithms form a significant component of an interactive design environment for the development and mapping of real‐time embedded parallel programs. The paper describes the algorithms, the encapsulating toolset, and presents an example of their application to an existing embedded application—an Autonomous Underwater Vehicle application.
Partitioning tasks between a pair of interconnected heterogeneous processors: A case study
Authors: Lilja David J.
Published: November 2006

With the variety of computer architectures available today, it is often difficult to determine which particular type of architecture will provide the best performance on a given application program. In fact, one type of architecture may be well suited to executing one section of a program while another architecture may be better suited to executing another section of the same program. One potentially promising approach for exploiting the best features of different computer architectures is to partition an application program to simultaneously execute on two or more types of machines interconnected with a high‐speed communication network. A fundamental difficulty with this heterogeneous computing, however, is the problem of determining how to partition the application program across the interconnected machines. The goal of this paper is to show how a programmer or a compiler can use a model of a heterogeneous system to determine the machine on which each subtask should be executed. This technique is illustrated with a simple model that relates the relative performance of two heterogeneous machines to the communication time required to transfer partial results across their interconnection network. Experiments with a Connection Machine CM‐200 demonstrate how to apply this model to partition two different application programs across the sequential front‐end processor and the parallel back‐end array.
P3L: A structured high‐level parallel language, and its structured support
Authors: Bacci Bruno , Danelutto Marco , Orlando Salvatore , Pelagatti Susanna , Vanneschi Marco
Published: November 2006

The paper presents a parallel programming methodology that ensures easy programming, efficiency and portability of programs to different machines belonging to the class of the general‐purpose, distributed‐memory, MIMD architectures. The methodology is based on the definition of a new, high‐level, explicitly parallel language, called P3L, and of a set of static tools that automatically adapt the program features for each target architecture.

P3L does not require programmers to specify process activations, the actual parallelism degree, scheduling, or interprocess communications, i.e. all those features that need to be adjusted to harness each specific target machine. Parallelism is, on the other hand, expressed in a structured and qualitative way, by hierarchical composition of a restricted set of language constructs, corresponding to those forms of parallelism that are frequently encountered in parallel applications, and that can be efficiently implemented.

The efficient portability of P3L applications is guaranteed by the compiler along with the novel structure of the support. The compiler automatically adapts the program features for each specific architecture, using the costs (in terms of performance) of the low‐level mechanisms exported by the architecture itself. In our methodology, these costs, along with other features of the architecture, are viewed through an abstract machine, whose interface is used by the compiler to produce the final object code.
Distributed implementations of communicating objects
Authors: Jia Weijia , Libert Gaetan
Published: November 2006

The paper presents the design and implementation of a CSP‐based object‐oriented system. The system consists of a specification model, Communicating‐object, and a prototype system, C‐OBJECT, supporting the model. The objects execute in a set of parallel processes called actions. The dynamic communicating objects exchange messages by both data transmissions and function invocations. The C‐OBJECT prototype is constructed in a MIMD architecture (32‐node transputer) with C++ which is composed of two parts: network configuration and a Communicating‐object service subsystem (library) providing various levels of message‐passing primitives. The initial prototype with good performance has shown its availability for C and C++ programming. The integrated system facilitates application software with tools of specification, design and implementation.
The genesis distributed memory benchmarks. Part 2: COMMS1, TRANS1, FFT1 and QCD2 benchmarks on the suprenum and IPSC/860 computers
Authors: Hey A. J. G. , Hockney R. , Getov V. , Wolton I. , Merlin J. , Allwright J.
Published: November 2006

The Genesis benchmark suite has been assembled to evaluate the performance of distributed‐memory MIMD systems. The problems selected all have a scientific origin (mostly from physics or theoretical chemistry), and range from synthetic code fragments designed to measure the basic hardware properties of the computer (especially communication and synchronisation overheads), through commonly used library subroutines, to full application codes. This is the second of a series of papers on the Genesis distributed‐memory benchmarks, which were developed under the European ESPRIT research program. Results are presented for the SUPRENUM and iPSC/860 computers when running the following benchmarks: COMMS1 (communications), TRANS1 (matrix transpose), FFT1 (fast Fourier transform) and QCD2 (conjugate gradient kernel). The theoretical predictions are compared with, or fitted to, the measured results, and then used to predict (with due caution) how the performance might scale for larger problems and more processors than were actually available during the benchmarking.
Accelerated ray tracing using an nCUBE2 multicomputer
Authors: Grimstead I. J. , Hurley S.
Published: November 2006

Acceleration techniques for rendering a dynamic sequence of frames (animations) and static scenes using ray tracing are presented. The first technique discusses temporal acceleration for dynamic scenes which takes advantage of ray coherence, while the second technique discusses acceleration for complex static scenes based on parallelism. Several practical aspects of the parallel implementation on an nCUBE2 hypercube computer are included.
The dynamic behaviour of parallel programs under process migration
Authors: Candlin Rosemary , Phillips Joseph
Published: November 2006

We have studied the interaction between process‐based parallel programs whose characteristics change in various ways at run time and the operation of load‐balancing, as implemented by process migration. In order to do this, we propose a simple performance model, whose parameters represent features of the program's execution such as the frequency and regularity of the changes in computational characteristics, and conduct a series of experiments involving simulated executions of synthetic programs with controlled parameter values. From these we can deduce the relative importance of the parameters from the point of view of their influence on performance.

We can explain our observations in terms of a simplified stochastic model that relates local changes in load to global behaviour. We show that the dynamics of load‐balancing can be represented approximately by a first‐order difference equation, and that the distributed process migration algorithm is consistent with a behaviour on the global scale which can be regarded as that of a traditional feedback controller.
Dynamic scheduling techniques for heterogeneous computing systems
Authors: Hamidzadeh Babak , Atif Yacine , Lilja David J.
Published: November 2006

There has been a recent increase of interest in heterogeneous computing systems, due partly to the fact that a single parallel architecture may not be adequate for exploiting all of a program's available parallelism. In some cases, heterogeneous systems have been shown to produce higher performance for lower cost than a single large machine. However, there has been only limited work on developing techniques and frameworks for partitioning and scheduling applications across the components of a heterogeneous system. In this paper we propose a general model for describing and evaluating heterogeneous systems that considers the degree of uniformity in the processing elements and the communication channels as a measure of the heterogeneity in the system. We also propose a class of dynamic scheduling algorithms for a heterogeneous computing system interconnected with an arbitrary communication network. These algorithms execute a novel optimization technique to dynamically compute schedules based on the potentially non‐uniform computation and communication costs on the processors of a heterogeneous system. A unique aspect of these algorithms is that they easily adapt to different task granularities, to dynamically varying processor and system loads, and to systems with varying degrees of heterogeneity. Our simulations are designed to facilitate the evaluation of different scheduling algorithms under varying degrees of heterogeneity. The results show improved performance for our algorithms compared to the performance resulting from existing scheduling techniques.
An adaptive algorithm for resolving processor thrashing in load distribution
Authors: Lu Chin , Lau Sau‐Ming
Published: November 2006

Processor thrashing in load distribution refers to the situation when a number of nodes try to negotiate with the same target node simultaneously. The performance of dynamic load‐balancing algorithms can be degraded because processor thrashing can lead to receiver node overdrafting, thus causing congestion at a receiver node and reduction of workload distribution. In the paper we present an adaptive algorithm for resolving processor thrashing in load distribution. The algorithm is based on the integration of three components: (1) a batch task assignment policy, which allows a number of tasks to be transferred as a single batch from a sender to a receiver; (2) a negotiation protocol to obtain mutual agreement between a sender and a receiver on the batch size; and (3) an adaptive symmetrically‐initiated location policy to select a potential transfer partner. Simulations reveal that our algorithm provides a significant performance improvement at high system loads because the algorithm can avoid processor thrashing so that CPU capacity is more fully utilized.
A load index and a transfer policy for global scheduling tasks with deadlines
Authors: Shivaratri Niranjan G. , Singhal Mukesh , Singhal Mukesh
Published: November 2006

Two important components of a global scheduling algorithm are its transfer policy and its location policy. While the transfer policy determines whether a task should be transferred, the location policy determines where it should be transferred. Many global scheduling algorithms have been proposed to schedule tasks with deadline constraints. These algorithms try to transfer tasks only when task's deadlines cannot be met locally or local load is high (i.e. they take only corrective measures). However, a scheduling algorithm that takes preventive measures in addition to corrective measures can reduce potential deadline misses substantially. In this paper we present: (a) a load index which characterizes the system state and is more conducive to preventive and corrective measures; (b) a new transfer policy which takes preventive measures by doing anticipatory task transfers in addition to corrective measures. The proposed transfer policy adapts better to the workload by availing of the accurate system state made available by the proposed load index. An algorithm making use of the new transfer policy and the new load index is shown to reduce the number of deadline misses significantly when compared to algorithms taking only corrective measures.
Nearest‐neighbor algorithms for load‐balancing in parallel computers
Authors: Xu Chengzhong , Lau Francis C. M. , Lau Francis C. M. , Monien Burkhard , Lüling Reinhard
Published: November 2006

With nearest‐neighbor load‐balancing algorithms, a processor makes balancing decisions based on localized workload information and manages workload migrations within its neighborhood. The paper compares a couple of fairly well‐known nearest‐neighbor algorithms,the dimension‐exchange(DE) andthe diffusion(DF) methods and their several variants—the average dimension‐exchange (ADE), optimally tuned dimension‐exchange (ODE), local average diffusion (ADF) and optimally tuned diffusion (ODF). The measures of interest are their efficiency in driving any initial workload distribution to a uniform distribution and their ability in controlling the growth of the variance among the processors' workloads. The comparison is made with respect to both one‐port and all‐port communication architectures and in consideration of various implementation strategies including synchronous/asynchronous invocation policies and static/dynamic random workload behaviors. It turns out that the dimension‐exchange method outperforms the diffusion method in the one‐port communication model. In particular, the ODE algorithm is best suited for statically synchronous implementations of a load‐balancing process regardless of its underlying communication models. The strength of the diffusion method is in asynchronous implementations in the all‐port communication model; the ODF algorithm performs best in that case. The underlying communication networks considered assume the most popular topologies, the mesh and the torus and their special cases: the hypercube and thek‐aryn‐cube.
Exenatide effects on glucose metabolism and metabolic disorders common to overweight and obese patients with type 2 diabetes
Authors: Webb David M. , Wintle Matthew , Malone James K.
Published: November 2006

The risks of cardiovascular disease (CVD) and type 2 diabetes increase as body mass index increases in overweight (25–30 kg/m2) and obese (>30 kg/m2) individuals. However, these risks can be reduced with even modest weight loss. In patients with established type 2 diabetes, control of both glycemia and body weight are important to minimize the risk of future diabetic complications. Exenatide is a 39‐amino‐acid peptide incretin mimetic currently approved in the United States for the treatment of type 2 diabetes as an adjunct to sulfonylurea and/or metformin. Phase‐3 clinical studies showed exenatide therapy for 30 weeks significantly reduced glycosylated hemoglobin (HbA1c), and fasting and postprandial plasma glucose, while significantly reducing body weight. Open‐label extensions from these pivotal trials demonstrated patients treated with exenatide for 2 years had sustained reductions in glycemic control at 30 weeks and a progressive reduction in body weight. Patients treated with exenatide also had improvement in blood pressure, inflammatory markers, and lipid profiles. The glucoregulatory and weight‐reducing effects of exenatide are the result of multiple modes of action that mimic several of the glucoregulatory actions of the naturally occurring peptide, glucagon‐like peptide‐1 (GLP‐1). These include restoration of first phase insulin response, enhancement of glucose‐dependent insulin secretion, suppression of inappropriate glucagon secretion, slowing of gastric emptying, and affects on satiety leading to reduced food intake. Further research is required to fully understand the role for exenatide to potentially alleviate metabolic disorders associated with type 2 diabetes, including CVD and obesity. Drug Dev. Res. 67:666–676, 2006. © 2006 Wiley‐Liss, Inc.
“The next big thing” in diabetes: clinical progress on DPP‐IV inhibitors
Authors: von Geldern Thomas W. , Trevillyan James M.
Published: November 2006

Inhibitors of the enzyme dipeptidyl peptidase‐IV (DPP‐IV) appear poised to become the next major advance in the treatment of type 2 diabetes mellitus (T2DM). Glucagon‐like peptide‐1 (GLP‐1) is an “incretin hormone” released from L cells in the small intestine in response to the ingestion of nutrients, which enhances the glucose‐dependent secretion of insulin from pancreatic β‐cells. In type 2 diabetic patients, the continuous infusion of GLP‐1 decreases plasma glucose and hemoglobin A1cconcentrations and improves β‐cell function. The rapid clearance of active GLP‐1 (in vivo half‐life ∼1 min) through DPP‐IV processing poses challenges to the development of exogenous GLP‐1‐based therapy. The inhibition of endogenous GLP‐1 degradation by reducing DPP‐IV activity is an alternative strategy for improving the incretin action of GLP‐1 in vivo. The area has attracted increasing attention in recent years from both academic and pharma researchers. Numerous reports of small‐molecule DPP‐IV inhibitors have appeared in the recent literature; many more reports describe the beneficial effects of these inhibitors in vitro and in animal models of T2DM. More recently, this approach has been explored clinically, with the most advanced agents currently under review by regulators. This review highlights the progress and status of clinically evaluated agents of this class, also noting key preclinical experiments that have provided proof of concept for this novel mechanism of action. Drug Dev. Res. 67:627–642, 2006. © 2006 Wiley‐Liss, Inc.
Targeting of the central histaminergic system for treatment of obesity and associated metabolic disorders
Authors: Malmlöf Kjell , Hohlweg Rolf , Rimvall Karin
Published: November 2006

There is currently a need for effective pharmacological therapies for treatment of obesity. In this communication, the involvement of the neurotransmitter histamine in the regulation of food intake is reviewed, together with results obtained in animals with pharmacologically increased brain histamine levels. A survey of the literature reveals that histaminergic circuits, arising from nerve cell bodies in the tuberomammillary nucleus and projecting into the paraventricular nucleus, the arcuate nucleus, and the ventromedial hypothalamus, are strongly involved in regulation of food intake and possibly also energy expenditure. Current literature also suggests the histaminergic circuits connect to other neuronal pathways involved in the regulation of energy balance and body weight. Studies performed in rodents demonstrate that H3receptor antagonists increase hypothalamic histamine and decrease food intake, which result in decreased body weight. Lipid oxidation is increased and, at higher doses, body fat is also decreased. These changes are associated with lower circulating levels of insulin during an oral glucose challenge suggesting an increase in insulin sensitivity. The effects on food intake have also been confirmed in pigs and rhesus monkeys. It can thus be concluded that results obtained with H3antagonist in animals warrant future clinical studies to evaluate whether this principle is effective in the treatment of human obesity. Drug Dev. Res. 67:651–665, 2006. © 2006 Wiley‐Liss, Inc.
New generation angiotensin II type 1 receptor antagonists that selectively modulate peroxisome proliferator‐activated receptor‐γ
Authors: Pershadsingh Harrihar A.
Published: November 2006

The discovery that the antihypertensive angiotensin II type 1 receptor (AT1R) blockers (ARBs), telmisartan and irbesartan, were capable of activating peroxisome proliferators‐activated receptor (PPAR)‐γ has provided a novel approach for developing new generation ARBs with beneficial metabolic effects. By selectively blocking the angiotensin II–mediated pro‐inflammatory AT1R signaling pathway, while activating the PPARγ‐dependent anti‐inflammatory pathway, these compounds may confer broader anti‐inflammatory protection compared to other ARBs, i.e., those lacking PPARγ activity. Both telmisartan and irbesartan function as selective PPARγ modulators. Their potential beneficial effects beyond blood pressure reduction, include increased insulin sensitivity, improved lipid profile, improved anti‐inflammatory, and anti‐atherogenic risk profiles. These properties could provide superior clinical efficacy in hypertensive patients with insulin‐resistant states such as the metabolic syndrome and type 2 diabetes. Thus, among existing ARBs, telmisartan and irbesartan may have added benefits in the treatment of cardiovascular diseases with metabolic pathology, and their associated end‐organ microvascular and macrovascular complications. This unique subset of ARBs provides a strategic platform for designing prototypes of a new class of PPARγ ligands capable of antagonizing AT1R, for broadly targeting cardiometabolic diseases for which therapy is presently insufficient or non‐existent. Drug Dev. Res. 67:687;–697, 2006. © 2006 Wiley‐Liss, Inc.
A model for targeted substitution mutagenesis during SOS replication of double‐stranded DNA containing cis‐syn cyclobutane thymine dimers
Authors: Grebneva Helen A.
Published: November 2006

A model for ultraviolet mutagenesis is described that is based on the formation of rare tautomeric bases in pyrimidine dimers. It is shown that during SOS synthesis the modified DNA‐polymerase inserts canonical bases opposite the dimers; the inserted bases are capable of forming hydrogen bonds with bases in the template DNA. SOS‐replication of double‐stranded DNA having thymine dimers, with one or both bases in a rare tautomeric conformation, results in targeted transitions, transversions, or one‐nucleotide gaps. Structural analysis indicates that one type of dimer containing a single tautomeric base (TT1*, with the “*” indicating a rare tautomeric base and the subscript referring to the particular conformation) can cause A:T → G:C transition or homologous A:T → T:A transversion, while another dimer (TT2*) can cause a one‐nucleotide gap. The dimers containing T4* result in A:T → C:G transversion, while TT5* dimers can cause A:T → C:G transversion or homologous A:T → T:A transversion. If both bases in the dimer are in a rare tautomeric form, then tandem mutations or double‐nucleotide gaps can be formed. The dimers containing the rare tautomeric forms T1 *′, T2*′, T3*′, T4*′, and T5*′ may not result in mutations. The question of whether dimers containing T4*′ and T5*′ result in mutations requires further investigation. Environ. Mol. Mutagen., 2006. © 2006 Wiley‐Liss, Inc.
Euler solutions using flux‐based wave decomposition
Authors: Ahmad Nash'at , Lindeman John
Published: November 2006

The Euler equations are solved for non‐hydrostatic atmospheric flow problems in two dimensions using a high‐resolution Godunov‐type scheme. The Riemann problem is solved using a flux‐based wave decomposition suggested by LeVeque. This paper describes in detail, the design and implementation of the Riemann solver used for computing the Godunov fluxes. The methodology is then validated against benchmark cases for non‐hydrostatic atmospheric flows. Comparisons are made with solutions obtained from the National Center for Atmospheric Research's state‐of‐the‐art numerical model. The method shows promise in simulating non‐hydrostatic flows, which are characterized by steep gradients on the meso‐, micro‐ and urban‐scales. Copyright © 2006 John Wiley & Sons, Ltd.
Microglial control of neuronal death and synaptic properties
Authors: Bessis Alain , Béchade Catherine , Bernard Delphine , Roumier Anne
Published: November 2006

Microglia have long been characterized by their immune function in the nervous system and are still mainly considered in a beneficial versus detrimental dialectic. However a review of literature enables to shed novel lights on microglial function under physiological conditions. It is now relevant to position these cells as full time partners of neuronal function and more specifically of synaptogenesis and developmental apoptosis. Indeed, microglia can actively control neuronal death. It has actually been shown in retina that microglial nerve growth factor (NGF) is necessary for the developmental apoptosis to occur. Similarly, in cerebellum, microglia induces developmental Purkinje cells death through respiratory burst. Furthermore, in spinal cord, microglial TNFα commits motoneurons to a neurotrophic dependent developmental apoptosis. Microglia can also control synaptogenesis. This is suggested by the fact that a mutation in KARAP/DAP12, a key protein of microglial activation impacts synaptic functions in hippocampus, and synapses protein content. In addition it has been now demonstrated that microglial brain‐derived neurotrophin factor (BDNF) directly regulates synaptic properties in spinal cord. In conclusion, microglia can control neuronal function under physiological conditions and it is known that neuronal activity reciprocally controls microglial activation. We will discuss the importance of this cross‐talk which allows microglia to orchestrate the balance between synaptogenesis and neuronal death occurring during development or injuries. © 2006 Wiley‐Liss, Inc.