Arthur Perais

André Seznec

Revisiting Value Prediction

Keywords: Value Prediction, VTAGE, hybrid predictors Revisiting Value Prediction Prédiction de valeurs, VTAGE, prédicteurs hybrides

Value prediction was proposed in the mid 90's to enhance the performance of highend microprocessors. Unfortunately, to the best of our knowledge, there are no Value Prediction implementations available on the market. Moreover, the research on Value Prediction techniques almost vanished in the early 2000's as it was more effective to increase the number of cores than to dedicate silicon to Value Prediction. However, high-end processor chips currently feature 8-16 high-end cores and the technology will allow to implement 50-100 of such cores on a single die in a foreseeable future. Amdahl's law suggests that the performance of most workloads will not scale to that level. Therefore, dedicating more silicon area to single high-end core will be considered as worthwhile for future multicores, either in the context of heterogeneous multicores or homogeneous multicore. In particular, spending transistors on specialized, performance and/or power optimized units, such as a value predictor. In this report, we first build on the concept of value prediction. We introduce a new value predictor VTAGE harnessing the global branch history. VTAGE directly inherits the structure of the indirect jump predictor ITTAGE. We show that VTAGE is able to predict with a very high accuracy many values that were not correctly predicted by previously proposed predictors, such as the FCM predictor and the stride predictor. Compared with these previously proposed solutions, VTAGE can accommodate very long prediction latencies. The introduction of VTAGE opens the path to the design of new hybrid predictors. Three sources of information can be harnessed by these predictors: the global branch history, the differences of successive values and the local history of values. We show that the predictor components using these sources of information are all amenable to very high accuracy at the cost of some prediction coverage. Using SPEC 2006 benchmarks, our study shows that with a large hybrid predictor, in average 56.76% of the values can be predicted with a 99.48% accuracy against respectively 55.50% and 98.62% without advanced confidence estimation and the VTAGE component.

Introduction

Around 2020, IC technology might allow to build processor chips integrating 50-100 superscalar cores. Intrinsically parallel workloads strongly benefit from additional cores. Yet the software industry is moving towards parallel applications at a relatively slow pace, while Amdahl's law [START_REF] Amdahl | Validity of the single processor approach to achieving large scale computing capabilities[END_REF] emphasizes the need for performance on sequential code sections. Dedicating more silicon area to single thread performance is becoming worth to reconsider either in the context of heterogeneous multicores, as suggested in [START_REF] Hill | Amdahl's law in the multicore era[END_REF] or in the context of homogeneous general-purpose multicores. Some architectural techniques were proposed in the late 90's for high-end uniprocessor but were not implemented at the beginning of the multicore era; among these techniques was Value Prediction [START_REF] Lipasti | Value locality and load value prediction[END_REF], which we revisit in this paper. Superscalar processors leverage Instruction Level Parallelism (ILP) to increase sequential performance by concurrently executing several independent instructions from the same control flow. However, ILP is limited and no more than a few instructions can be executed in parallel [START_REF] Hennessy | Computer architecture: a quantitative approach[END_REF]. This is due to both control and data dependencies between instructions in the code. As a consequence, being able to break these dependencies might be leveraged for direct sequential performance gains.

To accommodate control dependencies, Branch Prediction is universally used in processor design. The processor can continue fetching instructions speculatively ignoring control dependencies. Similarly, on out-of-order execution processors, Register Renaming is used to truly remove false data dependencies (Write-After-Write and Write-After-Read) on registers. However, nowadays true data dependencies (Read-After-Write) on registers are always enforced by stalling the pipeline. [START_REF] Lipasti | Value locality and load value prediction[END_REF] to speculatively ignore true register RAW dependencies. By speculating on the result of instructions, Value Prediction allows for early speculative execution of instructions requiring the predicted value. Value Prediction leverages Value Locality, that is the observation that dynamic instructions tend to produce results that were already generated by a previous instance of the same static instruction [START_REF] Lipasti | Value locality and load value prediction[END_REF]. Value Prediction is usually approached as a way to further improve sequential performance by implementing it in a state of the art pipeline. However, it should be noted that instead of aiming for the ultimate sequential performance, Value Prediction can also be viewed as an alternative to out-of-order execution [START_REF] Rychlik | Efficacy and performance impact of value prediction[END_REF].

Lipasti et al. proposed Value Prediction

Previous work in this field led to moderately to highly accurate predictors [START_REF] Nakra | Global context-based value prediction[END_REF][START_REF] Sazeides | The predictability of data values[END_REF][START_REF] Wang | Highly accurate data value prediction using hybrid predictors[END_REF]. However, accuracy was shown to be critical due to misprediction penalties [START_REF] Zhou | A study of value speculative execution and misspeculation recovery in superscalar microprocessors[END_REF]. If no selective replay is implemented then the penalty of a value misprediction can be as high as the cost of a branch misprediction. Therefore, even a slight drop in accuracy might lead to a big performance loss.

In this paper, we present a new value predictor component: The Value TAGE predictor (VTAGE). This predictor leverages the global branch history and is amenable to very high confidence. We show that VTAGE captures some value predictability that is captured neither by previously proposed value predictors leveraging local value history nor by stride-based predictors. Consequently, we show that one can build very accurate predictors with high prediction coverage through combining a local value history predictor, a stride value predictor and VTAGE.

The remainder of this paper is organized as follow: Section 2 describes related work. Section 3 introduces our new value predictor component, VTAGE. In Section 4, we describe how to improve all the predictors in order to achieve very high accuracy on high confidence predictions. Section 5 summarizes our evaluation methodology while Section 6 details the results we obtained. Finally, Section 7 provides some directions for future research.

Related Work

Value Predictors

Lipasti and Shen introduced Value Locality in [START_REF] Lipasti | Exceeding the dataflow limit via value prediction[END_REF][START_REF] Lipasti | Value locality and load value prediction[END_REF]. Value Locality states that a given dynamic instruction is likely to produce a result that was also produced by a previous instance. Value Locality exists for both instruction results and effective addresses. They propose the last value prediction (LVP), which consists in always predicting that the result of an instruction is the result produced by the last instance of the corresponding static instruction.

Sazeides and Smith defined two types of value predictors in [START_REF] Sazeides | The predictability of data values[END_REF]. On the one hand, Computational predictors generate a prediction by applying a function to the value(s) produced by the previous instance(s) of the instruction. For instance, the Last Value predictor uses the identity function while a Stride predictor uses the addition of a constant (stride) as its function. A Two-Delta Stride [START_REF] Eickemeyer | A load-instruction unit for pipelined processors[END_REF] predictor is similar except for the fact that it uses two strides: one stride is always updated and the second stride is only updated if the first stride has seen the same value two consecutive times. The latter is used to make the prediction.

On the other hand, Context-Based predictors rely on patterns in the value history of a given static instruction to generate the speculative result of the current instance. The main representatives of this category are Finite Context Method predictors (FCM). Such predictors are usually implemented as two levels structures. The first level (Value History Table or VHT) records a value history -possibly compressed -and is accessed using the instruction address. The history is then hashed to form the index of the second level (Value Prediction Table or VPT), which contains the actual prediction. A confidence estimation mechanism is usually added in the form of saturating counters in either the first level table or the second level table [START_REF] Burtscher | Improving Context-Based Load Value Prediction[END_REF][START_REF] Sazeides | Implementations of context based value predictors[END_REF]. These two families of value predictors are complementary to some extent since they are expert at predicting distinct instructions.

Real implementations of FCM-like predictors may be very difficult because several instances of the same instructions might be in the pipeline at the same time. Consequently, a speculative history must be kept for each in-flight instruction.

Nakra et al. use global branch history for predicting values [START_REF] Nakra | Global context-based value prediction[END_REF]. The Per-Path Stride predictor (PS) is a stride-based predictor using the global branch history to select the stride to be added to the result produced by the last instance. First, the instruction address is used to access the last value in the Value History Table (VHT), while the stride is selected in the Stride History Table (SHT) using a hash of the history and the PC. Then, the two values are added to form the prediction.

Yet, to accommodate the misprediction recovery, value predictors must be very accurate. In [START_REF] Zhou | A study of value speculative execution and misspeculation recovery in superscalar microprocessors[END_REF], Zhou et al. showed that even when using a very smart mechanism to handle recovery (namely selective replay), accuracy is still fundamental to benefit from Value Prediction. Even in the idealistic case where faulting instructions can get back in the reissue queue in only one cycle, the average speedup nearly vanishes as the misprediction rate increases from 0% to 15%. Granted a conventional confidence mechanism, we found that existing predictors can manage to reach around 96% accuracy. However, bridging the gap between 96 and 99% is necessary to reach speedups in accordance with the cost of Value Prediction. This observation gets even more relevant as the width and the depth of the pipeline grows, since more and more instructions can be in flight at a given instant.

Indirect Jump Target Prediction

The prediction of the results of particular instructions, namely indirect jumps, has received a particular attention. Since our VTAGE predictor is directly derived from the ITTAGE predictor Inria [START_REF] Seznec | A case for (partially) tagged geometric history length branch prediction[END_REF], we detail the latter.

It has been observed that most of the correlations between branches are found between close ones (in terms of dynamic branch instructions executed), and fewer correlations are found between distant branches. However, to achieve high accuracy and coverage, capturing correlations between distant branches is necessary. Seznec proposed the TAgged GEometric predictor in [START_REF] Seznec | A case for (partially) tagged geometric history length branch prediction[END_REF] to fulfill this very requirement. This scheme is well suited for branch prediction but also for indirect branch target prediction, as demonstrated by the ITTAGE predictor [START_REF] Seznec | A case for (partially) tagged geometric history length branch prediction[END_REF].

