DIRECTORY
YggEnvironment,
YggInternal,
BasicTime,
YggDIDMap USING [DocumentFromLockID, GetName],
List,
YggLock,
YggLockControl,
YggLockInternal,
Process,
Rope USING [Cat, Concat, ROPE],
YggMonitoringHooks USING [TransIDFromTransHandle, TransIDToRope],
YggMonitoringLog USING [notice, TransactionAbortInfo],
YggTransactionMap;

YggLockWatchdogImpl: CEDAR PROGRAM
IMPORTS
BasicTime, YggDIDMap, List, YggLock, YggLockInternal, Process, Rope, YggMonitoringHooks, YggMonitoringLog, YggTransactionMap
EXPORTS
YggInternal, YggLockControl

= BEGIN

LockID: TYPE = YggLock.LockID;
nullLockID: LockID = YggLock.nullLockID;
LockMode: TYPE = YggLock.LockMode;
ModeReleasableSet: TYPE = YggLock.ModeReleasableSet;
Lock: TYPE = YggLockInternal.Lock;
LockRep: TYPE = YggLockInternal.LockRep;
Header: TYPE = YggLockInternal.Header;
Request: TYPE = YggLockInternal.Request;
GrantedRequest: TYPE = YggLockInternal.GrantedRequest;
WaitingRequest: TYPE = YggLockInternal.WaitingRequest;
LockTransHeader: TYPE = YggLockInternal.LockTransHeader;
ConflictingTranses: TYPE = RECORD[holder: YggTransactionMap.TransHandle, waiter: YggTransactionMap.TransHandle, lock: LockID];	-- typical information about a lock conflict

LockTransHeaderObject: PUBLIC TYPE = YggLockInternal.LockRep.request.transHeader;


ForkWatchdogProcess: PUBLIC PROC [
wakeupPeriod: Process.Milliseconds,
abortWaitingRequestInterval: INT--seconds--,
abortInactiveGrantedRequestInterval: INT--seconds--] = {
TRUSTED {Process.Detach[FORK LockWatchdogProcess[wakeupPeriod, abortWaitingRequestInterval, abortInactiveGrantedRequestInterval]]; };
};

LockWatchdogProcess: PROC [
wakeupPeriod: Process.Milliseconds,
abortWaitingRequestInterval: INT--seconds--,
abortInactiveGrantedRequestInterval: INT--seconds--] = {
wakeupPeriodsUntilTimeoutCheck: INT _ 0;
numWaits: INT _ 0;
p: Path _ NIL;
DO
Process.Pause[Process.MsecToTicks[wakeupPeriod] ! ABORTED => GOTO aborted];

IF (wakeupPeriodsUntilTimeoutCheck _ wakeupPeriodsUntilTimeoutCheck-1) <= 0 THEN {
l: LIST OF ConflictingTranses;
logProc: PROC [YggMonitoringLog.TransactionAbortInfo];  -- (used to stop race condition)

[wakeupPeriodsUntilTimeoutCheck, l] _ ChooseTimeoutVictims[wakeupPeriod, abortWaitingRequestInterval];
UNTIL l = NIL DO
lNext: LIST OF ConflictingTranses _ l.rest;
IF (logProc _ YggMonitoringLog.notice.abortTransaction) # NIL THEN {
fileName: Rope.ROPE;		-- name of the file being fought over
message: Rope.ROPE;
message _ IF l.first.holder # NIL THEN
Rope.Cat["transaction timed out on lock held by ",
YggMonitoringHooks.TransIDToRope[YggMonitoringHooks.TransIDFromTransHandle[l.first.holder]]]
ELSE
"transaction timed out; livelock?";
fileName _ YggDIDMap.GetName[YggDIDMap.DocumentFromLockID[l.first.lock]];
message _ message.Cat[
"; waiting for ", 
IF fileName = NIL THEN
"(NIL)"
ELSE
fileName
];
logProc[[
transID: YggMonitoringHooks.TransIDFromTransHandle[l.first.waiter],
where: "LockWatchdogImpl.LockWatchdogProcess",
why: watchDog,
message: message
]];
};
YggTransactionMap.AbortUnilaterally[l.first.waiter, timeout];
Process.Yield[];
FREE[@l];
l _ lNext;
ENDLOOP;
};

