Athanasios Naskos

Dependable Horizontal Scaling Based on Probabilistic Model Checking

The focus of this work is the on-demand resource provisioning in cloud computing, which is commonly referredto as cloud elasticity. Although a lot of effort has been invested in developing systems and mechanisms that enable elasticity, the elasticity decision policies tend to be designed without quantifying or guaranteeing the quality of their operation. We present an approach towards the development of more formalized and dependable elasticity policies. We make two distinct contributions. First, we propose an extensible approach to enforcing elasticity through the dynamic instantiation and online quantitative verification of Markov Decision Processes(MDP) using probabilistic model checking. Second, various concrete elasticity models and elasticity policies are studied. We evaluate the decision policies using traces from a realNoSQL database cluster under constantly evolving externalload. We reason about the behaviour of different modelling and elasticity policy options and we show that our proposal can improve upon the state-of-the-art in significantly decreasing under-provisioning while avoiding over-provisioning.

Probabilistic Model Checking at Runtime for the Provisioning of Cloud Resources

We elaborate on the ingredients of a model-driven approach for the dynamic provisioning of cloud resources in an autonomic manner. Our solution has been experimentally evaluated using a NoSQL database cluster running on a cloud infrastructure. In contrast to other techniques, which work on a best-effort basis, we can provide probabilistic guarantees for the provision of sufficient resources. Our approach is based on the probabilistic model checking of Markov Decision Processes (MDPs) at runtime. We present: (i) the specification of an appropriate MDP model for the provisioning of cloud resources, (ii) the generation of a parametric model with system-specific parameters, (iii) the dynamic instantiation of MDPs at runtime based on logged and current measurements and (iv) their verification using the PRISM model checker for the provisioning/deprovisioning of cloud resources to meet the set goals (This research has been co-financed by the European Union (European Social Fund - ESF) and Greek national funds through the Operational Program “Education and Lifelong Learning of the National Strategic Reference Framework (NSRF) - Research Funding Program: Thales. Investing in knowledge society through the European Social Fund.”).

Cost-aware horizontal scaling of NoSQL databases using probabilistic model checking

In this work we target horizontal scaling of NoSQL databases, which exhibit highly varying, unpredictable and difficult to model behavior coupled with transient phenomena during VM removals and/or additions. We propose a solution that is cost-aware, systematic, dependable while it accounts for performance unpredictability and volatility. To this end, we model the elasticity as a dynamically instantiated Markov decision process, which can be both solved and verified using probabilistic model checking. Further, we propose a range of complementary decision making policies, which are thoroughly evaluated in workloads from real traces. The evaluation provides strong insights into the trade-offs between performance and cost that our policies can achieve and prove that we can avoid both over- and under-provisioning.

Security-Aware Elasticity for NoSQL Databases

We focus on horizontally scaling NoSQL databases in a cloud environment, in order to meet performance requirements while respecting security constraints. The performance requirements refer to strict latency limits on the query response time. The security requirements are derived from the need to address two specific kinds of threats that exist in cloud databases, namely data leakage, mainly due to malicious activities of actors hosted on the same physical machine, and data loss after one or more node failures. We explain that usually there is a trade-off between performance and security requirements and we derive a model checking approach to drive runtime decisions that strike a user-defined balance between them. We evaluate our proposal using real traces to prove the effectiveness in configuring the trade-offs.

Extracting Components from Open Source: The Component Adaptation Environment (COPE) Approach

Open Source Software (OSS) represents an extremely valuable resource that is reused systematically almost in every software project. The reuse of OSS components however is restricted to ready-made components and developers who want to reuse code that exists in OSS projects but is not offered as a black-box component often resort to copying existing code and adapting it in their projects. OPEN-SME is a European research project which aims at providing ready-to-use OSS components that originate from existing OSS projects but are not necessarily provided as such. In this work we describe the Component Adaptation Environment (COPE) tool that was developed in the context of the OPEN-SME project and enables software experts, called reuse engineers, to extract components from OSS projects, test them and provide test documentation, validate them with Model-Based Testing techniques, package them and upload them in a component repository for reuse. The whole approach aims at creating an ever increasing repository of trustworthy reusable software components from different application domains.

