1,173 research outputs found
Optimization Coaching for JavaScript
The performance of dynamic object-oriented programming languages such as JavaScript depends heavily on highly optimizing just-in-time compilers. Such compilers, like all compilers, can silently fall back to generating conservative, low-performance code during optimization. As a result, programmers may inadvertently cause performance issues on users\u27 systems by making seemingly inoffensive changes to programs. This paper shows how to solve the problem of silent optimization failures. It specifically explains how to create a so-called optimization coach for an object-oriented just-in-time-compiled programming language. The development and evaluation build on the SpiderMonkey JavaScript engine, but the results should generalize to a variety of similar platforms
Structuring fault-tolerant object-oriented systems using inheritance and delegation
PhD ThesisMany entities in the real world that a software system has to interact with, e.g.,
for controlling or monitoring purposes, exhibit different behaviour phases in their
lifetime, in particular depending on whether or not they are functioning correctly.
That is, these entities exhibit not only a normal behaviour phase but also one or
more abnormal behaviour phases associated with the various faults which occur
in the environment. These faults are referred to as environmental faults. In the
object-oriented software, real-world entities are modeled as objects. In a classbased
object-oriented language, such as C++, all objects of a given class must
follow the same external behaviour, i.e., they have the same interface and associated
implementation. However this requires that each object permanently belong
to a particular class, imposing constraints on the mutability of the behaviour for
an individual object. This thesis proposes solutions to the problem of finding
means whereby objects representing real-world entities which exhibit various behaviour
phases can make corresponding changes in their own behaviour in a clear
and explicit way, rather than through status-checking code which is normally
embedded in the implementation of various methods.
Our proposed solution is (i) to define a hierarchy of different subclasses related to
an object which corresponds to an external entity, each subclass implementing a
different behaviour phase that the external entity can exhibit, and (ii) to arrange
that each object forward the execution of its operations to the currently appropriate
instance of this hierarchy of subclasses. We thus propose an object-oriented
approach for the provision of environmental fault tolerance, which encapsulates
the abnormal behaviour of "faulty" entities as objects (instances of the above
mentioned subclasses). These abnormal behaviour variants are defined statically,
and runtime access to them is implemented through a delegation mechanism which
depends on the current phase of behaviour. Thus specific reconfiguration changes
at the level of objects can be easily incorporated to a software system for tolerating
environmental faults
Link-time smart card code hardening
This paper presents a feasibility study to protect smart card software against fault-injection attacks by means of link-time code rewriting. This approach avoids the drawbacks of source code hardening, avoids the need for manual assembly writing, and is applicable in conjunction with closed third-party compilers. We implemented a range of cookbook code hardening recipes in a prototype link-time rewriter and evaluate their coverage and associated overhead to conclude that this approach is promising. We demonstrate that the overhead of using an automated link-time approach is not significantly higher than what can be obtained with compile-time hardening or with manual hardening of compiler-generated assembly code
Formal verification of AI software
The application of formal verification techniques to Artificial Intelligence (AI) software, particularly expert systems, is investigated. Constraint satisfaction and model inversion are identified as two formal specification paradigms for different classes of expert systems. A formal definition of consistency is developed, and the notion of approximate semantics is introduced. Examples are given of how these ideas can be applied in both declarative and imperative forms
- …