projects / OpenSPARC-T2-DV / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial commit of OpenSPARC T2 design and verification files.
[OpenSPARC-T2-DV] / verif / env / common / vera / classes / ccx_tag_class.vr
// ========== Copyright Header Begin ==========================================
//
// OpenSPARC T2 Processor File: ccx_tag_class.vr
// Copyright (C) 1995-2007 Sun Microsystems, Inc. All Rights Reserved
// 4150 Network Circle, Santa Clara, California 95054, U.S.A.
//
// * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; version 2 of the License.
//
// This 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 program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// For the avoidance of doubt, and except that if any non-GPL license
// choice is available it will apply instead, Sun elects to use only
// the General Public License version 2 (GPLv2) at this time for any
// software where a choice of GPL license versions is made
// available with the language indicating that GPLv2 or any later version
// may be used, or where a choice of which version of the GPL is applied is
// otherwise unspecified.
//
// Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
// CA 95054 USA or visit www.sun.com if you need additional information or
// have any questions.
//
// ========== Copyright Header End ============================================
#include <vera_defines.vrh>
#include <globals.vri>
#include <ccx.vri>
#include <defines.vri>
#include <std_display_defines.vri>
#include <std_display_class.vrh>
//----------------------------------------------------------
//----------------------------------------------------------
class TAG_MEM {
local integer instance;
string name;
reg type; // I$ or D$
reg [2:0] max_tag; // 7 or 3
reg [6:0] max_line; // 63 or 127
reg [239:0] tag_mem [128];
//----------------------------------------------------------
task new (reg new_type,
reg [6:0] new_max_line,
reg [2:0] new_max_tag,
integer inst=0) {
integer i,j;
type = new_type;
max_tag = new_max_tag;
max_line = new_max_line;
if (type==DATA_TAG) {
name = "dtag";
} else {
name = "itag";
}
instance = inst;
// Initialize memory - all entries are invalid
for (i=0; i<=max_line; i=i+1) {
tag_mem[i] = 0;
}
PR_DEBUG(name, MON_DEBUG, psprintf("C%0d type = %b max_line = %d max_tag = %d ",instance,type,max_line,max_tag));
}
//----------------------------------------------------------
// Print all valid entries in the table
task dump_mem (integer msglevel) {
integer i,j;
if (msglevel>=MON_NORMAL) {
if (type==DATA_TAG) {
PR_NORMAL(name, MON_NORMAL,
psprintf("--- C%0d D$ TAG MEMORY (valid entries only) --- ",instance));
} else {
PR_NORMAL(name, MON_NORMAL,
psprintf("--- C%0d I$ TAG MEMORY (valid entries only) --- ",instance));
}
} else {
if (type==DATA_TAG) {
PR_INFO(name, MON_INFO,
psprintf("--- C%0d D$ TAG MEMORY (valid entries only) --- ",instance));
} else {
PR_INFO(name, MON_INFO,
psprintf("--- C%0d I$ TAG MEMORY (valid entries only) --- ",instance));
}
}
for (i=0; i<=max_line; i=i+1) {
if (tag_mem[i] !== 0) dump_line ("Dump",i,msglevel);
}
}
//----------------------------------------------------------
// Print the line
task dump_line (string why, reg [6:0] index,integer msglevel) {
reg [28:0] tag0,tag1,tag2,tag3,tag4,tag5,tag6,tag7;
reg valid0,valid1,valid2,valid3,valid4,valid5,valid6,valid7;
error_check(0,index);
read_line (index,
tag0,tag1,tag2,tag3,
tag4,tag5,tag6,tag7,
valid0,valid1,valid2,valid3,
valid4,valid5,valid6,valid7);
if (msglevel>=MON_NORMAL) {
PR_NORMAL(name, MON_NORMAL,
psprintf({"C%0d tag_mem[%2h] ",
"w3-w0 V:T %b:%h %b:%h %b:%h %b:%h [dump_line]%s"},
instance,index,
valid3,tag3,valid2,tag2,valid1,tag1,valid0,tag0,why));
if (type!=DATA_TAG) {
PR_NORMAL(name, MON_NORMAL,
psprintf({"C%0d tag_mem[%2h] ",
"w7-w4 V:T %b:%h %b:%h %b:%h %b:%h [dump_line]%s"},
instance,index,
valid7,tag7,valid6,tag6,valid5,tag5,valid4,tag4,why));
}
} else {
PR_INFO(name, MON_INFO,
psprintf({"C%0d tag_mem[%2h] ",
"w3-w0 V:T %b:%h %b:%h %b:%h %b:%h [dump_line]%s"},
instance,index,
valid3,tag3,valid2,tag2,valid1,tag1,valid0,tag0,why));
if (type!=DATA_TAG) {
PR_INFO(name, MON_INFO,
psprintf({"C%0d tag_mem[%2h] ",
"w7-w4 V:T %b:%h %b:%h %b:%h %b:%h [dump_line]%s"},
instance,index,
valid7,tag7,valid6,tag6,valid5,tag5,valid4,tag4,why));
}
}
#ifdef TAG_DEBUG
PR_INFO(name, MON_INFO,
psprintf({"C%0d tag_mem[%2h] ",
"w3-w0 V:T %b:%h %b:%h %b:%h %b:%h (adr) [dump_line]%s"},
instance,index,
valid3,tag3>>1,valid2,tag2>>1,valid1,tag1>>1,valid0,tag0>>1,why));
if (type!=DATA_TAG) {
PR_INFO(name, MON_INFO,
psprintf({"C%0d tag_mem[%2h] ",
"w7-w4 V:T %b:%h %b:%h %b:%h %b:%h (adr) [dump_line]%s"},
instance,index,
valid7,tag7>>1,valid6,tag6>>1,valid5,tag5>>1,valid4,tag4>>1,why));
}
#endif
}
//----------------------------------------------------------
// Print lines in a group (cache line).
// Itag - 2 lines
// Dtag - 4 lines
// index must be normalized between 0..31
task dump_group (string why, reg [5:0] index) {
if (type==DATA_TAG) {
dump_line(why, (index*4+0), MON_INFO);
dump_line(why, (index*4+1), MON_INFO);
dump_line(why, (index*4+2), MON_INFO);
dump_line(why, (index*4+3), MON_INFO);
} else {
dump_line(why, (index*2+0), MON_INFO);
dump_line(why, (index*2+1), MON_INFO);
}
}
//----------------------------------------------------------
task write_tag (reg [2:0] way,
reg [6:0] index,
reg [28:0] tag,
reg valid,
reg hitCheck=0) {
reg [239:0] old_line;
reg [239:0] new_line;
integer i,count;
reg [39:0] pa;
error_check(way,index);
// Read/Modify/Write
old_line = tag_mem[index];
new_line = old_line;
#ifdef TAG_DEBUG
if (valid) {
#endif
case (way) {
0: new_line [ 29: 0] = {valid,tag};
1: new_line [ 59: 30] = {valid,tag};
2: new_line [ 89: 60] = {valid,tag};
3: new_line [119: 90] = {valid,tag};
4: new_line [149:120] = {valid,tag};
5: new_line [179:150] = {valid,tag};
6: new_line [209:180] = {valid,tag};
7: new_line [239:210] = {valid,tag};
}
#ifdef TAG_DEBUG
} else {
case (way) {
0: new_line [ 29] = valid;
1: new_line [ 59] = valid;
2: new_line [ 89] = valid;
3: new_line [119] = valid;
4: new_line [149] = valid;
5: new_line [179] = valid;
6: new_line [209] = valid;
7: new_line [239] = valid;
}
}
#endif
pa = get_pa(tag,index);
// is the L1 allocating when it doesn't need to? L1 should have hit!
if (old_line == new_line && hitCheck) {
printf("\n");
dump_line ("write: Old ",index,MON_NORMAL);
PR_ERROR(name, MON_ERR,
psprintf ("C%0d L1 should have hit! index=%h tag=%h PA[39:0]=%h",instance,index,tag,pa));
printf("\n");
}
if (gDbg.info) dump_line ("write_tag: Old ",index,MON_INFO);
tag_mem[index] = new_line;
if (gDbg.info) dump_line ("write_tag: New ",index,MON_INFO);
// check if Multiple hits in tag line that was just written
count = 0;
for (i=0;i<8;i++) if (new_line[30*i+29:30*i] == {1'b1,tag}) count++;
if (count > 1) {
printf("\n");
dump_line ("Multiple hits in line",index,MON_NORMAL);
PR_ERROR(name, MON_ERR,
psprintf ("C%0d Multiple hits in tag table for a single line! PA[39:0]=%h",
instance,pa));
printf("\n");
dump_mem(MON_NORMAL);
}
PR_INFO(name, MON_INFO,
psprintf({"C%0d tag_mem[%0h] tag=0x%h way=0x%h PA[39:0]=0x%h [write_tag]"},
instance,index,tag,way,pa));
#ifdef TAG_DEBUG
dump_mem(MON_INFO);
#endif
}
//----------------------------------------------------------
// Read tag line and return way if tag hit
// way[3:0] is in the format required for the inval.vector in Vack field of CPX pkt
function reg [3:0] get_way ( string why,
reg [6:0] index,
reg [28:0] tag ) {
reg [239:0] line;
reg [28:0] tag0,tag1,tag2,tag3,tag4,tag5,tag6,tag7;
reg valid0,valid1,valid2,valid3,valid4,valid5,valid6,valid7;
reg hit0,hit1,hit2,hit3,hit4,hit5,hit6,hit7;
reg hit;
reg [39:0] pa;
if ((type==INSTR_TAG)&&(index>63)) {
PR_ERROR(name, MON_ERR,
psprintf ("C%0d index=%0d. It cannot be >63 for I_tag table.",instance,index));
}
pa = get_pa(tag,index);
read_line (index,
tag0,tag1,tag2,tag3,
tag4,tag5,tag6,tag7,
valid0,valid1,valid2,valid3,
valid4,valid5,valid6,valid7);
hit0 = {tag,1'b1}=={tag0,valid0};
hit1 = {tag,1'b1}=={tag1,valid1};
hit2 = {tag,1'b1}=={tag2,valid2};
hit3 = {tag,1'b1}=={tag3,valid3};
hit4 = {tag,1'b1}=={tag4,valid4};
hit5 = {tag,1'b1}=={tag5,valid5};
hit6 = {tag,1'b1}=={tag6,valid6};
hit7 = {tag,1'b1}=={tag7,valid7};
hit = (hit0 | hit1 | hit2 | hit3 | hit4 | hit5 | hit6 | hit7);
if (type==DATA_TAG) {
case ({hit7,hit6,hit5,hit4,hit3,hit2,hit1,hit0}) {
8'b00000000: get_way = 4'b0000; // n/a, bittom 2 always 10 if hit
8'b00000001: get_way = 4'b0010; // 0
8'b00000010: get_way = 4'b0110; // 1
8'b00000100: get_way = 4'b1010; // 2
8'b00001000: get_way = 4'b1110; // 3
8'b00010000,
8'b00100000,
8'b01000000,
8'b10000000: {printf("\n");
dump_line (why,index,MON_NORMAL);
PR_NORMAL(name, MON_NORMAL,
psprintf({"C%0d hit[7:0] = %b index = %h tag = %h "},
instance,{hit7,hit6,hit5,hit4,hit3,hit2,hit1,hit0},index,tag));
PR_ERROR(name, MON_ERR,
psprintf ("C%0d Out of range hit in D$ tag table. One of the bits (7:4) is 1 and shouldn't be. ",instance));
}
default : {printf("\n");
dump_line ("Multiple hits in line",index,MON_NORMAL);
PR_NORMAL(name, MON_NORMAL,
psprintf({"C%0d hit[7:0] = %b index = %h tag = %h "},
instance,{hit7,hit6,hit5,hit4,hit3,hit2,hit1,hit0},index,tag));
PR_ERROR(name, MON_ERR,
psprintf ("C%0d Multiple hits in tag table for a single line! PA[39:0]=%h",
instance, pa));
printf("\n");
dump_mem(MON_NORMAL);
}
}
} else {
case ({hit7,hit6,hit5,hit4,hit3,hit2,hit1,hit0}) {
8'b00000000: get_way = 4'b0000; // N/A, bottom bit always 1 is hit
8'b00000001: get_way = 4'b0001; // 0
8'b00000010: get_way = 4'b0011; // 1
8'b00000100: get_way = 4'b0101;
8'b00001000: get_way = 4'b0111;
8'b00010000: get_way = 4'b1001;
8'b00100000: get_way = 4'b1011;
8'b01000000: get_way = 4'b1101;
8'b10000000: get_way = 4'b1111; // 7
default : {printf("\n");
dump_line ("Multiple hits in line",index,MON_NORMAL);
PR_NORMAL(name, MON_NORMAL,
psprintf({"C%0d hit[7:0] = %b index = %h tag = %h "},
instance,{hit7,hit6,hit5,hit4,hit3,hit2,hit1,hit0},index,tag));
PR_ERROR(name, MON_ERR,
psprintf ("C%0d Multiple hits in tag table for a single line! PA[39:0]=%h",
instance, pa));
printf("\n");
dump_mem(MON_NORMAL);
}
}
}
if (gDbg.info) dump_line (why,index,MON_INFO);
PR_INFO(name, MON_INFO,
psprintf({"C%0d way[3:0]=%b hit[7:0]=%b index=%0h tag=%h pa=%h [get_way]%s"},
instance,get_way,{hit7,hit6,hit5,hit4,hit3,hit2,hit1,hit0},index,tag,pa,why));
}
//----------------------------------------------------------
// Return index that points to the line with a valid entry
task search_tagmem (var reg valid, var reg [6:0] index) {
integer cnt;
cnt = 0;
index = random() % (max_line+1);
valid = 0;
while ((cnt<=max_line)&&!valid) {
if (index==max_line) {
index = 0;
} else {
index = index + 1;
}
valid = line_valid (index);
PR_DEBUG (name, MON_DEBUG,
psprintf("C%0d count = %0h index = %0h valid = %0b ",instance,cnt,index,valid));
cnt = cnt + 1;
}
if (!valid) {
PR_INFO (name, MON_INFO,
psprintf("C%0d No valid entry found in tag table. [search_tagmem]",instance));
} else {
PR_INFO (name, MON_INFO,
psprintf("C%0d Valid entry found in tag table at index = %0h valid = %b [search_tagmem]",instance,index,valid));
}
}
//----------------------------------------------------------
// Search line and return tag on any valid entry
// Return 0's if no valid entry found
task get_tag (reg [6:0] index, var reg valid, var reg [28:0] tag) {
reg [28:0] tag0,tag1,tag2,tag3,tag4,tag5,tag6,tag7;
reg valid0,valid1,valid2,valid3,valid4,valid5,valid6,valid7;
valid = 1'b0;
read_line (index,
tag0,tag1,tag2,tag3,
tag4,tag5,tag6,tag7,
valid0,valid1,valid2,valid3,
valid4,valid5,valid6,valid7);
casex ({valid7,valid6,valid5,valid4,valid3,valid2,valid1,valid0}) {
8'bxxxxxxx1: { tag = tag0; valid = 1'b1;}
8'bxxxxxx10: { tag = tag1; valid = 1'b1;}
8'bxxxxx100: { tag = tag2; valid = 1'b1;}
8'bxxxx1000: { tag = tag3; valid = 1'b1;}
8'bxxx10000: { tag = tag4; valid = 1'b1;}
8'bxx100000: { tag = tag5; valid = 1'b1;}
8'bx1000000: { tag = tag6; valid = 1'b1;}
8'b10000000: { tag = tag7; valid = 1'b1;}
8'b00000000: { tag = 29'b0; valid = 1'b0;}
default: PR_ERROR(name, MON_ERR,
psprintf ("C%0d BENCH Problem: get_tag should not hit case default.",instance));
}
}
//----------------------------------------------------------
// Read line and return individual fields in the line
task read_line (reg [6:0] index,
var reg [28:0] tag0,
var reg [28:0] tag1,
var reg [28:0] tag2,
var reg [28:0] tag3,
var reg [28:0] tag4,
var reg [28:0] tag5,
var reg [28:0] tag6,
var reg [28:0] tag7,
var reg valid0,
var reg valid1,
var reg valid2,
var reg valid3,
var reg valid4,
var reg valid5,
var reg valid6,
var reg valid7
) {
reg [239:0] line;
line = tag_mem [index];
tag0 = line [ 28: 0];
tag1 = line [ 58: 30];
tag2 = line [ 88: 60];
tag3 = line [118: 90];
tag4 = line [148:120];
tag5 = line [178:150];
tag6 = line [208:180];
tag7 = line [238:210];
valid0 = line [ 29];
valid1 = line [ 59];
valid2 = line [ 89];
valid3 = line [119];
valid4 = line [149];
valid5 = line [179];
valid6 = line [209];
valid7 = line [239];
}
//----------------------------------------------------------
// Use this function to calculate the pa from the tag & index
function reg [39:0] get_pa (reg [28:0] tag, reg [6:0] index) {
if (type==DATA_TAG) {
get_pa = {tag,index[6:0],4'h0};
} else {
get_pa = {tag,index[5:0],5'h0};
}
}
//----------------------------------------------------------
function reg line_valid (reg [6:0] index) {
reg [28:0] tag0,tag1,tag2,tag3,tag4,tag5,tag6,tag7;
reg valid0,valid1,valid2,valid3,valid4,valid5,valid6,valid7;
read_line (index,
tag0,tag1,tag2,tag3,
tag4,tag5,tag6,tag7,
valid0,valid1,valid2,valid3,
valid4,valid5,valid6,valid7);
line_valid = valid0 | valid1 | valid2 | valid3 |
valid4 | valid5 | valid6 | valid7;
}
//----------------------------------------------------------
task error_check (reg [2:0] way,
reg [6:0] index) {
if ((type==DATA_TAG)&&(way>3)) {
PR_ERROR(name, MON_ERR,
psprintf ("C%0d way=%0d. It cannot be >3 for D_tag table.",instance,way));
}
if ((type==INSTR_TAG)&&(index>63)) {
PR_ERROR(name, MON_ERR,
psprintf ("C%0d index=%0d. It cannot be >63 for I_tag table.",instance,index));
}
}
//----------------------------------------------------------
// Create 32 or 24 bit invalidation vector to be used in response data field
// Can be used for Vack or Vinv in CPX packets
task create_vector (reg format,
reg [3:0] way,
var reg [31:0] vect) {
vect = 32'b0;
if (format==WAY_3BIT) {
case (instance) {
0: vect[ 2: 0] = way[3:1];
1: vect[ 5: 3] = way[3:1];
2: vect[ 8: 6] = way[3:1];
3: vect[11: 9] = way[3:1];
4: vect[14:12] = way[3:1];
5: vect[17:15] = way[3:1];
6: vect[20:18] = way[3:1];
7: vect[23:21] = way[3:1];
}
} else {
case (instance) {
0: vect[ 3: 0] = way;
1: vect[ 7: 4] = way;
2: vect[11: 8] = way;
3: vect[15:12] = way;
4: vect[19:16] = way;
5: vect[23:20] = way;
6: vect[27:24] = way;
7: vect[31:28] = way;
}
}
}
//----------------------------------------------------------
// Index is normalized to be 0..31 (pointer to L2 cache line - top of group)
task evict_group (reg [28:0] evict_tag,
reg [4:0] evict_index,
var reg [111:0] inv_vect) {
reg [6:0] index [4];
reg [3:0] way [4];
reg [3:0] tmp_way;
reg [31:0] vect0,vect1,vect2,vect3;
integer i;
dump_group("Before Evict",evict_index);
//--------------------
// Default values
vect0 = 32'b0;
vect1 = 32'b0;
vect2 = 32'b0;
vect3 = 32'b0;
inv_vect = 112'b0;
for (i=0; i<=3; i=i+1) {
index[i] = 5'b0;
way[i] = 4'b0;
}
//--------------------
// dtag
if (type==DATA_TAG) {
//--------------------
// Setup Indexes for the group of lines that we are going to evict
index[0] = (evict_index * 4);
index[1] = (evict_index * 4) + 1;
index[2] = (evict_index * 4) + 2;
index[3] = (evict_index * 4) + 3;
//--------------------
// Repeat get_way for all lines in the L2 cache line
// Get the way for the tag (even if no valid entry)
// since it is returned in inval vector
for (i=0; i<=3; i=i+1) {
way[i] = get_way ("Get_evict",index[i],evict_tag);
}
//--------------------
// Invalidate the entries in the eviction group
// (for the lines that had a valid entry)
for (i=0; i<=3; i=i+1) {
tmp_way = way[i];
if (tmp_way!=4'b0) {
tmp_way = {2'b0,tmp_way[3:2]};
write_tag (tmp_way[2:0],index[i],29'b0,TAG_INVAL);
}
}
create_vector (WAY_4BIT, way[0], vect0);
create_vector (WAY_3BIT, way[1], vect1);
create_vector (WAY_4BIT, way[2], vect2);
create_vector (WAY_3BIT, way[3], vect3);
//--------------------
// itag
} else {
//--------------------
// Setup Indexes for the group of lines that we are going to evict
index[0] = (evict_index * 2);
index[1] = (evict_index * 2) + 1;
//--------------------
// Repeat get_way for all lines in the L2 cache line
// Get the way for the tag (even if no valid entry)
// since it is returned in inval vector
for (i=0; i<=1; i=i+1) {
way[i] = get_way ("Get_evict",index[i],evict_tag);
}
// Invalidate the entries in the eviction group
// (for the lines that had a valid entry)
for (i=0; i<=1; i=i+1) {
tmp_way = way[i];
if (tmp_way!=4'b0) {
tmp_way = {1'b0,tmp_way[3:1]};
write_tag (tmp_way[2:0],index[i],29'b0,TAG_INVAL);
}
}
create_vector (WAY_4BIT, way[0], vect0);
vect1 = 32'b0;
create_vector (WAY_4BIT, way[1], vect2);
vect3 = 32'b0;
}
inv_vect = {vect3[23:0],vect2,vect1[23:0],vect0};
dump_group("After Evict",evict_index);
}
//----------------------------------------------------------
} // end class CCX_REQ
//----------------------------------------------------------
// END OF FILE
//----------------------------------------------------------
Full OpenSPARC design & verification tarball including full HDL.