Opaque data type

Abstract: An apparatus, program product and method support the deallocation of a data structure in a multithreaded computer without requiring the use of computationally expensive semaphores or spin locks. Specifically, access to a data structure is governed by a shared pointer that, when a request is received to deallocate the data structure, is initially set to a value that indicates to any thread that later accesses the pointer that the data structure is not available. In addition, to address any thread that already holds a copy of the shared pointer, and thus is capable of accessing the data structure via the shared pointer after the initiation of the request, all such threads are monitored to determine whether any thread is still using the shared pointer by determining whether any thread is executing program code that is capable of using the shared pointer to access the data structure. Once this condition is met, it is ensured that no thread can potentially access the data structure via the shared pointer, and as such, the data structure may then be deallocated.

Abstract: The presence of pointer variables in high level programming languages constitutes an artifact originally introduced to support the representation of recursive data structures. Programming practice has come to rely on pointer variables for their originally intended use, and for several others as well. Their use adds to the complexity of stating algorithms by forcing one to conceptualize data representations in which storage addressing is made manifest. In addition, the use of pointer variables allows one to refer to a common data object by a multiplicity of names, a phenomenon we call the alias variable problem, Alias variables make the verification of program behavior substanially more difficult, and frustrate the goals of modular decomposition.In this paper, we consider alternatives to the use of pointer variables in programming. One of these alternatives is the inclusion of a class of data abstractions based on recursively defined data types. The representational power of the proposed data types is characterized formally, and some issues of implementation and efficiency of programs are discussed.

Abstract: If a program is structured using abstract data types as the basic unit of modularity, then that program is much easier to extend or modify. This thesis is illustrated by the staged development of a program to compute prime numbers based on the sieve of Eratosthenes. This paper includes an extensive introduction to the concept of abstract data types and can be used as a tutorial survey. It includes discussions on the use of abstract data types in connection with recent approaches to data abstractions, heirarchical structure, and program design. Abstract data types are an extension and modification of the traditional concept of data type. An abstract data type defines not only a data representation for objects of the type but also the set of operations that can be performed on objects of the type. Furthermore, the abstract data type can protect the data representation from direct access by other parts of the program.

Abstract: The concept of abstract data types has emerged from programming language research as a device to encourage and facilitate structured and modular programming [1]. It separates the abstraction of a data object from its implementation. The user of an abstract data type only concerns himself with the behavioral semantics of the type: what meaningful operations can be applied to objects of the type; the internal representation and structure of the type is unknown to him. In this way, irrelevent detail is suppressed and meaningfulness of programs enhanced.What application does this concept have to the area of data bases? There are some obvious similarities between the principle of abstraction and the concept of data independence of data bases [2]. Data independence means that application programs that utilize a data base do not need to know either the physical or the structural organization of the data base, but can relate to it purely on a logical plane. As with data abstractions, the goal is clarity and modifiability of programs, resulting from concentration on semantics rather than representation.