sam-t2/sam/cpus/vonk/ss/lib/cpu/src/SS_Tlb.h

/*
* ========== Copyright Header Begin ==========================================
*
* OpenSPARC T2 Processor File: SS_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 __SS_Tlb_h__
#define __SS_Tlb_h__

#include "SS_Tte.h"
#include "SS_Node.h"
#include "SS_Strand.h"
#include "BL_Mutex.h"
#include "BL_Atomic.h"
#include <synch.h>

class SS_Tlb
{
  public:
    enum Type
    {
      INST_TLB = 0x1,
      DATA_TLB = 0x2
    };

    friend Type operator|( Type a, Type b )     { return Type(int(a)|int(b)); }


    SS_Tlb( Type type, uint_t _size );
    SS_Tlb( SS_Tlb& tlb );
    ~SS_Tlb();

    uint_t tlb_id()                             { return tlb_ident; }

    // is_xxxx_tlb() returns true when the TLB is of type xxxx

    bool is_inst_tlb()                          { return tlb_type & INST_TLB; }
    bool is_data_tlb()                          { return tlb_type & DATA_TLB; }

    bool is_a_clone()                           { return !not_a_clone; }

    // clone() can be called to make a copy of the tlb. The method function
    // is provided by this class or derived classes. clone() is primarily used in
    // the SS_TlbSync.
    SS_Tlb* (*clone)( SS_Tlb* );

    // add_strand() is called by a strand to register itself with the TLB to
    // receive tte flushes for decode cache updates. (strand unparks)
    void add_strand( SS_Strand* s );

    // rem_strand() is called by a strand to unregister itself with the TLB to
    // stop receivingtte flushes for decode cache updates. (strand parks)
    void rem_strand( SS_Strand* s );

    // reuse_tte() is called by the strand after strand->flush_tte is done and
    // the usage_count count is decremented to zero (the atomic add returns the
    // previous value of the atomic count). Note in cosim mode with tlb syncing
    // we should not call this as we keep all tte's ever created.
    void reuse_tte( SS_Tte* tte )
    {
      assert(tte->usage_count);

      if (bl_atomic_add32(&tte->usage_count,-1) == 1)
      {
        tte_list_mutex.lock();
        tte->next = tte_list;
        tte->valid_bit(false);
        tte_list = tte;
        tte_list_mutex.unlock();
      }
    }

    // lock_reuse_tte() is used in SS_Strand::trc_step to hold on to the current
    // tte used for the instruction trace. SS_Strand::trc_step will call reuse_tte
    // to unlock the TTE. Locking is done by bumping the flosh_pending count by one
    // which prevents the recycling of the TTE.

    void lock_reuse_tte( SS_Tte* tte )
    {
      bl_atomic_add32(&tte->usage_count,1);
    }

    // size() returns the size of the tlb in number of TTEs
    uint_t size()
    {
      return tlb_size;
    }

    // get() return the TTE as index.
    SS_Tte* get( uint_t index )
    {
      assert(index < size());
      return ptr_table[index];
    }

    // set() inserts tte into the TLb at index: it copies the TTE contents
    void set( uint_t index, SS_Tte* tte )
    {
      assert(index < size());
      tlb_access.lock();
      SS_Tte* old_tte = ptr_table[index];
      assert(old_tte->index == index);
      SS_Tte* new_tte = alloc_tte(index);
      *new_tte = *tte;
      new_tte->index = index;
      ptr_table[index] = new_tte;
      flush_tte(0,old_tte);
      tlb_access.unlock();
    }

    // flush() is for frontends that play with tte fields we need a way to flush
    // the modified tte from the decode caches.

    void flush( SS_Tte* tte )
    {
      assert(tte);
      flush_tte(0,tte);
    }

    int next_valid_index( int i )
    {
      if (0 <= i)
        for (; i < size(); i++)
          if (ptr_table[i]->valid())
            return i;
      return -1;
    }

    void dump(FILE *fp=stdout);

    // invalidate_tte() is for demap operations to invalidate a TTE.
    // It replaces the TTE at index i with a new TTE and calls flush_tte()
    // to evict the TTE from the decode caches.

    void invalidate_tte( SS_Strand* strand, uint i )
    {
      SS_Tte* tte = ptr_table[i];
      assert(tte->index == i);
      ptr_table[i] = alloc_tte(i);
      flush_tte(strand,tte);
    }

    void invalidate_tte( SS_Strand* strand, SS_Tte* tte )
    {
      assert(tte == ptr_table[tte->index]);
      ptr_table[tte->index] = alloc_tte(tte->index);
      flush_tte(strand,tte);
    }

  protected:
    BL_Mutex          tlb_access;               // The lock used for gaining write access to the TLB

    // tlb_access_lock() and tlb_access_unlock() are used for TLB insert and
    // demap. The tlb_access_lock bumps the generation count by one after
    // locking the tlb access mutex. A tlb lookup routine that
    // does not need the lock and unlock routines can use tlb_access_enter()
    // and tlb_access_leave() to ensure that at most one TLB insert or remove
    // happened. If the results of these routines are different then one or
    // more tlb modifications happened. If they are the same then zero or
    // maximum one tlb modification is happening.
    //
    // When c and C are tlb_access_enter and leave respectively, and m and M
    // are tlb_access_lock and unlock respectively, then we can have the
    // following situaltions.
    //
    // cCmM  ok, generation count equal. all fine.
    // cmCM  oops, generation count different
    // cmMC  oops, generation count different
    // mcCM  fail, generation count equal but mutexed operation ongoing
    // mcMC  oops, generation count different
    // mMcC  ok, generation count equal. all fine.
    //
    // The mcCM case is painfull, but at least it allows us to deal
    // with recycling memory in not to difficult fashion and have mutex
    // free TLB lookup which is crucial for MP performance (scalability).

    void tlb_access_lock()
    {
      tlb_access.lock();
      ++generation_count;
    }

    void tlb_access_unlock()
    {
      tlb_access.unlock();
    }

    uint64_t tlb_access_enter()
    {
      return generation_count;
    }

    uint64_t tlb_access_leave()
    {
      return generation_count;
    }

    static uint_t tlb_id_no;            // The next tlb_id number, bumped on creation

    uint_t      tlb_ident;              // The id of this TLB
    Type        tlb_type;               // Inst and or data tlb
    uint_t      tlb_size;               // The size of the TLB in no TTEs
    SS_Tte**    ptr_table;              // The PTR table points to the tte_table entries

    // flush_tte() is called to signal the strands that a tte should be flushed
    // from the decode cache. usage_count is set to the number of flushes send
    // out. Each strand decrements usage_count by one. The tte will not be reused
    // while usage_count >= 0. The last strand to perform an atomic decrement by -1
    // on the usage_count during reuse_tte will cause the tte to become available again.

    void flush_tte( SS_Strand* caller, SS_Tte* tte )
    {
      if (tte->valid_bit())
      {
        if (caller && caller->trc_hook)
          caller->trc_hook->tlb_update(false,this,tte->index,tte);

        bl_atomic_add32(&tte->usage_count,no_strands - 1);   // Initial usage_count is 1

        for (Node* strand=strand_list; strand; strand = strand->next)
        {
          SS_Signal* sgn;
          if (caller)
            sgn = caller->msg.make_signal(SS_Signal::FLUSH_TTE);
          else
            sgn = SS_Signal::alloc(SS_Signal::FLUSH_TTE);
          sgn->tte = tte;
          sgn->tlb = this;
          strand->strand->post_signal(sgn);
        }
      }
      else if ((caller && !caller->sim_state.cosim()) || (caller == 0))
      {
        tte_list_mutex.lock();
        tte->next = tte_list;
        tte_list = tte;
        tte_list_mutex.unlock();
      }
    }

    // alloc_tte() gets a new tte from either the tte_list or mallocs it.
    // We initialise the usage_count of the TTE to 1 and we set the index
    // of the TTE to the index of the ptr_table.

    SS_Tte* alloc_tte_block();

    SS_Tte* alloc_tte( uint_t index )
    {
      tte_list_mutex.lock();
      SS_Tte* help = tte_list;
      if (help == 0)
        help = alloc_tte_block();
      else
        tte_list = help->next;
      help->index = index;
      help->usage_count = 1;
      tte_list_mutex.unlock();
      return help;
    }

  private:
    volatile uint64_t generation_count;         // Each modifications of the TLB bumps the count by 1

    static SS_Tlb* ss_clone( SS_Tlb* );

    class Node
    {
      public:
        Node( SS_Strand* s, Node* _next ) : strand(s), next(_next) {}

        SS_Strand* strand;
        Node*      next;
    };

    bool      not_a_clone;              // True when the TLB is the original TLB (false when clone()d)
    Node*     strand_list;              // Linked list of all strands that share this TLB
    uint_t    no_strands;               // No strands in the strands list

    BL_Mutex  tte_list_mutex;           // Mutex lock for updating tte_list
    SS_Tte*   tte_list;                 // List of free tte's that can be used for tlb updates.
};

#endif