Adapting functional programs to higher order logic

Higher-order logic proof systems combine functional programming with logic, providing functional programmers with a comfortable setting for the formalization of programs, specifications, and proofs. However, a possibly unfamiliar aspect of working in such an environment is that formally establishing program termination is necessary. In many cases, termination can be automatically proved, but there are useful programs that diverge and others that always terminate but have difficult termination proofs. We discuss techniques that support the expression of such programs as logical functions. Electronic Supplementary Material  The online version of this article () contains supplementary material, which is available to authorized users.     

Matrix and finite element stack machines for structural engineering computations with units

Despite the well known benefits of physical units, matrices, and matrix algebra in engineering computations, most engineering analysis packages are essentially dimensionless. This paper describes the design and implementation of matrix and finite element stack machines for Aladdin, a new computational environment that embeds units inside matrix and finite element calculations. Functionality of the Aladdin stack machine is illustrated by working step by step through the setup and execution of three examples: (1) Parsing and stack machine execution for x = 2 in; (2) Deflection analysis of a cantilever beam, and (3) Rollup maneuver for a long cantilever beam.     

A methodology for detailed performance modeling of reduction computations on SMP machines

In this paper, we revisit the problem of performance prediction on SMP machines, motivated by the need for selecting parallelization strategy for random write reductions. Such reductions frequently arise in data mining algorithms.

In our previous work, we have developed a number of techniques for parallelizing this class of reductions. Our previous work has shown that each of the three techniques, full replication, optimized full locking, and cache-sensitive, can outperform others depending upon problem, dataset, and machine parameters. Therefore, an important question is, “Can we predict the performance of these techniques for a given problem, dataset, and machine?”.

This paper addresses this question by developing an analytical performance model that captures a two-level cache, coherence cache misses, TLB misses, locking overheads, and contention for memory. Analytical model is combined with results from micro-benchmarking to predict performance on real machines. We have validated our model on two different SMP machines. Our results show that our model effectively captures the impact of memory hierarchy (two-level cache and TLB) as well as the factors that limit parallelism (contention for locks, memory contention, and coherence cache misses). The difference between predicted and measured performance is within 20% in almost all cases. Moreover, the model is quite accurate in predicting the relative performance of the three parallelization techniques.     

Adapting paper prototyping for designing user interfaces for multiple display environments

A multiple display environment (MDE) networks personal and shared devices to form a virtual workspace, and designers are just beginning to grapple with the challenges of developing interfaces tailored for these environments. To develop effective interfaces for MDEs, designers must employ methods that allow them to rapidly generate and test alternative designs early in the design process. Paper prototyping offers one promising method, but needs to be adapted to effectively simulate the use of multiple displays and allow testing with groups of users. In this paper, we share experiences from two projects in which paper prototyping was utilized to explore interfaces for MDEs. We identify problems encountered when applying the traditional method, describe how these problems were overcome, and distill our experiences into recommendations that others can draw upon. By following our recommendations, designers need only make minor modifications to the existing method to better realize benefits of paper prototyping for MDEs.     

Adapting grid computing environments dependable with virtual machines: design, implementation, and evaluations

Due to its potential, using virtual machines in grid computing is attracting increasing attention. Most of the researches focus on how to create or destroy a virtual execution environments for different kinds of applications, while the policy of managing the virtual environments is not widely discussed. This paper proposes the design, implementation, and evaluation of an adaptive and dependable virtual execution environment for grid computing, ADVE, which focuses on the policy of managing virtual machines in grid environments. To build a dependable virtual execution environments for grid applications, ADVE provides an set of adaptive policies managing virtual machine, such as when to create and destroy a new virtual execution environment, when to migrate applications from one virtual execution environment to a new virtual execution environment. We conduct experiments over a cluster to evaluate the performance of ADVE, and the experimental results show that ADVE can improve the throughput and the reliability of grid resources with the adaptive management of virtual machines.     

Contour ranking on coarse grained machines: a case study for low-level vision computations

