Shlomit S. Pinter

Using a model-based test generator to test for standard conformance

In this paper we describe two experiments in the verification of software standard conformance. In our experiments, we use a model-based test generator to create a test suite for parts of the POSIX™ standard and another test suite for the specification of Java™ exception handling. We demonstrate that models derived from specifications produce better test suites than the suites specified by standards. In particular, our test suites achieved higher levels of code coverage with complete test requirements coverage. Moreover, the test suite for the Java study found code defects that were not exposed by other benchmark test suites. The effort involved in producing these models and test suites was comparable to the effort involved in developing a test suite by more conventional methods. We avoid the state space explosion problem by modeling only the external behavior of a specific feature of the standard, without modeling the details of any particular implementation.

Improving machine virtualization with 'hotplug memory'

Machine virtualization has emerged as a key technology for server consolidation and on-demand server provisioning. To support this trend, it is essential to improve the performance of virtualization software and hence enable the efficient running of many virtual machines. We present a virtualization system that can dynamically extend the real memory of its guest virtual machines. We describe an implementation of dynamic memory extension for Linux guests running on the IBM zVM virtualization environment. Our implementation for the Linux extension is based on device drivers for accessing these dynamic memory extensions. Moreover, we show that this new capability can improve utilization and performance of the Linux guests in our virtualization environment. Specifically, memory management is improved and more virtual machines can run at a given moment. We study the utilization of dynamic memory extension of a Linux guest for a JVM heap. Running Specjbb2000 benchmark on a small virtual machine extended with dynamic memory to host the heap, we measured an improvement in transaction throughput and a 23.23% reduction in paging activity compared to an initially large machine. We further studied the implication of our experiments on the number of virtual machines that can run efficiently.

Improving machine virtualisation with 'hotplug memory'

Machine virtualisation is a key technology for server consolidation and on-demand server provisioning. To support this trend, it is essential to improve the performance of virtualisation software and enable the efficient running of many virtual machines. We present a virtualisation system that can dynamically extend the real memory of its guest virtual machines. We describe an implementation of dynamic memory extension for Linux guests running on the IBM zVM virtualisation environment. Our implementation utilises device drivers for accessing dynamic memory extensions. We show that this capability can improve utilisation and performance of the Linux guests in our virtualisation environment.

Handling sensed data in hostile environments

Systems that track sensed data trigger alerts based on the evaluation of some condition. In the presence of loss data a conservative condition may not generate a necessary alert and an aggressive condition may generate an alert that could have never happened. We observe that some lost values can be predicted and suggest new classes of conditions that provide more accurate alerts. We motivate the use of such conditions, provide a method for comparing two condition systems, and investigate the systems’ properties in both replicated and non replicated architectures. In addition, we propose a weak completeness property, discuss its merit and show a motivation for its use. Our main result shows that a triggering algorithm, used in one of our condition systems, strictly dominates another algorithm for conservative system, yet, both algorithms satisfy the same set of properties; thus, with some simple observations, we have a strong evidence for its optimality.

Profile-driven compression scheme for embedded systems

The extensive usage of embedded systems involves running complex applications that require tightly limited resources such as memory and storage. One efficient way to satisfy the resource requirements is to reduce the code size through code compression. Our work describes a software-based code compression scheme that reduces the storage space of a program, which in turn induces a reduction of access time to off-chip memory in SoC embedded architectures. To select those sections of code that are most advantageous for compression, our scheme utilizes profiling information to evaluate and trade off storage space reduction for future run-time overhead. During run-time, the compressed parts are decompressed as necessary into a run-time buffer for execution. Experimental results on the SPEC CPU2000 and MediaBench suites show reduction in code size averaging 18.5%, along with reasonable memory consumption overhead averaging 3.8%, and a reasonable run-time overhead averaging 7.8%.

Selective Code Compression Scheme for Embedded Systems

The extensive usage of embedded systems involves running complex applications that require tightly limited resources such as memory and storage. One efficient way to satisfy the resource requirements is to reduce the code size through code compression. Our work describes a software-based code compression scheme that reduces the storage space of a program, which in turn induces a reduction of access time to off-chip memory in SoC (System-on-a-chip) embedded architectures. To select those sections of code that are most advantageous for compression, our scheme utilizes profiling information to evaluate and trade off storage space reduction for future run-time overhead. During run-time, the compressed parts are decompressed as necessary into a run-time buffer for execution. Experimental results on the SPEC CPU2000 and MediaBench suites show reduction in code size averaging 18.5%, along with reasonable memory consumption overhead averaging 3.8%, and a reasonable run-time overhead averaging 7.8%.