11 research outputs found
Deploying active objects onto multicore
The performance of a program on multicore platform crucially depends on the
scheduling of its tasks; existing high-level programming languages, however,
offer limited control over scheduling. In this thesis, we develop Cacoj as an
extensible tool set to transform Creol’s active concurrent objects into Java to
be deployed on multicore through standard Java Runtime Environment. The
concurrent object paradigm is a promising trend for multicore programming
because each object may conceptually encapsulate a processor. Cacoj introduces
a higher-level abstraction of concurrency API and a Creol compiler in which
the translated object in Java takes control over the scheduling of the incoming
messages through a per-object approach in contrast with current mainstream
trend. Cacoj brings about the required grounds to extend Creol syntax to
additionally specify different levels of priority and integrate them into the notion
of active concurrent objects
Formal Verification of Service Level Agreements Through Distributed Monitoring
In this paper, we introduce a formal model of the availability, budget compliance and sustainability of istributed services, where service sustainability is a new concept which arises as the composition of service availability and budget compliance. The model formalizes a distributed platform for monitoring the above service characteristics in terms of a parallel composition of task automata, where dynamically generated tasks model asynchronous events with deadlines. The main result of this paper is a formal model to optimize and reason about service characteristics through monitoring. In particular, we use schedulability analysis of the underlying timed automata to optimize and guarantee service sustainability
Programming and Deployment of Active Objects with Application-Level Scheduling
We extend and implement a modeling language based on
concurrent active objects with application-level scheduling
policies. The language allows a programmer to assign pri-
orities at the application level, for example, to method def-
initions and method invocations, and assign corresponding
policies to the individual active objects for scheduling the
messages. Thus, we leverage scheduling and performance
related issues, which are becoming increasingly important
in multi-core and cloud applications, from the underlying
operating system to the application level. We describe a
tool-set to transform models of active objects extended with
application-level scheduling policies into Java. This tool-set
allows a direct use of Java class libraries; thus, we obtain a
full-fledged programming language based on active objects
which allows for high-level control of deployment related is-
sues
Monitoring Method Call Sequences using Annotations
In this paper we introduce JMSeq, a Java-based tool for
the specification and runtime verification via monitoring of sequences of
possibly nested method calls. JMSeq provides a simple but expressive
way to specify the sequential execution of a Java program using code
annotations via user-given sequences of methods calls. Similar to many
monitoring-oriented environments, verification in JMSeq is done at run-
time, but differently from all other approaches based on aspect-oriented
programming, JMSeq does not use code instrumentation, and therefore
is suitable for component-based software verification
On the Integration of Automatic Deployment into the ABS Modeling Language
In modern software systems, deployment is an integral and critical part of application development (see, e.g., the DevOps approach to software development). Nevertheless, deployment is usually overlooked at the modeling level, thus losing the possibility to perform deployment conscious decisions during the early stages of development. In this paper, we address the problem of promoting deployment as an integral part of modeling, by focusing on the Abstract Behavioral Specification (ABS) language used for the specification of models of systems composed of concurrent objects consuming resources provided by deployment components. We extend ABS with class annotations expressing the resource requirements of the objects of that class. Then we define a tool that, starting from a high-level declaration of the desired system, computes a model instance of such system that optimally distributes objects over available deployment components
Towards Type-Based Optimizations in Distributed Applications Using ABS and JAVA 8
In this paper we present an API to support modeling applications with Actors based on the paradigm of the Abstract Behavioural Specification (ABS) language. With the introduction of JAVA 8, we expose this API through a JAVA library to allow for a high-level actor-based methodology for programming distributed systems which supports the programming to interfaces discipline. We validate this solution through a case study where we obtain significant performance improvements as well as illustrating the ease with which simple high and low-level optimizations can be obtained by examining topologies and communication within an application. Using this API we show it is much easier to observe drawbacks of shared data-structures and communications methods in the design phase of a distributed application and apply the necessary corrections in order to obtain better results
A design pattern for optimizations in data intensive applications using ABS and JAVA 8
Cloud environments have become a standard method for enterprises to offer their applications by means of web services, data management systems, or simply renting out computing resources. In our previous work, we presented how we can use a modeling language together with the new features of JAVA 8 to overcome certain drawbacks of data structures and synchronization mechanisms in parallel applications. We extend this solution into a design pattern that allows application-specific optimizations in a distributed setting. We validate this integration using our previous case study of the Prime Sieve of Eratosthenes and illustrate the performance improvements in terms of speed-up and memory consumption
A design pattern for optimizations in data intensive applications using ABS and JAVA 8
Cloud environments have become a standard method for enterprises to offer their applications by means of web services, data management systems, or simply renting out computing resources. In our previous work, we presented how we can use a modeling language together with the new features of JAVA 8 to overcome certain drawbacks of data structures and synchronization mechanisms in parallel applications. We extend this solution into a design pattern that allows application-specific optimizations in a distributed setting. We validate this integration using our previous case study of the Prime Sieve of Eratosthenes and illustrate the performance improvements in terms of speed-up and memory co
Monitoring method call sequences using annotations
In this paper we introduce JMSeq, a Java-based tool for monitoring sequences of method calls. JMSeq provides a simple but expressive language to specify the observables of a Java program in terms of sequences of possibly nested method calls. Similar to many monitoring-oriented environments, verification in JMSeq is done at run-time; unlike all other approaches based on aspect-oriented programming, JMSeq uses code annotation rather than instrumentation, and therefore is suitable for component-based software verification