Programming specialized network processors (NPU) is inherently difficult. Unlike mainstream processors where architectural features such as out-of-order execution and caches hide most of the complexities of efficient program execution, programmers of NPUs face a 'bare-metal' view of the architecture. They have to deal with a multithreaded environment with a high degree of parallelism, pipelining and multiple, heterogeneous, execution units and memory banks. Software development on such architectures is expensive. Moreover, different NPUs, even within the same family, differ considerably in their architecture, making portability of the software a major concern. At the same time expensive network processing applications based on deep packet inspection are both in-creasingly important and increasingly difficult to realize due to high link rates. They could potentially benefit greatly from the hardware features offered by NPUs, provided they were easy to use. We therefore propose to use more abstract programming models that hide much of the complexity of 'bare-metal' architectures from the programmer. In this paper, we present one such programming model: Ruler, a flexible high-level language for deep packet in-spection (DPI) and packet rewriting that is easy to learn, platform independent and lets the programmer concentrate on the functionality of the application. Ruler provides packet matching and rewrit-ing based on regular expressions. We describe our implementa-tion on the Intel IXP2xxx NPU and show how it provides versatile packet processing at gigabit line rates.

Abstract We present a set of language extensions that improve the expressiveness and performance of Java for scientific computation. The language extensions allow the manipulation of multi‐dimensional arrays to be expressed more naturally, and to be implemented more efficiently. Furthermore, data‐parallel programming is supported, allowing efficient parallelization of a large class of operations on arrays. We also provide language extensions to construct specialized array representations, such as symmetric, block, and sparse matrices. These extensions are: tuples, parameterized types, array subscript overloading, and the inline modifier. These extensions are not only useful in the construction of special array representations, but are also useful in their own right. Finally, we add complex numbers as a primitive type to the language. We evaluate our language extensions using performance results. We also compare relevant code fragments of our extended language with standard Java implementations and language extensions proposed by others. Copyright © 2003 John Wiley & Sons, Ltd.

We present Spar, a programming language for semi-automatic parallel programming, in particular for the programming of array-based applications. The language has been designed as part of the Automap project, in which a compiler and runtime system are being developed for distributed-memory systems. As suggested by its name, Automap aims at completely automatic code and data mapping at either compile time or runtime. This relieves the programmer of a difficult task, and makes Spar programs completely portable. Apart from a few minor modifications, Spar is a superset of Java. This provides Spar with a modern, solid, language as its basis, and makes Spar more accessible. Spar extends Java with constructs forparallel programming, extensive support for array manipulation, and a number of other powerful language extensions. © 1997 John Wiley & Sons, Ltd.

In this paper, we analyze the efficiency of three local enumeration and three storage compression schemes for cyclic(m) data distributions in High Performance Fortran (HPF).We show that for linear array access sequences, efficient enumeration and storage compression schemes can be derived.Furthermore, local enumeration and storage techniques are shown to be orthogonal, if the local storage compression scheme is collapsible.Performance figures of the methods are given for a number of different processors.

Data parallel languages, like High Performance Fortran (HPF), support the notion of distributed arrays. However, the implementation of such distributed array structures and their access on message passing computers is not straightforward. This holds especially for distributed arrays that are aligned to each other and given a block-cyclic distribution. In this paper, an implementation framework is presented for HPF distributed arrays on message passing computers. Methods are presented for efficient (in space and time) local index enumeration, local storage, and communication. Techniques for local set enumeration provide the basis for constructing local iteration sets and communication sets. It is shown that both local set enumeration and local storage schemes can be derived from the same equation. Local set enumeration and local storage schemes are shown to be orthogonal, i.e., they can be freely combined. Moreover, for linear access sequences generated by our enumeration methods, the local address calculations can be moved out of the enumeration loop, yielding efficient local memory address generation. The local set enumeration methods are implemented by using a relatively simple general transformation rule for absorbing ownership tests. This transformation rule can be repeatedly applied to absorb multiple ownership tests. Performance figures are presented for local iteration overhead, a simple communication pattern, and storage efficiency.