DIRECTORY
Basics USING [UnsafeBlock],
BasicTime USING [GMT, Now, nullGMT, Period, Update],
Camelot USING [btidT, tidT],
IO USING [EndOfStream, GetChar, GetLength, STREAM, UnsafeGetBlock],
PBasics USING [charsPerWord],
Process USING [Detach, MsecToTicks, Pause, SetTimeout, Ticks],
RedBlackTree USING [Compare, Create, Delete, GetKey, Insert, InsertNode, Lookup, LookupNextLarger, LookupSmallest, Node, Size, Table, UserData],
RefText USING [ObtainScratch, ReleaseScratch],
Rope USING [Concat, Compare, FromRefText, ROPE],
YggDID USING [DID],
YggDIDPrivate USING [DIDRep],
YggDIDMap USING [GetComponentFiles, OpenDocumentFromDID],
YggEnvironment USING [AccessRights, LockMode, LockOption, nullTransID, TransID],
YggFileStream USING [StreamFromComponentFilesAndTid],
YggFixedNames USING [Contents, Inlinks, Outlinks],
YggInternal USING [Document, FileHandle],
YggLock USING [Failed, MakeLockID, Set],
YggMonitoringLog USING [LockConflictInfo, notice],
YggRep USING [AccurateGMT, AccurateGMTRep, AccurateGMTRepByteSize, Attribute, AttributePreambleByte, AttributeValue, Bits, BitsFromBits, BitsRep, date, float, did, int, metaAttributeMod, rope, shortRope, TypedPrimitiveElement, unknown, uninterpretedBytes, VDoc, VDocRep],
YggTransaction USING [EqualTrans, GetParent, IsNullTrans, NotePossibleDocumentUpdate],
YggVolatileObjectCache;

YggVolatilizeImpl: CEDAR MONITOR
IMPORTS BasicTime, IO, Process, RedBlackTree, RefText, Rope, YggDIDMap, YggFileStream, YggFixedNames, YggLock, YggMonitoringLog, YggRep, YggTransaction
EXPORTS YggDID, YggRep, YggVolatileObjectCache
~ BEGIN

ROPE: TYPE ~ Rope.ROPE;

scratchBuffSize: INT = 128;

didCache: RedBlackTree.Table;
desiredSizeOfDIDCache: INT _ 50;

cacheEntry: TYPE ~ REF cacheEntryRep;
cacheEntryRep: TYPE ~ RECORD [
users: INT _ 0,
timeOfLastVolatize: BasicTime.GMT _ BasicTime.nullGMT,
vDoc: YggRep.VDoc _ NIL
];
myCondition: CONDITION;
latchCondition: CONDITION;

DID: PUBLIC TYPE ~ REF DIDRep;
DIDRep: PUBLIC TYPE ~ YggDIDPrivate.DIDRep;

Now: BasicTime.GMT _ BasicTime.Now[];


