protected override long RunDisruptorPass()
{
int batchSize = 10;
CountdownEvent latch = new CountdownEvent(1);
long expectedCount = myRunnable.GetSequence.Value + (ITERATIONS * batchSize);
myRunnable.Reset(latch, expectedCount);
Task.Factory.StartNew(() => myRunnable.Run());
Stopwatch watch = Stopwatch.StartNew();
ISequenced sequencer = this.sequencer;
for (long i = 0; i < ITERATIONS; i++)
{
long next = sequencer.Next(batchSize);
sequencer.Publish((next - (batchSize - 1)), next);
}
latch.Wait();
long opsPerSecond = (ITERATIONS * 1000L * batchSize) / (watch.ElapsedMilliseconds);
waitForEventProcessorSequence(expectedCount);
return(opsPerSecond);
}
/// <summary>
/// Examine if tit and tat are equal as sequenced collections
/// using the specified item equalityComparer (assumed compatible with the two collections).
/// </summary>
/// <param name="collection1">The first collection</param>
/// <param name="collection2">The second collection</param>
/// <param name="itemequalityComparer">The item equalityComparer to use for comparison</param>
/// <returns>True if equal</returns>
public static bool StaticEquals(ISequenced <T> collection1, ISequenced <T> collection2, System.Collections.Generic.IEqualityComparer <T> itemequalityComparer)
{
if (object.ReferenceEquals(collection1, collection2))
{
return(true);
}
if (collection1.Count != collection2.Count)
{
return(false);
}
//This way we might run through both enumerations twice, but
//probably not (if the hash codes are good)
if (collection1.GetSequencedHashCode() != collection2.GetSequencedHashCode())
{
return(false);
}
using (System.Collections.Generic.IEnumerator <T> dat = collection2.GetEnumerator(), dit = collection1.GetEnumerator())
{
while (dit.MoveNext())
{
dat.MoveNext();
if (!itemequalityComparer.Equals(dit.Current, dat.Current))
{
return(false);
}
}
}
return(true);
}
public void Init()
{
dit = new HashSet <int>(MemoryType);
dat = new HashSet <int>(MemoryType);
dut = new HashSet <int>(MemoryType);
dit.Add(2); dit.Add(1);
dat.Add(1); dat.Add(2);
dut.Add(3);
Dit = new LinkedList <ICollection <int> >();
Dat = new LinkedList <ICollection <int> >();
Dut = new LinkedList <ICollection <int> >();
}
public bool SequencedEquals(ISequenced <T> otherCollection)
{
// No preconditions
// is Valid, not disposed
Requires(IsValid);
// Enumeration of the collections must yield equal items
Ensures(Result <bool>() == (otherCollection != null && this.SequenceEqual(otherCollection, EqualityComparer)));
Ensures(Result <bool>() == this.SequencedEquals(otherCollection, EqualityComparer));
return(default(bool));
}
public void Init()
{
dit = new LinkedList <int>();
dat = new LinkedList <int>();
dut = new LinkedList <int>();
dot = new LinkedList <int>();
dit.Add(2); dit.Add(1);
dat.Add(1); dat.Add(2);
dut.Add(3);
dot.Add(2); dot.Add(1);
Dit = new HashSet <ISequenced <int> >(MemoryType);
Dat = new HashSet <ISequenced <int> >(MemoryType);
Dut = new HashSet <ISequenced <int> >(MemoryType);
Dot = new HashSet <ISequenced <int> >(MemoryType);
}
/// <summary>
/// Compute the unsequenced hash code of a collection
/// </summary>
/// <param name="items">The collection to compute hash code for</param>
/// <param name="itemequalityComparer">The item equalitySCG.Comparer</param>
/// <returns>The hash code</returns>
public static int ComputeHashCode(ISequenced <T> items, System.Collections.Generic.IEqualityComparer <T> itemequalityComparer)
{
//NOTE: It must be possible to devise a much stronger combined hashcode,
//but unfortunately, it has to be universal. OR we could use a (strong)
//family and initialise its parameter randomly at load time of this class!
//(We would not want to have yet a flag to check for invalidation?!)
//NBNBNB: the current hashcode has the very bad property that items with hashcode 0
// is ignored.
int iIndexedHashCode = 0;
foreach (T item in items)
{
iIndexedHashCode = iIndexedHashCode * HASHFACTOR + itemequalityComparer.GetHashCode(item);
}
return(iIndexedHashCode);
}
public static int GetSequencedHashCode <T>(this ISequenced <T> items, SCG.IEqualityComparer <T> equalityComparer = null)
{
if (items == null)
{
return(0); // TODO: Better default value?
}
if (equalityComparer == null)
{
equalityComparer = SCG.EqualityComparer <T> .Default;
}
var hashCode = 0; // TODO: Better intial value?
foreach (var item in items)
{
hashCode = hashCode * HashFactor + equalityComparer.GetHashCode(item);
}
return(hashCode);
}
public static bool SequencedEquals <T>(this ISequenced <T> first, ISequenced <T> second, SCG.IEqualityComparer <T> equalityComparer = null)
{
Ensures(Result <bool>() == (ReferenceEquals(first, second) || (first != null && second != null && first.SequenceEqual(second, equalityComparer))));
// Equal if reference equal - this is true for two nulls as well
if (ReferenceEquals(first, second))
{
return(true);
}
if (first == null || second == null)
{
return(false);
}
if (first.Count != second.Count)
{
return(false);
}
if (equalityComparer == null)
{
equalityComparer = SCG.EqualityComparer <T> .Default;
}
using (var e1 = first.GetEnumerator())
using (var e2 = second.GetEnumerator()) {
// Enumerators are equally long
while (e1.MoveNext() & e2.MoveNext())
{
if (!equalityComparer.Equals(e1.Current, e2.Current))
{
return(false);
}
}
}
return(true);
}
public void Dispose()
{
dit = dat = dut = dot = null;
Dit = Dat = Dut = Dot = null;
}
/// <summary>
///
/// </summary>
/// <param name="that"></param>
/// <returns></returns>
public bool SequencedEquals(ISequenced <T> that)
{
return(innerlist.SequencedEquals(that));
}
public StubPublisher(ISequenced ringBuffer)
{
_ringBuffer = ringBuffer;
}
/// <summary>
/// Check if the contents of that is equal to the contents of this
/// in the sequenced sense. Using the item equalityComparer of this collection.
/// </summary>
/// <param name="otherCollection">The collection to compare to.</param>
/// <returns>True if equal</returns>
public virtual bool SequencedEquals(ISequenced <T> otherCollection)
{
return(StaticEquals((ISequenced <T>) this, otherCollection, itemequalityComparer));
}
/// <summary>
/// Wrap a sequenced collection in a read-only wrapper
/// </summary>
/// <param name="sorted"></param>
public GuardedSequenced(ISequenced <T> sorted) : base(sorted)
{
sequenced = sorted;
}
/// <summary>
///
/// </summary>
/// <param name="that"></param>
/// <returns></returns>
public bool SequencedEquals(ISequenced <T> that)
{
return(sequenced.SequencedEquals(that));
}
public bool Equals(ISequenced <T> that)
{
return(false);
}
public abstract bool SequencedEquals(ISequenced <T> otherCollection);