Process.Yield[];
DO
l: LIST OF ConflictingTranses _ GetBlockingTransactions[];
currentTime: BasicTime.GMT _ BasicTime.Now[];
noAbortDone: BOOL _ TRUE;
UNTIL l = NIL DO
lNext: LIST OF ConflictingTranses _ l.rest;
elapsedTimeSinceLastStartWork: INT _ BasicTime.Period[from: YggTransactionMap.GetTimeOfLastStartWork[l.first.holder], to: currentTime];
IF elapsedTimeSinceLastStartWork > abortInactiveGrantedRequestInterval THEN {
logProc: PROC [YggMonitoringLog.TransactionAbortInfo];
fileName: Rope.ROPE;		-- name of file being fought over
IF (logProc _ YggMonitoringLog.notice.abortTransaction) # NIL THEN {
fileName _ YggDIDMap.GetName[YggDIDMap.DocumentFromLockID[l.first.lock]];
logProc[[
transID: YggMonitoringHooks.TransIDFromTransHandle[l.first.holder],
where: "LockWatchdogImpl.LockWatchdogProcess",
why: watchDog,
message: Rope.Cat[
"trans is holding up ",
YggMonitoringHooks.TransIDToRope[YggMonitoringHooks.TransIDFromTransHandle[l.first.waiter]],
"; waiting for ",
IF fileName = NIL THEN 
"(NIL)"
ELSE 
fileName
]
]]
};
YggTransactionMap.AbortUnilaterally[l.first.holder, blockingNewLockRequest];
Process.Yield[];
noAbortDone _ FALSE;
};
FREE[@l];
l _ lNext;
ENDLOOP;
IF noAbortDone THEN EXIT;
ENDLOOP;

Process.Yield[];
{
g: WaitingForGraph;
[numWaits, g] _ ComputeWaitingForGraph[numWaits];
IF g # NIL THEN {
logProc: PROC [YggMonitoringLog.TransactionAbortInfo];  -- (used to stop race condition)
DO
t: YggTransactionMap.TransHandle;	-- transaction to kill
p _ FindCycle[g, p];
IF (t _ ChooseVictim[p]) = NIL THEN GOTO freeGraph;
IF (logProc _ YggMonitoringLog.notice.abortTransaction) # NIL THEN {
deadlockList: Rope.ROPE _ NIL;
FOR i: NAT IN [0 .. p.length) DO
deadlockList _ deadlockList.Cat[
" ",
YggMonitoringHooks.TransIDToRope[YggMonitoringHooks.TransIDFromTransHandle[p[i].waitingTrans.trans]]
];
deadlockList _ deadlockList.Cat[
"(",
YggDIDMap.GetName[YggDIDMap.DocumentFromLockID[p[i].waitingTrans.waitingFor]],
")"
];
ENDLOOP;
logProc[[
transID: YggMonitoringHooks.TransIDFromTransHandle[t],
where: "LockWatchdogImpl.LockWatchdogProcess",
why: watchDog,
message: Rope.Concat["deadlock of", deadlockList]
]];
};
YggTransactionMap.AbortUnilaterally[t, deadlock];
Process.Yield[];
g _ EliminateTrans[g, t];
REPEAT
freeGraph => FreeGraph[g];
ENDLOOP;
};
};

ENDLOOP;
EXITS
aborted => NULL
};



WaitMemb: PROC [trans: YggTransactionMap.TransHandle, list: LIST OF ConflictingTranses] RETURNS [BOOLEAN] ~ {
UNTIL list = NIL DO
IF trans = list.first.waiter THEN RETURN [TRUE];
list _ list.rest
ENDLOOP;
RETURN [FALSE]
};

BlockMemb: PROC [trans: YggTransactionMap.TransHandle, list: LIST OF ConflictingTranses] RETURNS [BOOLEAN] ~ {
UNTIL list = NIL DO
IF trans = list.first.holder THEN RETURN [TRUE];
list _ list.rest
ENDLOOP;
RETURN [FALSE]
};


