{ rjmh, pareto, sabry We have designed and implemented a type-based analysis for proving some baaic properties of reactive systems. The analysis manipulates rich type expressions that contain in-formation about the sizes of recursively defined data struc-tures. Sized types are useful for detecting deadlocks, non-termination, and other errors in embedded programs. To establish the soundness of the analysis we have developed an appropriate semantic model of sized types. 1 Embedded Functional Programs In a reactive system, the control software must continu-ously react to inputs from the environment. We distin-guish a class of systems where the embedded programs can be naturally expressed as functional programs manipulat-ing streams. This class of programs appears to be large enough for many purposes [2] and is the core of more ex-pressive formalisms that accommodate asynchronous events, non-determinism, etc. The fundamental criterion for the correctness of pro-grams embedded in reactive systems is Jwene.ss. Indeed, before considering the properties of the output, we must en-sure that there is some output in the first place: the program must continuous] y react to the input streams by producing elements on the output streams. This latter property may fail in various ways: e the computation of a stream element may depend on itself creating a “black hole, ” or e the computation of one of the output streams may demand elements from some input stream at different rates, which requires unbounded buffering, or o the computation of a stream element may exhaust the physical resources of the machine or even diverge.

: Program profiles identify frequently executed portions of a program, which are the places at which optimizations offer programmers and compilers the greatest benefit. Compilers, however, infrequently exploit program profiles, because profiling a program requires a programmer to instrument and run the program. An attractive alternative is for the compiler to statically estimate program profiles. . This paper presents several new techniques for static branch prediction and profiling. The first technique combines multiple predictions of a branch's outcome into a prediction of the probability that the branch is taken. Another technique uses these predictions to estimate the relative execution frequency (i.e., profile) of basic blocks and controlflow edges within a procedure. A third algorithm uses local frequency estimates to predict the global frequency of calls, procedure invocations, and basic block and control-flow edge executions. Experiments on the SPEC92 integer benchmarks and Uni...

We present the first system for estimating and using datadependent expression execution times in a language with first-class procedures and imperative constructs. Thepresence of first-class procedures and imperative constructs makes cost estimation a global problem that can benefit from type information. We estimate expression costs with the aid of an algebraic type reconstruction system that assigns every procedure atype that includes a static dependent cost. A static dependent cost describes the execution time of a procedure in terms of its inputs. In particular, a procedure’s static dependent cost can depend on the size of input data structures and the cost of input first-class procedures. Our cost system produces symbolic cost expressions that contain free variables describing the size and cost of the procedure’s inputs. At run-time, a cost estimate is dynamically computed from the statically determined cost expression and run-time cost and size information. We present experimental results that validate our cost system onthreecompilers and architectures. We experimentally demonstrate the utility of cost estimates in making dynamic parallelization decisions. In our experience, dynamic parallelization meets or exceeds the parallel performance of any fixed number of processors. 1

