Initial commit of OpenSPARC T2 architecture model.

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

// ========== Copyright Header Begin ==========================================
// 
// OpenSPARC T2 Processor File: N2_TrieTlb.cc
// 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 ============================================

#include "N2_Tlb.h"
#include "N2_TrieTlb.h"
#include <new>

N2_TrieTlb::N2_TrieTlb( N2_Tlb* _tlb )/*{{{*/
:
 tlb(_tlb),
 fail_node1(0),
 fail_node2(0),
 fail_node3(0),
 fail_page5(0),
 fail_page3(0),
 fail_page1(0),
 free_node1(0),
 free_node2(0),
 free_node3(0),
 free_page5(0),
 free_page3(0),
 free_page1(0)
{
 fail_page1 = new Page1(0);
 fail_page3 = new Page3(fail_page1);
 fail_page5 = new Page5(fail_page3);
 fail_node3 = new Node3(fail_page5);
 fail_node2 = new Node2(fail_node3);
 fail_node1 = new Node1(fail_node2);

 fail_node1->fail_node();
 fail_node2->fail_node();
 fail_node3->fail_node();
 fail_page5->fail_node();
 fail_page3->fail_node();
 fail_page1->fail_node();

 for (uint_t p=0; p < PID_SIZE; p++)
 {
   real[p] = fail_node1;
   for (uint_t c=0; c < CTX_SIZE; c++)
     virt[p][c] = fail_node1;
 }
}
/*}}}*/
N2_TrieTlb::N2_TrieTlb( N2_TrieTlb& trie, N2_Tlb* _tlb )/*{{{*/
:
 tlb(_tlb),
 fail_node1(trie.fail_node1),
 fail_node2(trie.fail_node2),
 fail_node3(trie.fail_node3),
 fail_page5(trie.fail_page5),
 fail_page3(trie.fail_page3),
 fail_page1(trie.fail_page1),
 free_node1(trie.free_node1),
 free_node2(trie.free_node2),
 free_node3(trie.free_node3),
 free_page5(trie.free_page5),
 free_page3(trie.free_page3),
 free_page1(trie.free_page1)
{
 trie.free_node1 = 0;
 trie.free_node2 = 0;
 trie.free_node3 = 0;
 trie.free_page5 = 0;
 trie.free_page3 = 0;
 trie.free_page1 = 0;

 for (uint_t p=0; p < PID_SIZE; p++)
 {
   real[p] = trie.copy(trie.real[p]);
   for (uint_t c=0; c < CTX_SIZE; c++)
     virt[p][c] = trie.copy(trie.virt[p][c]);
 }
}
/*}}}*/
N2_TrieTlb::~N2_TrieTlb()/*{{{*/
{
 for (uint_t p=0; p < PID_SIZE; p++)
   demap_all(0,p);

 while (free_node1)
 {
   Node1* help = free_node1;
   free_node1 = free_node1->next;
   delete help;
 }

 while (free_node2)
 {
   Node2* help = free_node2;
   free_node2 = free_node2->next;
   delete help;
 }

 while (free_node3)
 {
   Node3* help = free_node3;
   free_node3 = free_node3->next;
   delete help;
 }

 while (free_page5)
 {
   Page5* help = free_page5;
   free_page5 = free_page5->next;
   delete help;
 }

 while (free_page3)
 {
   Page3* help = free_page3;
   free_page3 = free_page3->next;
   delete help;
 }

 while (free_page1)
 {
   Page1* help = free_page1;
   free_page1 = free_page1->next;
   delete help;
 }
}
/*}}}*/