ChooseTimeoutVictims: PROC [wakeupPeriod: INT--msec--, abortWaitingRequestInterval: INT--seconds--] RETURNS [wakeupPeriodsUntilTimeoutCheck: INT, l: LIST OF ConflictingTranses] = {
currentTime: BasicTime.GMT = BasicTime.Now[];
secondsToNextWakeup: INT _ abortWaitingRequestInterval;
NoticeWaitingRequest: PROC [wr: WaitingRequest] RETURNS [stop: BOOL] = {
m: LockMode = ModeAfterGrantingRequest[wr];
elapsedTimeSinceWait: INT--seconds-- = BasicTime.Period[from: wr.startTime, to: currentTime];
IF elapsedTimeSinceWait >= abortWaitingRequestInterval THEN {  
IF NOT WaitMemb[wr.trans, l] THEN {
FOR h: Lock _ wr.requestList, h.requestList UNTIL h=wr DO
WITH h SELECT FROM
grh: GrantedRequest =>
IF grh.trans # wr.trans AND NOT YggLock.Compat[m][grh.mode] THEN {
l _ CONS[first: [holder: grh.trans, waiter: wr.trans, lock: YggLockInternal.LockIDFromRH[wr]], rest: l];
GOTO FoundABlocker
}
ENDCASE;
REPEAT
FoundABlocker => NULL;
FINISHED => 
l _ CONS[first: [holder: NIL, waiter: wr.trans, lock: YggLockInternal.LockIDFromRH[wr]], rest: l];
ENDLOOP;
}
}
ELSE {
secondsToNextWakeup _ MIN[secondsToNextWakeup, abortWaitingRequestInterval-elapsedTimeSinceWait];
}; 
RETURN [stop: FALSE];
};	-- NoticeWaitingRequest

l _ NIL;
YggLockInternal.GetInfo[waitingRequestEnumProc: NoticeWaitingRequest];
RETURN [(secondsToNextWakeup*1000 + wakeupPeriod-1)/wakeupPeriod, l];
};



GetBlockingTransactions: PROC [] RETURNS [l: LIST OF ConflictingTranses] = {
NoticeWaitingRequest: PROC [wr: WaitingRequest] RETURNS [stop: BOOL] = {
m: LockMode = ModeAfterGrantingRequest[wr];
FOR h: Lock _ wr.requestList, h.requestList UNTIL h=wr DO
WITH h SELECT FROM
grh: GrantedRequest =>
IF grh.trans # wr.trans AND NOT YggLock.Compat[m][grh.mode] AND NOT BlockMemb[grh.trans, l] THEN
l _ CONS[first: [holder: grh.trans, waiter: wr.trans, lock: YggLockInternal.LockIDFromRH[wr]], rest: l];
ENDCASE;
ENDLOOP;
RETURN [stop: FALSE];
};

l _ NIL;
YggLockInternal.GetInfo[waitingRequestEnumProc: NoticeWaitingRequest];
RETURN [l];
};

ModeAfterGrantingRequest: PROC [wr: WaitingRequest] RETURNS [LockMode] = {
FOR h: Lock _ wr.requestList, h.requestList UNTIL h=wr DO
WITH h SELECT FROM
grh: GrantedRequest =>
IF grh.trans = wr.trans THEN RETURN[YggLock.Sup[wr.mode][grh.mode]];
ENDCASE;
ENDLOOP;
RETURN [wr.mode];
};



WaitingTransHandle: TYPE = REF WaitingTransObject;
WaitingTransObject: TYPE = RECORD [
trans: YggTransactionMap.TransHandle,
waitingFor: LockID _ ,
edges: LIST OF--WaitingTransHandle--REF ANY,
visited: BOOL _ FALSE,
onPath: BOOL _ FALSE
];
WaitingForGraph: TYPE = LIST OF--WaitingTransHandle--REF ANY;

