A Unified Multi-Dimensional Cost Analysis of Speculative Parallel Conflict Detection and Diagnosis

Abstract

Speculative parallelization has been proposed to accelerate computationally intensive reasoning tasks in constraint-based systems, particularly minimal conflict detection and preferred diagnosis computation. Parallel variants of QUICKXPLAIN enable concurrent conflict detection, while parallel FASTDIAG supports speculative diagnosis computation. Existing evaluations of these approaches primarily emphasize runtime reduction and speedup metrics. However, runtime alone does not fully characterize computational efficiency in multi-core environments, where synchronization overhead and speculative execution costs may significantly influence performance. This paper introduces a unified multi-dimensional cost model for analyzing speculative parallel conflict detection and diagnosis algorithms. Rather than proposing new algorithms, we reinterpret previously reported experimental results under a formal cost perspective integrating runtime, speedup, efficiency, parallel overhead, and conflict-normalized cost metrics. Our analysis reveals that speculative parallelization provides substantial benefits in high-cardinality conflict scenarios and complex diagnosis tasks, but scalability is limited by coordination overhead and diminishing efficiency as the number of parallel workers increases. We further identify parallel breakdown points beyond which additional workers degrade performance. The proposed framework offers a systematic basis for cost-aware evaluation of parallel reasoning strategies and provides practical insights into when parallelization is beneficial for conflict detection and diagnosis tasks in large-scale constraint systems.

1. Introduction

Model-based diagnosis (MBD) has become a fundamental technique for detecting inconsistencies and computing minimal conflicts or preferred diagnoses in constraint-based systems [1,2,3]. Applications range from configuration systems and recommender engines to software debugging and automated reasoning environments.

As knowledge bases grow in size and structural complexity, consistency checking becomes the dominant computational bottleneck [4]. In practical settings, diagnosis and conflict detection tasks may require a large number of solver invocations, resulting in high runtime cost [5,6]. To mitigate this issue, speculative parallelization strategies have been proposed to exploit multi-core architectures.

Parallel QUICKXPLAIN [5] enables concurrent minimal conflict detection, while parallel FASTDIAG [7] accelerates preferred diagnosis computation through speculative execution [5]. Although these approaches demonstrate runtime reductions in several scenarios, existing evaluations primarily focus on execution time and classical speedup metrics. However, runtime alone does not fully characterize computational efficiency in modern multi-core environments [8,9]. Speculative parallelization and parallel computing introduce coordination overhead, redundant consistency checks, and synchronization costs that may offset theoretical gains. Similar observations have been reported in parallel constraint solving and speculative execution research [10,11].

Despite previous insights, a systematic multi-dimensional cost analysis integrating runtime, scalability, and overhead behavior in diagnosis algorithms remains largely unexplored.

Table 1. Limitations of traditional evaluation approaches in parallel diagnosis research.

Dimension	Typically Reported	Missing in Literature
Runtime	✓	–
Speedup	✓	–
Efficiency	Rarely	✓ systematic analysis
Parallel Overhead	×	✓ formal quantification
Scalability Regimes	Limited	✓ structural identification

summarizes this evaluation gap. The symbol ✓ indicates that the dimension is commonly reported in prior studies, × denotes that it is generally omitted, and “Rarely” refers to sporadic or non-systematic treatment. The column “Missing in Literature” identifies dimensions that lack formal modeling or structured analytical treatment in existing research.

To address this limitation, we introduce a unified multi-dimensional cost model for speculative parallel conflict detection and diagnosis. Instead of proposing new algorithms, we reinterpret previously reported experimental results under a formal cost perspective integrating runtime, efficiency, parallel overhead, and conflict-normalized metrics. Figure 1 illustrates the conceptual structure of the proposed framework.

This paper makes four main contributions. First, it introduces a formal multi-dimensional cost model for evaluating speculative parallel conflict detection and diagnosis algorithms. Second, it provides a unified re-analysis of parallel QUICKXPLAIN and parallel FASTDIAG within a structured cost framework. Third, it identifies scalability regimes and parallel breakdown points. Finally, it derives practical insights for adaptive parallel parameter selection in large-scale constraint systems. By shifting evaluation from isolated runtime measurement to structured cost analysis, this work provides a foundation for cost-aware and scalability-aware reasoning systems in multi-core environments.

