Delayed runahead exit policies

Abstract

Spriket mellom klokkehastigheten til prosessorer og hovedminne utgjør en stor flaskehals i prosessorytelse for minneintensive programmer. Denne ytelsesbegrensningen skyldes langtidsinnlastere, innlastingsinstrukser som utfører minneaksesser som ikke treffer i siste nivå av prosessorens hurtigbufferhierarki. Disse instruksene har ofte ventetider på flere hundre sykluser. Moderne prosessorkjerner kan tolerere noe av ventetiden til innlastingsinstrukser ved å eksekvere instrukser utenfor rekkefølge (OoO) og spore rekkefølgen deres i store omordningsbuffere, men disse er fremdeles for små til å håndtere langtidsinnlastere. Maskinvarebasert forhåndsinnhenting av minneverdier kan ikke alltid skjule ventetiden for aksesser til hovedminne fordi slike teknikker ikke kan forutsi fremtidige minneaksesser med perfekt nøyaktighet. Sluttresultatet er at omordningsbufferen ofte fylles opp mens prosessoren venter på minne, og dermed at prosessoren blokkeres.

Forutløpende eksekvering er en moderne teknikk for forhåndsinnhenting av minneverdier. Teknikken er implementert i prosessorens mikroarkitektur og tillater prosessorkjernen å utnytte sykluser hvor prosessoren venter på minne. Syklusene utnyttes for å eksekvere fremtidige instrukser som henter inn minneverdier på forhånd med svært høy nøyaktighet. På denne måten blir bom i hurtigbufferen omgjort til treff. Tidligere arbeider har funnet at minneinnhentingseffekten til forutløpende eksekvering dekker et begrenset antall innlastingsinstrukser. Dette skyldes delvis at selv om ventetidene for minne totalt sett skader prosessorytelsen, vil hvert individuelle minneaksess ta så kort til at forutløpende eksekvering ikke har nok tid til å hente inn mange nok minneverdier.

I denne masteroppgaven undersøker jeg effekten av å forsinke byttet fra den forutløpende eksekveringsmodusen tilbake til normal modus. Dette gjøres ved å innføre tradisjonell forutløpende eksekvering i en OoO-prosessormodell i datamaskinarkitektursimulatoren gem5. Ved å simulere tre ulike modeller for forsinket modusbytte viser jeg at en prosessor med støtte for forutløpende eksekvering kan forbedre ytelsen med 2.3% hvis den forsinker byttet ut av forutløpende eksekveringsmodus.

The memory wall, a growing gap between processor and memory clock speeds, represents a major bottleneck for processor performance in memory-intensive programs. Long latency loads (LLLs), loads that miss in the last level of cache, have latencies up to hundreds of cycles, causing the processor to stall. Modern out-of-order (OoO) cores can tolerate some memory latency owing to their large re-order buffer (ROB) sizes but are still too small to handle LLLs. Hardware prefetchers cannot always hide these latencies as they are, by design, unable to perfectly predict the future demand accesses of processors. The result is that many loads still cause the ROB to fill up and subsequently the processor to stall.

Runahead execution is a modern prefetching technique implemented in processor microarchitecture that utilizes cache miss stall cycles to execute the future instruction stream. Runahead prefetches critical loads with near-perfect accuracy, thus turning future cache misses into cache hits. However, previous works have found that the prefetching effect of runahead has limited coverage. This is partly because even though these stalls degrade performance in total, each individual stall period is too short for runahead to prefetch enough loads to achieve adequate coverage.

In this thesis, I study the effect that delaying exit from runahead mode has on processor performance by implementing a traditional runahead scheme in the gem5 computer architecture simulator. By simulating three different exit policies I find that delaying exit from runahead can improve overall processor performance by 2.3% compared to a runahead processor that eagerly exits runahead.