HPDcache

https://openhw-group-cv-hpdcache.readthedocs-hosted.com/
Admin
HPDcache is a high-performance L1 data cache IP designed to serve memory access requests from RISC-V...
Tokens:70,248
Snippets:266
Trust Score:8.4
Update:1 month ago
Show doc for...
Tokens:
Raw
### Try to pop a ready request

Source: https://openhw-group-cv-hpdcache.readthedocs-hosted.com/_sources/architecture.rst.txt

Attempts to select a ready request from the RTAB using a round-robin policy and manages linked list traversal.

```c
req_t rtab_pop_try()
   {
     //  These are global states (preserved between function calls)
     static int pop_state = HEAD;
     static int last = 0;
     static int next = 0;

     int index;

     //  Brief description of the following code:
     //    The rtab_pop_try function tries to retire all the requests of a given
     //    linked list. Then it passes to another one.
     switch (pop_state) {
       case HEAD:
         //  Find a list whose head request is ready
         //  (using a round-robin policy)
         index = rtab_find_ready(last);

         //  If there is no ready entry, or there is an ongoing rollback,
         //  return an invalid index
         if ((index == -1) || rtab_pop_rollback)
           return -1;

         //  Update the pointer to the last linked list served
         last = index;

         //  If the list have more than one request, the next time this function
         //  is called, serve the next request of the list
         if (!rtab[index].ll_tail) {
            next = rtab[index].ll_next;
            pop_state = NEXT;
         }

         //  Temporarily unset the head bit. This is to prevent the
         //  request to be rescheduled.
         rtab[index].ll_head = 0;
         break;

       case NEXT:
         index = next;

         //  If there is an ongoing rollback, abandon the current pop
         if (rtab_pop_rollback) {
            pop_state = HEAD;
            return -1;
         }

         //  If the list have more than one request, the next time this function
         //  is called, serve the next request of the list
         if (!rtab[next].ll_tail) {
            next = rtab[index].ll_next;
            pop_state = NEXT;
         }
         //  It it is the last element of the list, return to the HEAD state
         else {
            pop_state = HEAD;
         }

         //  Temporarily unset the head bit. This is to prevent the
         //  request to be rescheduled.
         rtab[index].ll_head = 0;
     }

     //  Pop the selected request
     return rtab[index].req;
   }
```

--------------------------------

### Find ready request

Source: https://openhw-group-cv-hpdcache.readthedocs-hosted.com/_sources/architecture.rst.txt

Searches for a linked list whose head request is ready for replay using a round-robin policy.

```c
int rtab_find_ready(int last)
   {
     // choose a ready entry using a round-robin policy
     int i = (last + 1) % RTAB_NENTRIES;
     for (;;) {
       //  ready entry found
       if (rtab[i].valid && rtab[i].ll_head && (rtab[i].deps == 0))
         return i;

       //  there is no ready entry
       if (i == last)
         return -1;

       i = (i + 1) % RTAB_NENTRIES;
     }
   }
```

--------------------------------

### Select victim way with select_victim_way function

Source: https://openhw-group-cv-hpdcache.readthedocs-hosted.com/architecture.html

Implements the victim selection algorithm for cache misses. It returns the first way with valid bit unset, then the first way with LRU bit unset and not being fetched, then a clean way, then a dirty way, and finally -1 if all ways are pre-selected, causing the request to be placed in the replay table.

```c
int select_victim_way(int set)
{
   //  Return the first way (of the target set) whose valid bit is unset
   for (int w = 0; w < HPDCACHE_WAYS; w++) {
      if (!valid[set][w]) {
         return w;
      }
   }

   //  If all ways are valid, return the first way (of the target set) whose
   //  PLRU bit is unset and which is not pre-selected as victim
   for (int w = 0; w < HPDCACHE_WAYS; w++) {
      if (!fetch[set][w] && !lru[set][w]) {
         return w;
      }
   }

   //  If the PLRU designated way cannot be selected (already pre-selected
   //  as victim), return the first clean way (no locally modified in case
   //  of write-back policy)
   for (int w = 0; w < HPDCACHE_WAYS; w++) {
      if (!fetch[set][w] && !dirty[set][w]) {
         return w;
      }
   }

   //  If there is no clean way selectable, return the first dirty way
   for (int w = 0; w < HPDCACHE_WAYS; w++) {
      if (!fetch[set][w]) {
         return w;
      }
   }

   // If there is no selectable way (all ways are being already pre-selected
   // and are waiting for a refill) returns -1. In this case the cache
   // controller puts the miss request on hold in the replay table.
   return -1;
}

```