The idea is to have several tablescomponents -storing predictions. Each table is indexed by a different number of bits of the global branch history, hashed with the PC of the branch instruction. The different lengths form a geometric series. These tables are backed up by a base predictor, which is accessed using only the instruction address. In ITTAGE, an entry of a tagged component consists of a partial tag, a 1-bit usefulness counter u used by the replacement policy, a full address targ giving the prediction and a 2-bit hysteresis counter ctr. An entry of the base predictor simply consists of the prediction and the hysteresis counter.

When a prediction must be provided, all components are accessed in parallel to check for a hit. The component with a hit accessed with the longest history is called the provider component. It will provide the prediction to the pipeline. The component that would have provided the prediction had there been a miss in the provider component is called the alternate component. In some cases, it is more interesting to take the prediction of the alternate component (e.g. when the provider entry was allocated recently). This property is monitored by a global counter.

Once the prediction is made, only the provider is updated. On both a correct or an incorrect prediction, ctr1 and u2 are updated. On a misprediction only, targ is replaced if ctr is equal to 0 and a new entry is allocated in a component using a longer history than the provider : all "upper" components are accessed to see whether one of them has an entry that is not useful (u is 0) or not. If not, the u counter of all matching entries are reset but no entry is allocated. Otherwise, a new entry is allocated in one of the components whose corresponding entry is not useful. The component is chosen randomly. We refer the reader to [START_REF] Seznec | A case for (partially) tagged geometric history length branch prediction[END_REF] for a more detailed description.

3 Exploiting Branch Outcomes to Correlate Instruction Results

Introducing the Value TAgged GEometric Predictor

From our current perspective, ITTAGE could be considered as a value predictor specialized in predicting indirect branch targets, since they are contained in registers. Therefore, we apply the same principles for the Value TAgged GEometric history length predictor, but for predicting the result of any instruction. To do so, the global branch history and the program counter are used to index multiple predictor tagged tables. The matching entry with the longest history provides the prediction. The set of history lengths form a geometric series, therefore enabling to capture correlation with short history vectors as well as very long history vectors. In this paper, we will consider a predictor featuring 6 tables in addition to a base -untagged -component, a single useful bit per entry in the tagged components and a 3-bit hysteresis counter ctr per entry in every component. The tag of tagged components is 10+rank -bit long with rank varying between 1 and 6. The minimum history length is 2 and the maximum length is 64 as we found that this values provide the best results in our experiments. Lastly, as suggested by Seznec in [START_REF] Seznec | Storage free confidence estimation for the tage branch predictor[END_REF], we use the 3-bit hysteresis counters as confidence counters. We reset the hysteresis counter on a misprediction.

Figure 1: N-components VTAGE predictor. Val is the prediction, c is the hysteresis counter (acting as confidence counter), u is the useful bit used by the replacement policy to find an entry to evict.

Fig. 1 describes a N-component VTAGE predictor. It works similarly to the ITTAGE predictor: all components are checked in parallel to find the provider and alternate components. Then, we check the confidence counter of the component actually making the prediction to see if it is saturated. If yes, we let the prediction proceed, otherwise, no prediction is made for the current instruction.

Inria

Prediction Latency is not an Issue on VTAGE

If VTAGE features large tables then the prediction latency can be quite high. However, prediction latency is not a major issue on VTAGE since the values are needed rather late in the pipeline (after register renaming stage). This has to be contrasted with conventional branch predictors, local value history predictors and stride value predictors. For branch predictors, we need the result of the prediction to predict the next branch. For the local history predictor, we need the (predicted or computed) results of the previous occurrences of the instruction to compute the prediction. The same goes for the stride predictors: they need the immediate previous value to compute the current prediction. On the contrary, VTAGE only needs the current branch history and should be much more resilient to delayed updates: By nature, it can predict without knowing the outcome of the previous instruction instance.

Maximizing Accuracy Through Confidence on Value Predictors

Predictor #Entries Tag Conf(Thr, Rand filter B-hist Width Sat, Inc, Dec) Sat. Prob. LVP [START_REF] Lipasti | Exceeding the dataflow limit via value prediction[END_REF] 4096 Full (52) (

