Sequential Object-oriented Programs Research Articles

An analytical model for source code distributability verification

One way to speed up the execution of sequential programs is to divide them into concurrent segments and execute such segments in a parallel manner over a distributed computing environment. We argue that the execution speedup primarily depends on the concurrency degree between the identified segments as well as communication overhead between the segments. To guarantee the best speedup, we have to obtain the maximum possible concurrency degree between the identified segments, taking communication overhead into consideration. Existing code distributor and multi-threading approaches do not fulfill such requirements; hence, they cannot provide expected distributability gains in advance. To overcome such limitations, we propose a novel approach for verifying the distributability of sequential object-oriented programs. The proposed approach enables users to see the maximum speedup gains before the actual distributability implementations, as it computes an objective function which is used to measure different distribution values from the same program, taking into consideration both remote and sequential calls. Experimental results showed that the proposed approach successfully determines the distributability of different real-life software applications compared with their real-life sequential and distributed implementations.

Optimistic parallelism based on speculative asynchronous message passing

This article proposes a new speculative multi-threading execution model for object-oriented programs. Using this model, sequential object-oriented programs are partitioned into multiple speculative object threads according to their structure and semantics by compiler and runtime system. Object threads that serve as the basic unit of the parallel target code are dynamically mapped onto thread units of the target machine. However, synchronous message passing between objects in a source program prevents parallel execution of object threads in the target code at synchronous points. By speculating the execution of message passing in object-oriented programs, we can convert synchronous message passing into speculative asynchronous message passing. This enables us to decrease synchronization overhead in runtime and to exploit greater parallelism for such programs. The runtime system verifies speculative asynchronous message passing by comparing it with non-speculative synchronous message passing so that parallel execution remains predictable and deterministic. This model was implemented as a prototype system, Rope, for evaluation. Experiments with a Java version of the Olden benchmark suite showed that the proposed model exhibits excellent accelerating effects for object-oriented programs.

Specification and verification challenges for sequential object-oriented programs

Abstract The state of knowledge in how to specify sequential programs in object-oriented languages such as Java and C# and the state of the art in automated verification tools for such programs have made measurable progress in the last several years. This paper describes several remaining challenges and approaches to their solution.

Towards verification of C# programs: A three-level approach

In the paper, a new three-level approach to the verification of sequential object-oriented programs is presented. It is applied to an expressive subset C#-light of the C# language, which includes all basic sequential constructs of the latter. At the first stage, the C#-light language is translated into the intermediate C#-kernel language. At the second stage, lazy correctness conditions are generated by means of the axiomatic semantics developed for C#-kernel. These conditions are lazy because they may include special functional symbols representing postponed extraction of invariants of labeled statements, as well as postponed invocations of methods and delegates. At the third stage, these conditions are refined with the use of operational semantics algorithms. Such an approach simplifies the axiomatic semantics and makes it possible to uniquely derive correctness conditions. An example of verification of a C#-light program is presented.

Preventing Timing Leaks Through Transactional Branching Instructions

Timing channels constitute one form of covert channels through which programs may be leaking information about the confidential data they manipulate. Such timing channels are typically eliminated by design, employing ad-hoc techniques to avoid information leaks through execution time, or by program transformation techniques, that transform programs that satisfy some form of noninterference property into programs that are time-sensitive termination-sensitive non-interfering. However, existing program transformations are thus far confined to simple languages without objects nor exceptions.We introduce a program transformation that uses transaction mechanisms to prevent timing leaks in sequential object-oriented programs. Under some strong but reasonable hypotheses, the transformation preserves the semantics of programs and yields for every termination-sensitive noninterfering program a time-sensitive termination-sensitive non-interfering program.