A Quantitative Evaluation of the Contribution of Native Code to Java Workloads

Many performance analysis tools for Java focus on tracking executed bytecodes, but provide little support in determining the specific contribution of native code libraries. This paper introduces and assesses a portable approach for characterizing the amount of native code executed by Java applications. A profiling agent based on the JVM Tool Interface (JVMTI) accurately keeps track of all runtime transitions between bytecode and native code. It relies on a combination of JVMTI events, Java Native Interface (JNI) function interception, bytecode instrumentation, and hardware performance counters

TOWARDS CHANGE VALIDATION IN DYNAMIC SYSTEM UPDATING FRAMEWORKS

Dynamic Software Updating (DSU) provides mechanisms to update a program without stopping its execution. An indiscriminate update that does not consider the current state of the computation, potentially undermines the stability of the running application. Determining automatically a safe moment, the time that the updating process could be started, is still an open crux that usually neglected from the existing DSU systems. The program developer is the best one who knows the program semantics and the logical relations between two successive versions as well as the constraints which should be respected in order to proceed with the update. Therefore, a set of meta-data has been introduced that could be exploited to explain the constraints of the update. These constraints should be considered at the dynamic update time. Thus, a runtime validator has been designed and implemented to verify these constraints before starting the update process. The validator is independent of existing DSU systems and can be plugged into DSUs as a pre-update component. An architecture for validation has been proposed that includes the DSU, the running program, the validator, and their communications. Along with the ability to describe the restrictions by using meta-data, a method has been presented to extract some constraints automatically. The gradual transition from the old version to the new version requires that the running application frequently switches between executing old and new code for a transient period. Although this swinging execution phenomenon is inevitable, its beginning can be selected. Considering this issue, an automatic method has been proposed to determine which part of the code is unsafe to participate in the swinging execution. The method has been implemented as a static analyzer which can annotate the unsafe part of the code as constraints. This approach is demonstrated in the evolution of the various versions of three different long-running software systems and compared to other approaches. Although the approach has been evaluated by evolving various programs, the impact of different changes in the dynamic update is not entirely clear. In addition, the study of the effect of these changes can identify code smells on the program, regarding the dynamic update issue. For the first time, the code smells have been introduced that may cause a run-time or syntax error on the dynamic update process. A set of candidate error-prone patterns has been developed based on programming language features and possible changes for each item. This set of 75 patterns is inspected by three distinct DSUs to identify problematic cases as code smells. Additionally, error- prone patterns set can be exploited as a reference set by other DSUs to measure own flexibility

Vérification dynamique ciblée et interactive de programmes grâce à une architecture modulaire

Le cycle de développement d’une application contient plusieurs phases, de l’écriture au soutien technique suivant la publication. Une phase particulièrement importante est la vérification du programme. Il s’agit de vérifier que le programme produit répond à la spécification au sens large, c’est à dire qu’il présente le comportement prévu sans bogue, quel que soit le scénario et les entrées présentées. De nombreux outils sont disponibles pour assister l’utilisateur dans cette tâche. Parmi ceux-ci, on trouve les outils de vérification formelle qui permettent de modéliser le déroulement d’un programme et d’en prouver mathématiquement la validité. Les analyses statiques peinent cependant à vérifier des programmes complexes, et une autre famille d’outils est souvent nécessaire. Ce sont les outils dynamiques, qui vérifient l’intégrité du programme pendant son exécution. Dans ce domaine, on trouve surtout des outils spécialisés et efficaces, mais peu flexibles. En effet, en l’absence d’une structure commune, beaucoup d’outils réécrivent intégralement toutes les fonctionnalités de base, et ce coût de développement fait qu’ils se limitent souvent aux fonctionnalités strictement nécessaires. Peu d’outils proposent ainsi une instrumentation dynamique ou une interface graphique.----------ABSTRACT: The development cycle of an application covers multiple different stages, from code writing to technical support. One crucial phase is program verification and debugging. During this stage, the developers need to make sure that the program they deliver corresponds to both its explicit and implicit specification, meaning that it has to behave correctly and without any bug whatever input is given to it. Multiple tools exist to assist the developers. Among them, formal verification is a method which proves mathematically the validity of a program by modeling its behavior. However, this type of static analysis struggle to analyse properly complex programs, and developers often also rely on dynamic tools, which check the integrity of a running program. A large number of specialized tools exist in that domain, but they often go for a lean approach, with little flexibility and adaptability. This is partly due to the lack of a common framework for high performance runtime verification tools. Most tools have to reprogram every functionality from the ground up, which means they often limit their scope to what is strictly necessary to reduce development costs. Features such as dynamic instrumentation or even a graphical user interface are seldom available. As part of this research project, we propose a solution to this problem, taking example on the recent development in integrated development environments. The goal is to provide modularity in order to share underlying features as much as possible. This removes the need for rewriting those basic features and enables developers to focus on more advanced tasks, which in turn produces better verification tools

Optimisations de compilateur optimistes pour les systèmes réseaux