ComputeWaitingForGraph: PROC [numWaits: INT]
RETURNS [newNumWaits: INT, g: WaitingForGraph] = {
NoticeGeneralInfo: YggLockInternal.GeneralInfoProc = {
newNumWaits _ nSetCallsWaited;
};
NoticeWaitingRequest: PROC [wr: WaitingRequest] RETURNS [stop: BOOL] = {
IF newNumWaits = numWaits THEN RETURN [stop: TRUE]
ELSE {
IF (LookupTrans[g, wr.trans] = NIL) THEN {
wt: WaitingTransHandle _ NEW[WaitingTransObject _ [trans: wr.trans, edges: NIL, waitingFor: YggLockInternal.LockIDFromRH[wr]]];
g _ CONS[first: wt, rest: g];
};
RETURN [stop: FALSE];
};
};
NoticeWaitingRequest2: PROC [wr: WaitingRequest] RETURNS [stop: BOOL] = {
IF newNumWaits = numWaits THEN RETURN [stop: TRUE]
ELSE {
waiting: WaitingTransHandle = LookupTrans[g, wr.trans];
m: LockMode = ModeAfterGrantingRequest[wr];
FOR h: Lock _ wr.requestList, h.requestList UNTIL h = wr DO
WITH h SELECT FROM
grh: GrantedRequest =>
IF grh.trans # wr.trans AND NOT YggLock.Compat[m][grh.mode] THEN {
granted: WaitingTransHandle _ LookupTrans[g, grh.trans];
IF granted # NIL AND NOT List.Memb[granted, waiting.edges] THEN
waiting.edges _ CONS[first: granted, rest: waiting.edges];
};
ENDCASE;
ENDLOOP;
RETURN [stop: FALSE];
};
};
g _ NIL;
YggLockInternal.GetInfo[
generalInfoProc: NoticeGeneralInfo,
waitingRequestEnumProc: NoticeWaitingRequest,
waitingRequestEnumProc2: NoticeWaitingRequest2];
RETURN [newNumWaits, g];
};

PathRecord: TYPE = RECORD [
length: NAT _ 0,
vertices: SEQUENCE maxLength: NAT OF RECORD [
waitingTrans: WaitingTransHandle,
nextEdge: LIST OF--WaitingTransHandle--REF ANY
]
];
Path: TYPE = REF PathRecord;

FindCycle: PROC [g: WaitingForGraph, oldPath: Path] RETURNS [path: Path] = {
top: LIST OF REF ANY _ g;
pathLast: NAT _ 0;
v: WaitingTransHandle;
pathMaxLength: NAT = List.Length[g];
path _ IF oldPath # NIL AND oldPath.length >= pathMaxLength
THEN oldPath
ELSE NEW[PathRecord[pathMaxLength]];
DO
{ -- EXITS NextTopLevelVertex
v _ NARROW[top.first];
IF v.visited THEN GOTO NextTopLevelVertex;
DO
path[pathLast] _ [waitingTrans: v, nextEdge: v.edges];
v.visited _ v.onPath _ TRUE;
DO
e: LIST OF REF ANY _ path[pathLast].nextEdge;
IF e = NIL THEN {
path[pathLast].waitingTrans.onPath _ FALSE;
IF pathLast = 0 THEN GOTO NextTopLevelVertex;
pathLast _ pathLast - 1;
}
ELSE {
path[pathLast].nextEdge _ e.rest;
v _ NARROW[e.first];
IF v.onPath THEN GOTO FoundCycle;
IF NOT v.visited THEN {
pathLast _ pathLast + 1;
EXIT;
};
};
ENDLOOP;
ENDLOOP;
EXITS
NextTopLevelVertex => IF (top _ top.rest) = NIL THEN {
path.length _ 0;
GOTO done;
};
FoundCycle => {
cycleStart: NAT;
FOR cycleStart _ 0, cycleStart+1
UNTIL path[cycleStart].waitingTrans = v DO ENDLOOP;
FOR j: NAT IN [cycleStart .. pathLast] DO
path[j-cycleStart] _ [path[j].waitingTrans, NIL];
ENDLOOP;
path.length _ pathLast-cycleStart+1;
GOTO done;
};
};
ENDLOOP;
EXITS done =>
FOR j: NAT IN [path.length .. path.maxLength) DO
path[j] _ [NIL, NIL];
ENDLOOP;
};

