![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to common.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / dmp4|
Return to common.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / dmp4 |
1.1 root 1:
2: #include "dmp_defs.h"
3:
4: /***********************************************************************
5: *
6: * COMMON ROUTINES FOR THE DEMAND PAGING TESTS
7: *
8: ***********************************************************************/
9:
10:
11:
12: /************************************************************************
13: * print a demand paging test error message
14: *
15: * The message will be of the form:
16: * cycle: xx. DMP test xx. <inst>. <error message>
17: * instruction cache {hit/miss}, data index = xx, page faults on byte(s) 0, x
18: * addressing mode: <addressing mode description>
19: * { pipeline test #x. <instruction buffer description> }
20: * inst buf = xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx
21: ************************************************************************/
22: prt_dmp_er_msg( msg )
23: char *msg;
24: {
25: int page_byte;
26: if( !error ) { /* 1st err. for this inst? */
27: error++; /* set current error flg */
28: writec('\n'); /* start a new line */
29: }
30: writes("\ncycle: ");
31: writed( cycle ); /* print the cycle # */
32: writes(". DMP test ");
33: writeh( test_no ); /* print the test # */
34: writes(". ");
35: writes( op_name ); /* print the inst name */
36: writes( msg ); /* print the error msg */
37: writes("\ninstruction cache ");
38: if( i_cache_hit )
39: writes("hit");
40: else
41: writes("miss");
42: writes(", data index = "); /* print the data index */
43: writed( index );
44: writes(", page faults on inst. byte(s) 0");
45: page_byte = 20 - shift_count; /* get byte w/ page break */
46: if( page_byte ) {
47: writes(", ");
48: writed( page_byte );
49: }
50: writec('\n');
51: if( no_ops ) { /* print the addressing mode */
52: writes("addressing mode: ");
53: writes( addressing_modes[ addr_mode ] );
54: writec('\n');
55: }
56: if( pipe_test ) {
57: writes("pipeline test #");
58: writed( pipe_test ); /* print the pipe test # */
59: writes(". ");
60: if( pipe_inst1 == LDD_OP_CODE )
61: writes("LDD (initial acc), ");
62: else if( pipe_inst1 == LDF_OP_CODE )
63: writes("LDF (initial acc), ");
64: else if( pipe_inst1 == MULD_OP_CODE )
65: writes("MULD (1.0), ");
66: else if( pipe_inst1 == MULF_OP_CODE )
67: writes("MULF (1.0), ");
68: writes( op_name );
69: if( !(no_ops) )
70: writes(", ");
71: else if( no_ops == 1 )
72: writes(" (operand), ");
73: else if( no_ops == 2 )
74: writes(" (op #1, op #2), ");
75: if( pipe_inst2 == MULD_OP_CODE )
76: writes("MULD (1.0)\n");
77: else
78: writes("MULF (1.0)\n");
79: }
80: print_inst_buf(); /* print the inst buf contents */
81: }
82:
83:
84:
85: /********************************************************************
86: * print the contents of the instruction buffer
87: * inst buf = xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx
88: ********************************************************************/
89: print_inst_buf()
90: {
91: int page_byte;
92: writes("inst buf =");
93: write_lw_bytes( inst_buf[0] ); /* print word 0 as bytes */
94: write_lw_bytes( inst_buf[1] ); /* print word 1 as bytes */
95: write_lw_bytes( inst_buf[2] ); /* print word 2 as bytes */
96: write_lw_bytes( inst_buf[3] ); /* print word 3 as bytes */
97: write_lw_bytes( inst_buf[4] ); /* print word 4 as bytes */
98: writec('\n');
99: }
100:
101:
102:
103:
104: /********************************************************************
105: * print a longword a byte at a time
106: ********************************************************************/
107: write_lw_bytes( lw )
108: int lw;
109: {
110: writec(' ');
111: writeh( (lw >> 28) & 0xf );
112: writeh( (lw >> 24) & 0xf );
113: writec(' ');
114: writeh( (lw >> 20) & 0xf );
115: writeh( (lw >> 16) & 0xf );
116: writec(' ');
117: writeh( (lw >> 12) & 0xf );
118: writeh( (lw >> 8) & 0xf );
119: writec(' ');
120: writeh( (lw >> 4) & 0xf );
121: writeh( (lw & 0xf) );
122: }
123:
124:
125:
126: /********************************************************************
127: * print the information for a bad register fault
128: ********************************************************************/
129: prt_reg_data()
130: {
131: writes(" register ");
132: writed( reg_no );
133: writes(" = ");
134: write32h( store_regs[ reg_no ] );
135: writes(", should be = ");
136: write32h( exp_regs[ reg_no ] );
137: writec('\n');
138: }
139:
140:
141:
142: /*
143: ***********************************************************************
144: * fill a register buffer with known patterns
145: ***********************************************************************
146: */
147: fill_reg_buf( buffer )
148: int *buffer;
149: {
150: buffer[0] = 0x10101010; /* register '0' data */
151: buffer[1] = 0x11111111;
152: buffer[2] = 0x12121212;
153: buffer[3] = 0x13131313;
154: buffer[4] = 0x14141414;
155: buffer[5] = 0x15151515;
156: buffer[6] = 0x16161616;
157: buffer[7] = 0x17171717;
158: buffer[8] = 0x18181818;
159: buffer[9] = 0x19191919;
160: buffer[10] = 0x1a1a1a1a;
161: buffer[11] = 0x1b1b1b1b;
162: buffer[12] = 0x1c1c1c1c;
163: buffer[13] = 0x1d1d1d1d;
164: }
165:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.