$PAGE "MPE Caching Global Defines"                                      00010000
<<************************************************************>>        00015000
<<************ mpe caching global defines ********************>>        00020000
<<************************************************************>>        00025000
                                                                        00030000
<< file inclsf (system failures) is required to complete      >>        00035000
<< these defines.                                             >>        00040000
                                                                        00045000
<< sysglob cells >>                                                     00050000
define cache'dst     = absolute(%1273)#,<< cache dst number   >>        00055000
       cache'dst'bank= absolute(%1274)#,<< cache dst bank #   >>        00060000
       cache'dst'ofst= absolute(%1275)#;<< cache dst bk offset>>        00065000
                                                                        00070000
<< memory management page size (in words) >>                            00075000
equate mmpagesize = 128;   <<256>> <<512>>                              00080000
                                                                        00085000
<< these are the default minimum fetch size used >>                     00090000
<< for access methods (reads) when caching is    >>                     00095000
<< first enabled on the system.  the value is the>>                     00100000
<< the number of sectors to fetch.               >>                     00105000
equate cache'sequential = 96,  << 24k bytes >>                          00110000
       cache'random     = 16;  <<  4k bytes >>                          00115000
                                                                        00120000
<< this array is used to access the cdt with db pointing to it.  >>     00125000
integer array cdt'array(*) = db + 0;                                    00130000
double  array cdt'darray(*)= db + 0;                                    00135000
                                                                        00140000
<< this integer will be used wherever caching routines access the>>     00145000
<< index register explicitly.                                    >>     00150000
integer cdt'x = x;                                                      00155000
                                                                        00160000
equate cdt'entry'size     = 24;    << cdt entries are 24 words <<07294>>00165000
                                                                        00170000
<<************ cache dst equates and defines *****************>>        00175000
<<note: items beginning with dbl must be on a dbl word boundry>>        00180000
<<************************************************************>>        00185000
                                                                        00190000
<< dst header entry >>                                                  00195000
equate cdt'entries    = 0,                        <<entries in table  >>00200000
       cdt'size       = cdt'entries + 1,          <<entry size        >>00205000
       cdt'free'count = cdt'size + 1,             <<# free entries    >>00210000
       cdt'free'head  = cdt'free'count + 1,       <<first free entry  >>00215000
       cdt'free'tail  = cdt'free'head + 1,        <<last free entry   >>00220000
       cdt'max'used   = cdt'free'tail + 1,        <<max entries used  >>00225000
       cdt'num'ldevs  = cdt'max'used + 1,         <<num ldevs cached  >>00230000
       cdt'disc'head  = cdt'num'ldevs + 1,        <<first cached ldev >>00235000
       cdt'dst'words  = cdt'disc'head + 1,        <<number of dst wds >>00240000
       cdt'stop'pnd   = cdt'dst'words+1,  <<true if stopcache >>        00245000
       cdt'seq'minftch= cdt'stop'pnd+1,   <<# sectors seq ftch>>        00250000
       cdt'rnd'minftch= cdt'seq'minftch+1,<<# secs random ftch>>        00255000
       cdt'force'post = cdt'rnd'minftch+1,<<true-wait wrt comp>>        00260000
       cdt'stop'queue = cdt'force'post+1, <<head pin on impede>>        00265000
       cdt'end        = cdt'stop'queue+1; <<len of entry      >>        00270000
                                                                        00275000
<< cached disc device entry >>                                          00280000
equate cdt'de'next'ldev = 0,                      <<next cached ldev  >>00285000
       cdt'de'prev'ldev = cdt'de'next'ldev+ 1,    <<prev cached ldev  >>00290000
       cdt'de'ldev = cdt'de'prev'ldev + 1,        <<ldev of disc      >>00295000
                                                               <<06407>>00300000
                                                               <<06407>>00305000
                                                               <<06407>>00310000
       cdt'de'mapd'pages= cdt'de'ldev     + 1,    <<number of m<<06407>>00315000
                                                  <<pages now a<<06407>>00320000
       cdt'de'mapd'cnt  = cdt'de'mapd'pages+1,    <<# mapped cd<<06407>>00325000
       cdt'de'mapd'head = cdt'de'mapd'cnt + 1,    <<hd mapped cdt     >>00330000
       cdt'de'mapd'tail = cdt'de'mapd'head + 1,   <<tail mapped cdt   >>00335000
       cdt'de'regions   = cdt'de'mapd'tail + 1,   <<# of regions      >>00340000