VolatizeFromDID: PUBLIC PROC [transID: YggEnvironment.TransID, did: YggDID.DID, 
access: YggEnvironment.AccessRights, lock: YggEnvironment.LockOption, metaAttributesOnly: BOOL]
RETURNS [vDoc: YggRep.VDoc _ NIL] ~ {
parseAttributes: PROC [attrStream: IO.STREAM] RETURNS [attributeList: LIST OF YggRep.Attribute _ NIL, contentsAttribute: YggRep.TypedPrimitiveElement _ [YggRep.unknown, NIL], outlinksAttribute: LIST OF YggRep.AttributeValue _ NIL, inlinksAttribute: LIST OF YggRep.AttributeValue _ NIL]  = {
readInt: PROC RETURNS [int: INT] = {
charsRead: INT _ 0;
rint: REF INT;
rint _ NEW[INT];
TRUSTED {charsRead _ IO.UnsafeGetBlock[attrStream, [LOOPHOLE[rint], 0, BYTES[INT]]];};
IF charsRead # BYTES[INT] THEN ERROR;
RETURN[rint^];
};
readString: PROC [extraChars: INT] RETURNS [string: ROPE _ NIL]= {
nullFound: BOOL _ FALSE;
lenInScratch: INT _ 0;
numberToFetch: INT _ PBasics.charsPerWord-extraChars;
fourChars: REF PACKED ARRAY [0..PBasics.charsPerWord) OF CHAR;
scratch: REF TEXT = RefText.ObtainScratch[scratchBuffSize];
fourChars _ NEW[PACKED ARRAY [0..PBasics.charsPerWord) OF CHAR];
UNTIL nullFound DO
charsRead: INT _ 0;
TRUSTED {charsRead _ IO.UnsafeGetBlock[attrStream, [LOOPHOLE[fourChars], 0 , numberToFetch]];};
IF charsRead # numberToFetch THEN ERROR;
FOR charNo: INT IN [0..numberToFetch) DO
IF fourChars[charNo] = 0C THEN {nullFound _ TRUE; EXIT};
scratch[lenInScratch] _ fourChars[charNo];
lenInScratch _ lenInScratch + 1;
IF lenInScratch = scratchBuffSize THEN {
scratch.length _ lenInScratch;
string _ Rope.Concat[string, Rope.FromRefText[s: scratch, start: 0, len: lenInScratch]];
lenInScratch _ 0;
};
ENDLOOP;
numberToFetch _ PBasics.charsPerWord;
ENDLOOP;
IF lenInScratch # 0 THEN {
scratch.length _ lenInScratch;
string _ Rope.Concat[string, Rope.FromRefText[s: scratch, start: 0, len: lenInScratch]];
};
RefText.ReleaseScratch[scratch];
};
doneWithAttributes: BOOL _ FALSE;
attributeListLast: LIST OF YggRep.Attribute _ NIL;
contentsDocType _ readInt[];
DO  -- for each attribute
attributeName: ROPE _ NIL;  --  attribute name
attributeValue: LIST OF YggRep.AttributeValue _ NIL;  --  attribute name
attributeValueLast: LIST OF YggRep.AttributeValue _ NIL;  --  attribute name
numberOfAttributeValues: INT _ 1;
preampleByte: CHAR;
preample: YggRep.AttributePreambleByte;
fieldDocType: CARD;
TRUSTED {preampleByte _ IO.GetChar[attrStream ! IO.EndOfStream => {
doneWithAttributes _ TRUE;
CONTINUE;
};
 ];};  -- @preample points to preample[0]
IF doneWithAttributes THEN EXIT;
preample _ LOOPHOLE[preampleByte];
fieldDocType _ SELECT preample.typeCode FROM
integer => YggRep.int,
ropeLarge => YggRep.rope,
ropeShort => YggRep.shortRope,
float => YggRep.float,
date => YggRep.date,
did => YggRep.did,
uninterpretedBytes => YggRep.uninterpretedBytes,
ENDCASE => YggRep.unknown;
attributeName _ readString[1];  --  read attribute name
IF ~preample.singletonAttribute THEN {
numberOfAttributeValues _ readInt[];
};
FOR attVal: INT IN [0..numberOfAttributeValues) DO  -- for each attribute value (a field)
fieldName: ROPE _ NIL;
valueSet: LIST OF YggRep.TypedPrimitiveElement _ NIL; -- set of values for field
valueSetLast: LIST OF YggRep.TypedPrimitiveElement _ NIL; -- set of values for field
IF ~preample.noFieldNames THEN {
fieldName _ readString[0];  --  read field name
};
DO -- for each typed primitive element in the field's value set
fieldValue: YggRep.Bits;
IF preample.typeCode = separate THEN {
fieldDocType _ readInt[];
};
SELECT fieldDocType FROM
YggRep.unknown => EXIT;
YggRep.int => {
i: INT32;
ri: REF INT32;
i _ readInt[];
ri _ NEW[INT32 _ i];
fieldValue _ ri;
};
YggRep.shortRope => {
rRope: ROPE;
rRope _ readString[0];
fieldValue _ rRope;
};
YggRep.rope => {
len: INT;
lenToRead: INT;
charsRead: INT;
rRope: ROPE;
scratch: REF TEXT;
len _ readInt[];
lenToRead _ PBasics.charsPerWord * ((len - 1 + PBasics.charsPerWord)/PBasics.charsPerWord);
scratch _ RefText.ObtainScratch[lenToRead];
TRUSTED {charsRead _ IO.UnsafeGetBlock[attrStream, [LOOPHOLE[scratch, LONG POINTER]+UNITS[TEXT[0]], 0 , lenToRead]];};
IF charsRead # lenToRead THEN ERROR;
scratch.length _ len;
rRope _ Rope.FromRefText[s: scratch, start: 0, len: len];
fieldValue _ rRope;
};
YggRep.float => {
rReal: REF REAL32;
rReal _ NEW[REAL32];
TRUSTED {
charsRead: INT;
ptReal: LONG POINTER TO REAL32;
ptReal _ LOOPHOLE[rReal];
charsRead _ IO.UnsafeGetBlock[attrStream, [LOOPHOLE[ptReal], 0, BYTES[REAL32]]];
IF charsRead # BYTES[REAL32] THEN ERROR;
};
fieldValue _ rReal;
};
YggRep.date => {
rAccurateGMT: YggRep.AccurateGMT;
rAccurateGMT _ NEW[YggRep.AccurateGMTRep];
TRUSTED {
charsRead: INT;
ptAGMT: LONG POINTER TO YggRep.AccurateGMTRep;
ptAGMT _ LOOPHOLE[rAccurateGMT];
charsRead _ IO.UnsafeGetBlock[attrStream, [LOOPHOLE[ptAGMT], 0, YggRep.AccurateGMTRepByteSize]];
IF charsRead # YggRep.AccurateGMTRepByteSize THEN ERROR;
};
fieldValue _ rAccurateGMT;
};
YggRep.did => {
rDID: DID;
rDID _ NEW[DIDRep];
TRUSTED {
charsRead: INT;
ptDID: LONG POINTER TO DIDRep;
ptDID _ LOOPHOLE[rDID];
charsRead _ IO.UnsafeGetBlock[attrStream, [LOOPHOLE[ptDID], 0, BYTES[DIDRep]]];
IF charsRead # BYTES[DIDRep] THEN ERROR;
};
fieldValue _ rDID;
};
ENDCASE => {
charsRead: INT;
junk: REF PACKED ARRAY [0..PBasics.charsPerWord) OF CHAR;
len: INT;
lenToRead: INT;
nullsToRead: INT;
rBits: REF YggRep.BitsRep;
len _ readInt[];
lenToRead _ PBasics.charsPerWord * ((len - 1 + PBasics.charsPerWord)/PBasics.charsPerWord);
rBits _ NEW[YggRep.BitsRep[len]];
rBits.validBytes _ len;
TRUSTED {
ptBits: LONG POINTER TO YggRep.BitsRep;
ptBits _ LOOPHOLE[rBits];
charsRead _ IO.UnsafeGetBlock[attrStream, [LOOPHOLE[ptBits, LONG POINTER] + UNITS[YggRep.BitsRep[0]], 0, len]];
IF charsRead # len THEN ERROR;
};
nullsToRead _ lenToRead - len;
IF nullsToRead > 0 THEN TRUSTED {
junk _ NEW[PACKED ARRAY [0..PBasics.charsPerWord) OF CHAR];
charsRead _ IO.UnsafeGetBlock[attrStream, [LOOPHOLE[junk], 0 , nullsToRead]];
IF charsRead # nullsToRead THEN ERROR;
};
fieldValue _ rBits;
};
IF valueSet = NIL THEN valueSetLast _ valueSet _ CONS[[fieldDocType, fieldValue], NIL]
 ELSE valueSetLast _ (valueSetLast.rest _ CONS[[fieldDocType, fieldValue], NIL]);
IF preample.singletonField THEN EXIT;
ENDLOOP;  -- for each typed primitive element in the field's value set
IF attributeValue = NIL THEN attributeValueLast _ attributeValue _ CONS[[fieldName, valueSet], NIL]
 ELSE attributeValueLast _ (attributeValueLast.rest _ CONS[[fieldName, valueSet], NIL]);
ENDLOOP;  -- for each attribute value
SELECT TRUE FROM
Rope.Compare[YggFixedNames.Contents, attributeName, FALSE] = equal => {
IF attributeValue = NIL THEN ERROR;
IF attributeValue.first.valueSet = NIL THEN ERROR;
IF attributeValue.rest # NIL THEN ERROR;
IF attributeValue.first.valueSet = NIL THEN ERROR;
IF attributeValue.first.valueSet.rest # NIL THEN ERROR;
contentsAttribute _ attributeValue.first.valueSet.first;
};
Rope.Compare[YggFixedNames.Outlinks, attributeName, FALSE] = equal => {
FOR linkList: LIST OF YggRep.AttributeValue _ attributeValue, linkList.rest UNTIL linkList = NIL DO
FOR vS: LIST OF YggRep.TypedPrimitiveElement _ linkList.first.valueSet, vS.rest UNTIL vS = NIL DO
IF vS.first.docType # YggRep.did THEN ERROR;
ENDLOOP;
ENDLOOP;
outlinksAttribute _ attributeValue;
};
Rope.Compare[YggFixedNames.Inlinks, attributeName, FALSE] = equal => {
FOR linkList: LIST OF YggRep.AttributeValue _ attributeValue, linkList.rest UNTIL linkList = NIL DO
FOR vS: LIST OF YggRep.TypedPrimitiveElement _ linkList.first.valueSet, vS.rest UNTIL vS = NIL DO
IF vS.first.docType # YggRep.did THEN ERROR;
ENDLOOP;
ENDLOOP;
inlinksAttribute _ attributeValue;
};
ENDCASE => {
IF attributeList = NIL THEN attributeListLast _ attributeList _ CONS[[attributeName, preample.ordered, attributeValue], NIL]
 ELSE attributeListLast _ (attributeListLast.rest _ CONS[[attributeName, preample.ordered, attributeValue], NIL]);
};
ENDLOOP;  -- for each attribute
};

