This article presents the design principles and efficient implementation techniques for ABCL/R3, an object-oriented concurrent reflective language. One of the most distinguished features of ABCL/R3 is compilation techniques using partial evaluation, which effectively remove interpretation from meta-level programs. The meta-level objects are designed so that they can be partially evaluated in an effective manner. Benchmark programs show that our compilation frameworks make object execution drastically faster than interpreter-based implementations, and achieves performance close to nonreflective compilers.

It is difficult to map the execution model of multithread-ing languages (languages which support fine-grain dynamic thread creation) onto the single stack execution model of C. Consequently, previous work on efficient multithreading uses elaborate frame formats and allocation strategy, with com-pilers customized for them. This paper presents an alterna-tive cost-effective implementation strategy for multithread-ing languages which can maximally exploit current sequen-tial C compilers. We identify a set of primitives whereby ef-ficient dynamic thread creation and switch can be achieved and clarify implementation issues and solutions which work under the stack frame layout and calling conventions of cur-rent C compilers. The primitives are implemented as a C library and named StackThreads. In StackThreads, a thread creation is done just by a C procedure call, max-imizing thread creation performance. When a procedure suspends an execution, the context of the procedure, which is roughly a stack frame of the procedure, is saved into heap and resumed later. With StackThreads, the compiler writer can straightforwardly translate sequential constructs of the source language into corresponding C statements or expres-sions, while using StackThreads primitives as a blackbox mechanism which switches execution between C procedures.

A concurrent object-oriented extension to the programming language Scheme, called Schematic, is described. Schematic supports familiar constructs often used in typical parallel programs (future and higher-level macros such as plet and pbegin), which are actually defined atop a very small number of fundamental primitives. In this way, Schematic achieves both the convenience for typical concurrent programming and simplicity and flexibility of the language kernel. Schematic also supports concurrent objects which exhibit more natural and intuitive behavior than the "bare" (unprotected) shared memory, and permit intra-object concurrency. Schematic will be useful for intensive parallel applications on parallel machines or networks of workstations, concurrent graphical user interface programming, distributed programming over network, and even concurrent shell programming.

This paper describes the design and implementation of a garbage collection scheme on large-scale distributed-memory computers and reports various experimental results. The collector is based on the conservative GC library by Boehm & Weiser. Each processor traces local pointers using the GC library while traversing remote pointers by exchanging "mark messages" between processors. It exhibits a promising performance---in the most space-intensive settings we tested, the total collection overhead ranges from 5% up to 15% of the application running time (excluding idle time). We not only examine basic performance figures such as the total overhead or latency of a global collection, but also demonstrate how local collection scheduling strategies affect application performance. In our collector, a local collection is scheduled either independently or synchronously. Experimental results show that the benefit of independent local collections has been overstated in the literature. Independent l...

Motivation: Predict the consensus secondary structure, possibly including pseudoknots, of a set of RNA unaligned sequences Results: We have designed a method based on a new representation of any RNA secondary structure as a set of structural relations between the helices of the structure. We refer to this representation as a structural pattern. In a first step we use thermodynamic parameters to select, for each sequence, the best secondary structures according to energy minimisation and we represent each of them using its corresponding structural pattern. In a second step we search for the repeated structural patterns i.e. the largest structural patterns that occur in at least one sequence, i.e. included in at least one of the structural patterns associated to each sequence. Thanks to an efficient encoding of structural patterns this search comes down to identify the largest repeated word suffixes in a dictionary. In a third step we compute the plausibility of each repeated structura...

The prediction of the correct secondary structures of large RNAs is one of the unsolved challenges of computational molecular biology. Among the major obstacles is the fact that accurate calculations scale as O(n 4), so the computational requirements become prohibitive as the length increases. Existing folding programs implement heuristics and approximations to overcome these limitations. We present a new parallel multicore and scalable program called GTfold, which is one to two orders of magnitude faster than the de facto standard programs and achieves comparable accuracy of prediction. Development of GTfold opens up a new path for the algorithmic improvements and application of an improved thermodynamic model to increase the prediction accuracy. In this paper we analyze the algorithm’s concurrency and describe the parallelism for a shared memory environment such as a symmetric multiprocessor or multicore chip. In a remarkable demonstration, GTfold now optimally folds 11 picornaviral RNA sequences ranging from 7100 to 8200 nucleotides in 8 minutes, compared with the two months it took in a previous study. We are seeing a paradigm shift to multicore chips and parallelism must be explicitly addressed to continue gaining performance with each new generation of systems. We also show that the exact algorithms like internal loop speedup can be implemented with our method in an affordable amount of time. GTfold is freely available as open source from our website.

this document are those of the authors and should not be interpreted as necessarily representing the o#cial policies or endorsements, either expressed or implied, of Phillips Laboratory or the U.S. Government." Access to the CACR facility was provided by the California Institute of Technology in the context of a collaboration with Paul E. Stolorz. Partial financial support by the Austrian 10