ChooseVictim: PROC [p: Path] RETURNS [YggTransactionMap.TransHandle] = {
minUpdateCost: INT _ LAST[INT];
minUpdateCostTrans: YggTransactionMap.TransHandle _ NIL;
FOR i: NAT IN [0 .. p.length) DO
updateCost: INT _ YggTransactionMap.GetEstimatedUpdateCost[p[i].waitingTrans.trans];
IF updateCost < minUpdateCost OR minUpdateCostTrans = NIL THEN {
minUpdateCost _ updateCost;
minUpdateCostTrans _ p[i].waitingTrans.trans;
};
ENDLOOP;
RETURN [minUpdateCostTrans];
};

LookupTrans: PROC [g: WaitingForGraph, t: YggTransactionMap.TransHandle]
RETURNS [wt: WaitingTransHandle] = {
FOR l: LIST OF REF ANY _ g, l.rest UNTIL l = NIL DO
wt: WaitingTransHandle _ NARROW[l.first];
IF wt.trans = t THEN RETURN [wt];
ENDLOOP;
RETURN [NIL];
};

EliminateTrans: PROC [g: WaitingForGraph, t: YggTransactionMap.TransHandle]
RETURNS [newG: WaitingForGraph]= {
wt: WaitingTransHandle _ LookupTrans[g, t];
FreeList[wt.edges];  wt.edges _ NIL;
FOR l: LIST OF REF ANY _ g, l.rest UNTIL l = NIL DO
w: WaitingTransHandle _ NARROW[l.first];
w.visited _ w.onPath _ FALSE;
w.edges _ List.DRemove[wt, w.edges];
ENDLOOP;
RETURN [List.DRemove[wt, g]];
};

FreeGraph: PROC [g: WaitingForGraph] = {
FOR l: LIST OF REF ANY _ g, l.rest UNTIL l = NIL DO
wt: WaitingTransHandle _ NARROW[l.first];
FreeList[wt.edges];
FREE[@wt];
ENDLOOP;
FreeList[g];
};

FreeList: PROC [l: LIST OF REF ANY] = {
UNTIL l = NIL DO
lNext: LIST OF REF ANY _ l.rest;
FREE[@l];
l _ lNext;
ENDLOOP;
};

END.--LockWatchdogImpl

CHANGE LOG

Changed by MBrown on February 6, 1983 10:03 pm

®YggLockWatchdogImpl.mesa
Copyright Ó 1984, 1985, 1988 by Xerox Corporation.  All rights reserved.
MBrown on January 30, 1984 5:41:50 pm PST
Kupfer, February 28, 1985 2:16:45 pm PST
Hauser, May 20, 1985 1:40:32 pm PDT
Bob Hagmann July 13, 1988 10:52:40 am PDT