<<dbl>>cdt'de'reg'hd    = cdt'de'regions + 1,     <<double abs reg hd >>00345000
<<dbl>>cdt'de'reg'tl    = cdt'de'reg'hd +2,       <<double abs reg tl >>00350000
                                                                        00355000
<<dbl>>cdt'de'rhit      = cdt'de'reg'tl + 2,      <<cache read hit cnt>>00360000
<<dbl>>cdt'de'whit      = cdt'de'rhit + 2,        <<cache wrt hit coun>>00365000
<<dbl>>cdt'de'rmiss     = cdt'de'whit + 2,        <<cache read misses >>00370000
<<dbl>>cdt'de'wmiss     = cdt'de'rmiss + 2,       <<cache write misses>>00375000
<<dbl>>cdt'de'stop      = cdt'de'wmiss + 2,       <<cache i/o blocks  >>00380000
<<dbl>>cdt'de'scanpt    = cdt'de'stop   + 2,      <<last ref domain pt>>00385000
       cdt'de'end       = cdt'de'scanpt    + 2;   <<entry lengt<<06407>>00390000
                                                                        00395000
<< mapped disc domain entry >>                                          00400000
equate cdt'md'prev      = 0,                      <<prev mapd cdt dom.>>00405000
       cdt'md'next      = cdt'md'prev + 1,        <<next mapd cdt dom.>>00410000
<<dbl>>cdt'md'sector    = cdt'md'next + 1,        <<sector base       >>00415000
<<dbl>>cdt'md'end'sector= cdt'md'sector + 2,      <<sector limit      >>00420000
       cdt'md'flags     = cdt'md'end'sector + 2,  <<misc flag bits    >>00425000
       cdt'md'read'cnt  = cdt'md'flags + 1,       <<# discreq reading >>00430000
       cdt'md'write'cnt = cdt'md'read'cnt + 1,    <<# discreq writing >>00435000
       cdt'md'lkd'cdt   = cdt'md'write'cnt + 1,   <<cdt locked waiting>>00440000
       cdt'md'imped'hd  = cdt'md'lkd'cdt + 1,     <<head ldr waited   >>00445000
       cdt'md'ldr'head  = cdt'md'imped'hd + 1,    <<head ldr active   >>00450000
<<dbl>>cdt'md'mem'addr  = cdt'md'ldr'head + 1,    <<abs addr of region>>00455000
                                                  <<if present        >>00460000
       cdt'md'discreq   = cdt'md'mem'addr + 2,    <<spare disc req    >>00465000
       cdt'md'lk'cnt    = cdt'md'discreq + 1,     <<# of flushing cdts>>00470000
       cdt'md'ldev      = cdt'md'lk'cnt  + 1,     <<domain's ldev     >>00475000
       cdt'md'impeded   = cdt'md'ldev + 1,        <<head impede<<06407>>00480000
       cdt'md'de        = cdt'md'impeded + 1,     <<device entry #    >>00485000
       cdt'md'end       = cdt'md'de      + 1;     <<entry length      >>00490000
                                                                        00495000
<< equates for cdt'md'state - all possible 'states' a cdt can be in   >>00500000
equate cdt'avail'state = 0, <<available, no ldrs attached             >>00505000
       cdt'read'state  = 1, <<only read ldrs are attached             >>00510000
       cdt'write'state = 2, <<write and read ldrs are attached        >>00515000
       cdt'flush'state = 3, <<all ldrs must be completed: purge cdt   >>00520000
       cdt'lock'state  = 4; <<cdt locked, awaiting other cdt flush(es)>>00525000
                                                                        00530000
