Theorie"en voor het berekenen van algoritmen (met een samenvatting in het Nederlands) PROEFSCHRIFT ter verkrijging van de graad van doctor aan de Rijksuniversiteit te Utrecht op gezag van de Rector Magnificus, Prof. Dr. J.A. van Ginkel ingevolge het besluit van het College van Dekanen

Abstract. Implementations that load XML documents and give access to them via, e.g., the DOM, suffer from huge memory demands: the space needed to load an XML document is usually many times larger than the size of the document. A considerable amount of memory is needed to store the tree structure of the XML document. Here a technique is presented that allows to represent the tree structure of an XML document in an efficient way. The representation exploits the high regularity in XML documents by “compressing ” their tree structure; the latter means to detect and remove repetitions of tree patterns. The functionality of basic tree operations, like traversal along edges, is preserved in the compressed representation. This allows to directly execute queries (and in particular, bulk operations) without prior decompression. For certain tasks like validation against an XML type or checking equality of documents, the representation allows for provably more efficient algorithms than those running on conventional representations. 1

Symbolic tree data structures, or terms, are used in many computing systems. Although terms can be compressed by hand, using specialized algorithms, or using universal compression utilities, all of these approaches have drawbacks. We propose an approach which avoids these problems by using knowledge of term structure to obtain more accurate predictive models for term compression. We describe two models that predict child symbols based on their parents and locations. Our experiments compared these models with first-order Markov sequence models using Hu#man coding and found that one model can obtain 20% better compression in similar time, and the other, simpler model can obtain similar compression 40% faster. These compression models also approach, but do not exceed, the performance of gzip.

transPROSE is a comprehensive research project investigating techniques for transporting programs securely over potentially insecure channels. The central focus of this project is the development of a blueprint for a nextgeneration mobile-code distribution format. A problem of previous approaches to mobile-code security has been that the additional provisions for security lead to a loss of efficiency, often to the extent of making an otherwise virtuous security scheme unusable for all but trivial programs. Project transPROSE strives to deviate from the common approach of studying security in isolation and instead focuses simultaneously on multiple aspects of mobile-code quality. Besides security, such aspects include encoding density, speed of dynamic code generation, and the eventual execution performance. This paper gives a high-level overview of project transPROSE and presents initial results.

Abstract. k-ary trees are a fundamental data structure in many textprocessing algorithms (e.g., text searching). The traditional pointer-based representation of trees is space consuming, and hence only relatively small trees can be kept in main memory. Nowadays, however, many applications need to store a huge amount of information. In this paper we present a succinct representation for dynamic k-ary trees of n nodes, requiring 2n + nlog k + o(nlog k) bits of space, which is close to the information-theoretic lower bound. Unlike alternative representations where the operations on the tree can be usually computed in O(log n) time, our data structure is able to take advantage of asymptotically smaller values of k, supporting the basic operations parent and child in O(log k+log log n) time, which is o(log n) time whenever log k = o(log n). Insertions and deletions of leaves in the tree are supported log k in O((log k + log log n)(1 +)) amortized time. Our rep-log (log k+log log n) resentation also supports more specialized operations (like subtreesize, depth, etc.), and provides a new trade-off when k = O(1) allowing faster updates (in O(log log n) amortized time, versus the amortized time of O((log log n) 1+ǫ), for ǫ> 0, from Raman and Rao [21]), at the cost of slower basic operations (in O(log log n) time, versus O(1) time of [21]). 1

Dynamic compilation often comes at the price of reduced code quality, because there is not enough time available to perform expensive optimizations. One solution to this problem has been the addition of annotations by the code producer that enable a dynamic code generator on the code consumer 's side to shortcut certain analysis and optimization steps. However, code annotation often creates a new problem, in that most such annotations are unsafe|if they become corrupted during transit, then the safety of the target system is in jeopardy.

Introduction A large part of the data sent over the internet is (semi-) structured, examples are databases, html files, and javaScript programs. And a recent future-scenario about the internet predicted that future computer users will not buy their programs (editors, compilers, spreadsheets, etc.) anymore, but instead fetch their programs from the internet. Thus a considerable amount of internet traffic consists of files that possess structure, and it will pay to compress these structured files. Structure-specific compression methods give much better compression results than conventional compression methods such as the Unix compress utility [11, 10, 1]. For example, Unix compress typically requires four bits per byte of Pascal program code, whereas Cameron [2] reports compression results of one bit per byte Pascal program code. The basic idea of the structure-specific compression methods is simple: parse the input file into a structured value, separate structure from contents,

Mobile programs can potentially be malicious. To protect itself, a host that receives such mobile programs from an untrusted party or via an untrusted network connection will want some kind of guarantee that the mobile code is not about to cause any damage. The traditional solution to this problem has been verification, by which the receiving host examines the mobile program to discover all its actions even before starting execution. Unfortunately, aside from consuming computing resources in itself, verification inhibits traditional compiler optimizations, making such verifiable mobile code much less efficient than native code. We have found an alternative solution...

this paper can be used in the construction of an algorithm for coding a tree with respect to a dictionary of trees. This paper is organised as follows. Section 2 describes the edit model and the induced form of incremental algorithms. Section 3 specifies the problem of coding a text with respect to a dictionary, and Section 4 sketches a derivation of an incremental algorithm for this problem. 2 Incremental algorithms and the edit model

of a car (13 M triangles). Right: Close-up of the power plant (13 M triangles). Hierarchical mesh quantization achieves an average compression rate of 5.7: 1 in comparison to a BVH and an indexed face set. Path tracing with the compressed acceleration structure is only 17 % slower than using a fast uncompressed representation. With ray packets, the difference is even smaller: only 11 % on average. We present a lossily compressed acceleration structure for ray tracing that encodes the bounding volume hierarchy (BVH) and the triangles of a scene together in a single unified data structure. Total memory consumption of our representation is smaller than previous comparable methods by a factor of 1.7 to 4.8, and it achieves performance similar to the fastest uncompressed data structures. We store quantized vertex positions as local offsets to the leaf bounding box planes and encode them in bit strings. Triangle connectivity is represented as a sequence of strips inside the leaf nodes. The BVH is stored in a compact quantized format. We describe techniques for efficient implementation using register SIMD instructions (SSE). Hierarchical mesh quantization (HMQ) with 16 bits of accuracy achieves an average compression rate of 5.7: 1 in comparison to a BVH and an indexed face set. The performance impact is only 11 percent for packet tracing and 17 percent for single ray path tracing on average.