-- File: TimeServerClockImpl.mesa - last edit:
-- HGM 25-Jun-85 2:47:16 - version to LogClockChange
-- KAM 15-Apr-85 18:02:42
-- Tim Diebert 6-Aug-87 5:34:46 added TimeServerClockExtras for home WS.
-- Copyright (C) 1984, 1985 by Xerox Corporation. All rights reserved.
DIRECTORY
Buffer USING [NSBuffer],
Inline USING [DIVMOD, LowHalf],
NSConstants USING [timeServerSocket],
PacketExchange USING [ExchangeClientType],
Process USING [
Abort, Pause, priorityBackground, SecondsToTicks, SetPriority, Ticks],
Router USING [
endEnumeration, EnumerateRoutingTable, FillRoutingTable, FindMyHostID,
GetDelayToNet, infinity, NoTableEntryForNet, startEnumeration],
Socket USING [
BroadcastPacketToAllConnectedNets, ChannelHandle, Create, Delete, GetPacket,
GetSendBuffer, PutPacket, ReturnBuffer, SetPacketWords, SetWaitTime,
TimeOut],
SpecialSystem USING [AdjustClock, clockSlipping, SetBackTooFar, TimeLastSet],
System USING [
AdjustGreenwichMeanTime, broadcastHostNumber, GetClockPulses,
GetGreenwichMeanTime, GreenwichMeanTime, HostNumber, Microseconds,
NetworkAddress, NetworkNumber, nullNetworkAddress, nullNetworkNumber,
nullSocketNumber, Pulses, PulsesToMicroseconds, SecondsSinceEpoch],
TimeServerClock USING [Error, Rate, undefined],
TimeServerClockExtras USING [],
TimeServerFormat USING [LongToWire, TSPacket, Version, WireToGMT, WireToLong],
TimeServerLog USING [LogClockChange, LogInconsistancy];
TimeServerClockImpl: MONITOR
IMPORTS
Inline, Process, Router, Socket, SpecialSystem, System, TimeServerFormat,
TimeServerLog
EXPORTS TimeServerClock, TimeServerClockExtras =
BEGIN
-- Initial values to these variables are assigned by the procedure Init
tsError: TimeServerClock.Error;
tsDrift, tsWobble: TimeServerClock.Rate;
tsResetPeriod: CARDINAL;
clockInvalid: BOOLEAN ← FALSE; -- set if SpecialSystem.SetBackTooFar is raised
ignoringServer: BOOLEAN ← FALSE;
ignoringServerAddress: System.HostNumber;
tsSourceLastReset: System.NetworkAddress ← System.nullNetworkAddress;
tsLastChange: LONG INTEGER ← 0;
tsVersion: LONG CARDINAL ← 0;
started: BOOLEAN ← FALSE;
surveyorProcess: PROCESS;
lastID: LONG CARDINAL ← 1;
oneSecond: Process.Ticks = Process.SecondsToTicks[1];
triesPerNetwork: CARDINAL = 3;
resetTries: CARDINAL = 10;
Inconsistent: PUBLIC ERROR = CODE;
Invalid: PUBLIC SIGNAL = CODE;
-- public procedures
AdjustClock: PUBLIC PROCEDURE [
amount: LONG INTEGER, error: TimeServerClock.Error, newVersion: BOOLEAN] =
BEGIN
UpVersion: ENTRY PROCEDURE [update: BOOLEAN] RETURNS [LONG CARDINAL] = {
RETURN[IF update THEN SUCC[tsVersion] ELSE tsVersion]};
AdjustClockEntry[
amount, error, UpVersion[newVersion], 0, System.nullNetworkAddress, TRUE];
END;
GetParameters: PUBLIC ENTRY PROCEDURE RETURNS [
drift, wobble: TimeServerClock.Rate,
resetPeriod: CARDINAL, timeLastReset: System.GreenwichMeanTime,
sourceLastReset: System.NetworkAddress, changeLastReset: LONG INTEGER] = {
RETURN[
tsDrift, tsWobble, tsResetPeriod, SpecialSystem.TimeLastSet[],
tsSourceLastReset, tsLastChange]};
Read: PUBLIC ENTRY PROCEDURE RETURNS [
time: System.GreenwichMeanTime, error: TimeServerClock.Error,
accurate: BOOLEAN, version: LONG CARDINAL] =
BEGIN
IF clockInvalid THEN SIGNAL Invalid;
error ← ErrorInternal[];
RETURN[
System.GetGreenwichMeanTime[], error,
(error # TimeServerClock.undefined) AND NOT SpecialSystem.clockSlipping,
tsVersion];
END;
ResetClock: PUBLIC PROCEDURE [from: System.NetworkAddress]
RETURNS [reset: BOOLEAN ← FALSE] =
BEGIN
cH: Socket.ChannelHandle ← Socket.Create[System.nullSocketNumber];
b: Buffer.NSBuffer ← NIL;
Socket.SetWaitTime[cH, WaitForHops[Router.GetDelayToNet[
from.net ! Router.NoTableEntryForNet => {
Socket.Delete[cH]; GOTO NoReset}]]];
IF from.host # System.broadcastHostNumber THEN
BEGIN ENABLE UNWIND => IF b # NIL THEN Socket.ReturnBuffer[b];
time: LONG INTEGER;
error, delay, version: LONG CARDINAL;
sendMsec: System.Microseconds;
MaxVersion: ENTRY PROCEDURE RETURNS [LONG CARDINAL] = {
RETURN[MAX[tsVersion, version]]};
FOR tries: CARDINAL IN [0.. 2*resetTries) UNTIL reset DO
sendMsec ← System.PulsesToMicroseconds[System.GetClockPulses[]];
SendTimeRequest[cH, from, TRUE, (tries < resetTries)];
b ← Socket.GetPacket[cH ! Socket.TimeOut => LOOP];
IF b.ns.packetType = packetExchange AND b.ns.exchangeType =
PacketExchange.ExchangeClientType[timeService]
AND LOOPHOLE[b.ns.exchangeID, LONG CARDINAL] = lastID THEN
BEGIN
p: LONG POINTER TO TimeServerFormat.TSPacket =
LOOPHOLE[@b.ns.exchangeBody];
delay ← (
System.PulsesToMicroseconds[System.GetClockPulses[]] - sendMsec)
/1000;
WITH r: p↑ SELECT FROM
internalTimeResponse =>
BEGIN
reset ← TRUE;
time ← System.SecondsSinceEpoch[TimeServerFormat.WireToGMT[r.time]]
- System.SecondsSinceEpoch[System.GetGreenwichMeanTime[]];
error ← TimeServerFormat.WireToLong[r.absoluteError];
IF error # TimeServerClock.undefined
THEN error ← error + delay + 1000;
version ← TimeServerFormat.WireToLong[r.timeVersion];
END;
timeResponse =>
BEGIN
reset ← TRUE;
time ← System.SecondsSinceEpoch[TimeServerFormat.WireToGMT[r.time]]
- System.SecondsSinceEpoch[System.GetGreenwichMeanTime[]];
error ← IF NOT r.errorAccurate THEN TimeServerClock.undefined
ELSE TimeServerFormat.WireToLong[r.absoluteError] + delay + 1000;
version ← 0;
END;
ENDCASE;
IF reset THEN AdjustClockEntry[
time, error, MaxVersion[], delay, from, TRUE];
END;
Socket.ReturnBuffer[b];
ENDLOOP;
END
ELSE
FOR tries: CARDINAL IN [0.. resetTries) UNTIL reset DO
from.socket ← NSConstants.timeServerSocket;
BEGIN
ENABLE Inconsistent => RETRY;
pulsesSent: System.Pulses = System.GetClockPulses[];
SendTimeRequest[cH, from, (tries = 0), TRUE];
reset ← CollectTimeReplies[cH, pulsesSent];
END;
ENDLOOP;
Socket.Delete[cH];
EXITS NoReset => NULL;
END;
ResyncNow: PUBLIC ENTRY PROCEDURE = {
IF started THEN Process.Abort[surveyorProcess]};
SetParameters: PUBLIC ENTRY PROCEDURE [
drift, wobble: TimeServerClock.Rate, resetPeriod: CARDINAL] =
BEGIN
tsDrift ← drift; tsWobble ← wobble; tsResetPeriod ← resetPeriod + Random[];
IF started THEN Process.Abort[surveyorProcess]; -- signal new wait time
END;
Start: PUBLIC ENTRY PROCEDURE =
BEGIN ENABLE UNWIND => NULL;
IF started THEN RETURN;
clockInvalid ← FALSE;
tsVersion ← 0;
surveyorProcess ← FORK SurveyorProcess[];
started ← TRUE;
END;
Stop: PUBLIC ENTRY PROCEDURE =
BEGIN ENABLE UNWIND => NULL;
IF NOT started THEN RETURN;
started ← FALSE;
Process.Abort[surveyorProcess]; -- do after setting started to FALSE
JOIN surveyorProcess;
END;
-- private procedures
AdjustClockEntry: ENTRY PROCEDURE [
amount: LONG INTEGER, error: TimeServerClock.Error, version: LONG CARDINAL,
delay: LONG CARDINAL, who: System.NetworkAddress, useAlways: BOOLEAN] =
BEGIN ENABLE UNWIND => NULL;
me: TimeServerClock.Error = ErrorInternal[];
IF useAlways OR version > tsVersion
OR (version = tsVersion AND error < me) THEN
BEGIN
TimeServerLog.LogClockChange[
System.GetGreenwichMeanTime[], amount, who,
(me = TimeServerClock.undefined), me, error, delay, version];
SpecialSystem.AdjustClock[amount];
tsError ← error;
tsSourceLastReset ← who;
tsLastChange ← amount;
IF tsVersion < version THEN SendNewVersionNote[tsVersion ← version];
END;
END;
BroadcastAddress: PROCEDURE [net: System.NetworkNumber]
RETURNS [System.NetworkAddress] = INLINE {
RETURN[
[net: net, host: System.broadcastHostNumber,
socket: NSConstants.timeServerSocket]]};
CheckForConsistency: ENTRY PROCEDURE [
amount: LONG INTEGER, error: TimeServerClock.Error, version: LONG CARDINAL,
who: System.NetworkAddress] =
BEGIN ENABLE UNWIND => NULL;
MarkInconsistent: INTERNAL PROCEDURE =
BEGIN
now: System.GreenwichMeanTime = System.GetGreenwichMeanTime[];
TimeServerLog.LogInconsistancy[
who, now, me, System.AdjustGreenwichMeanTime[now, amount], error];
ignoringServer ← TRUE;
ignoringServerAddress ← who.host;
tsError ← TimeServerClock.undefined;
END;
me: TimeServerClock.Error = ErrorInternal[];
IF tsVersion = version
AND me # TimeServerClock.undefined AND ABS[amount*1000] > error + me THEN {
MarkInconsistent[]; ERROR Inconsistent};
END;
CollectTimeReplies: PROCEDURE [
cH: Socket.ChannelHandle, sent: System.Pulses] RETURNS [success: BOOLEAN] =
BEGIN
sendMsec: System.Microseconds = System.PulsesToMicroseconds[sent];
bestTime, time: LONG INTEGER;
bestError: LONG CARDINAL ← TimeServerClock.undefined;
bestVersion: LONG CARDINAL ← 0;
error, delay, version, bestDelay: LONG CARDINAL;
bestServer: System.NetworkAddress;
myHostNumber: System.HostNumber = Router.FindMyHostID[];
b: Buffer.NSBuffer;
success ← FALSE;
DO
b ← Socket.GetPacket[cH !
Socket.TimeOut => EXIT; ABORTED => IF started THEN RETRY];
IF b.ns.packetType = packetExchange
AND b.ns.exchangeType = PacketExchange.ExchangeClientType[timeService]
AND LOOPHOLE[b.ns.exchangeID, LONG CARDINAL] = lastID
AND b.ns.source.host # myHostNumber
AND (NOT ignoringServer OR b.ns.source.host # ignoringServerAddress) THEN
BEGIN
p: LONG POINTER TO TimeServerFormat.TSPacket =
LOOPHOLE[@b.ns.exchangeBody];
delay ← (System.PulsesToMicroseconds[System.GetClockPulses[]]-sendMsec)
/1000;
WITH r: p↑ SELECT FROM
internalTimeResponse =>
BEGIN
error ← TimeServerFormat.WireToLong[r.absoluteError];
IF error # TimeServerClock.undefined THEN
BEGIN
success ← TRUE;
error ← error + delay + 1000;
time ← System.SecondsSinceEpoch[TimeServerFormat.WireToGMT[r.time]]
- System.SecondsSinceEpoch[System.GetGreenwichMeanTime[]];
version ← TimeServerFormat.WireToLong[r.timeVersion];
IF version > bestVersion
OR (version = bestVersion AND error <= bestError) THEN {
bestTime ← time; bestError ← error; bestVersion ← version;
bestServer ← b.ns.source; bestDelay ← delay};
END;
END;
ENDCASE;
END;
Socket.ReturnBuffer[b];
ENDLOOP;
IF success THEN
BEGIN
CheckForConsistency[bestTime, bestError, bestVersion, bestServer];
AdjustClockEntry[bestTime, bestError, bestVersion, bestDelay,
bestServer, FALSE !
SpecialSystem.SetBackTooFar => {clockInvalid ← TRUE; CONTINUE}];
END;
END;
ErrorInternal: INTERNAL PROCEDURE RETURNS [error: LONG CARDINAL] =
BEGIN
wobbleBase, driftBase: LONG CARDINAL;
IF tsError = TimeServerClock.undefined THEN RETURN [tsError];
driftBase ← System.GetGreenwichMeanTime[] - SpecialSystem.TimeLastSet[];
wobbleBase ← MIN[tsWobble.base, driftBase];
error ← tsWobble.amount*wobbleBase/tsWobble.base
+ tsDrift.amount*driftBase/tsDrift.base;
RETURN[error + tsError];
END;
Init: PROCEDURE =
BEGIN
tsError ← TimeServerClock.undefined;
tsDrift ← [base: 86400, amount: 1000];
tsWobble ← [base: 3600, amount: 1000];
tsResetPeriod ← 15 + Random[];
END;
Random: PROCEDURE RETURNS [CARDINAL] =
-- This generates a "random" (across servers) number between 0 and 10
-- which is added to the reset rate in order to keep the server polling
-- unsynchronized
BEGIN
words: ARRAY [0.. SIZE[System.HostNumber]) OF CARDINAL
= LOOPHOLE[Router.FindMyHostID[]];
RETURN[Inline.DIVMOD[words[SIZE[System.HostNumber]-1], 10].remainder];
END;
RequestTime: PUBLIC PROCEDURE =
BEGIN
haveReply: BOOLEAN ← FALSE;
incID: BOOLEAN;
pulsesSent: System.Pulses;
cH: Socket.ChannelHandle ← Socket.Create[System.nullSocketNumber, 1, 5];
BEGIN ENABLE UNWIND => {Socket.Delete[cH]; Router.FillRoutingTable[0]};
Router.FillRoutingTable[];
Process.Pause[2*oneSecond];
FOR hops: CARDINAL IN [0.. Router.infinity) UNTIL haveReply DO
Socket.SetWaitTime[cH, WaitForHops[hops]];
incID ← TRUE;
THROUGH [0.. triesPerNetwork) UNTIL haveReply DO
pulsesSent ← System.GetClockPulses[];
IF hops = 0 THEN
BEGIN
SendTimeRequest[
cH, BroadcastAddress[System.nullNetworkNumber], TRUE, TRUE];
incID ← FALSE;
END
ELSE FOR net: System.NetworkNumber ←
Router.EnumerateRoutingTable[Router.startEnumeration, hops],
Router.EnumerateRoutingTable[net, hops]
UNTIL net = Router.endEnumeration DO
SendTimeRequest[cH, BroadcastAddress[net], incID, TRUE];
incID ← FALSE;
ENDLOOP;
-- if incID is FALSE here, then a time request was sent
IF NOT incID THEN haveReply ← CollectTimeReplies[cH, pulsesSent];
ENDLOOP;
ENDLOOP;
Socket.Delete[cH];
Router.FillRoutingTable[0];
END;
END;
SendNewVersionNote: INTERNAL PROCEDURE [new: LONG CARDINAL] =
BEGIN
cH: Socket.ChannelHandle ← Socket.Create[System.nullSocketNumber];
b: Buffer.NSBuffer = Socket.GetSendBuffer[cH];
note: LONG POINTER TO noteNewVersion TimeServerFormat.TSPacket
= LOOPHOLE[@b.ns.exchangeBody];
b.ns.packetType ← packetExchange;
b.ns.exchangeID ← LOOPHOLE[lastID];
b.ns.exchangeType ← PacketExchange.ExchangeClientType[timeService];
b.ns.destination ← BroadcastAddress[System.nullNetworkNumber];
Socket.SetPacketWords[b, 3 +
SIZE[noteNewVersion TimeServerFormat.TSPacket]];
note↑ ← [
version: TimeServerFormat.Version,
tsBody: noteNewVersion[TimeServerFormat.LongToWire[new]]];
Socket.BroadcastPacketToAllConnectedNets[cH, b];
Socket.Delete[cH];
END;
SendTimeRequest: PROCEDURE [
cH: Socket.ChannelHandle, who: System.NetworkAddress, incrementID: BOOLEAN,
internalFormat: BOOLEAN] =
BEGIN
b: Buffer.NSBuffer = Socket.GetSendBuffer[cH];
iReq: LONG POINTER TO internalTimeRequest TimeServerFormat.TSPacket
= LOOPHOLE[@b.ns.exchangeBody];
eReq: LONG POINTER TO timeRequest TimeServerFormat.TSPacket
= LOOPHOLE[@b.ns.exchangeBody];
IF incrementID THEN lastID ← lastID + 1;
b.ns.packetType ← packetExchange;
b.ns.exchangeID ← LOOPHOLE[lastID];
b.ns.exchangeType ← PacketExchange.ExchangeClientType[timeService];
b.ns.destination ← who;
Socket.SetPacketWords[b, 3 + (
IF internalFormat THEN SIZE[internalTimeRequest TimeServerFormat.TSPacket]
ELSE SIZE[timeRequest TimeServerFormat.TSPacket])];
IF internalFormat THEN
iReq↑ ← [version: TimeServerFormat.Version, tsBody: internalTimeRequest[]]
ELSE eReq↑ ← [version: TimeServerFormat.Version, tsBody: timeRequest[]];
(IF who.net = System.nullNetworkNumber THEN
Socket.BroadcastPacketToAllConnectedNets ELSE Socket.PutPacket)[cH, b]
END;
SurveyorProcess: PROCEDURE =
BEGIN
-- broadcasts a time request every tsResetPeriod minutes
Process.SetPriority[Process.priorityBackground];
UNTIL NOT started DO
ENABLE ABORTED => LOOP;
IF NOT SpecialSystem.clockSlipping
THEN RequestTime[! Inconsistent => RETRY];
ignoringServer ← FALSE;
Wait[tsResetPeriod];
ENDLOOP;
END;
Wait: PROCEDURE [time: CARDINAL -- minutes --] =
BEGIN ENABLE ABORTED => GOTO StopWaiting;
oneMinute: LONG CARDINAL = LONG[Process.SecondsToTicks[60]];
ticksToWait: LONG CARDINAL = oneMinute*LONG[time];
maxTicks: Process.Ticks = LAST[Process.Ticks];
ticksLeft: LONG CARDINAL;
FOR ticksLeft ← ticksToWait, ticksLeft - MIN[ticksLeft, maxTicks] UNTIL
ticksLeft = 0 DO Process.Pause[Inline.LowHalf[MIN[ticksLeft, maxTicks]]];
ENDLOOP;
EXITS StopWaiting => NULL;
END;
WaitForHops: PROCEDURE [hops: CARDINAL] RETURNS [delay: CARDINAL] = INLINE {
RETURN[MAX[2+3*(hops/2), 6]*1000]};
Init[];
END...