Online Analysis of Security Risks in Elastic Cloud Applications

Security-related concerns in elastic cloud applications call for a risk-based approach due to the inherent trade-offs among security and other nonfunctional requirements, such as performance. To this end, the authors advocate a solution that can be efficiently realized through modeling the application behavior as a Markov decision process, on top of which probabilistic model checking is applied. The article explains the main steps in this approach and illustrates its use in online analysis and decision making regarding elasticity decisions. The runtime analysis is capable of providing evidence for key security-related aspects of the running applications, such as the probability of data leakage in the next hour.

Flexible partitioning for selective binary theta-joins in a massively parallel setting

Efficient join processing plays an important role in big data analysis. In this work, we focus on generic theta joins in a massively parallel environment, such as MapReduce and Spark. Theta joins are notoriously slow due to their inherent quadratic complexity, even when their selectivity is low, e.g., 1%. The main performance bottleneck differs between cases, and is due to any of the following factors or their combination: amount of data being shuffled, memory load on reducers, or computation load on reducers. We propose an ensemble-based partitioning approach that tackles all three aspects. In this way, we can save communication cost, we better respect the memory and computation limitations of reducers and overall, we reduce the total execution time. The key idea behind our partitioning is to cluster join key values following two techniques, namely matrix re-arrangement and agglomerative clustering. These techniques can run either in isolation or in combination. We present thorough experimental results using both band queries on real data and arbitrary synthetic predicates. We show that we can save up to 45% of the communication cost and reduce the computation load of a single reducer up to 50% in band queries, whereas the savings are up to 74 and 80%, respectively, in queries with arbitrary theta predicates. Apart from being effective, the potential benefits of our approach can be estimated before execution from metadata, which allows for informed partitioning decisions. Finally, our solutions are flexible in that they can account for any weighted combination of the three bottleneck factors.

Security-aware elasticity for NoSQL databases in multi-cloud environments

We focus on horizontally scaling NoSQL databases in a cloud environment, in order to meet performance requirements whi le respecting security constraints. The performance requirements refer to strict latency limits on the query response time. The security requirements are derived from the need to address two specific kinds of threats that exist in cloud data bases, namely data leakage, mainly due to malicious activities of actors hoste d on the same physical machine, and data loss after one or more node failures. A key f eature of our approach is that we account for multiple cloud providers off ering resources of different characteristics. We explain that usually there i s a trade-off between performance and security requirements and we derive a model checking approach to drive runtime decisions that strike a user-defined balanc e between them taking into account the infrastructure heterogeneity. Finally, w e evaluate our proposal using real traces to prove the effectiveness in configuring t he trade-offs.

A bi-objective cost model for optimizing database queries in a multi-cloud environment

Abstract Cost models are broadly used in query processing to drive the query optimization process, accurately predict the query execution time, schedule database query tasks, apply admission control and derive resource requirements to name a few applications. The main role of cost models is to estimate the time needed to run the query on a specific machine. In a multi-cloud environment, cost models should be easily calibrated for a wide range of different physical machines, and time estimates need to be complemented with monetary cost information, since both the economic cost and the performance are of primary importance. This work aims to serve as the first proposal for a bi-objective query cost model suitable for queries executed over resources provided by potentially multiple cloud providers. We leverage existing calibrating modeling techniques for time estimates and we couple such estimates with monetary cost information covering the main charging options for using cloud resources. Moreover, we explain how the cost model can become part of an optimizer. Our approach is applicable to more generic data flow graphs, the execution plans of which do not necessarily comprise relational operators. Finally, we give a concrete example about the usage of our proposal and we validate its accuracy through real case studies.