In the paper we present parallel solutions for performing image contour ranking on coarse-grained machines. In contour ranking, a linear representation of the edge contours is generated from the edge contours of a raw image. We describe solutions that employ different divide-and-conquer approaches and that use different communication patterns. The combining step of the divide-and-conquer solutions uses efficient sequential techniques for merging information about subimages. The proposed solutions are implemented on Intel Delta and Intel Paragon machines. We discuss performance results and present scalability analysis using different image and machine sizes. © 1997 by John Wiley & Sons, Ltd.     

Modelling and Adapting to Context

One of the hardest points in context-aware applications is deciding what reactions a system has to a certain context. In this paper, we introduce an architecture used in two context-aware museum guides. We discuss how the context is modelled and we briefly present a rule-based mechanism to trigger system actions. A rule-based system offers the flexibility required to be context-sensitive in the broadest sense since many context features can be considered and evaluated at the same time. This architecture is very flexible and easily supports a fast prototyping approach.     

Adapting to change and uncertainty

Understanding how people adapt to change and uncertainty is critical to system design, and good system design expands the ability of people to adapt. Cognitive systems engineering (CSE) enables us to understand work domains, reveal expertise, and derive essential features for systems. This is valuable because the demand for rapidly evolving systems such as information and communication technology does not allow for long-term deliberation by system developers. The publication of work by Norman, Hollnagel and Woods, and Rasmussen in the early 1980s provides an opportunity to consider where CSE stands nearly 30?years since its inception. The papers in this special issue of Cognition, Technology and Work convey insights from authors who have substantial firsthand experience with the use of CSE to study human adaptation to changing, uncertain work settings. Their research demonstrates the current state of CSE, the potential for CSE to reveal how people adapt to change and uncertainty, and implications for the design of complex adaptive systems.     

A functional correspondence between call-by-need evaluators and lazy abstract machines

We bridge the gap between compositional evaluators and abstract machines for the lambda-calculus, using closure conversion, transformation into continuation-passing style, and defunctionalization of continuations. This article is a followup of our article at PPDP 2003, where we consider call by name and call by value. Here, however, we consider call by need.We derive a lazy abstract machine from an ordinary call-by-need evaluator that threads a heap of updatable cells. In this resulting abstract machine, the continuation fragment for updating a heap cell naturally appears as an ‘update marker’, an implementation technique that was invented for the Three Instruction Machine and subsequently used to construct lazy variants of Krivine's abstract machine. Tuning the evaluator leads to other implementation techniques such as unboxed values. The correctness of the resulting abstract machines is a corollary of the correctness of the original evaluators and of the program transformations used in the derivation.     

Communication-induced determination of consistent snapshots

A classical way to determine consistent snapshots consists in using Chandy-Lamport's algorithm. This algorithm relies on specific control messages that allow processes to synchronize local checkpoint determination and message recording in order for the resulting snapshot to be consistent. This paper investigates a communication-induced approach to determine consistent snapshots. In such an approach, control information is carried out by application messages. Two abstract necessary and sufficient conditions are stated: one associated with global checkpoint consistency, the other associated with message recording. A general protocol is derived from these abstract conditions. Actually, this general protocol can be instantiated in distinct ways, giving rise to a family of communication-induced snapshot protocols. This general protocol shows there is an intrinsic trade-off between the number of forced checkpoints and the number of recorded messages. Finally, a particular instantiation of the general protocol is provided     

Power-efficient assignment of virtual machines to physical machines

Motivated by current trends in cloud computing, we study a version of the generalized assignment problem where a set of virtual processors has to be implemented by a set of identical processors. For literature consistency, we say that a set of virtual machines (VMs) is assigned to a set of physical machines (PMs). The optimization criterion is to minimize the power consumed by all the PMs. We term the problem Virtual Machine Assignment (VMA). Crucial differences with previous work include a variable number of PMs, that each VM must be assigned to exactly one PM (i.e., VMs cannot be implemented fractionally), and a minimum power consumption for each active PM. Such infrastructure may be strictly constrained in the number of PMs or in the PMs’ capacity, depending on how costly (in terms of power consumption) it is to add a new PM to the system or to heavily load some of the existing PMs. Low usage or ample budget yields models where PM capacity and/or the number of PMs may be assumed unbounded for all practical purposes. We study four VMA problems depending on whether the capacity or the number of PMs is bounded or not. Specifically, we study hardness and online competitiveness for a variety of cases. To the best of our knowledge, this is the first comprehensive study of the VMA problem for this cost function.     