contents, attributes, meta: IO.STREAM _ NIL;
contentsDocType: INT _  -1;
doc: YggInternal.Document _ NIL;
componentFiles: LIST OF YggInternal.FileHandle;

IF ~metaAttributesOnly THEN {
[] _ YggLock.Set[
trans: transID,
lock: YggLock.MakeLockID[did],
mode: lock.mode,
wait: lock.ifConflict=wait
! YggLock.Failed => {		-- Log the error and let the error propagate.
logProc: PROC [YggMonitoringLog.LockConflictInfo];
IF (logProc _ YggMonitoringLog.notice.lockConflict) # NIL THEN
logProc[[
what: why,			-- (conflict or timeout)
where: "YggVolatilizeImpl.VolatizeFromDID",
transID: transID,
mode: lock.mode,
specifics: entireFile[""],
message: ""
]]
}
];
};
IF (vDoc _ LookupDIDInCache[did, transID, lock.mode]) # NIL THEN RETURN;
ReserveDIDInCache[did, transID];
doc _ YggDIDMap.OpenDocumentFromDID[did, transID];
componentFiles _ YggDIDMap.GetComponentFiles[doc];
contents _ YggFileStream.StreamFromComponentFilesAndTid[componentFiles: componentFiles, fileUse: $contents, tid: transID];
IF contents # NIL THEN {
IF IO.GetLength[contents] <= 0 THEN SIGNAL itsZero;
};
attributes _ YggFileStream.StreamFromComponentFilesAndTid[componentFiles: componentFiles, fileUse: $attributes, tid: transID];
IF attributes # NIL THEN {
IF IO.GetLength[attributes] <= 0 THEN SIGNAL itsZero;
};
meta _ YggFileStream.StreamFromComponentFilesAndTid[componentFiles: componentFiles, fileUse: $meta, tid: transID];
vDoc _ NEW[YggRep.VDocRep];
vDoc.did _ did;
vDoc.tid _ IF lock.mode = read THEN YggEnvironment.nullTransID ELSE transID;
IF attributes # NIL THEN {
attributeList: LIST OF YggRep.Attribute _ NIL;
contentsAttribute: YggRep.TypedPrimitiveElement _ [YggRep.unknown, NIL];
outlinksAttribute: LIST OF YggRep.AttributeValue _ NIL;
inlinksAttribute: LIST OF YggRep.AttributeValue _ NIL;
[attributeList, contentsAttribute, outlinksAttribute, inlinksAttribute] _ parseAttributes[attributes];
IF contentsAttribute # [YggRep.unknown, NIL] THEN {
IF contents # NIL THEN ERROR;
vDoc.contents _ contentsAttribute;
};
vDoc.attributes _ attributeList;
vDoc.outlinks _ outlinksAttribute;
vDoc.inlinks _ inlinksAttribute;
};
IF meta # NIL THEN {
attributeList: LIST OF YggRep.Attribute _ NIL;
contentsAttribute: YggRep.TypedPrimitiveElement _ [YggRep.unknown, NIL];
[attributeList, contentsAttribute] _ parseAttributes[meta];
IF contentsAttribute # [YggRep.unknown, NIL] THEN ERROR;
vDoc.metaAttributes _ attributeList;
};
IF contents # NIL THEN {
bits: REF YggRep.BitsRep;
size: INT;
bytesLeft: INT;
nextByteToRead: INT _ 0;
IF contentsDocType = -1 THEN ERROR;
vDoc.contents.docType _ contentsDocType;
size _ bytesLeft _ IO.GetLength[contents];
IF size <= 0 THEN SIGNAL itsZero;
vDoc.contents.bits _ bits _ NEW[YggRep.BitsRep[size]];
bits.validBytes _ size;
WHILE bytesLeft > 0 DO
nBytesRead: INT;
unsafeBlock: Basics.UnsafeBlock;
TRUSTED {
firstByte: LONG POINTER;
firstByte _ LOOPHOLE[vDoc.contents.bits, LONG POINTER] + UNITS[YggRep.BitsRep[0]];
unsafeBlock _ [LOOPHOLE[firstByte], nextByteToRead, bytesLeft];
nBytesRead _ IO.UnsafeGetBlock[self: contents, block: unsafeBlock];
};
bytesLeft _ bytesLeft - nBytesRead;
nextByteToRead _ nextByteToRead + nBytesRead;
ENDLOOP;
};
IF lock.mode # read THEN YggTransaction.NotePossibleDocumentUpdate[transID, vDoc];
IF vDoc.contents.docType # YggRep.unknown AND vDoc.contents.bits = NIL THEN SIGNAL itsZero;
CacheDID[did, transID, vDoc];
};
itsZero: SIGNAL = CODE;
LatchVDoc: PUBLIC ENTRY PROC [vDoc: YggRep.VDoc, wait: BOOL _ TRUE] RETURNS [latched: BOOL _ TRUE] ~ {
ENABLE UNWIND => {};
IF vDoc = NIL THEN RETURN[FALSE];
WHILE vDoc.latched DO
IF ~wait THEN RETURN[FALSE];
WAIT latchCondition;
ENDLOOP;
vDoc.latched _ TRUE;
};
UnlatchVDoc: PUBLIC ENTRY PROC [vDoc: YggRep.VDoc] RETURNS [latched: BOOL _ FALSE] ~ {
ENABLE UNWIND => {};
IF vDoc.latched THEN {vDoc.latched _ FALSE; RETURN [TRUE]};
BROADCAST latchCondition;
};
scratchVDocUnderMonitor: YggRep.VDoc _ NEW[YggRep.VDocRep];

