![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cosf.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 / macro4|
Return to cosf.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
1.1 root 1: #include "fpp_defs.h"
2:
3:
4:
5: /***************************************************************************
6: *
7: * COSF - SINGLE PRECISION FLOATING POINT COSF FUNCTION TEST
8: *
9: * COSF TEST MONITOR
10: *
11: *****************************************************************************/
12: cosf()
13: {
14: asm(".globl _cosf_t");
15: asm("_cosf_t:"); /* entry address */
16: if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
17: {
18: writes(" COSF");
19: }
20: cosf_1(); /* test square root w/ delay */
21: cosf_2(); /* test square root */
22: cosf_3(); /* register corruption */
23: /* cosf_4(); /* test the PSL */
24: cosf_5(); /* pipelined entry */
25: cosf_6(); /* pipelined exit */
26: asm("jmp *return"); /* return to the test monitor */
27: }
28:
29: /***************************************************************************
30: *
31: * SUBTEST 1 - COSF FUNCTION
32: *
33: ***************************************************************************/
34: cosf_1()
35: {
36: #define DELAY 20 /* wait 40 ticks between COSF and STF */
37: force_loop = FALSE; /* clear the LOOP flag */
38: subtest = 1;
39: index = 0;
40: do
41: {
42: sgl_ld_acc = cosf_1_data[index].ld; /* get the operand */
43: sgl_expected = cosf_1_data[index].exp; /* get expected results */
44: sgl_dummy1 = DELAY;
45: /*
46: * If LOOP ON ERROR is set, this is the loop for this subtest.
47: * The force loop flag is set after the first error.
48: */
49: asm("_cosf_1_lp1:");
50: asm("movl _sgl_ld_acc,r4"); /* set the data to load */
51: asm("ldf r4"); /* load the accumulator */
52: asm("movl _sgl_dummy1,r0"); /* get the delay factor */
53: asm("cosf"); /* get ACC.'s cosine */
54: asm("1:");
55: asm("decl r0"); /* delay to let the COSF */
56: asm("bgtr 1b"); /* instruction finish */
57: asm("stf r5"); /* store the result */
58: if( force_loop )
59: asm("brb _cosf_1_lp1");; /* loop on the error */
60: /*
61: * end error loop
62: */
63: asm("movl r5,_sgl_st_acc"); /* save the result */
64: if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
65: {
66: errcnt++; /* bump the error count */
67: if ( prt_error ) {
68: writes(" \n"); /* start a new print line */
69: writes("cycle: ");
70: writed( cycle );
71: writes(" COSF test ");
72: writed( test_no );
73: writes(", subtest 1 (delayed store) - BAD FINAL ACC\n");
74: print_cosf_data();
75: writes(", data index = ");
76: writed( index );
77: writec('\n');
78: writes(" Acc expected = ");
79: write32h( sgl_expected );
80: writec('\n');
81: }
82: if ( halt_flg ) /* halt on error? */
83: cosf_er_halt( BAD_ACC_HLT );
84: if ( loop_on_err )
85: {
86: force_loop = TRUE; /* set the force loop flag */
87: asm("jmp _cosf_1_lp1"); /* and loop */
88: }
89: } /* end of compare error */
90: } while( index++ < max_cosf_1_index );
91: } /* end of subtest 1 */
92:
93:
94:
95: /***************************************************************************
96: *
97: * SUBTEST 2 - COSF FUNCTION
98: *
99: ***************************************************************************/
100: cosf_2()
101: {
102: force_loop = FALSE; /* clear the LOOP flag */
103: subtest = 2;
104: index = 0;
105: do
106: {
107: sgl_ld_acc = cosf_1_data[index].ld; /* get the operand */
108: sgl_expected = cosf_1_data[index].exp; /* get expected results */
109: /*
110: * If LOOP ON ERROR is set, this is the loop for this subtest.
111: * The force loop flag is set after the first error.
112: */
113: asm("_cosf_2_lp1:");
114: asm("movl _sgl_ld_acc,r4"); /* set the data to load */
115: asm("ldf r4"); /* load the accumulator */
116: asm("cosf"); /* get ACC.'s cosine */
117: asm("stf r5"); /* store the result */
118: if( force_loop )
119: asm("brb _cosf_2_lp1");; /* loop on the error */
120: /*
121: * end error loop
122: */
123: asm("movl r5,_sgl_st_acc"); /* save the result */
124: if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
125: {
126: errcnt++; /* bump the error count */
127: if ( prt_error ) {
128: writes(" \n"); /* start a new print line */
129: writes("cycle: ");
130: writed( cycle );
131: writes(" COSF test ");
132: writed( test_no );
133: writes(", subtest 2 (immediate store) - BAD FINAL ACC\n");
134: print_cosf_data();
135: writes(", data index = ");
136: writed( index );
137: writec('\n');
138: writes(" Acc expected = ");
139: write32h( sgl_expected );
140: writec('\n');
141: }
142: if ( halt_flg ) /* halt on error? */
143: cosf_er_halt( BAD_ACC_HLT );
144: if ( loop_on_err )
145: {
146: force_loop = TRUE; /* set the force loop flag */
147: asm("jmp _cosf_2_lp1"); /* and loop */
148: }
149: } /* end of compare error */
150: } while( index++ < max_cosf_1_index );
151: } /* end of subtest 2 */
152:
153:
154:
155: /***************************************************************************
156: *
157: * SUBTEST 3 - REGISTER INTEGRITY WITH THE COSF FUNCTION
158: *
159: ***************************************************************************/
160: cosf_3()
161: {
162: fill_reg_buf( load_regs ); /* set reg values to load */
163: force_loop = FALSE; /* clear the LOOP flag */
164: subtest = 3;
165: index = 0;
166: do
167: {
168: sgl_ld_acc = cosf_1_data[index].ld; /* get the operand */
169: sgl_expected = cosf_1_data[index].exp; /* get expected results */
170: /*
171: * If LOOP ON ERROR is set, this is the loop for this subtest.
172: * The force loop flag is set after the first error.
173: */
174: asm("_cosf_3_lp1:");
175: asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
176: asm("ldf _sgl_ld_acc"); /* load the accumulator */
177: asm("cosf"); /* get ACC.'s cosf */
178: asm("stf _sgl_st_acc"); /* store the result */
179: asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
180: if( force_loop )
181: asm("brb _cosf_3_lp1");; /* loop on the error */
182: /*
183: * end error loop
184: */
185: reg_no = 0;
186: regs_ok = TRUE;
187: while( (reg_no < 13) && (regs_ok) ) /* check 1st 12 regs */
188: if( store_regs[ reg_no ] == load_regs[ reg_no ] )
189: reg_no++;
190: else
191: regs_ok = FALSE;
192: if( !regs_ok )
193: {
194: errcnt++; /* bump the error count */
195: if ( prt_error ) {
196: writes(" \n"); /* start a new print line */
197: writes("cycle: ");
198: writed( cycle );
199: writes(" COSF test ");
200: writed( test_no );
201: writes(", subtest 3 - A REGISTER WAS MODIFIED\n"); {
202: print_cosf_data();
203: writec('\n');
204: writes("register ");
205: writed( reg_no );
206: writes(" = ");
207: write32h( load_regs[reg_no] );
208: writes(", should be = ");
209: write32h( store_regs[reg_no] );
210: writec('\n');
211: }
212: if ( halt_flg ) /* halt on error? */
213: cosf_er_halt( BAD_REG_HLT );
214: if ( loop_on_err )
215: {
216: force_loop = TRUE; /* get the force loop flag */
217: asm("jmp _cosf_3_lp1"); /* and loop */
218: }
219: } /* end of compare error */
220: } /* end of while loop */
221: } while( index++ < max_cosf_1_index );
222: } /* end of subtest 3 */
223:
224:
225:
226: /************************************************************************
227: *
228: * SUBTEST 4 - Check for PSL corruption
229: *
230: ************************************************************************/
231: cosf_4()
232: {
233: force_loop = FALSE; /* clear force_loop flg */
234: subtest = 4;
235: fill_reg_buf( load_regs ); /* get patterns for regs */
236: for( index = 0; index < 3; index++ ) {
237: sgl_ld_acc = cosf_1_data[index].ld; /* get operand 1 */
238: sgl_expected = cosf_1_data[index].exp; /* get expected */
239: sgl_dummy1 = status_array[index]; /* status = +, -, 0 */
240: /*
241: * If LOOP ON ERROR is set, this is the loop for this subtest.
242: * The force loop flag is set after the first error.
243: */
244: asm("_cosf_4_lp1:");
245: asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */
246: asm("nop");
247: asm("tstl _sgl_dummy1"); /* set the PSL status */
248: asm("movpsl _init_psl"); /* save the initial PSL */
249: asm("cosf"); /* do the cosf */
250: asm("nop");
251: asm("movpsl _psl_val"); /* save the final PSL */
252: asm("stf _sgl_st_acc"); /* save the accumulator */
253: if( force_loop )
254: asm("brb _cosf_4_lp1");; /* loop on the error */
255: /*
256: * Now compare the final PSL to the initial PSL -they should be the same
257: */
258: exp_psl = init_psl;
259: if( psl_val != exp_psl ) {
260: errcnt++; /* bump the error count */
261: if( prt_error ) {
262: writes(" \n"); /* start a new print line */
263: writes("cycle: ");
264: writed( cycle );
265: writes(" COSF test ");
266: writed( test_no );
267: writes(", subtest 4 - INCORRECT FINAL PSL\n");
268: print_cosf_data(); /* print the operands */
269: writec('\n');
270: writes("initial PSL = ");
271: write32h( init_psl );
272: writes(", final PSL = ");
273: write32h( psl_val );
274: writes(", expected PSL = ");
275: write32h( exp_psl );
276: writes("\n");
277: }
278: if( halt_flg )
279: cosf_er_halt( BAD_PSL_HLT ); /* halt on the error */
280: if( loop_on_err ) {
281: force_loop = TRUE; /* set the force loop flag */
282: asm("brw _cosf_4_lp1");; /* and loop on the error */
283: } /* end of loop on error */
284: } /* end of PSL corruption error */
285: } /* end of WHILE loop */
286: } /* end of subtest 4 */
287:
288:
289:
290: /************************************************************************
291: *
292: * SUBTEST 5 - pipelined entry test
293: *
294: ************************************************************************/
295: cosf_5()
296: {
297: force_loop = FALSE;
298: subtest = 8;
299: for( index = 0; index < max_cosf_1_index; index++ ) {
300: sgl_ld_acc = cosf_1_data[index].ld; /* get operand 1 */
301: sgl_expected = cosf_1_data[index].exp; /* get expected result */
302: /*
303: * If LOOP ON ERROR is set, this is the loop for this subtest.
304: * The force loop flag is set after the first error.
305: */
306: asm("_cosf_5_lp1:");
307: asm("movl $0,r0"); /* clear r0 */
308: asm("ldf r0"); /* load the Acc. with 0.0 */
309: asm("addf _sgl_ld_acc"); /* add the 1st operand */
310: asm("cosf"); /* get the cosf */
311: asm("stf _sgl_st_acc"); /* store the result */
312: if( force_loop )
313: asm("brb _cosf_5_lp1");; /* loop on the error */
314: /*
315: * end error loop - test the results
316: */
317: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
318: errcnt++; /* bump the error count */
319: if( prt_error ) {
320: writes(" \n"); /* start a new print line */
321: writes("cycle: ");
322: writed( cycle );
323: writes(" COSF test ");
324: writed( test_no );
325: writes(", subtest 5 (Piped Entry) - BAD FINAL ACC\n");
326: print_cosf_data();
327: writes(", data index = ");
328: writed( index );
329: writec('\n');
330: writes(" Acc expected = ");
331: write32h( sgl_expected );
332: writec('\n');
333: }
334: if( halt_flg )
335: cosf_er_halt( BAD_ACC_HLT ); /* halt on the error */
336: if( loop_on_err ) {
337: force_loop = TRUE; /* set the force loop flag */
338: asm("brw _cosf_5_lp1");; /* and loop on the error */
339: } /* end of loop on error */
340: } /* end of compare error */
341: } /* end of WHILE loop */
342: } /* end of subtest 5 */
343:
344:
345:
346: /************************************************************************
347: *
348: * SUBTEST 6 - pipelined exit test
349: *
350: ************************************************************************/
351: cosf_6()
352: {
353: force_loop = FALSE;
354: subtest = 8;
355: for( index = 0; index < max_cosf_1_index; index++ ) {
356: sgl_ld_acc = cosf_1_data[index].ld; /* get operand 1 */
357: sgl_expected = cosf_1_data[index].exp; /* get expected result */
358: /*
359: * If LOOP ON ERROR is set, this is the loop for this subtest.
360: * The force loop flag is set after the first error.
361: */
362: asm("_cosf_6_lp1:");
363: asm("movl $0,r0"); /* clear r0 */
364: asm("ldf _sgl_ld_acc"); /* load the Acc. */
365: asm("cosf"); /* get the cosf */
366: asm("addf r0"); /* add a zero to the acc */
367: asm("stf _sgl_st_acc"); /* store the result */
368: if( force_loop )
369: asm("brb _cosf_6_lp1");; /* loop on the error */
370: /*
371: * end error loop - test the results
372: */
373: if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
374: errcnt++; /* bump the error count */
375: if( prt_error ) {
376: writes(" \n"); /* start a new print line */
377: writes("cycle: ");
378: writed( cycle );
379: writes(" COSF test ");
380: writed( test_no );
381: writes(", subtest 6 (Piped Exit) - BAD FINAL ACC\n");
382: print_cosf_data();
383: writes(", data index = ");
384: writed( index );
385: writec('\n');
386: writes(" Acc expected = ");
387: write32h( sgl_expected );
388: writec('\n');
389: }
390: if( halt_flg )
391: cosf_er_halt( BAD_ACC_HLT ); /* halt on the error */
392: if( loop_on_err ) {
393: force_loop = TRUE; /* set the force loop flag */
394: asm("brw _cosf_6_lp1");; /* and loop on the error */
395: } /* end of loop on error */
396: } /* end of compare error */
397: } /* end of WHILE loop */
398: } /* end of subtest 6 */
399:
400:
401: /**************************************************************************
402: *
403: * PRINT THE DATA AND STORE RESULTS
404: *
405: * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx
406: * Acc expected = xxxxxxxx
407: **************************************************************************/
408: print_cosf_data()
409: {
410: writes("initial Acc = ");
411: write32h( sgl_ld_acc );
412: writes(", final Acc = ");
413: write32h( sgl_st_acc );
414: }
415:
416:
417:
418: /**************************************************************************
419: *
420: * HALT ON ERROR ROUTINE
421: *
422: **************************************************************************/
423: cosf_er_halt( halt_code )
424: int halt_code;
425: {
426: sgl_dummy1 = halt_code; /* get the error type */
427: asm("movl _test_no,r0"); /* r0 = test number */
428: asm("movl _subtest,r1"); /* r1 = subtest number */
429: asm("movl _sgl_dummy1,r2"); /* r2 = error code */
430: asm("movl _cycle,r3"); /* r3 = cycle count */
431: asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */
432: asm("movl _sgl_st_acc,r5"); /* r5 = data stored */
433: asm("movl _sgl_expected,r6"); /* r6 = data expected */
434: asm("movl _index,r7"); /* r7 = data index */
435: if( halt_code == BAD_REG_HLT ) {
436: sgl_dummy1 = load_regs[index2];
437: sgl_dummy2 = store_regs[index2];
438: asm("movl _index2,r6"); /* r6 = bad register # */
439: asm("movl _sgl_dummy2,r7"); /* r7 = actual value */
440: asm("movl _sgl_dummy1,r8"); /* r8 = expected value */
441: } else
442: if( halt_code == BAD_PSL_HLT ) {
443: asm("movl _init_psl,r6"); /* r6 = initial PSL */
444: asm("movl _psl_val,r7"); /* r7 = final PSL */
445: asm("movl _exp_psl,r8"); /* r8 = expected PSL */
446: };
447: asm("halt"); /* HALT ... */
448: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.