public void Stop()
{
commandWorker.CancelAsync();
PercentProgress = 0;
ProgressText = "Execution Stopped";
loaderInstance = null;
}
public override void Run(ModelLoaderInterface loader)
{
Factory.Provider.StartSockets();
parallelMode = ParallelMode.RealTime;
Factory.SysLog.RegisterHistorical("FIXSimulator", GetDefaultLogConfig());
Factory.SysLog.RegisterRealTime("FIXSimulator", GetDefaultLogConfig());
Config = "WarehouseTest.config";
Address = "inprocess";
//TODO: Needs to support seperate tests
#if USE_MBT
var provider = "MBTFIXProvider/Simulate";
var assemblyName = "MBTFIXProvider";
#else
AddProvider("LimeFIXProvider/Simulate");
var provider = "LimeProvider/Simulate";
var assemblyName = "LimeProvider";
#endif
AddProvider(provider);
SetupProviderServiceConfig();
var providerManager = Factory.Parallel.SpawnProvider("ProviderCommon", "ProviderManager");
providerManager.SendEvent(new EventItem(EventType.SetConfig, "WarehouseTest"));
using (Factory.Parallel.SpawnProvider(assemblyName, "FIXSimulator", "Negative", ProjectProperties))
{
base.Run(loader);
}
Factory.Provider.ShutdownSockets();
}
public void StartupPluginLoaderTest()
{
CoreStartup start = new CoreStartup("TickZoomTest");
start.StartCoreServices();
start.RunInitialization();
string addInConfig =
@"<Plugin name = ""LoaderTests""
author = ""Wayne Walter""
url = """"
description = ""TODO: Put description here"">
<Runtime>
<Import assembly = ""TickZoomLoaderTests.dll""/>
</Runtime>
<Path name = ""/Tests/Loaders"">
<Extension id=""MyLoader"" class=""TestLoader""/>
</Path>
</Plugin>";
var reader = new StringReader(addInConfig);
Plugin plugin = Plugin.Load(reader, ".");
plugin.Enabled = true;
PluginTree.InsertPlugin(plugin);
ModelLoaderInterface loader = (ModelLoaderInterface)PluginTree.BuildItem("/Tests/Loaders/MyLoader", this);
Assert.IsNotNull(loader);
}
public virtual void Run()
{
ModelLoaderInterface loader = Plugins.Instance.GetLoader(projectFileLoaderCategory + ": " + projectFileLoaderName);
projectProperties = ProjectPropertiesCommon.Create(new StreamReader(ProjectFile));
Run(loader);
}
public ModelLoaderInterface GetLoader(string name)
{
var count = 0;
ModelLoaderInterface result = null;
for (int i = 0; i < modelLoaders.Count; i++)
{
Type type = modelLoaders[i];
var loader = (ModelLoaderInterface)Activator.CreateInstance(type);
if (loader.Name.Equals(name))
{
count++;
result = loader;
}
}
if (count == 1)
{
return(result);
}
else if (count > 0)
{
throw new ApplicationException("More than one ModelLoader '" + name + "' was found.");
}
else
{
throw new ApplicationException("ModelLoader '" + name + "' not found.");
}
}
public void WriteEngineResults(ModelLoaderInterface loader, List <TickEngine> engines, Action <int, double> fitnessCallback)
{
for (int i = 0; i < engines.Count; i++)
{
WriteEngineResult(loader, engines[i], fitnessCallback);
}
}
public void WriteEngineResult(ModelLoaderInterface loader, TickEngine engine, Action <int, double> fitnessCallback)
{
try {
loader.OptimizeOutput = new FileStream(fileName, FileMode.Append);
using (StreamWriter fwriter = new StreamWriter(loader.OptimizeOutput)) {
ModelInterface topModel = engine.Model;
foreach (var chain in topModel.Chain.Dependencies)
{
var passModel = chain.Model as StrategyInterface;
var strings = passModel.Name.Split(new char[] { '-' });
var passNumber = int.Parse(strings[2]);
if (fitnessCallback != null)
{
fitnessCallback(passNumber, passModel.OnGetFitness());
}
if (passModel == null)
{
log.Error("Model " + passModel + " must implement the StrategyInterface or PortfolioInterface for the optimizer statistics results to get recorded.");
}
else
{
WritePassStats(fwriter, passModel);
}
}
}
} catch (Exception ex) {
log.Error("ERROR: Problem writing optimizer results.", ex);
}
}
public override void Run(ModelLoaderInterface loader)
{
SetupSymbolData();
Factory.Provider.StartSockets();
parallelMode = ParallelMode.RealTime;
Factory.SysLog.RegisterHistorical("FIXSimulator", GetDefaultLogConfig());
Factory.SysLog.RegisterRealTime("FIXSimulator", GetDefaultLogConfig());
Config = "WarehouseTest.config";
Address = "inprocess";
#if !USE_LIME
var provider = "MBTFIXProvider/Simulate";
var fixAssembly = "MBTFIXProvider";
var fixSimulator = "MBTProviderSimulator";
#else
var provider = "LimeProvider/Simulate";
var fixAssembly = "LimeProvider";
var fixSimulator = "ProviderSimulator";
#endif
AddProvider(provider);
SetupProviderServiceConfig();
var providerManager = Factory.Parallel.SpawnProvider("ProviderCommon", "ProviderManager");
providerManager.SendEvent(new EventItem(EventType.SetConfig, "WarehouseTest"));
using (Factory.Parallel.SpawnProvider(fixAssembly, fixSimulator, "Simulate", ProjectProperties))
{
base.Run(loader);
}
Factory.Provider.ShutdownSockets();
}
public override void Run(ModelLoaderInterface loader)
{
parallelMode = ParallelMode.RealTime;
Factory.SysLog.RegisterRealTime("RealTime", GetDefaultLogConfig()); // This creates the config if not exists.
Factory.SysLog.RegisterHistorical("Historical", HistoricalStarter.GetDefaultLogConfig()); // This creates the config if not exists.
Factory.SysLog.ReconfigureForRealTime();
base.Run(loader);
}
public override void Run(ModelLoaderInterface loader)
{
Config = "WarehouseTest.config";
var provider = "TickZoomCombinedMock";
AddProvider(provider);
SetupProviderServiceConfig(provider, (ushort)Port);
base.Run(loader);
}
private void SetupStarter(Starter starterInstance)
{
FlushCharts();
IntervalsUpdate();
starterInstance.ProjectProperties.ConfigFile = projectConfig;
starterInstance.ProjectProperties.Starter.StartTime = (TimeStamp)startDateTime;
starterInstance.ProjectProperties.Starter.EndTime = (TimeStamp)endDateTime;
starterInstance.ProjectProperties.Starter.TestFinishedTimeout = TestFinishedTimeout;
if (simulatorProperties != null)
{
starterInstance.ProjectProperties.Simulator = simulatorProperties;
}
starterInstance.BackgroundWorker = commandWorker;
starterInstance.DataFolder = dataSubFolder;
if (!disableCharting)
{
if (CreateChart == null || ShowChart == null)
{
log.Warn("Charting is enabled but you never set one of the CreateChart or the ShowChart properties.");
}
else
{
starterInstance.CreateChartCallback = new CreateChartCallback(CreateChart);
starterInstance.ShowChartCallback = new ShowChartCallback(ShowChart);
log.Info("Starter create chart callback set to " + starterInstance.CreateChartCallback);
}
}
else
{
log.Warn("You have the \"disable charts\" check box enabled.");
}
starterInstance.ProjectProperties.Chart.ChartType = chartType;
starterInstance.ProjectProperties.Starter.SetSymbols(symbolList);
starterInstance.ProjectProperties.Starter.IntervalDefault = intervalDefault;
starterInstance.Config = serviceConfig;
starterInstance.Port = servicePort;
starterInstance.AddProvider(providerAssembly);
if (useDefaultInterval)
{
starterInstance.ProjectProperties.Chart.IntervalChartBar = intervalDefault;
}
else
{
starterInstance.ProjectProperties.Chart.IntervalChartBar = intervalChartBar;
}
if (intervalChartBar.BarUnit == BarUnit.Default)
{
starterInstance.ProjectProperties.Chart.IntervalChartBar = intervalDefault;
}
log.Info("Running Loader named: " + modelLoader);
loaderInstance = Plugins.Instance.GetLoader(modelLoader);
}
public ModelInterface ProcessLoader(ModelLoaderInterface loader, int passNumber)
{
loader.OnClear();
loader.OnLoad(ProjectProperties);
ModelInterface topModel = loader.TopModel;
if (!SetOptimizeValues(loader))
{
throw new ApplicationException("Error, setting optimize variables.");
}
topModel.Name += "-Pass-" + passNumber;
return(topModel);
}
public bool SetOptimizeValues(ModelLoaderInterface loader)
{
// Then set them for logging separately to optimization reports.
Dictionary <string, object> optimizeValues = new Dictionary <string, object>();
for (int i = 0; i < loader.Variables.Count; i++)
{
optimizeValues[loader.Variables[i].Name] = loader.Variables[i].Value;
}
bool retVal = true;
foreach (var kvp in optimizeValues)
{
string name = kvp.Key;
object value = kvp.Value;
string[] namePairs = kvp.Key.Split('.');
if (namePairs.Length < 2)
{
log.Error("Sorry, the optimizer variable '" + kvp.Key + "' was not found.");
retVal = false;
continue;
}
string strategyName = namePairs[0];
StrategyInterface strategy = null;
foreach (StrategyInterface tempStrategy in GetStrategyList(loader.TopModel.Chain.Tail))
{
if (tempStrategy.Name.CompareWildcard(strategyName, false))
{
strategy = tempStrategy;
if (!SetOptimizeValue(strategy, name, value))
{
retVal = false;
break;
}
}
}
if (strategy == null)
{
log.Error("Sorry, a strategy matching '" + strategyName + "' was never found for optimizer variable '" + kvp.Key + "'.");
retVal = false;
continue;
}
}
optimizeValueMap.Add(loader.TopModel, optimizeValues);
return(retVal);
}
public virtual void Run(ModelLoaderInterface loader)
{
if (loader.Category == projectFileLoaderCategory && loader.Name == projectFileLoaderName)
{
log.Notice("Loading project from " + ProjectFile);
projectProperties = ProjectPropertiesCommon.Create(new StreamReader(ProjectFile));
}
loader.OnInitialize(ProjectProperties);
loader.OnLoad(ProjectProperties);
if (!SetOptimizeValues(loader))
{
throw new ApplicationException("Error, setting optimize variables. See log file for details.");
}
ModelInterface model = loader.TopModel;
Run(model);
}
public override void Run(ModelLoaderInterface loader)
{
Factory.SysLog.Reconfigure("FIXRealTimePlayBack", GetDefaultLogConfig());
Config = "WarehouseTest.config";
var provider = "MBTFIXProvider/Simulate";
AddProvider(provider);
SetupProviderServiceConfig(provider, (ushort)Port);
try {
fixServer = (FIXSimulator)Factory.FactoryLoader.Load(typeof(FIXSimulator), "MBTFIXProvider", "PlayBack");
base.Run(loader);
} finally {
if (fixServer != null)
{
fixServer.Dispose();
}
}
}
public StartCommand(Starter starter, ModelLoaderInterface loader)
{
this.starter = starter;
this.loader = loader;
CanExecuteChanged = (s, e) => { };
}
public override void Run(ModelLoaderInterface loader)
{
Factory.Parallel.SetMode(parallelMode);
Factory.SysLog.ResetConfiguration();
this.loader = loader;
try {
if (loader.OptimizeOutput == null)
{
Directory.CreateDirectory(Path.GetDirectoryName(FileName));
File.Delete(FileName);
}
} catch (Exception ex) {
log.Error("Error while creating directory and deleting '" + FileName + "'.", ex);
return;
}
log.Notice("Beginning Genetic Optimize of: ");
log.Notice(loader.Name + " model loader. Type: " + loader.GetType().Name);
loader.QuietMode = true;
loader.OnInitialize(ProjectProperties);
optimizeVariables = new List <ModelProperty>();
for (int i = 0; i < loader.Variables.Count; i++)
{
ModelProperty var = loader.Variables[i];
if (var.Optimize)
{
optimizeVariables.Add(var);
}
}
// Get Total Number of Bits
int totalBits = 0;
for (int i = 0; i < optimizeVariables.Count; i++)
{
ModelProperty var = optimizeVariables[i];
int bits = Convert.ToString(var.Count - 1, 2).Length;
totalBits += bits;
}
if (optimizeVariables.Count == 1)
{
generationCount = 1;
}
// Get the highest count.
populationCount = totalPasses / generationCount;
tasksRemaining = totalPasses;
log.Notice("Assigning genomes.");
// Create initial set of random chromosomes.
generation = new List <Chromosome>();
// This list assures we never retry a previous one twice.
alreadyTried = new List <Chromosome>();
// Create a genome holder.
int[] genome = new int[optimizeVariables.Count];
// Indexes for going through randomList
int[] indexes = new int[optimizeVariables.Count];
// for( int repeat=0; repeat < Math.Min(optimizeVariables.Count,2); repeat++) {
//
//Get random values for each.
List <List <int> > randomLists = new List <List <int> >();
for (int i = 0; i < optimizeVariables.Count; i++)
{
randomLists.Add(GetRandomIndexes(optimizeVariables[i]));
}
// Create initial population
for (int loop = 0; loop < populationCount; loop++)
{
// Set the genome from the randomLists using the indexes.
for (int i = 0; i < optimizeVariables.Count; i++)
{
genome[i] = randomLists[i][indexes[i]];
}
Chromosome chromosome = new Chromosome(genome);
log.Debug(chromosome.ToString());
generation.Add(chromosome);
alreadyTried.Add(chromosome);
for (int i = 0; i < indexes.Length; i++)
{
indexes[i]++;
ModelProperty var = optimizeVariables[i];
if (indexes[i] >= populationCount)
{
indexes[i] = 0;
}
}
}
// }
#if CLRPROFILER
CLRProfilerControl.LogWriteLine("Entering Genetic Loop");
CLRProfilerControl.AllocationLoggingActive = true;
CLRProfilerControl.CallLoggingActive = false;
#endif
int totalEngineCount = Environment.ProcessorCount * generationCount;
// Pre-setup engines. This causes the progress
// bar to show a complete set of information for all
// generations.
var iteration = 1;
for (int genCount = 0; genCount < generationCount && !CancelPending; genCount++)
{
// Assign fitness values
var topModels = new List <ModelInterface>();
for (int i = generation.Count - 1; i >= 0; i--)
{
Chromosome chromosome = generation[i];
if (!chromosome.FitnessAssigned)
{
ModifyVariables(chromosome);
var model = ProcessLoader(loader, i);
topModels.Add(model);
}
else
{
tasksRemaining--;
log.Debug("Saves processing on " + chromosome + "!");
}
}
int tasksPerEngine = CalculateTasksPerEngine(topModels.Count);
ModelInterface topModel = new Portfolio();
int passCount = 0;
foreach (var model in topModels)
{
topModel.Chain.Dependencies.Add(model.Chain);
passCount++;
if (passCount % tasksPerEngine == 0)
{
var engine = SetupEngine(true, "Iteration" + ++iteration);
engine.Model = topModel;
engine.QueueTask();
engineIterations.Add(engine);
topModel = new Portfolio();
if (engineIterations.Count >= Environment.ProcessorCount)
{
ProcessIteration();
}
}
}
if (topModel.Chain.Dependencies.Count > 0)
{
var engine = SetupEngine(true, "Iteration" + ++iteration);
engine.Model = topModel;
engine.QueueTask();
engineIterations.Add(engine);
}
if (engineIterations.Count > 0)
{
ProcessIteration();
}
generation.Sort();
log.Notice("After sorting generation...");
double maxFitness = 0;
for (int i = 0; i < generation.Count; i++)
{
log.Debug(generation[i].ToString());
maxFitness = Math.Max(generation[i].Fitness, maxFitness);
}
// If none of the genes in the chromosome
// had a positive fitness, stop here.
if (maxFitness <= 0)
{
break;
}
List <Chromosome> newGeneration = new List <Chromosome>();
log.Notice("Crossover starting...");
while (newGeneration.Count < populationCount - 1)
{
Chromosome chromo1 = Roulette();
Chromosome chromo2;
do
{
chromo2 = Roulette();
} while(chromo2.Equals(chromo1));
log.Debug("Before: " + chromo1 + " - " + chromo2);
chromo1.DoubleCrossOver(chromo2);
log.Debug("After: " + chromo1 + " - " + chromo2);
if (alreadyTried.Contains(chromo1))
{
chromo1 = alreadyTried[alreadyTried.IndexOf(chromo1)];
}
else
{
alreadyTried.Add(chromo1);
}
if (alreadyTried.Contains(chromo2))
{
chromo2 = alreadyTried[alreadyTried.IndexOf(chromo2)];
}
else
{
alreadyTried.Add(chromo2);
}
newGeneration.Add(chromo1);
newGeneration.Add(chromo2);
}
generation = newGeneration;
}
GetEngineResults();
WriteEngineResults(loader, engineIterations);
engineIterations.Clear();
#if CLRPROFILER
CLRProfilerControl.AllocationLoggingActive = false;
CLRProfilerControl.CallLoggingActive = false;
CLRProfilerControl.LogWriteLine("Exiting Genetic Loop");
#endif
log.Notice("Genetic Algorithm Finished.");
}
public override void Run(ModelLoaderInterface loader)
{
Factory.SysLog.Reconfigure("Historical", GetDefaultLogConfig());
base.Run(loader);
}
public void WriteEngineResults(ModelLoaderInterface loader, List <TickEngine> engines)
{
WriteEngineResults(loader, engines, null);
}
public override void Run(ModelLoaderInterface loader)
{
Factory.SysLog.ResetConfiguration();
try {
if (loader.OptimizeOutput == null)
{
Directory.CreateDirectory(Path.GetDirectoryName(FileName));
File.Delete(FileName);
}
} catch (Exception ex) {
log.Error("Error while creating directory and deleting '" + FileName + "'.", ex);
return;
}
this.loader = loader;
this.loader.QuietMode = true;
startMillis = Factory.TickCount;
engineIterations = new List <TickEngine>();
loader.OnInitialize(ProjectProperties);
totalTasks = 0;
foreach (var num in RecursiveOptimize(0))
{
totalTasks++;
}
tasksRemaining = totalTasks;
int tasksPerEngine = CalculateTasksPerEngine(totalTasks);
int iterations = Math.Max(1, totalTasks / maxParallelPasses);
int leftOverPasses = Math.Max(0, totalTasks - (maxParallelPasses * iterations));
if (totalTasks % maxParallelPasses > 0)
{
log.Notice("Planning " + iterations + " iterations with " + maxParallelPasses + " passes plus 1 pass with " + leftOverPasses + " iterations.");
}
else
{
log.Notice("Planning " + iterations + " iterations with " + maxParallelPasses + " passes each.");
}
ModelInterface topModel = new Portfolio();
passCount = 0;
foreach (var num in RecursiveOptimize(0))
{
ModelInterface model = ProcessLoader(loader, passCount);
topModel.Chain.Dependencies.Add(model.Chain);
passCount++;
if (passCount % tasksPerEngine == 0)
{
TickEngine engine = ProcessHistorical(topModel, true);
engine.QueueTask();
engineIterations.Add(engine);
topModel = new Portfolio();
if (engineIterations.Count >= Environment.ProcessorCount)
{
ProcessIteration();
}
}
}
if (topModel.Chain.Dependencies.Count > 0)
{
TickEngine engine = ProcessHistorical(topModel, true);
engine.QueueTask();
engineIterations.Add(engine);
}
if (engineIterations.Count > 0)
{
ProcessIteration();
}
long elapsedMillis = Factory.TickCount - startMillis;
log.Notice("Finished optimizing in " + elapsedMillis + "ms.");
}
