
DIRECTORY
IO, Rope, RedBlackTree, BasicTime, PFS, Commander, CommanderOps, QPSolve;

AnalyzeDumpLogsImpl: CEDAR PROGRAM
IMPORTS IO, Rope, RedBlackTree, BasicTime, PFS, Commander, CommanderOps, QPSolve
~ BEGIN

ROPE: TYPE ~ Rope.ROPE;
STREAM: TYPE ~ IO.STREAM;

nullGMT: BasicTime.GMT ~ BasicTime.nullGMT;

LogContents: TYPE ~ REF LogContentsRep;
LogContentsRep: TYPE ~ RECORD [
tree: RedBlackTree.Table
];

FS: TYPE ~ REF FSRep;
FSRep: TYPE ~ RECORD [
name: ROPE,
level0Size: INT м 0,
nIncrs: INT м 0,
incrs: LIST OF Incr м NIL
];
Incr: TYPE ~ RECORD [
days: INT,
size: INT
];

halfDay: INT ~ 12*60*60; -- 12 hours of seconds
wholeDay: INT ~ 2*halfDay; -- 24 hours of seconds

GetKey: RedBlackTree.GetKey ~ {
fs: FS ~ NARROW[data];
RETURN[fs.name];
};
Compare: RedBlackTree.Compare ~ {
key: ROPE м NARROW[k];
fs: FS ~ NARROW[data];
RETURN [ Rope.Compare[key, fs.name] ];
};
ReadFilteredLog: PROC [in: STREAM, msgs: STREAM] RETURNS [lc: LogContents] ~ {
lineSelect: ROPE м in.GetTokenRope[].token;
currentFS: FS;
currLine: INT м 0;
lev5Date: BasicTime.GMT;
lev0Date: BasicTime.GMT;
DoDriveLine: PROC ~ {
ExceptWhitespace: IO.BreakProc ~ {
RETURN[SELECT char FROM
IN [IO.NUL .. IO.SP] => sepr,
ENDCASE => other]
};
drive: ROPE м in.GetTokenRope[ExceptWhitespace].token;
IF (currentFS м NARROW[lc.tree.Lookup[drive]]) = NIL THEN {
currentFS м NEW[FSRep м [name: drive]];
lc.tree.Insert[currentFS, drive];
};
lev5Date м nullGMT;
lev0Date м nullGMT;
};
DoLev5Line: PROC ~ {
lev5Date м in.GetTime[];
};
DoLev0Line: PROC ~ {
lev0Date м in.GetTime[];
};
DoSizeLine: PROC ~ {
dumpSize: INT м in.GetInt[];
SELECT TRUE FROM
lev5Date # nullGMT AND lev0Date # nullGMT => {
daysSinceLev0: INT м (BasicTime.Period[from~lev0Date, to~lev5Date]+halfDay)/wholeDay;
currentFS.incrs м CONS[[size~dumpSize, days~daysSinceLev0], currentFS.incrs];
currentFS.nIncrs м currentFS.nIncrs+1;
};
lev0Date # nullGMT => {
currentFS.level0Size м dumpSize;
};
ENDCASE => NULL;
};
{
ENABLE {
IO.EndOfStream=> GOTO done;
};
lc м NEW[LogContentsRep];
lc.tree м RedBlackTree.Create[GetKey, Compare];
currLine м 0;
DO
currLine м currLine+1;
{
ENABLE {
IO.Error=> {
msgs.PutF["Parsing error in line %g at position %g of input file.\n",
[integer[currLine]], [integer[in.GetIndex[]]]];
CONTINUE
};
};
SELECT TRUE FROM
Rope.Equal[lineSelect, "drive"] => DoDriveLine[];
Rope.Equal[lineSelect, "level5"] => DoLev5Line[];
Rope.Equal[lineSelect, "level0"] => DoLev0Line[];
Rope.Equal[lineSelect, "size"] => DoSizeLine[];
ENDCASE => NULL;
};
[] м in.GetLineRope[];
lineSelect м in.GetTokenRope[].token;
ENDLOOP;
EXITS done => RETURN;
}
};

