Robert Bernecky

An introduction to function rank

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 and representations

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 derivations of verbs from gerunds in the J dialect of APL, and show how these derivations provide control structures for sequencing, selection (in the sense of generalized forms of CASE or SWITCH statements and IF/THEN/ELSE), iteration (DO UNTIL), recursion, and parallel computation (MIMD, or Multiple Instruction, Multiple Data). We conclude with alternative representations of verbs which are useful in other contexts.

ACORN : APL to C on real numbers

a prototype APL to C compiler ( ACORN : APL to C On Real Numbers) was produced while investigating improved tools for solving numerically intensive problems on supercomputers. ACORN currently produces code which runs slower than hand-coded Cray FORTRAN, but we have identified the major performance bottlenecks, and believe we know how to remove them. Although created in a short time on a limited budget, and intended only as a proof of the feasibility of compiling APL for numerically intensive environments, ACORN has shown that straightforward compiled APL will be able to compete with hand-optimized FORTRAN in many common supercomputer applications.

Reducing computational complexity with array predicates

This article describes how array predicates were used to reduce the computational complexity of four APL primitive functions when one of their arguments is a permutation vector. The search primitives, indexof and set membership, and the sorting primitives, upgrade and downgrade, execute in linear time on such arguments. Our contribution, a method for static determination of array properties, lets us generate code that is optimized for special cases of primitives. Our approach eliminates runtime checks which would otherwise slow down the execution of all cases of the effected primitives. We use the same analysis technique to reduce the type complexity of certain array primitives.

APL: A prototyping language

The use of APL as a language for system design and prototyping is discussed. Benefits of APL over traditional design techniques are shown to include higher productivity, improved code reliability, superior maintainability and performance, and executable documentation. Hierarchical and hybrid approaches to modelling systems of various degrees of complexity are presented, with examples chosen from the authors experience.

Array morphology

Array morphology is the study of the form, structure, and evolution of arrays. An array annotation for a program written in an applicative array language is an abstract syntax tree for the program, amended with information about the arrays created by that program. Array notations are useful in the production of efficient compiled code for applicative array programs. Array morphology is shown to be an effective compiler writers tool. Examples of an array annotator in action are presented, showing its value in array morphology. Array morphology is shown to provide methods for static detection of certain classes of programming errors.Assertions are a generalization of declarations that offer significant benefits to application writers as well as compiler writers. Although assertions are executable code, they can often be evaluated at compilation time. Assertions, and therefore declarations, may be represented as conjunctions, and are, therefore, conforming extensions to ISO Standard APL. A domain conjunction is offered as an example of how assertions might be defined in APL or J.

Representations for enclosed arrays

This paper defines coadunate representation, an organization of data used to represent recursive data structures in SHARP APL, and shows that it has desirable performance characteristics for several families of APL functions that apply to enclosed arrays. The effect on an implementation is to make it possible for those functions to operate on enclosed arrays at processor speeds and storage costs which are nearly independent of the contents or structure of the array elements.

Shape cliques

We introduce shape cliques, a simple way to organize a subset of the arrays appearing in an array-language-based application into sets of identically shaped arrays - shape cliques - and show how a compiler can analyze an application to infer membership in those cliques. We describe an algorithm for performing shape clique inference (SCI), and demonstrate that shape cliques can improve the performance of generated code, by permitting extension of an optimization for removal of run-time checks, and by extending the set of arrays to which optimizations, such as Index Vector Elimination (IVE), can be applied. Implementation of SCI in the APEX APL compiler permitted removal of 25% of run-time checks remaining on 156 benchmarks remaining after other compiler optimizations had eliminated 72% of the 1251 checks present in the original code. In the SAC compiler, IVE using SCI produced typical speedups of 2-14X on benchmarks operating on arrays of non-fixed rank and shape, compared to the operation of IVE in a non-SCI environment. Shape clique inference data can be exploited to allow certain other optimizations, such as loop fusion and withloop folding, to be performed on arrays of statically unknown shape and rank, with the potential for significant reductions in execution time.

Profiling, performance, and perfection (tutorial session)

A profile is “a set of data often in graphic form portr:ying the significant features of something” [WeSS]. Profiles can help us to quickly understand a person or entity better. In the development of computerbased applications, profiles are invaluable. They help us to understand the application how it works, how well it works, whether it in fact works as we think it does, and whether it is still working the same way it did last month.

An SPMD/SIMD parallel tokenizer for APL

We describe a highly parallel (SIMD within SPMD) tokenizer for the APL language, itself written in APL. The tokenizer does not break any new ground in the world of parallel computation, but does serve the didactic purpose of demonstrating that a large amount of parallelism exists in non-numeric computation. We plan to release the APEX APL Compiler, including the tokenizer, under the GNU Public License.