LookupDIDInCache: PUBLIC ENTRY PROC [did: DID, transID: YggEnvironment.TransID, mode: YggEnvironment.LockMode] RETURNS [vDoc: YggRep.VDoc _ NIL] ~ {
ENABLE UNWIND => {};
val: REF;
tid: Camelot.tidT _ transID;
DO
transFound: BOOL _ FALSE;
scratchVDocUnderMonitor.did _ did;  -- do this every time due to the WAIT below
scratchVDocUnderMonitor.tid _ tid;
val _ RedBlackTree.Lookup[self: didCache, lookupKey: scratchVDocUnderMonitor];
IF val # NIL THEN {
entry: cacheEntry;
last: LIST OF YggRep.Attribute;
vDoc: YggRep.VDoc _ NIL;
entry _ NARROW[val];
entry.timeOfLastVolatize _ Now;
IF entry.users # 0 THEN {WAIT myCondition; LOOP;};
IF mode = read THEN RETURN[entry.vDoc];
IF YggTransaction.EqualTrans[tid, transID] THEN {
IF mode # read THEN YggTransaction.NotePossibleDocumentUpdate[transID, vDoc];
RETURN[entry.vDoc];
};
vDoc _ NEW[YggRep.VDocRep _ [
did: did,
tid: transID,
contents:  [YggRep.unknown, NIL],
contentsChanged: FALSE,
attributes: NIL,  -- the attributes of the document
attributesChanged: NIL
 ]];
FOR aL: LIST OF YggRep.Attribute _ entry.vDoc.attributes, aL.rest UNTIL aL = NIL DO
IF vDoc.attributes = NIL THEN last _ vDoc.attributes _ LIST[aL.first]
 ELSE {last.rest _ LIST[aL.first]; last _ last.rest; };
ENDLOOP;
vDoc.contents.docType _ entry.vDoc.contents.docType;
SELECT vDoc.contents.docType FROM
YggRep.unknown => ERROR;
YggRep.int => vDoc.contents.bits _ NEW[INT _ NARROW[entry.vDoc.contents.bits, REF INT]^];
YggRep.shortRope, YggRep.rope, YggRep.did => vDoc.contents.bits _ entry.vDoc.contents.bits;
YggRep.float => vDoc.contents.bits _ NEW[REAL32 _ NARROW[entry.vDoc.contents.bits, REF REAL32]^];
YggRep.date => vDoc.contents.bits _ NEW[YggRep.AccurateGMTRep _ NARROW[entry.vDoc.contents.bits, REF YggRep.AccurateGMTRep]^];
ENDCASE =>  vDoc.contents.bits _ YggRep.BitsFromBits[entry.vDoc.contents.bits];
scratchVDocUnderMonitor.tid _ transID;
RedBlackTree.Insert[self: didCache, insertKey: scratchVDocUnderMonitor, dataToInsert: NEW[cacheEntryRep _ [0, Now, vDoc]]];
IF mode # read THEN YggTransaction.NotePossibleDocumentUpdate[transID, vDoc];
RETURN[vDoc];
};
IF YggTransaction.IsNullTrans[tid] THEN EXIT;
[transFound, tid] _ YggTransaction.GetParent[tid];
IF ~transFound THEN ERROR;
ENDLOOP;
};
ReserveDIDInCache: PUBLIC ENTRY PROC [did: DID, transID: YggEnvironment.TransID] ~ {
ENABLE UNWIND => {};
val: REF;
scratchVDocUnderMonitor.did _ did;
scratchVDocUnderMonitor.tid _ transID;
val _ RedBlackTree.Lookup[self: didCache, lookupKey: scratchVDocUnderMonitor];
IF val # NIL THEN {
entry: cacheEntry;
entry _ NARROW[val];
WHILE entry.users # 0 DO WAIT myCondition; ENDLOOP;
entry.users _ 1;
}
 ELSE {
RedBlackTree.Insert[self: didCache, insertKey: scratchVDocUnderMonitor, dataToInsert: NEW[cacheEntryRep _ [1, Now, NEW[YggRep.VDocRep _ [did: did, tid: transID]]]]];
};
};
UnreserveDIDInCache: PUBLIC ENTRY PROC [did: DID, transID: YggEnvironment.TransID] ~ {
ENABLE UNWIND => {};
val: REF;
scratchVDocUnderMonitor.did _ did;
scratchVDocUnderMonitor.tid _ transID;
val _ RedBlackTree.Lookup[self: didCache, lookupKey: scratchVDocUnderMonitor];
IF val # NIL THEN {
entry: cacheEntry;
entry _ NARROW[val];
entry.users _ entry.users - 1;
entry.timeOfLastVolatize _ Now;
BROADCAST myCondition;
}
 ELSE ERROR;
};
CacheDID: PUBLIC ENTRY PROC [did: DID, transID: YggEnvironment.TransID, vDoc: YggRep.VDoc] ~ {
ENABLE UNWIND => {};
val: REF;
scratchVDocUnderMonitor.did _ did;
scratchVDocUnderMonitor.tid _ transID;
val _ RedBlackTree.Lookup[self: didCache, lookupKey: scratchVDocUnderMonitor];
IF val # NIL THEN {
entry: cacheEntry;
entry _ NARROW[val];
entry.vDoc _ vDoc;
entry.users _ 0;
entry.timeOfLastVolatize _ Now;
BROADCAST myCondition;
}
 ELSE {
RedBlackTree.Insert[self: didCache, insertKey: vDoc, dataToInsert: NEW[cacheEntryRep _ [0, Now, vDoc]]];
};
};
InvalidateDID: PUBLIC ENTRY PROC [did: DID, transID: YggEnvironment.TransID] ~ {
ENABLE UNWIND => {};
val: REF;
scratchVDocUnderMonitor.did _ did;
scratchVDocUnderMonitor.tid _ transID;
val _ RedBlackTree.Lookup[self: didCache, lookupKey: scratchVDocUnderMonitor];
IF val # NIL THEN {
entry: cacheEntry;
deletedNode: RedBlackTree.Node _ NIL;
entry _ NARROW[val];
WHILE entry.users # 0 DO WAIT myCondition; ENDLOOP;
scratchVDocUnderMonitor.did _ did;  -- WAIT may have changed did/tid
scratchVDocUnderMonitor.tid _ transID;
deletedNode _ RedBlackTree.Delete[self: didCache, deleteKey: scratchVDocUnderMonitor];
deletedNode _ NIL;
};
};
PromoteToParent: PUBLIC ENTRY PROC [did: YggDID.DID, transID: YggEnvironment.TransID] ~ {
ENABLE UNWIND => {};
val: REF;
parentVal: REF;
transFound: BOOL _ FALSE;
parentTid: YggEnvironment.TransID;
scratchVDocUnderMonitor.did _ did;
scratchVDocUnderMonitor.tid _ transID;
val _ RedBlackTree.Lookup[self: didCache, lookupKey: scratchVDocUnderMonitor];
IF val # NIL THEN {
entry: cacheEntry;
entry _ NARROW[val];
[transFound, parentTid] _ YggTransaction.GetParent[transID];
IF ~transFound THEN ERROR;
scratchVDocUnderMonitor.tid _ parentTid;
parentVal _ RedBlackTree.Lookup[self: didCache, lookupKey: scratchVDocUnderMonitor];
IF parentVal # NIL THEN {
parentEntry: cacheEntry;
deletedNode: RedBlackTree.Node _ NIL;
parentEntry _ NARROW[parentVal];
scratchVDocUnderMonitor.tid _ transID;
deletedNode _ RedBlackTree.Delete[self: didCache, deleteKey: scratchVDocUnderMonitor];
deletedNode _ NIL;
parentEntry.vDoc _ entry.vDoc;
parentEntry.vDoc.tid _ parentTid;
IF entry.vDoc.metaAttributesChanged # NIL THEN {
IF parentEntry.vDoc.metaAttributesChanged = NIL THEN parentEntry.vDoc.metaAttributesChanged _ entry.vDoc.metaAttributesChanged
ELSE {
last: LIST OF YggRep.metaAttributeMod _ NIL;
FOR lomam: LIST OF YggRep.metaAttributeMod _ parentEntry.vDoc.metaAttributesChanged, lomam.rest UNTIL lomam = NIL DO
last _ lomam;
ENDLOOP;
last.rest _ entry.vDoc.metaAttributesChanged;
};
};
}
 ELSE { -- no parent
node: RedBlackTree.Node;
parentEntry: cacheEntry;
scratchVDocUnderMonitor.tid _ transID;
node _ RedBlackTree.Delete[self: didCache, deleteKey: scratchVDocUnderMonitor];
IF node = NIL THEN ERROR;
parentEntry _ NARROW[node.data];
parentEntry.vDoc.tid _ parentTid;
scratchVDocUnderMonitor.tid _ parentTid;
RedBlackTree.InsertNode[self: didCache, nodeToInsert: node, insertKey: scratchVDocUnderMonitor];
};
};
};

