Robert Bernecky

Learn More
APEX: the APL Parallel Executor Robert Bernecky Master of Science Graduate Department of Computer Science University of Toronto 1997 APEX is an APL-to-SISAL compiler, generating high-performance, portable, parallel code that executes up to several hundred times faster than interpreted APL, with serial performance of kernels competitive with FORTRAN.(More)
This paper gives a simple introduction to the concepts of Function Rank and the Rank Operator as they are defined in SHARP APL, and presents examples of their use. It shows the benefits, both in language design and in practice, of these concepts. Comparisons are made with other APL implementations, which do not use these concepts.
Gerunds, verbal forms that can be used as nouns, are recognized as having utility in the realm of programming languages. We show that gerunds can be viewed as arrays of atomic representations of verbs (functions), in a way which is consistent with the syntax and semantics of APL, and which allows verbs to be first class objects in the language. We define(More)
Although multicomputers are becoming feasible for solving large problems, they are difficult to program: Extraction of parallelism from scalar languages is possible, but limited. Parallelism in algorithm design is difficult for those who think in von Neumann terms. Portability of programs and programming skills can only be achieved by hiding the underlying(More)
This article describes how <i>array predicates</i> were used to reduce the computational complexity of four APL primitive functions when one of their arguments is a permutation vector. The search primitives, <i>indexof</i> and set membership, and the sorting <i>primitives,</i> upgrade and downgrade, execute in linear time on such arguments. Our(More)
a prototype APL to C compiler (<italic>ACORN</italic>: APL to C On Real Numbers) was produced while investigating improved tools for solving numerically intensive problems on supercomputers. <italic>ACORN</italic> currently produces code which runs slower than hand-coded Cray FORTRAN, but we have identified the major performance bottlenecks, and believe we(More)
Compiling indexing operations on n-dimensional arrays into efficiently executable code is a challenging task. This paper focuses on the reduction of offset computations as they typically occur when transforming index vectors into offsets for linearized representations of ndimensional arrays. We present a high-level optimization to that effect which is(More)
The specification and resolution of non-trivial domain constraints has become a well-recognised measure for improving the stability of large software systems. In this paper we propose an approach based on partial evaluation which tries to prove such constraints statically as far as possible and inserts efficient dynamic checks otherwise.