DIRECTORY
Basics USING [LongNumber],
BufferDefs USING [defaultDataWordsPerSystemBuffer, BufferAccessHandle, BufferAccessObject, BufferFunction, BufferType, Buffer, PupBuffer, OisBuffer, SppBuffer, BufferObject, Queue, QueueObject, wordsPerNonVarientBufferOverhead],
CommFlags USING [doDebug, doStats],
CommUtilDefs USING [AllocateBuffers, FreeBuffers, AllocateIocb, FreeIocb, GetReturnFrame, MaybeShorten],
DriverDefs USING [Glitch, GetGiantVector, Network],
DriverTypes USING [bufferSeal, bufferPoolSeal, queueSeal],
PrincOpsUtils USING [BITAND, LowHalf],
OISCP USING [],
OISCPTypes USING [BufferBody, wordPerPktHeader, wordsPerLevel2SppHeader],
Process USING [InitializeCondition, MsecToTicks],
PupDefs USING [],
StatsDefs USING [StatBump, StatIncr],
ProcessorFace USING [GetClockPulses, microsecondsPerHundredPulses];

BufferMgr: MONITOR
IMPORTS CommUtilDefs, DriverDefs, PrincOpsUtils, Process, StatsDefs, ProcessorFace
EXPORTS BufferDefs, DriverDefs, OISCP, PupDefs
SHARES BufferDefs =
BEGIN OPEN BufferDefs, DriverDefs;

Network: PUBLIC TYPE = DriverDefs.Network;

accessHandleChainHead: BufferDefs.BufferAccessHandle _ NIL;
systemAccessHandle: PUBLIC BufferDefs.BufferAccessHandle _ NIL;
systemFreeQueueNotEmpty: CONDITION;
systemBufferQueue: Queue;
systemDataWordsPerBuffer: CARDINAL _ MAX[defaultDataWordsPerSystemBuffer, 271]; -- The 271 ensures that the raw buffers are big enough to hold a maximum-size ARPA IP packet (576 bytes plus 8 bytes of encapsulation). The constant was determined empirically; its computation is to disgusting to describe cleanly.
systemBufferSize: CARDINAL _ 0;
useCount: CARDINAL _ 0;
wordsPerIocb: CARDINAL _ 0;
totalSendAndReceiveBuffers: CARDINAL _ 0;
totalSendAndReceiveBuffersInUse: CARDINAL _ 0;
totalReserveBuffers: CARDINAL _ 0;
inactivePools: CARDINAL _ 0;
enqueue: PROCEDURE [Queue, Buffer] _ Enqueue;


rawOverhead: CARDINAL = BufferDefs.wordsPerNonVarientBufferOverhead;
oisOverhead: CARDINAL = rawOverhead + OISCPTypes.wordPerPktHeader;
sppOisOverhead: CARDINAL = oisOverhead + OISCPTypes.wordsPerLevel2SppHeader;
pupOverhead: CARDINAL = SIZE[pupWords pup BufferDefs.BufferObject] + 1;
overhead: CARDINAL = MAX[
pupOverhead,
oisOverhead,
sppOisOverhead];

QueueSealBroken: PUBLIC ERROR = CODE;
PoolSealBroken: PUBLIC ERROR = CODE;
BufferSealBroken: PUBLIC ERROR = CODE;
FreeQueueNotInitialized: PUBLIC ERROR = CODE;
BufferPoolNotInitialized: PUBLIC ERROR = CODE;
QueueScrambled: PUBLIC ERROR = CODE;
CantResetWhileActive: PUBLIC ERROR = CODE;
SystemBufferSizeConfused: PUBLIC ERROR = CODE;
DontKnowHowToAllocateBuffer: PUBLIC ERROR = CODE;


AdjustBufferSize: PUBLIC ENTRY PROCEDURE [bufferSize: CARDINAL] =
BEGIN
IF useCount # 0 THEN Glitch[CantResetWhileActive];
IF bufferSize # 0 THEN systemDataWordsPerBuffer _ bufferSize;
systemBufferSize _ 0;
END;

GetBufferSize: PUBLIC PROCEDURE RETURNS [bufferSize: CARDINAL] =
BEGIN RETURN[systemDataWordsPerBuffer]; END;

GetWordsPerIocb: PUBLIC PROCEDURE RETURNS [CARDINAL] =
BEGIN RETURN[wordsPerIocb]; END;

SetWordsPerIocb: PUBLIC PROCEDURE [new: CARDINAL] =
BEGIN wordsPerIocb _ new; END;


MakeBufferPool: PUBLIC ENTRY PROCEDURE [
total: CARDINAL, -- number of new buffer that will actually be created   
send: CARDINAL,
receive: CARDINAL,
reserve: CARDINAL,
forSystemUse: BOOLEAN] -- as opposed to for socket use 
RETURNS [p: BufferAccessHandle] =
BEGIN
b: Buffer;
x: --SHORT--POINTER TO BufferObject = NIL;
i: CARDINAL;
newSystemBufferSize: CARDINAL;
IF NOT forSystemUse THEN
BEGIN
totalSendAndReceiveBuffers _ totalSendAndReceiveBuffers + send + receive;
END;
totalReserveBuffers _ totalReserveBuffers + reserve;
useCount _ useCount + 1;
p _ NEW[BufferAccessObject];
p.seal _ DriverTypes.bufferPoolSeal;
p.active _ TRUE;
p.madeForSystem _ forSystemUse;
p.filler _ 0;
p.total _ total;
p.sendInUse _ p.receiveInUse _ p.recovered _ 0;
p.send _ send;
p.receive _ receive;
p.reserve _ reserve;
p.next _ accessHandleChainHead;
accessHandleChainHead _ p;
IF CommFlags.doDebug THEN DriverDefs.GetGiantVector[].firstBufferAccessHandle _ accessHandleChainHead;
Process.InitializeCondition[
CommUtilDefs.MaybeShorten[@p.bufferAvailable], Process.MsecToTicks[10000]];
IF p.total = 0 THEN
BEGIN
p.firstBuffer _ LOOPHOLE[p];
RETURN;
END;
p.wordsPerBuffer _ systemDataWordsPerBuffer + overhead + 2 + 4 + 3;
UNTIL PrincOpsUtils.BITAND[p.wordsPerBuffer, 3] = 0 DO
p.wordsPerBuffer _ p.wordsPerBuffer + 1; ENDLOOP;
newSystemBufferSize _
p.wordsPerBuffer - (@x.encapsulation - LOOPHOLE[x, POINTER]);
IF systemBufferSize = 0 THEN systemBufferSize _ newSystemBufferSize
ELSE
IF newSystemBufferSize # systemBufferSize THEN
Glitch[SystemBufferSizeConfused];
p.firstBuffer _ CommUtilDefs.AllocateBuffers[p.wordsPerBuffer*total + 3];
DO
c: CARDINAL _ LOOPHOLE[PrincOpsUtils.LowHalf[@p.firstBuffer.encapsulation]];
IF PrincOpsUtils.BITAND[c, 3] = 3 THEN EXIT;
p.firstBuffer _ p.firstBuffer + 1;
ENDLOOP;
b _ p.firstBuffer;
FOR i IN [0..total) DO
b.iocbChain _ NIL;
b.allNets _ b.bypassZeroNet _ FALSE;
b.type _ raw;
b.pupLength _ b.length _ 0;
b.pupType _ last;
b.queue _ NIL;
b.pool _ p;
b.next _ NIL;
IF CommFlags.doDebug THEN b.seal _ DriverTypes.bufferSeal;
b.requeueProcedure _ ReturnFreeBuffer;
Enqueue[systemBufferQueue, b];
b _ b + p.wordsPerBuffer;
ENDLOOP;
IF wordsPerIocb # 0 THEN
BEGIN
b _ p.firstBuffer;
FOR i IN [0..total) DO
b.iocbChain _ CommUtilDefs.AllocateIocb[wordsPerIocb];
b _ b + p.wordsPerBuffer;
ENDLOOP;
END;
END;