N2_TrieTlb::Node1* N2_TrieTlb::copy( Node1* r_n1 )/*{{{*/
{
 if (r_n1 == fail_node1)
   return r_n1;
 Node1* l_n1 = new_node1();
  
 for (uint_t i0=0; i0 < Node1::SIZE; i0++)
 {
   Node2* r_n2 = r_n1->idx(i0);

   if (r_n2 == fail_node2)
     continue;
   Node2* l_n2 = new_node2();
 
   l_n1->insert(i0,l_n2);

   for (uint_t i1=0; i1 < Node2::SIZE; i1++)
   {
     Node3* r_n3 = r_n2->idx(i1);

     if (r_n3 == fail_node3)
       continue;
     Node3* l_n3 = new_node3();

     l_n2->insert(i1,l_n3);

     for (uint_t i2=0; i2 < Node3::SIZE; i2++)
     {
       Page5* r_p5 = r_n3->idx(i2);

       if (r_p5 == fail_page5)
         continue;
       Page5* l_p5 = new_page5();

       l_p5->tte = r_p5->tte;
       l_n3->insert(i2,l_p5);

       for (uint_t i3=0; i3 < Page5::SIZE; i3++)
       {
         Page3* r_p3 = r_p5->idx(i3);

         if (r_p3 == fail_page3)
           continue;
         Page3* l_p3 = new_page3();

         l_p3->tte = r_p3->tte;
         l_p5->insert(i3,l_p3);

         for (uint_t i4=0; i4 < Page3::SIZE; i4++)
         {
           Page1* r_p1 = r_p3->idx(i4);

           if (r_p1 == fail_page1)
             continue;
           Page1* l_p1 = new_page1();

           l_p1->tte = r_p1->tte;
           l_p3->insert(i4,l_p1);

           for (uint_t i5=0; i5 < Page1::SIZE; i5++)
           {
             SS_Tte* tte = r_p1->idx(i5);

             if (tte)
               l_p1->insert(i5,tte);
           }
         }
       }
     }
   }
 }
 return l_n1;
}
/*}}}*/

