EngineRunner.cs

using System.Diagnostics;
using ExecutionTcaEngine.Configuration;
using ExecutionTcaEngine.Execution;
using ExecutionTcaEngine.MarketData;
using ExecutionTcaEngine.Output;

namespace ExecutionTcaEngine;

public static class EngineRunner
{
    public static void Run(EngineConfig config)
    {
        var events = EventSources.Load(config);
        EnsureChronological(events);
        var eventsPerSecond = BenchmarkReplay(events);
        var parentOrders = BuildParentOrders(config.Parents);
        var simulator = new VwapSimulator(config.Parents.SliceSeconds, config.FillModel);
        var result = simulator.Simulate(events, parentOrders);
        var outputDirectory = Path.Combine(config.Run.OutputDir, config.Run.Id);
        CsvRecordWriter.Write(outputDirectory, result, events, config.Data.Label);

        Console.WriteLine(
            $"Replayed {events.Count:N0} events at {eventsPerSecond:N0} events/sec; " +
            $"simulated {result.Parents.Count:N0} parents and {result.Fills.Count:N0} fills.");
        Console.WriteLine($"Wrote CSV records to {Path.GetFullPath(outputDirectory)}");
    }

    public static double BenchmarkReplay(IReadOnlyList<MarketEvent> events)
    {
        var state = new TopOfBookState();
        var stopwatch = Stopwatch.StartNew();
        foreach (var marketEvent in events)
        {
            state.Update(marketEvent);
        }

        stopwatch.Stop();
        return events.Count / Math.Max(stopwatch.Elapsed.TotalSeconds, 1e-9);
    }

    public static IReadOnlyList<ParentOrder> BuildParentOrders(ParentConfig config)
    {
        var orders = new List<ParentOrder>();
        var sequence = 0;
        foreach (var window in config.Windows)
        {
            foreach (var side in config.Sides)
            {
                foreach (var size in config.Sizes)
                {
                    sequence++;
                    orders.Add(new ParentOrder(
                        $"P{sequence:0000}",
                        side,
                        size,
                        window.StartSeconds,
                        window.EndSeconds));
                }
            }
        }

        return orders;
    }

    private static void EnsureChronological(IReadOnlyList<MarketEvent> events)
    {
        if (events.Count == 0)
        {
            throw new InvalidOperationException("Event source returned no rows.");
        }

        for (var index = 1; index < events.Count; index++)
        {
            if (events[index].Timestamp < events[index - 1].Timestamp)
            {
                throw new InvalidDataException("Market events must be chronological.");
            }
        }
    }
}