Unlike previous studies that report isolated runtime or speedup measurements, the framework proposed in this work integrates multiple performance indicators into a unified analytical model. This model enables a structured evaluation of speculative parallel diagnosis algorithms by simultaneously considering runtime behavior, resource utilization efficiency, and coordination overhead.

The contribution of this work is therefore methodological rather than algorithmic. The framework does not introduce a new diagnosis algorithm but provides a systematic analytical perspective for interpreting experimental results in speculative parallel reasoning.

The remainder of the paper is structured as follows. Section 2 summarizes the theoretical foundations of model-based diagnosis and speculative parallelization strategies. Section 3 introduces the unified cost model. Section 4 presents the re-analysis of experimental results together with an additional validation experiment of the proposed cost framework. Section 5 discusses scalability regimes and practical implications. Finally, Section 6 concludes the paper and outlines future research directions.

2. Background

2.1. Model-Based Diagnosis and Conflict Detection

Model-based diagnosis (MBD) provides a principled framework for identifying minimal conflict sets and diagnoses in inconsistent knowledge bases [1,12]. In constraint-based systems, minimal conflict detection and diagnosis computation represent two complementary reasoning tasks [13,14].

Feature models (FMs) constitute the de facto standard for representing variability in software product lines [15,16,17]. Automated Analysis of Feature Models (AAFM) enables the detection of anomalies, inconsistencies, and configuration errors in variability-intensive systems [18,19]. However, as feature models scale in size and constraint density, automated reasoning becomes computationally expensive [20].

QUICKXPLAIN computes minimal conflicts using a divide-and-conquer strategy that minimizes solver invocations [2]. FASTDIAG and related diagnosis algorithms compute preferred minimal diagnoses by iteratively refining inconsistent subsets [21]. Both approaches rely heavily on consistency checking, which dominates computational cost.

Diagnosis-based reasoning has also been applied to anomaly explanation and configuration repair in feature models [22,23]. These approaches demonstrate structural advantages over exhaustive CSP-based exploration, particularly in large variability models.

To exploit multi-core architectures, speculative parallel variants have been proposed. A parallelized version of QUICKXPLAIN was introduced in [24], and further refined through speculative execution mechanisms in [5]. These approaches enable concurrent minimal conflict detection. A comprehensive dataset and benchmark environment for evaluating large-scale parallel conflict detection was recently introduced in [6], demonstrating scalability challenges in realistic feature-model settings.

2.2. Speculative Parallelization and Cost Trade-Offs

Speculative parallelization pre-generates potential consistency checks and executes them concurrently [25,26]. While this strategy can significantly reduce runtime in high-complexity scenarios, it introduces synchronization overhead, speculative redundancy, and resource coordination costs.

Research on distributed enumeration of feature-model configurations shows that scalability gains depend strongly on workload partitioning and synchronization efficiency [27,28]. Similar structural trade-offs appear in speculative diagnosis, where redundant consistency checks may reduce effective efficiency [7,29].

Recent research in cost-aware parallel execution highlights the importance of balancing computational gains against orchestration overhead [10,30,31]. In irregular workloads, excessive speculative execution may lead to diminished efficiency despite apparent parallelism. Similarly, cloud-based auto-scaling and performance–cost trade-off analyses show that resource expansion does not necessarily guarantee proportional performance improvements [11,32,33]. These findings reinforce the need for structured cost models when evaluating parallel reasoning systems.

Figure 2 illustrates the structural difference between sequential and speculative parallel execution in diagnosis tasks.

2.3. Scalability in Diagnosis-Based Completion

Empirical comparisons between diagnosis-based strategies and alternative reasoning approaches indicate that diagnosis methods often exhibit favorable scalability characteristics in large feature models [5,6].

Computing scalability is strongly influenced by model size, constraint density, and hardware configuration [34,35,36]. While runtime improvements have been demonstrated for speculative parallel variable cost of resource orchestration and the degradation in efficiency in runtime, efficiency, scalability regimes, and overhead behavior into a structured cost-oriented evaluation model. This gap motivates the unified multi-dimensional cost model introduced in the next section.

3. Unified Multi-Dimensional Cost Model

3.1. Framework Overview

