Experimental evaluation of distributed middleware with a virtualized Java environment

Carvalho, Nuno; Bordalo, João; Campos, Filipe; Pereira, José

doi:10.1145/2093185.2093188

Cited by 6 publications

(11 citation statements)

References 14 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The approach of MINHA [4] is closer to CESIUM [1], which also accurately reflects the cost of executing real code in simulated resource usage. MINHA does however virtualize a significant part of a modern Java platform, thus providing unprecedented support for running off-the-shelf code.…”

Section: Related Workmentioning

confidence: 90%

“…Instead of building yet another simulator, we rely on the MINHA 1 platform [4] and extend it with capabilities to write distributed algorithms at a high abstraction level. Briefly, MINHA virtualizes multiple Java Virtual Machines (JVM) instances in a single JVM while simulating key environment components, reproducing the concurrency, distribution, and performance characteristics of a much larger distributed system.…”

Section: Introductionmentioning

confidence: 99%

“…The MINHA [4] framework is capable of virtualizing multiple JVM instances in a single JVM. It is able to do so simulating a real distributed environment by virtualizing the network, CPU scheduling and by virtualizing most of the standard Java APIs.…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Practical Evaluation of Large Scale Applications

Jorge

Maia

Matos

et al. 2015

Distributed Applications and Interoperable Systems

Self Cite

View full text Add to dashboard Cite

Abstract. Designing and implementing distributed systems is a hard endeavor, both at an abstract level when designing the system, and at a concrete level when implementing, debugging and evaluating it. This stems not only from the inherent complexity of writing and reasoning about distributed software, but also from the lack of tools for testing and evaluating it under realistic conditions. Moreover, the gap between the protocols' specifications found on research papers and their implementations on real code is huge, leading to inconsistencies that often result in the implementation no longer following the specification. As an example, the specification of the popular Chord DHT comprises a few dozens of lines, while its Java implementation, OpenChord, is close to twenty thousand lines, excluding libraries. This makes it hard and error prone to change the implementation to reflect changes in the specification, regardless of programmers' skill. Besides, critical behavior due to the unpredictable interleaving of operations and network uncertainty, can only be observed on a realistic setting, limiting the usefulness of simulation tools. We believe that being able to write an algorithm implementation very close to its specification, and evaluating it in a real environment is a big step in the direction of building better distributed systems. Our approach leverages the MINHA platform to offer a set of built in primitives that allows one to program very close to pseudo-code. This high level implementation can interact with off-the-shelf existing middleware and can be gradually replaced by a production-ready Java implementation. In this paper, we present the system design and showcase it using a well-known algorithm from the literature.

show abstract

Section: Related Workmentioning

confidence: 90%

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Practical Evaluation of Large Scale Applications

Jorge

Maia

Matos

et al. 2015

Distributed Applications and Interoperable Systems

Self Cite

View full text Add to dashboard Cite

show abstract