void N2_TrieTlb::insert( SS_Strand* strand, SS_Tte* tte, SS_Tte* rem_tte )/*{{{*/
{
 Node1*   n1;

 if (tte->is_virt())
 {
   n1 = virt[tte->pid()][tte->context()];
   if (n1 == fail_node1)
   {
     n1 = new_node1();
     virt[tte->pid()][tte->context()] = n1;
   }
 }
 else if (tte->is_real())
 {
   n1 = real[tte->pid()];
   if (n1 == fail_node1)
   {
     n1 = new_node1();
     real[tte->pid()] = n1;
   }
 }
 else
 {
   remove(rem_tte);
   return;
 }

 // For the va we use the non aligned tag value, e.g we don't 
 // use tte->virt_page. We do this so we auto demap the 
 // correct smaller page(s).

 SS_Vaddr va = tte->tag();
 uint_t ps = tte->page_size();
 
 Node2* n2 = n1->at(va);
 Node3* n3 = n2->at(va);
 Page5* p5 = n3->at(va);
 Page3* p3 = p5->at(va);
 Page1* p1 = p3->at(va);

 Page5* p5_new = 0;
 Page3* p3_new = 0;
 Page1* p1_new = 0;
 
 SS_Tte* p5_tte = p5->tte;
 SS_Tte* p3_tte = p3->tte;
 SS_Tte* p1_tte = p1->tte;
 SS_Tte* p0_tte = p1->at(va);

 // Inserts the TTE and auto demap the overlapping TTEs. E.g. demap
 // p0_tte, p1_tte, p3_tte, and p5_tte is they are valid TTEs (!= 0).
 // This insert and demap has to be (like in hardware) an atomic operation. 
 // We do this by creating a new path with the TTEs that are to be
 // demapped removed and the new TTE inserted.

 if (p0_tte)
 {
   // We have a full path: p5, p3, p1 and the have to demap a p0 TTE.
   // Optimise for a simple case: replace p0_tte, as Solaris often 
   // changes readonly TTEs into readwrite TTEs: a result from fork().
   // The unoptimised case creates a new path and updates the TTEs and
   // inserts the path in the trie as the last operation.
   
   if ((ps == 0) && (p1_tte == 0) && (p3_tte == 0) && (p5_tte == 0))
   {
     p1->at(va) = tte;

     if (p0_tte != rem_tte)
     {
       tlb->clr_used(p0_tte->index);
       tlb->invalidate_tte(strand,p0_tte);
       remove(rem_tte);
     }
     return;
   }
   else
   {
     p5_new = new_page5(p5);
     p3_new = new_page3(p3);
     p1_new = new_page1(p1);

     p5_new->at(va) = p3_new;
     p3_new->at(va) = p1_new;

     p5_new->tte = (ps == 5) ? tte : 0;
     p3_new->tte = (ps == 3) ? tte : 0;
     p1_new->tte = (ps == 1) ? tte : 0;

     if (ps == 0)
       p1_new->at(va) = tte;
     else 
       p1_new->remove(va,0);

     if (p1_new->is_empty())
     {
       p3_new->remove(va,fail_page1);
       if (p3_new->is_empty())
       {
         p5_new->remove(va,fail_page3);
         del_page3(p3_new);
         p3_new = 0;
       }
       del_page1(p1_new);
       p1_new = 0;
     }

     n3->at(va) = p5_new;
   }
 }
 else if (p1_tte)
 {
   // Again we have a full path: p5, p3, p1 and the smallest TTE we have
   // to demap is p1 TTE. Optimise for a trivial case. Otherwise create
   // a new path with the TTEs updated and insert in the trie at the end.
  
   if ((ps == 1) && (p3_tte == 0) && (p5_tte == 0))
   {
     p1->tte = tte;
     
     if (p1_tte != rem_tte)
     {
       tlb->clr_used(p1_tte->index);
       tlb->invalidate_tte(strand,p1_tte);
       remove(rem_tte);
     }
     return;
   }
   else
   {
     p5_new = new_page5(p5);
     p3_new = new_page3(p3);
     p1_new = new_page1(p1);

     p5_new->at(va) = p3_new;
     p3_new->at(va) = p1_new;

     p5_new->tte = (ps == 5) ? tte : 0;
     p3_new->tte = (ps == 3) ? tte : 0;
     p1_new->tte = (ps == 1) ? tte : 0;

     if (ps == 0)
       p1_new->insert(va,tte);

     if (p1_new->is_empty())
     {
       p3_new->remove(va,fail_page1);
       if (p3_new->is_empty())
       {
         p5_new->remove(va,fail_page3);
         del_page3(p3_new);
         p3_new = 0;
       }
       del_page1(p1_new);
       p1_new = 0;
     }

     n3->at(va) = p5_new;
   }
 }
 else if (p3_tte)
 {
   // We have at least a p5 and p3 node. Select the trivial case for
   // optimisation. Else switch between possibly shrinking the path
   // (ps >= 3) or extending the path.
   
   if ((ps == 3) && (p5_tte == 0))
   {
     p3->tte = tte;

     if (p3_tte != rem_tte)
     {
       tlb->clr_used(p3_tte->index);
       tlb->invalidate_tte(strand,p3_tte);
       remove(rem_tte);
     }
     return;
   }
   else if (ps >= 3)
   {
     p5_new = new_page5(p5);
     p3_new = new_page3(p3);

     p5_new->at(va) = p3_new;

     p5_new->tte = (ps == 5) ? tte : 0;
     p3_new->tte = (ps == 3) ? tte : 0;

     if (p3_new->is_empty())
     {
       p5_new->remove(va,fail_page3);
       del_page3(p3_new);
       p3_new = 0;
     }

     n3->at(va) = p5_new;
   }
   else
   {
     Page1* p1_tmp;

     p5_new = new_page5(p5);
     p3_new = new_page3(p3);
     p5_new->at(va) = p3_new;

     if (p1 == fail_page1)
     {
       p1 = new_page1();
       p3_new->insert(va,p1);
       p1_tmp = p1;
     }
     else
     {
       p1_new = new_page1(p1);
       p3_new->at(va) = p1_new;
       p1_tmp = p1_new;
     }

     p5_new->tte = 0;
     p3_new->tte = 0;
     p1_tmp->tte = (ps == 1) ? tte : 0;

     if (ps == 0)
       p1_tmp->insert(va,tte);

     n3->at(va) = p5_new;
   }
 }
 else if (p5_tte)
 {
   // We have a p5 node. Optimise the simple case. Otherwise
   // insert and create missing path.
  
   if (ps == 5)
   {
     p5->tte = tte;

     if (p5_tte != rem_tte)
     {
       tlb->clr_used(p5_tte->index);
       tlb->invalidate_tte(strand,p5_tte);
       remove(rem_tte);
     }
     return;
   }
   else
   {
     Page1* p1_tmp;
     Page3* p3_tmp;

     p5_new = new_page5(p5);
     p5_new->tte = 0;

     if (p3 == fail_page3)
     {
       p3 = new_page3();
       p5_new->insert(va,p3);
       p3_tmp = p3;
     }
     else
     {
       p3_new = new_page3(p3);
       p5_new->at(va) = p3_new;
       p3_tmp = p3_new;
     }

     if (ps == 3)
     {
       p3_tmp->tte = tte;
     }
     else
     {
       p3_tmp->tte = 0;

       if (p1 == fail_page1)
       {
         p1 = new_page1();
         p3_tmp->insert(va,p1);
         p1_tmp = p1;
       }
       else
       {
         p1_new = new_page1(p1);
         p3_new->at(va) = p1_new;
         p1_tmp = p1_new;
       }

       if (ps == 1)
       {
         p1_tmp->tte = tte;
       }
       else
       {
         p1_tmp->tte = 0;
         p1_tmp->insert(va,tte);
       }
     }

     n3->at(va) = p5_new;
   }
 }
 else if (p1 != fail_page1)
 {
   // We have no overlapping TTEs and the path p5, p3, p1 is there.
   // This is a simple case, likely to happen often. We can just set 
   // the new TTE, remove the replaced TTE and return.

   if (ps == 0)
     p1->insert(va,tte);
   else if (ps == 1)
     p1->tte = tte;
   else if (ps == 3)
     p3->tte = tte;
   else 
     p5->tte = tte;

   remove(rem_tte);
   return;
 }
 else 
 {
   // The path is partial there. Create as much as we need, based on 
   // the page size (ps) of the TTE to be inserted.

   if (p5 == fail_page5)
   {
     if (n3 == fail_node3)
     {
       if (n2 == fail_node2)
       {
         n2 = new_node2();
         n1->insert(va,n2);
       }
       n3 = new_node3();
       n2->insert(va,n3);
     }
     p5 = new_page5();
     n3->insert(va,p5);
   }

   if (ps == 5)
   {
     p5->tte = tte;
   }
   else
   {
     if (p3 == fail_page3)
     {
       p3 = new_page3();
       p5->insert(va,p3);
     }

     if (ps == 3)
     {
       p3->tte = tte;
     }
     else
     {
       if (p1 == fail_page1)
       {
         p1 = new_page1();
         p3->insert(va,p1);
       }

       if (ps == 1)
         p1->tte = tte;
       else
         p1->insert(va,tte);
     }
   }
 }

 // Now invalidate all the TTEs that got autodemapped.
 // However, don't invalidate the TTE that is selected
 // by the replacement algorithm to make place for the
 // new TTE.

 if (p0_tte == rem_tte)
   rem_tte = 0;
 else if (p0_tte)
 {
   tlb->clr_used(p0_tte->index);
   tlb->invalidate_tte(strand,p0_tte);
 }

 if (p1_tte == rem_tte)
   rem_tte = 0;
 else if (p1_tte)
 {
   tlb->clr_used(p1_tte->index);
   tlb->invalidate_tte(strand,p1_tte);
 }

 if (p3_tte == rem_tte)
   rem_tte = 0;
 else if (p3_tte)
 {
   tlb->clr_used(p3_tte->index);
   tlb->invalidate_tte(strand,p3_tte);
 }

 if (p5_tte == rem_tte)
   rem_tte = 0;
 else if (p5_tte)
 {
   tlb->clr_used(p5_tte->index);
   tlb->invalidate_tte(strand,p5_tte);
 }
    
 // Free up the pages that got copied to make auto-demap 
 // an atomic operation. Note we don;t clear the tte pointers
 // and we don't demolish the p5 to p3 to p1 path. We
 // do this so that lookup can detect multi hits properly.

 if (p5_new)
   del_page5(p5);
 if (p3_new)
   del_page3(p3);
 if (p1_new)
   del_page1(p1);
 
 remove(rem_tte);
}
/*}}}*/
void N2_TrieTlb::remove( SS_Tte* tte )/*{{{*/
{
 Node1*   n1;

 if (tte == 0)
   return;
 else if (tte->is_virt())
   n1 = virt[tte->pid()][tte->context()];
 else if (tte->is_real())
   n1 = real[tte->pid()];
 else
   return;

 SS_Vaddr va = tte->virt_page;
 uint_t   ps = tte->page_size();

 Node2* n2 = n1->at(va);
 Node3* n3 = n2->at(va);
 Page5* p5 = n3->at(va);
 Page3* p3 = p5->at(va);
 Page1* p1 = p3->at(va);

 assert(n1 != fail_node1);
 assert(n2 != fail_node2);
 assert(n3 != fail_node3);
 assert(p5 != fail_page5);

 if (ps == 5)
 {
   assert((p5->tte == tte) || (p5->tte == 0));
   p5->tte = 0;
 }
 else
 {
   assert(p3 != fail_page3);

   if (ps == 3)
   {
     assert((p3->tte == tte) || (p3->tte == 0));
     p3->tte = 0;
   }
   else
   {  
     assert(p1 != fail_page1);

     if (ps == 1)
     {
       assert((p1->tte == tte) || (p1->tte == 0));
       p1->tte = 0;
     }
     else
     {
       assert(ps == 0);
       assert((p1->at(va) == tte) || (p1->at(va) == 0));
       p1->remove(va,0);
     }

     if (p1->is_empty())
     {
       p3->remove(va,fail_page1);
       del_page1(p1);
     }
   }

   if (p3->is_empty())
   {
     p5->remove(va,fail_page3);
     del_page3(p3);
   }
 }

 if (p5->is_empty())
 {
   n3->remove(va,fail_page5);
   del_page5(p5);

   if (n3->is_empty())
   {
     n2->remove(va,fail_node3);
     del_node3(n3);

     if (n2->is_empty())
     {
       n1->remove(va,fail_node2);
       del_node2(n2);

       if (n1->is_empty())
       {
         if (tte->is_real())
           real[tte->pid()] = fail_node1;
         else
           virt[tte->pid()][tte->context()] = fail_node1;
         del_node1(n1);
       }
     }
   }
 }
}
/*}}}*/

