private Process GetOnlineProcess(DataDescription data, int len, Experiment ex)
{
string test = ex == Experiment.Precision ? "o" : "rt";
Process proc = TemplateProcess();
proc.StartInfo.FileName = EnvPath + "../cmake-build-debug/incCD";
proc.StartInfo.Arguments = $"-alg ogdimpute -test {test} -n {data.N} -m {data.M} -k {AlgoPack.TypicalTruncation} " +
$"-in ./{SubFolderDataIn}{data.Code}_m{len}.txt " +
$"-out ./{SubFolderDataOut}{AlgCode}{len}.txt" + " -xtra stream";
return(proc);
}
private Process GetOfflineProcess(DataDescription data, int len, int k, Experiment ex)
{
string test = ex == Experiment.Precision ? "o" : "rt";
Process proc = TemplateProcess();
proc.StartInfo.FileName = EnvPath + "../cmake-build-debug/incCD";
proc.StartInfo.Arguments = $"-alg cd-ssv -test {test} -n {data.N} -m {data.M} -k {k} " +
$"-in ./{SubFolderDataIn}{data.Code}_m{len}.txt " +
$"-out ./{SubFolderDataOut}{AlgCode}{len}_k{k}.txt";
return(proc);
}
private Process GetRuntimeMDISVDProcess(DataDescription data, int len, bool stream)
{
Process isvdproc = new Process();
isvdproc.StartInfo.WorkingDirectory = EnvPath;
isvdproc.StartInfo.FileName = EnvPath + "../cmake-build-debug/incCD";
isvdproc.StartInfo.CreateNoWindow = true;
isvdproc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
isvdproc.StartInfo.UseShellExecute = false;
isvdproc.StartInfo.Arguments = $"-alg mdisvd -test rt -n {data.N} -m {data.M} -k {AlgoPack.TypicalTruncation} " +
$"-in ./{SubFolderDataIn}{data.Code}_m{len}.txt " +
$"-out ./{SubFolderDataOut}{AlgCode}{len}.txt " + (stream ? "-xtra stream" : "");
return(isvdproc);
}
private Process GetRuntimeSpiritProcess(DataDescription data, int tcase, bool streaming)
{
Process spiritproc = new Process();
spiritproc.StartInfo.WorkingDirectory = EnvPath;
spiritproc.StartInfo.FileName = EnvPath + "../cmake-build-debug/algoCollection";
spiritproc.StartInfo.CreateNoWindow = true;
spiritproc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
spiritproc.StartInfo.UseShellExecute = false;
spiritproc.StartInfo.Arguments = $"-alg spirit -test rt -n {data.N} -m {data.M} -k {Truncation} " +
$"-in ./{SubFolderDataIn}{data.Code}_m{tcase}.txt " +
$"-out ./{SubFolderDataOut}{AlgCode}{tcase}.txt";
return(spiritproc);
}
private Process GetRuntimeOGDProcess(DataDescription data, int len)
{
Process ogdproc = new Process();
ogdproc.StartInfo.WorkingDirectory = EnvPath;
ogdproc.StartInfo.FileName = EnvPath + "../cmake-build-debug/incCD";
ogdproc.StartInfo.CreateNoWindow = true;
ogdproc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
ogdproc.StartInfo.UseShellExecute = false;
ogdproc.StartInfo.Arguments = $"-alg ogdimpute -test rt -n {data.N} -m {data.M} -k {AlgoPack.TypicalTruncation} " +
$"-in ./{SubFolderDataIn}{data.Code}_m{len}.txt " +
$"-out ./{SubFolderDataOut}{AlgCode}{len}.txt";
return(ogdproc);
}
private Process GetRuntimeTrmfProcess(DataDescription data, int len)
{
Process trmfproc = new Process();
trmfproc.StartInfo.WorkingDirectory = EnvPath;
trmfproc.StartInfo.FileName = "octave-cli";
trmfproc.StartInfo.CreateNoWindow = true;
trmfproc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
trmfproc.StartInfo.UseShellExecute = false;
string functionArgs = $"{len}, '{data.Code}', {Truncation}";
trmfproc.StartInfo.Arguments = $"--eval \"experimentRun({functionArgs}, 1, {Truncation})\"";
return(trmfproc);
}
private Process GetCdProcess(int n, int m, DataDescription data, int len, int k)
{
Process cdproc = new Process();
cdproc.StartInfo.WorkingDirectory = EnvPath;
cdproc.StartInfo.FileName = EnvPath + "../cmake-build-debug/algoCollection";
cdproc.StartInfo.CreateNoWindow = true;
cdproc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
cdproc.StartInfo.UseShellExecute = false;
cdproc.StartInfo.Arguments = $"-test r -n {n} -m {m} -k {k} " +
$"-in ./{SubFolderDataIn}{data.Code}_m{len}.txt " +
$"-out ./{SubFolderDataOut}{AlgCode}{len}_k{k}.txt";
return(cdproc);
}
private Process GetRuntimeROSLProcess(DataDescription data, int len)
{
Process roslproc = new Process();
roslproc.StartInfo.WorkingDirectory = EnvPath;
roslproc.StartInfo.FileName = EnvPath + "../cmake-build-debug/algoCollection";
roslproc.StartInfo.CreateNoWindow = true;
roslproc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
roslproc.StartInfo.UseShellExecute = false;
roslproc.StartInfo.Arguments = $"-alg rosl -test rt -n {data.N} -m {data.M} -k {Truncation} " +
$"-in ./{SubFolderDataIn}{data.Code}_m{len}.txt " +
$"-out ./{SubFolderDataOut}{AlgCode}{len}.txt";
return(roslproc);
}
private Process GetRuntimeprocess(DataDescription data, int len)
{
Process proc = new Process();
proc.StartInfo.WorkingDirectory = EnvPath;
proc.StartInfo.FileName = "python2";
proc.StartInfo.CreateNoWindow = true;
proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
proc.StartInfo.UseShellExecute = false;
string functionArgs = $"--input \"{SubFolderDataIn}{data.Code}_m{len}.txt\" --output \"{SubFolderDataOut}{AlgCode}{len}.txt\"";
proc.StartInfo.Arguments = $"main.py --epochs {Epochs} --batch_size 64 --model brits_i_univ {functionArgs} --runtime 1";
return(proc);
}
private Process GetRuntimeMRNNProcess(DataDescription data, int len)
{
Process mrnnproc = new Process();
mrnnproc.StartInfo.WorkingDirectory = EnvPath;
mrnnproc.StartInfo.FileName = "python";
mrnnproc.StartInfo.CreateNoWindow = true;
mrnnproc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
mrnnproc.StartInfo.UseShellExecute = false;
string functionArgs = $"\"{SubFolderDataIn}{data.Code}_m{len}.txt\", \"{SubFolderDataOut}{AlgCode}{len}.txt\", 1";
mrnnproc.StartInfo.Arguments = "-c 'from testerMRNN import mrnn_recov; " +
$"mrnn_recov({functionArgs})'";
return(mrnnproc);
}
private Process GetProcess(DataDescription data, int len, bool runtime)
{
Process proc = new Process();
proc.StartInfo.WorkingDirectory = EnvPath;
proc.StartInfo.FileName = "python";
proc.StartInfo.CreateNoWindow = true;
proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
proc.StartInfo.UseShellExecute = false;
string functionArgs = $"\"{SubFolderDataIn}{data.Code}_m{len}.txt\", \"{SubFolderDataOut}{AlgCode}{len}.txt\", {(runtime ? 1 : 0)}";
proc.StartInfo.Arguments = "-c 'from recovery import rmv_main; " +
$"rmv_main(\"{AlgCode}\", {functionArgs})'";
return(proc);
}
private Process GetRuntimeStmvlProcess(int finalN, int finalM, DataDescription data, int len)
{
Process stmvlproc = new Process();
stmvlproc.StartInfo.WorkingDirectory = EnvPath;
stmvlproc.StartInfo.FileName = EnvPath + "../cmake-build-debug/algoCollection";
stmvlproc.StartInfo.CreateNoWindow = true;
stmvlproc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
stmvlproc.StartInfo.UseShellExecute = false;
stmvlproc.StartInfo.Arguments = $"-alg st-mvl -test rt -n {data.N} -m {data.M} -k {(int)(Alpha * 1000.0)} " +
$"-xtra {SubFolderDataIn}{data.Code}_m{len}_latlng.txt " +
$"-in ./{SubFolderDataIn}{data.Code}_m{len}.txt " +
$"-out ./{SubFolderDataOut}{AlgCode}{len}.txt";
return(stmvlproc);
}
private Process GetSVTProcess(DataDescription data, int len)
{
Process svtproc = new Process();
svtproc.StartInfo.WorkingDirectory = EnvPath;
svtproc.StartInfo.FileName = EnvPath + "../cmake-build-debug/algoCollection";
svtproc.StartInfo.CreateNoWindow = true;
svtproc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
svtproc.StartInfo.UseShellExecute = false;
svtproc.StartInfo.Arguments = $"-alg svt -test o -n {data.N} -m {data.M} -k {AlgoPack.TypicalTruncation} " +
$"-in ./{SubFolderDataIn}{data.Code}_m{len}.txt " +
$"-out ./{SubFolderDataOut}{AlgCode}{len}.txt " +
$"-xtra {TauScale}";
return(svtproc);
}
private Process GetRuntimeSSAProcess(DataDescription data, int len)
{
Process ssaproc = new Process();
ssaproc.StartInfo.WorkingDirectory = EnvPath;
ssaproc.StartInfo.FileName = "python";
ssaproc.StartInfo.CreateNoWindow = true;
ssaproc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
ssaproc.StartInfo.UseShellExecute = false;
string functionArgs = $"\"{SubFolderDataIn}{data.Code}_m{len}_ts.txt\", \"{SubFolderDataIn}{data.Code}_m{len}.txt\", \"{SubFolderDataOut}{AlgCode}{len}.txt\", 1, 2";
ssaproc.StartInfo.Arguments = "-c 'from testScriptSynthControlALS import rmv_mydata; " +
$"rmv_mydata({functionArgs})'";
return(ssaproc);
}
private void TypeReferencer(DataDescription dataEntry)
{
//Check SymbolTable for dataEntry DataType.Name
var types = dataEntry.SymbolTable.GetType(dataEntry.DataType);
if (types.Count != 1)
{
return;
}
//Add this dataEntry to type references
var typeToUpdate = types.First();
if (typeToUpdate == null)
{
return;
}
typeToUpdate.References.Add(dataEntry);
}
private void CheckVariableDeclarations()
{
// Find all source/sources and give them types or references to definitions
foreach (Identifier id in _program.VariableReferences)
{
//Identifier id = program.VariableReferences[key] as Identifier;
DataDescription definition = _program.VariableDeclarations[id.Name] as DataDescription;
ClassDefinition classDef;
if (definition == null)
{
//Console.WriteLine("No VariableDeclaration for "+id.Name);
//Check class defs
if (_program.Environment != null)
{
if (_program.Environment.ConfigurationSection != null)
{
if (_program.Environment.ConfigurationSection.Repository != null)
{
classDef = _program.ClassDeclarations[id.Name] as ClassDefinition;
if (classDef != null)
{
id.ClassDefinition = classDef;
continue;
}
}
}
}
//Built-in identifiers...
switch (id.Name.ToUpper())
{
case "ZERO":
break;
default:
throw new UndefinedVariableException(id.LineNumber, id.Name);
}
}
id.Definition = definition;
}
}
private Process GetProcess(DataDescription data, int len, bool runtime)
{
Process proc = new Process();
proc.StartInfo.WorkingDirectory = EnvPath;
proc.StartInfo.FileName = "octave-cli";
proc.StartInfo.CreateNoWindow = true;
proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
proc.StartInfo.UseShellExecute = false;
string functionArgs = $"'{SubFolderDataIn}{data.Code}_m{len}.txt', '{SubFolderDataOut}{AlgCode}{len}.txt', {(runtime ? 1 : 0)}";
if (proc.StartInfo.FileName.Contains("octave"))
{
proc.StartInfo.Arguments = $"--eval \"recovery('{AlgCode}', {functionArgs})\"";
}
else
{
proc.StartInfo.Arguments = $"-nodisplay -r \"recovery('{AlgCode}', {functionArgs})\"";
}
return(proc);
}
private void AddToSymbolTable(DataDescription node)
{
var table = node.SymbolTable;
if (node.CodeElement().IsGlobal&& table.CurrentScope != SymbolTable.Scope.GlobalStorage)
{
table = table.GetTableFromScope(SymbolTable.Scope.Global);
}
else
{
var parent = node.Parent as DataDescription;
while (parent != null)
{
if (parent.CodeElement().IsGlobal&& table.CurrentScope != SymbolTable.Scope.GlobalStorage)
{
table = table.GetTableFromScope(SymbolTable.Scope.Global);
}
parent = parent.Parent as DataDescription;
}
}
table.AddVariable(node);
}
protected override void PrecisionExperiment(ExperimentType et, ExperimentScenario es,
DataDescription data, int tcase)
{
RunNnmf(GetNnmfProcess(data, tcase, "False", "False"));
}
protected override void RuntimeExperiment(ExperimentType et, ExperimentScenario es, DataDescription data,
int tcase)
{
if (et == ExperimentType.Streaming)
{
RunTkcm(GetStreamingTkcmProcess(data, tcase, es));
}
else
{
RunTkcm(GetRuntimeTkcmProcess(data, tcase, es));
}
}
protected override void RuntimeExperiment(ExperimentType et, ExperimentScenario es, DataDescription data,
int tcase)
{
Run(et == ExperimentType.Streaming
? GetOnlineProcess(data, tcase, Experiment.Runtime)
: GetOfflineProcess(data, tcase, Experiment.Runtime));
}
public TypedDataNode(DataDescription node)
: base(null)
{
this.Node = node;
}
protected override void PrecisionExperiment(ExperimentType et, ExperimentScenario es,
DataDescription data, int tcase)
{
RunTkcm(GetTkcmProcess(data, tcase, es));
}
protected abstract void RuntimeExperiment(ExperimentType et, ExperimentScenario es, DataDescription data, int tcase);
protected override void RuntimeExperiment(ExperimentType et, ExperimentScenario es, DataDescription data,
int tcase)
{
RunSSA(GetRuntimeSSAProcess(data, tcase));
}
protected override void PrecisionExperiment(ExperimentType et, ExperimentScenario es,
DataDescription data, int tcase)
{
RunSVDImpute(GetSVDImputeProcess(data, tcase));
}
// [/COBOL 2002]
private void EnterDataDescriptionEntry(DataDescriptionEntry data)
{
SetCurrentNodeToTopLevelItem(data.LevelNumber.Value);
var node = new DataDescription(data);
Enter(node);
if (!node.IsPartOfATypeDef) node.SymbolTable.AddVariable(node);
}
protected override void PrecisionExperiment(ExperimentType et, ExperimentScenario es,
DataDescription data, int tcase)
{
RunDynaMMo(GetDynaMMoProcess(data, tcase));
}
protected override void PrecisionExperiment(ExperimentType et, ExperimentScenario es,
DataDescription data, int tcase)
{
KList.ForEach(k => RunCd(GetCdProcess(data.N, data.M, data, tcase, k)));
}
private void EnterDataDescriptionEntry(DataDescriptionEntry data)
{
SetCurrentNodeToTopLevelItem(data.LevelNumber);
var node = new DataDescription(data);
Enter(node);
AddToSymbolTable(node);
}
public DataDescription[] GetSubItems()
{
Log.Debug($"GetSubItems called on path {Path}");
if (Path == null || Path == OPCEventFlowBehavior.SNAPSHOT_DATA) // If we're at the top, just return all server names:
{
return(opcServerOrm.Fetch()
.Select(x => new DataDescription(typeof(OPCDataProvider), x.GetEntity().EntityName, false)
{
NestedVariableName = x.GetEntity().EntityName
}).ToArray());
}
string[] pathSplit = Path.Split(new char[] { '.' }, 2); // {Server Name}.{remaining.tag.path}
DynamicORM orm = new DynamicORM();
HashSet <string> nextPaths = new HashSet <string>();
List <DataDescription> dds = new List <DataDescription>();
foreach (string key in OPCEngine.mostRecentValues.Keys) // keys are like "<guid>|Channel1.Device1.Tag1"
{
string[] keySplit = key.Split('|');
string eventId = keySplit[0];
string keyTagPath = keySplit[1];
OPCEvent ev = orm.Fetch(typeof(OPCEvent), eventId) as OPCEvent;
if (ev == null)
{
throw new Exception("OPCEvent not found with id " + eventId);
}
string serverName = (orm.Fetch(typeof(Folder), ev.EntityFolderID) as Folder)?.EntityName;
if (string.IsNullOrEmpty(serverName))
{
throw new Exception("Server name not found");
}
if (serverName != pathSplit[0])
{
continue;
}
if (pathSplit.Length == 1) // This is the node for the server, so include everything under it:
{
nextPaths.Add(keyTagPath.Split('.')[0]);
}
else
{
// If "Channel1.Device1.Tag1" starts with "Channel1.Device1", for example:
if (keyTagPath.StartsWith(pathSplit[1]))
{
string remainingPath = keyTagPath.Substring(pathSplit[1].Length + 1); // "Tag1"
string[] splitRemaining = remainingPath.Split('.');
if (splitRemaining.Length == 1) // This is a tag, so find its type
{
BaseTagValue tagValue;
if (!OPCEngine.mostRecentValues.TryGetValue(key, out tagValue))
{
throw new Exception("Could not find type for tag " + key);
}
if (dds.Any(d => d.Name == splitRemaining[0])) // Don't create duplicates - most recent value will be used.
{
continue;
}
DataDescription dd = TagValueUtils.GetDataDescriptionFromTagType(tagValue.GetType(), splitRemaining[0]);
dd.NestedVariableName = $"{this.Path}.{splitRemaining[0]}";
dds.Add(dd);
}
else
{
nextPaths.Add(splitRemaining[0]);
}
}
}
}
foreach (string nextPath in nextPaths)
{
dds.Add(new DataDescription(typeof(OPCDataProvider), nextPath, false)
{
NestedVariableName = $"{this.Path}.{nextPath}"
});
}
return(dds.ToArray());
}
public override bool Visit(DataDescription dataEntry)
{
TypeReferencer(dataEntry);
return(base.Visit(dataEntry));
}
// [/COBOL 2002]
private void AddToSymbolTable(DataDescription node)
{
if (node.IsPartOfATypeDef) return;
var table = node.SymbolTable;
if (node.CodeElement().IsGlobal)
while(table.CurrentScope != SymbolTable.Scope.Global)
table = table.EnclosingScope;
table.AddVariable(node);
}
public virtual void StartDataDescriptionEntry(DataDescriptionEntry entry)
{
var dataTypeDescriptionEntry = entry as DataTypeDescriptionEntry;
if (dataTypeDescriptionEntry != null)
{
StartTypeDefinitionEntry(dataTypeDescriptionEntry);
}
else
{
SetCurrentNodeToTopLevelItem(entry.LevelNumber);
//Update DataType of CodeElement by searching info on the declared Type into SymbolTable.
//Note that the AST is not complete here, but you can only refer to a Type that has previously been defined.
var node = new DataDescription(entry);
if (_CurrentTypeDefinition != null)
{
node.ParentTypeDefinition = _CurrentTypeDefinition;
}
Enter(node);
if (entry.Indexes != null && entry.Indexes.Any())
{
var table = node.SymbolTable;
foreach (var index in entry.Indexes)
{
if (node.CodeElement().IsGlobal)
{
table = table.GetTableFromScope(SymbolTable.Scope.Global);
}
var indexNode = new IndexDefinition(index);
Enter(indexNode, null, table);
if (_CurrentTypeDefinition != null)
{
indexNode.ParentTypeDefinition = _CurrentTypeDefinition;
}
table.AddVariable(indexNode);
Exit();
}
}
var types = node.SymbolTable.GetType(node);
if (types.Count == 1)
{
entry.DataType.RestrictionLevel = types[0].DataType.RestrictionLevel;
}
//else do nothing, it's an error that will be handled by Cobol2002Checker
if (_IsInsideWorkingStorageContext)
{
node.SetFlag(Node.Flag.WorkingSectionNode, true); //Set flag to know that this node belongs to Working Storage Section
}
if (_IsInsideLinkageSectionContext)
{
node.SetFlag(Node.Flag.LinkageSectionNode, true); //Set flag to know that this node belongs to Linkage Section
}
if (_IsInsideLocalStorageSectionContext)
{
node.SetFlag(Node.Flag.LocalStorageSectionNode, true); //Set flag to know that this node belongs to Local Storage Section
}
if (_IsInsideFileSectionContext)
{
node.SetFlag(Node.Flag.FileSectionNode, true); //Set flag to know that this node belongs to File Section
}
if (_IsInsideGlobalStorageSection)
{
node.SetFlag(Node.Flag.GlobalStorageSection, true); //Set flag to know that this node belongs to Global Storage Section
}
AddToSymbolTable(node);
}
}
