Transforming Final Constraints

So far, a main cost expression E_ph and a set of non-final constraintsIC_ph for a phaseph= (c₁∨ · · · ∨c_n)⁺ have been computed. Algorithm 3 completes the phase’s cost structure with a set of final constraints FC_ph(x_sx_f)(and possibly additional non-final constraints) that bind the intermediate variables ofE_phand IC_ph. The algorithm receives the partial cost structure computed so far〈E_ph,IC_ph〉, the final constraints of the CE’s cost structures〈FC_c

1,FC_c

2,· · ·,FC_cn〉, and the cost equations of the phaseph.

Algorithm3Initialization

For each c_i with cost structure〈E_ci,IC_ci,FC_ci(x x⁰)〉, the algorithm maintains two sets ofpending con-straintsPsums^ci andPms^ci. These sets contain the constraints that have to be transformed to bind their corresponding Sum variables or Max/Min variables. FunctioninitPending (Line4) initializes the pend-ing sets uspend-ing the final constraints of eachc_i ∈phand considering the set of used variables in E_ph and IC_ph. LetUsed:=uses(〈E_ph,IC_ph〉), it returns the sets:

Psums^ci:= P

iv./klk ∈FC_ci (smiv∩Used)6=; ∪

iv_{i ti} ≤1,iv_{i ti}≥1 #c_i∈Used Pms^ci:=

iv_k≤ klk ∈FC_ci divek∈Used ∪

iv_k≥ klk ∈FC_ci bivck∈Used

(1) Psums^ci is initialized with the constraints of FC_ci such that some smiv_k in smiv has to be bound (because it is used in the cost structure). Additionally, the constraints iv_{i ti} ≤1 andiv_{i ti} ≥1 are added if #c_i has to be bound. The variable iv_{i ti} represents the number of times c_i is evaluated such that smiv_{i ti} =#c_i.

(2) Pms^ci is initialized with the constraints of FC_ci with a single variable on the left side such that the corresponding dive or bivc has to be bound (it is used in the cost structure). As mentioned before, the constraints of the formPm

k=1iv_k≤ klk can be split into iv_k ≤ klk for1≤k ≤m on demand during the initialization ofPms^ci.

Algorithm3Main loop

The main loop of the algorithm iterates over the pending sets (Lines 7-9). In each iteration, the algorithm removes one constraint fc from one of the pending sets (function takeElem in Line 8) and applies one or several strategies to the removed constraint (function applyStrategies in Line 9). The variableorigin indicates the origin of the constraint, that is, whether the constraint was in a setPsums^ci orPms^ci and from which CEc_i. A strategy generates new constraints (final or non-final) for the phase’s cost structure using the cost equations in ph. Psums is also passed to applyStrategies because some strategies can take additional pending constraints into account. The generated constraints are added to

6.5. Phases 87

the setsIC_ph orFC_ph. A strategy can also add additional constraints to the pending setsPsumsorPms to be processed later. The algorithm repeats the process until allPsums^ci andPms^ci are empty (Line7).

In principle, the algorithm can finish without generating constraints for all intermediate variables.

For instance, if the cost of the phase is actually infinite or some of the strategies fail to generate any constraint. It is also possible that the algorithm does not terminate if new constraints keep being added to the pending sets indefinitely. However, this does not happen often in practice. The loop condition can be strengthened to ensure termination. For instance, the loop can exit if all the intermediate variables are already directly or indirectly bound by final constraints. In addition, a limit can be established on the total number of iterations or on the number of times that additional pending constraints can be added toPsumsandPms.

The remaining of this section contains a series of strategies to deal with different kind of constraints and phase behaviors and, at the end of the section, there is an example of how these strategies work together to obtain a complex cost structure.

Inductive Sum Strategy LetP

iv./kl(x x⁰)k ∈Psums^ci be a pending constraint, the strategy tries to find a linear expression that approximates the sumP#c_i