SetSizeOfDIDCache: PUBLIC ENTRY PROC [size: INT] = {
ENABLE UNWIND => {};
desiredSizeOfDIDCache _ size;
};
TickerProcess: PROC = {
ticksToWait: Process.Ticks;
ticksToWait _ Process.MsecToTicks[1123];
DO
Process.Pause[ticksToWait];
Now _ BasicTime.Now[];
ENDLOOP;

};
DIDCacheTrimProcess: PROC = {
ticksToWait: Process.Ticks;
lastVDoc: YggRep.VDoc _ NIL;
threshold: BasicTime.GMT _ BasicTime.Now[];
ticksToWait _ Process.MsecToTicks[293];
DO
innerTrim: ENTRY PROC = {
ENABLE UNWIND => {};
minGMT: BasicTime.GMT _ threshold;
minPeriod: INT _ LAST[INT];
size: INT;
size _ RedBlackTree.Size[didCache];
IF lastVDoc = NIL THEN {
data: RedBlackTree.UserData;
data _ RedBlackTree.LookupSmallest[didCache];
IF data # NIL THEN {
ce: cacheEntry;
ce _ NARROW[data];
lastVDoc _ ce.vDoc;
};
};
IF lastVDoc # NIL THEN DO
data: RedBlackTree.UserData;
ce: cacheEntry;
data _ RedBlackTree.LookupNextLarger[didCache, lastVDoc];
IF data = NIL THEN data _ RedBlackTree.LookupSmallest[didCache];
IF data = NIL THEN EXIT;
ce _ NARROW[data];
IF ce.users = 0 THEN {
period: INT;
IF (period _ BasicTime.Period[from: threshold, to: ce.timeOfLastVolatize]) <= 0 THEN [] _ RedBlackTree.Delete[self: didCache, deleteKey: ce.vDoc]
 ELSE {
IF period < minPeriod THEN {
minGMT _ ce.timeOfLastVolatize;
minPeriod _ period;
};
};
};
lastVDoc _ ce.vDoc;
size _ size - 1;
IF size <= desiredSizeOfDIDCache THEN EXIT;
ENDLOOP;
IF size <= desiredSizeOfDIDCache THEN threshold _ BasicTime.Update[minGMT, 2];
};
Process.Pause[ticksToWait];
IF RedBlackTree.Size[didCache] > desiredSizeOfDIDCache THEN innerTrim[];
ENDLOOP;
};
GetKeyProc: RedBlackTree.GetKey  = {  
entry: cacheEntry _ NARROW[data];
RETURN[ entry.vDoc ];
};