DestroyBufferPoolLocked: PROCEDURE [p: BufferAccessHandle] =
BEGIN
IF CommFlags.doDebug THEN
BEGIN
b: Buffer _ p.firstBuffer;
FOR i: CARDINAL IN [0..p.total) DO
IF b.queue # NIL THEN Glitch[QueueScrambled];
b _ b + p.wordsPerBuffer;
ENDLOOP;
END;
IF p.total # 0 THEN
BEGIN
b: Buffer _ p.firstBuffer;
FOR i: CARDINAL IN [0..p.total) DO
IF b.iocbChain # NIL THEN CommUtilDefs.FreeIocb[b.iocbChain];
b _ b + p.wordsPerBuffer;
ENDLOOP;
CommUtilDefs.FreeBuffers[p.firstBuffer, p.wordsPerBuffer*p.total + 3];
END;
IF NOT p.madeForSystem THEN
totalSendAndReceiveBuffers _
totalSendAndReceiveBuffers - (p.send + p.receive - p.total);
p.firstBuffer _ NIL;
IF accessHandleChainHead=p THEN
BEGIN
accessHandleChainHead _ p.next;
IF CommFlags.doDebug THEN DriverDefs.GetGiantVector[].firstBufferAccessHandle _ accessHandleChainHead;
END
ELSE
BEGIN
prev: BufferDefs.BufferAccessHandle _ accessHandleChainHead;
WHILE (prev#NIL) AND (prev.next#p) DO
prev _ prev.next;
ENDLOOP;
IF prev=NIL THEN ERROR;
prev.next _ p.next;
END;
p.next _ NIL;
useCount _ useCount - 1;
IF (inactivePools _ inactivePools - 1) = 0 AND enqueue =
EnqueueActiveBuffersOnly THEN
BEGIN
IF CommFlags.doStats THEN
StatsDefs.StatBump[statRecyclingZombieBuffersTime, LOOPHOLE[((ProcessorFace.GetClockPulses[]-startReCyclingTime+50)/100)*ProcessorFace.microsecondsPerHundredPulses, Basics.LongNumber].lowbits];
enqueue _ Enqueue;
END;
END;

startReCyclingTime: LONG CARDINAL --Pulses--;

FreeBufferPool: PUBLIC ENTRY PROCEDURE [p: BufferAccessHandle] =
BEGIN
b: Buffer _ p.firstBuffer;
IF CommFlags.doDebug AND (useCount = 0 OR p = NIL) THEN Glitch[FreeQueueNotInitialized];
IF CommFlags.doDebug AND p.seal # DriverTypes.bufferPoolSeal THEN
Glitch[PoolSealBroken];
IF CommFlags.doDebug AND p.firstBuffer = NIL THEN Glitch[BufferPoolNotInitialized];
IF NOT p.madeForSystem THEN
BEGIN
WHILE p.sendInUse>0 DO
WAIT systemFreeQueueNotEmpty;  -- any short CV will do
ENDLOOP;
END;
p.active _ FALSE;
inactivePools _ inactivePools + 1;
totalReserveBuffers _ totalReserveBuffers - p.reserve;
p.recovered _ 0;
FOR i: CARDINAL IN [0..p.total) DO
IF b.queue = systemBufferQueue THEN
BEGIN
p.recovered _ p.recovered + 1;
IF NOT p.madeForSystem THEN
totalSendAndReceiveBuffers _ totalSendAndReceiveBuffers - 1;
IF ExtractFromQueue[systemBufferQueue, b] # b THEN Glitch[QueueScrambled];
END;
b _ b + p.wordsPerBuffer;
ENDLOOP;
IF p.recovered = p.total THEN
DestroyBufferPoolLocked[p]  -- all buffers recovered, so destroy pool.
ELSE
BEGIN
IF CommFlags.doStats AND enqueue # EnqueueActiveBuffersOnly THEN
startReCyclingTime _ ProcessorFace.GetClockPulses[];
enqueue _ EnqueueActiveBuffersOnly; -- continue trying to recover buffers
END;
END;

EnqueueActiveBuffersOnly: PROCEDURE [q: Queue, b: Buffer] =
BEGIN
aH: BufferAccessHandle = b.pool;
IF aH.active THEN Enqueue[q, b]
ELSE
BEGIN
IF b = NIL OR b.queue # NIL THEN Glitch[QueueScrambled];
IF CommFlags.doDebug AND q.seal # DriverTypes.queueSeal THEN Glitch[QueueSealBroken];
IF CommFlags.doDebug AND b.seal # DriverTypes.bufferSeal THEN
Glitch[BufferSealBroken];
b.next _ NIL;
aH.recovered _ aH.recovered + 1;
IF NOT aH.madeForSystem THEN
totalSendAndReceiveBuffers _ totalSendAndReceiveBuffers - 1;
IF aH.recovered = aH.total THEN DestroyBufferPoolLocked[aH];
END;
END;



DataWordsPerPupBuffer: PUBLIC SAFE PROCEDURE RETURNS [CARDINAL] =
CHECKED BEGIN RETURN[systemDataWordsPerBuffer + (overhead - pupOverhead)]; END;


DataWordsPerRawBuffer: PUBLIC PROCEDURE RETURNS [CARDINAL] =
BEGIN RETURN[systemDataWordsPerBuffer + (overhead - rawOverhead)]; END;


DataWordsPerOisBuffer: PUBLIC PROCEDURE RETURNS [CARDINAL] =
BEGIN
RETURN[systemDataWordsPerBuffer + (overhead - oisOverhead)];
END;


DataWordsPerSppBuffer: PUBLIC PROCEDURE RETURNS [CARDINAL] =
BEGIN
RETURN[systemDataWordsPerBuffer + (overhead - sppOisOverhead)];
END;


SendAndReceiveBuffersInFreeQueue: PROCEDURE RETURNS [CARDINAL] = INLINE
BEGIN
RETURN[
IF totalSendAndReceiveBuffersInUse >= totalSendAndReceiveBuffers THEN 0
ELSE totalSendAndReceiveBuffers - totalSendAndReceiveBuffersInUse];
END;


GetInputBuffer: PUBLIC ENTRY PROCEDURE [tryToWaitForBuffer: BOOLEAN]
RETURNS [b: Buffer _ NIL] =
BEGIN
IF CommFlags.doDebug AND useCount = 0 THEN Glitch[FreeQueueNotInitialized];
FOR i: CARDINAL IN [0..2) DO
IF systemBufferQueue.length > 0 THEN
BEGIN
b _ Dequeue[systemBufferQueue];
b.currentOwner _ systemAccessHandle;
b.bufFunc _ systemUse;
b.length _ systemBufferSize;
b.type _ raw;
IF CommFlags.doDebug THEN b.debug _ CommUtilDefs.GetReturnFrame[].accesslink;
RETURN;
END;
IF (~tryToWaitForBuffer) OR (i > 0) THEN RETURN;
WAIT systemFreeQueueNotEmpty;
ENDLOOP;
END;

FillInBufferTypeInformation: PROCEDURE [
b: Buffer, bufType: BufferType, bufFunc: BufferFunction] = INLINE
BEGIN
b.bufFunc _ bufFunc;
SELECT bufType FROM
oisSpp =>
BEGIN
sppBuf: LONG POINTER TO spp OISCPTypes.BufferBody = LOOPHOLE[b+rawOverhead];
sppBuf.systemPacket _ sppBuf.sendAck _ sppBuf.attention _ sppBuf.endOfMessage _ FALSE;
bufType _ ois;
END;
pup => b.pupType _ data;
ENDCASE => NULL;
b.type _ bufType;
END;

GetFreeBuffer: PUBLIC ENTRY PROCEDURE [
bufType: BufferType, aH: BufferAccessHandle, bufFunc: BufferFunction]
RETURNS [b: Buffer] =
BEGIN
ENABLE UNWIND => NULL;
IF CommFlags.doDebug AND useCount = 0 THEN Glitch[FreeQueueNotInitialized];
IF CommFlags.doDebug AND aH.seal # DriverTypes.bufferPoolSeal THEN
Glitch[PoolSealBroken];
IF CommFlags.doDebug AND aH.firstBuffer = NIL THEN Glitch[BufferPoolNotInitialized];
IF aH = systemAccessHandle THEN
BEGIN
IF CommFlags.doDebug AND bufFunc # systemUse THEN Glitch[DontKnowHowToAllocateBuffer];
IF CommFlags.doStats AND ~systemBufferQueue.length >
totalReserveBuffers + SendAndReceiveBuffersInFreeQueue[] THEN
StatsDefs.StatIncr[statBufferWaits];
UNTIL systemBufferQueue.length >
totalReserveBuffers + SendAndReceiveBuffersInFreeQueue[] DO
WAIT systemFreeQueueNotEmpty; ENDLOOP;
END
ELSE
BEGIN
sendOrReceiveInUse: LONG POINTER TO CARDINAL;
sendOrReceive: CARDINAL;
SELECT bufFunc FROM
send =>
BEGIN sendOrReceiveInUse _ @aH.sendInUse; sendOrReceive _ aH.send; END;
receive =>
BEGIN
sendOrReceiveInUse _ @aH.receiveInUse;
sendOrReceive _ aH.receive;
END;
ENDCASE => Glitch[DontKnowHowToAllocateBuffer];
IF CommFlags.doStats AND
(~sendOrReceiveInUse^ < sendOrReceive OR systemBufferQueue.length = 0)
THEN StatsDefs.StatIncr[statBufferWaits];
UNTIL (sendOrReceiveInUse^ < sendOrReceive) DO
WAIT aH.bufferAvailable; ENDLOOP;
sendOrReceiveInUse^ _ sendOrReceiveInUse^ + 1;
totalSendAndReceiveBuffersInUse _ totalSendAndReceiveBuffersInUse + 1;
UNTIL (systemBufferQueue.length > 0) DO
WAIT systemFreeQueueNotEmpty; ENDLOOP;
END;
b _ Dequeue[systemBufferQueue];
IF CommFlags.doDebug AND b = NIL THEN Glitch[QueueScrambled];
FillInBufferTypeInformation[b, bufType, bufFunc];
b.currentOwner _ aH;
IF CommFlags.doDebug THEN b.debug _ CommUtilDefs.GetReturnFrame[].accesslink;
END;


MaybeGetFreeBuffer: PUBLIC ENTRY PROCEDURE [
bufType: BufferType, aH: BufferAccessHandle, bufFunc: BufferFunction]
RETURNS [b: Buffer] =
BEGIN
IF CommFlags.doDebug AND useCount = 0 THEN Glitch[FreeQueueNotInitialized];
IF CommFlags.doDebug AND aH.seal # DriverTypes.bufferPoolSeal THEN
Glitch[PoolSealBroken];
IF CommFlags.doDebug AND aH.firstBuffer = NIL THEN Glitch[BufferPoolNotInitialized];
IF aH = systemAccessHandle THEN
BEGIN
IF ~systemBufferQueue.length > SendAndReceiveBuffersInFreeQueue[] THEN
BEGIN
b _ NIL;
IF CommFlags.doStats THEN StatsDefs.StatIncr[statBufferWaits];
RETURN;
END;
IF CommFlags.doDebug AND bufFunc # systemUse THEN Glitch[DontKnowHowToAllocateBuffer];
END
ELSE
BEGIN
sendOrReceiveInUse: LONG POINTER TO CARDINAL;
sendOrReceive: CARDINAL;
SELECT bufFunc FROM
send =>
BEGIN sendOrReceiveInUse _ @aH.sendInUse; sendOrReceive _ aH.send; END;
receive =>
BEGIN
sendOrReceiveInUse _ @aH.receiveInUse;
sendOrReceive _ aH.receive;
END;
ENDCASE => Glitch[DontKnowHowToAllocateBuffer];
IF (~sendOrReceiveInUse^ < sendOrReceive) OR (systemBufferQueue.length = 0)
THEN
BEGIN
b _ NIL;
IF CommFlags.doStats THEN StatsDefs.StatIncr[statBufferWaits];
RETURN;
END;
sendOrReceiveInUse^ _ sendOrReceiveInUse^ + 1;
totalSendAndReceiveBuffersInUse _ totalSendAndReceiveBuffersInUse + 1;
END;
IF (b _ Dequeue[systemBufferQueue]) = NIL THEN Glitch[QueueScrambled];
FillInBufferTypeInformation[b, bufType, bufFunc];
b.currentOwner _ aH;
IF CommFlags.doDebug THEN b.debug _ CommUtilDefs.GetReturnFrame[].accesslink;
END;


CreditReceiveOisBuffer: PUBLIC ENTRY PROCEDURE [
aH: BufferAccessHandle, b: OisBuffer] RETURNS [gotCreadit: BOOLEAN] =
BEGIN
IF CommFlags.doDebug AND (aH = NIL OR aH.firstBuffer = NIL) THEN
Glitch[BufferPoolNotInitialized];
IF CommFlags.doDebug AND aH.seal # DriverTypes.bufferPoolSeal THEN
Glitch[PoolSealBroken];
IF (gotCreadit _ aH.receiveInUse < aH.receive) THEN
BEGIN
aH.receiveInUse _ aH.receiveInUse + 1;
totalSendAndReceiveBuffersInUse _ totalSendAndReceiveBuffersInUse + 1;
b.currentOwner _ aH;
b.bufFunc _ receive;
END
ELSE
IF CommFlags.doStats THEN StatsDefs.StatIncr[statBufferWaits];
END;

NILNetwork: PROCEDURE RETURNS [Network] = INLINE {RETURN[NIL]};

ReturnFreePupBuffer: PUBLIC PROCEDURE [PupBuffer] = LOOPHOLE[ReturnFreeBuffer];
ReturnFreeOisBuffer: PUBLIC PROCEDURE [OisBuffer] = LOOPHOLE[ReturnFreeBuffer];
ReturnFreeSppBuffer: PUBLIC PROCEDURE [SppBuffer] = LOOPHOLE[ReturnFreeBuffer];
ReturnFreeBuffer: PUBLIC ENTRY PROCEDURE [b: Buffer] =
BEGIN
aH: BufferAccessHandle = b.currentOwner;
IF CommFlags.doDebug AND useCount = 0 THEN Glitch[FreeQueueNotInitialized];
IF CommFlags.doDebug AND aH.firstBuffer = NIL THEN Glitch[BufferPoolNotInitialized];
b.requeueProcedure _ ReturnFreeBuffer;
b.network _  NILNetwork[];  --  because of mokelumne compiler bug
IF aH # systemAccessHandle THEN
BEGIN
SELECT b.bufFunc FROM
send => aH.sendInUse _ aH.sendInUse - 1;
receive => aH.receiveInUse _ aH.receiveInUse - 1;
ENDCASE => Glitch[DontKnowHowToAllocateBuffer];
totalSendAndReceiveBuffersInUse _ totalSendAndReceiveBuffersInUse - 1;
BROADCAST aH.bufferAvailable;
END;
enqueue[systemBufferQueue, b];
BROADCAST systemFreeQueueNotEmpty;
END;

BuffersLeft: PUBLIC ENTRY PROCEDURE [aH: BufferAccessHandle]
RETURNS [left: CARDINAL] =
BEGIN
IF CommFlags.doDebug AND useCount = 0 THEN Glitch[FreeQueueNotInitialized];
IF CommFlags.doDebug AND aH.seal # DriverTypes.bufferPoolSeal THEN
Glitch[PoolSealBroken];
IF CommFlags.doDebug AND aH.firstBuffer = NIL THEN Glitch[BufferPoolNotInitialized];
IF aH = systemAccessHandle THEN
BEGIN
reserved: CARDINAL =
SendAndReceiveBuffersInFreeQueue[] + totalReserveBuffers;
IF CommFlags.doDebug AND useCount = 0 THEN Glitch[FreeQueueNotInitialized];
left _ systemBufferQueue.length;
left _ (IF left > reserved THEN left - reserved ELSE 0);
END
ELSE BEGIN left _ aH.send + aH.receive - aH.sendInUse - aH.receiveInUse; END;
END;

SendBuffersLeft: PUBLIC ENTRY PROCEDURE [aH: BufferAccessHandle]
RETURNS [CARDINAL] =
BEGIN
IF CommFlags.doDebug AND useCount = 0 THEN Glitch[FreeQueueNotInitialized];
IF CommFlags.doDebug AND aH.seal # DriverTypes.bufferPoolSeal THEN
Glitch[PoolSealBroken];
IF CommFlags.doDebug AND aH.firstBuffer = NIL THEN Glitch[BufferPoolNotInitialized];
RETURN[aH.send - aH.sendInUse];
END; -- SendBufferLeftInPool

ReceiveBuffersLeft: PUBLIC ENTRY PROCEDURE [aH: BufferAccessHandle]
RETURNS [CARDINAL] =
BEGIN
IF CommFlags.doDebug AND useCount = 0 THEN Glitch[FreeQueueNotInitialized];
IF CommFlags.doDebug AND aH.seal # DriverTypes.bufferPoolSeal THEN
Glitch[PoolSealBroken];
IF CommFlags.doDebug AND aH.firstBuffer = NIL THEN Glitch[BufferPoolNotInitialized];
RETURN[aH.receive - aH.receiveInUse];
END; -- ReceiveBufferLeftInPool

EnumerateBuffersInPool: PUBLIC PROCEDURE [
pool: BufferAccessHandle, proc: PROCEDURE [Buffer]] =
BEGIN
b: BufferDefs.Buffer;
IF CommFlags.doDebug AND useCount = 0 THEN Glitch[FreeQueueNotInitialized];
b _ pool.firstBuffer;
IF CommFlags.doDebug AND pool.seal # DriverTypes.bufferPoolSeal THEN
Glitch[PoolSealBroken];
FOR i: CARDINAL IN [0..pool.total) DO proc[b]; b _ b + pool.wordsPerBuffer; ENDLOOP;
END; -- EnumerateBuffersInPool


GetFreePupBuffer: PUBLIC PROCEDURE RETURNS [PupBuffer] = 
BEGIN
RETURN[
LOOPHOLE[GetFreeBuffer[pup, systemAccessHandle, systemUse], PupBuffer]];
END;

GetClumpOfPupBuffers: PUBLIC ENTRY PROCEDURE [
q: Queue, n: CARDINAL, wait: BOOLEAN] =
BEGIN
ENABLE UNWIND => NULL;
IF CommFlags.doDebug AND useCount = 0 THEN Glitch[FreeQueueNotInitialized];
IF CommFlags.doDebug AND q.seal # DriverTypes.queueSeal THEN Glitch[QueueSealBroken];
UNTIL systemBufferQueue.length >
n + SendAndReceiveBuffersInFreeQueue[] + totalReserveBuffers DO
IF ~wait THEN RETURN; WAIT systemFreeQueueNotEmpty; ENDLOOP;
THROUGH [0..n) DO
b: PupBuffer _ DequeuePup[systemBufferQueue];
b.type _ pup;
b.pupType _ data;
IF CommFlags.doDebug THEN b.debug _ CommUtilDefs.GetReturnFrame[].accesslink;
EnqueuePup[q, b];
ENDLOOP;
END;


QueueInitialize: PUBLIC PROCEDURE [q: Queue] =
BEGIN
q^ _ [length: 0, first: NIL, last: NIL, seal: DriverTypes.queueSeal];
END;


QueueCleanup: PUBLIC PROCEDURE [q: Queue] =
BEGIN
b: Buffer;
UNTIL (b _ Dequeue[q]) = NIL DO ReturnFreeBuffer[b]; ENDLOOP;
END;

ExtractPupFromQueue: PUBLIC PROCEDURE [Queue, PupBuffer] RETURNS [PupBuffer] =
LOOPHOLE[ExtractFromQueue];
ExtractOisFromQueue: PUBLIC PROCEDURE [Queue, OisBuffer] RETURNS [OisBuffer] =
LOOPHOLE[ExtractFromQueue];
ExtractSppFromQueue: PUBLIC PROCEDURE [Queue, SppBuffer] RETURNS [SppBuffer] =
LOOPHOLE[ExtractFromQueue];
ExtractFromQueue: PUBLIC PROCEDURE [q: Queue, b: Buffer] RETURNS [Buffer] =
BEGIN
previousB, currentB: Buffer;
IF q = NIL THEN Glitch[QueueScrambled];
IF CommFlags.doDebug AND q.seal # DriverTypes.queueSeal THEN Glitch[QueueSealBroken];
IF CommFlags.doDebug AND b.seal # DriverTypes.bufferSeal THEN Glitch[BufferSealBroken];
previousB _ NIL;
currentB _ q.first;
UNTIL currentB = b DO
IF currentB = NIL THEN EXIT;
previousB _ currentB;
currentB _ currentB.next;
ENDLOOP;
IF currentB # NIL THEN
BEGIN
IF CommFlags.doDebug AND currentB.seal # DriverTypes.bufferSeal THEN
Glitch[BufferSealBroken];
IF currentB = q.first THEN q.first _ currentB.next;
IF currentB = q.last THEN q.last _ previousB;
IF previousB # NIL THEN previousB.next _ currentB.next;
q.length _ q.length - 1;
currentB.queue _ NIL;
currentB.next _ NIL;
IF CommFlags.doStats THEN StatsDefs.StatIncr[statXqueue];
END
ELSE IF CommFlags.doStats THEN StatsDefs.StatIncr[statXqueueNIL];
RETURN[currentB];
END;

EnqueuePup: PUBLIC PROCEDURE [Queue, PupBuffer] = LOOPHOLE[Enqueue];
EnqueueOis: PUBLIC PROCEDURE [Queue, OisBuffer] = LOOPHOLE[Enqueue];
EnqueueSpp: PUBLIC PROCEDURE [Queue, SppBuffer] = LOOPHOLE[Enqueue];
Enqueue: PUBLIC PROCEDURE [q: Queue, b: Buffer] =
BEGIN
IF q = NIL OR b = NIL OR b.queue # NIL THEN Glitch[QueueScrambled];
IF CommFlags.doDebug AND q.seal # DriverTypes.queueSeal THEN Glitch[QueueSealBroken];
IF CommFlags.doDebug AND b.seal # DriverTypes.bufferSeal THEN Glitch[BufferSealBroken];
IF CommFlags.doDebug AND q.length # 0 AND (q.first = NIL OR q.last = NIL) THEN
Glitch[QueueScrambled];
IF CommFlags.doDebug AND q.length > 256 THEN Glitch[QueueScrambled];
b.next _ NIL;
IF CommFlags.doStats THEN StatsDefs.StatIncr[statEnqueue];
IF q.first = NIL THEN q.first _ b ELSE q.last^.next _ b;
q.last _ b;
b.queue _ q;
q.length _ q.length + 1;
END; -- Enqueue

DequeuePup: PUBLIC PROCEDURE [Queue] RETURNS [PupBuffer] = LOOPHOLE[Dequeue];
DequeueOis: PUBLIC PROCEDURE [Queue] RETURNS [OisBuffer] = LOOPHOLE[Dequeue];
DequeueSpp: PUBLIC PROCEDURE [Queue] RETURNS [SppBuffer] = LOOPHOLE[Dequeue];
Dequeue: PUBLIC PROCEDURE [q: Queue] RETURNS [b: Buffer] =
BEGIN
IF q = NIL THEN Glitch[QueueScrambled];
IF CommFlags.doDebug AND q.seal # DriverTypes.queueSeal THEN Glitch[QueueSealBroken];
IF (b _ q.first) = NIL THEN
BEGIN
IF CommFlags.doDebug AND q.length # 0 THEN Glitch[QueueScrambled];
IF CommFlags.doStats THEN StatsDefs.StatIncr[statDequeueNIL];
RETURN;
END;
IF (q.first _ q.first.next) = NIL THEN q.last _ NIL;
IF CommFlags.doDebug AND q.length > 256 THEN Glitch[QueueScrambled];
q.length _ q.length - 1;
IF CommFlags.doStats THEN StatsDefs.StatIncr[statDequeue];
IF b.queue # q THEN Glitch[QueueScrambled];
b.queue _ NIL;
b.next _ NIL;
IF CommFlags.doDebug AND b.seal # DriverTypes.bufferSeal THEN Glitch[BufferSealBroken];
IF CommFlags.doDebug AND q.length # 0 AND (q.first = NIL OR q.last = NIL) THEN
Glitch[QueueScrambled];
END; -- Dequeue


systemBufferQueue _ NEW[QueueObject];
QueueInitialize[systemBufferQueue];
Process.InitializeCondition[
CommUtilDefs.MaybeShorten[@systemFreeQueueNotEmpty], Process.MsecToTicks[
1000]];


IF CommFlags.doDebug THEN
BEGIN
GetGiantVector[].firstBuffer _ NIL;
GetGiantVector[].freeQueue _ systemBufferQueue;
END;
END.



*BufferMgr.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
BLyon on: March 19, 1981  12:37 PM
HGM on: March 17, 1981  6:32 PM
Garlick on: January 26, 1981  1:52 PM
Levin, August 9, 1983 9:27 am
Taft, February 4, 1984 2:37:41 pm PST
Russ Atkinson (RRA) February 2, 1985 3:49:15 pm PST
EXPORTed TYPEs
monitor protected data
the raw buffer data length that drivers need to know (includes encapsulation words)
Buffers and IOCB locations must be rounded up for alignment constraints.
Alto SLA Microcode needs IOCB/LCB to be EVEN.
D0 Ethernet/Xwire Microcode needs IOCB to be Quad word aligned,
and first data word to be (almost?) QUAD word aligned.
size of a buffer without any data
1 extra for pup checksum
for the Glitches
Cold Procedures
NB: wordsPerBuffer and wordsPerIocb MUST be QuadWord multiples
number of send type buffer that can be allocated from this pool (could be greater than total)   
number of receive type buffer that can be allocated from this pool (could be greater than total)   
number of send type buffer that can be allocated from this pool (could be greater than total)   
insert this accessObject into the linked list of known accessObjects
kludgy, but lets us do sanity check for nil values
2 for checksum, 4 for end test, 3 for round down
systemBufferSize is a little bigger because of the quad word allignment
This determines the buffer alignment: see DriverTypes.Encapsulation
this does NOT align each individual iocb
remove this accessObject from the linked list of known accessObjects
Heap.FreeNode[p: p]; before conversion to REFs. (ADB).
since sends are asynchronous, don't free the pool until they are completed
Cool Procedures
This is not an ENTRY procedure because we assume that systemBufferPool can
have its parameters set only once.
This is not an ENTRY procedure because we assume that systemBufferPool can
have its parameters set only once.
This is not an ENTRY procedure because we assume that systemBufferPool can
have its parameters set only once.
This is not an ENTRY procedure because we assume that systemBufferPool can
have its parameters set only once.
Hot Procedures
This routine is only used by device drivers to get buffers to read things into.
NB: b.length is setup for the size of the buffer, including ALL of the encapsulation.
All device drivers except for the XWire must fudge things themsleves, since they do
not use all of the encapsulation field.
since the drivers only use the buffers for a short time, no access control
is used in their allocation; a filled buffer will be subject to usual access control
when it is delivered;  therefore if we have a buffer the drivers can have it.
Get free buffer, but don't wait if there is none
NB: These will return the last buffer, use with caution
credits may be used to avoid copying buffers
Note: we do some "initialization" of things here since there are several ways to get
buffers from the freeQueue.
This is ugly, but there isn't any way to make things work without it, if 2
PROCESSes are waiting for buffers.
Get free buffer, but don't wait if there is none
NB: These will return the last buffer, use with caution
Queue Manipulation Routines
Put all buffers back onto buffer pool's freeQueue
remove this buffer from the queue
initialization
systemAccessHandle _ MakeBufferPool[total: 0, send: 0, receive: 0, reserve: 0, forSystemUse: TRUE];
Κ‰˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ"™"Kš
œ™Kš
œ%™%Kš
œ™Kš
œ%™%J™3—K˜š
Οk	˜	Kšœžœ˜KšœžœΤ
˜δ
Kšœ
žœ˜#Kšœ
žœV˜hKšœžœ#˜3Kšœžœ)˜:Kšœžœžœ˜&Kšžœ
žœ˜Kšœžœ9˜IKšœžœ$˜1Kšœžœ˜Kšœ
žœ˜%Kšœžœ0˜CK˜—šœž˜KšžœK˜RKšžœžœ	˜.Kšžœ
˜Kšžœ
žœ˜"K˜Kš
œ™Kšœ	žœ
žœ˜*K˜Kš
œ™Kšœ7žœ
˜;Kšœžœ!žœ
˜?Kšœž	œ
˜#K˜Kšœžœžœ(Οcζ
˜ΆKšœžœ˜Kš
œS™SKšœ
žœ˜Kšœžœ˜Kšœžœ˜)Kšœ!žœ˜.Kšœžœ˜"Kšœžœ˜Kšœ	ž	œ˜-K˜Kš
œH™HKš
œ-™-Kš
œ?™?Kš
œ6™6K˜Kš
œ!™!Kšœ
žœ/˜DKšœ
žœ-˜BKšœžœ4˜LKš
œ™Kšœ
žœžœ+˜Gšœ
žœžœ
˜K˜K˜K˜K˜—Kš
œ™Kšœžœ
žœžœ
˜%Kšœžœ
žœžœ
˜$Kšœžœ
žœžœ
˜&Kšœžœ
žœžœ
˜-Kšœžœ
žœžœ
˜.Kšœžœ
žœžœ
˜$Kšœžœ
žœžœ
˜*Kšœžœ
žœžœ
˜.Kšœžœ
žœžœ
˜1K˜Kš
œ™K˜š
Οnœžœ
žœ
ž	œžœ˜AKš
ž˜Kšžœžœ˜2Kšžœžœ'˜=K˜Kšžœ
˜K˜—š
 
