ER[DGALU];	*RANDOM NUMBER TEST OF P, Q, AND ALU

%TO ASSEMBLE:	MICRO/L LANG DGALU -OR- MICRO/L LANG2 DGALU
TO RUN:		MIDAS RDGALU
		START;G
CURRENT SOURCES ON TENEX <ERF> DIRECTORY.
%

SM[SY10,10];
SM[SLC,0]; TARGET[SLC];	*CONSTANTS FOR P-REGISTER MASK SIMULATION
0V;		1V;		3V;		7V;
17V;		37V;		77V;		177V;
377V;		777V;		1777V;		3777V;
7777V;		17777V;		37777V;		77777V;
177777V;	377777V;	777777V;	1 777777V;
3 777777V;	7 777777V;	17 777777V;	37 777777V;
77 777777V;	177 777777V;	377 777777V;	777 777777V;
1777 777777V;	3777 777777V;	7777 777777V;	17777 777777V;
37777 777777V;	77777 777777V;	177777 777777V;	377777 777777V;
777777 777777V;	777777 777777V;	777777 777777V;	777777 777777V;
777777 777777V;	777777 777777V;	777777 777777V;	777777 777777V;
777777 777777V;	777777 777777V;	777777 777777V;	777777 777777V;
777777 777777V;	777777 777777V;	777777 777777V;	777777 777777V;
777777 777777V;	777777 777777V;	777777 777777V;	777777 777777V;
777777 777777V;	777777 777777V;	777777 777777V;	777777 777777V;
777777 777777V;	777777 777777V;	777777 777777V;	777777 777777V;

*ORIGINAL VALUES FOR RANDOM NO. GENERATOR
*MUST BE AT BOUNDARY OF 8
X0:	7654321V;
X1:	76543210V;
X2:	765432100V;
X3:	7654321000V;
X4:	76543210000V;
X5:	765432100000V;
X6:	654321000007V;
X7:	543210000076V;

@X0:	E1[X0];
@X7:	E1[X7];

SVN[YRAN]; SVN[COUNT]; SVN[RANP]; SVN[STEMP]; SVN[SMDATA]; MC[J,J];

RVN[RDATA]; RVN[RTEMP]; LVN[LDATA]; LVN[MDATA];

IM[ILC,20]; TARGET[ILC];

MCYCLE:	BRKP[1], COUNT_Q, GOTO[NXTNUM];
START:	ARM_NULL, INHINT, DGOTO[NXTNUM];
	IRET, INHINT, COUNT_NULL, CALL[INIRAN];

PQCOMP:	P#Q;
	RETURN[ALU=0];
	BRKP[1], RETURN;

RETN:	RETURN;

*INITIALIZE RANDOM NO. GENERATOR
INIRAN:	Y_@X7;
	RANP_Y, RETURN;

*RETURN RANDOM NO. IN Q (USES Y WHICH MUST NOT BE CLOBBERED), CLOBBERS P
RGEN:	Y_P_RANP;
	Q_@X0;
	P-Q-1, P_SY, DECY;
	Q_SY, GOTO[.+2,ALU>=0];
	A0, Y_@X7, GOTO[.-1];
	Q_P+Q, RANP_Y;
	SY_Q, RETURN;

*SAVE RANDOM NO. GENERATOR STATE IN SM FOR RESTORATION LATER
RMARK:	Y_RANP;
	YRAN_Y;			*SAVE POINTER
	P_@X0;
	Y_@X7;
	Q_Y;
	P-Q, Q_SY, DGOTO[.-1];
	SY10_Q, DECY, RETURN[ALU>=0];

*RESTORE RANDOM NO. GENERATOR STATE
RREST:	Y_YRAN;
	RANP_Y;
	P_@X0;
	Y_@X7;
	Q_Y;
	P-Q, Q_SY10, DGOTO[.-1];
	SY_Q, DECY, RETURN[ALU>=0];

*SUBROUTINE USED BY SMASKT AND AMASKT
SAMT:	MDR_P;
	P_SY, Q_RDATA;
	P_MDR, Q_P AND Q, INCY, GOTO[PQCOMP];

*SUBROUTINE USED BY BAMASKT
BAMT:	INCY, Q_P AND Q, P_MDR, GOTO[PQCOMP];