AnalyzeOneFS: PROC [fs: FS, out: STREAM] ~ {
IF fs.level0Size = 0 THEN {
out.PutF1["No full dump data for %g.  Can't compute percentages for incrementals.\n", [rope[fs.name]]];
RETURN;
};
SELECT fs.nIncrs FROM
0 => {
out.PutF1["No incremental data for %g.\n", [rope[fs.name]]];
RETURN;
};
1 => {
out.PutF["%g %g (based on one incremental dump).\n", [rope[fs.name]], 
[real[(100.0*fs.incrs.first.size)/fs.level0Size]] ]; 
RETURN;
};
ENDCASE => NULL;
{
l: LIST OF Incr м fs.incrs;
c: QPSolve.RVector ~ NEW[QPSolve.RVectorRep[2+fs.nIncrs] ];
A: QPSolve.Matrix ~ QPSolve.NewMatrix[fs.nIncrs, 2+fs.nIncrs];
lobd: QPSolve.RVector ~ NEW[QPSolve.RVectorRep[2+fs.nIncrs]];
x: QPSolve.RVector ~ NEW[QPSolve.RVectorRep[2+fs.nIncrs]];
iVar: QPSolve.IVector ~ NEW[QPSolve.IVectorRep[2+fs.nIncrs]];
minMaxDay: INT м INT.LAST;
maxbd: REAL м 0;
nFR: NAT м 0;
nFX: NAT м  2+fs.nIncrs-1;
sum: REAL м 0;
c.n м 2+fs.nIncrs;
lobd.n м 2+fs.nIncrs;
x.n м 2+fs.nIncrs;
iVar.n м 2+fs.nIncrs;
FOR i: INT IN [0..fs.nIncrs) DO
A[i][0] м 1;
A[i][1] м l.first.days;
sum м sum + l.first.days;
A[i][2+i] м -1;
lobd[2+i] м (100.0*l.first.size)/fs.level0Size;
IF lobd[2+i] >= maxbd THEN {
maxbd м lobd[2+i];
IF l.first.days < minMaxDay  THEN minMaxDay м l.first.days;
};
c[2+i] м 0;
l м l.rest;
ENDLOOP;
FOR i: INT IN [0..fs.nIncrs) DO
x[2+i] м maxbd;
IF lobd[2+i]= maxbd AND A[i][1]=minMaxDay THEN {
iVar[nFX] м 2+i;
nFX м nFX-1;
}
ELSE {
IF lobd[2+i]= maxbd THEN lobd[2+i] м .9999*lobd[2+i]; -- hack to preserve dimension of problem
iVar[nFR] м 2+i;
nFR м nFR+1;
};
ENDLOOP;
x[0] м maxbd;
iVar[nFR] м 0;
x[1] м 0;
iVar[nFX] м 1;
nFR м nFX;
c[0] м fs.nIncrs*1.0e3;
c[1] м sum*1.0e3; 
[] м QPSolve.QPSolve[c, A, lobd, x, iVar, nFR];
out.PutFL["%g %4g %4g (based on %g incrementals).\n", LIST[[rope[fs.name]], [real[x[0]]], [real[x[1]]], [integer[fs.nIncrs]]]];
};
};

AnalyzeDumpLog: Commander.CommandProc ~ {
inStream: STREAM м PFS.StreamOpen[PFS.PathFromRope[CommanderOps.NextArgument[cmd]]];
lc: LogContents м ReadFilteredLog[inStream, cmd.out];
EachFS: RedBlackTree.EachNode ~ { 
fs: FS м NARROW[data];
AnalyzeOneFS[fs, cmd.out];
};
RedBlackTree.EnumerateIncreasing[lc.tree, EachFS];
};

Commander.Register["AnalyzeDumpLog", AnalyzeDumpLog];
END.
    
