FIFO Cache Analysis for WCET Estimation

Abstract

Although most previous work in cache analysis for WCET estimation assumes the LRU replacement policy, in practice more processors use simpler non-LRU policies for lower cost, power consumption, and thermal output. This chapter focuses on the analysis of FIFO, one of the most widely used cache replacement policies. Previous analysis techniques for FIFO caches are based on the same framework as for LRU caches using qualitative always-hit/always-miss classifications. This approach, though works well for LRU caches, is not suitable to analyze FIFO and usually leads to poor WCET estimation quality.

Appendix: The Complete IPET Formulation

We first introduce the loop structures adopted in our ILP encoding. As a common restriction in structured programming [127], we assume each loop contains a single head basic block, and the program can jump into the loop by reaching the head basic block via some entry edges. The loop bound restricts the maximal times the program iterates every time it enters the loop. The head basic block tests whether the loop condition is satisfied (e.g., the loop bound has not been reached). If the loop condition is satisfied, the program continues to execute the body basic blocks, which are the basic blocks in the loop excluding the head basic block, otherwise the program exists the loop. Formally we define a loop as:

Definition 3.6 (Loop Structure).

A loop in the CFG is a tuple $\mathfrak{L}_{\ell} = (\mathsf{entr}_{\ell},$ $\mathsf{head}_{\ell},\mathsf{body}_{\ell},\mathsf{lpb}_{\ell})$ with:

• entr _ℓ : the set of entry edges of the loop;

• head _ℓ : the head basic block of the loop;

• body _ℓ : the set of all body basic blocks of the loop;

• lpb _ℓ : the loop bound.

The ILP formulation uses the following constants

• C ^h: the execution delay of each node upon a cache hit,

• C ^m: the execution delay of each node upon a cache miss,

and the following non-negative variables

• c _a : for each basic block b _a , c _a is b _a ’s total execution cost,

• x _a : for each basic block b _a , x _a is the execution count of b _a ,

• y _j : for each edge e _j in the entry edge set entr _ℓ of some loop $\mathfrak{L}_{\ell}$, y _j counts how many times this edge is taken during the whole execution,

• z _i : for each node n _i included in some k-Miss node sets regarding some loops, z _i counts how many times n _i executes with cache misses.

To obtain the WCET, the following maximization problem is solved:

$$\displaystyle{ Maximize\ \ \left \{\sum _{\forall b_{a}}c_{a}\right \} }$$

The following constraints are respected to bound the total cost:

• Cost Constraint: As discussed in Sect. 2.5.5, the total cost of each basic block is

  $$\displaystyle{\forall b_{a}: c_{a} = (\pi _{\mathsf{AH}} \times C^{h} +\pi _{\mathsf{ NC}} \times C^{m}) \times x_{ a} +\sum _{n_{i}\in b_{a}^{{\ast}}}\left (C^{m} \times z_{ i} + C^{h} \times (x_{ a} - z_{i})\right )}$$

  where π _AH and π _NC is the number of AH and NC nodes in b _a , respectively, and $b_{a}^{{\ast}}$ is the set of nodes in b _a that are contained in some k-Miss node sets (regarding some loops). Additionally, each $n_{i} \in b_{a}^{{\ast}}$ should satisfy $z_{i} \leq x_{a}$.

• k- Miss  Constraint: As discussed in Sect. 2.5.5, the following constraints bound the number of misses incurred by a k-Miss node set:

  $$\displaystyle{\forall (S,\mathfrak{L}_{\ell})\text{ s.t. }S\text{ is }k\mathrm{-\mathsf{Miss}\ regarding\ }\mathfrak{L}_{\ell}:\sum _{n_{i}\in S}z_{i} \leq k \times \sum _{e_{j}\in \mathsf{entr}_{\ell}}y_{j}}$$

• Structure Constraint: Each basic block should have balanced input and output:

  $$\displaystyle{\forall b_{a}:\ \ x_{a} =\sum _{e_{j}\in \mathsf{input}(b_{a})}y_{j} =\sum _{e_{j}\in \mathsf{output}(b_{a})}y_{j}}$$

  The start basic block b _st of the program is executed only once:

  $$\displaystyle{x_{st} = 1}$$

  Each time the program enters the loop, each body basic block executes for at most lpb _ℓ times, so we have

  $$\displaystyle{\forall \mathfrak{L}_{\ell},\forall b_{a} \in \mathsf{body}_{\ell}: x_{a} \leq \mathsf{lpb}_{\ell} \times \sum _{e_{j}\in \mathsf{entr}_{\ell}}y_{j}}$$

  The head basic block may execute one more time to realize that the loop condition is not satisfied and thus the program exists the loop, so we have:

  $$\displaystyle{\forall \mathfrak{L}_{\ell},b_{a} = \mathsf{head}_{\ell}: x_{a} \leq (\mathsf{lpb}_{\ell} + 1) \times \sum _{e_{j}\in \mathsf{entr}_{\ell}}y_{j}}$$