96 research outputs found
Revisiting Actor Programming in C++
The actor model of computation has gained significant popularity over the
last decade. Its high level of abstraction makes it appealing for concurrent
applications in parallel and distributed systems. However, designing a
real-world actor framework that subsumes full scalability, strong reliability,
and high resource efficiency requires many conceptual and algorithmic additives
to the original model.
In this paper, we report on designing and building CAF, the "C++ Actor
Framework". CAF targets at providing a concurrent and distributed native
environment for scaling up to very large, high-performance applications, and
equally well down to small constrained systems. We present the key
specifications and design concepts---in particular a message-transparent
architecture, type-safe message interfaces, and pattern matching
facilities---that make native actors a viable approach for many robust,
elastic, and highly distributed developments. We demonstrate the feasibility of
CAF in three scenarios: first for elastic, upscaling environments, second for
including heterogeneous hardware like GPGPUs, and third for distributed runtime
systems. Extensive performance evaluations indicate ideal runtime behaviour for
up to 64 cores at very low memory footprint, or in the presence of GPUs. In
these tests, CAF continuously outperforms the competing actor environments
Erlang, Charm++, SalsaLite, Scala, ActorFoundry, and even the OpenMPI.Comment: 33 page
Actors that Unify Threads and Events
There is an impedance mismatch between message-passing concurrency and virtual machines, such as the JVM. VMs usually map their threads to heavyweight OS processes. Without a lightweight process abstraction, users are often forced to write parts of concurrent applications in an event-driven style which obscures control flow, and increases the burden on the programmer. In this paper we show how thread-based and event-based programming can be unified under a single actor abstraction. Using advanced abstraction mechanisms of the Scala programming language, we implemented our approach on unmodified JVMs. Our programming model integrates well with the threading model of the underlying VM
libcppa - Designing an Actor Semantic for C++11
Parallel hardware makes concurrency mandatory for efficient program
execution. However, writing concurrent software is both challenging and
error-prone. C++11 provides standard facilities for multiprogramming, such as
atomic operations with acquire/release semantics and RAII mutex locking, but
these primitives remain too low-level. Using them both correctly and
efficiently still requires expert knowledge and hand-crafting. The actor model
replaces implicit communication by sharing with an explicit message passing
mechanism. It applies to concurrency as well as distribution, and a lightweight
actor model implementation that schedules all actors in a properly
pre-dimensioned thread pool can outperform equivalent thread-based
applications. However, the actor model did not enter the domain of native
programming languages yet besides vendor-specific island solutions. With the
open source library libcppa, we want to combine the ability to build reliable
and distributed systems provided by the actor model with the performance and
resource-efficiency of C++11.Comment: 10 page
Elastic Scalable Cloud Computing Using Application-Level Migration
middleware framework to support autonomous workload elas-ticity and scalability based on application-level migration as a reconfiguration strategy. While other scalable frameworks (e.g., MapReduce or Google App Engine) force application developers to write programs following specific APIs, COS provides scal-ability in a general-purpose programming framework based on an actor-oriented programming language. When all executing VMs are highly utilized, COS scales a workload up by migrating mobile actors over to newly dynamically created VMs. When VM utilization drops, COS scales the workload down by consolidating actors and terminating idle VMs. Application-level migration is advantageous compared to VM migration especially in hybrid clouds in which migration costs over the Internet are critical to scale out the workloads. We demonstrate the general purpose programming approach using a tightly-coupled computation. We compare the performance of autonomous (i.e., COS-driven) versus ideal reconfiguration, as well as the impact of granularity of reconfiguration, i.e., VM migration versus application-level migration. Our results show promise for future fully automated cloud computing resource management systems that efficiently enable truly elastic and scalable general-purpose workloads. I
Scalable Resource and QoS Brokering Mechanisms for Massively Multiplayer Online Games
Multiplayer online games have become an increasingly integral part of online entertainment.
With advances in social media, the number of players of these games is
increasing at a very rapid rate, which in some cases has been observed to be exponential.
This is when resource becomes a concern. In this thesis, I investigated several
challenges in developing and maintaining multiplayer games such as hotspots, genrespeci
c limitations, unpredictable quality of service and rigidity in resource availability.
I showed that these issues can be solved by adopting mechanisms for separation
of resource concerns from functional concerns and coordination of resources. To support
resource coordination, I divided the ownership of resources among three partiesgame
owner, resource owner and game player. I developed the CyberOrgs-MMOG
API, which supports Massively Multiplayer Online Game (MMOG) platforms capable
of resource sharing among multiple peers, through mechanisms for acquiring
these resources dynamically. I showed that dynamic acquisition of resources can
solve the resource questions mentioned above. The API was evaluated using a 2D
game with up to 250 simulated players. I also showed, how the game's responsiveness
can be dynamically adjusted in a scalable way. This thesis presents the design and
implementation of the CyberOrgs-MMOG API, interfaces provided to the interacting
agents representing di erent parties. I integrated a 2D multiplayer game with
the API and evaluated the mechanisms supported by the API
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
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
- …