j=1kl(a_c

ija⁰_c

ij)kfor any evaluation in terms of the initial and final values of the phase (a_sa_f).

Remember that the CEs in the phase have the formc_i:C(x :y) =ϕi,b,C(x⁰:y⁰),bwhereC(x⁰:y⁰)is the only recursive call;ϕ_i is the CE’s constraint set; andx y and x⁰y⁰ are the input and output variables of the head and the recursive call.

Let us consider first the simple case where c_i is the only CE in the phase. The strategy uses the CE’s constraint set ϕi and Farkas’ Lemma to generate a candidate linear expression cd(x) such that ϕ_i⇒(kl(x x⁰)k./cd(x)−cd(x⁰)≥0). If a candidatecd(x)is found, for any evaluation we have:

Xsmiv./

#c_i

X

j=1

kl(a_cija⁰_c

ij)k./

#c_i

X

j=1

(cd(a_cij)−cd(a⁰_c

ij)) =cd(a_s)−cd(a_f)

This is because each intermediate −cd(a⁰_c

ij) and cd(ac_ij+1) cancel each other (cd(a⁰_c

ij) = cd(ac_ij+1)).

Therefore, the constraintP

smiv./kcd(xs)−cd(xf)kis valid and can be added toFC_ph.

Example 6.26. This is the case of phase(9)⁺ of Program13with the variablesi_s,z_s,i_f,z_f andPsums⁹= {iv_{i t}

9≤1,iv_{i t}

9≥1}. The strategy generates the candidate−ifor both iv_{i t}

9 ≤1andiv_{i t}

9 ≥1. We have {i<z,i⁰ = i+1} ⇒ k1k ≤ −i−(−i⁰) and {i <z,i⁰ =i+1} ⇒ k1k ≥ −i−(−i⁰). The generated final constraints aresmiv_{i t9} ≤ ki_f −i_sk andsmiv_{i t9} ≥ ki_f −i_sk. Later ki_f −i_sk will become kz−ik in chain (9)⁺(8)andkzkin CE7. The variablesmiv_{i t}

9corresponds toiv₁ in Figure6.3.

If the phase contains other CEs c_e (e 6= i), their effect on the sum has to be taken into account. For example, suppose that we have anotherc_e(e6=i) that increments our candidate by two (ϕ_e⇒cd(x⁰) = cd(x)+2). Between two consecutive evaluations ofc_i(thej-th and the(j+1)-th evaluations), there might be a number of evaluations n_e of c_e that increment the candidate by 2n_e (cd(x_c

ij+1) =cd(x_c⁰

ij) +2n_e).

If we consider the complete phase evaluation wherec_e is evaluated#c_e times, we obtain the following sum:

Xsmiv./

#c_i

X

j=1

kl(ac_ija⁰_c

ij)k./

#c_i

X

j=1

cd(ac_ij)−cd(a⁰_c

ij) =cd(as)−cd(af) +2#c_e

Table 6.1.: CE Classification conditions for strategies: A CE c_e can be classified into a class with respect to a candidatecd(x)if its condition is satisfied. Each class defines an expression/intermediate variable.

Class Condition when./is≤ Condition when./is≥ Defines

Cnt (P

iv⁰./kl⁰k)∈Psums^ce∧ kl⁰k./cd(x)−cd(x⁰)≥0 cnt_e:=P smiv⁰ Dc 0≤dc_e(x x⁰)≤cd(x)−cd(x⁰) dc_e(x x⁰)≥cd(x)−cd(x⁰) iv_dce :=kdc_e(x x⁰)k Ic ic_e(x x⁰)≥cd(x⁰)−cd(x) 0≤ic_e(x x⁰)≤cd(x⁰)−cd(x) iv_ice:=kic_e(x x⁰)k

CntR (P

iv⁰≤ kl⁰k)∈Psums^ce∧ kl⁰k ≤ kcd(x)k − kcd(x⁰)k cntr_e:=P smiv⁰ Rst cd(x⁰)./krst_e(x)k iv_rste :=krst_e(x)k

