Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / rst / rstzip3 / rstzip_v3 / rz3utils.h

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: rz3utils.h
* Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
* 
* The above named program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License version 2 as published by the Free Software Foundation.
* 
* The above named program is distributed in the hope that it will be 
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* General Public License for more details.
* 
* You should have received a copy of the GNU General Public
* License along with this work; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
* 
* ========== Copyright Header End ============================================
*/
/* rz3utils.h
* utility programs for rstzip3
*
* Copyright (C) 2003 Sun Microsystems, Inc.
* All Rights Reserved
*/

#ifndef _rz3utils_h_
#define _rz3utils_h_

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>


#include "rz3iu.h"
#include "rz3_bitarray.h"
#include "rz3_valuecache.h"


static int rz3_nbits(uint64_t v) {
 int rv = 1;
 while(v >> rv) {
   rv++;
 }
 return rv;
} // rz3_nbits()


template <class vtype> struct rz3_tagged_table {

 rz3_tagged_table(int size) {
   sz = size;
   tags = new uint64_t [sz];
   data= new vtype [sz];

   clear();
 }

 ~rz3_tagged_table() {
   delete [] tags; tags = NULL;
   delete [] data; data = NULL;
 }

 void clear() {
   bzero(tags, sz*sizeof(uint64_t));
   bzero(data, sz*sizeof(vtype));
 }

 void set(uint64_t key, const vtype value) {
   int idx = (key & (sz-1));
   tags[idx] = key;
   data[idx] = value;
 }

 vtype get(uint64_t key) {
   int idx = key & (sz-1);
   if (tags[idx] == key) {
     return data[idx];
   } else {
     return 0;
   }
 }

 int sz;
 uint64_t *tags;
 vtype *data;
}; // template <class vtype> struct rz3_tagged_table


template <class vtype> struct rz3_table {

 rz3_table(int size) {
   sz = size;
   data= new vtype [sz];

   clear();
 }

 ~rz3_table() {
   delete [] data; data = NULL;
 }

 void clear() {
   bzero(data, sz*sizeof(vtype));
 }

 void set(uint64_t key, const vtype value) {
   int idx = (key & (sz-1));
   data[idx] = value;
 }

 vtype get(uint64_t key) {
   int idx = key & (sz-1);
   return data[idx];
 }

 int sz;
 vtype *data;
}; // template <class vtype> struct rz3_table



// proximity list - used in rstzip3 to exploit temporal-spatial locality
// to compress ea_va and regval/memval values
struct rz3_prox_elem {
 int valid;
 uint64_t data;
 rz3_prox_elem * next;
 rz3_prox_elem * prev;
}; // struct rz3_prox_elem


struct rz3_prox_list {
 rz3_prox_list(int size) {
   sz = size;
   arr = new rz3_prox_elem[sz];

   clear();
 } // rz3_prox_list::()


 void clear() {
   int i;
   for (i=0; i<sz; i++) {

     if (i == 0) {
       arr[i].prev = NULL;
     } else {
       arr[i].prev = &(arr[i-1]);
     }

     if (i == (sz-1)) {
       arr[i].next = NULL;
     } else {
       arr[i].next = &(arr[i+1]);
     }

     arr[i].data = 0x0;
   } // for each allocated elem

 } // clear();

 uint64_t lookup(int idx) {
   int i;
   rz3_prox_elem *pe = arr;
   for (i=0; i<idx; i++) {
     pe = pe->next;
   }
   return pe->data;
 }


 // returns the index if match, -1 otherwise
 // if v is found in the prox list, it is moved
 // to the head of the list ("most recent" position)
 int ref(uint64_t v) {
   int i;
   rz3_prox_elem * pe = arr;
   assert(pe->prev == NULL);
   for (i=0; i<sz; i++) {
     if (pe->data == v) break;
     if (pe->next) {
       pe = pe->next;
     } else {
       assert(i==(sz-1));
     }
   }

   if (i==0) {
     return 0;
   }

   if (i < sz) { // hit
     pe->prev->next = pe->next;

     if (pe->next) {
       pe->next->prev = pe->prev;
     }

     pe->prev = NULL;
     pe->next = arr;
     arr->prev = pe;
     arr = pe;

     return i;
   } else { // miss
     // pe is last - move it to the head
     pe->data = v;
     pe->prev->next = NULL;
     pe->next = arr;
     pe->prev = NULL;
     arr->prev = pe;
     arr = pe;
     return -1;
   }
 } // int ref(uint64_t v)

 ~rz3_prox_list() {
   delete [] arr;
 }

 int sz;
 rz3_prox_elem * arr;

}; // struct rz3_prox_list


#endif // _rz3utils_h_