--------------------------------

### rtab_pop_try: Select ready request from RTAB

Source: https://openhw-group-cv-hpdcache.readthedocs-hosted.com/architecture.html

Called by the cache controller to select a ready request (dependencies resolved) from the RTAB. Uses a round-robin policy to find a ready linked list head, handles rollback by returning -1, and updates the head bit to prevent rescheduling.

```c
req_t rtab_pop_try()
{
  //  These are global states (preserved between function calls)
  static int pop_state = HEAD;
  static int last = 0;
  static int next = 0;

  int index;

  //  Brief description of the following code:
  //    The rtab_pop_try function tries to retire all the requests of a given
  //    linked list. Then it passes to another one.
  switch (pop_state) {
    case HEAD:
      //  Find a list whose head request is ready
      //  (using a round-robin policy)
      index = rtab_find_ready(last);

      //  If there is no ready entry, or there is an ongoing rollback,
      //  return an invalid index
      if ((index == -1) || rtab_pop_rollback)
        return -1;

      //  Update the pointer to the last linked list served
      last = index;

      //  If the list have more than one request, the next time this function
      //  is called, serve the next request of the list
      if (!rtab[index].ll_tail) {
         next = rtab[index].ll_next;
         pop_state = NEXT;
      }

      //  Temporarily unset the head bit. This is to prevent the
      //  request to be rescheduled.
      rtab[index].ll_head = 0;
      break;

    case NEXT:
      index = next;

      //  If there is an ongoing rollback, abandon the current pop
      if (rtab_pop_rollback) {
         pop_state = HEAD;
         return -1;
      }

      //  If the list have more than one request, the next time this function
      //  is called, serve the next request of the list
      if (!rtab[next].ll_tail) {
         next = rtab[index].ll_next;
         pop_state = NEXT;
      }
      //  It it is the last element of the list, return to the HEAD state
      else {
         pop_state = HEAD;
      }

      //  Temporarily unset the head bit. This is to prevent the
      //  request to be rescheduled.
      rtab[index].ll_head = 0;
  }

  //  Pop the selected request
  return rtab[index].req;
}

```

--------------------------------

### rtab_find_ready: Find ready linked list head

Source: https://openhw-group-cv-hpdcache.readthedocs-hosted.com/architecture.html

Searches for a linked list whose head request can be replayed (dependencies resolved). Uses a round-robin policy and returns -1 if no ready entry is found.

```c
int rtab_find_ready(int last)
{
  // choose a ready entry using a round-robin policy
  int i = (last + 1) % RTAB_NENTRIES;
  for (;;) {
    //  ready entry found
    if (rtab[i].valid && rtab[i].ll_head && (rtab[i].deps == 0))
      return i;

    //  there is no ready entry
    if (i == last)
      return -1;

    i = (i + 1) % RTAB_NENTRIES;
  }
}

```

--------------------------------

### Allocate and link request in RTAB

Source: https://openhw-group-cv-hpdcache.readthedocs-hosted.com/_sources/architecture.rst.txt

Allocates a new entry in the RTAB and links it to the tail of an existing request list.

```c
int rtab_alloc_and_link(req_t r)
   {
     int index = rtab_find_empty();
     int match = rtab_match_tail(get_nline(r));

     //  replace the tail of the linked list
     rtab[match].ll_tail = 0;

     //  make the next pointer of the old tail to point to the new entry
     rtab[match].ll_next = index;

     //  add the new request as the tail of the linked list
     rtab[index] = {
       valid     : 1,
       deps      : 0,
       ll_head   : 0,
       ll_tail   : 1,
       ll_next   : 0,
       request   : r
     };

     return index;
   }
```
Tokens:
Raw