*DIAGNOSTIC STARTS HERE
NXTNUM:	CALL[RGEN];
	LDATA_Q, CALL[RGEN];
	RDATA_Q, CALL[RGEN];
	SMDATA_MDATA_Q;

RBLT:	P_Q_RDATA, CALL[PQCOMP];
	GOTO[.+1];

LBLT:	P_Q_LDATA, CALL[PQCOMP];
	GOTO[.+1];

QLSHT:	Q_RDATA;
	Q LSH 1, DECY, AQ, B_SY;	*DECY, AQ, B_SY FOR NOISE EFFECT
	MDR_Q, P_RDATA, Q_A0;
	PQ LCY [1], Q_MDR, CALL[PQCOMP]; *P/ RDATA LSH 1 VIA PQ LCY [1]
	GOTO[.+1];			*Q/ RDATA LSH 1 VIA Q LSH 1

QRSHT:	Q_RDATA;
	Q RSH 1, DECY, NOT Q, B_SY;
	MDR_Q, P_RDATA, Q_A0;
	PQ RCY [1], Q_MDR, CALL[PQCOMP]; *P/ RDATA RSH 1 VIA PQ RCY [1]
	GOTO[.+1];			*Q/ RDATA RSH 1 VIA Q RSH 1

QRBR1T:	P_(RDATA) RSH [1], Q_(RDATA) RSH 1, CALL[PQCOMP];
	GOTO[.+1];			*P/ RDATA RSH 1 VIA RM RSH 1
					*Q/ RDATA RSH 1 VIA RM RSH 1

SADDT:	P_LDATA, Q_RDATA;
	MDR_P_P+Q;
	P_P-Q, Q_LDATA, CALL[PQCOMP];	*P/ LDATA+RDATA-RDATA
	GOTO[.+1];			*Q/ LDATA

ASUBT:	P_LDATA, Q_RDATA;
	MDR_P_P-Q-1;
	P_P+Q+1, Q_LDATA, CALL[PQCOMP];	*P/ LDATA-RDATA-1+RDATA+1
	GOTO[.+1];			*Q/ LDATA VIA LM

P1TST:	P_LDATA;
	P_P1, Q_P, CALL[PQCOMP];		*P/ LDATA VIA P1
	GOTO[.+1];			*Q/ LDATA VIA ALU
	Q_LDATA, P_P1, CALL[PQCOMP];		*P/ LDATA VIA P1
	GOTO[.+1];			*Q/ LDATA VIA LM

ALUR1T:	P_RDATA, A0, Q_(RDATA) RSH 1;
	P_(P) ARSHC 1, CALL[PQCOMP];		*P/ RDATA RSH 1 VIA ALU RSH 1
	GOTO[.+1];			*Q/ RDATA RSH 1 DIRECT

RBRCT:	Q_RDATA;
	QQ RCY [1], Q_(RDATA) RCY 1, CALL[PQCOMP];
	GOTO[.+1];			*P/ RDATA RCY 1 VIA QQ RCY
					*Q/ RDATA RCY 1 DIRECTY

XMASKT:	Q_RDATA, P_77S;
	X_P AND Q;
	P_LDATA, XMASK, Y_X;
	RTEMP_P, P_SY, Q_LDATA;
	P_P AND Q, Q_RTEMP, CALL[PQCOMP]; *PROBABLY FAILURE OF P_LDATA, XMASK
	GOTO[.+1];			*P/ GOOD VALUE
					*Q/ P_LDATA, XMASK

*ON TESTS BELOW, FAILURE IS PROBABLY ON P_RDATA, SAMASK.  ON FAILURE:
*P/ RESULT OF P_RDATA, SAMASK VIA MDR
*Q/ CORRECT VALUE VIA Q_P AND Q
SMASKT:	Y_NULL, P_RDATA, Q_LDATA, SAMASK[0], CALL[SAMT];
	SET[TT,1];
REPEAT[77,ILC[(P+Q, P_RDATA, Q_LDATA, SAMASK[TT], CALL[SAMT])]
	SET[TT,ADD[TT,1]]];		*P+Q FOR NOISE AFFECT