// demap_trie() remove TTEs from a Trie in an atomic fashion.
// 
// Lookup searches with va from largest TTE to smaller TTE.
// When demapping we remove TTEs from smaller to largest. 
// This way the TTE found by lookup is always the largest or 
// one that persist after the demap, e.g. it makes the demap
// appear atomic.

bool N2_TrieTlb::demap_trie( SS_Strand* strand, Node1* n1, SS_Vaddr va )/*{{{*/
{
 Node2* n2 = n1->at(va);
 Node3* n3 = n2->at(va);
 Page5* p5 = n3->at(va);
 Page3* p3 = p5->at(va);
 Page1* p1 = p3->at(va);

 SS_Tte* tte;

 if ((tte = p1->at(va)))
 {
   p1->remove(va,0);
   tlb->clr_used(tte->index);
   tlb->invalidate_tte(strand,tte);
 }

 if ((tte = p1->tte))
 {
   p1->tte = 0;
   tlb->clr_used(tte->index);
   tlb->invalidate_tte(strand,tte);
 }

 if (p1->is_empty())
 {
   p3->remove(va,fail_page1);
   del_page1(p1);
 }

 if ((tte = p3->tte))
 {
   p3->tte = 0;
   tlb->clr_used(tte->index);
   tlb->invalidate_tte(strand,tte);
 }

 if (p3->is_empty())
 {
   p5->remove(va,fail_page3);
   del_page3(p3);
 }

 if ((tte = p5->tte))
 {
   p5->tte = 0;
   tlb->clr_used(tte->index);
   tlb->invalidate_tte(strand,tte);
 }

 if (p5->is_empty())
 {
   n3->remove(va,fail_page5);
   del_page5(p5);
 }

 if (n3->is_empty())
 {
   n2->remove(va,fail_node3);
   del_node3(n3);
 }

 if (n2->is_empty())
 {
   n1->remove(va,fail_node2);
   del_node2(n2);
 }

 if (n1->is_empty())
 {
   del_node1(n1);
   return true;
 }

 return false;
}
/*}}}*/