The paper proposes a technique for inferring conditions on goals that, when satisfied, ensure that a goal is sufficiently coarse-grained to warrant parallel evaluation. The method is powerful enough to reason about divide-and-conquerprograms, and in the case of quicksort, for instance, can infer that a quicksort goal has a time complexity that exceeds 64 resolution steps (a threshold for spawning) if the input list is of length 10 or more. This gives a simple run-time tactic for controlling spawning. The method has been proved correct, can be implemented straightforwardly, has been demonstrated to be useful on a parallel machine, and, in contrast with much of the previous work on time-complexity analysis of logic programs, does not require any complicated difference equation solving machinery. 1 Introduction Automatic time-complexity analysis is useful to the programmer for algorithmic considerations but has a special role in the development of efficient parallel programs [9, 6, 7, 12...

Speculative evaluation, including leniency and futures, is often used to produce high degrees of parallelism. Existing speculative implementations, however, may serialize computation because of their implementation of queues of suspended threads. We give a provably efficient parallel implementation of a speculative functional language on various machine models. The implementation includes proper parallelization of the necessary queuing operations on suspended threads. Our target machine models are a butterfly network, hypercube, and PRAM. To prove the efficiency of our implementation, we provide a cost model using a profiling semantics and relate the cost model to implementations on the parallel machine models. 1 Introduction Futures, lenient languages, and several implementations of graph reduction for lazy languages all use speculative evaluation (call-by-speculation [15]) to expose parallelism. The basic idea of speculative evaluation, in this context, is that the evaluation of a...

Granularity control is a method to improve parallel execution performance by limiting excessive parallelism. The general idea is that if the gain obtained by executing a task in parallel is less than the overheads required to support parallel execution, then the task is better executed sequentially. Traditionally, in logic programming task size is estimated from the sequential time-complexity of evaluating the task. Tasks are only executed in parallel if task size exceeds a pre-determined threshold. We argue in this paper that the estimation of complexity on its own is not an ideal metric for improving the performance of parallel programs through granularity control. We present a new metric for measuring granularity, based on a notion of distance. We present some initial results with two very simple methods of using this metric for granularity control. We then discuss how more sophisticated granularity control methods can be devised using the new metric. 1 Introduction Granularity con...

We describe a new automatic static analysis for determining upper-bound functions on the use of quantitative resources for strict, higher-order, polymorphic, recursive programs dealing with possibly-aliased data. Our analysis is a variant of Tarjan’s manual amortised cost analysis technique. We use a type-based approach, exploiting linearity to allow inference, and place a new emphasis on the number of references to a data object. The bounds we infer depend on the sizes of the various inputs to a program. They thus expose the impact of specific inputs on the overall cost behaviour. The key novel aspect of our work is that it deals directly with polymorphic higher-order functions without requiring source-level transformations that could alter resource usage. We thus obtain safe and accurate compile-time bounds. Our work is generic in that it deals with a variety of quantitative resources. We illustrate our approach with reference to dynamic memory allocations/deallocations, stack usage, and worst-case execution time, using metrics taken from a real implementation on a simple micro-controller platform that is used in safety-critical automotive applications.

For problems with highly dynamic behavior, our experiments showed that there are specific characteristics for different applications. We therefore propose a mapping environment providing several strategies for both granularity control and dynamic load balancing. For appropriate selection and parameterization of strategies, we extract the application characteristics using trace-based profiling and appropriate evaluations. Our profiling approach differs from others in that more information (like argument sizes or the branching factor) is collected and more advanced evaluations are performed. Large real-life applications have been successfully measured, and examples demonstrate differences in characteristics and which the corresponding strategies being appropriate are. 1 Introduction Although functional programs, by definition, provide a rich source of parallelism because of the absence of side-effects, they nevertheless pose similar problems as encountered with procedural programs for c...

We have designed and implemented an asynchronous data-parallel scheduler for the SML/NJ ML compiler. Using this general scheduler we built a data-parallel module that provides new operators to manipulate sequences (i.e., arrays, vectors) in parallel. Parallelization concerns such as thread creation and synchronization are hidden from the application programmer by ML's module abstraction. We find that languages with modules, higher-order functions and automatic parallel storage management can, in this manner, seamlessly support data-parallel operators. An implementation of applications using the new sequence module on an eight-processor shared-memory machine indicates that in some cases useful speedup is possible with our approach.

We havedesigned and implemented an asynchronous data-parallel scheduler for the SML/NJ ML compiler. Using this general scheduler we built a data-parallel module that provides new operators to manipulate sequences (i.e., arrays, vectors) in parallel. Parallelization concerns such as thread creation and synchronization are hidden from the application programmer by ML's module abstraction. We nd that languages with modules, higher-order functions and automatic parallel storage management can, in this manner, seamlessly support data-parallel operators. An implementation of applications using the new sequence module on an eight-processor shared-memory machine indicates that in some cases useful speedup is possible with our approach. 1