NOTES
Some care has been taken to make these procedures efficient in the (normal) case that waiting happens rarely, the total number of waiting requests is small, and SkiPatrol logging is turned off for abortTransaction.  This allows us to check more frequently, which improves response in cases when the wait can be resolved right away (deadlock and inactive blocking transaction).
YggInternal.LockTransHeaderObject
YggLockControl.ForkWatchdogProcess.
For each waiting request, abort its transaction if it has waited for more than abortWaitingRequestInterval seconds.  (Of course, don't bother to check for timed-out requests unless a request might be timed out, based on information obtained on the last check.)
Collect a list of transactions that hold locks that other transactions need.  For each blocking transaction: if it has done no work in the last abortInactiveGrantedRequestInterval seconds, abort it.  Repeat until no transaction is aborted by this test.
Compute a graph whose vertices are transactions with one or more waiting lock requests, containing a directed edge from t1 to t2 if t2 holds a lock that prevents a waiting lock request or t1 from being satisfied.  (Don't bother to compute the graph if no lock requests have waited since the last time the graph was computed.)  If the graph contains a cycle, find a cycle and abort the lowest-cost transaction in the cycle.  Repeat until the graph contains no cycle.
Log the transaction ID's of everyone involved in the deadlock.
Support for timeout and blockingNewLockRequest detection.
Tells whether "trans" appears as a "waiter" in "list".
Tells whether "trans" appears as a "holder" in "list".
INTERNAL to LockCoreImpl
If "wr" is old and not already in our list of things to kill (l), then add it to the list.  When we add it, we'd like to record a transaction ID for a transaction that is blocking it (there may be more than one).  If we can't find a holder, record NIL as the holder (but kill the waiter anyway).
wr is old and not already in the list, so find a holder
wr isn't old; update time for next wakeup, if necessary
INTERNAL to LockCoreImpl
Look for transactions that are blocking wr.  As one is found, add it to the list if it isn't already in it.
INTERNAL to LockCoreImpl
Support for deadlock detection.
If numWaits equals the number of lock waits reported by the lock manager, return newNumWaits = numWaits, g = NIL.  Otherwise compute the current waiting-for graph, and return it as g.
If there are new waiters, add this transaction to the list of waiting transactions.
If there are new waiters, create an edge for each transaction blocking this request.
If g contains a cycle, returns a cycle as path; returns path.length = 0 if g contains no cycle.  Reuses oldPath's storage if it can.
Add the new vertex v to the end of the path.
Explore the next edge out of the vertex at the end of the path.
Remove a vertex from the end of the path.
Add v to the end of the path.
Move vertices of cycle down to start of sequence, clean up rest, and return.
Transactions in p are deadlocked.  Choose one to be aborted.
Return NIL iff p is empty.
Compute a new graph, eliminating t.  Mark all vertices unvisited and not on path.
NILs things out (superstition).
Bug in GetBlockingTransactions: always returned the waiting transaction instead of the blocking transaction.  This meant wait => abort nearly every time.
Edited on July 24, 1984 11:01:18 am PDT, by Kupfer
Add YggMonitoringLog probes.
changes to: LockWatchdogImpl, LockWatchdogProcess
Edited on July 29, 1984 7:08:42 pm PDT, by Kupfer
Add code so that the lockConflict probes can report who the interested parties were.
changes to: LockWatchdogImpl, ChooseTimeoutVictims, NoticeWaitingRequest (local of ChooseTimeoutVictims)
Edited on August 6, 1984 3:31:53 pm PDT, by Kupfer
Remove the possible race condition in YggMonitoringLog probes by assigning the PROC to a temporary variable.
changes to: LockWatchdogImpl
Edited on February 28, 1985 11:35:48 am PST, by Kupfer
Record the name of the files being fought over when the watchdog has to kill some transaction.
changes to: LockWatchdogImpl, NoticeWaitingRequest (local of ChooseTimeoutVictims), NoticeWaitingRequest (local of GetBlockingTransactions), ComputeWaitingForGraph
�ÊÕ˜Icodeš
œ™š
œH™HKš
œ)™)K™(K™#K™)—K™K˜
K˜Kš
œ™K˜Kš
œø™øK˜š
Ïk	˜	Kš
œ˜Kš
œ˜K˜
Kšœ
�œ˜.K˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœ�œ�œ˜Kšœ�œ)˜AKšœ�œ ˜6Kš
œ˜K˜—šœ�
˜"š
�˜Kš
œ|˜|—š
�˜Kš
œ˜K˜—Kšœ�˜K˜Kšœ�œ˜Kš
œ(˜(Kšœ
�œ˜"Kšœ�œ˜4Kšœ�œ˜"Kšœ	�œ˜(Kšœ�œ˜&Kšœ	�œ˜(Kšœ�œ"˜6Kšœ�œ"˜6Kšœ�œ#˜8Kšœ�œ�œ^Ïc,˜«
K˜šœ�œ
�œ/˜QKš
œ!™!K˜—K˜šÏnœ�œ
�œ˜"Kš
œ#˜#Kšœ�žœ
˜,Kšœ%�žœ˜8Kš
œ#™#Kšœ�œi˜…
K˜K˜—šŸœ�œ˜Kš
œ#˜#Kšœ�žœ
˜,Kšœ%�žœ˜8Kšœ �œ˜(Kšœ
�œ˜Kšœ
�œ
˜š
�˜Kšœ2�œ�œ
˜KK˜Kš
œ„™„š�œJ�œ˜RKšœ�œ
�œ˜Kšœ	�œ+ž ˜XK˜K˜fš�œ�œ
�˜Kšœ�œ
�œ˜+š�œ8�œ
�œ˜DKšœ�œž%˜;Kšœ�œ
˜šœ
�œ�œ
�˜&˜2Kš
œ\˜\——š
�˜K˜#—Kš
œI˜I˜K˜š�œ�œ
�˜Kš
œ˜—š
�˜Kš
œ˜—K˜—š
œ	˜	Kš
œC˜CKš
œ.˜.Kš
œ˜Kš
œ˜K˜—K˜—Kš
œ=˜=Kš
œ˜Kš�œ˜	K˜
Kš�œ
˜—K˜K˜—Kšœ�
Ïr#œI™ü
Kš
œ˜š
�˜Kšœ�œ
�œ0˜:Kšœ�œ˜-Kšœ
�œ�œ
˜š�œ�œ
�˜Kšœ�œ
�œ˜+Kšœ�œe˜‡
š�œE�œ˜MKšœ	�œ)˜6Kšœ�œž!˜7š�œ8�œ
�˜DKš
œI˜Iš
œ	˜	Kš
œC˜CKš
œ.˜.Kš
œ˜˜K˜Kš
œ\˜\Kš
œ˜š�œ�œ
˜K˜—š�œ
˜K˜—K˜
—K˜—K˜—Kš
œL˜LKš
œ˜Kšœ�œ
˜K˜—Kš�œ˜	K˜
Kš�œ
˜—Kš�œ
�œ
�œ
˜Kš�œ
˜K˜—Kš
œÑ™ÑKš
œ˜˜
K˜K˜1š�œ�œ
�œ˜Kšœ	�œ+ž ˜Xš
�˜Kšœ"ž˜8K˜Kš�œ�œ
�œ
�œ˜3š�œ8�œ
�˜DKš
œ>™>Kšœ�œ�œ
˜š�œ�œ
�œ�˜ ˜ K˜Kš
œd˜dKš
œ˜—˜ K˜Kš
œN˜NK˜K˜—Kš�œ
˜—š
œ	˜	Kš
œ6˜6Kš
œ.˜.Kš
œ˜K˜1K˜—K˜—Kš
œ1˜1Kš
œ˜K˜š
�˜K˜—Kš�œ
˜—K˜—K˜K˜—Kš�œ
˜—š
�˜Kšœ�˜—K˜—K˜—˜Iheadš
œ9™9K˜šŸœ�œ.�œ
�œ�œ�œ˜mJš
œ6™6š�œ�œ
�˜Jš�œ�œ
�œ�œ˜0J˜Jš�œ
˜—Jš�œ�œ
˜J˜J˜—šŸ	œ�œ.�œ
�œ�œ�œ˜nJš
œ6™6š�œ�œ
�˜Jš�œ�œ
�œ�œ˜0J˜Jš�œ
˜—Jš�œ�œ
˜J˜J˜—K˜šŸœ�œ�žœ�žœ
�œ"�œ�œ
�œ˜´
Kšœ�œ˜-Kšœ�œ˜7
unitšŸœ�œ�œ�œ˜HKš
œ™K˜+Kšœ�žœ9˜]Kšœ> 
Ϗ
™§š�œ5�œ˜?š�œ
�œ�œ˜#Jš œ5™7š�œ)�œ�˜9š�œ�œ
�˜š
œ˜š�œ�œ
�œ�œ˜BKšœ�œ`˜hKš�œ˜K˜
——Kš�œ
˜—š
�˜Kšœ�œ
˜š�œ˜Kšœ�œ�œF˜b——Kš�œ
˜—K˜
—K˜
—š�œ˜Kš œ5™7Kšœ�œH˜aKš
œ˜—Kš�œ�œ˜Kšœž˜K˜—Kšœ�œ
˜Kš
œF˜FKš�œ?˜EK˜K˜K˜K˜—š
Ÿœ�œ�œ�œ
�œ˜LšŸœ�œ�œ�œ˜HKš
œ™K˜+Jšœ( œA™kš�œ)�œ�˜9š�œ�œ
�˜š
œ˜š�œ�œ
�œ�œ
�œ�˜`Kšœ�œ`˜h——Kš�œ
˜—Kš�œ
˜—Kš�œ�œ˜K˜K˜—Kšœ�œ
˜Kš
œF˜FKš�œ˜K˜K˜—šŸœ�œ�œ˜JKš
œ™š�œ)�œ�˜9š�œ�œ
�˜š
œ˜Kš�œ�œ
�œ!˜D—Kš�œ
˜—Kš�œ
˜—Kš�œ˜K˜—K˜—˜Lš
œ™K˜Kšœ�œ�œ˜2šœ�œ�œ˜#Kš
œ%˜%K˜Kš	œ�œ
�ž�œ
�œ
˜,Kšœ	�œ�œ
˜Kšœ�œ�˜K˜—Kšœ�œ�œ
�ž�œ
�œ
˜=K˜šŸœ�œ�œ
˜,Kš�œ�œ˜2Kš
œ·
™·
šŸœ%˜6K˜K˜—šŸœ�œ�œ�œ˜HKš
œS™SKš�œ�œ
�œ�œ
˜2š�œ˜š�œ�œ�œ˜*Kšœ�œ/�œ1˜Kšœ�œ˜K˜—Kš�œ�œ˜K˜—K˜—šŸœ�œ�œ�œ˜IKš
œT™TKš�œ�œ
�œ�œ
˜2š�œ˜K˜7K˜+š�œ)�œ�˜;š�œ�œ
�˜š
œ˜š�œ�œ
�œ�œ˜BK˜8š	�œ�œ
�œ
�œ#�˜?Kšœ�œ&˜:—K˜——Kš�œ
˜—Kš�œ
˜—Kš�œ�œ˜K˜—K˜—Kšœ�œ
˜š
œ˜K˜#K˜-K˜0—Kš�œ˜K˜——˜šœ�œ�œ˜Kšœ�œ˜š	œ
�œ�œ
�œ
�œ˜-K˜!Kšœ
�œ
�ž�œ
�˜.K˜
—K˜—Kšœ�œ�œ˜K˜šŸ	œ�œ%�œ˜LKš
œ„
™„
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š�œ
˜—š
�˜šœ�œ�œ
�œ˜6K˜Kš�œ˜
K˜—˜Kš
œL™LKšœ�œ
˜š�œ˜ Kš�œ#�œ
�œ
˜3—š�œ�œ
�œ�˜)Kšœ,�œ˜1Kš�œ
˜—K˜$Kš�œ˜
K˜——K˜—Kš�œ
˜—š�œ˜
š�œ�œ
�œ!�˜0Kšœ�œ�œ˜Kš�œ
˜——K˜——˜šŸœ�œ�œ$˜HKš
œ<™<Kš
œ™Kšœ�œ�œ
�œ˜Kšœ4�œ
˜8š�œ�œ
�œ�˜ Kšœ�œE˜Tš�œ�œ�œ
�œ˜@K˜K˜-K˜—Kš�œ
˜—Kš�œ˜K˜K˜—šŸœ�œ7˜HKš�œ˜$š�œ�œ
�œ
�œ
�œ
�œ�œ
�˜3Kšœ�œ
˜)Kš�œ�œ
�œ˜!Kš�œ
˜—Kš�œ�œ˜
K˜K˜—šŸœ�œ7˜KKš�œ˜"Kš
œQ™QK˜+Kšœ �œ
˜$š�œ�œ
�œ
�œ
�œ
�œ�œ
�˜3Kšœ�œ
˜(Kšœ�œ
˜K˜$Kš�œ
˜—Kš�œ˜K˜K˜—šŸ	œ�œ˜(Kš
œ™š�œ�œ
�œ
�œ
�œ
�œ�œ
�˜3Kšœ�œ
˜)K˜Kš�œ˜
Kš�œ
˜—K˜K˜K˜—šŸœ�œ�œ
�œ
�œ
�œ˜'š�œ�œ
�˜Kš	œ�œ
�œ
�œ
�œ
˜ Kš�œ˜	K˜
Kš�œ
˜—K˜K˜—Kš�œ
ž˜K˜—Kš�œ
�˜
K˜K˜.Kš
Ϫ
™™
K˜™2Kš
œ™Kšœ %™1—™1K™TKšœ <œ ™h—™2Kš
œl™lKšœ ™—™6K™^Kšœ &œ  œ# ™£
——…—2NUÑ