Efficient Utility-Driven Self-Healing Employing Adaptation Rules for Large Dynamic Architectures

Self-adaptation can be realized in various ways. Rule-based approaches prescribe the adaptation to be executed if the system or environment satisfy certain conditions and result in scalable solutions, however, with often only satisfying adaptation decisions. In contrast, utility-driven approaches determine optimal adaptation decisions by using an often costly optimization step, which typically does not scale well for larger problems. We propose a rule-based and utility-driven approach that achieves the beneficial properties of each of these directions such that the adaptation decisions are optimal while the computation remains scalable since an expensive optimization step can be avoided. The approach can be used for the architecture-based self-healing of large software systems. We define the utility for large dynamic architectures of such systems based on patterns capturing issues the self-healing must address and we use patternbased adaptation rules to resolve the issues. Defining the utility as well as the adaptation rules pattern-based allows us to compute the impact of each rule application on the overall utility and to realize an incremental and efficient utility-driven self-healing. We demonstrate the efficiency and optimality of our scheme in comparative experiments with a static rule-based scheme as a baseline and a utility-driven approach using a constraint solver.

💡 Research Summary

The paper addresses the challenge of providing self‑healing capabilities for large, dynamic software architectures. Traditional approaches fall into two categories: rule‑based adaptation, which is fast and scalable but often yields only satisfactory (non‑optimal) decisions, and utility‑driven adaptation, which can compute optimal decisions by maximizing a utility function but typically requires costly optimization techniques that do not scale to large configuration spaces. The authors propose a hybrid method that combines the strengths of both paradigms while avoiding their weaknesses.

The core idea is to define the utility of an architectural runtime model in a pattern‑based manner. Two families of patterns are introduced: positive utility patterns (P⁺) that capture beneficial architectural fragments (e.g., a started component with high reliability and connectivity) and negative utility patterns (P⁻) that capture detrimental situations such as component failures. Each pattern match contributes a sub‑utility value Uᵢ that depends on contextual attributes (criticality, reliability, connectivity, etc.). The overall utility U(G) of a configuration G is the sum of all sub‑utilities over all matches, as expressed in Equation 1.

Adaptation rules are also defined in a pattern‑based fashion. Each rule references a set of negative patterns it can repair and specifies the expected increase in utility (utilityIncrease) as well as the execution cost (costs). Because the utility impact of a rule can be computed a priori from the matched patterns and their contexts, the system can evaluate the benefit‑cost ratio of every applicable rule at runtime. The planning phase therefore reduces to selecting a sequence of rule applications that maximizes the net utility gain while respecting the costs, without invoking an external constraint solver or exhaustive search. This selection is performed incrementally on the current set of detected violations, yielding a greedy yet optimal sequence for the considered problem class.

The approach is evaluated using mRUBiS, a modular variant of the RUBiS online marketplace. mRUBiS consists of many shops, each containing 18 components with varying reliability and criticality. Failures are injected to generate negative patterns, and a set of repair rules (e.g., restart component, redeploy component, recreate connector) is applied. Three configurations are compared: (1) a static rule‑based system that only matches and applies rules, (2) a utility‑driven system that uses a constraint solver to find the optimal configuration, and (3) the proposed hybrid method.

Results show that the hybrid method achieves higher cumulative utility over time than the static rule‑based baseline, demonstrating that it makes better healing decisions. In terms of runtime performance, the hybrid approach is orders of magnitude faster than the constraint‑solver based method, especially as the architecture size grows. Importantly, the utility achieved by the hybrid method matches that of the optimal solver, confirming that the incremental, rule‑centric planning does not sacrifice optimality.

Key contributions of the paper are: (1) a pattern‑based utility definition that naturally adapts to dynamic architectural changes, and (2) an incremental planning algorithm that predicts the utility impact of each rule, enabling optimal self‑healing without expensive global optimization. The authors argue that this combination is particularly suitable for large‑scale cloud or micro‑service environments where rapid, optimal adaptation is essential. Future work is suggested to extend the method to multi‑objective scenarios, incorporate additional non‑functional concerns (e.g., security, performance), and validate the approach on real production systems.