CntT P

iv⁰./kl⁰k

∈Psums^ce∧l⁰./cd(x)≥0∧cd(x⁰)−cd(x)./q_e cntt_e:=P smiv⁰

Nop cd(x⁰)−cd(x) =0

That is, the sum computed for the simple casecd(a_s)−cd(a_f)plus the sum of all the increments to the candidate2#c_eeffected by CEc_e. This constraint can be expressed with the following intermediate and final constraints:

Psmiv./iv_cd+−iv_cd−+2#c_e iv_cd+./kcd(x_s)−cd(x_f)k iv_cd−!./k−cd(x_s) +cd(x_f)k whereiv_cd+andiv_cd−represent the positive and negative part ofcd(x_s)−cd(x_f)and!./is the opposite operator of./(if./is≤, the operator!./is≥and vice-versa).

In the general case, the strategy is divided into three steps:

1. First, the strategy generates a candidate cdusing c_i’s constraint setϕi, the condition kl(x x⁰)k ./

cd(x)−cd(x⁰)≥0, and Farkas’ Lemma (as in the simple case before).

2. Next, it classifies the CEs of the phase c_e ∈ ph (including c_i) according to their effect on the candidate.

3. Finally, it uses this classification to generate constraints that take these effects into account.

Let us consider now the second and third steps:

Cost Equation Classification

Each c_e∈phhas to be classified with respect to a candidatecdinto a class. Each class has a condition and defines a linear expression (see Table 6.1). In order to classify a CE c_e into a class, its condition has to be implied by the corresponding CE’s constraint setϕe. Some of the conditions contain unknown linear expressions: dc_e(x x⁰), ic_e(x x⁰) or rst_e(x x⁰) (For the classes Dc, Ic and Rst respectively). The implication can be verified and the unknown linear expressions can be inferred using Farkas’ Lemma and linear templates. The considered classes in this strategy are⁶:

• Cnt:c_e∈Cntif there is a constraintP

iv⁰./kl⁰k ∈Psums^cethat can also be bound by the candidate:

ϕe ⇒ kl⁰k./ cd(x)−cd(x⁰). The expressionP

smiv⁰ can be incorporated to the left-hand side of the constraint. We definecnt_e:=P

smiv⁰ as a shorthand. Note thatc_i, whose constraint was used to generate the candidate in the first place, trivially satisfies the condition and thusc_i ∈Cnt.

6 The rest of the classes are used by other strategies.

6.5. Phases 89

• Dc: c_e∈Dcif in each evaluation ofc_ethe candidate is decremented by at leastdc_e(x x⁰)(or at most dc_e(x x⁰) if./ is ≥). A fresh intermediate variable is assigned to this amountiv_dce :=kdc_e(x x⁰)k. To generate a valid constraint, the sum of all those decrements, that issmiv_dce, is subtracted from the right-hand side of the constraint.

• Ic: c_e ∈ Ic if in each evaluation of c_e the candidate is incremented by at most ic_e(x x⁰) (or at least ic_e(x x⁰) if ./ is ≥). As before, a fresh intermediate variable is assigned to that amount iv_ice :=kic_e(x x⁰)k. To generate a valid constraint, the sum of all those increments, that is smiv_ice, is added to the right-hand side of the constraint.

Constraint Generation

Once all the CEs in a phase have been classified with respect to a candidate, the strategy generates the following constraints to be added to the phase’s constraints:

Theorem 6.27. Let!./be the reverse of./(e.g.≥if./is≤). If everyc_e∈phhas been successfully classified intoCnt,IcorDcwith respect to a candidatecd(x), the following constraints are valid:

X

ce∈Cnt

cnt_e./iv_cd+−iv_cd−+X

ce∈Ic

smiv_ice− X

ce∈Dc

smiv_dce iv_cd+./kcd(x_s)−cd(x_f)k iv_cd−!./k−cd(x_s) +cd(x_f)k

