private void AddStartEvent(long ticks)
{
var realEvent = new RealEvent(EventType.Start, ticks);
_queue.Enqueue(realEvent);
_allEvents.Add(realEvent);
}
public RealEventEnumerator(Span <Bucket> buckets, int firstEventIndex, int lastEventIndex)
{
_buckets = buckets;
_firstEventIndex = firstEventIndex;
_lastEventIndex = lastEventIndex;
_canMove = _buckets.Length > 0;
_currentBucketIndex = 0;
_currentEventIndex = _firstEventIndex - 1;
_currentItem = default;
}
private void AddStopEvent(long ticks)
{
var realEvent = new RealEvent(EventType.Stop, ticks);
_queue.Enqueue(realEvent);
_allEvents.Add(realEvent);
var count = _queue.Count;
if (count >= 10)
{
_eventsBatchGenerated.Set();
}
}
protected void WriteFile(Func <bool> continueWriting, bool append)
{
var thread = new Thread(() =>
{
using (var fileWriter = new FileWriter(_filename, append))
{
int writtenEvents = 0;
RealEvent lastEventWritten = default;
bool continueFlag = true;
while ((continueFlag = continueWriting()) || !_queue.IsEmpty)
{
// we don't need to wait if there will be no more events
if (continueFlag && !_queue.IsEmpty)
{
_eventsBatchGenerated.WaitOne(3000);
}
while (_queue.TryDequeue(out RealEvent ev))
{
// start event should be first event ever
if (writtenEvents == 0 && ev.EventType == EventType.Stop)
{
continue;
}
if (writtenEvents > 0 && ev.Ticks <= lastEventWritten.Ticks)
{
throw new InvalidOperationException($"Events are not sorted. Previous event: {lastEventWritten}, current event: {ev}");
}
if (writtenEvents > 0 && ev.EventType == lastEventWritten.EventType)
{
throw new InvalidOperationException($"Event types are the same. Previous event: {lastEventWritten}, current event: {ev}");
}
fileWriter.WriteEvent(
ev,
new Payload(GetRandomNumber(), GetRandomNumber(), GetRandomNumber(), GetRandomNumber())
);
writtenEvents++;
lastEventWritten = ev;
}
Console.Write("\rNumber of events written: {0}", writtenEvents);
}
}
});
thread.Start();
thread.Join();
}
private BucketContainer CreateBucketContainer(EventPair[] eventPairs, long offset)
{
var buckets = new List <Bucket>();
var builder = new BucketBuilder();
long previousEventTime = offset;
foreach (var pair in eventPairs)
{
long startEventTime = pair.IsAbsoluteOffset ? offset + pair.Offset : previousEventTime + pair.Offset;
var startEvent = new RealEvent(EventType.Start, startEventTime);
var stopEvent = new RealEvent(EventType.Stop, startEventTime + pair.Duration * pair.DurationTimeUnit.GetTimeUnitDuration());
if (!builder.IsFitIntoCurrentBucket(startEvent.Ticks))
{
if (builder.HasEvents)
{
buckets.Add(builder.Build(false));
}
builder.StartNewBucket(startEvent.Ticks);
}
builder.AddEvent(startEvent);
if (!builder.IsFitIntoCurrentBucket(stopEvent.Ticks))
{
buckets.Add(builder.Build(false));
builder.StartNewBucket(stopEvent.Ticks);
}
builder.AddEvent(stopEvent);
previousEventTime = stopEvent.Ticks;
}
var bucket = builder.Build(false);
if (bucket != null)
{
buckets.Add(bucket);
}
return(new BucketContainer(buckets.ToArray(), 0));
}
private bool GetEventsCount(out uint eventsCount, out long totalStreamLength)
{
try
{
totalStreamLength = _reader.BaseStream.Length;
RealEvent ev = new RealEvent();
Payload payload = new Payload();
eventsCount = (uint)(totalStreamLength /
(Marshal.SizeOf(ev) + Marshal.SizeOf(payload)));
return(true);
}
catch (NotSupportedException)
{
eventsCount = default;
totalStreamLength = default;
return(false);
}
}
public bool MoveNext()
{
if (!_canMove)
{
return(false);
}
var result = EnumerationHelper.MoveNext(_buckets, ref _currentBucketIndex, ref _currentEventIndex, _lastEventIndex);
if (result)
{
var bucket = _buckets[_currentBucketIndex];
var ev = bucket.Events[_currentEventIndex];
_currentItem = new RealEvent(
ev.EventType,
bucket.GetAbsoluteTimeForEvent(ev)
);
}
return(result);
}