*ON TESTS BELOW, FAILURE IS PROBABLY ON P_RDATA, AMASK.  ON FAILURE:
*P/ RESULT OF P_RDATA, AMASK VIA MDR
*Q/ CORRECT VALUE VIA Q_P AND Q
AMASKT:	Y_NULL, P_RDATA, Q_LDATA, AMASK[0], CALL[SAMT];
	SET[TT,1];
REPEAT[37,ILC[(P_RDATA, Q_LDATA, AMASK[TT], CALL[SAMT])]
	SET[TT,ADD[TT,1]]];

*ON TESTS BELOW, FAILURE IS PROBABLY ON P_LDATA, BAMASK.  ON FAILURE:
*P/ RESULT OF P_LDATA, BAMASK VIA MDR
*Q/ CORRECT RESULT VIA Q_P AND Q
BAMSKT:	Y_NULL, P_LDATA, Q_RDATA, BAMASK[0]; *Q_RDATA FOR NOISE AFFECT
	MDR_P, Q_LDATA;
	P_SY, CALL[BAMT];
	SET[TT,1];
REPEAT[77,ILC[(P_LDATA, Q_SY, BAMASK[TT])]
	ILC[(MDR_P, P_Q, Q_LDATA, CALL[BAMT])]
	SET[TT,ADD[TT,1]]];

PQCYCT:	P_RDATA, Q_44S, AMASK[6];
	P-Q;
	Y_P, PQ RCY [1], GOTO[.-1,ALU>=0]; *Y_NUMBER .L. 44
	P_RDATA, Q_LDATA;
	PQ RCY [Y], DECY, STEMP_Y;
	MDR_P, P_LDATA, Q_RDATA, DECY, GOTO[.+2,Y<0];
	Q RSH 1, PQ RCY [1], ASHOVF, DECY, GOTO[.,Y>=0];
	P_MDR, CALL[PQCOMP];		*P/ RESULT OF PQ RCY [STEMP]
	GOTO[.+1];			*Q/ SAME RESULT VIA Q RSH 1, ASHOVF

0QCYCT:	P_RDATA, Q_44S, AMASK[6];
	P-Q;
	Y_P, PQ RCY [1], GOTO[.-1,ALU>=0]; *Y_NUMBER .L. 44
	P_RDATA, Q_LDATA;
	0Q RCY [Y], DECY, STEMP_Y, Q_A0;
	MDR_P, P_LDATA, DECY, GOTO[.+2,Y<0];
	Q RSH 1, PQ RCY [1], ASHOVF, DECY, GOTO[.,Y>=0];
	P_MDR, CALL[PQCOMP];		*P/ RESULT OF 0Q RCY [STEMP]
	GOTO[.+1];			*Q/ SAME RESULT VIA Q RSH 1

QQCYCT:	P_RDATA, Q_44S, AMASK[6];
	P-Q;
	Y_P, PQ RCY [1], GOTO[.-1,ALU>=0];
	P_RDATA, Q_LDATA;
	QQ RCY [Y], DECY, STEMP_Y;
	MDR_P, P_Q_LDATA, DECY, GOTO[.+2,Y<0];
	Q RSH 1, PQ RCY [1], ASHOVF, DECY, GOTO[.,Y>=0];
	P_MDR, CALL[PQCOMP];		*P/ RESULT OF QQ RCY [STEMP]
	GOTO[.+1];			*Q/ SAME RESULT VIA Q RSH 1

%THE SLOWEST ALU PATHS ARE P MASKING, NOT(ALU)Q RCY [Y] WITH ARITHMETIC THROUGH ALU AND INPUT CARRY COMPLEMENTING THE PREVIOUS INSTRUCTION.
WORST CASES ARE XMASK AFTER X_SLOW SOURCE, RCY [Y] AFTER Y_FAST SOURCE.
THESE COMBINATIONS ARE TESTED BELOW.