The proof of this theorem can be found in Section 6.10. Note that iv_cd+ and −iv_cd− represent the positive and negative part ofcd(x_s)−cd(x_f). The constraints bind the sum of allsmivincnt_e (for each c_e∈Cnt) tocd(x_s)−cd(x_f)plus all the incrementsP

ce∈Icsmiv_ice minus all the decrementsP

ce∈Dcsmiv_dce. If the classIcis empty,cd(x_s)−cd(x_f)is guaranteed to be positive (the candidate is never incremented) and the summand−iv_cd−and its corresponding constraintiv_cd−!./k−cd(x_s)+cd(x_f)kcan be eliminated.

Finally, the strategy adds constraints for the new intermediate variables iv_ice and iv_dce to the corre-sponding pending setPsums^ce so their sumssmiv_ice andsmiv_dce are bound afterwards:

• For eachc_e∈Ic, the constraintiv_ice ./kic_e(x x⁰)kis added toPsums^ce

• For eachc_e∈Dc, the constraintiv_dce!./kdc_e(x x⁰)kis added toPsums^ce

Furthermore, if ./ is ≤ the first constraint in Theorem 6.27 can be simplified by removing the in-termediate variables that are subtracted. This maintains the validity of the constraint (remember that intermediate variables are always non-negative) which has the following form:

X

c_e∈Cnt

cnt_e≤iv_cd++X

c_e∈Ic

smiv_ice

This simplification also implies that the pending constraints for eachc_e∈Dccan be discarded.

Example 6.28. In phase(3.1∨3.2)⁺we haveiv₅≤ ky−y⁰+1k ∈Psums^3.2. A valid candidate is y+x. The CEs are classified as follows: CE 3.2∈ Cntbecause it has generated the candidate andcnt_3.2 :=smiv₅; and CE3.1∈Dcbecause y+x decreases in CE3.1bydc_3.1=0. The generated constraints are: smiv₅≤ iv_cd+−iv_cd−−smiv_dc, iv_cd+≤ k(y_s+x_s)−(y_f +x_f)kandiv_cd+≤ k−(y_s+x_s)+(y_f +x_f)k. However, given thatIcis empty anddc_3.1=0, they can be simplified to a single constraint:smiv₅≤ k(y_s+x_s)−(y_f+x_f)k (wheresmiv₅ isiv₆ in Figure6.3).

Example 6.29. The class Cnt makes possible to bind Sum variables of differentc_i under a single con-straint. For instance, if we had⁷ iv_{i t3.1} ≥1∈Psums^3.1 andiv_{i t3.2} ≥1∈Psums^3.2, the expression x would be a valid candidate with the classificationCnt={3.1,3.2}withcnt_3.1:=smiv_{i t3.1} andcnt_3.2:=smiv_{i t3.2}.

7 smiv_{i t3.1} andsmiv_{i t3.2} are actually not needed for computing the cost of the program in this case. Therefore, these constraints are never added to the pending sets.

