Search

MapReduce is a major computing model for big data solutions through distributed virtual computing environment. Cloud container environment is one of the platforms to compute MapReduce tasks. However, a new challenge lies on the lack of resource provisioning for containerized MapReduce computations with deadline requirements. There are two major resource provisioning strategies to solve this challenge: Static and dynamic, but neither of them can satisfactorily solve it. This paper presents a resource provisioning framework, integrating semi-static and dynamic strategies, to address this challenge. The framework includes a performance model to estimate minimum resource requirements under deadline limitation, and a scheduler to adjust resource allocation. Experimental results show that the proposed semi-static framework can complete the MapReduce computation with less resource utilization and meeting the given deadline. However, proposed dynamic resource provisioning is not suitable for our scenario caused by resource overhead and late completion.

In this paper, we present a detailed evaluation of a set of well-known Machine Learning classifiers in front of dynamic and non-deterministic software anomalies. The system state prediction is based on monitoring system metrics. This allows software proactive rejuvenation to be triggered automatically. Random Forest approach achieves validation errors less than 1% in comparison to the well-known ML algorithms under avaluation. In order to reduce automatically the number of monitored parameters, needed to predict software anomalies, we analyze Lasso Regularization technique jointly with the Machine Learning classifiers to evaluate how the prediction accuracy could be guaranteed within an acceptable threshold. This allows to reduce drastically (around 60% in the best case) the number of monitoring parameters. The framework, based on ML and Lasso regularization techniques, has been validated using an e-commerce environment with Apache Tomcat server, and MySql database server., Postprint (author’s final draft)

Counting networks were proposed by Aspnes, Herlihy and Shavit [3] as a low-contention concurrent data structure for multiprocessor coordination. We address the issue of tolerating faults in counting networks. In our fault model, balancer objects experience responsive crash failures: they behave correctly until they fail, and thereafter they are inaccessible. We propose two methods for tolerating such faults. The first is based on a construction of a k-fault-tolerant balancer with 2(K + 1) bits of memory. All balancers in a counting network are replaced by fault-tolerant ones. Thus, a counting network with depth O(log2 n), where n is the width, is transformed into a k-fault-tolerant counting network with depth O(k log^2 n). We also consider the case where inaccessible balancers can be remapped to spare balancers. We present a bound on the error in the output token distribution of counting networks with remapped faulty balancers (a generalization of the error bound for sorting networks with faulty comparators presented by Yao & Yao [10]). Our second method for tolerating faults is based on the construction of a correction network. Given a token distribution with a bounded error, the correction network produces a token distribution that is smooth (i.e., the number of tokens on each output wire differs by at most one — a weaker condition than the step property of counting networks). The correction network is constructed with fault-tolerant balancers. It is appended to a counting network in which faulty balancers are remapped to spare balancers. In order to tolerate k faults, the correction network has depth 2k(k + l)(log n + 1), for a network of width n. Therefore, this method results in a network with a smaller depth provided that O(k) < O(log n). However, it is only applicable if it is possible to remap faulty balancers.

Chandra et al. [5] showed that the group membership problem cannot be solved in asynchronous systems with crash failures. We identify the main assumptions required for their proof and show how to circumvent this impossibility result building a weaker, yet non trivial specification. We provide an algorithm that solves this specification and show that our solution is an improvement upon previous attempts to solve this problem using a weaker specification.