**NOTE:  RCY [Y] IS ILLEGAL AFTER LOADING Y FROM SLOW SOURCE AND RCY [44-Y]
**AFTER ANY LOAD OF Y.
%
SLOWT1:	Y_SMDATA;
	P_RDATA, Q_LDATA;
	NOT(P+Q+1)Q RCY [44-Y];		*F2 = CARRY1
	MDR_P, P_RDATA, Q_LDATA;
	P_P+Q+1;
	P_NOT P;
	PQ RCY [44-Y], Q_MDR, CALL[PQCOMP,H=0]; *P/ RESULT VIA QUICK PATHS
	GOTO[.+1];			*Q/ RESULT VIA SLOW PATHS

SLOWT2:	Q_MDATA;
	P_RDATA, Q_LDATA, XSPLIT_Q;	*X_Y_FAST SOURCE
	NOT(P-Q)Q RCY [Y];		*F2 = CARRY1
	MDR_P, P_LDATA, Q_RDATA;
	P_P-Q-1, Q_LDATA;		*NOT(RDATA-LDATA) = LDATA-RDATA-1
	PQ RCY [Y], Q_MDR, CALL[PQCOMP,H=0]; *P/ RESULT VIA QUICK PATHS
	GOTO[.+1];			*Q/ RESULT VIA SLOW PATHS

SLOWT3:	Q_MDATA;
	P+Q+1, P_LDATA, Q_RDATA, SETSF[J], XSPLIT_Q;
	NOT(P+Q)Q RCY [Y];
	MDR_P, P_LDATA, Q_RDATA;
	P_P+Q;
	P_NOT P;
	PQ RCY [Y], Q_MDR, CALL[PQCOMP,H=0]; *P/ QUICK RESULT
	GOTO[.+1];			*Q/ SLOW RESULT

SLOWT4:	Q_MDATA;
	P_LDATA, Q_RDATA, Y_Q;
	NOT(P-Q)Q RCY [Y];		*F2 = CARRY1
	MDR_P, P_LDATA, Q_RDATA;
	P_P-Q;
	P_NOT P, Q_RDATA;
	PQ RCY [Y], Q_MDR, CALL[PQCOMP,H=0]; *P/ QUICK RESULT
	GOTO[.+1];			*Q/ SLOW RESULT

SLOWT5:	Q_MDATA;
	P_LDATA, Q_RDATA, BSPLIT_Q;
	NOT(P+Q+1)Q RCY [Y];		*F2 = CARRY1
	MDR_P, P_LDATA, Q_RDATA;
	P_P+Q+1;
	P_NOT P, Q_RDATA;
	PQ RCY [Y], Q_MDR, CALL[PQCOMP,H=0]; *P/ QUICK RESULT
	GOTO[.+1];			*Q/ SLOW RESULT

SLOWT6:	Q_MDATA;
	P_LDATA, Q_RDATA, FSPLIT_Q;
	NOT(P-Q-1)Q RCY [Y];
	MDR_P, P_RDATA, Q_LDATA;
	P_P-Q, Q_RDATA;
	PQ RCY [Y], Q_MDR, CALL[PQCOMP,H=0]; *P/ QUICK RESULT
	GOTO[.+1];			*Q/ SLOW RESULT

SLOWT7:	P_RDATA, Q_LDATA, XSPLIT_SMDATA; *X_Y_SLOW BIPOLAR MEM.
	Q_B, B_P+Q+1, NEGY;		*F2 = CARRY1, Q_SLOW ALU
	PQ RCY [Y], XMASK;
	MDR_P, P_RDATA, Q_LDATA;
	Q_P+Q+1;
	PQ RCY [Y], XMASK, Q_MDR, CALL[PQCOMP,H=0];
	GOTO[.+1];			*P/ RESULT VIA QUICK PATHS
					*Q/ RESULT VIA SLOW PATHS

SLOWT8:	XSPLIT_A1, P_Q_LDATA;
	P_RDATA, XSPLIT_Q_B, B_P+Q+1;	*X_Y_SLOW ALU
	QQ RCY [Y], XMASK;			*F2 = CARRY1, F1 = RCYQQ
	MDR_P, P_Q_LDATA;
	P_Q_P+Q+1;
	PQ RCY [Y], XMASK, Q_MDR, CALL[PQCOMP,H=0];
	GOTO[.+1];			*P/ RESULT VIA QUICK PATHS
					*Q/ RESULT VIA SLOW PATHS

	P_COUNT;
	Q_P+1, GOTO[MCYCLE];