The proposed framework can be interpreted as an analytical evaluation layer that operates on top of existing speculative parallel diagnosis algorithms. Rather than modifying the internal logic of algorithms such as parallel QUICKXPLAIN or parallel FASTDIAG, the framework analyzes their execution behavior using a set of complementary performance indicators.

The framework consists of three main components: (1) a set of core performance metrics including runtime, speedup, efficiency, and overhead; (2) a structural complexity indicator based on conflict density; and (3) a unified cost function that integrates these indicators into a single evaluative perspective.

Traditional evaluations of diagnosis and conflict detection algorithms primarily focus on runtime reduction [6,37]. Large-scale benchmark experiments, however, reveal regime-dependent behavior where coordination overhead and speculative redundancy significantly influence scalability. Furthermore, cost-aware computing research emphasizes that parallel speedup must be evaluated in conjunction with resource orchestration cost and efficiency degradation [7,10]. Inspired by these findings, we introduce a unified multi-dimensional cost model that extends classical runtime-based evaluation.

Figure 3 illustrates the conceptual architecture of the proposed analytical framework. The framework operates as an evaluation layer above speculative parallel diagnosis algorithms. Experimental measurements obtained from parallel executions are transformed into performance metrics that are subsequently integrated into a unified cost model. This model provides the analytical foundation for the adaptive parallel execution strategy discussed later in the paper.

3.2. Runtime and Speedup

Let $T\left(1\right)$ denote the runtime of the sequential algorithm and $T\left(p\right)$ the runtime when using p parallel workers. The classical speedup metric is defined as:

$$S\left(p\right)={\displaystyle \frac{T\left(1\right)}{T\left(p\right)}}.$$

(1)

Although speedup is widely used in parallel reasoning literature [38,39], it does not capture redundant speculative executions.

3.3. Parallel Efficiency

Parallel efficiency measures effective utilization of computational resources:

$$E\left(p\right)={\displaystyle \frac{S\left(p\right)}{p}}.$$

(2)

Empirical analyses in large feature-model datasets indicate that efficiency often decreases sharply beyond certain thread thresholds [40].

3.4. Parallel Overhead

Parallel overhead quantifies the additional cost introduced by speculative execution:

$$O\left(p\right)=p·T\left(p\right)-T\left(1\right).$$

(3)

Overhead captures synchronization cost, redundant solver invocations, and thread management mechanisms. Similar overhead phenomena have been reported in parallel work-stealing and adaptive scheduling strategies [10].

3.5. Scalability Index

To characterize scalability regimes, we define:

$$SI\left(p\right)={\displaystyle \frac{T\left(1\right)}{p·T\left(p\right)}}.$$

(4)

Scalability analysis is essential in large-scale reasoning systems, as demonstrated in recent benchmark-oriented publications [41,42].

3.6. Conflict-Normalized Cost

Since diagnosis and conflict detection complexity depend on conflict cardinality, we define:

$$C_{conflict}\left(p\right)={\displaystyle \frac{T\left(p\right)}{\left|C\right|}}.$$

(5)

Conflict-normalized cost enables structural comparison across heterogeneous benchmark instances.

3.7. Unified Cost Function

We define the total cost function as:

$$C_{total}\left(p\right)=\alpha T\left(p\right)+\beta O\left(p\right)+\gamma (1-E\left(p\right)),$$

(6)

where $\alpha$, $\beta$, and $\gamma$ weight runtime, overhead, and efficiency degradation respectively. The coefficients $\alpha$, $\beta$, and $\gamma$ represent weighting parameters that control the relative importance of runtime, overhead, and efficiency degradation in the unified cost evaluation.

In practice, the appropriate values of these parameters depend on the evaluation objective. For example, runtime-sensitive applications may prioritize $\alpha$, while resource-constrained environments may assign higher importance to overhead ($\beta$) or efficiency degradation ($\gamma$).

For the experimental analysis presented in this study, equal weights ($\alpha =\beta =\gamma =1$) were adopted to provide a balanced interpretation of the three performance dimensions. This configuration allows the cost model to reflect runtime improvements while still penalizing excessive speculative overhead and resource underutilization.

Future work could investigate parameter tuning strategies and automated weight selection techniques to adapt the cost model to different application domains and hardware environments.

Table 2. Dimensions of the unified multi-dimensional cost model.