CompareProc: RedBlackTree.Compare = {
entryData: cacheEntry _ NARROW[data];
keyData: YggRep.VDoc _ NARROW[k];
SELECT keyData.did.didHigh FROM
> entryData.vDoc.did.didHigh => RETURN [greater];
< entryData.vDoc.did.didHigh => RETURN [less];
ENDCASE => {
SELECT keyData.did.didLow FROM
> entryData.vDoc.did.didLow => RETURN [greater];
< entryData.vDoc.did.didLow => RETURN [less];
ENDCASE => {
SELECT keyData.tid.top.nodeId.value FROM
> entryData.vDoc.tid.top.nodeId.value => RETURN [greater];
< entryData.vDoc.tid.top.nodeId.value => RETURN [less];
ENDCASE => {
SELECT keyData.tid.top.highTicker FROM
> entryData.vDoc.tid.top.highTicker => RETURN [greater];
< entryData.vDoc.tid.top.highTicker => RETURN [less];
ENDCASE => {
SELECT keyData.tid.top.lowTicker FROM
> entryData.vDoc.tid.top.lowTicker => RETURN [greater];
< entryData.vDoc.tid.top.lowTicker => RETURN [less];
ENDCASE => RETURN [equal];
};
};
};
};
};
didCache _ RedBlackTree.Create[getKey: GetKeyProc, compare: CompareProc];
TRUSTED {
mcp: LONG POINTER TO CONDITION _ @myCondition;
Process.Detach[FORK DIDCacheTrimProcess];
Process.Detach[FORK TickerProcess];
Process.SetTimeout[condition: mcp, ticks: Process.MsecToTicks[157]];
mcp _ @latchCondition;
Process.SetTimeout[condition: mcp, ticks: Process.MsecToTicks[250]];
};

END.
ΒYggVolatilizeImpl.mesa
Copyright Σ 1988 by Xerox Corporation.  All rights reserved.
Bob Hagmann October 27, 1988 1:09:48 pm PDT

This module converts documents from stable to volatile forms.

Exported conversion procedures
Given a DID, return the volatile form of the document it refers to.  If metaAttributesOnly is TRUE, then the transID must be null.
read an int from the attributes stream
read a null terminated string from the attributes stream
Check to be sure that the value is a singleton value of a singleton set
Make sure the list of links is all to DID's, and build up the outlinks value
Make sure the list of links is all to DID's, and build up the inlinks value


Cache management utilities
Set a short term latch.


Remove a short term latch.

Given a DID, transaction, and lock mode, return the volatile form of the document if it is cached.  If the object is reserved, block until this is over.
For readers, the VDoc for this transaction or the nearest parent transaction is returned (or for the null transaction).
For writers, the cached VDoc must match both the did and tid.  If any object with the proper did exists, a new object is constructed with the did and tid from a deep copy of the nearest parent transaction.  Otherwise, NIL is returned.
copy attributes


Given a DID and a transaction, reserve this DID as being volatized.  Calling this procedure obligates the caller to call CacheDID to clear the reservation.


Undo a reservation.


Add this document to the cache for the did.


Remove this did from the cache.

Remove this did from the cache.

Cache trim
Internal red black procs
PROC [data: UserData] RETURNS [Key]
PROC [k: Key, data: UserData] RETURNS [Basics.Comparison]
Initialization


ΚΖ˜
code•Mark
outsideHeaderš
œ™Kš
œ<™<Kš
œ+™+—K™K™=K™š
Οk	˜	Kšœœ˜Kšœ
œœ ˜4Kšœœ˜Kšœ
œ#œ˜CKšœœ˜Kšœœ1˜>Jšœ
œ~˜
Kšœœ!˜.Kšœœ œ˜0Kšœœœ˜Kšœœ
˜Kšœ
œ*˜9Kšœœ<˜PKšœœ"˜5Kšœœ˜2Kšœœ˜)Kšœœ˜(Kšœœ˜2Kšœœƒ˜KšœœB˜VKš
œ˜—K˜KšΡblnΠbl
œ
œ
˜ Kšœ
œ‚
˜—
Kšœ'˜.šœ˜K˜Kšœœœ
˜K˜Kšœœ˜K˜Kš
œ˜Icode2šœœ˜ K˜Kšœœœ˜%šœœœ˜Kšœœ˜Kšœœ˜6Kšœ˜K˜—Kšœ
	œ