Cette thèse présente un ensemble de techniques qui permettent l’optimisation des performances des sysèmes réseaux modernes. Ces techniques reposent sur l’analyse et la transformation des programmes impliqués dans la mise en ´oeuvre des protocoles réseaux. La première de ces techniques fait appel à la spécialisation de programmes pour optimiser des piles de protocoles r´eseaux. La deuxième, que nous avons nomm´ee sp´ecialisation distante, permet à des systèmes embarqu´es limit´es en ressources de b´en´eficier de la sp´ecialisation de programmes en d´eportant à travers le r´eseau les op´erations de sp´ecialisation à une machine distante moins limit´ee. La troisième propose un nouvel allocateur de m´emoire qui optimise l’utilisation des caches mat´eriels faite par un serveur r´eseau. Enfin, la quatrième technique utilise l’analyse de programmes statiques pour int´egrer l’allocateur propos´e dans un serveur réseau existant. On appelle ces techniques optimisations compilateur parce qu’elles opèrent sur le flot des donn´ees et du controle dans des programmes en les transformant pour qu’ils fonctionnent plus efficacement.This dissertation describes techniques that can optimize the performance of modernday network systems. They are applied through the analysis and transformation of programs that implement network protocols. The first of these techniques involves the use of Program Specialization, a well-established code-optimization approach, to optimize network protocol stacks. The second, Remote Specialization makes specialization amenable to resource-limited embedded systems by deferring it over the network to a more capable system. The third technique revolves around a novel memory manager introduced in this thesis and optimizes a network server’s use of the underlying hardware caches. Finally, the fourth technique uses static analysis to integrate the proposed memory manager with an existing network server. All four techniques are implemented in a set of tools that can be used to automatically optimize network applications, and are referred to as compiler optimizations as they are based on program analysis and transformation

ARC Computing Element System Administrator Guide

The ARC Computing Element (CE) is an EMI product allowing submission and management of applications running on DCI computational resourc

Dynamic Reconfiguration with Virtual Services

We present a new architecture (virtual services) and accompanying implementation for dynamically adapting and reconfiguring the behavior of network services. Virtual services are a compositional middleware system that transparently interposes itself between a service and a client, overlaying new functionality with configurations of modules organized into processing chains. Virtual services allow programmers and system administrators to extend, modify, and reconfigure dynamically the behavior of existing services for which source code, object code, and administrative control are not available. Virtual service module processing chains are instantiated on a per connection or invocation basis, thereby enabling the reconfiguration of individual connections to a service without affecting other connections to the same service. To validate our architecture, we have implemented a virtual services software development toolkit and middleware server. Our experiments demonstrate that virtual services can modularize concerns that cut across network services. We show that we can reconfigure and enhance the security properties of services implemented as either TCP client-server systems, such as an HTTP server, or as remotely invocable objects, such as a Web service. We demonstrate that virtual services can reconfigure the following security properties and abilities: authentication, access control, secrecy/encryption, connection monitoring, security breach detection, adaptive response to security breaches, concurrent and dynamically mutable implementation of multiple security policies for different clients

A linguistic approach to concurrent, distributed, and adaptive programming across heterogeneous platforms

Two major trends in computing hardware during the last decade have been an increase in the number of processing cores found in individual computer hardware platforms and an ubiquity of distributed, heterogeneous systems. Together, these changes can improve not only the performance of a range of applications, but the types of applications that can be created. Despite the advances in hardware technology, advances in programming of such systems has not kept pace. Traditional concurrent programming has always been challenging, and is only set to be come more so as the level of hardware concurrency increases. The different hardware platforms which make up heterogeneous systems come with domain-specific programming models, which are not designed to interact, or take into account the different resource-constraints present across different hardware devices, motivating a need for runtime reconfiguration or adaptation. This dissertation investigates the actor model of computation as an appropriate abstraction to address the issues present in programming concurrent, distributed, and adaptive applications across different scales and types of computing hardware. Given the limitations of other approaches, this dissertation describes a new actor-based programming language (Ensemble) and its runtime to address these challenges. The goal of this language is to enable non-specialist programmers to take advantage of parallel, distributed, and adaptive programming without the programmer requiring in-depth knowledge of hardware architectures or software frameworks. There is also a description of the design and implementation of the runtime system which executes Ensemble applications across a range of heterogeneous platforms. To show the suitability of the actor-based abstraction in creating applications for such systems, the language and runtime were evaluated in terms of linguistic complexity and performance. These evaluations covered programming embedded, concurrent, distributed, and adaptable applications, as well as combinations thereof. The results show that the actor provides an objectively simple way to program such systems without sacrificing performance

Extempore: The design, implementation and application of a cyber-physical programming language

There is a long history of experimental and exploratory programming supported by systems that expose interaction through a programming language interface. These live programming systems enable software developers to create, extend, and modify the behaviour of executing software by changing source code without perceptual breaks for recompilation. These live programming systems have taken many forms, but have generally been limited in their ability to express low-level programming concepts and the generation of efficient native machine code. These shortcomings have limited the effectiveness of live programming in domains that require highly efficient numerical processing and explicit memory management. The most general questions addressed by this thesis are what a systems language designed for live programming might look like and how such a language might influence the development of live programming in performance sensitive domains requiring real-time support, direct hardware control, or high performance computing. This thesis answers these questions by exploring the design, implementation and application of Extempore, a new systems programming language, designed specifically for live interactive programming