Computer Languages最新文献

The parallel language FORK [1], based on a scalable shared memory model, is a PASCAL-like language with some additional parallel constructs. A PRAM (Parallel Random Access Machine) algorithm can be expressed on a high level of abstraction as a FORK program which is translated into efficient PRAM code guaranteeing theoretically predicted runtimes.

In this paper, we concentrate on those features of the language FORK related to parallelism, such as the group concept, a shared memory access and synchronous or asynchronous execution. We present a trace-based denotational interleaving semantics where processes describe synchronous computations. Processes are created or deleted dynamically and run asynchronously. Interleaving rules reflect the underlying CRCW (concurrent-read-concurrent-write) PRAM model.

A new parallel parsing algorithm for block structured languages, capable of parsing incrementally also, is presented. The parser is for LR grammars. A shared memory multiprocessor model is assumed. We associate processors to parse corrections independently with minimum reparsing. A new compatibility condition is used by the associated processors to terminate parsing, and prevent redoing the work of other processors. We give an efficient way of assembling the final parse tree from the individual parses. Our compatibility condition is simple and it can be computed at the parser construction time itself. Further, the compatibility condition can be tested while parsing, in constant time. The parser can be integrated into the editor. We give an estimate for speedup by our parallel parsing and parallel incremental parsing methods. We have obtained considerable speedups in simulation studies of our algorithm.

In this paper so-called discrete loops are introduced which narrow the gap between general loops (e.g. while- or repeat-loops) and for-loops. Although discrete loops can be used for applications that would otherwise require general loops, discrete loops are known to complete in any case. Furthermore it is possible to determine the number of iterations of a discrete loop, while this is trivial to do for for-loops and extremely difficult for general loops. Thus discrete loops form an ideal frame-work for determining the worst case timing behavior of a program and they are especially useful in implementing real-time systems and proving such systems correct.

The aggregate update problem has received considerable attention since pure functional programming languages were recognised as an interesting research topic. There is extensive literature in this area, which proposes a wide variety of solutions. We have tried to apply some of the proposed solutions to our own applications to see how these solutions work in practice. We have been able to use destructive updates but are not convinced that this could have been achieved without application specific knowledge. In particular, no form of update analysis has been reported that is applicable to non-flat domains in polymorphic languages with higher order functions.

It is our belief that a refinement of the monolithic approach towards constructing arrays may be a good alternative to using the incremental approach with destructive updates.

Several researchers have looked into various issues related to automatic parallelization of sequential programs for multicomputers. But there is a need for a coherent framework which encompasses all these issues. In this paper we present a such a framework which takes best advantage of the multicomputer architecture. We resort to tiling transformation for iteration space partitioning and propose a scheme of automatic data partitioning and dynamic data distribution. We have tried a simple implementation of our scheme on a transputer based multicomputer [1] and the results are encouraging.

The paper describes the results of a large empirical study to measure the practical behavior of the basic versions of the popular internal sorting algorithms, Shellsort, quicksort, and mergesort, for medium to large size data and compares them with previous results. The results give running times of θ(N^1.25) for Shellsort, quicksort, and mergesort for 1000 < N < 2 × 10⁶. The study also shows that Shellsort behaves better than mergesort for 1000 < N < 150,000. However, mergesort outperforms Shellsort for N > 150,000. Quicksort outperforms both Shellsort and mergesort for all values of N > 1000. Our fits show better performance for Shellsort than the previous studies and are mostly accurate to within 2% for 1000 < N < 2 × 10⁶. The primary reason for this error seems to be related to the error in the measured data.

Type-sensitive parsing of expressions is context-sensitive parsing based on type. Previous research reported a general class of algorithms for type-sensitive parsing. Unfortunately, these algorithms are impractical for languages that infer type. This paper describes a related algorithm which is much more efficient—its incremental cost is linear (with a small constant) in the length of the expression, even when types must be deduced. Our method can be applied to any statically typed language solving a variety of problems associated with conventional parsing techniques including problems with operator precedence and the interaction between infix operators and higher order functions.

Since the mid-1970s, and with the development of each new programming paradigm there has been an increasing interest in exceptions and the benefits of exception handling. With the move towards programming for ever more complex architectures, understanding basic facilities such as exception handling as an aid to improving program reliability, robustness and comprehensibility has become much more important. Interest has sparked the production of many papers both theoretical and practical, each giving a view of exceptions and exception handling from a different standpoint.

In an effort to provide a means of classifying exception handling models which may be encountered, a taxonomy is presented in this paper. As the taxonomy is developed some of the concepts of exception handling are introduced and discussed. The taxonomy is applied to a number of exception handling models in some contemporary programming languages and some observations and conclusions offered.

We present two grammar transformations which can decrease the search space of generated top-down backtrack parsers. The transformations are simple and can be of practical use.

The first transformation, which is a combination of substitution and left-factorization, is based on the LR-table construction. The second transformation uses the calculation of the sets FIRST and FOLLOW, and a grammar property, called rrelative unambiguity.

The time complexity of the transformations is worst case polynomial and in practical cases linear in the size of the grammar.