˜Kšœ	œ
˜K˜Kšœœœ˜Kšœœ
œ˜+K˜K˜%K˜K˜—
head™šΟnœœ
œ/œ]œœœ˜Φ
Kšœœw™‚
šΟbœœœ
œœtœœ
œ0œ
œ"˜’š‘œœ
œœ˜$K™&Kšœœ˜Kšœœ
œ
˜Kšœœ
œ˜Kš
œœœœ
œ˜VKš
œ
œ
œœ
œ
˜%Kšœ˜Kš
œ˜—š‘
œœœœ
œœ˜BK™8Kšœœœ
˜Kšœœ˜Kšœœ#˜5Kš	œ
œ
œœ
œ
˜>Jšœ	œ
œ*˜;Kš	œœ
œœ
œ˜@šœ˜Kšœœ˜Kšœœœ#˜_Kšœœ
œ
˜(šœ	œ
œ˜(Kšœœœœ˜8Kš
œ*˜*Kš
œ ˜ šœ œ˜(Kš
œ˜Kš
œX˜XKš
œ˜K˜—Kšœ
˜—Kš
œ%˜%Kšœ
˜—šœœ˜Kš
œ˜Kš
œX˜XK˜—Kš
œ ˜ Kš
œ˜—Kšœœœ
˜!Kš
œ2˜2Kš
œ˜šœΟc˜Kšœœœ’˜.Kšœœ
œœ’˜HKšœœ
œœ’˜LKšœœ˜!Kšœœ
˜Kš
œ'˜'Kšœœ
˜šœœœ˜CKšœœ
˜Kšœ
˜	Kš
œ˜—Kšœ’"˜)Kšœœ
œ
˜ Kšœœ˜"šœœ˜,Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ0˜0Kšœ˜—Kšœ ’˜7šœœ˜&Kš
œ$˜$K˜—š	œ	œ
œœ’%˜YKšœœœ
˜Kšœ
œ
œ œ’˜PKšœœ
œ œ’˜Tšœœ˜ Kšœ’˜/K˜—šœ
’<˜?K˜šœœ˜&K˜K˜—šœ˜Kšœœ
˜š
œ˜Kšœœ
˜	Kšœœ
œ
˜Kš
œ˜Kšœœ
œ˜K˜K˜—š
œ˜Kšœœ
˜Kš
œ˜Kš
œ˜K˜—š
œ˜Kšœœ
˜	Kšœœ
˜Kšœœ
˜Kšœœ
˜Kšœ	œ
œ
˜Kš
œ˜Kš
œ[˜[Kš
œ+˜+Kšœœœ
œ
œœ
œ˜vKšœœ
œ
˜$Kš
œ˜Kš
œ9˜9Kš
œ˜K˜—š
œ˜Kšœœ
œ
˜Kšœœ
œ˜šœ˜	Kšœœ
˜Kšœœ
œ
œ
˜Kšœ	œ˜Kšœœœœ˜PKšœœœ
œ
˜(Kš
œ˜—Kš
œ˜Kš
œ˜—š
œ˜Kš
œ!˜!Kšœœ˜*šœ˜	Kšœœ
˜Kšœœ
œ˜.Kšœ	œ˜ Kšœœœ-˜`Kšœ+œ
œ
˜8Kš
œ˜—Kš
œ˜Kš
œ˜—š
œ˜Kšœœ
˜
Kšœœ	˜šœ˜	Kšœœ
˜Kšœœ
œ˜Kšœœ˜Kšœœœœ˜OKšœ
œ	œ
œ
˜(Kš
œ˜—Kš
œ˜Kš
œ˜—šœ˜Kšœœ
˜Kš	œ
œ
œœ
œ
˜9Kšœœ
˜	Kšœœ
˜Kšœ
œ
˜Kšœœ˜Kš
œ˜Kš
œ[˜[Kšœœ˜!Kš
œ˜šœ˜	Kšœœ
œ˜'Kšœ	œ˜Kšœœœ	œ'˜oKšœœ
œ
˜Kš
œ˜—Kš
œ˜šœœ
œ˜!Kš	œœ
œœ
œ˜;Kšœœœ˜MKšœœ
œ
˜&Kš
œ˜—Kš
œ˜K˜——Kš
œœ
œœœ
˜VKšœ
œ%œœ˜QKšœœ
œ
˜%Kšœ’<˜F—Kš
œœ
œ'œœ
˜cKšœ
œ1œœ˜XKšœ’˜%—šœ
œ
˜šœ4œ˜GK™GKšœœ
œ
œ
˜#Kšœ!œ
œ
œ
˜2Kšœœ
œ
œ
˜(Kšœ!œ
œ
œ
˜2Kšœ&œ
œ
œ
˜7Kš
œ8˜8K˜—šœ4œ
œ˜GK™Lšœœ
œ7œœ
˜cšœœ
œAœœ
˜aKšœœ
œ
˜,Kšœ
˜—Kšœ
˜—Kš
œ#˜#K˜—šœ3œ
œ˜FK™Kšœœ
œ7œœ
˜cšœœ
œAœœ
˜aKšœœ
œ
˜,Kšœ
˜—Kšœ
˜—Kš
œ"˜"K˜—šœ˜Kš
œœ
œ%œ4œ
˜|Kšœ
œ/œ4œ˜rK˜——Kšœ’˜—K˜—K˜Kšœœ
œœ
˜,Kšœ	œ
˜Kšœœ
˜ Kšœœ
œ˜/K˜šœœ˜˜Kš
œ˜Kš
œ˜K˜K˜šœ’-˜DKšœ	œ%˜2šœ4œ
˜>š
œ	˜	Kšœ
’˜%Jš
œ+˜+J˜J˜J˜Jš
œ˜J˜——J˜
—Kš
œ˜—K˜—Kšœ6œ
œ
œ
˜HKš
œ ˜ Kš
œ2˜2Kš
œ2˜2Jš
œz˜zš
œ˜Jšœœ.˜3Jš
œ˜—Jš
œ~˜~šœœ
œ˜Jšœ
œœ
œ	˜5Jš
œ˜—Jš
œr˜rKšœœ˜Kš
œ˜Kšœœœœ	˜Lšœœ
œ˜Kšœœ
œœ
˜.KšœCœ˜HKšœœ
œ˜7Kšœœ
œ˜6Kš
œf˜fšœ&œœ˜3Kšœœ
œ
œ
˜Kš
œ"˜"K˜—Kš
œ ˜ Kš
œ"˜"Kš
œ ˜ K˜—šœœ
œ˜Kšœœ
œœ
˜.KšœCœ˜HKš
œ;˜;Kšœ&œœ
œ
˜8Kš
œ$˜$K˜—šœœ
œ˜Kšœœ˜Kšœœ
˜
Kšœœ
˜Kšœœ˜Kš
œ#˜#Kš
œ(˜(Kšœœ˜*Jš
œ!˜!Kšœœ˜6Kš
œ˜šœ˜Kšœœ
˜Kš
œ ˜ šœ˜	Kšœœ
˜Kšœœœ˜RKšœœ(˜?Kšœ
œ4˜CKš
œ˜—Kš
œ#˜#Kš
œ-˜-Kšœ
˜—K˜—Kšœœ:˜RKš
œ[˜[Kš
œ˜˜K™—š
œ˜K™———™š 	œœ
œ
œœœœœ˜fK™K˜Kš
œœ
œ
œ
œ˜!šœ˜Kšœœ
œ
œ˜Kšœ˜Kšœ
˜—Kšœœ
˜K˜K™K™—š œœ
œ
œœœœ˜VK™K˜Kš
œœœœœ˜;Kš	œ˜K˜K™—Kšœ'œ˜;K˜š œœ
œ
œœBœœ˜”
KšœΠksœ
™˜
Kš
œw™wKšœΪ
œ
™κ
K˜Kšœœ
˜	Kš
œ˜š
˜Kšœœœ
˜Kšœ$’+˜OKš
œ"˜"Kš
œN˜Nšœœ
œ˜K˜Kšœœ
œ˜Kšœœ
˜Kšœœ˜Kš
œ˜Kšœœœœ˜2Kšœ
œ
œ
˜'šœ)œ

˜1Kšœ
œ:˜MKšœ
˜K˜—šœœ˜Kš
œ	˜	Kš
œ
˜
Kšœœ˜!Kšœœ
˜Kšœœ’!˜3Kšœ˜—š
œ˜K™—šœœ
œ3œœ
˜SKšœœ
œœ
˜EKšœ
œœ ˜7Kšœ
˜—Kš
œ4˜4š
œ!˜!Kšœœ
˜Kš
œY˜YKš
œ[˜[Kš
œa˜aKš
œ~˜~Kš
œO˜O—Kš
œ&˜&KšœVœ"˜{Kšœ
œ:˜MKšœ˜
K˜—Kšœ!œ
œ
˜-Kš
œ2˜2Kšœ
œ
œ
˜Kšœ
˜—˜K™K™——š
 œœ
œ
œœ&˜TKšœœ!œl™›
K˜Kšœœ
˜	Kš
œ"˜"Kš
œ&˜&Kš
œN˜Nšœœ
œ˜K˜Kšœœ˜Kšœœ
œœ
˜3Kš
œ˜K˜
—šœ
œ˜KšœVœœ/˜₯
Kš
œ˜—K˜K™K™—š œœ

œœ$˜VKš
œ™K˜Kšœœ
˜	Kš
œ"˜"Kš
œ&˜&Kš
œN˜Nšœœ
œ˜K˜Kšœœ˜Kš
œ˜Kš
œ˜Kš	œ
˜K˜
—Kšœ
œ
œ
˜K˜K™K™—š œœ

œœ9˜^Kš
œ+™+K˜Kšœœ
˜	Kš
œ"˜"Kš
œ&˜&Kš
œN˜Nšœœ
œ˜K˜Kšœœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš	œ
˜K˜
—šœ
œ˜KšœCœ"˜hK˜—K˜K™K™—š 
œœ

œœ$˜PKš
œ™K˜Kšœœ
˜	Kš
œ"˜"Kš
œ&˜&Kš
œN˜Nšœœ
œ˜K˜Kšœ!œ
˜%Kšœœ˜Kšœœ
œœ
˜3Kšœ$’ ˜DKš
œ&˜&Kš
œV˜VKšœœ
˜K˜—K˜K™—š
 œœ
œ
œœ&˜YK˜Kšœœ
˜	Kšœœ
˜Kšœœ	˜Kš
œ"˜"Kš
œ"˜"Kš
œ&˜&Kš
œN˜Nšœœ
œ˜K˜Kšœœ˜Kš
œ<˜<Kšœ
œ
œ
˜Kš
œ(˜(Kš
œT˜Tšœ
œ
œ˜K˜Kšœ!œ
˜%Kšœœ˜ Kš
œ&˜&Kš
œV˜VKšœœ
˜Kš
œ˜Kš
œ!˜!šœ$œ
œ˜0Kšœ*œ
œJ˜~šœ˜Kšœœ
œœ
˜,šœœ
œNœ	œ
˜tKš
œ
˜
Kšœ
˜—Kš
œ-˜-K˜—K˜—K˜
—šœ
œ’˜Kš
œ˜Kš
œ˜Kš
œ&˜&Kš
œO˜OKšœœ
œ
œ
˜Kš
œ ˜ Kš
œ!˜!Kš
œ(˜(Kš
œ`˜`K˜—K˜—K˜K˜—š œœœ˜4Kš
œ™K˜Kš
œ˜K˜—K™—™
š 
œœ˜Lš
œ˜Lš
œ(˜(š
˜Lš
œ˜L˜Lšœ
˜—L˜L˜—š œœ˜Lš
œ˜Lšœœ
˜Lšœœ˜+Lš
œ'˜'š
˜š‘	œœ
œ˜Kšœ
œ˜Lšœœ
˜"Lš
œ˜Lšœœ
˜
Lš
œ#˜#šœœ
œ˜Lš
œ˜Lš
œ-˜-šœœ
œ˜L˜Lšœœ˜Lš
œ˜L˜—L˜—šœœ
œ
˜Lš
œ˜L˜Lš
œ9˜9Lšœœ
œ.˜@Lšœœ
œ
œ
˜Lšœœ˜šœœ˜L˜Lš
œ‘
˜‘
˜š
œ˜Lš
œ˜Lš
œ˜L˜—L˜—L˜—Lš
œ˜Lš
œ˜Lšœœ
œ
˜+Lšœ
˜—Lšœœ)˜NLš
œ˜—Lš
œ˜Lšœ5œ
˜HLšœ
˜—Lš
œ˜——š
œ™š 
œ˜&Jšœœ™#Jšœœ˜!Jšœ˜J˜J˜—•StartOfExpansion[]š œ˜%Jšœœ™9Jšœœ˜%Jšœœ˜!šœ˜Jšœ œ˜1Jšœ œ˜.šœ˜šœ˜Jšœœ˜0Jšœœ˜-šœ˜šœ˜(Jšœ)œ˜:Jšœ)œ˜7šœ˜šœ˜&Jšœ'œ˜8Jšœ'œ˜5šœ˜šœ˜%Jšœ&œ˜7Jšœ&œ˜4Jšœœ	˜—J˜——J˜——J˜——J˜——J˜——™Kš
œI˜Išœ˜	Lš	œœ
œ
œ
	œ˜.Lšœœ˜)Lšœœ˜#Lš
œD˜DLš
œ˜Lš
œD˜DLš
œ˜K™K™——K˜Kšœ
˜—…—Yμ|t