œžœ
ž	œ
žœžœ˜@Kšžœ
žœžœ
˜,K˜—š
 œžœ
ž	œ
žœžœ˜6Kšžœ
žœžœ
˜ K˜—š œžœ
ž	œžœ˜3Kšžœžœ
˜K˜—Kš
œ>™>K˜š œžœ
žœ
ž	œ˜(KšœžœŸ8˜IKšœžœ
˜Kš
œ`™`Kšœ	žœ
˜Kš
œc™cKšœ	žœ
˜Kš
œ`™`šœžœŸ ˜7Kšžœ˜!—Kš
ž˜K˜
KšœŸ	žœ
žœžœ
˜*Kšœžœ
˜Kšœžœ
˜šžœ
žœž˜Kš
ž˜K˜IKšžœ
˜—K˜4K˜Kšœžœ˜K˜$Kšœžœ
˜K˜K˜
K˜K˜/K˜K˜K˜Kš
œD™DK˜K˜KšžœžœM˜f˜K˜K—šžœ
ž˜Kš
ž˜Kšœžœ˜Kš
œ2™2Kšžœ
˜Kšžœ
˜—Kš
œ0™0K˜Cšžœžœž˜6Kšœ)žœ
˜1—Kš
œG™G˜Kšœ'žœžœ˜=—Kšžœžœ'˜Cš
ž˜šžœ(ž˜.K˜!——K˜IKš
œC™Cš
ž˜Kšœžœžœ6˜LKšžœžœžœ
žœ
˜,Kš
œ"˜"Kšžœ
˜—K˜šžœžœž˜Kšœžœ
˜Kšœžœ
˜$K˜
K˜K˜Kšœ
žœ
˜K˜Kšœ	žœ
˜
Kšžœžœ!˜:K˜&K˜K˜Kšžœ
˜—šžœž˜Kš
ž˜K˜šžœžœž˜Kš
œ(™(K˜6K˜Kšžœ
˜—Kšžœ
˜—Kšžœ
˜K˜—š œž	œ˜<Kš
ž˜šžœž˜Kš
ž˜K˜šžœžœ
žœž˜"Kšžœžœ
žœ˜-K˜Kšžœ
˜—Kšžœ
˜—šžœ
ž˜Kš
ž˜K˜šžœžœ
žœž˜"Kšžœžœ
žœ$˜=K˜Kšžœ
˜—K˜FKšžœ
˜—šžœ
žœž˜˜K˜<——Kšœžœ
˜Kš
œD™Dšžœž˜Kš
ž˜K˜—šžœžœM˜fKš
ž˜—š
ž˜Kš
ž˜K˜<šžœžœžœž˜%K˜Kšžœ
˜—Kšžœžœ
žœ
žœ
˜K˜Kšžœ
˜—Kšœ	žœ
˜
Kš
œ6™6K˜šžœ)žœ
˜8Kšœž˜Kš
ž˜šžœž˜Kšœ3žœ†
˜Α
—K˜Kšžœ
˜—Kšžœ
˜K˜—Kšœžœ
žœ
Ÿ
œ
˜-K˜š œžœ
žœ
ž	œ˜@Kš
ž˜K˜Kš
žœžœžœžœžœ!˜Xšžœžœ%ž˜AK˜—Kšžœžœžœ
žœ"˜SKš
œJ™Jšžœ
žœž˜Kš
ž˜šžœž˜KšžœŸ˜6Kšžœ
˜—Kšžœ
˜—Kšœžœ
˜K˜"K˜6K˜šžœžœ
žœž˜"šžœž˜#Kš
ž˜K˜šžœ
žœž˜K˜<—Kšžœ,žœ˜JKšžœ
˜—K˜Kšžœ
˜—šžœž˜KšœŸ*˜F—š
ž˜Kš
ž˜šžœžœ$ž˜@K˜4—Kšœ$Ÿ%˜IKšžœ
˜—Kšžœ
˜K˜—š œž	œ˜;Kš
ž˜K˜ Kšžœžœ˜š
ž˜Kš
ž˜Kš
žœžœ
žœžœ
žœ˜8Kšžœžœ žœ˜Ušžœžœ!ž˜=K˜—Kšœ	žœ
˜
K˜ šžœ
žœž˜K˜<—Kšžœžœ˜<Kšžœ
˜—Kšžœ
˜K˜—Kš
œ™K˜Kš
œJ™JKš
œ"™"K˜š œžœ
žœ
ž	œ
žœžœ˜AKšžœ
žœ
žœ7žœ
˜OK˜—Kš
œJ™JKš
œ"™"K˜š
 œžœ
ž	œ
žœžœ˜<Kšžœ
žœ7žœ
˜GK˜—Kš
œJ™JKš
œ"™"K˜š
 œžœ
ž	œ
žœžœ˜<Kš
ž˜Kšžœ6˜<Kšžœ
˜K˜—Kš
œJ™JKš
œ"™"K˜š
 œžœ
ž	œ
žœžœ˜<Kš
ž˜Kšžœ9˜?Kšžœ
˜K˜—Kš
œ™K˜š	  œž	œ
žœžœž˜GKš
ž˜šžœ
˜Kšžœ?žœ˜GKšžœ?˜C—Kšžœ
˜K˜—Kš
œO™OKš
œU™UKš
œS™SKš
œ'™'K˜š
 œžœ
žœ
ž	œžœ
˜DKšžœžœ˜Kš
ž˜Kšžœžœžœ!˜Kšžœžœ
žœž˜Kš
œJ™JKš
œT™TKš
œM™Mšžœž˜$Kš
ž˜K˜K˜$K˜K˜K˜
Kšžœžœ4˜MKšžœ
˜Kšžœ
˜—Kšžœžœ	žœ
žœ
˜0Kšžœ˜Kšžœ
˜—Kšžœ
˜K˜—š œž	œ˜(Kšœ;ž˜AKš
ž˜K˜šžœ	ž˜˜	Kš
ž˜Kš	œžœ
žœ
žœžœ˜LKšœPžœ
˜VK˜Kšžœ
˜—K˜Kšžœžœ
˜—K˜Kšžœ
˜K˜—š 
œžœ
žœ
ž	œ˜'K˜EKšžœ˜Kš
ž˜Kšžœ
žœžœ
˜Kšžœžœžœ!˜Kšžœžœ&ž˜BK˜—Kšžœžœžœ
žœ"˜Tšžœž˜Kš
ž˜Kšžœžœžœ%˜Všžœžœ˜4Kšœ9ž˜=K˜$—šžœ˜ Kšœ9ž˜;Kšžœžœ
˜&—Kš
ž˜—š
ž˜Kš
ž˜Kš	œžœ
žœ
žœ
žœ
˜-Kšœžœ
˜šžœ	ž˜˜Kšžœ>žœ
˜G—˜
Kš
ž˜K˜&K˜Kšžœ
˜—Kšžœ(˜/—šžœž˜Kšœ&žœ˜FKšžœ%˜)—šžœ'ž˜.Kšžœžœ
˜!—K˜.K˜Fšžœ ž˜'Kšžœžœ
˜&—Kšžœ
˜—K˜Kšžœžœžœ
žœ˜=K˜1K˜Kšžœžœ4˜MKšžœ
˜K˜—Kš
œ0™0Kš
œ7™7K˜š œžœ
žœ
ž	œ˜,K˜EKšžœ˜Kš
ž˜Kšžœžœžœ!˜Kšžœžœ&ž˜BK˜—Kšžœžœžœ
žœ"˜Tšžœž˜Kš
ž˜šžœ@ž˜FKš
ž˜Kšœžœ
˜Kšžœžœ%˜>Kšžœ
˜Kšžœ
˜—Kšžœžœžœ%˜VKš
ž˜—š
ž˜Kš
ž˜Kš	œžœ
žœ
žœ
žœ
˜-Kšœžœ
˜šžœ	ž˜˜Kšžœ>žœ
˜G—˜
Kš
ž˜K˜&K˜Kšžœ
˜—Kšžœ(˜/—šžœ(žœ˜KKš
ž˜Kš
ž˜Kšœžœ
˜Kšžœžœ%˜>Kšžœ
˜Kšžœ
˜—K˜.K˜FKšžœ
˜—Kšžœ$žœ
žœ˜FK˜1K˜Kšžœžœ4˜MKšžœ
˜K˜—Kš
œ,™,K˜š œžœ
žœ
ž	œ˜0Kšœ&žœžœ˜EKš
ž˜šžœžœžœ
žœžœž˜@K˜!—šžœžœ&ž˜BK˜—šžœ-ž˜3Kš
ž˜K˜&K˜FK˜K˜Kš
ž˜—š
ž˜Kšžœžœ%˜>—Kšžœ
˜K˜—Kš 
œž	œ
žœ
žœžœ
žœ˜?K˜Kš œžœ
ž	œžœ˜OKš œžœ
ž	œžœ˜OKš œžœ
ž	œžœ˜Oš œžœ
žœ
ž	œ˜6Kš
ž˜K˜(Kšžœžœžœ!˜KKšžœžœžœ
žœ"˜TKš
œT™TKš
œ™K˜&KšœŸ%˜Ašžœž˜Kš
ž˜šžœž˜K˜(K˜1Kšžœ(˜/—K˜FKšž	œ˜Kšžœ
˜—K˜Kš
œJ™JKš
œ"™"Kšž	œ˜"Kšžœ
˜K˜—š œžœ
žœ
ž	œ˜<Kšžœžœ˜Kš
ž˜Kšžœžœžœ!˜Kšžœžœ&ž˜BK˜—Kšžœžœžœ
žœ"˜Tšžœž˜Kš
ž˜šœ
žœ˜K˜9—Kšžœžœžœ!˜KK˜ Kšœžœžœžœ˜8Kš
ž˜—Kšžœ
žœ?žœ
˜MKšžœ
˜K˜—š œžœ
žœ
ž	œ˜@Kšžœžœ˜Kš
ž˜Kšžœžœžœ!˜Kšžœžœ&ž˜BK˜—Kšžœžœžœ
žœ"˜TKšžœ˜KšžœŸ˜K˜—š œžœ
žœ
ž	œ˜CKšžœžœ˜Kš
ž˜Kšžœžœžœ!˜Kšžœžœ&ž˜BK˜—Kšžœžœžœ
žœ"˜TKšžœ˜%KšžœŸ˜K˜—š œžœ
ž	œ˜*Kšœ ž	œ˜5Kš
ž˜K˜Kšžœžœžœ!˜KK˜šžœžœ(ž˜DK˜—Kš
žœžœ
žœžœ'žœ
˜TKšžœŸ˜K˜—Kš
œ0™0Kš
œ7™7K˜š œžœ
ž	œ
žœ˜9Kš
ž˜šžœ
˜Kšžœ@˜H—Kšžœ
˜K˜—š œžœ
žœ
ž	œ˜.Kšœ
žœžœ˜'Kš
ž˜Kšžœ
žœžœ
˜Kšžœžœžœ!˜KKšžœžœ žœ˜Ušžœ˜ Kšœ=ž˜?Kš
žœžœ
žœžœžœ
˜<—šžœž˜K˜-K˜
K˜Kšžœžœ4˜MK˜Kšžœ
˜—Kšžœ
˜K˜—Kš
œ™K˜š œžœ
ž	œ
˜.Kš
ž˜Kšœžœžœ˜EKšžœ
˜K˜—Kš
œ1™1K˜š œžœ
ž	œ
˜+Kš
ž˜K˜
Kšžœžœ
žœžœ
˜=Kšžœ
˜K˜—š œžœ
ž	œžœ˜NKšžœ˜—š œžœ
ž	œžœ˜NKšžœ˜—š œžœ
ž	œžœ˜NKšžœ˜—š œžœ
ž	œžœ˜KKš
ž˜K˜Kšžœžœ
žœ˜'Kšžœžœ žœ˜UKšžœžœ!žœ˜WKšœžœ
˜K˜šžœž˜Kšžœžœ
žœ
žœ
˜K˜K˜Kšžœ
˜—šžœžœ
ž˜Kš
ž˜Kš
œ!™!šžœžœ(ž˜DK˜—Kšžœžœ˜3Kšžœžœ˜-Kšžœ
žœ
žœ ˜7K˜Kšœžœ
˜Kšœžœ
˜Kšžœžœ ˜9Kš
ž˜—Kšžœ
žœžœ#˜AKšžœ˜Kšžœ
˜K˜—Kš 
œžœ
ž	œžœ
˜DKš 
œžœ
ž	œžœ
˜DKš 
œžœ
ž	œžœ
˜Dš œžœ
ž	œ˜1Kš
ž˜Kšžœžœ
žœžœ
žœžœ
žœ˜CKšžœžœ žœ˜UKšžœžœ!žœ˜Wš
žœžœžœžœ
žœ
žœž˜NK˜—Kšžœžœžœ˜DKšœ	žœ
˜
Kšžœžœ!˜:Kšžœžœ
žœ
žœ˜8K˜K˜K˜KšžœŸ
˜K˜—Kš
 
œžœ
ž	œ	žœžœ
˜MKš
 
œžœ
ž	œ	žœžœ
˜MKš
 
œžœ
ž	œ	žœžœ
˜Mš œžœ
ž	œžœ˜:Kš
ž˜Kšžœžœ
žœ˜'Kšžœžœ žœ˜Ušžœžœ
ž˜Kš
ž˜Kšžœžœžœ˜BKšžœžœ$˜=Kšžœ
˜Kšžœ
˜—Kšžœžœ
žœ
žœ
˜4Kšžœžœžœ˜DK˜Kšžœžœ!˜:Kšžœ
žœ˜+Kšœ
žœ
˜Kšœ	žœ
˜
Kšžœžœ!žœ˜Wš
žœžœžœžœ
žœ
žœž˜NK˜—KšžœŸ
˜K˜—Kš
œ™Kš
œc™cK˜Kšœžœ˜%K˜#˜K˜IK˜K˜K˜—šžœž˜Kš
ž˜Kšœžœ
˜#K˜/Kšžœ
˜—Kšžœ
˜K˜K˜——…—V(~Ϋ