<< add equates for bit positions in cdt'md'flags word   >>              00535000
equate cdt'abs'bit         = 0,  << absent bit          >>              00540000
       cdt'imi'bit         = 1,  << in-motion in        >>              00545000
       cdt'imo'bit         = 2,  << in-motion out ???   >>              00550000
       cdt'miss'bit        = 3,  << miss on cache       >>              00555000
       cdt'locked'bit      = 4,  << locked bit set      >>              00560000
       cdt'fwip'bit        = 5,  << forced-write in prog>>              00565000
       cdt'roc'bit         = 6,  << rec. overlay canidat>>              00570000
       cdt'virgin'bit      = 7,  << region is virgin    >>              00575000
       cdt'wait'on'nopost  = 8,  << waiting on nopost wt>>              00580000
       cdt'seq'bit         = 9,  << seq access to cdt   >>              00585000
       cdt'state'bits      =13;  << (13:3) - state bits >>              00590000
                                                                        00595000
<< defines for bits in flags word of a mapped cdt entry >>              00600000
define cdt'absent     = (cdt'abs'bit:1)#, <<region is absent        >>  00605000
       cdt'imi        = (cdt'imi'bit:1)#, <<in-motion in            >>  00610000
       cdt'imo        = (cdt'imo'bit:1)#, <<ask john b!!!!!!        >>  00615000
       cdt'lockreq'pnd= (cdt'miss'bit:1)#, <<lock request pending  >>   00620000
       cdt'locked     = (cdt'locked'bit:1)#, <<entry is locked      >>  00625000
       cdt'fwip       = (cdt'fwip'bit:1)#, <<forced write in-prog.  >>  00630000
       cdt'roc        = (cdt'roc'bit:1)#, <<recoverable overlay can.>>  00635000
       cdt'virgin     = (cdt'virgin'bit:1)#,<<region is virgin      >>  00640000
       cdt'nopost     = (cdt'wait'on'nopost:1)#,<<wait nopost compl.>>  00645000
       cdt'md'state   = (cdt'state'bits:3)#;<<cdt state bits        >>  00650000
                                                                        00655000