Program 14 Cost relations void cds (int x ,int y){

int z =*;

while(x >0 && y >0 && z >0) {

if(*) y - -;

else y =*;

x - -;

z - -;

tick (1) ; }

1.1:cds(x,y) ={x>0,y>0,z>0},wh[(3∨4)⁺(2)](x,y,z) 1.2:cds(x,y) =wh[(2)](x,y,z)

2:wh(x,y,z) ={}

3:wh(x,y,z) ={x>0,y>0,z>0,x⁰=x−1,y⁰= y−1, z⁰=z−1}, 1,wh(x⁰,y⁰,z⁰)

4:wh(x,y,z) ={x>0,y>0,z>0,x⁰=x−1,z⁰=z−1}, 1,wh(x⁰,y⁰,z⁰)

Figure 6.4.:Program14: Example where multiple candidates are important

The strategy would generate the (simplified) constraintsmiv_{i t3.1}+smiv_{i t3.2} ≥ kx_s−x_fkwhich is equiva-lent to#c_3.1+#c_3.2≥ kx_s−x_fkand represents thatwh3iterates at leastkx_s−x_fktimes. WithoutCnt, the strategy would fail to obtain a non-trivial lower bound for #c_3.1 or #c_3.2 as they can both be 0(if considered individually).

Discussion

It is worth noting that while the initial motivation for this strategy was to find a linear expression that could bind the sumP

smiv, the resulting constraints do not necessarily represent a linear expression due to the effects of other CEs in the phase. For instance, the added variables capturing incrementssmiv_ice can represent non-linear expressions.

The strategy can fail at two points. (1) It can fail to generate a candidate (if there is no linear constraint that satisfies the conditions) or (2) it can fail to classify the CEs of a phase with respect to a given candidate. In the latter case, it can attempt to generate a different candidate (Possibly taking the CEs where the classification failed into account). Moreover, even if the strategy does not fail, we can adjust it to consider several candidates. In general, the more candidates it considers, the more constraints it will be able to generate and the better precision it can achieve. Evidently, this comes at a cost in terms of performance.

Example 6.30. Let us compute a cost structure for the phase(3∨4)⁺ of Program14(Figure6.4). The initial pending set of CE 3 is Psums³ = {iv_{i t}

3 ≤ 1,iv_{i t}

3 ≥ 1}. The expression y is a valid candidate for iv_{i t}

3 ≤ 1 in CE3. However, CE 4 cannot be classified successfully with respect to the candidate y and consequently the strategy fails at this point. The strategy can backtrack and consider a different candidate.

Both x and z are valid candidates and can successfully classify CE 4 in Cnt with cnt₄ = iv_{i t4}. The generated constraints are: #c₃+#c₄≤ kx_s−x_fkand#c₃+#c₄≤ kz_s−z_fkwhich can be transformed to

#c₃+#c4≤ kxkand#c₃+#c₄≤ kzkfor the chain(3∨4)⁺(2). Unfortunately, even though the candidate z was successfully classified, later in the analysis its corresponding constraint #c₃+#c₄ ≤ kzk will be lost. This is becausezis initialized to an unknown value and thus it cannot be expressed in terms of the input parameters of function x and y. Therefore, if the analysis considers only the candidate z, it will fail to obtain a bound for CE1.1.

Finally, note that this strategy is completely symmetric. It can be used to obtain upper and lower bounds. However, it is not useful for divergent phases in which the variablesx_f cannot be related to any specific value or output variable.

6.5. Phases 91

Inductive Sum Strategy with Resets

This variant of theInductive Sumstrategy allows us to obtain upper bounds of sums in terms of the initial variables of the phase only (x_s). Such bounds are also useful for divergent phases. The strategy follows the same scheme as before.

Candidate Generation LetP

iv≤ klk ∈Psums^ci, it generates a candidatecd(x)using the constraint setϕi of CEc_i and Farkas’

Lemma. However, this time the strategy uses the conditionkl⁰k ≤ kcd(x)k − kcd(x⁰)k. This condition considers only the positive part of the candidate which allows us to ignore the final value of the candidate cd(x_f)and guarantee that the generated constraint is valid for (selected partial evaluations of) divergent phases (see Definition6.3).

Cost Equation Classification

As in the previous strategy, the CEs in the phase are classified. This strategy considers the classCntR, instead ofCnt, whose condition considers the positive part of the candidates as well (see Table6.1). It considers the classesDcandIcto capture decrements and increments of the candidate and, in addition, it considers theRstclass to support phases where the candidate is reset to a completely different value.

Ifc_e∈Rstthe candidate is reset to a value of at mostkrst_e(x)k. A fresh intermediate variable is assigned to such reset valueiv_rste :=krst_e(x)k.

Constraint Generation

Theorem 6.31. If everyc_e∈phis classified intoCntR,Ic,DcandRstwith respect to a candidatecd(x), the following constraints are valid:

X

c_e∈CntR

cntr_e≤iv_cd+X

c_e∈Ic

smiv_ice+ X

c_e∈Rst

smiv_rste iv_cd ≤ kcd(xs)k

The strategy generates the following pending constraints:

• For eachc_e∈Ic, the constraintiv_ice ≤ kic(x x⁰)kis added toPsums^ce.

• For eachc_e∈Rst, the constraintiv_rste≤ krst(x)kis added toPsums^ce.

Note that this strategy ignores the decrements of c_e ∈Dc. For divergent phases the lower bounds on variablessmiv_dce always be0, because the evaluation can be truncated at any point.

Basic Product Strategy

In many cases, the previous strategies fail to even infer a candidate. Given a constraintP

iv./kl(x x⁰)k ∈ Psums^ci, it might be impossible to infer a linear expression representingP#c_i

j=1kl(x_jx⁰_j)k. This is the case for most nested loops such aswh10in Program13.

Example 6.32. Consider the cost computation of phase(7)⁺ of Program 13 in which the pending set Psums⁷ contains the constraintiv₁ ≤ kzk. In the phase, the variable z does not change in CE7 and#c₇ is at most y so P#c₇

j=1kzk =kyk · kzk which is non-linear. This result can be obtained by rewriting the constraintiv₁≤ kzkasiv₁≤1·kzkand generating the constraintsmiv₁≤smiv_{i t}

7·dive_mz(that corresponds toiv₂ ≤iv₃·iv₄ using the intermediate variables of Figure6.3). Then,iv_{i t}

7 ≤1is added toPsums⁷ and iv_mz ≤ kzk is added to Pms⁷. These constraints will be later processed by the strategies Inductive Sum andMax-Minrespectively.

In general, given a constraintP

iv≤ klk ∈Psums^ciwherelis not a constant, theBasic Productstrategy generates the non-final constraint:

Xsmiv≤smiv_{i ti}· divep

And it adds the pending constraintsiv_{i ti} ≤ 1 to Psums^ci andiv_p ≤ klk to Pms^ci. This way, it reduces a complex sum into a simpler sum and a max/minimization. This strategy is the main source of non-final constraints in the form of a product of two intermediate variables. It proceeds analogously for constraints with the operator≥.

Max-Min Strategy

This strategy deals with constraints iv./klk ∈Pms^ci and its role is to generate constraints for Maxdive and Minbivcvariables. It follows the same three steps scheme or theInductive Sumstrategies.

First, it generates a candidate cd(x) using the CE’s constraint set ϕi. However, the condition used to generate the candidate is simply l ./ cd(x) since it has to bind a single instance of l instead of the sum of all its instances. Second, the strategy classifies thec_e ∈phwith respect to the candidate. In this case, it does not consider the classCntbut it considersIc,DcandRst(see Table6.1). Third, the strategy generates constraints:

Theorem 6.33. Letiv≤ klk ∈Pms^ciand letcd(x)be a candidate such thatϕ_i⇒l≤cd(x). If everyc_e∈ph is classified intoDc,IcandRstwith respect tocd(x), the following constraints are valid:

dive ≤iv_{ma x} +X

ce∈Ic

smiv_ice iv_{ma x} ≤max

c_e∈Rst(diverst_e,iv_cd) iv_cd≤ kcd(x_s)k

These constraints bind diveto the sum of all the incrementssmiv_ice forc_e∈Icplus the maximum of all the maximum values that the resets can takediverst_e. This maximum also includes the initial value of the candidatecd(x_s) in case it is never reset.

The strategy adds the following pending constraints:

• For eachc_e∈Ic, the constraintiv_ice ≤ kic_e(x x⁰)kis added toPsums^ce.

• For eachc_e∈Rst, the constraintiv_rste ≤ krst_e(x)kis added toPms^ce.

The strategy proceeds analogously for constraints with the operator≥ but it subtracts the decrements instead of adding the increments and takes the minimum of the resetsbivcrst_e:

Theorem 6.34. Letiv≥ klk ∈Pms^ciand letcd(x)be a candidate such thatϕ_i⇒l≥cd(x). If everyc_e∈ph is classified intoDc,IcandRstwith respect tocd(x), the following constraints are valid:

bivc ≥iv_min− X

ce∈Dc

smiv_dce iv_min≥ min

c_e∈Rst(bivcrst_e,iv_cd) iv_cd ≥ kcd(x_s)k

Example 6.35. In Example6.32the constraintiv_mz≤ kzkwas added toPms⁷ during the computation of the cost of(7)⁺. TheMax-Minstrategy generates a candidate z and classifies CE7 inDcwith dc₇ :=0 (z is not modified in CE7). The resulting (simplified) constraint is divemz≤ kz_sk(which corresponds to iv₄≤ kz_skusing the intermediate variables of Figure6.3).

Triangular Sum Strategy

This strategy represents an alternative to theBasic Productstrategy for dealing with constraintsP iv./

kl(x x⁰)k ∈Psums^ci wherekl(x x⁰)kvaries in each iteration by a constant amount.

6.5. Phases 93

Refined cost relations of Program2

2:for₂(x,n) ={y=x,x <n,x⁰=x+1},for₃[(3)⁺(4)](y,n),for₂(x⁰,n) 3:for₂(x,n) ={x≥n}

4:for₃(y,n) ={y <n,y⁰=y+1}, 1,for₃(y⁰,n) 5:for₃(y,n) ={y ≥n}

Lower bound: knk²/2+knk/2

Figure 6.5.:Refined cost relations of Program2and its lower bound

Example 6.36. A typical example is Program2(in Page5). Figure6.5contains its refined cost relations.

In this example, cost equations2and3represent the outer loop and4 and5 the inner loop. The chain that represents the total cost of the program is(2)⁺(3). The final values of the variables x_o, y_o and n_o are not included in the CRs to simplify the presentation. Let us consider obtaining the lower bound of such an example.

Assume the cost of the inner loop (chain (4)⁺(5)) is 〈iv₁,;,{iv₁ = kn− yk}〉 which yields a cost of

〈iv₁,;,{iv₁ =kn−xk}〉for CE2. The main cost expression of the phase(2)⁺ is E₍₂₎+ :=smiv₁, there are no non-final constraints and the pending sets are:Psums²={iv₁≤ kn−xk,iv₁≥ kn−xk}andPms²=;.

If we apply the Basic Product strategy toiv₁≥ kn−xk, we would obtainsmiv₁≥smiv_{i t}

2· bivc2and later smiv_{i t}

2≥ kn_s−x_skandbivc2≥1(the minimum value ofkn−xkis1in the last iteration) which represents the imprecise lower boundkn−xk ·1.

Instead, we consider thatkn−xkdecreases by at most1in each iteration so we can reformulate:

#c₂

P

j=1

kn_j−x_jk ≥

#c₂

P

j=1

(kn_s−x_sk −(j−1)) =kn_s−x_sk ·#c₂−

#c₂−1

P

j=0

j=kn_s−x_sk ·#c₂−¹₂(#c₂²−#c₂) This expression can be represented with constraints as follows:

smiv₁≥iv_p1−¹₂iv_p2+¹₂smiv_{i t2} iv_p1≥iv_ini·smiv_{i t2} iv_p2≤smiv_{i t}

2·smiv_{i t}

2 iv_ini≥ kn_s−x_sk

Note that the constraint over iv_p2 has ≤ instead of≥. This is because iv_p2 appears negated in the first constraint and it has to be maximized. Later, applying theInductive Sumstrategy toiv_{i t}

2≤1andiv_{i t}

2≥1 (inPsums²), we generatesmiv_{i t2} =k(n_s−x_s)−(n_f −x_f)k. When we compute the cost of the complete chain(2)⁺(3), we transformk(n_s−x_s)−(n_f −x_f)k intokn_s−x_sk(because n_f −x_f must be0in chain (2)⁺(3)). If we minimize the cost of the resulting cost structure, we obtain:

kn_s−x_sk²−¹₂kn_s−x_sk²+¹₂kn_s−x_sk =¹₂kn_s−x_sk²+¹₂kn_s−x_sk= ¹₂kn_sk²+¹₂kn_sk In the general case, given a constraintP

iv./klk ∈Psums^ci, the strategy generates a candidatecd(x) under the condition that it approximates the cost of one instance ofkl(x x⁰)k, it is positive, and it varies by a constant amountq_i ∈Q. The condition is:

l./cd(x)≥0 ∧ cd(x⁰)−cd(x)./q_i

This strategy considers the classesCntT andNop(see Table6.1in Page 89). Ifc_e∈CntT, there exists a constraint(P

iv⁰./kl⁰k)∈Psums^cethat is bound by the candidate and the candidate varies by an amount q_e. As in previous strategies, this condition coincides with the one used to generate the candidate and c_i∈CntT. The CEsc_e∈Nopdo not modify the candidate.

Program 15 Refined cost relations

1while (x >0) {

2 if (*) {

3 while (y >0 && *) {

4 y - -;

5 tick (2) ;

6 }

7 } else {

8 if (*) y ++;

9 else y=z;

10 }

11 x - -;

12}

1:wh1(x,y,z) ={x≤0}

2:wh1(x,y,z) ={x>0,y> y⁰≥0,x⁰=x−1},wh3[(7)⁺(6)](y: y⁰), wh1(x,y⁰,z)

3:wh1(x,y,z) ={x>0,y= y⁰≥0,x⁰=x−1},wh3[(6)](y: y⁰), wh1(x,y⁰,z)

4:wh1(x,y,z) ={x⁰=x−1≥0,y⁰= y+1},wh1(x⁰,y⁰,z) 5:wh1(x,y,z) ={x>0,x⁰=x−1,y=z},wh1(x⁰,y⁰,z) 6:wh3(y: y_o) ={y =y_o}

7:wh3(y: y_o) ={y ≥1,y⁰= y−1}, 2,wh3(y⁰: y_o)

Figure 6.6.:Program15: Example with complex phase

Theorem 6.37. If everyc_e∈phis classified intoCntTandNopwith respect to a candidatecd(x). Letq be q:= max

c_e∈CntT(q_e)when./is≤orq:= min

c_e∈CntT(q_e)when./is≥. The following constraints are valid:

P

c_e∈CntT

cntt_e./iv_p1+₂^qiv_p2−^q₂iv_its , iv_p1./iv_ini·iv_its iv_p2=iv_its·iv_its, iv_its= P

c_e∈CntT

smiv_{i te}, iv_ini./kcd(x_s)k

The intermediate variables iv_p1,iv_p2,iv_its, and iv_ini are fresh: iv_p1 andiv_p2 simply represent different parts of the expression, the variable iv_its represents the sum of all the iterations#c_e of c_e ∈ CntT, and iv_ini represents the initial value of the candidate. The constraints of the formiv=x stand foriv≤x and iv≥x. Finally, for eachc_e∈CntT, the constraintsiv_{i te} ≤1andiv_{i te}≥1are added to eachPsums^ce.

This strategy allows us to obtain both upper and lower bounds that are more precise than the ones ob-tained with the Basic Product strategy. However, it also generates many more constraints so its adequacy highly depends on the goals of the analysis. For instance, if we are only interested in the asymptotic complexity, this strategy can be advantageous for lower bounds but not for upper bounds. Consider Program 2, the expression ^knk₂² + ^knk₂ is the upper and lower bound obtained with the Triangular Sum strategy and it is quadratic. Without the Triangular Sum strategy, the obtained upper and lower bounds aren² andnrespectively. While both are imprecise at the concrete level, the upper bound is asymptot-ically precise. In the future work chapter (Chapter10) there is a discussion on how this strategy could be improved and extended.

Im Dokument Cost Analysis of Programs Based on the Refinement of Cost Relations (Seite 103-111)