Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / cpus / vonk / n2 / lib / cpu / src / N2_Tlb.h

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: N2_Tlb.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 ============================================
*/
#ifndef __N2_Tlb_h__
#define __N2_Tlb_h__

#include "SS_Tlb.h"
#include "N2_TrieTlb.h"

class N2_Tlb : public SS_Tlb
{
  public:
    enum
    {
      ITLB_SIZE = 64,
      DTLB_SIZE = 128
    };
    
    N2_Tlb( Type type, uint_t size );
    N2_Tlb( N2_Tlb& tlb );
    ~N2_Tlb();

    // lookup_ra2pa() does a TLB lookup for real addresses. lookup_va2pa() does it 
    // for virtual addresses. The multi_hit boolean is true when a TTE is returned
    // that has overlapping smaller TTEs in the TLB. The multi_hit is false otherwise.
    //
    // lookup_va2pa() and lookup_ra2pa() don't use mutexes to make them MP safe.
    // Doing so will kill the MP performance. Read write lock aren't much better
    // either. So we code TLB insert and demap carefully and have lookup allow
    // at least one concurrent insert or demap, but no more. This is checked by
    // the tlb_access_enter() and tlb_access_leave() routines: e and l will differ
    // when lookup overlaps two or more inserts and demaps.

    SS_Tte* lookup_ra2pa( SS_Strand* strand, SS_Vaddr ra, uint_t pid, bool* multi_hit )
    {
      SS_Tte* t;
      uint64_t e,l;
      do
      {
	e = tlb_access_enter();
	t = trie.lookup(pid,ra,multi_hit);
        l = tlb_access_leave();
      }
      while (e != l);
      return t;
    }

    SS_Tte* lookup_va2pa( SS_Strand* strand, SS_Vaddr va, uint64_t ctxt, uint_t pid, bool* multi_hit )
    {
      SS_Tte* t;
      uint64_t e,l;
      do
      {
        e = tlb_access_enter();
	t = trie.lookup(pid,ctxt,va,multi_hit);
        l = tlb_access_leave();
      }
      while (e != l);
      return t;
    }

    // insert_tsb_tte() inserts a TTE into the TLB (autodemapping if neccesary). If the idx is negative 
    // then the TLB will find a free spot for the TTE. Otherwise the selected index (modulo size()) is used.
    // When r is 1 the tte inserted will be marked ra2pa, else it's a va2pa TTE

    SS_Tte* insert_tsb_tte( SS_Strand* strand, uint16_t pid, uint64_t tag, uint64_t data, SS_Vaddr va, int idx, int r );

    void demap_virt( SS_Strand* strand, uint_t pid, uint_t context, SS_Vaddr va );
    void demap_virt( SS_Strand* strand, uint_t pid, uint_t context );
    void demap_virt( SS_Strand* strand, uint_t pid );
    void demap_real( SS_Strand* strand, uint_t pid, SS_Vaddr va );
    void demap_real( SS_Strand* strand, uint_t pid );
    void demap_all ( SS_Strand* strand, uint_t pid );
    void demap_auto( SS_Strand* strand, SS_Tte* new_tte, uint_t new_idx );
    
    void snapshot( SS_SnapShot& ss, const char* prefix="", const char* inst="inst" );

    void insert( SS_Tte* tte );

    // set_used() sets the used flag of TLB entry i
    void set_used( uint_t i )
    {
      if (!used[i])
      {
	used[i] = true;
	if (++used_count == tlb_size)
	  clear_used();
      }
    }

    // clr_used() clears the used flag of TLB entry i
    void clr_used( uint_t i )
    {
      if (used[i])
      {
	used[i] = false;
	--used_count;
      }
    }

  protected:
    N2_TrieTlb trie;

    static SS_Tlb* n2_clone( SS_Tlb* );

    bool*  used;		
    uint_t used_count;

    void clear_used()
    {
      for (uint_t i=0; i < tlb_size; i++)
	used[i] = false;
      used_count = 0;
    }

    uint_t get_free_tte()
    {
      uint_t i;

      for (i=0; i < tlb_size; i++)
      {
	SS_Tte* tte = ptr_table[i];
	if (!tte->valid())
	  return i;
      }
      
      for (i=0; i < tlb_size; i++)
	if (!used[i])
	  return i;
      
      clear_used();

      return tlb_size - 1;
    }
};


#endif