Ahmed Gheith

Mambo: a full system simulator for the PowerPC architecture

Mambo is a full-system simulator for modeling PowerPC-based systems. It provides building blocks for creating simulators that range from purely functional to timing-accurate. Functional versions support fast emulation of individual PowerPC instructions and the devices necessary for executing operating systems. Timing-accurate versions add the ability to account for device timing delays, and support the modeling of the PowerPC processor microarchitecture. We describe our experience in implementing the simulator and its uses within IBM to model future systems, support early software development, and design new system software.

CHAOS arc : kernel support for multiweight objects, invocations, and atomicity in real-time multiprocessor applications

CHAOS<supscrpt>arc</supscrpt> is an object-based multiprocessor operating system kernel that provides primitives with which programmers may easily construct objects of differing types and object invocations of differing semantics, targeting multiprocessor systems, and real-time applications. The CHAOS<supscrpt>arc</supscrpt> can <italic>guarantee</italic> desired performance and functionality levels of selected computations in real-time applications. Such guarantees can be made despite possible uncertainty in execution environments by allowing programs to <italic>adapt</italic> in performance and functionality to varying operating conditions. This paper reviews the primitives offered by CHAOS<supscrpt>arc</supscrpt> and demonstrates how the required elements of the CHAOS<supscrpt>arc</supscrpt> real-time kernel are constructed with those primitives.

Application of full-system simulation in exploratory system design and development

This paper describes the design and application of a full-system simulation environment that has been widely used in the exploration of the IBM PowerPC® processor and system design. The IBM full-system simulator has been developed to meet the needs of hardware and software designers for fast, accurate, execution-driven simulation of complete systems, incorporating parameterized architectural models. This environment enables the development and tuning of production-level operating systems, compilers, and critical software support well in advance of hardware availability, which can significantly shorten the critical path of system development. The ability to develop early versions of software can benefit hardware development by identifying design issues that may affect functionality and performance far earlier in the development cycle, when they are much less costly to correct. In this paper, we describe features of the simulation environment and present examples of its application in the context of the Sony-Toshiba-IBM Cell Broadband EngineTM and IBM PERCS development projects.

KTK: kernel support for configurable objects and invocations

The Kernel Tool Kit (KTK) is an object-based operating system kernel and parallel programming library that offers explicit support for on- and off-line program configuration. Specifically, KTK allows the specification of attributes for object classes, object instances, state variables, operations and object invocations. Attributes are interpreted by policy classes that may be varied separately from the abstractions with which they are associated. They can be used to vary object internal implementation and semantics without affecting the methods being invoked. In this paper, the runtime configuration of KTK attributes is shown to improve the runtime performance of multiprocessor applications. KTK is layered on a portable and configurable parallel programming substrate, a Mach Cthreads compatible runtime library/spl lsqb/22/spl rsqb/. >

IBM Bluemix Mobile Cloud Services

The Mobile Cloud Services offering of IBM Bluemix® is a platform for cloud-based mobile applications, providing data and file storage, application authentication, push notifications, and server-side application logic, all available through easy-to-use client software development kits (SDKs). In this paper, we describe the server-side architecture for the key components of the Mobile Cloud Services. For scalability and fault resilience, components are implemented as stateless services that communicate using a distributed message queue. We adopted a “design for failure” approach to all environmental services, including basic networking support. We developed a robust communications layer that adds timeout and retry logic to all external interactions. We also built a flexible and robust application-monitoring infrastructure to constantly probe the service components, test end-to-end functionality, and report any problems through web monitors and text messages. Finally, we designed and delivered client SDKs for Android®, iOS®, and JavaScript® that enable application developers to quickly create robust mobile applications that utilize IBM Mobile Cloud Services. These architecture and implementation choices have resulted in a robust and scalable cloud-based platform for mobile application developers.

Real-time threads

Portability is an important attribute of real-time operating systems because their target hardware environments routinely vary from special purpose processors to parallel machines to distributed execution environments. In this paper, we address the issue of operating systems portability by development of a real-time threads package based on the Mach cthreads interface. Real-time threads have been implemented on standard Unix platforms and on a 32-node BBN Butterfly multiprocessor. In contrast to cthreads, the schedulability of real-time threads may be determined dynamically at the time of threads creation. In addition, any scheduling guarantees made at thread creation time are maintained when threads communicate or cooperate using the packages other primitives.

Automatic Problem Localization via Multi-dimensional Metric Profiling

Debugging todays large-scale distributed applications is complex. Traditional debugging techniques such as breakpoint-based debugging and performance profiling require a substantial amount of domain knowledge and do not automate the process of locating bugs and performance anomalies. We present Orion, a framework to automate the problem-localization process in distributed applications. From a large set of metrics, Orion intelligently chooses important metrics and models the applications runtime behavior through pair wise correlations of those metrics in the system, within multiple non-overlapping time windows. When correlations deviate from those of a learned correct model due to a bug, our analysis pinpoints the metrics and code regions (class and method within it) that are most likely associated with the failure. We demonstrate our framework with several real-world failure cases in distributed applications such as: HBase, Hadoop DFS, a campus-wide Java application, and a regression testing framework from IBM. Our results show that Orion is able to pinpoint the metrics and code regions that developers need to concentrate on to fix the failures.

Solutions and debugging for data consistency in multiprocessors with noncoherent caches

We analyze two important problems that arise in shared-memory multiprocessor systems. Thestale data problem involves ensuring that data items in local memory of individual processors are current, independent of writes done by other processors.False sharing occurs when two processors have copies of the same shared data block but update different portions of the block. The false sharing problem involves guaranteeing that subsequent writes are properly combined. In modern architectures these problems are usually solved in hardware, by exploiting mechanisms for hardware controlled cache consistency. This leads to more expensive and nonscalable designs. Therefore, we are concentrating on software methods for ensuring cache consistency that would allow for affordable and scalable multiprocessing systems. Unfortunately, providing software control is nontrivial, both for the compiler writer and for the application programmer. For this reason we are developing a debugging environment that will facilitate the development of compiler-based techniques and will help the programmer to tune his or her application using explicit cache management mechanisms. We extend the notion of a race condition for IBM Shared Memory System POWER/4, taking into consideration its noncoherent caches, and propose techniques for detection of false sharing problems. Identification of the stale data problem is discussed as well, and solutions are suggested.

Lilliput meets brobdingnagian: Data center systems management through mobile devices

In this paper, we put forward the notion that systems management for large masses of virtual machines in data centers is going to be done differently in the short to medium term future-through smart phones and through controlled crowdsourcing to a variety of experts within an organization, rather than dedicated system administrators alone. We lay out the research and practitioner challenges this model raises and give some preliminary solution directions that are being developed, here at IBM and elsewhere.

Experiences with Dynamic Binary Translation in a Full System Simulator

In this paper we describe our experiences with a new full-system simulator for the Power™ architecture that achieves a high-level of simulation performance through careful design and the application of dynamic binary translation. Our simulator is written entirely in Java and can run simple applications and also boot whole operating systems. We chose Java because it has a wide developer base, portability, support for modern programming features such as inheritance, ease of scripting, built in serialization, and a broad selection of robust developer tools. To improve simulation performance, we treat the byte code for our instruction interpreter as an intermediate representation to drive dynamic binary translation. When running as a pure instruction interpreter, the simulator can achieve simulation speeds of over 100 MIPS. For simple applications, dynamic binary translation can improve simulation performance by a factor of 2 or more, to over 200 MIPS. We continue to work on dynamic binary translation for booting a full operating system, and we are also exploring dynamic translation of Java byte code directly to host object code.