public void MergeClock()
{
VectorClock clock1 = new VectorClock();
clock1 = clock1.Increment("key1");
clock1 = clock1.Increment("key1");
clock1 = clock1.Increment("key1");
VectorClock clock2 = new VectorClock();
clock2 = clock2.Increment("key2");
clock2 = clock2.Increment("key2");
VectorClock clock3 = new VectorClock();
clock3 = clock3.Increment("key3");
VectorClock mergedClock = new VectorClock();
mergedClock = mergedClock.Merge(clock1);
mergedClock = mergedClock.Increment("key1");
mergedClock = mergedClock.Merge(clock2);
mergedClock = mergedClock.Merge(clock3);
Assert.That(mergedClock["key1"] == 4 && mergedClock["key2"] == 2 && mergedClock["key3"] == 1);
// Merge should not affect the original VectorClock
Assert.That(clock1["key1"] == 3);
}
public void StartAtOne()
{
VectorClock clock = new VectorClock();
Assert.That(!clock.ContainsKey("key1"));
clock = clock.Increment("key1");
Assert.That(clock["key1"] == 1);
}
public void CheckToString()
{
var d1 = new Dictionary<int, int> { { 1, 1 }, { 2, 2 } };
var p = new VectorClock(d1);
var expected = "1[1]\r\n2[2]\r\n";
Assert.AreEqual(expected, p.ToString());
}
public override void writeDeleteRequest(Stream iostr, string storeName, byte[] key, VectorClock version, bool shouldReroute)
{
VoldemortRequest request = new VoldemortRequest();
request.type = RequestType.DELETE;
request.store = storeName;
request.should_route = shouldReroute;
request.delete = new DeleteRequest() { key = key, version = version };
Serializer.SerializeWithLengthPrefix(iostr, request, PrefixStyle.Fixed32BigEndian);
}
public override void writePutRequest(Stream iostr, string storeName, byte[] key, byte[] value, VectorClock version, bool shouldReroute)
{
VoldemortRequest request = new VoldemortRequest();
request.type = RequestType.PUT;
request.store = storeName;
request.should_route = shouldReroute;
request.put = new PutRequest() { key = key, versioned = new Versioned() { value = value, version = version } };
Serializer.SerializeWithLengthPrefix(iostr, request, PrefixStyle.Fixed32BigEndian);
}
public void IsBeforeSameElements()
{
var p = new VectorClock();
p.Increment(1);
var q = new VectorClock();
q.Increment(1);
q.Increment(1);
Assert.AreEqual(ConcurrencyComparison.Before, p.Compare(q));
}
public void IsAfterSameElements()
{
var p = new VectorClock();
p.Increment(1);
var q = new VectorClock();
q.Increment(1);
q.Increment(1);
Assert.AreEqual(ConcurrencyComparison.After, q.Compare(p));
}
public void IsEqual()
{
var p = new VectorClock();
p.Increment(1);
p.Increment(2);
var q = new VectorClock();
q.Increment(1);
q.Increment(2);
Assert.AreEqual(ConcurrencyComparison.Equal, p.Compare(q));
}
public void IncrementClock()
{
Dictionary<string, int> vector = new Dictionary<string, int>();
vector["key1"] = 2;
vector["key2"] = 3;
VectorClock clock = new VectorClock(vector);
clock = clock.Increment("key1");
clock = clock.Increment("key2");
Assert.That(clock["key1"] == 3 && clock["key2"] == 4);
}
public void CopyClock()
{
VectorClock clock1 = new VectorClock();
clock1 = clock1.Increment("key1");
clock1 = clock1.Increment("key1");
clock1 = clock1.Increment("key1");
VectorClock clock2 = clock1.Copy();
clock2 = clock2.Increment("key1");
Assert.That(clock1 != clock2);
Assert.That(clock1["key1"] == 3);
Assert.That(clock2["key1"] == 4);
}
public Gossip(ImmutableSortedSet<Member> members, GossipOverview overview, VectorClock version)
{
_members = members;
_overview = overview;
_version = version;
_membersMap = new Lazy<ImmutableDictionary<UniqueAddress, Member>>(
() => members.ToImmutableDictionary(m => m.UniqueAddress, m => m));
ReachabilityExcludingDownedObservers = new Lazy<Reachability>(() =>
{
var downed = Members.Where(m => m.Status == MemberStatus.Down).ToList();
return Overview.Reachability.RemoveObservers(downed.Select(m => m.UniqueAddress).ToImmutableHashSet());
});
if (Cluster.IsAssertInvariantsEnabled) AssertInvariants();
}
public void SetUp()
{
this.evt6 = new TestEvent(); // Earliest timestamp, but should be last based on VectorClock
Thread.Sleep(10);
VectorClock clock = new VectorClock();
this.evt1 = new TestEvent();
this.evt1.VectorClock = clock.Increment("key1");
this.evt2 = new TestEvent();
this.evt2.VectorClock = this.evt1.VectorClock.Increment("key1");
this.evt3 = new TestEvent();
this.evt3.VectorClock = this.evt2.VectorClock.Increment("key1");
Thread.Sleep(10); // Add sleep so the timestamp is different between evt3 and evt4
this.evt4 = new TestEvent();
this.evt4.VectorClock = this.evt2.VectorClock.Increment("key2");
this.evt5 = new TestEvent();
this.evt5.VectorClock = this.evt3.VectorClock.Merge(this.evt4.VectorClock).Increment("key3");
this.evt6.VectorClock = this.evt5.VectorClock.Increment("key1");
}
public void TypedEquals()
{
var p = new VectorClock();
p.Increment(1);
var q = new VectorClock();
q.Increment(1);
Assert.IsTrue(p.Equals(q));
}
public void NullObjectEquals()
{
var p = new VectorClock();
p.Increment(1);
object c = null;
Assert.IsFalse(p.Equals(c));
}
public void ObjectEquals()
{
var p = new VectorClock();
p.Increment(1);
var q = new VectorClock();
q.Increment(1);
object c = q;
Assert.IsTrue(p.Equals(c));
}
public void MustHaveZeroVersionsWhenCreated()
{
var clock = VectorClock.Create();
Assert.Equal(new Dictionary <VectorClock.Node, long>(), clock.Versions);
}
public void IsConcurrentAgainstNull()
{
var p = new VectorClock();
p.Increment(1);
p.Increment(2);
p.Increment(3);
Assert.AreEqual(ConcurrencyComparison.Concurrent, p.Compare(null));
}
private void ConvergentUpdate(CRDT.Application.Convergent.Set.LWW_SetWithVCService <TestType> sourceReplica, TestType value, VectorClock vectorClock, List <CRDT.Application.Convergent.Set.LWW_SetWithVCService <TestType> > downstreamReplicas)
{
sourceReplica.LocalAssign(value, vectorClock);
var(adds, removes) = sourceReplica.State;
foreach (var downstreamReplica in downstreamReplicas)
{
downstreamReplica.Merge(adds, removes);
}
}
public void CompareVectors()
{
VectorClock clock1 = new VectorClock();
clock1 = clock1.Increment("key1");
VectorClock clock2 = clock1.Copy();
clock2 = clock2.Increment("key2");
VectorClock clock3 = new VectorClock();
clock3 = clock3.Increment("key1");
clock3 = clock3.Increment("key2");
Assert.That(clock1.CompareVectors(clock2) == VectorClock.ComparisonResult.Smaller);
Assert.That(clock2.CompareVectors(clock1) == VectorClock.ComparisonResult.Greater);
Assert.That(clock3.CompareVectors(clock2) == VectorClock.ComparisonResult.Equal);
}
private void AssertDoesNotExistInRepository(TestType value, VectorClock vectorClock)
{
Assert.DoesNotContain(_repository.GetElements(),
e => Equals(e.Value, value) &&
e.VectorClock.Equals(vectorClock));
}
public override void writePutRequest(Stream iostr, string storeName, byte[] key, byte[] value, VectorClock version, bool shouldReroute)
{
throw new NotSupportedException();
}
private void CommutativeUpdate(CRDT.Application.Commutative.Set.OUR_OptimizedSetWithVCService <TestType> sourceReplica, TestType value, VectorClock vectorClock, List <CRDT.Application.Commutative.Set.OUR_OptimizedSetWithVCService <TestType> > downstreamReplicas)
{
var observedTags = sourceReplica.GetTags(value.Id);
sourceReplica.LocalUpdate(value, observedTags, vectorClock);
foreach (var downstreamReplica in downstreamReplicas)
{
downstreamReplica.DownstreamUpdate(value, observedTags, vectorClock);
}
}
private void CommutativeAdd(CRDT.Application.Commutative.Set.OUR_OptimizedSetWithVCService <TestType> sourceReplica, TestType value, VectorClock vectorClock, List <CRDT.Application.Commutative.Set.OUR_OptimizedSetWithVCService <TestType> > downstreamReplicas)
{
var tag = Guid.NewGuid();
sourceReplica.LocalAdd(value, tag, vectorClock);
foreach (var downstreamReplica in downstreamReplicas)
{
downstreamReplica.DownstreamAdd(value, tag, vectorClock);
}
}
private void ConvergentRemove(CRDT.Application.Convergent.Set.LWW_OptimizedSetWithVCService <TestType> sourceReplica, TestType value, VectorClock vectorClock, List <CRDT.Application.Convergent.Set.LWW_OptimizedSetWithVCService <TestType> > downstreamReplicas)
{
sourceReplica.LocalRemove(value, vectorClock);
foreach (var downstreamReplica in downstreamReplicas)
{
downstreamReplica.Merge(sourceReplica.State);
}
}
private void CommutativeUpdate(CRDT.Application.Commutative.Set.LWW_OptimizedSetWithVCService <TestType> sourceReplica, TestType value, VectorClock vectorClock, List <CRDT.Application.Commutative.Set.LWW_OptimizedSetWithVCService <TestType> > downstreamReplicas)
{
sourceReplica.LocalAssign(value, vectorClock);
foreach (var downstreamReplica in downstreamReplicas)
{
downstreamReplica.DownstreamAssign(value, vectorClock);
}
}
public void NullTypedEquals()
{
var p = new VectorClock();
p.Increment(1);
VectorClock q = null;
Assert.IsFalse(p.Equals(q));
}
private void AssertExistsInRepository(TestType value, VectorClock vectorClock)
{
Assert.Equal(1, _repository.GetElements().Count(e => Equals(e.Value, value) &&
e.VectorClock.Equals(vectorClock)));
}
private void ReportReadSharedWriteRace(string sourceLocation, long currentMId, VectorClock currentVC, VarState varState,
UIntPtr objHandle, UIntPtr offset)
{
string writeInfo = "Write by:";
string readInfo = "Shared Read by: ";
if (Config.EnableReadWriteTracing)
{
writeInfo = String.Format("Write ({0}) by", sourceLocation);
}
for (int previousReader = varState.VC.NextGT(currentVC, 0); previousReader > -1;
previousReader = varState.VC.NextGT(currentVC, previousReader + 1))
{
// Read-Shared - Write race between previousReader and currentMId
if (Config.EnableReadWriteTracing)
{
readInfo = String.Format("Shared Read ({0}) by", varState.LastReadLocation[(long)previousReader]);
}
if (!InSameMonitor(varState.InMonitorRead[(long)previousReader], this.InMonitor))
{
ReportRace($"Read-Shared/Write[{objHandle}/{offset}]", readInfo, previousReader, writeInfo, currentMId);
}
}
}
public abstract void writeDeleteRequest(Stream iostr, string storeName, byte[] key, VectorClock version, bool shouldReroute);
public Gossip Copy(ImmutableSortedSet<Member> members = null, GossipOverview overview = null,
VectorClock version = null)
{
return new Gossip(members ?? _members, overview ?? _overview, version ?? _version);
}
public void DetectSimultaneousOperations()
{
VectorClock baseClock = new VectorClock();
baseClock = baseClock.Increment("key1");
baseClock = baseClock.Increment("key1");
VectorClock clock1 = baseClock.Copy();
VectorClock clock2 = baseClock.Copy();
VectorClock clock3 = baseClock.Copy();
clock1 = clock1.Increment("key1");
clock2 = clock2.Increment("key2");
clock3 = clock3.Increment("key3");
Assert.That(clock1.CompareVectors(clock2) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(clock2.CompareVectors(clock1) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(clock1.CompareVectors(clock3) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(clock3.CompareVectors(clock1) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(clock3.CompareVectors(clock2) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(clock2.CompareVectors(clock3) == VectorClock.ComparisonResult.Simultaneous);
VectorClock clock4 = clock1.Merge(clock2);
clock4 = clock4.Merge(clock3);
Assert.That(clock4.CompareVectors(clock1) == VectorClock.ComparisonResult.Greater);
Assert.That(clock4.CompareVectors(clock2) == VectorClock.ComparisonResult.Greater);
Assert.That(clock4.CompareVectors(clock3) == VectorClock.ComparisonResult.Greater);
Assert.That(clock1.CompareVectors(clock4) == VectorClock.ComparisonResult.Smaller);
Assert.That(clock2.CompareVectors(clock4) == VectorClock.ComparisonResult.Smaller);
Assert.That(clock3.CompareVectors(clock4) == VectorClock.ComparisonResult.Smaller);
// All previous clocks descend from baseClock which has the vector ["key1" : 2]
VectorClock otherClock = new VectorClock();
otherClock = otherClock.Increment("key4");
// otherClock should be simultaneous with all of them since it doesnt recognize ["key1" : 2]
Assert.That(otherClock.CompareVectors(baseClock) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(otherClock.CompareVectors(clock1) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(otherClock.CompareVectors(clock2) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(otherClock.CompareVectors(clock3) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(otherClock.CompareVectors(clock4) == VectorClock.ComparisonResult.Simultaneous);
}
public void MaxNull()
{
var d1 = new Dictionary<int, int> { { 1, 1 }, { 2, 1 }, { 3, 3 }, { 4, 4 } };
var d3 = new Dictionary<int, int> { { 1, 1 }, { 2, 1 }, { 3, 3 }, { 4, 4 } };
var p = new VectorClock(d1);
var expected = new VectorClock(d3);
var candidate = p.Max(null);
Assert.IsTrue(expected.Equals(candidate));
}
/// <summary>
/// Increments the version for this 'Node'.
/// </summary>
public Gossip Increment(VectorClock.Node node)
{
return Copy(version: _version.Increment(node));
}
public LWW_RegisterWithVCElement(T value, VectorClock vectorClock, bool removed)
{
Value = value;
VectorClock = vectorClock;
Removed = removed;
}
public Gossip Prune(VectorClock.Node removedNode)
{
var newVersion = Version.Prune(removedNode);
if (newVersion.Equals(Version))
return this;
else
return new Gossip(Members, Overview, newVersion);
}
public GossipStatus(UniqueAddress from, VectorClock version)
{
_from = from;
_version = version;
}
public override void writeDeleteRequest(Stream iostr, string storeName, byte[] key, VectorClock version, bool shouldReroute)
{
throw new NotImplementedException();
}
public void RegisterRead(ulong source, string sourceLocation, UIntPtr location, UIntPtr objHandle, UIntPtr offset, bool isVolatile)
{
LogRead(sourceLocation, source, objHandle, offset);
ReadCount++;
var key = new Tuple <UIntPtr, UIntPtr>(objHandle, offset);
// For Raise actions and init actions, we might not have seen a dequeue
// of the action yet, so source \in MS is not guaranteed
if (!MS.ContainsKey(source))
{
// WriteToLog("Saw a read in an action without a corresponding deq");
MS[source] = new InstrMachineState(source, this.Log, Config.EnableRaceDetectorLogging);
}
// Implementation of the FastTrack rules for read operations
var machineState = MS[source];
var currentEpoch = machineState.Epoch;
if (VS.ContainsKey(key))
{
var varState = VS[key];
varState.InMonitorRead[(long)source] = this.InMonitor;
if (Config.EnableReadWriteTracing)
{
varState.LastReadLocation[(long)source] = sourceLocation;
}
if (varState.ReadEpoch == currentEpoch)
{
// Same-epoch read
return;
}
VectorClock mVC = machineState.VC;
long readEpoch = varState.ReadEpoch;
long writeEpoch = varState.WriteEpoch;
long writeMId = Epoch.MId(writeEpoch);
long currentMId = (long)source;
// The lastest write was from a diff machine, and no HB
if (writeMId != currentMId && !Epoch.Leq(writeEpoch, mVC.GetComponent(writeMId)) &&
!InSameMonitor(varState.InMonitorWrite, this.InMonitor))
{
// Write/Read race
ReportRace(RaceDiagnostic.WriteRead, varState.lastWriteLocation, writeMId, sourceLocation, currentMId, objHandle, offset);
return;
}
if (readEpoch == Epoch.ReadShared)
{
Runtime.Assert((long)currentMId == Epoch.MId(currentEpoch), "Inconsistent Epoch");
varState.VC.SetComponent(currentMId, currentEpoch);
}
else
{
long rMId = Epoch.MId(readEpoch);
if (currentMId == rMId || Epoch.Leq(readEpoch, mVC.GetComponent(rMId)))
{
varState.ReadEpoch = currentEpoch;
}
else
{
if (varState.VC == null)
{
varState.VC = new VectorClock(Math.Max(rMId, currentMId));
}
varState.VC.SetComponent(rMId, readEpoch);
varState.VC.SetComponent(currentMId, currentEpoch);
varState.ReadEpoch = Epoch.ReadShared;
}
}
}
else // The first read from this variable
{
var currentState = new VarState(false, currentEpoch, Config.EnableReadWriteTracing, this.InMonitor);
currentState.InMonitorRead[(long)source] = this.InMonitor;
if (Config.EnableReadWriteTracing)
{
currentState.LastReadLocation[(long)source] = sourceLocation;
}
VS[key] = currentState;
}
}