An implementation of syntax directed functional programming on nested-stack machines

This paper contributes to the field of functional programming languages. We investigate the call-by-name and call-by-need implementation of a restricted type of functional programming, calledsyntax directed functional programming; the target of this implementation is an abstract machine that is based on nested stacks. In fact, the technical kernel of this paper is a refinement of an automata theoretical result that, roughly speaking, investigates the well-known relationship recursion = iteration + stack in the framework of tree transducers. More precisely, in the underlying result the class of functions computed by total deterministic macro tree-to-string transducers with the call-by-name computation strategy is characterized by total deterministic checking-tree nested-stack transducers. Note that total deterministic macro tree-to-string transducers are term rewriting systems by means of which the reduction semantics of syntax directed functional programming languages can be described.The work of this author has been supported by the Deutsche Forschungsgemeinschaft (DFG).     

Deriving parallel computations from functional specifications: A seismic example on a hypercube

Three algorithms developed for a seismic model illustrate that, when the target hardware has many processing elements, functional programs can exhibit better performance than programs developed with conventional techniques. This stands in contrast to the widely held belief that functional programs necessarily pay in poor performance for their advantages in conciseness and likelihood of correctness. Two of the algorithms evolved from an analysis of the seismic model with the goal of finding parts of the computation that could proceed in parallel. The first algorithm has a low communication to computation ratio. The second and third algorithms have higher ratios trading communication time for computation time. The third algorithm was derived from a presentation of the input/output relationship of the model expressed as a composition of mathematical functions. This algorithm exhibited substantially better performance than either of the others. The algorithm achieves its good performance by setting up a producer-consumer pipeline between simultaneously operating portions of the computation. This pipeline balances computation and interprocessor communication more effectively than the other two algorithms.     

From insects to machines

Insects and hummingbirds remain unmatched in their aerodynamic ability to hover in place in addition to other acrobatic feats such as flying backward and sideways by exploiting flapping-wing motion [1]. Although this remarkable ability is key to making small-scale aircraft, flapping-hovering behavior has been difficult to reproduce artificially because of the challenging stability, power, and aeroelastic phenomena involved. Recent interest in small-scale unmanned air vehicles, especially those capable of hovering like insects and hummingbirds, is driven by many potential applications. A number of flapping machines have been developed [2]-[8], but only two are capable of untethered hovering flight [9], [10]. A key challenge is to demonstrate a stable untethered flapping-hovering ability at a weight and power approximating that of insects and birds where flapping-hovering flight is observed in nature. Here we demonstrate, for the first time, a passively stable 24-g machine capable of flapping-hovering flight at a Reynolds number similar to insects (Re = 8 × 10³). This architecture, particularly the passive stability, may help in the design of insect-sized hovering vehicles as well as shed light on the aeroelastic dynamic principles underlying insect flight.     

Adapting automation to man, culture and society

Anxiety about the effects of automation on workers and society is at least 150 years old. The recent explosion of microelectronics and robotic applications has sharpened our understanding of both the gains and the risks: mismatch to human physiological, psychological and cultural characteristics; alienation from fulfillment and dignity in work; widening of the gap between skilled and unskilled workers and between technologically developed and underdeveloped communities; decrement in individual security. Attention to these problems can ensure that automation results in a better society. The control engineer, who is responsible for enlarging the scale of automation, should also play a role in adapting it to people. For the time being, technology should be individually designed to each culture.     

A declarative approach to visualizing concurrent computations

The authors explore the graphical representation of objects and processes as a means for understanding programs consisting of large numbers of concurrent processes. Their goal is to establish a technical foundation for research into the monitoring and debugging of large-scale concurrent programs. They explain declarative visualization and introduce some shared-data-space concepts and notation by means of a simple, nondeterministic, parallel algorithm. They discuss visual abstraction and their visualization methodology, which they illustrate by applying it to region labeling. Thy examine the relaxation of nonintervention that visualization makes possible