-2D-Str [START_REF] Eickemeyer | A load-instruction unit for pipelined processors[END_REF] 4096 Full (52) ( We already mentioned in Section 2 that the performance cost of a value misprediction will be quite high. The effective misprediction penalty depends on the actual design implemented to handle the misprediction. Therefore, associating a confidence counter with each predictor entry is needed on every predictor. If one uses predictions only when the confidence counter is saturated then the accuracy will be in the 96-98% range for predictors such as LVP, FCM, the stride predictor or even VTAGE (see Section 6). However a 96-98% accuracy will not lead to a significant enough performance increase even with advanced selective replay for the mispredicted instruction and all the dependent instructions [START_REF] Zhou | A study of value speculative execution and misspeculation recovery in superscalar microprocessors[END_REF].

In [START_REF] Seznec | Storage free confidence estimation for the tage branch predictor[END_REF], Seznec addressed the issue of isolating a class of very high level confidence branch predictions on the TAGE predictor. He showed that predictions provided by saturated counters are high confidence, but that it is possible to increase the level of confidence for this class by filtering the transition of the counter from nearly saturated to saturated using a random filter. On a correct prediction and if the providing counter is nearly saturated it is set to saturated only with a low probability (e.g. 1 out of 16 or 1 out of 1325). The transition from saturated to nearly saturated is always performed on a misprediction. This method allows to increase the prediction accuracy on the high level confidence prediction class at the cost of a decrease of its coverage. Riley et al. also considered some form of probabilistic counters in [START_REF] Riley | Probabilistic counter updates for predictor hysteresis and stratification[END_REF].

All the value predictors we consider in our evaluation have (or were added) confidence counters, allowing to discriminate between high confidence and low confidence predictions. Saturated confidence counters correspond to high confidence predictions. In order to reinforce the accuracy on high confidence predictions, we use the same random transition from nearly saturated to saturated as for the TAGE branch predictor. Moreover, the confidence counter is reset on a misprediction.

The results we present in Section 6 show that through applying such a simple modification to the predictor update automaton, value predictors are amenable to very high accuracy on high confidence predictions, but at the cost of decreasing the coverage of the predictors.

Evaluation Methodology

Test Suite

We gathered all results using PIN and the x86_64 ISA. As our test suite, we used all benchmarks from the SPEC'06 suite. We compiled the benchmarks using gcc3 . We fed all benchmarks their respective reference workloads. Instrumentation begins with the 30B th instruction and lasts until 200 million instructions have been retired. Each component tries to predict all results (including floating point values) as well as effective addresses. Note that since a single instruction (hence PC) can lead to two predictions (address and result), we left-shift the PC by one and add either 0 or 1 to differentiate the two predictions when necessary. Furthermore, as PIN only exposes committed instructions, we assume that the predictors and branch histories are immediately updated.

The number of benchmarks is high (12 for SPEC'06INT and 17 for SPEC'06FP). Consequently, we only report cumulated results as well as results for a few of them, because several benchmarks behave in the same manner when it comes to Value Prediction. Specifically, we chose three integer benchmarks (perlbench, bzip2 and gobmk ) and three floating point benchmarks (namd, soplex and lbm).

Value Predictors

Single Component Predictors

We study the behavior of several distinct value predictors in addition to the VTAGE predictor. On the one hand, three computational predictors in the form of the Last Value predictor [START_REF] Lipasti | Exceeding the dataflow limit via value prediction[END_REF], the 2-delta Stride predictor (2D-Str) [START_REF] Eickemeyer | A load-instruction unit for pipelined processors[END_REF] and the Per-Path Stride predictor [START_REF] Nakra | Global context-based value prediction[END_REF]. On the other hand, a context-based predictors in the form of a generic order 4 FCM predictor (o4-FCM) [START_REF] Burtscher | Improving Context-Based Load Value Prediction[END_REF][START_REF] Sazeides | The predictability of data values[END_REF] as it outperformed the 2-level predictor (with a threshold of 12 so as to favor accuracy) of Wang et al. [START_REF] Wang | Highly accurate data value prediction using hybrid predictors[END_REF] in our experiments.

For this study we consider medium size predictors whose parameters are illustrated in Table 1. Each of these predictors necessitates about 256-512 Kbits of storage for implementation. We did not make any attempt to optimize the area of the predictors, e.g. full strides are used as well as full tags when relevant, so as to maximize accuracy. Therefore, the effective sizes should be viewed as an upper bound rather than an absolute requirement to achieve a given performance level. Indeed, it has been shown that partial strides cover most of what full strides can cover [START_REF] Rychlik | Efficacy and performance impact of value prediction[END_REF]. Similarly, full tags might not be a cost-effective way to maximize accuracy due to the presence of confidence estimation. As we have pointed out that accuracy is particularly important on value prediction, we simulated all predictors assuming a basic confidence counter mechanism, and we only use the predictions when the confidence counter is saturated. Table 1 describes the configurations of these confidence counters.

We simulated these predictor components with and without the random filter described in Section 4 so as to illustrate the loss of coverage that can be expected when aiming for such high accuracy. The probability used for the random filter was determined in order to achieve an accuracy of 99% or more for all components. The predictors can use a lower probability if even higher accuracy is needed. Adapting the probability at run-time, as suggested in [START_REF] Seznec | Storage free confidence estimation for the tage branch predictor[END_REF], could also be considered.

Hybrid Predictors

We also focus on combination of several predictors -2 and 3-component hybrids -so as to evaluate the potential of VTAGE to predict instructions not covered by any other prediction generation method. We do not consider all possible combinations as there would be too many, however, we retained the ones we found the most interesting.

First, for studying the complementarity of the components only, we will only consider the different sets of predictable results of each components among a given hybrid predictor. That is, we do not look and accuracy and coverage but only at the respective prediction sets of each components.

Nonetheless, to gain insight on what actual coverage can be expected, we apply a realistic selection mechanism to hybrid value predictors. Specifically, if only one component predicts, its prediction is naturally selected. When two or more predictors predict, the selection works as follows: use a majority vote if the three component predict and at least two provide the same result, do not predict if the three components disagree. Use a saturating 5-bit counter to monitor the respective efficiency of pairs of components to select among two predictions when there are only two components predicting. While very basic, this selection mechanism proved to be very effective in our simulations, in particular when we applied random filtering.

Metrics

In this study, we only focus on the qualities of Value Prediction per se. Performance impact of Value Prediction is very dependent on many parameters such as the structure of the superscalar processor and the precise recovery mechanisms for mispredictions and will be addressed in future work. Therefore we will only display accuracy and coverage.

For each predictor, we collect the number of correct, incorrect and not predicted results and deduce accuracy and coverage. Accuracy is the amount of correct predictions out of the attempted predictions, i.e.:

Accuracy = correct (correct + incorrect)
Coverage is the amount of VP-eligible results the predictor is able to capture, i.e.: Coverage = correct (VP-eligible results)

Simulation Results

In this section, we present results for three categories of instruction results, integer arithmetic, address computation and floating point operations.

Single Predictors

Without Random Filters

From Figs. 2 through 5, we can observe that integer computations are usually better predicted with stride-based predictors, except in the case of perlbench where VTAGE cover more predictions. From Fig. 6 through 9, we can see that floating point benchmarks behave similarly to integer ones: stride-based predictors cover more results than context-based predictors: up to 30% more results on average for general-purpose results. This is understandable as the computation heavy part of those benchmarks is composed of floating point operations. Therefore, we expect the general-purpose computations to be more regular, hence predictable. This phenomenon is less pronounced on addresses but can still be observed. Accuracy is nearing 98% for LVP and PS but FCM lags behind at 95% for general-purpose results, on average.

The behavior of predictions of floating point values is also interesting. Context-based predictors appear as more efficient since coverage is slightly higher on average: 3 to 4% of the overall predictions. Accuracy is around 99% for computational predictors and 98% for context-based ones. However, some benchmark such as namd and lbm exhibit very little FP predictability. Also, note that due to the very nature of floating point values (three separate fields: sign, exponent and mantissa), conventional stride-based predictors will lose efficiency if partial strides are used. This phenomenon does not appear here since we use strides of the same length as the prediction.

With Random Filters

The considered figures also show accuracy and coverage for the same benchmarks when adding the random filter to all predictors. We show the probabilities we used in Table 1. All predictors now feature an accuracy which is close to 99% on average on both SPEC'06INT and SPEC'06FP, at a cost of between 3 and 11% in coverage (2 to 3% for floating point values). FCM is the least precise although its accuracy is always greater than 98%. In general, the penalty in coverage is less pronounced for VTAGE than for FCM.

Further tweaking of the probability of the random filter is possible to either gain accuracy or recover some lost coverage but this choice is dependent on the misprediction recovery policy, among other design choices. Still, a probability of 1/32 is generally sufficient to near 99.5% accuracy for VTAGE when FCM will need to use a lower one (further decreasing its coverage) to reach that accuracy level on all prediction types. Adapting the probability at run-time could also be considered to achieve a predetermined level of accuracy as suggested in [START_REF] Seznec | Storage free confidence estimation for the tage branch predictor[END_REF].

Summary

To summarize, we showed that given a random filter, all existing predictors including VTAGE are amenable to a very high accuracy, at a slight to noticeable cost in coverage. For the predictors size we considered, computational predictors are more storage-efficient except for floating point results where context-based predictors appear slightly more adapted. Previous work has already noted that for context-based predictors to beat computational predictor, bigger sizes need to be considered [START_REF] Sazeides | Implementations of context based value predictors[END_REF]. Given the supposed availability of a large number of transistors, using contextbased predictors such as VTAGE is a direction to further explore. Moreover, using hybrid predictors is a simple way to increase coverage [START_REF] Sazeides | The predictability of data values[END_REF].

Hybrid Value Predictors

To achieve high coverage, hybridizing values predictors is necessary. To that extent, we present results for 2-and 3-component predictors using the random filter mechanism. Fig. 12 summarizes the amount of predictions exclusively captured by a given component in a specific hybrid, abstracting any selection mechanism. By lack of space, we only report numbers cumulated on the whole SPEC'06 suite and we consider all types of predictions (general-purpose, addresses and floating point). Therefore, rather than giving us insight on what speedup can be expected, these numbers reflect the predictability exposed by the overall suite to different prediction methods when they are combined. We observe that hybrid predictors made of a context-based component and a stride-based component indeed show good complementarity, as expected [START_REF] Sazeides | The predictability of data values[END_REF]. The computational component is generally able to exclusively capture slightly more than two times more predictions than the context-based component. The amount of predictions captured by both components is also close to the number of predictions exclusively captured by the computational component. However, an interesting phenomenon is that the hybrid predictor made of two context-based components (namely FCM and VTAGE) also shows complementarity. Specifically, on average, VTAGE exclusively predicts 15.11% of the results, FCM 11.13% and both do predict another 15.66%. Recall that this is in fact the upper bound of the attainable coverage. This behavior implies that a 3-component hybrid featuring a computational component, FCM and VTAGE can yield an even better coverage.

F C M + 2 D - S t r V T A G E + 2 D - S t r F C M + P S V T A G E + P S V T A G E + F C M 2 D - S t r + F C M + V T A G E P S + F C M + V T A G E Percentage of
The two rightmost bars of Fig. 12 describe the prediction sets of such 3-component hybrids. Even though the sets of exclusively predictable results of the two context-based components are quite small, VTAGE can bring an additional coverage of respectively 7.02% (2D-Str+FCM+VTAGE) and 7.29% (PS+FCM+VTAGE). The computational component can once again exclusively predict more results (13.26% for 2D-Str and 16.22% for PS) while FCM lags behind at respectively 6.65% (2D-Str+FCM+VTAGE) and 6.98% (PS+FCM+VTAGE). Nonetheless, there is potential for a 3-component hybrid featuring VTAGE.

To gauge what accuracy and coverage can be attained using a realistic selector, we ran the benchmark suite using the mechanism described in Section 5. For 3-component hybrid predictors, we use a majority vote selector and three 5-bit saturating counters. For 2-component hybrid predictors, we use a simple 5-bit saturating counter. Fig. 13 summarizes the numbers when considering such mechanisms. Specifically, we can attain 56.76% coverage and 99.48% accuracy with our 3-component PS+FCM+VTAGE when PS+FCM (resp. PS+FCM without filter) culminates at 49.83% (resp. 55.5%) coverage and 99.46% (resp. 98.62%) accuracy. In essence, VTAGE is able to bring back the coverage lost due to the addition of the random filter to the PS+FCM and 2D-Str+FCM predictors, while keeping the overall accuracy near 99.5%.

Key Directions for Future Work

Collecting accuracy and coverage of value predictors is not sufficient to assert the performance benefit. We need to Evaluate a value predictor in a realistic pipeline to gauge its effective impact. To that extent, our future work will focus on simulating the VTAGE predictor and its hybrid extensions, and assess the actual speedup they can yield. In order to do so, many possibilities exist regarding the implementation of Value Prediction. In this section, we discuss some of these possibilities.

Impact of Speculative Updates and Speculative History

Theoretically, the predictor can be accessed as soon as the instruction address is known, but the prediction can only be updated once the result is known, that is, several cycles after the fetch stage. From previous works in branch prediction [START_REF] Jiménez | Reconsidering complex branch predictors[END_REF], the impact on such delayed updates is known to be limited on the accuracy of the branch predictor, but might slightly impact the coverage of high confidence predictions. We have to verify that this property also stands for value predictors such as VTAGE.

In the case of context-based predictors using local history, however, speculative updates imply that each entry can contain a speculative history, with the associated overhead. Supporting speculative value history is a challenge in itself on a deep pipeline, especially when a single entry can be accessed several times before it is updated by a committed instruction. Coverage might also be affected by the following phenomenon: if one of the in-flight occurrences is low confidence then the speculative history is also low confidence. The two same phenomena potentially apply to stride-based predictors.

Prediction Criticality

Several studies make the observation that the speedup obtainable from Value Prediction is related with the number of critical results correctly predicted rather than with the predictor coverage [START_REF] Calder | Selective value prediction[END_REF][START_REF] González | The potential of data value speculation to boost ilp[END_REF][START_REF] Rychlik | Efficacy and performance impact of value prediction[END_REF]. For instance, previous studies have shown that predicting the result of load instructions is important [START_REF] Calder | Selective value prediction[END_REF][START_REF] Lipasti | Value locality and load value prediction[END_REF], especially as the gap between processor speed and memory speed is large. Calder et al. state that only predicting the result of load instructions can provide up to 75% of the potential speedup while only predicting 30% of the VP-eligible instructions [START_REF] Calder | Selective value prediction[END_REF].

The challenge is to identify critical instructions and/or critical instances of these instructions and to limit the use of predictions to these instructions. This might allow to determine which predictor component(s) should be favored in an effective implementation. Additionally, it might guide the choice of components in the predictor.

Conclusion

Even though Value Prediction has not been considered for current commercially available microprocessors, the move toward heterogeneous architectures calls for very effective superscalar cores to quickly execute the sequential workloads. Given the availability of a large number of transistors, Value Prediction appears as a possibility to increase performance.

In this paper, we have made two contributions that may favor the introduction of value predictors in effective hardware.

First we have derived the Value TAGE predictor from the ITTAGE predictor by leveraging the similarities between Indirect Target Branch Prediction and Value Prediction. We have shown that the baseline VTAGE predictor is able to reach fairly high coverage and high accuracy, in the Inria range of what can be attained with existing predictors augmented with conventional confidence counters when necessary. Since VTAGE uses global branch history instead of per-instruction value history, it appears more easily implementable than other context-based predictor using local value history. Due to its structure, VTAGE should be much more efficient in a wide-issue, deeply pipelined superscalar processor because of its resiliency to speculative history and prediction latency: only the current branch history -which can be provided by the branch predictor -is required to predict and its prediction is needed very late. Consequently, incorporating VTAGE alone in a processor might prove to be a worthy tradeoff between coverage/accuracy and ease of implementation.

Second, we have shown that adding a random filter to force the confidence counters to saturate with a low probability is beneficial: A very high accuracy (> 99%) can be ensured for nearly all the value predictors at some cost in coverage. This cost is reasonable for VTAGE (always < 5%) but can reach roughly 10% for other predictors in some cases. Nonetheless, a very high accuracy is especially interesting since the performance benefit that can be expected from value prediction can be seriously impaired by the cost of mispredictions.

Furthermore, we have verified that computational and context-based predictors are complementary to some extent. However, among context-based predictors, local value history-based and global branch history-based predictors exclusively predict a decent amount of results. This can be leveraged to increase prediction coverage.

As a consequence, we studied the possibility of using 3-component hybrid predictors composed of VTAGE, FCM and PS/2D-Str. We showed that using a very simple selector and the random filter to maximize accuracy, we can attain 56.76% coverage on average while maintaining 99.48% accuracy on SPEC2006 workload, when the PS+FCM has significantly less coverage (49.83%) for a similar accuracy (99.46%).

  -Single Predictors -General Purpose Coverage Accuracy (a) 400.perlbench -w/o Filter

Figure 2 :Figure 3 :

 23 Figure 2: SPEC'06INT, general-purpose register prediction. Accuracy and coverage of distinct predictors with and without random saturation filtering.

Figure 4 :

 4 Figure 4: SPEC'06INT, address prediction. Accuracy and coverage of distinct predictors with and without random saturation filtering.

Figure 5 :

 5 Figure 5: SPEC'06INT average, address prediction. Accuracy and coverage of distinct predictors with and without random saturation filtering.

Figs. 2

 2 Figs. 2 through 9 respectively summarize the accuracy and coverage of the considered predictors with and without the random filter for some representative benchmarks of the SPEC'06INT and SPEC'06FP suite for general-purpose results and addresses. Figs. 10 and 11 summarizes them for floating point results on SPEC'06FP benchmarks. The bottom part of each figure illustrates the arithmetic mean obtained on either SPEC'06INT or SPEC'06FP.

Figure 6 :

 6 Figure 6: SPEC'06FP, general-purpose register prediction. Accuracy and coverage of distinct predictors with and without random saturation filtering.

Figure 7 :

 7 Figure 7: SPEC'06FP average, general-purpose register prediction. Accuracy and coverage of distinct predictors with and without random saturation filtering.

Figure 8 :

 8 Figure 8: SPEC'06FP, address prediction. Accuracy and coverage of distinct predictors with and without random saturation filtering.

Figure 9 :

 9 Figure 9: SPEC'06FP average, address prediction. Accuracy and coverage of distinct predictors with and without random saturation filtering.

Figure 10 :Figure 11 :

 1011 Figure 10: SPEC'06FP, floating point prediction. Accuracy and coverage of distinct predictors with and without random saturation filtering.

Figure 12 :Figure 13 :

 1213 Figure 12: Average complementarity of different hybrid components. SPEC'06, all predictions (general-purpose, addresses, FP).

Table 1 :

 1 Layout Summary. For VTAGE predictor, rank is the position of the tagged component and varies from 1 to 6.

	-

RR n°8155

ctr = ctr + 1 if correct or ctr -1 if incorrect. Saturating arithmetic.

u = correct && altpred = pred if the provider is not the base predictor.RR n°8155

gcc -O3 -mfpmath=sse -march=native -mtune=native -msse4.1 -mno-mmx -m64 (-O1 for perlbench). GCC

4.4.1. Inria

Publisher Inria Domaine de Voluceau -Rocquencourt BP 105 -78153 Le Chesnay Cedex inria.fr ISSN 0249-6399


J.-C Jaskula

G B Partridge

M Bonneau

R Lopes

J Ruaudel

D Boiron

C I Westbrook

An acoustic analog to the dynamical Casimir effect in a Bose-Einstein condensate

Keywords: numbers: 03.75.Kk, 67.10.Jn, 42.50.Lc

We have modulated the density of a trapped Bose-Einstein condensate by changing the trap stiffness, thereby modulating the speed of sound. We observe the creation of correlated excitations with equal and opposite momenta, and show that for a well defined modulation frequency, the frequency of the excitations is half that of the trap modulation frequency.

Although we often picture the quantum vacuum as containing virtual quanta whose observable effects are only indirect, it is a remarkable prediction of quantum field theory that the vacuum can generate real particles when boundary conditions are suddenly changed [1][2][3][4]. Known as the dynamical Casimir effect, a cavity with accelerating boundaries generates photon pairs. Recent experiments have demonstrated this effect in the microwave regime using superconducting circuits [5,6]. Hawking radiation [7] is another situation characterized by spontaneous pair creation and work on sonic analogs to the Hawking problem [8] has led to the realization that Bose-Einstein condensates (BEC) are attractive candidates to study such analog models [9][10][11], because their low temperatures promise to reveal quantum effects. Here we exhibit an acoustic analog to the dynamical Casimir effect by modulating the speed of sound in a BEC. We show that correlated pairs of elementary excitations, both phonon-like and particle-like, are produced, in a process that formally resembles parametric down conversion [4,12].

The first analyses of the dynamical Casimir effect considered moving mirrors, but it has been suggested that a changing index of refraction could mimic the effect [13,14]. Our experiment is motivated by a suggestion in Ref. [12] that one can realize an acoustic analog to the dynamical Casimir effect by changing the scattering length in an interacting Bose gas. The change in the interaction strength is analogous to an optical index change: the speed of sound (or light) changes. Seen in a more microscopic way, the ground state of such a gas is the vacuum of Bogoliubov quasi-particles whose makeup is interaction-dependent. Changing the interaction strength projects this old vacuum onto a new state containing pairs of the new quasi-particles [12], which appear as pairwise excitations. Instead of changing the interaction strength, we have simply modified the confining potential, which in turn changes the density. Sudden changes such as these have also been suggested as analogs to cosmological phenomena [15][16][17].

We study two situations, in the first the confining potential is suddenly increased and in the second the poten-tial is modulated sinusoidally. The sinusoidal modulation of the trapping potential was studied in Ref. [18][19][20] in the context of the observation of Faraday waves. Our results on sinusoidal modulation are similar to this work and we have extended it to observe correlated pairs of Bogoliubov excitations. We produce these excitations in both the phonon and particle regimes, and observe correlations in momentum space. Parametric excitation of a quantum gas was also studied in optical lattices in which the optical lattice depth was modulated [21,22], although in that experiment, the excitation was observed as a broadening of a momentum distribution.

The experimental apparatus is the same as that described in Refs. [23,24] and is shown schematically in Fig. 1a. We start from a BEC of approximately 10 5 metastable helium (He*) atoms evaporatively cooled in a vertical optical trap to a temperature of about 200 nK. The trapped cloud is cigar shaped with axial and radial frequencies of 7 Hz and 1500 Hz. In the first experiment we raise the trapping laser intensity by a factor of 2 with a time constant of 50 µs using an acousto-optic modulator (see inset to Fig. 1b). The trap frequencies thus increase by √ 2. The compressed BEC is held for 30 ms before the trap laser is switched off (in less than 10 µs). The cloud falls onto a position sensitive, single atom detector which allows us to measure the atom velocities [25]. After compression, the gas is excited principally in the vertical direction: transversely we only observe a slight heating (about 100 nK). Figure 1b shows a single shot distribution of vertical atom velocities relative to the center of mass and integrated horizontally, while Fig. 1c shows the same distribution averaged over 50 shots. These distributions are more than one order of magnitude wider than that of an unaffected BEC. The individual shots show a complex structure which is not reproduced from shot to shot, as is seen from the washing out of the peaks upon averaging.

We consider the correlations between atoms with vertical velocities v z and v z , by constructing a normalized second-order correlation function, g (2) (v z , v z )[25], averaged over the x-y plane and shown in Fig. 2a. The plot exhibits two noticeable features along the v z = v z and v z = -v z diagonals. The former reflects the fluctuations in the momentum distribution, as in the Hanbury Brown and Twiss effect [26], except that this cloud is far from thermal equilibrium. The v z = -v z correlation is a clear signature of a correlation between quasi-particles of opposite velocities. A projection of this off-diagonal correlation is shown in Fig. 2b. At low momentum, the excitations created by the perturbation are density waves (phonons) which in general consist of superpositions of several atoms traveling in opposite directions. In the conditions of our clouds, a phonon is adiabatically converted into a single atom of the same momentum during the release by a process referred to as "phonon evaporation" [27]. Therefore in the phonon regime as well as in the particle regime, we interpret the back-to-back correlation in Fig. 2a as the production of pairs of Bogoliubov excitations with oppositely directed momenta as predicted in the acoustic dynamical Casimir effect analysis [12].

To further study this process, we replace the compression by a sinusoidal modulation of the laser intensity I(t) = I 0 (1 + δ cos ω m t) (inset of Fig. 1d). We choose δ such that the trap frequencies are modulated peak to peak by about 10%. The modulation is applied for 25 ms before releasing the condensate. Figures 1d and1e show respectively single shot and averaged momentum distributions resulting from the modulation. One sees that the momentum distribution develops sidebands, approximately symmetrically placed about the center. Figure 3a shows the normalized correlation function, plotted in the same way as in Fig. 2a, for a modulation frequency ω m /2π = 2170 Hz. We again observe anti-diagonal correlations as for a sudden excitation except that the correlations now appear at a well defined velocity, which coincides with that of the sidebands (see Fig. 3b).

We have examined sinusoidal modulation for frequencies ω m /2π between 900 Hz and 5000 Hz and observed excitations similar to those in Fig. 3. We summarize our observations in Fig. 4a in which we plot the excitation frequency as a function of the sideband velocity. We also plot the locations of the peaks in the correlation functions on the same graph. For modulation frequencies much above 2 kHz, the antidiagonal correlation functions are quite noisy preventing us from clearly identifying correlation peaks. This noise may have to do with the proximity of the parametric resonance with the transverse trap frequency (∼ 3 kHz) [19].

(δv z )

1.10

1.05

1.00 0.95

3 2 1 0 -1 -2 -3 v z (cm/s) δ 1.2 1.0 -8 -4 0 4 8 v z (cm/s) g (2) (v z ) c FIG. 2.
Density correlations after a sudden compression (color online). a, Normalized correlation function g (2) (vz, v z ) of the data Fig. 1c (50 shot average). The signal on the diagonal results from the density fluctuations in the cloud. The anti-diagonal line indicates the creation of correlated quasiparticles with opposite momenta, and is the signature of the dynamical Casimir effect. b, Anti-diagonal correlation function g (2) (vz, v z = -vz). The smooth line shows the result of smoothing the data over a window of about 1 cm/s. The correlations apparently persist over a scale comparable to that of the density distribution. c, Correlation function along the dashed line and integrated over a region indicated by the dotted arrows, as a function of δvz = v z -vz. The dips on either side the peak may be related to the effect reported in [28].

A weakly interacting quantum gas obeys the well known Bogoliubov-de Gennes dispersion relation between the frequency ω k and wavevector k:

ω k = α c 2 k 2 + k 2 2m 2 (1)
with α = 1 and c, the sound velocity. This relation describes both phonons (long wavelength excitations) whose dispersion is linear and free particles, whose dispersion is quadratic. If our observation indeed corresponds to the creation of pairs, we expect the total excitation energy to be shared between the two excitations. Momentum conservation, on the other hand, requires (2) (vz, v z ) measured after sinusoidal modulation of the trap frequency at a frequency ωm/2π = 2.17 kHz, averaging over 243 experimental shots. We observe a strong correlation between well defined, oppositely directed velocities. b, Plot of the density distribution (blue) and of the anti-diagonal velocity correlation function, g (2) (vz, v z = -vz) (red).

that the two energies be equal, implying ω m = 2ω k . Therefore the relation between the modulation frequency and the sideband velocity should also be given by Eq. 1 but with α = 2 and k = mv z / . Fitting the points in Fig. 4a to (1) with α and c as free parameters, we obtain α = 2.2 ± 0.3. The fitted sound velocity, 8 ± 3 mm/s, is consistent with the value one can calculate from the trap parameters and the estimated number of atoms [25].

We can further corroborate our interpretation of pairwise excitations by a method more direct and robust than the 2 parameter fit to the data in Fig. 4a. In Fig. 4b, we compare the dispersion relation resulting from modulation with that obtained by Bragg scattering. Bragg scattering produces single excitations of quasiparticles at a definite energy and momentum [29]. We excited the BEC with two lasers in the Bragg configuration to determine the frequency for a given k-vector [25]. Then, under the same experimental conditions, using sinusoidal trap laser modulation, we excited the BEC at various frequencies and found the corresponding velocities. The lower curve in Fig. 4b is and fit the speed of sound. The upper curve is a fit to the trap modulation data in which we set the speed of sound to that found in the first fit and we allowed α to vary. This second fit yields α = 2.07 ± 0.2. The fitted speed of sound for this data set (about 13 mm/s) is higher than in the data of Fig. 4a, because during these runs the number of atoms in the condensate was larger.

An even more dramatic confirmation of our interpretation would be the observation of sub-Poissonian intensity differences in the two sidebands, as was observed in the experiment of Ref. [5], as well as in Refs. [30]. The latter experiment modulated the center of a trapped, one dimensional gas producing transverse excitations which in turn produced twin beams. Equivalently, one could ask whether the Cauchy-Schwarz inequality is violated [31],

indicating a non-classical correlation. Comparing intensity differences in the sidebands we observe a reduction of the fluctuations compared to uncorrelated regions of the distribution. However, we observe no sub-Poissonian fluctuations or Cauchy-Schwarz violation, probably because of a background under the sidebands (see Fig. 1d). The background is due to atoms spilling out of the trap before release.

Another difference between our experiment and an ideal realization of the dynamical Casimir effect is that the temperature is not negligible. This means that the pair generation did not arise from the vacuum but rather from thermal noise. For our temperature of 200 nK, the thermal occupation of the mode of frequency 2 kHz is 1.6. In the absence of a thermal background, the normalized correlation function would show an even higher peak. Using the perturbative approach of Ref. [12], one can show that g (2) (v z , v z = -v z ) is a decreasing function of the temperature, since thermal quasi-particles are uncorrelated and only dilute the correlation.

Many authors have discussed the relationship of the dynamical Casimir effect to Hawking and Unruh radiation (see [4] for a recent review). It has also been pointed out that the two-particle correlations arising in the sonic Hawking problem constitute an important potential detection strategy [10,32], although the above authors discussed correlations in position space. The present study has confirmed the power of correlation techniques, and shown in addition that momentum space is a good place to look for them. We expect that a similar approach can be applied to Hawking radiation analogs as well as the general problem of studying the physics of curved spacetime by laboratory analogies. This work was supported by the IFRAF institute, the Triangle de la Physique, the ANR-ProQuP project, J.R. by the DGA, R.L. by the FCT scholarship SFRH/BD/74352/2010, and GBP by the Marie Curie program of the European Union. We acknowledge fruitful discussions with D. Clément, I. Carusotto, A. Recati, R. Balbinot, A. Fabbri, N. Pavloff and P.-E. Larré.

Supplemental material

Detection and data analysis. The atoms are detected after falling 46.5 cm to a position sensitive detector which allows reconstruction of the arrival time and horizontal position of individual atoms [26]. The mean time of flight is 307 ms. Given the value of the vertical Thomas-Fermi radius (0.5 mm), this time is long enough for the arrival time to reflect the vertical velocity, provided this velocity is well above 1.5 mm/s.

The experimental correlation function corresponds to a 2D-histogram of the vertical velocities v z and v z of each possible pair of atoms originating from a single condensate, and averaging over all realizations. For normalization we divide this first histogram by a second 2D-histogram obtained with pairs of atoms originating from separate realizations. We observe shot to shot fluctuations in the arrival times and widths of the condensate. To avoid spurious correlation signals arising from fluctuations in arrival time, we recentered each shot by aligning the condensate peaks before averaging and normalizing. The fluctuations in the width were reduced by selecting two different width classes and normalizing them separately before adding them to obtain Fig. 3.

Speed of sound in a quasi-condensate. For our typical atom number and trap frequencies, the atomic clouds are in the 1D-3D cross-over. We follow the model of Ref. [33] to calculate the speed of sound of atoms confined in a cylindrical trap and obtain mc 2 = ω ⊥ 2 (μ -1/μ) where ω ⊥ /2π is the transverse frequency of the trap and μ > 1 the chemical potential in units of ω ⊥ . We then apply a local density approximation for the longitudinal confinement on the dynamical structure factor [29] to relate the speed of sound of equation ( 1) with the atom number.

Bragg spectroscopy. In the Bragg spectroscopy measurement of Fig. 4, we use two laser beams at an angle θ to provide an excitation wavevector k = 2 × sin (θ/2)k laser e z . The angles were approximately 6 • and 9 • . The wave vector was measured by applying an intense 10 µs pulse which populated many diffraction orders. The positions of the diffraction orders permitted an accurate fit to find the wavevector. For Bragg diffraction, the excitation pulse was of 5 ms duration. We then varied the relative frequency of the two laser beams to find the Bragg resonances for both positive and negative frequency differences. The difference in the position of the resonances divided by 2 was used as the frequency ω k . The Bragg spectra exhibit a single sideband, showing that phonon excitations appear with a single momentum, as predicted by the phonon evaporation scenario.

10 FIG. 1 .

 101 FIG. 1. Effects of time-varying potentials (color online). a, Schematic view of the experiment. Pairs of Bogoliubov quasiparticles are created by varying the trap stiffness. After the flight to the detector these excitations appear as a broadening or sidebands on the atom cloud in the vertical (z) direction. In the following plots we convert arrival times to relative velocities and average over the transverse dimensions. b, Single shot velocity distribution for a cloud which was subjected to a sudden increase in the trap stiffness. The inset shows the time evolution of the trap stiffness. c, As in b but averaged over 50 shots. d, Single shot velocity distribution for a cloud which was subjected to a weak, sinusoidal modulation of the trap stiffness at 2.17 kHz. The inset shows the time evolution of the trap stiffness. e, As in d but averaged over 780 shots.

FIG. 3 .

 3 FIG.3. Density correlations after a periodic modulation (color online). a, Normalized correlation function g(2) (vz, v z ) measured after sinusoidal modulation of the trap frequency at a frequency ωm/2π = 2.17 kHz, averaging over 243 experimental shots. We observe a strong correlation between well defined, oppositely directed velocities. b, Plot of the density distribution (blue) and of the anti-diagonal velocity correlation function, g(2) (vz, v z = -vz) (red).

1 ModulationFIG. 4 .

 14 FIG. 4. Dispersion relation observed by modulating the trap depth (color online). a, The orange squares show the sideband velocity determined from the density distributions. The green triangles are derived from the correlation functions of the same data. The curve is a fit to the dispersion relation (1) as described in the text. Only the solid squares were included in the fit: these points were all taken on the same day, whereas the open squares were taken under slightly different trap conditions, with possibly different density. The error bars are statistical estimates based on the fits to the velocity distributions such as in figure 3b. b, Comparison between trap modulation and Bragg scattering. The black circles are observations of the dispersion relation by Bragg spectroscopy. The orange squares are found as in (a), and clearly show that the corresponding frequency is about a factor of two higher than in the Bragg data at a given velocity. The curves show the two fits discussed in the text. The vertical error bars on the Bragg data are determined by fits to the Bragg resonances.


Minh Tu Ton That
email: minh-tu.ton-that@univ-ubs.fr

Salah Sadou
email: salah.sadou@univ-ubs.fr

Flavio Oquendo
email: flavio.oquendo@univ-ubs.fr

Using Architectural Patterns to Define Architectural Decisions

Keywords: architectural decision, pattern, SOA

During the architecture development process, architectural design decisions play an important role in maintaining non-functional properties of the system. Instead of supposing that architectural decisions are implicitly recognizable, existing works propose to give them first-class status. However, little focus is paid on the automation of architectural decision checking. This paper proposes to leverage pattern formalization techniques to document architectural decisions. The approach consists of a way to describe architectural patterns that hold the architectural decision definition, show how to integrate architectural decisions (patterns) into an architectural model and finally automate the architectural decision conformance checking.

I. INTRODUCTION

One of the major problems of software development lies in the "maintenance and evolution" stage. Indeed, given the high costs associated with this stage (about 80% of the total cost), it becomes important to find a solution to reduce them. The main factors of this problem are the non-compliance with established practices and the lack of explicitness of the choices made throughout the development process.

If we are in the first case and we need to apply an evolution, we must first rebuild what has already been improperly built. Applying an evolution on a poorly constructed system can only make it more complex and ultimately not able to evolve further (Lehman second law [START_REF] Lehman | Programs, life cycles, and laws of software evolution[END_REF]). In the second case, the system is well developed, except that the intentions behind each choice are not explicit. There are always different solutions to achieve a change, but some of them may be in contradiction with certain implicit intentions. Moreover, it can take several steps between the creation of the contradiction and its detection. This requires undoing what has already been built, resulting in an important additional costs.

The first factor of the problem cited above may be avoided by human or automatic controls [START_REF] Gloahec | Good architecture = good (adl + practices)[END_REF] to check compliance with good practices. To avoid the second factor, we need to make explicit and exploitable intentions that lie behind each choice. The explicitness must begin at the software architecture definition stage. In this paper we will focus on this last point.

The intention associated with an architectural choice is designated in the literature by the term "Architectural Decision" (AD) [START_REF] Jansen | Software architecture as a set of architectural design decisions[END_REF]. Thus, the objective is to define the links that bind the components of AD: the property identification, the involved architectural elements and the rules defining the property. A formalization of this link serves to automatically check that an evolution does not conflict with the choices already made. Several studies have already been made to define such links [START_REF] Tibermacine | Preserving architectural choices throughout the component-based software development process[END_REF], [START_REF] Knemann | Linking design decisions to design models in model-based software development[END_REF], [START_REF] Tibermacine | A family of languages for architecture constraint specification[END_REF], [START_REF] Tibermacine | Component-based specification of software architecture constraints[END_REF]. Proposed solutions usually consist of elements added to the architecture (constraints, specification, etc.) to establish the link. Although these elements indicate the presence of ADs, they do not encourage the architect to use the best solutions and/or good practices. Moreover, the added elements are often described using a language that is different from the ADL used for the architecture description. So, understanding the architecture requires a review of different elements from different languages, which complicates the task. As understanding the architecture is a step prior to its evolution, its complication undoubtedly induces a significant cost.

With this paper we propose to make the architectural decision a first class entity in the architecture description languages. We chose to use the architectural patterns as a support for describing the architectural decisions. In our approach, an architecture consists of architectural elements, their relationships and a set of definitions of architectural views. From a given architecture several architectural views can be obtained, but only a few among these views really have meaning. The views that we associate with the architecture are those that highlight the architectural decisions. Thus, when a view conforms with a pattern, it implies the presence of an architectural decision.

The remaining of the paper is organized as follows: Sect. 2 introduces the general approach, Sect. 3 goes into detail the reusable AD creation step, Sect. 4 describes AD manipulation stage, Sect. 5 introduces the implemented tool and the experimentation, Sect. 6 discusses related work, and Sect. 7 concludes the paper.

II. GENERAL APPROACH

The main idea behind our work is the leverage of architectural patterns as forms of AD representation. Similar to [START_REF] Zimmermann | Reusable architectural decision models for enterprise application development[END_REF], AD documentation in our approach falls into three steps: AD creation, AD integration and AD verification. Decision creation consists in the specification of an AD made to an architectural model. A decision could be specific to a project or reusable within different projects. Architectural decisions could be well-known architectural patterns which are lessons learned from many previous works or decisions that have high potential to be reused in an enterprise. AD integration is a step in which architects link ADs with affected elements in the architectural model. During the AD verification step, the architectural model is checked whether it complies with the integrated ADs.

On the purpose of automating the process of AD documentation, we use the Model Driven Architecture (MDA) approach [START_REF]Model-driven architecture[END_REF]. Each artifact is considered as a model conforming to its meta-model in order to create a systematic process thanks to model transformations and leverage existing MDA techniques (e.g. conformity verification).

In the remainder of this section, we will go further into each step in the AD documentation process, clarify its objectives and explain how we achieve them with our approach. To be more concrete, in the remainder we will use the case of service-oriented architectures.

A. Decision creation

The first objective of decision creation is to facilitate communication between individuals and teams by creating a visual, compact AD model. In a collaborative working environment, ADs are often shared among members and teams in the project. Therefore, compact, visual AD models are welcomed instead of immense and complex ones. Our second objective is to increase reusability by languageindependent ADs. During the process of reusing ADs, it becomes apparent that architects are likely to deal with architectural models described in different languages. As a consequence, a language-independent AD documentation model supporting adaptation to whatever language is needed.

Our approach relies on the fact that an architectural decision can be represented generically by a pattern. As shown in Figure 1 (Pattern definition part), we propose the use of a general pattern meta-model which contains only architectural elements involved in the AD definition. These elements are determined through a survey of well-known architectural patterns [START_REF] Buschmann | Pattern-Oriented Software Architecture[END_REF] according to the used ADL and some properties related to the way to define patterns. Thus, this meta-model is dependent on the family of the used ADL. In this paper, we propose a general pattern meta-model for the Service-Oriented ADL family that allows description of patterns such those defined in [START_REF] Thomas | SOA Design Patterns[END_REF]. Based on this general pattern metamodel, one can define a meaningful architectural pattern in form of a pattern model using only necessary elements and hence, the first objective is satisfied. Furthermore, pattern models are also language-independent. With the separation between AD documentation and architectural design, no modification to the architectural model is needed to define an AD, which makes it easy to adapt to different architectural languages of the same family.

B. Decision integration

Links between AD elements and their correspondent architectural elements play an important role in keeping track of AD made to an architectural model. An explicit linking will facilitate the AD documentation as well as the AD modification (if there is one) in the future. In our approach, links between AD elements and architectural elements are represented by mapping models (illustrated in the Pattern verification part of Figure 1). We can observe here that an architectural model is now a combination of architectural elements and mapping models associated with them. A mapping model indicates that an AD is made on an architectural model.

In the literature, architecture is considered as a set of views which are representations of system elements and relations associated with them [START_REF] Clements | Documenting software architectures: Views and beyond[END_REF]. Each view serves a specific purpose depending on the concerns of one or more stakeholders. Having taken this viewpoint into account, we propose to consider an architectural model as a multiview representation where each view contains only elements related to a specific AD. In this scenario, architectural views are filtered from the architectural model through a transformation mechanism in which mapping models play the role of integrating AD's information into the architectural model.

C. Decision verification

To make sure that an architectural model is consistent with ADs, not only do the existence of AD-related elements in an architectural model need to be verified but also the constraints imposed on them need to be handled. To achieve the first goal, the presence of ADs in the architectural model is checked through the completeness of mapping models. Indeed, mapping models are intermediary bridges between the architectural model and ADs and thus, the incompleteness of mapping models shows the lack of ADs in the architectural model. To achieve the second goal, the constraints imposed by ADs on the architectural model are checked through the conformity of AD architectural views with their corresponding AD view models. To check the conformity of views to patterns it is possible to define similarity functions between models, as it was done in [START_REF] Ramos | Matching model snippets[END_REF] or leverage the meta-model representation form of patterns as in [START_REF] France | A umlbased pattern specification technique[END_REF]. We chose to first transform the architectural patterns into meta-models (AD view meta-models in figure 1) in order to make use of consistency checking tools from MDA. Indeed, we believe that defining a function that checks the conformity of a view (model) with a pattern (generic model) would lead largely to redefine a function which checks conformity of a model with a meta-model. And contrary to [START_REF] France | A umlbased pattern specification technique[END_REF], we do not modify the initial language

III. REUSABLE AD CREATION

After having generally introduced the reusable AD creation stage in the previous section, in this section we aim at going further into detail. As we choose architectural pattern as the form of AD representation, the process of creating an AD consists in specifying a pattern model. We first introduce the General pattern meta-model from which ADs are created. Next, we clarify the AD creation process through a concrete example.

A. General pattern meta-model

The general pattern meta-model provides the language to define an architectural pattern. It contains all necessary architectural features from an ADL to create a pattern. Since we validate our approach in the SOA domain, our general pattern meta-model is purposely proposed for SOA. As shown in Figure 2, the meta-model is composed of 2 parts: pattern structure and architectural structure.

Inspired by the SCA model 1 [START_REF] Beisiegel | SCA service component architecture[END_REF], we construct the structural aspect of our General Pattern Meta-Model for the SOA description language family as follows:

• Composite serves as the container to assemble and connect service-oriented building blocks together. • Components are basic units of the architecture that represent business functions from which composite applications are built. • A component is composed of component services and component references. The former provide functionalities supported by the component and the latter play 1 SCA is a model created by a group of industrial partners to support building applications and systems using SOA solution. A component reference can be wired to a component service through its target attribute.

• Thinking of composites as black-box components, they have also services and references. To be consumed by the world outside of a composite, a component service of the containing component can be promoted as a service of the composite. Similarly, to be served by an outside service, a component reference should be promoted as a composites reference.

The pattern aspect part of our meta-model aims at providing functionalities to characterize a meaningful architectural pattern. To be more specific, the meta-model allows us to describe a pattern at two level: generic and concrete. Via the isGeneric attribute, we can specify an element as generic or concrete. A concrete element provides guidance on a specific pattern-related feature. Being generic, an element represents a set of concrete elements playing the same role in the architecture. Each element in the meta-model can be associated with a role. A role specifies properties that a model element must have if it is to be part of a pattern solution model [START_REF] France | A umlbased pattern specification technique[END_REF]. To characterize a role, we provide two supports: constraint and multiplicity. A constraint made to a role on an element helps make sure that the element participating in a pattern has the aimed characteristics. Constraints are represented in our approach in form of OCL [START_REF] Omg | Object Constraint Language, OCL Version 2.0[END_REF] rules. A multiplicity indicates how many times a pattern-related element should be repeated and how it is repeated. For instance, we can specify that an element in a pattern should be repeated in a maximum of three times and the repeating instances of this element should be organized horizontally. Figure 3 shows two types of orientation organization: vertical and horizontal. Being organized vertically, participating elements are parallel which means that they are all connected to the same elements. On the other hand, being organized horizontally, participating elements are inter-connected as in the case of the pipeline architectural pattern.

B. Architectural Pattern Specification

As described in the previous section, in our approach a reusable AD is represented as a fully understandable architectural pattern with cohesive elements and constraints imposed on them. For the purpose of illustration, we will examine the SOA Legacy Wrapper pattern [START_REF] Thomas | SOA Design Patterns[END_REF].

As shown in Figure 4, the SOA Legacy Wrapper pattern stipulates that in order to eliminate legacy technical details Figure 4. SOA legacy wrapper pattern [START_REF] Thomas | SOA Design Patterns[END_REF] from a legacy component, one should use a wrapper service equipped with a standardized service contract. In other words, every service in the architecture must communicate with the legacy component (if needed) through the legacy wrapper bridge to avoid the potential technical incompatibility. This architectural pattern aims at assuring the system interoperability.

IV. AD MANIPULATION

In our approach, the ADs are on one hand integrated into the architecture description to complete its documentation and on the other hand, they are used as a means to verify that the architecture is consistent with the taken decisions. The integration of an AD to an architectural model is made thanks to a mapping model, and the checking of the conformance of the architecture with an AD is made thanks to a particular view on the architectural.

A. Associating an AD to an Architectural Model

The association of an AD with an architectural model consists of defining a mapping model between the latter and an architectural pattern representing the AD. The mapping model is part of the architectural model as a means to associate an AD to the architecture. Concretely, it links elements in the architecture that directly relates to elements from the pattern model.

The mapping meta-model consists of one meta-class per type of mapping. So, each meta-class defines a mapping between an element's type from the ADL meta-model that may participate in architectural patterns and an element's type in the general pattern meta-model. For the purpose of illustration, we built an architecture for the Client Support System (CSS) (as shown in Figure 6) which aims at supporting a company to receive, manage and answer client's requests systematically. Figure 7 sketches the mapping model which associates the Legacy Wrapper pattern to a part of the CSS architecture. As we can see in this figure, two components LegacyPersonnelManage-mentService and PersonnelManagementService in the CSS architecture are mapped respectively to two components playing the roles of legacy component and wrapper component in the Legacy Wrapper pattern model.

B. Extracting AD views

The architectural views are very useful for understanding the overall architecture of a complex system. In our case, a view is constructed by applying a transformation on the architectural model which targets a given AD. The transformation serves as a filter to realize two purposes: first, extract from the architectural model elements relating to ADs and second, eliminate language-specific features to create a language-independent architectural model. Therefore, this can be compared to the transformation step from PSM (platform specific model) to PIM (platform independent model) in the MDA approach. To realize this, we leverage the MDA transformation techniques. More precisely, we use ATL [START_REF] Jouault | Atl: a qvt-like transformation language[END_REF] transformation rules to transform architectural models into AD view models.

Thus, the transformation consists of:

• From the architectural model, transform one by one only elements whose equivalent type is specified in the pattern model. • Based on the mapping model, copy role information of mapped elements from the architectural model to their equivalent elements in the AD view. The following is an excerpt of one of the rules associated with the SOA Legacy Wrapper pattern used in the mapping of figure 7 As illustrated, the rule above transforms a SCA composite to a composite according to the AD view. First, the rule searches through the mapping model if there is a mapping in which the SCA composite is a source. If there is, the rule transforms the role the composite plays in the pattern to a composite in the AD view. Second, based on the existence of the component, the service and the reference in the pattern model, the rule transforms their values respectively to their corresponding in the AD view. The result of this transformation is an AD view which contains only ADrelated elements with roles embedded on some of them.

C. AD Checking

The conformity of an architectural model with one of its associated ADs is verified through the conformity of the extracted AD view with the concerned architectural pattern. We chose to leverage the MDA verification technique to realize this step. Therefore, in our approach, AD view metamodels are generated from pattern models for the purpose of checking. The consistency of an AD view is thus verified against its corresponding AD view meta-model.

For every pattern model defined, an AD view meta-model is generated containing a subset of meta-classes, from the general pattern meta-model, that participate in the definition of the pattern model. Applying this principle to the Legacy Wrapper pattern model described in the previous section, we obtain an AD view meta-model with the participation of only three meta-classes: Component, ComponentService and ComponentReference as shown in Figure 8. This meta-model is embedded with invariants imposed on the Component meta-class as follows: Invariants on meta-classes correspond to constraints specified on their instances that have a specified role in the pattern model. Furthermore, information about orientation and multiplicity are also reflected in the meta-model via invariants on meta-classes. We can observe through the example that the constraint imposed on the LegacyComponent role in the pattern model is transformed into a legacyWrapper invariant on the Component meta-class with a condition on the LegacyComponent role. The multiplicity of the Wrapper-Component role in the pattern model is transformed into two other invariants in the Component meta-class: multiplicity and orientation. We will not present the transformation rule here because of the lack of space but basically it consists in:

• Transform one by one all elements with their role information.

• Add relations between elements based on their existence in the target meta-model. • Constraints specified on role are reflected in the metaclass. • Multiplicity information specified on roles are reflected in the meta-class. After being generated, the AD view meta-model is used to check the the consistency of AD view. Whenever there is a violation of constraints imposed by the AD view metamodels on AD views, warnings are notified to the architect about which AD is violated and which elements in the architectural model are involved.

V. IMPLEMENTATION AND EXPERIMENTATION

To verify the feasibility of our approach, we developed a tool called ADManager, then we applied it to the case of SOA.

A. ADManager tool

With ADManager we aim to make concrete the aforementioned concepts. The tool provides the following functionalities:

1) Create architectural patterns (support of ADs definition) 2) Integrate ADs to architectural models 3) Verify the consistency of architectural models according to the held ADs. ADManager is developed based on EMF (Eclipse Modelling Framework). We choose EMF to realize our tool since we leverage MDA, where models are basic building units, to develop our approach. As shown in Figure 9, the tool consists of five Eclipse plug-ins built on existing Eclipse technologies. They are:

• Pattern creation plug-in uses EMF modeling support in order to allow architects to define Pattern models. This editor depends on the General Pattern Meta-Model (see figure 1, which is given as a parameter. Thus, according to the targeted ADL family we need to give the corresponding General Pattern Meta-Model. [START_REF] Thomas | SOA Design Patterns[END_REF] and architectural model elements. It depends on the Mapping Meta-Model, which is also depending on the targeted ADL family.

• AD verification plug-in uses OCL tool to support writing rules in pattern models, during pattern creation, as well as conformance verification between AD view models and AD view meta-models during AD checking. It relies on General Pattern Meta-Model to check the consistency of OCL rules. • AD view meta-model generator plug-in uses ATL to implement rules generating AD view meta-models from pattern models. It relies mainly on General Pattern Meta-Model. • AD view generator plug-in uses ATL to implement rules generating AD views from architectural models. It relies mainly on the mapping models attached with the latter. Thus, for ADManager to work, it needs to have the General Pattern Meta-Model and the Mapping Meta-Model that are already defined. We did it for the SOA description language family (see the previous section). Thus, to switch to another language family (such as object-oriented), we must provide the appropriate meta-models. The Mapping Meta-Model can be produced very easily when we have General Pattern Meta-Model. To produce the latter we need a good knowledge on the ADL family. Note that in Figure 2 the example of General Pattern Meta-Model for SOA is separated into two parts: one specific to the SOA description language family and the other for the notion of pattern. Thus, this example can be reused for producing a new General Pattern Meta-Model only by redefining the part related to the targeted ADL family.

B. Experimentation with SOA Patterns

As can be guessed from reading our paper, we experimented with our approach on Service-Oriented ADLs. Thus, we wanted to verify that our tool allows the definition of well known SOA patterns. So, we have examined the SOA patterns from [START_REF] Thomas | SOA Design Patterns[END_REF] (Synthetized in table I).

In the table I we reused the categorization of patterns given in [START_REF] Thomas | SOA Design Patterns[END_REF]. Among the 74 identified patterns there are up to 45 patterns focusing on the aspect of service management Figure 9. The architecture of ADManager such as how to centralize or decentralize services physically, how to determine the boundary of service logic, how to add additional routines to service processing, etc. Therefore, these patterns cannot be documented using concepts from the ADL.

In fact, as we can observe in the table I, Among the remaining 29 architectural patterns there are ones based on architectural concepts that are not supported yet by SOADLs such as service inventory, service layer, service state data, data schema... That explains why only 13 patterns are documented using our approach. Most of the formalizable patterns fall into the Service design pattern category. Indeed, patterns in this category are good practices in service organization, encapsulation, implementation, governance and therefore, suitable to be documented architecturally. However, all those falling into this category are not related only on architectural aspects. For instance, the service identification patterns aim to conceptually decide a suitable level in which solution logic is decomposed and service encapsulation is identified are not documented. It is obvious that these patterns serve a purpose in organizing the logic of the system and thus, they are not purely architectural patterns.

in the Service composition design pattern category there are two patterns (namely Neutral Sub-controller and Brokered Authentication) that are possibly documented due to the fact that they manipulate certain architectural elements to stipulate their logic such as service, composite service, etc.

As illustrated in the designed CSS architecture (see fig- First, we have successfully checked that the architecture respects the three ADs. After that, we have made several modifications to the architecture where we know they lead to an AD violation. Each time the tool indicates the correct violated AD and which elements in the architecture are involved. Therefore, the test succeeded.

C. Discussion

The pattern description language is based on the target ADL as shown in Figure 2. If we take the meta-model of the target ADL as basis to define the pattern description language, we get a language capable of expressing all what can express the target ADL. Two goals are sought by allowing the description of patterns related to a project or a company: making architectural decisions explicit and reusable at least in their context (project or company). This last point implies a certain genericity in the description of patterns. We know that all elements of the target ADL are not necessary to describe patterns. So, ignoring them in the meta-model of pattern description allows for a simplified and more generic language.

Thus, we must find a balance between lightness and completeness of the pattern description language. For the case of SOA (see figure 2, which is used as example in this paper, we do not claim that we found the best balance. However, our experiment showed us that we can express the classical patterns related to SOA. We do not need to validate the coverage of all possible patterns for two reasons: i) It is not possible to imagine all possible architectural decisions. ii) the coverage depends on the meta-model of pattern description that is a data of our approach.

Therefore, the design of the meta-model for pattern description requires not only a good knowledge of the target ADL and its meta-model, but also extensive experience of its use. Thus, it would be interesting to define meta-models of architectural pattern description for the classical ADLs and make them available to others. Sharing these meta-models allows on one hand to help others and on the other hand, to get feedback to improve them. For companies that use exotic ADLs, the definition of such a meta-model should be left to more experienced architects.

The reader may obtain a complete guiding tutorial video and more information about the ADManager tool using the CSS application at http://www-valoria.univ-ubs.fr/SE/ ADManager.

VI. RELATED WORK

Our work directly concerns the definition of architectural decisions, but also concerns the AD conformance checking aspect. As we have chosen to represent ADs through architectural patterns, our work is also related to works on pattern definition. Thus, in the following we will discuss work related to these three aspects.

A. AD Documentation

In the literature there are many proposed models and tools supporting AD documentation. Among these works, we can mention some representative models such as the architectural decision template [START_REF] Tyree | Architecture decisions: Demystifying architecture[END_REF], the ontology of design decisions [START_REF] Kruchten | Building up and reasoning about architectural knowledge[END_REF] or recently the MAD 2.0 model [START_REF] Zalewski | Capturing architecture evolution with maps of architectural decisions 2.0[END_REF], and tools such as Archium [START_REF] Jansen | Software architecture as a set of architectural design decisions[END_REF], ADDSS [START_REF] Capilla | A web-based tool for managing architectural design decisions[END_REF], AREL [START_REF] Tang | A rationale-based architecture model for design traceability and reasoning[END_REF]. We can observe that most of these works concentrate on capturing and characterizing ADs but none of them provide the automated checking of design decision compliance in architectural models. In our work, we do not attempt to just define another AD model but propose a way to define ADs which allows to automatically detect their violation in the architectural model.

In [START_REF] Zimmermann | Reusable architectural decision models for enterprise application development[END_REF], Zimmermann et al. point out the importance of reusable ADs in decision identification, decision making and decision enforcement and propose a model to document reusable ADs. Furthermore, in [START_REF] Zimmermann | Combining pattern languages and reusable architectural decision models into a comprehensive and comprehensible design method[END_REF], they propose to weave pattern languages into reusable architectural decision models to benefit their mutual interests. Besides that, in [START_REF] Harrison | Leveraging architecture patterns to satisfy quality attributes[END_REF], Harrison et al. compare pattern and AD and think that the former can be leveraged to document the latter. We found these ideas interesting, thus we have gone further with our approach, which formalizes the representation of ADs with patterns.

B. AD Conformance Checking

Being one of the first works dealing with AD conformance checking, Tibermacine et al. [START_REF] Tibermacine | Preserving architectural choices throughout the component-based software development process[END_REF], [START_REF] Tibermacine | A family of languages for architecture constraint specification[END_REF] propose a family of architectural constraint languages to describe the structural part of AD. Architectural constraints are used as a means to formalize ADs. With our approach we raise the level of abstraction by using architectural patterns to document ADs. ADs are no longer architectural constraints imposed on the architectural model but self-contained semantic pattern models.

In another work, Könemann et al. [START_REF] Knemann | Linking design decisions to design models in model-based software development[END_REF] propose a linking model to bind architectural decisions and architectural models. The consistence of the architectural model is checked through the completeness of the binding model. The structuring part of the AD is specified through model differences.

In our approach, the conformance of the AD against its architectural model is checked through not only the mapping model but also the AD model itself. By using pattern to describe the structuring part of AD, we make sure that an AD is reflected semantically in the architectural model.

C. Pattern Definition

In [START_REF] France | A umlbased pattern specification technique[END_REF], France et al. modify UML to incorporate pattern definition features. As architectural decisions are generally specific to concrete projects, patterns in our approach must not be static in a language and thus, the support of defining new patterns becomes essential. In [START_REF] Elaasar | A metamodeling approach to pattern specification[END_REF], Elaasar et al. propose to bring concepts from the pattern specification language to the meta-meta-model. The modified meta-metamodel called Epattern is used to specify pattern metamodels. We can consider this approach as a pass from meta-meta-model level to meta-model level to define pattern language. In another work [START_REF] Ramos | Matching model snippets[END_REF] et al. propose to express patterns as model snippets. The conformity of patterns is checked through pattern-matching functions between pattern models. We consider this approach as a pass from model level to model level to define pattern language. As opposed to the two above approaches, our approach defines patterns as models and transform them to meta-models for verification and thus, can be considered as a pass from model level to meta-model level to define pattern language. Thus, we can reuse the classical features concerning the conformity of a model to a meta-model.

VII. CONCLUSION

Keeping track of ADs made on a system is very important to avoid degrading it during its evolution. Although there existed a lot of works focusing on documenting ADs, the automation of AD checking during the development of the architecture is still an open issue.

In this paper, we propose to document ADs in the form of formalized patterns. This approach helps guarantee the existence of ADs not only in syntactic aspect but also in some semantic aspects. With the presented approach, the purpose of AD checking, which is an error-prone task, was automated. Besides, the reusability characteristic of AD is also taken into consideration since we leverage a languageindependent AD creation mechanism. We also implemented a tool to realize our approach. We utilize the case of SOA to validate our approach but it is thoroughly relevant to other types of ADLs.

Still, we recognize some limitations in our approach. For example, considering the complexity of possible architectural patterns, we think that our general pattern meta-model is still not entirely sufficient. For instance, our pattern model only supports the multiplicity specification at element level, which makes it difficult to specify complicated patterns. For instance, when a pattern is composed of other patterns we may need to specify a multiplicity on some of the latter.

To overcome the above limitation, we are currently working on the way to incorporate more supports in the general pattern meta-model. For instance, to increase the generality of the multiplicity attribute of a role in the pattern, we intend to make it attachable to a group of elements. Thus, our pattern becomes a composite pattern composed of internal sub-patterns.

Figure 1 .

 1 Figure 1. MDA approach for AD documentation

Figure 2 .

 2 Figure 2. SOA General Pattern Meta-model

Figure 3 .

 3 Figure 3. Orientation organization of generic elements

Figure 5 .

 5 Figure 5. SOA Legacy Wrapper pattern model

Figure 7 .

 7 Figure 7. Mapping model for SOA Legacy Wrapper pattern in CSS

Figure 8 .

 8 Figure 8. AD view meta-model for the Legacy Wrapper pattern

  ure 6), we documented the three following patterns: Legacy Wrapper, Service Fac ¸cade and Redundant Implementation. Except for the Legacy Wrapper pattern which is well explained as an example in previous sections, we can also observe the two other patterns in CSS: The Client Management Fac ¸cade component plays the role of a fac ¸cade for the two components Client Policy Service and Client Information Service; the Request Receiving Service component is backed up by the Request Receiving Service Backup component.

  :

	Figure 6. Client Support System architecture
	rule Composite2Composite {
	from
	scai : SCAMM!Composite(GeneralSOAMM!Composite.
	allInstances()->notEmpty())
	to
	spo : SOAPatternMM!Composite(
	name <-scai.name,
	role <-if (not scai.getMappingFromComposite().
	oclIsUndefined())
	then scai.getMappingFromComposite().target.role
	else OclUndefined endif,
	component <-if (GeneralSOAMM!Component.
	allInstances()->notEmpty())
	then scai.component
	else OclUndefined endif,
	service <-if (GeneralSOAMM!Service.
	allInstances()->notEmpty())
	then scai.service
	else OclUndefined endif,
	reference <-if (GeneralSOAMM!Reference.
	allInstances()->notEmpty())
	then scai.reference
	else OclUndefined endif
	)
	}