Orlando Loques

A dynamic optimization model for power and performance management of virtualized clusters

An increasing number of large-scale server clusters are being deployed in data centers for supporting many different web-based application services in a seamless fashion. In this scenario, the rising energy costs for keeping up those web clusters is becoming an important concern for many business. In this paper we present an optimization solution for power and performance management in a platform running multiple independent web applications. Our approach assumes a virtualized server environment and includes an optimization model and strategy to dynamically manage the cluster power consumption, while meeting the applications workload demands.

Intelligent context-aware monitoring of hypertensive patients

We present a decision-level data fusion technique for monitoring and reporting critical health conditions of a hypertensive patient at home. Variables associated to the patient (physiological and behavioral) and to the living environment are considered in the solution, contributing to improve the confidence on the system outputs. In the paper, we model the problem variables as fuzzy, aiming to capture their intrinsic essence, and draw rules based on medical recommendations to identify the health condition of the patient. This initiative move towards to build an abstract framework for context-aware telemonitoring applications. We also describe the relevant components of the framework and provide an initial evaluation of its decision component. Our results demonstrate that a principled choice of rules and variables may lead to a consistent identification of critical patients conditions.

Java for high‐performance network‐based computing: a survey

There has been an increasing research interest in extending the use of Java towards high‐performance demanding applications such as scalable Web servers, distributed multimedia applications, and large‐scale scientific applications. However, extending Java to a multicomputer environment and improving the low performance of current Java implementations pose great challenges to both the systems developer and application designer. In this survey, we describe and classify 14 relevant proposals and environments that tackle Javas performance bottlenecks in order to make the language an effective option for high‐performance network‐based computing. We further survey significant performance issues while exposing the potential benefits and limitations of current solutions in such a way that a framework for future research efforts can be established. Most of the proposed solutions can be classified according to some combination of three basic parameters: the model adopted for inter‐process communication, language extensions, and the implementation strategy. In addition, where appropriate to each individual proposal, we examine other relevant issues, such as interoperability, portability, and garbage collection. Copyright

P-RIO: a modular parallel-programming environment

The authors discuss the development of their Parallel Reconfigurable Interconnectable Object (P-RIO) environment, which offers a graphical programming tool, modular construction, high portability, a separate configuration language, and runtime support mechanisms for parallel programs. P-RIO provides a middleware-based environment for parallel and distributed programming. Its object-based, software construction methodology facilitates modularity and code reuse, allowing engineers and scientists with little training to build relatively complex programs.

A framework for dynamic adaptation of power-aware server clusters

This paper presents a framework to support dynamic adaptation of applications, which consists of a reusable infrastructure with standard elements to monitor and adapt running applications, and a contract-based adaptation language to enable one to express high-level adaptation policies. The proposed framework is used to introduce dynamic adaptation capabilities into a server cluster infrastructure, intended to address power and performance management concerns. By experimental evaluation, we demonstrate that our approach is useful and effective in providing the required support for describing and deploying typical power management contracts.

A decision-making mechanism for context inference in pervasive healthcare environments

This paper presents a Fuzzy approach to health-monitoring of patients in pervasive computing environments. A decision model considers three classes of variables that represent the context information being collected: environmental, physiological, and behavioral. A case study of blood pressure monitoring was developed to identify critical situations based on medical knowledge. The solution maintains the interpretability of the decision rules, even after a learning phase which may propose adjustments in these rules. In this phase, the Fuzzy c-Means clustering was chosen to adjust membership functions, using the cluster centers. A medical team evaluated data from 24-h monitoring of 30 patients and the rating was compared with the results of the system. The proposed approach proved to be individualized, identifying critical events in patients with different levels of blood pressure with an accuracy of 90% and low number of false negatives.

Dynamic optimization of power and performance for virtualized server clusters

In this paper we present an optimization solution for power and performance management in a platform running multiple independent applications. Our approach assumes a virtualized server environment and includes an optimization model and strategy to dynamically control the cluster power consumption, while meeting the applications workload demands.

A contract-based approach to describe and deploy non-functional adaptations in software architectures

This paper presents a comprehensive approach to describe, deploy and adapt component-based applications having dynamic non-functional requirements. The approach is centered on high-level contracts associated to architectural descriptions, which allow the non-functional requirements to be handled separately during the system, design process. This helps to achieve separation of concerns facilitating the reuse of modules that implement the application in other systems. Besides specifying non-functional requirements, contracts are used at runtime to guide configuration adaptations required to enforce these requirements. The infrastructure required to manage the contracts follows an architectural pattern, which can be directly mapped to specific components included in a supporting reflective middleware. This allows designers to write a contract and to follow standard recipes to insert the extra code required to its enforcement in the supporting middleware.

Energy-Efficient Thread Assignment Optimization for Heterogeneous Multicore Systems

The current trend to move from homogeneous to heterogeneous multicore systems provides compelling opportunities for achieving performance and energy efficiency goals. Running multiple threads in multicore systems poses challenges on meeting limited shared resources, such as memory bandwidth. We propose an optimization approach that includes an Integer Linear Programming (ILP) optimization model and a scheme to dynamically determine thread-to-core assignment. We present simulation analysis that shows energy savings and performance gains for a variety of workloads compared to state-of-the-art schemes. We implemented and evaluated a prototype of our thread assignment approach at user level, leveraging Linux scheduling and performance-monitoring capabilities.

Customizing Component-Based Architectures by Contract

This paper presents an approach to describe, deploy and manage component-based applications having dynamic functional and non-functional requirements. The approach is centered on architectural descriptions and associated high-level contracts. The latter allow the non-functional requirements to be described separately at design time, and during the running time are used to guide architecture customizations required to enforce these requirements. This helps to achieve separation of concerns, facilitating the reuse of modules that implement the application in other systems. The infrastructure required to manage the contracts follows an architectural pattern, which can be directly mapped to specific components included in a supporting reflective middleware. This feature allows designers to write a contract and to follow a standard recipe to insert the extra code required to its enforcement in the supporting middleware.