public static void OverrideSettingsFromArguments(string[] args)
{
Runner r = new Runner();
SetSettingsCommand ss = SetSettingsCommand.CreateSettingsCommand(
"Debugger",
new[] { "--set-settings", "-ss" },
FLScriptEditor.Settings
);
r._AddCommand(ss);
r._RunCommands(args);
}
protected override void AddCommands(Runner runner)
{
SetSettingsCommand cmd = new SetSettingsCommand(
SetSettingsCommand.Create(
SetSettingsCommand.Create("http", HttpSettings),
SetSettingsCommand.Create("run", RunSettings)
)
);
AbortRun = true;
runner._AddCommand(new DefaultHelpCommand(runner, true));
runner._AddCommand(cmd);
runner._AddCommand(new RunCommand(this));
runner._AddCommand(new ListSettingsCommand(cmd));
}
public override bool Run(string[] args)
{
EmbeddedFileIOManager.Initialize();
ManifestReader.RegisterAssembly(typeof(FLScriptGenerator).Assembly);
ManifestReader.PrepareManifestFiles(false);
Runner.AddCommand(new HelpCommand(new DefaultHelpCommand(true)));
Runner.AddCommand(SetSettingsCommand.CreateSettingsCommand("Settings", Settings));
Runner.RunCommands(args);
if (!DoExecute)
{
return(true);
}
Debug.DefaultInitialization();
ManifestReader.RegisterAssembly(Assembly.GetExecutingAssembly());
ManifestReader.PrepareManifestFiles(false);
ExtPPDebugConfig.Settings.MinSeverity = Verbosity.Silent;
OpenFLDebugConfig.Settings.MinSeverity = Verbosity.Level1;
OpenCLDebugConfig.Settings.MinSeverity = Verbosity.Silent;
Directory.CreateDirectory(Settings.OutputFolder);
Random rnd = new Random();
for (int i = 0; i < Settings.Amount; i++)
{
string file = Path.Combine(Settings.OutputFolder, "genscript." + i + ".fl");
Logger.Log(LogType.Log, "Generating Script...", 1);
string script = FLScriptGenerator.GenerateRandomScript(
rnd.Next(Settings.Functions.Min, Settings.Functions.Max),
rnd.Next(Settings.Buffers.Min, Settings.Buffers.Max),
rnd.Next(Settings.Additional.Min, Settings.Additional.Max),
rnd.Next(Settings.AdditionalFunctions.Min, Settings.AdditionalFunctions.Max));
Logger.Log(LogType.Log, "Finished Script. Lines: " + script.Count(x => x == '\n'), 1);
File.WriteAllText(file, script);
}
return(true);
}
public override bool Run(string[] args)
{
TypeAccumulator.RegisterAssembly(typeof(OpenFLDebugConfig).Assembly);
Debug.DefaultInitialization();
Runner.AddCommand(new HelpCommand(new DefaultHelpCommand(true)));
SetSettingsCommand cmd = SetSettingsCommand.CreateSettingsCommand("Settings", Settings);
Runner.AddCommand(new ListSettingsCommand(cmd));
Runner.AddCommand(cmd);
Runner.AddCommand(new MultiThreadFlagCommand());
Runner.AddCommand(new AddToCheckPipelineCommand());
Runner.RunCommands(args);
if (!DoExecute)
{
Console.ReadLine();
return(true);
}
string[] checkTypesStr = Settings.CheckPipeline.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
List <Type> checkTypes = new List <Type>();
foreach (string s in checkTypesStr)
{
List <Type> r = TypeAccumulator <FLProgramCheck> .GetTypesByName(s);
if (r.Count != 1)
{
Console.Write("");
}
checkTypes.AddRange(r);
}
ExtPPDebugConfig.Settings.MinSeverity = Verbosity.Silent;
OpenFLDebugConfig.Settings.MinSeverity = Verbosity.Level1;
OpenCLDebugConfig.Settings.MinSeverity = Verbosity.Silent;
List <string> files = GetFileList();
Logger.Log(LogType.Log, "------------------------Run Execution Started------------------------", 1);
for (int i = 0; i < Settings.TotalRepetitions; i++)
{
OpenFLBenchmarks.InitializeTestRun(Settings.PerformanceFolder);
Logger.Log(LogType.Log, $"------------------------Run {i} Started------------------------", 1);
Logger.Log(LogType.Log,
OpenFLBenchmarks.RunParserInitBenchmark("_run" + i, Settings.InitIterations,
Settings.PerformanceFolder, true, true), 1);
Logger.Log(LogType.Log,
OpenFLBenchmarks.RunParserProcessBenchmark("_run" + i, files, Settings.ParsingIterations,
Settings.PerformanceFolder,
checkTypes.ToArray(), UseMultiThread), 1);
Logger.Log(LogType.Log,
OpenFLBenchmarks.RunProgramInitBenchmark("_run" + i, files, Settings.InitIterations,
Settings.PerformanceFolder,
checkTypes.ToArray(), true), 1);
Logger.Log(LogType.Log,
OpenFLBenchmarks.RunProgramSerializationBenchmark("_run" + i, files, Settings.IOIterations,
Settings.ExtraSteps.Split(new[] { ';' }),
Settings.PerformanceFolder, checkTypes.ToArray(), true), 1);
Logger.Log(LogType.Log,
OpenFLBenchmarks.RunProgramDeserializationBenchmark("_run" + i, files, Settings.IOIterations,
Settings.PerformanceFolder, checkTypes.ToArray(), true), 1);
Logger.Log(LogType.Log,
OpenFLBenchmarks.RunParsedFLExecutionBenchmark(Settings.WarmProgram, "_run" + i, files, Settings.ExecutionIterations,
Settings.PerformanceFolder, checkTypes.ToArray(), true, 2), 1);
Logger.Log(LogType.Log,
OpenFLBenchmarks.RunDeserializedFLExecutionBenchmark("_run" + i, files,
Settings.ExecutionIterations,
Settings.PerformanceFolder, checkTypes.ToArray(), true, 2), 1);
OpenFLBenchmarks.FinalizeTestRun(Settings.PerformanceFolder);
Logger.Log(LogType.Log, $"------------------------Run {i} Finished------------------------", 1);
}
Logger.Log(LogType.Log, "------------------------Run Execution Finished------------------------", 1);
return(true);
}
public override StaticInspectionResult Process(LoadSourceStageResult input)
{
ImportOptions options = new ImportOptions();
Runner runner = new Runner();
runner._AddCommand(
SetSettingsCommand.CreateSettingsCommand(
"Import",
new[] { FLKeywords.SetParserOptionKey },
options
)
);
List <string> opts = FLParser.FindParserOptions(input.Source).ToList();
opts.Insert(0, FLKeywords.SetParserOptionKey);
runner._RunCommands(opts.ToArray());
if (options.OnlyAllowImport && input.MainFile)
{
throw new InvalidOperationException(
$"The Script {input.Filename} can not be loaded as Entry point. As the Option: Import.OnlyAllowImport is set to true in the script"
);
}
if (options.NoImport && !input.MainFile)
{
throw new InvalidOperationException(
$"The Script {input.Filename} can not be imported. As the Option: Import.NoImport is set to true in the script"
);
}
DefineStatement[] definedScripts = null;
DefineStatement[] definedBuffers = null;
List <StaticFunction> functions = null;
Logger.Log(LogType.Log, "Statically Inspecting: " + input.Filename, 1);
Task <DefineStatement[]> scriptTask =
new Task <DefineStatement[]>(() => FLParser.FindDefineScriptsStatements(input.Source));
Task <DefineStatement[]> bufferTask =
new Task <DefineStatement[]>(() => FLParser.FindDefineStatements(input.Source));
if (parser.WorkItemRunnerSettings.UseMultithread)
{
scriptTask.Start();
bufferTask.Start();
}
else
{
scriptTask.RunSynchronously();
bufferTask.RunSynchronously();
}
StaticFunctionHeader[] functionsHeaders = FLParser.FindFunctionHeaders(input.Source)
.Select(x => new StaticFunctionHeader(x)).ToArray();
functions = WorkItemRunner.RunInWorkItems(
functionsHeaders.ToList(),
(list, start, count) =>
ParseFunctionTask(list, start, count, input.Source),
parser.WorkItemRunnerSettings
);
Task.WaitAll(scriptTask, bufferTask);
Logger.Log(LogType.Log, "Buffer And Script Tasks Finished.", 1);
definedScripts = scriptTask.Result;
definedBuffers = bufferTask.Result;
Logger.Log(LogType.Log, "Tasks Completed.", 1);
Logger.Log(LogType.Log, "Parsed Scripts: " + functions.Unpack(", "), 4);
return(new StaticInspectionResult(
input.Filename,
input.Source,
functions,
definedBuffers,
definedScripts,
options,
input.AdditionalKernels
));
}