AnalyzeDumpLogsImpl.mesa
Copyright ╙ 1992 by Xerox Corporation.  All rights reserved.
Chauser, April 9, 1992 3:45 pm PDT

This program analyzes unix dump logs to produce the statistics about incremental dumps used by the dump schedule generator.  The current model for the size of the incremental dump is (FSSize*a0 + FSSize*a1*(numberOfDays-since-fullDump)).  a0 and a1 are determined by linear programming from a set of constraints generated from an existing set of dumps. based on the actual size of the level 0 dumps.

Э╩b  ХNewlineDelimiter
Ц(cedarcode) styleЩ ЪЬЩJЪЬ
╧eЬ1Щ<JЩ"JЩ JЩПJЩ ЧIcodeШ Ъ╧k	Ш	KЪЬIШIKШ ЧKЪ╧nЬЮЬЮШ"KЪЮЬЮЬ!ЮЬ ШPЪЬЮШKШ KШKЪЮЬЮЬЮЬЮЬШKШ KЪЬЮЬШ+KШ KЪЬЮЬЮЬШ'ЪЬЮЬЮЬШKШKЪЬШKШ ЧKЪЮЬЮЬЮЬШЪЬЮЬЮЬШKЪЬЮЬШKЪЬЮЬШKЪЬЮЬШKЪЬЮЬЮЬЮШKЪЬШЧЪЬЮЬЮЬШKЪЬЮЬШ
KЪЬЮШ	KЪЬШKШ ЧKШ/KШ1KШ ЪЯЬШKЪЬЮЬЮЬШKЪЮЬ
ШKЪЬШЧЪЯЬШ!KЪЬЮЬЮЬШKЪЬЮЬЮЬШKЪЮЬ Ш&KЪЬШЧЪ
ЯЬЮЬЮЬЮЬЮЬШNKЪЬЮЬШ+KШKЪЬ
ЮЬШKШKШЪЯЬЮЬШЪЯЬЮЬШ"ЪЮЬЮЬЮШKЪЮЬЮЬЮЬ
ШKЪЮЬ
ШЧKЪЬШЧKЪЬЮЬ+Ш6ЪЮЬЮЬЮЬЮЬШ;KЪЬЮЬШ'KШ!KЪЬШЧKШKШKШЧЪЯ
ЬЮЬШKШKШЧЪЯ
ЬЮЬШKШKШЧЪЯ
ЬЮЬШKЪЬ
ЮЬШЪЮЬЮЬЮШЪЬЮЬШ.KЪЬЮЬCШUKЪЬЮЬ7ШMKШ&KЪЬШЧЪЬШKШ KЪЬШЧKЪЮЬЮЬШЧKШЧЪЬШЪЮЬШKЪЮЬЮЬШKШЧKЪЬЮЬШKШ/KШЪЮШKШШЪЮЬШЪЮЬ
ШШEKШ/KЪЮШЧKЪЬШЧKШЧЪЮЬЮЬЮШKШ1KШ1KШ1KШ/KЪЮЬЮЬШЧKШЧKШKШ%KЪЮЬШЧKЪЮЬ	ЮЬШKЪЬШЧKШKШ ЧЪЯЬЮЬЮЬШ,ЪЮЬЮЬШKШgKЪЮЬШ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ШKШKШKШ/ЪЮЬЮЬШKШKЪЮЬЮЬШ;KШЧKШKШKЪЮЬШЧЪЮЬЮЬЮЬЮШKШЪЮЬЮЬЮЬШ0KШKШKЪЬШЧЪЮЬШKЪЮЬЮЬ╧c(Ш^KШKШKЪЬШЧKЪЮЬШЧKШKШKШ	KШKШ
KШKШKШ/KШKЪЬШЧKЪЬШЧЧШ ЪЯЬШ)KЪЬ
ЮЬЮЬЮЬ/ШTKШ5ЪЯЬШ"KЪЬ	ЮЬШKЪЬШKШЧKШ2KЪЬШЧKШ KЪЬ5Ш5ЧKЪЮЬШЧ ЕЧ    ╩  >  