Object Pointers Research Articles

Type Information Elimination from Objects on Architectures with Tagged Pointers Support

Implementations of object-oriented programming languages associate type information with each object to perform various runtime tasks such as dynamic dispatch, type introspection, and reflection. A common means of storing such relation is by inserting a pointer to the associated type information into every object. Such an approach, however, introduces memory and performance overheads when compared with non-object-oriented languages. Recent 64-bit computer architectures have added support for tagged pointers by ignoring a number of bits - tag - of memory addresses during memory access operations and utilize them for other purposes; mainly security. This paper presents the first investigation into how this hardware support can be exploited by a Java Virtual Machine to remove type information from objects. Moreover, we propose novel hardware extensions to the address generation and load-store units to achieve low-overhead type information retrieval and tagged object pointers compression-decompression. The evaluation has been conducted after integrating the Maxine VM and the ZSim microarchitectural simulator. The results, across all the DaCapo benchmark suite, pseudo-SPECjbb2005, SLAMBench and GraphChi-PR executed to completion, show up to 26 and 10 percent geometric mean heap space savings, up to 50 and 12 percent geometric mean dynamic DRAM energy reduction, and up to 49 and 3 percent geometric mean execution time reduction with no significant performance regressions.

Object protection in distributed systems

With reference to a distributed system consisting of nodes connected by a local area network, we consider a salient aspect of the protection problem, the representation of access permissions and protection domains. We present a model of a protection system supporting typed objects. Possession of an access permission for a given object is certified by possession of an object pointer including the specification of a set of access rights. We associate an encryption key with each object and a password with each domain. Object pointers are stored in memory in a ciphertext form obtained by using the object key and including the value of the domain password. Each process is executed in a domain and can take advantage of a given object pointer only if this object pointer was encrypted by including the password of this domain. A set of protection primitives makes it possible to use object pointers for object reference and to control the movements of the objects across the network. The resulting protection environment is evaluated from a number of salient viewpoints, including ease of access right distribution and revocation, interprocess interaction and cooperation, protection against fraudulent actions of access right manipulation and stealing, storage overhead, and network traffic.

A scalable P2P platform for the knowledge grid

The knowledge grid needs to operate with a scalable platform to provide large-scale intelligent services. A key function of such a platform is to efficiently support various complex queries in a dynamic large-scale network environment. This paper proposes a platform to support index-based path queries by incorporating a semantic overlay with an underlying structured P2P network that provides object location and management services. Various distributed indexing structures can be dynamically formed by publishing, semantic objects as indexing nodes. Queries are forwarded along the chains of semantic object pointers to search for objects. We investigate the deployment of a scalable distributed trie index for broadcast queries on key strings, propose a decentralized load balancing method for solving the problem of uneven load distribution incurred by heterogeneity of loads and node capacities and by the distributed trie index, and give an approach for improving the availability of the semantic overlay and its trie index. Experiments demonstrate the scalability of the proposed platform.

Tapestry

No abstract available.

Modelling ecological interaction despite object-oriented modularity

Ecological modellers may be deterred from using object-oriented programming languages by reports of the inherent rigidity of the object-oriented formulation, giving rise to a poor representation of biotic interaction. Internal approaches of imitating relationships between the components of an ecological model bury the associated code inside the object declarations of one or more of these components. External approaches isolate a component's processes thereby maintaining the object's integrity, but at the cost of realism. Highlighted here is a frame-based technique that uses object pointers to reference the active components thereby allowing mimicry of interaction while maintaining individual object integrity.

Fast processing of an object‐oriented language by a low‐level parallel computer munap

AbstractSince bytecodes in Smalltalk‐80 are designed for stack machines, stack operations occupy half the total operations so that it is difficult to find low‐level parallelism. To perform fast processing with low‐level parallelism, we not only designed high‐level intermediate codes (I‐codes) which correspond to message passings on a one‐to‐one basis, but also introduced routines for determining multiple‐object pointers in parallel. We have developed both an I‐codes interpreter and a bytecodes interpreter on a low‐level parallel computer MUNAP and evaluated them.The results show that: the static number of I‐codes is close to that of bytecodes, but I‐codes halved the number of dynamic execution steps of bytecodes; the number of dynamic execution steps for basic cycles decreased from 30 percent for bytecodes to 17 percent for I‐codes so that the number of total execution steps was decreased 19 percent; the number of execution steps for determining object pointers was decreased 12 percent because 69 percent of the object pointers were determined in parallel; and compared with a single processor using bytecodes, the number of execution steps was 0.56 for bytecodes and 0.47 for I‐codes on MUNAP.

Virtual memory on a narrow machine for an object-oriented language

LOOM (Large Object-Oriented Memory) is a virtual memory implemented in software that supports the Smalltalk-80(™) programming language and environment on the Xerox Dorado computer. LOOM provides 8 billion bytes of secondary memory address space and is specifically designed to run on computers with a narrow word size (16-bit wide words). All storage is viewed as objects that contain fields. Objects may have an average size as small as 10 fields. LOOM swaps objects between primary and secondary memory, and addresses each of the two memories with a different sized object pointer. When objects are cached in primary memory, they are known only by their short pointers. On a narrow word size machine, the narrow object pointers in primary memory allow a program such as the Smalltalk-80 interpreter to enjoy a substantial speed advantage. Interesting design problems and solutions arise from the mapping between the two address spaces and the temporary nature of an object's short address. The paper explains why the unusual design choices in LOOM were made, and provides an interesting example of the process of designing an integrated virtual memory and storage management system.