void N2_TrieTlb::demap_trie( SS_Strand* strand, Node1* n1 )/*{{{*/
{
 assert(n1 != fail_node1);

 if (!n1->is_empty_trie())
 {
   for (uint_t i=0; i < Node1::SIZE; i++)
   {
     Node2* n2 = n1->idx(i);
     if (n2 == fail_node2)
       continue;
     n1->remove(i,fail_node2);
     demap_trie(strand,n2);
   }
 }

 del_node1(n1);
}
/*}}}*/
void N2_TrieTlb::demap_trie( SS_Strand* strand, Node2* n2 )/*{{{*/
{
 assert(n2 != fail_node2);

 if (!n2->is_empty_trie())
 {
   for (uint_t i=0; i < Node2::SIZE; i++)
   {
     Node3* n3 = n2->idx(i);
     if (n3 == fail_node3)
       continue;
     n2->remove(i,fail_node3);
     demap_trie(strand,n3);
   }
 }

 del_node2(n2);
}
/*}}}*/
void N2_TrieTlb::demap_trie( SS_Strand* strand, Node3* n3 )/*{{{*/
{
 assert(n3 != fail_node3);

 if (!n3->is_empty_trie())
 {
   for (uint_t i=0; i < Node3::SIZE; i++)
   {
     Page5* p5 = n3->idx(i);
     if (p5 == fail_page5)
       continue;
     n3->remove(i,fail_page5);
     demap_trie(strand,p5);
   }
 }

 del_node3(n3);
}
/*}}}*/
void N2_TrieTlb::demap_trie( SS_Strand* strand, Page5* p5 )/*{{{*/
{
 assert(p5 != fail_page5);

 SS_Tte* tte;
  
 if (!p5->is_empty_trie())
 {
   for (uint_t i=0; i < Page5::SIZE; i++)
   {
     Page3* p3 = p5->idx(i);
     if (p3 == fail_page3)
       continue;
     p5->remove(i,fail_page3);
     demap_trie(strand,p3);
   }
 }

 if ((tte = p5->tte))
 {
   p5->tte = 0;
   if (strand)
   {
     tlb->clr_used(tte->index);
     tlb->invalidate_tte(strand,tte);
   }
 }

 del_page5(p5);
}
/*}}}*/
void N2_TrieTlb::demap_trie( SS_Strand* strand, Page3* p3 )/*{{{*/
{
 assert(p3 != fail_page3);

 SS_Tte* tte;
 
 if (!p3->is_empty_trie())
 {
   for (uint_t i=0; i < Page3::SIZE; i++)
   {
     Page1* p1 = p3->idx(i);
     if (p1 == fail_page1)
       continue;
     p3->remove(i,fail_page1);
     demap_trie(strand,p1);
   }
 }

 if ((tte = p3->tte))
 {
   p3->tte = 0;
   if (strand)
   {
     tlb->clr_used(tte->index);
     tlb->invalidate_tte(strand,tte);
   }
 }
   
 del_page3(p3);
}
/*}}}*/
void N2_TrieTlb::demap_trie( SS_Strand* strand, Page1* p1 )/*{{{*/
{
 assert(p1 != fail_page1);

 SS_Tte* tte;

 if (!p1->is_empty_trie())
 {
   for (uint_t i=0; i < Page1::SIZE; i++)
   {
     if ((tte = p1->idx(i)))
     {
       p1->remove(i,0);
       if (strand)
       {
         tlb->clr_used(tte->index);
         tlb->invalidate_tte(strand,tte);
       }
     }
   }
 }

 if ((tte = p1->tte))
 {
   p1->tte = 0;
   if (strand)
   {
     tlb->clr_used(tte->index);
     tlb->invalidate_tte(strand,tte);
   }
 }

 del_page1(p1);
}
/*}}}*/