“…Afterwards, BUZZPSS uses the bold driver technique to adjust the learning rate (lines 7-11) and, finally, updates the values of prevAge and prevError for the subsequent iteration (lines [12][13]. It should be noted that Algorithm 1 is performed by each node individually.…”

Section: B Using Gradient Descent Explorationmentioning

confidence: 99%

“…If the error is higher than L, then the system is considered unstable (line 9) and BUZZPSS should adjust T using gradient descent. In other words, BUZZPSS performs Algorithm 1 (lines [8][9][10][11][12][13][14][15][16][17][18][19]. Otherwise, the system is considered stable for that iteration (line 22).…”

Section: Improving Bandwidth Efficiency By Rewarding Stabilitymentioning

confidence: 99%

BuzzPSS: A Dependable and Adaptive Peer Sampling Service

Machado

Maia

Matos

et al. 2016

2016 Seventh Latin-American Symposium on Dependable Computing (LADC)

View full text Add to dashboard Cite

A distributed system is often built on top of an overlay network. Overlay networks enable network topology transparency while, at the same time, can be designed to provide efficient data dissemination, load balancing, and even fault tolerance. They are constructed by defining logical links between nodes creating a node graph. In practice, this is materialized by a Peer Sampling Service (PSS) that provides references to other nodes to communicate with. Depending on the configuration of the PSS, the characteristics of the overlay can be adjusted to cope with application requirements and performance concerns.Unfortunately, overlay efficiency comes at the expense of dependability. To overcome this, one often deploys an application overlay focused on efficiency, along with a safety-net overlay to ensure dependability. However, this approach results in significant resource waste since safety-net overlays are seldom used.In this paper, we focus on safety-net overlay networks and propose an adaptable mechanism to minimize resource usage while maintaining dependability guarantees. In detail, we consider a random overlay network, known to be highly dependable, and propose BUZZPSS, a new Peer Sampling Service that is able to autonomously fine-tune its resource consumption usage according to the observed system stability. When the system is stable and connectivity is not at risk, BUZZPSS autonomously changes its behavior to save resources. Alongside, it is also able to detect system instability and act accordingly to guarantee that the overlay remains operational. Through an experimental evaluation, we show that BUZZPSS is able to autonomously adapt to the system stability levels, consuming up to 6x less resources than a static approach.

show abstract

On the replacement of objects from round-based applications over heterogeneous environments

Righi

Graebin

Costa

2014

Softw. Pract. Exper.

View full text Add to dashboard Cite

In recent years, there has been growing support for more tightly coupled applications regarding heterogeneous resources. A specific way of obtaining better performance in such applications is to consider the replacement of execution entities by newer resources during the application's lifetime. Therefore, this article describes the rationale for developing jMigBSP, which is a Java programming library that offers object rescheduling for round-based applications. In this context, the proposal addresses Bulk Synchronous Parallel (BSP) applications because BSP represents one of the most often used models for writing tightly coupled parallel programs. jMigBSP's main contribution examines the rescheduling facility in two different ways: (i) using migration directives in the application code directly; and (ii) through automatic load balancing at the middleware level. Specifically, this second idea is feasible because of Java's inheritance feature, which transforms a simple jMigBSP application into a migratable one by changing only a single line of code. In addition to the description of jMigBSP, this article emphasizes the benefits of using migration over heterogeneous environments by executing scientific applications. The results indicate gains of up to 56% with object rescheduling and support the feasibility of using migration as a load balancing technique. The migration of objects to different resources becomes increasingly important for tightly coupled applications because resource availability and application behavior can vary over time on grid environments. The use of a rescheduling technique enables on-the-fly load balancing to reduce the application's time. This dynamic rescheduling could transfer objects from overloaded to underloaded resources or reallocate objects with higher communications patterns in the same cluster. Rescheduling is especially important on long-running applications, which are characterized as CPU intensive, or on large-volume data transfers, because the newly optimized organization can be used at least to amortize the migration penalties [2].Currently, research in the rescheduling field includes the definition of unified metrics for acting in response to application and resource dynamics and user-friendly programming interfaces for providing both application's modeling and replacement facilities [8,9]. Technically, we can benefit from process migration either by modifying the application source code or by using migration-aware communication middleware [10]. The former represents an explicit approach, which usually consists of including migration directives or implementing receiver-initiated load balancing algorithms inside the application's code. The latter is commonly an extension of the programming library for providing a transparent and effortless migration mechanism from the user's point of view. Considering these characteristics, this last approach represents an implicit way of providing migration from the developer's perspective.In this regard, we could ask which is the best approach...

show abstract

Experimental evaluation of distributed middleware with a virtualized Java environment

Cited by 6 publications

References 14 publications

Practical Evaluation of Large Scale Applications

Practical Evaluation of Large Scale Applications

BuzzPSS: A Dependable and Adaptive Peer Sampling Service

On the replacement of objects from round-based applications over heterogeneous environments

Contact Info

Product

Resources

About