<< check that index passed is valid >>                                  00660000
<< db must be pointing to the cdt and integer cdt'entry is   >>         00665000
<< used to perform a validity check against.                 >>         00670000
define cdt'check'index =                                                00675000
if (cdt'entry mod cdt'entry'size) <> 0 or                               00680000
   not (0 <= cdt'entry <=                                               00685000
        (cdt'array(cdt'dst'words) - 1)) then                            00690000
  suddendeath(cdt'bad'index)                                   <<06407>>00695000
else                                                           <<06407>>00700000
  if cdt'array(cdt'entry) < 0 then                             <<06407>>00705000
    suddendeath(cdt'unassigned)#;                              <<06407>>00710000
                                                                        00715000
<< check that entry passed is valid >>                                  00720000
<< db must be pointing to the cdt and integer cdt'entry is   >>         00725000
<< used to perform a validity check against.                 >>         00730000
define cdt'check'entry =                                                00735000
if not (0 <= cdt'entry <= cdt'array(cdt'entries)) then                  00740000
  suddendeath(cdt'bad'index)                                   <<06407>>00745000
else                                                           <<06407>>00750000
  if cdt'array(cdt'entry*cdt'entry'size) = -1 then             <<06407>>00755000
    suddendeath(cdt'bad'index)#;                               <<06407>>00760000
                                                                        00765000
<< the cache control sir is used to protect the ldev string (of ldevs>> 00770000
<< cached).  it is used when caching is enabled or disabled against  >> 00775000
<< a disc, or when a command executor wishes to display information  >> 00780000
<< about a specific device under caching control.                    >> 00785000
                                                                        00790000
equate cache'control'sir = 2;                                           00795000
                                                                        00800000
<< this shift instruction is used in kernelc and in cacheseg  ><<06407>>00805000
<< to optimize llsh searching of disc addresses in caching.   ><<06407>>00810000
<< since the high-order nibble of a double-word disc address  ><<06407>>00815000
<< is reserved for ldev, we can always shift-over the disc    ><<06407>>00820000
<< address to overlay this field to increase the resolution of><<06407>>00825000
<< the llsh instruction.  worse case, this instruction will be><<06407>>00830000
<< dlsl(8), which merely overlays the ldev portion of the hoda><<06407>>00835000
<< since the hp7933 is currently our largest capacity disc,   ><<06407>>00840000
<< and uses only the lower 5 bits of the hoda to represent the><<06407>>00845000
<< highest possible sector address, we will assume dlsl(11).  ><<06407>>00850000
<< this will increase our resolution by 2**3.  if any larger  ><<06407>>00855000
<< discs are added to the 3000, this constant must be changed!><<06407>>00860000
define cdt'shift'da = assemble(dlsl 11)#;                      <<06407>>00865000
                                                               <<06407>>00870000
<< these subroutine defines are used in lieu of the procedures >>       00875000
<< in cacheseg for performance reasons.  note that no error    >>       00880000
<< checking is performed by these subroutines, and they will   >>       00885000
<< add to the procedure-local code size.                       >>       00890000
                                                                        00895000
integer cdt'sm3 = s-3,                                                  00900000
        cdt'sm4 = s-4,                                                  00905000
        cdt'sm5 = s-5,                                                  00910000
        cdt'sm6 = s-6,                                                  00915000
        cdt'sm7 = s-7,                                                  00920000
        cdt'sm8 = s-8;                                                  00925000
                                                                        00930000
double cdt'dsm4 = s-4,                                                  00935000
       cdt'dsm6 = s-6,                                                  00940000
       cdt'dsm10= s-10,                                                 00945000
       cdt'dsm12= s-12;                                                 00950000
                                                                        00955000
define cdt'abs'on'tos =                                                 00960000
                                                                        00965000
tos := cache'dst'bank;                                                  00970000
cdt'x := cdt'x + 1;                                                     00975000
tos := absolute(cdt'x)#;                                                00980000
                                                                        00985000
define def'ofst =                                                       00990000
                                                                        00995000
tos := cache'dst'bank;                                                  01000000
tos := absolute(cdt'x:=cdt'x+1)+(cdt'sm4<<cd>>*cdt'entry'size)          01005000
                +cdt'sm3<<ofst>>#,                                      01010000
                                                                        01015000
def'dofst =                                                             01020000
                                                                        01025000
tos := cache'dst'bank;                                                  01030000
tos := absolute(cdt'x:=cdt'x+1)+(cdt'sm5<<cd>>*cdt'entry'size)          01035000
                +cdt'sm4<<ofst>>#,                                      01040000
                                                                        01045000
def'fofst =                                                             01050000
                                                                        01055000
tos := cache'dst'bank;                                                  01060000
tos := absolute(cdt'x:=cdt'x+1)+(cdt'sm4<<cd>>*cdt'entry'size)          01065000
                +cdt'md'flags#,                                         01070000
                                                                        01075000
def'fsofst =                                                            01080000
                                                                        01085000
tos := cache'dst'bank;                                                  01090000
tos := absolute(cdt'x:=cdt'x+1)+(cdt'sm5<<cd>>*cdt'entry'size)          01095000
                +cdt'md'flags#,                                         01100000
                                                                        01105000
def'get'word =                                                          01110000
                                                                        01115000
integer subroutine cdt'get'word(cd,ofst,val);                           01120000
value cd,ofst,val;                                                      01125000
integer cd,ofst,val;                                                    01130000
begin                                                                   01135000
                                                                        01140000
<< load bank/offset on tos >>                                           01145000
def'ofst;                                                               01150000
                                                                        01155000
<< load value on tos >>                                                 01160000
assemble(lsea);                                                         01165000
                                                                        01170000
<< store in return value >>                                             01175000
cdt'sm7 := tos;                                                         01180000
                                                                        01185000
<< remove stacked address >>                                            01190000
assemble(ddel);                                                         01195000
                                                                        01200000
end#,                                                                   01205000
                                                                        01210000
def'set'word =                                                          01215000
                                                                        01220000
integer subroutine cdt'set'word(cd,ofst,val);                           01225000
value cd,ofst,val;                                                      01230000
integer cd,ofst,val;                                                    01235000
begin                                                                   01240000
                                                                        01245000
<< load bank/offset on tos >>                                           01250000
def'ofst;                                                               01255000
                                                                        01260000
<< load value on tos >>                                                 01265000
assemble(lsea);                                                         01270000
                                                                        01275000
<< store in return value >>                                             01280000
cdt'sm7 := tos;                                                         01285000
                                                                        01290000
<< store new value >>                                                   01295000
tos := cdt'sm3; <<val>>                                                 01300000
assemble(ssea);                                                         01305000
                                                                        01310000
<< remove stacked address >>                                            01315000
assemble(ddel);                                                         01320000
                                                                        01325000
end#,                                                                   01330000
                                                                        01335000
def'get'double =                                                        01340000
                                                                        01345000
double subroutine cdt'get'double(cd,ofst,val);                          01350000
value cd,ofst,val;                                                      01355000
integer cd,ofst;                                                        01360000
double val;                                                             01365000
begin                                                                   01370000
                                                                        01375000
<< load bank/offset on tos >>                                           01380000
def'dofst;                                                              01385000
                                                                        01390000
<< load value on tos >>                                                 01395000
assemble(ldea);                                                         01400000
                                                                        01405000
<< store in return value >>                                             01410000
cdt'dsm10 := tos;                                                       01415000
                                                                        01420000
<< remove stacked address >>                                            01425000
assemble(ddel);                                                         01430000
                                                                        01435000
end#,                                                                   01440000
                                                                        01445000
def'set'double =                                                        01450000
                                                                        01455000
double subroutine cdt'set'double(cd,ofst,val);                          01460000
value cd,ofst,val;                                                      01465000
integer cd,ofst;                                                        01470000
double val;                                                             01475000
begin                                                                   01480000
                                                                        01485000
<< load bank/offset on tos >>                                           01490000
def'dofst;                                                              01495000
                                                                        01500000
<< load value on tos >>                                                 01505000
assemble(ldea);                                                         01510000
                                                                        01515000
<< store in return value >>                                             01520000
cdt'dsm10 := tos;                                                       01525000
                                                                        01530000
<< store new value >>                                                   01535000
tos := cdt'dsm4; <<val>>                                                01540000
assemble(sdea);                                                         01545000
                                                                        01550000
<< remove stacked address >>                                            01555000
assemble(ddel);                                                         01560000
                                                                        01565000
end#,                                                                   01570000
                                                                        01575000
def'add'double =                                                        01580000
                                                                        01585000
double subroutine cdt'add'double(cd,ofst,val);                          01590000
value cd,ofst,val;                                                      01595000
integer cd,ofst;                                                        01600000
double val;                                                             01605000
begin                                                                   01610000
                                                                        01615000
<< load bank/offset on tos >>                                           01620000
def'dofst;                                                              01625000
                                                                        01630000
<< load value on tos >>                                                 01635000
assemble(ldea);                                                         01640000
                                                                        01645000
<< add val to old value >>                                              01650000
tos := tos + cdt'dsm6;                                                  01655000
assemble(ddup);                                                         01660000
                                                                        01665000
<< store in return value >>                                             01670000
cdt'dsm12 := tos;                                                       01675000
                                                                        01680000
<< store new value >>                                                   01685000
assemble(sdea);                                                         01690000
                                                                        01695000
<< remove stacked address >>                                            01700000
assemble(ddel);                                                         01705000
                                                                        01710000
end#,                                                                   01715000
                                                                        01720000
def'get'bit =                                                           01725000
                                                                        01730000
logical subroutine cdt'get'bit(cd,bit'no,val);                          01735000
value cd,bit'no,val;                                                    01740000
integer cd,bit'no,val;                                                  01745000
begin                                                                   01750000
                                                                        01755000
<< load bank/offset on tos >>                                           01760000
def'fofst;                                                              01765000
                                                                        01770000
<< load value on tos >>                                                 01775000
assemble(lsea);                                                         01780000
                                                                        01785000
<< store in return value >>                                             01790000
cdt'x := cdt'sm5;  <<bit'no>>                                           01795000
assemble(tbc 0,x);  << test the corresponding bit >>                    01800000
if = then                                                               01805000
  cdt'sm7 := 0                                                          01810000
else                                                                    01815000
  cdt'sm7 := 1;                                                         01820000
                                                                        01825000
<< remove stacked address >>                                            01830000
assemble(ddel,del);                                                     01835000
                                                                        01840000
end#,                                                                   01845000
                                                                        01850000
def'set'bit =                                                           01855000
                                                                        01860000
logical subroutine cdt'set'bit(cd,bit'no,val);                          01865000
value cd,bit'no,val;                                                    01870000
integer cd,bit'no,val;                                                  01875000
begin                                                                   01880000
                                                                        01885000
push(status);                                                           01890000
                                                                        01895000
                                                                        01900000
def'fsofst;                                                             01905000
                                                                        01910000
<< load value on tos >>                                                 01915000
disable;                                                                01920000
assemble(lsea);                                                         01925000
                                                                        01930000
                                                                        01935000
cdt'x := cdt'sm6;  <<bit'no>>                                           01940000
if logical(cdt'sm5<<val>>) then                                         01945000
  assemble(tsbc 0,x)    << turn on bit >>                               01950000
else                                                                    01955000
  assemble(trbc 0,x);   << turn off bit >>                              01960000
                                                                        01965000
if = then                                                               01970000
  cdt'sm8 := 0         << bit was off >>                                01975000
else                                                                    01980000
  cdt'sm8 := 1;        << bit was on >>                                 01985000
                                                                        01990000
<< store new value >>                                                   01995000
assemble(ssea);                                                         02000000
                                                                        02005000
                                                                        02010000
assemble(ddel);                                                         02015000
                                                                        02020000
if tos.(1:1) = 1 then                                                   02025000
  enable;                                                               02030000
                                                                        02035000
end#,                                                                   02040000
                                                                        02045000
def'add'word =                                                          02050000
                                                                        02055000
integer subroutine cdt'add'word(cd,ofst,val);                           02060000
value cd,ofst,val;                                                      02065000
integer cd,ofst,val;                                                    02070000
begin                                                                   02075000
                                                                        02080000
<< load bank/offset on tos >>                                           02085000
def'ofst;                                                               02090000
                                                                        02095000
<< load value on tos >>                                                 02100000
assemble(lsea);                                                         02105000
                                                                        02110000
<< add val to value on tos >>                                           02115000
tos:=tos+cdt'sm4;                                                       02120000
assemble(dup);                                                          02125000
                                                                        02130000
<< store in return value >>                                             02135000
cdt'sm8 := tos;                                                         02140000
                                                                        02145000
<< store new value >>                                                   02150000
assemble(ssea);                                                         02155000
                                                                        02160000
<< remove stacked address >>                                            02165000
assemble(ddel);                                                         02170000
                                                                        02175000
end#,                                                                   02180000
                                                                        02185000
def'cache'on'subroutine =                                               02190000
                                                                        02195000
   logical subroutine is'ldev'cache'on;                                 02200000
   begin                                                                02205000
      if cache'dst = 0 then is'ldev'cache'on := false                   02210000
      else                                                              02215000
        if cdt'find'de(ldev) = 0                                        02220000
           then is'ldev'cache'on := false                               02225000
      else is'ldev'cache'on := true;                                    02230000
   end#;                                                                02235000
                                                                        02240000
<<***********************************************************>>         02245000
<<***********************************************************>>         02250000
<<***********************************************************>>         02255000
