Some separation results between classes of pointer algorithms (original) (raw)

Lower Bounds for Accessing Information on Pure Pointer Machines

FCS, 2009

We study the complexity of accessing bits on a Pure Pointer Machine (PPM) or a pointer machine without arithmetic capabilities. In particular, we show that lower bounds in access time for information retrieval on a PPM arise from two independent factors: the complexity of information being stored and the amount of antisymmetry in the information. This result contrasts with earlier work by Ben-Amram and Galil that showed that for pointer machines with arithmetic capabilities look-up time depends only on the complexity of the information stored. We then demonstrate the use of these bounds to show optimal look-up times for comparing elements in partial and total orders on a PPM.

On pointers versus addresses

Journal of the ACM, 1992

What is the cost of random access to memory? This fundamental problem M addressed by studying the simulation of random addressing by a machine that lacks it, a "pointer machine.'" The problem is formulated in the context of high-level computational models, allowing the use of a data type of our choice, A RAM program of time tand space s can be simulated m 0(f log .s) time using a tree. To enable a lower-bound proof, we formalize a notion of incompressibility for general data types. The main theorem states that for all incompressible data types an Ll(f log s) lower bound holds. Incompressibility trivially holds for strings, but is harder to prove for a powerful data type. Incompressibility is proved for the real numbers with a set of primitives that includes all functions that are continuous except on a countable closed set. This may be the richest set of operations considered m a lower-bound proof. It is also shown that the integers with arithmetic +,-, x and [ .x/2~, any Boolean operations, and left shift are incompressible. Tbe situation is reversed once right shift is allowed.

The Communication Complexity of Pointer Chasing

Journal of Computer and System Sciences, 2001

We study the k-round two-party communication complexity of the pointer chasing problem for fixed k. C. Damm, S. Jukna and J. Sgall (1998, Comput. Complexity 7, 109 127) showed an upper bound of O(n log (k&1) n) for this problem. We prove a matching lower bound; this improves the lower bound of 0(n) shown by N. Nisan and A. Widgerson (1993, SIAM J. Comput. 22, 211 219), and yields a corresponding improvement in the hierarchy results derived by them and by H. Klauck (1998, in``Proceeding of the Thirteenth Annual IEEE Conference on Computational Complexity,'' pp. 141 152) for bounded-depth monotone circuits. We consider the bit version of this problem, and show upper and lower bounds. This implies that there is an abrupt jump in complexity, from linear to superlinear, when the number of rounds is reduced to kÂ2 or less. We also consider the s-paths version (originally studied by H. Klauck) and show an upper bound. The lower bounds are based on arguments using entropy. One of the main contributions of this work is a transfer lemma for distributions with high entropy; this should be of independent interest.

Abstractions for recursive pointer data structures

Proceedings of the ACM SIGPLAN 1992 conference on Programming language design and implementation - PLDI '92, 1992

Even though impressive progress has been made in the area of optimizing and parallelizing programs with arrays, the application of similar techniques to programs with pointer data structures has remained di cult. In this paper we introduce a new approach that leads to improved analysis and transformation of programs with recursively-de ned pointer data structures. Our approach is based on a mechanism for the Abstract Description of Data Structures (ADDS), which makes explicit the important properties, such as dimensionality, of pointer data structures. Numerous examples demonstrate that ADDS de nitions are both natural to specify and exible enough to describe complex, cyclic pointer data structures. We discuss how an abstract data structure description can improve program analysis by presenting an analysis approach that combines an alias analysis technique, path matrix analysis, with information available from an ADDS declaration. Given this improved alias analysis technique, we provide a concrete example of applying a software pipelining transformation to loops involving pointer data structures.

Exploiting Locality and Parallelism in Pointer-based Programs

While powerful optimization techniques are currently available for limited automatic com-pilation domains, such as dense array-based scientific and engineering numerical codes, a similar level of success has eluded general-purpose programs, specially symbolic and pointer-based codes. Current compilers are not able to successfully deal with parallelism in those codes. Based on our previously developed shape analysis techniques, we have designed preliminary methods to tackle the parallelism detection in those types of codes. As with parallelism, contemporary compilers cannot either successfully exploit locality exhibited in pointer-based programs. The locality problem comprises several aspects. In this paper we address two of the main aspects: data locality in cache hierarchy, and hiding of the processor-memory latency gap.

Towards a Versatile Pointer Analysis Framework

Lecture Notes in Computer Science, 2006

Current pointer analysis techniques fail to find parallelism in heap accesses. However, some of them are still capable of obtaining valuable information about the way dynamic memory is used in pointerbased programs. It would be desirable to have a unified framework with a broadened perspective that can take the best out of available techniques and compensate for their weaknesses. We present an early view of such a framework, featuring a graph-based shape analysis technique. We describe some early experiments that obtain detailed information about how dynamic memory arranges in the heap. Furthermore, we document how defuse information can be used to greatly optimize shape analysis.

Putting pointer analysis to work

1998

This paper addresses the problem of how to apply pointer analysis to a wide variety of compiler applications. We are not presenting a new pointer analysis. Rather, we focus on putting two existing pointer analyses, points-to analysis and connection analysis, to work.

A characterization of heaps and its applications

Information and Computation, 1990

In this paper we present a new' view of a classical data structure, the heap. We view a heap on n elements as an ordered collection of rlogz(n + l)] substructures of sizes 2'with i in {0,. .. . Llog,(n)]}. W e use the new view in the design of an algorithm ,for splitting a heap on n elements into two heaps on k and n-k elements, respectively. The algorithm requires O(log*(n)) comparisons, improving the previous bound of O(k) comparisons for all but small values of k, i.e., for k > log'(n). We also present a new and conceptually simple algorithm for merging heaps of sizes n and k into one heap of size n + k in O(log(n) *log(k)) comparisons.