ASMB,R,Q,C * NAME: SAM * SOURCE: 92071-18137 * RELOC: 92071-16137 * PGMR: HLC * * * **************************************************************** * * (C) COPYRIGHT HEWLETT-PACKARD COMPANY 1980. ALL RIGHTS * * * RESERVED. NO PART OF THIS PROGRAM MAY BE PHOTOCOPIED, * * * REPRODUCED OR TRANSLATED TO ANOTHER PROGRAM LANGUAGE WITHOUT * * * THE PRIOR WRITTEN CONSENT OF HEWLETT-PACKARD COMPANY. * * **************************************************************** * * NAM SAM,0 92071-16137 REV.2041 790807 * ENT $ALC,$RTN,$MAX,$SMLS ENT $$SAM,$.SAM * EXT $LIST,$MM * A EQU 0 B EQU 1 SUP * REQUESTS MAY BE MADE TO ALLOCATE AND RELEASE BUFFERS * FROM THE MEMORY ALLOCATED DURING GENERATION. * * 1. ALLOCATE: CALLING SEQUENCE - * (P) JSB $ALC * (P+1) (# OF WORDS NEEDED) * (P+2) -RETURN NO MEMORY EVER (A)=-1, (B)=MAX EVER * (P+3) -RETURN NO MEMORY NOW (A)=0, (B)=MAX NOW * (P+4) -RETURN OK (A)=ADDR , (B)=SIZE OR SIZE+1 * * 2. RELEASE BUFFER TO AVAILABLE MEMORY * (P) JSB $RTN * (P+1) (FWA OF BUFFER) * (P+2) (# OF WORDS RETURNED) * (P+3) -RETURN- (ALL REGISTERS MEANINGLESS) * * IF A REQUEST FOR A BUFFER OF LENGTH X CANNOT BE FILLED * DURING A GIVEN CALL, RETURN IS MADE WITH: * (A) = 0 * IF, WHEN BUFFER REQUESTED, - (SMEM ) - SHOWS INSUFFICIENT CORE * AVAILABLE TO CONTAIN A BUFFER OF THE LENGTH REQUESTED, * THEN RETURN IS MADE WITH: * (A) = -1 * (B) = MAXIMUM LENGTH BUFFER THAT THE PROGRAM MAY ALLOCATE. * TO FIND OUT HOW LARGE A BUFFER MAY BE ALLOCATED, USE THE CALL * JSB $ALC * DEC 32767 * BLOCKS OF MEMORY AVAILABLE FOR OUTPUT BUFFERING ARE LINKED THROUGH * THE FIRST TWO WORDS OF EACH BLOCK - * WORD1 - LENGTH OF BLOCK * WORD2 - ADDRESS OF NEXT BLOCK (OR 77777 IF THIS IS LAST BLOCK) SKP $ALC NOP ALLOCATE BLOCK OF MEMORY LDA $ALC,I GET THE LENGTH OF THE REQUEST STA ADX AND SAVE IT ADA SMEM ENOUGH MEMORY NOW SSA TO HONOR THE REQUEST? JMP .A1 YES, GO ALLOCATE. LDB ADX ADB $MAX SSB,RSS WHAT ABOUT LATER? JMP ERETN NEVER! ISZ $ALC MAYBE, BUT NOT NOW. REJ CLA,CLE,RSS A=0, E=0 NOT NOW ERETN CCA,CLE A=-1,E=0 NOT EVER JMP SETB RETURN * .A1 ISZ $ALC TRY AN ALLOCATION CCA SET CORE AVAIL. NOW TO 0 STA TEMP LDB $SMLS START THE SEARCH LOOP WITH .A2 STB BAD SET LAST BUFFER ADDRESS CLE,INB STEP TO THE NEXT ADDRESS LDB B,I GET THE NEXT SEGMENT ADDRESS CPB =B77777 IF 77777 THEN END OF LIST AND NO JMP NOMOR MEMORY SO REJECT LDA B,I CHECK TO SEE IF THIS IS THE ADA TEMP LARGEST LENGTH SO FAR LDA B,I GET THE LENGTH CMA,SEZ SET NEG(-1) AND IF STA TEMP LARGEST SO FAR SAVE ADA ADX WILL IT SATISFY THE REQUEST? CMA,SSA IF ZERO OR NEGATIVE USE IT JMP .A2 ELSE GO TRY NEXT ONE ADA =D-2 IS BLOCK AT LEAST 2 WORDS CCE,SSA LARGER THAN REQUEST? JMP .A4 NO-ALLOCATE WHOLE BLOCK ADA =D2 (A)=LENGTH(I)-L(X) STA B,I SET NEW L(I) ADA B (A)=BUFFER ADDRESS JMP SETA RETURN TO USER * .A4 LDA B,I ALLOCATE ENTIRE BLOCK. STA ADX SET BUFFER LENGTH STB A BUFFER ADDRESS TO A CCE,INB SET E FOR ACCEPTED RETURN LDB B,I GET THE POINTER TO THE NEXT BLOCK ISZ BAD STEP TO POINTER ADDRESS IN LAST STB BAD,I BLOCK AND SET THE POINTER SETA ISZ $ALC SETB LDB $MAX SET B FOR REJECT SZA,RSS IF JUST FOR NOW RESET TO MAX LDB SMEM AVAILABLE NOW CMB,SEZ SET POSITIVE AND IF REQUEST LDB ADX SATISFIED SET TO LENGTH ISZ $ALC STEP RETURN ADDRESS JMP $ALC,I SPC 1 SPC 1 NOMOR LDA TEMP PICK UP MAX LEFT DURING SEARCH STA SMEM UPDATE MAX AVAILABLE NOW JMP REJ NOW RETURN * SKP * * $RTN NOP ENTRY POINT FOR BUFFER RETURN LDA $RTN,I (A) = FWA RETURN BUFFER (ADX) STA ADX CMA,INA SET NEG AND STA TEMP SAVE ISZ $RTN * LDB $RTN,I # OF WORDS RETURNED (X) ADB =D-2 SSB <2? JMP RETNR BUFFER TOO SMALL - IGNORE LDA $SMLS GET STARTING POINTER .R11 STA BAD BAD _ AAD INA LDB A,I AAD _ NEXTBUFAD STB A A _ PNTR ADB TEMP AAD -ADX CMB,SSB,INB,SZB ADX-AAD>=0? RSS SKIP IF FOUND JMP .R11 ELSE CONTINUE * * * LDB BAD GET LOWER BUFFER ADDRESS CPB $SMLS IF LOCATE POINTER JMP .R3 ASSUME NO OVERLAP ADB B,I ADD LENGTH AND ADB TEMP SUBTRACT NEW BLOCK ADDRESS CMB,SSB,INB,RSS IF NEG NO OVERLAP SO JMP .R3 JUMP ADB $RTN,I ELSE COMPUTE NEW LENGTH ADB BAD,I NOW HAVE NEW +OLD-OVERLAP .R4 STB BAD,I SET LENGTH ;CHECK FOR HIGH OVER- ADB BAD LAP COMPUTE END OF BLOCK CMB,CLE,INB AND SUBTRACT FROM THE HIGH BLOCK ADB A A HAS HIGH BLOCK ADDRESS SEZ,SZB IF RESULT POSITIVE JMP .R5 JUMP ADB A,I ADD OLD UPPER LENGTH ADB BAD,I CURRENT LENGTH STB BAD,I NEW+OLD-OVERLAP INA GET POINTER AND BRING LDA A,I DOWN TO NEW BLOCK .R5 LDB BAD,I SAVE MAX LENGTH THIS RETURN ISZ BAD STEP TO POINTER ADRRESS STA BAD,I SET THE POINTER CLE LDA SMEM CHECK TOO SEE IF THIS LENGTH ADA B ADD CURRENT MAX CMB,SEZ SET NEG; NEW MAX? STB SMEM YES; SET IT RETNR ISZ $RTN MEM16 LDA $MM GET SUSPENSION LIST PTR SZA,RSS JMP $RTN,I END OF LIST INA LDA A,I BLOCK SIZE REQUESTED. ADA SMEM COMPARE TO MAX NOW CMA,SSA,INA,SZA ENOUGH YET? JMP $RTN,I NO, TOO BAD. LDB $MM JSB $LIST YES, SCHEDULE PROGRAM. OCT 60 JMP MEM16 TRY NEXT PROGRAM TOO. * .R3 ISZ BAD NO LOW OVERLAP SET NEW BLOCK LDB ADX ADDRESS IN LOW BLOCK STB BAD,I TO LINK THE BLOCKS STB BAD SET POINTER FOR HIGH BLOCK CHECK LDB $RTN,I SET B TO THE LENGTH OF RETURN JMP .R4 CHECK FOR HIGH OVERLAP * SPC 1 SPC 1 * * $SMLS DEF SMEM DUMMY BLOCK ADDRESS(DON'T MESS!) SMEM OCT -1 DUMMY BLOCK LENGTH (NOT USED) PNTR OCT 77777 DUMMY BLOCK END (DON'T MESS!) * BAD NOP TEMP NOP ADX NOP * $MAX NOP MAX SIZE BLOCK EVER AVAILABLE * INITIALIZED AT BOOT-UP * $$SAM EQU * STANDARD MODULE $.SAM DEC 0 STANDARD MODULE END