void N2_TrieTlb::demap_virt( SS_Strand* strand, uint_t pid, uint_t ctx, SS_Vaddr va )/*{{{*/
{
 Node1* n1 = virt[pid][ctx];
 if (demap_trie(strand,n1,va))
   virt[pid][ctx] = fail_node1;
}
/*}}}*/
void N2_TrieTlb::demap_virt( SS_Strand* strand, uint_t pid, uint_t ctx )/*{{{*/
{
 Node1* n1 = virt[pid][ctx];
 virt[pid][ctx] = fail_node1;
 if (n1 != fail_node1)
   demap_trie(strand,n1);
}
/*}}}*/
void N2_TrieTlb::demap_virt( SS_Strand* strand, uint_t pid )/*{{{*/
{
 for (uint_t ctx=0; ctx < CTX_SIZE; ctx++)
   demap_virt(strand,pid,ctx);
}
/*}}}*/

void N2_TrieTlb::demap_real( SS_Strand* strand, uint_t pid, SS_Vaddr ra )/*{{{*/
{
 Node1* n1 = real[pid];
 if (demap_trie(strand,n1,ra))
   real[pid] = fail_node1;
}
/*}}}*/
void N2_TrieTlb::demap_real( SS_Strand* strand, uint_t pid )/*{{{*/
{
 Node1* n1 = real[pid];
 real[pid] = fail_node1;
 if (n1 != fail_node1)
   demap_trie(strand,n1);
}
/*}}}*/

void N2_TrieTlb::demap_all( SS_Strand* strand, uint_t pid )/*{{{*/
{
 demap_virt(strand,pid);
 demap_real(strand,pid);
}
/*}}}*/