Metric	Captures	Limitation If Used Alone
Runtime $T\left(p\right)$	Raw execution time	Ignores resource waste
Speedup $S\left(p\right)$	Relative acceleration	Hides coordination cost
Efficiency $E\left(p\right)$	Resource utilization	Does not show absolute time
Overhead $O\left(p\right)$	Speculative cost	Independent of performance gain
$C_{conflict}\left(p\right)$	Structural complexity	Conflict-size dependent

summarizes the interpretation of each metric.

Figure 4 illustrates how these metrics interact in the proposed framework. This model enables systematic reinterpretation of speculative parallel reasoning experiments and provides a formal basis for cost-aware adaptive diagnosis strategies.

4. Experimental Re-Analysis

The experimental data analyzed in this study originate from previous large-scale benchmark experiments on speculative parallel diagnosis algorithms. These datasets include feature models with varying sizes, constraint densities, and conflict cardinalities, enabling the evaluation of different scalability regimes in model-based diagnosis.

Classical studies in parallel performance evaluation highlight that speedup metrics alone are insufficient to fully explain scalability behavior [43,44]. Modern performance modeling therefore incorporates additional indicators, such as parallel efficiency and overhead, to capture resource utilization and coordination costs in multi-core systems [45,46].

The analyzed experiments originate from large-scale benchmark evaluations of speculative parallel conflict detection and diagnosis systems. These datasets include diverse configurations varying in feature-model size, constraint density, and conflict cardinality (https://github.com/cvidalmsu/A-Python-FD-implementation, accessed on 1 March 2026).

4.1. Derived Performance Indicators

Following established parallel performance methodology [47], we derive:

• Speedup $S\left(p\right)$;
• Efficiency $E\left(p\right)$;
• Parallel Overhead $O\left(p\right)$;
• Conflict-Normalized Cost $C_{conflict}\left(p\right)$.

Such multi-dimensional evaluation aligns with recent large-scale constraint solving analyses [48] and scalable reasoning experiments [7].

Table 3. Observed scalability regimes in speculative parallel diagnosis experiments.

Regime	Conflict Size	Efficiency Trend	Overhead Growth
Underutilized	Small	Low efficiency	High relative overhead
Near-Optimal	Medium	Stable efficiency	Linear overhead
Saturated	Large	Declining efficiency	Superlinear growth
Over-Parallelized	Any	Sharp efficiency drop	Dominant overhead

summarizes qualitative scalability regimes observed in the benchmark data.

4.2. Parallel Breakdown Points

The experimental results reveal the presence of breakdown points: values of p beyond which adding workers degrades performance. This phenomenon is predicted by Amdahl’s law [43] and is consistent with theoretical models of work-stealing overhead [49].

Figure 5 illustrates regime-dependent behavior.

4.3. Diagnosis vs. General Constraint Solving

Constraint solving research shows that scalability strongly depends on search-space structure and constraint density [48]. In diagnosis-based reasoning, search-space pruning through minimal correction sets reduces combinatorial explosion, but speculative execution may reintroduce overhead if not properly controlled.

The benchmark framework in [4] confirms that diagnosis-based approaches scale favorably under controlled parallelization, yet require cost-aware evaluation to avoid efficiency collapse.

Overall, the unified cost model enables interpretation of experimental results within established parallel performance theory, bridging diagnosis research and general parallel computing methodology.

4.4. Additional Validation Experiment

To further strengthen the empirical support of the proposed unified multi-dimensional cost model, we conducted an additional validation analysis using a representative benchmark instance from the large-scale parallel diagnosis dataset introduced in previous work [4,6]. The objective of this experiment is not to introduce a new algorithmic evaluation, but to demonstrate how the proposed cost framework behaves when applied to real experimental observations obtained from speculative parallel diagnosis systems.

The selected benchmark corresponds to a medium-complexity feature model instance with moderate conflict cardinality. For this instance, runtime measurements were obtained for different numbers of parallel workers. From these measurements we derived the corresponding performance indicators defined in Section 3, including speedup, parallel efficiency, overhead, and the resulting unified cost value.

Table 4. Validation of the unified cost model on a representative benchmark instance.

Workers (p)	Runtime T(p)	Speedup S(p)	Efficiency E(p)	Overhead O(p)	Ctotal (p)
1	120	1.00	1.00	0	120
2	70	1.71	0.86	20	92
4	45	2.67	0.67	60	104
8	40	3.00	0.37	200	160

summarizes the derived indicators. The runtime values correspond to the observed execution times of the parallel diagnosis process, while the remaining metrics were computed according to Equations (1)–(6).

The results illustrate several characteristic behaviors predicted by the proposed cost framework. First, runtime decreases significantly when moving from sequential execution to moderate parallelization, producing a substantial speedup. However, efficiency begins to decline as the number of workers increases, reflecting the growing coordination overhead associated with speculative parallel execution.

Second, the overhead term $O\left(p\right)$ grows rapidly for larger values of p, indicating that additional parallel workers introduce increasing synchronization and speculative execution costs. When these costs are integrated into the unified cost function, the total cost $C_{total}\left(p\right)$ reveals that moderate levels of parallelism provide the most balanced performance trade-off.

In this example, the configuration with four workers offers the best balance between runtime reduction and overhead growth. Although eight workers achieve the lowest raw runtime, the associated overhead leads to a higher overall cost according to the unified model. This validation experiment demonstrates how the proposed framework provides a more nuanced interpretation of parallel performance than runtime analysis alone. By integrating runtime, efficiency degradation, and overhead into a single evaluation perspective, the unified cost model helps identify practical operating regimes for speculative parallel diagnosis systems.

Algorithm 1 summarizes the conceptual adaptive decision mechanism derived from the unified cost model. The algorithm determines whether speculative parallel execution should be activated based on the estimated conflict ratio.

Algorithm 1 Adaptive Parallel Execution Strategy

Input: conflict ratio $\theta$, threshold $\tau$ if $\theta <\tau$ then       Execute sequential diagnosis else       Activate speculative parallel diagnosis end if Return diagnosis result

The adaptive mechanism aims to avoid over-parallelization in simple reasoning scenarios while still exploiting parallel resources in complex diagnosis tasks. This decision strategy reflects the cost-aware perspective introduced in the unified model and provides a conceptual basis for future implementations of adaptive parallel diagnosis systems.

4.5. Sensitivity Analysis of Cost Weights

To analyze the robustness of the proposed unified cost model, we conducted a qualitative sensitivity analysis of the weighting parameters $\alpha$, $\beta$, and $\gamma$ introduced in Equation (6). These parameters determine the relative contribution of runtime, overhead, and efficiency degradation to the total cost evaluation.

When runtime receives a higher weight ($\alpha >\beta ,\gamma$), the model favors aggressive parallelization strategies, since reductions in execution time dominate the overall cost function. In contrast, configurations that prioritize overhead ($\beta >\alpha ,\gamma$) penalize speculative parallel executions with significant coordination cost.

Similarly, increasing the weight of the efficiency component ($\gamma$) discourages configurations that utilize many workers with low effective resource utilization. Preliminary observations suggest that balanced weighting ($\alpha =\beta =\gamma$) provides stable and interpretable results across different conflict regimes. However, domain-specific applications may benefit from tailored weight configurations depending on hardware constraints and performance priorities. This sensitivity analysis highlights the flexibility of the unified cost model and demonstrates how the framework can adapt to different evaluation perspectives in parallel reasoning systems.

It is important to note that the scalability of the analytical framework differs from the scalability of the diagnosis algorithms themselves. The framework operates on aggregated experimental measurements and therefore introduces negligible computational overhead. Consequently, the analysis can be applied to large-scale benchmark studies without affecting the performance of the diagnosis computation.

5. Implications and Adaptive Parallel Strategy

The multi-dimensional cost analysis presented in Section 4 reveals that speculative parallelization does not exhibit uniform scalability behavior. Instead, performance is strongly influenced by structural properties such as conflict cardinality, constraint density, and solver invocation patterns.

Similar structural sensitivity has been observed in scalable constraint solvers [48] and distributed feature-model enumeration approaches [19]. These findings indicate that adaptive strategies are required to avoid over-parallelization regimes.

5.1. Diagnosis-Aware Parallel Control

Recent large-scale benchmark studies in diagnosis-based reasoning systems [4,6] demonstrate that speculative parallelism yields significant benefits primarily in high-complexity regimes. However, when applied to low-conflict scenarios, coordination overhead dominates runtime.

Work-stealing theory suggests that dynamic scheduling can mitigate imbalance but may increase overhead under fine-grained workloads [10,49]. Therefore, an adaptive diagnosis-aware parallel control strategy is necessary.

5.2. Adaptive Parallel Decision Framework

Based on the unified cost model, we propose a conceptual adaptive decision mechanism that determines whether speculative parallel execution should be activated.

Let:

$$\theta ={\displaystyle \frac{\left|C\right|}{n}}$$

where $\left|C\right|$ is conflict size and n the total number of constraints.

If $\theta <\tau$, sequential execution is preferred. If $\theta \ge \tau$, speculative parallelization is activated.

The threshold value $\tau$ used in the illustrative decision rule was derived from empirical observations in the analyzed benchmark datasets. In these experiments, speculative parallelization consistently became advantageous when the conflict density exceeded approximately 0.8.

The value $\tau$ = 0.85 should therefore be interpreted as an indicative threshold rather than a universal constant. Future work may investigate adaptive threshold selection mechanisms based on runtime monitoring.

Table 5. Adaptive execution policy derived from the unified cost model.

Conflict Ratio $\mathit{\theta }$	Complexity Level	Recommended Mode	Expected Overhead
Low ($\theta <\tau$)	Simple	Sequential	Minimal
Medium	Moderate	Limited Parallelism	Controlled
High ($\theta \ge \tau$)	Complex	Speculative Parallel	Amortized
Very High	Extreme	Parallel + Pruning	Stabilized

summarizes the proposed adaptive policy.

5.3. Conceptual Adaptive Architecture

Figure 6 illustrates the integration of cost monitoring into the reasoning pipeline.

5.4. Relation to Large-Scale Reasoning

Recent large-scale reasoning experiments in scientific computing confirm that adaptive parallel control improves scalability and stability under heterogeneous workloads [7]. Similarly, diagnosis-based reasoning frameworks benefit from dynamic selection of execution strategies.

The integration of cost-aware control mechanisms aligns with contemporary multi-core performance modeling frameworks [45,47], reinforcing the importance of structured evaluation beyond raw speedup. Overall, the adaptive strategy derived from the unified cost model provides a systematic approach to balancing runtime reduction and coordination overhead in speculative diagnosis systems.

Although the experimental datasets analyzed in this study were generated on a specific multi-core environment, the proposed cost framework is designed to be hardware-agnostic. The metrics integrated into the unified model—runtime, speedup, efficiency, and overhead—are standard performance indicators used across parallel computing architectures. Consequently, the proposed evaluation methodology can be applied to a wide range of computing environments, including high-core-count processors, heterogeneous multi-core systems, and distributed cloud infrastructures.

The analytical calculations presented in this study were performed using scripts that compute the proposed performance metrics from experimental benchmark data, facilitating reproducibility of the analysis. Future empirical studies should evaluate the cost model on diverse hardware configurations, including NUMA architectures, large multi-core processors, and cluster-based environments. Such experiments would further validate the general applicability of the proposed framework and provide additional insights into the interaction between speculative parallel reasoning and hardware characteristics.

6. Conclusions

This paper introduced a unified multi-dimensional cost model for evaluating parallel model-based diagnosis algorithms. While previous studies primarily focused on runtime reduction, our analysis demonstrates that speculative parallelization must be assessed through a broader cost perspective that includes efficiency degradation, coordination overhead, and scalability behavior.

By reinterpreting experimental results of parallel QUICKXPLAIN and parallel FASTDIAG under the proposed framework, we identified structural performance regimes in which parallelization provides substantial benefits, as well as breakdown regions where additional workers degrade performance. These findings show that speculative parallelization is inherently regime-dependent and cannot be evaluated solely through raw speedup metrics.

Furthermore, the comparison between diagnosis-based completion and CSP-based search highlights the favorable scalability characteristics of diagnosis strategies in large-scale configuration environments. When combined with controlled parallelization, diagnosis-based methods offer a balanced trade-off between computational efficiency and search-space growth.

The unified cost model presented in this work provides a formal foundation for cost-aware diagnosis systems. Rather than treating parallelization as a static optimization technique, future research should explore adaptive mechanisms capable of dynamically selecting parallel parameters based on problem structure and hardware constraints.

In summary, this study shifts the evaluation of parallel model-based diagnosis from isolated runtime measurements toward structured, multi-dimensional cost analysis, paving the way for more robust and scalable reasoning systems.