Questa è la sfida di follow-up da questa , se sei confuso per favore controlla prima quella.

Innanzitutto, supponiamo che sia il numero di errori della cache che una sequenza s di accessi alle risorse avrebbe presumendo che la nostra cache abbia capacità k e utilizzi uno schema di espulsione first-in-first-out (FIFO) quando è pieno.$m(s, k)$$s$$k$

Quindi, dato un rapporto , restituisce una sequenza non vuota di accessi alle risorse s tale che esiste k > j con m ( s , k ) ≥ r ⋅ m ( s , j ) .$r > 1$$s$$k > j$$m(s, k) \geq r \cdot m(s, j)$

In parole povere, costruire una sequenza di risorsa accessi in modo tale che ci sono due dimensioni della cache in cui la cache più grande ha (almeno) r volte più cache miss quando viene utilizzato per risolvere s .$s$$r$$s$

$r = 1.1$$(3, 2, 1, 0, 3, 2, 4, 3, 2, 1, 0, 4)$$9$$3$$10$$4$

Non importa quale sequenza restituisci, purché soddisfi i requisiti.

Vince il codice più breve in byte.

Wolfram Language (Mathematica) , 124 113 101 byte

Flatten@{s=⌈2#⌉;q=Range[r=2s+1];g=Mod[q s-s,r];{Sort@g[[#+1;;]],g[[;;#]]}&~Array~r,Table[q,s^3]}&

Provalo online!

NOTA: L'output TIO non è l'elenco effettivo perché sarebbe molto lungo. La funzione wrapper su TIO indica il numero di errori di pagina per due capacità della cache.

Per l'elenco attuale: provalo online!

Correlato: arXiv: 1003.1336

Come?

Supponiamo una situazione in cui abbiamo due capacità di cache 3e 4.

Inoltre, diciamo che il 3-cache ha {4, 2, 5}paging, e 4-cache ha {5, 4, 3, 2}paging. Quindi, proviamo il paging {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}:

page  3-cache   4-cache
      {4,2,5}  {5,4,3,2}
  1   {1,4,2}  {1,5,4,3}
  2   {1,4,2}  {2,1,5,4}
  3   {3,1,4}  {3,2,1,5}
  4   {3,1,4}  {4,3,2,1}
  5   {5,3,1}  {5,4,3,2}
  1   {5,3,1}  {1,5,4,3}
  2   {2,5,3}  {2,1,5,4}
  3   {2,5,3}  {3,2,1,5}
  4   {4,2,5}  {4,3,2,1}
  5   {4,2,5}  {5,4,3,2}

Il 3-cache avuto 5 errori di pagina, mentre il 4-cache aveva 10. Abbiamo anche tornati al nostro stato originale.

Qui, se ripetiamo il paging {1, 2, 3, 4, 5}, raggiungeremmo asintoticamente il rapporto di 2.

Siamo in grado di estendere questo fenomeno a capacità di cache più elevate in modo da poter sfogliare {1, 2, 3, ... , 2n + 1}e finire con qualsiasi rapporto.