static ImmutableHashSet <Point3d> CalculateDayLayout(ImmutableHashSet <Point3d> blackTiles)
{
var result = blackTiles.ToBuilder();
var candidates = blackTiles
.SelectMany(t => AdjacentHexPoints(t).Append(t))
.Distinct();
foreach (var candidiate in candidates)
{
var adjacentBlackTiles = AdjacentHexPoints(candidiate).Count(p => blackTiles.Contains(p));
if (blackTiles.Contains(candidiate))
{
if (adjacentBlackTiles is 0 or > 2)
{
result.Remove(candidiate);
}
}
else
{
if (adjacentBlackTiles is 2)
{
result.Add(candidiate);
}
}
}
return(result.ToImmutable());
}
public override ImmutableHashSet <ValueTag> Process(BasicBlock block, ImmutableHashSet <ValueTag> input)
{
var output = input.ToBuilder();
// First, compute the materialization state of the basic block parameters.
var preds = block.Graph.GetAnalysisResult <BasicBlockPredecessors>();
foreach (var pred in preds.GetPredecessorsOf(block).Select(block.Graph.GetBasicBlock))
{
foreach (var branch in pred.Flow.Branches)
{
if (branch.Target != block.Tag)
{
continue;
}
foreach (var pair in branch.ZipArgumentsWithParameters(block.Graph))
{
if (pair.Value.IsValue)
{
// A basic block parameter needs to be materialized if any of
// its arguments needs to be materialized.
if (output.Contains(UnfoldAliases(pair.Value.ValueOrNull, block.Graph)))
{
output.Add(pair.Key);
}
}
else
{
// A basic block parameter needs to be materialized if any of
// its arguments are special.
output.Add(pair.Key);
}
}
}
}
// Visit the block's instructions and determine which values need to be
// materialized.
foreach (var instruction in block.NamedInstructions)
{
UpdateMaterialization(
instruction.Instruction,
instruction,
block.Graph,
output);
}
// Ditto for the block's outgoing flow.
foreach (var instruction in block.Flow.Instructions)
{
UpdateMaterialization(
instruction,
null,
block.Graph,
output);
}
return(output.ToImmutable());
}
protected void CreateAndAddFlocks(IEnumerable <IFlockConfiguration> configurations)
{
var builder = _flocks.ToBuilder();
foreach (var configuration in configurations)
{
var flock = CreateFlock(configuration);
builder.Add(flock);
OnFlockAdded(flock);
}
_flocks = builder.ToImmutable();
}
/// <summary>
/// "Prunes the PO-Log once an operation is causally delivered in the effect. The aim is to
/// keep the smallest number of PO-Log operations such that all queries return
/// the same result as if the full PO-Log was present. In particular, this method discards
/// operations from the PO-Log if they can be removed without impacting the output of query
/// operations"
/// These is called causal redundancy and it is one of the two mechanisms that conforms the semantic
/// compaction used by the framework to reduce the size of pure op-based CRDTs. The other one is causal
/// stabilization through <see cref="Stable(VectorTime)"/>.
/// </summary>
/// <param name="ops">The set of operations that conform the POLog.</param>
/// <param name="newOperation">The new delivered operation.</param>
/// <param name="r">A function that receives a new operation o and returns a filter that returns true if an operation o' is redundant by o.</param>
/// <returns>The set of operations that conform the POLog and are not redundant by <paramref name="newOperation"/>.</returns>
public ImmutableHashSet <Versioned <object> > Prune(ImmutableHashSet <Versioned <object> > ops, Versioned <object> newOperation, Redundancy r)
{
var builder = ops.ToBuilder();
foreach (var op in ops)
{
if (r(newOperation, op))
{
builder.Remove(op);
}
}
return(builder.ToImmutable());
}
static void Main(string[] args)
{
ImmutableHashSet <int> il = ImmutableHashSet.Create <int>();
il = il.Add(1);
il = il.Add(2);
il = il.Remove(2);
ImmutableHashSet <int> .Builder issBuilder = il.ToBuilder();
issBuilder.Add(10); //adds to original Hashset. returns void.
ImmutableHashSet <int> .Builder builder = ImmutableHashSet.CreateBuilder <int>();
builder.Add(1);
il = builder.ToImmutable();
}
/// <summary>
/// Adds children to the node
/// </summary>
/// <param name="children">child nodes to be added. Should not be null.</param>
public void AddChildren(IEnumerable <IDependencyNode> children)
{
Requires.NotNull(children, nameof(children));
lock (_childrenLock)
{
var builder = _children.ToBuilder();
foreach (var child in children)
{
builder.Add(child);
}
_children = builder.ToImmutableHashSet();
}
}
public ImmutableHashSet <FindSymbolResult> FindPropertyOrFieldSymbols(SemanticModel model, SyntaxList <StatementSyntax> statements, CancellationToken token)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
ImmutableHashSet <FindSymbolResult> symbolResults = ImmutableHashSet <FindSymbolResult> .Empty;
ImmutableHashSet <FindSymbolResult> .Builder builder = symbolResults.ToBuilder();
foreach (var syntax in statements)
{
token.ThrowIfCancellationRequested();
EnumerateNodes(ref builder, model, syntax.DescendantNodesAndSelf(), token);
}
return(builder.ToImmutable());
}
public static ImmutableHashSet <T> RemoveWhere <T>(this ImmutableHashSet <T> hashSet, Predicate <T> match, out int numRemoved)
{
if (match == null)
{
throw new ArgumentNullException(nameof(match));
}
var hashSetBuilder = hashSet.ToBuilder();
numRemoved = 0;
foreach (var value in hashSet)
{
if (match(value) && hashSetBuilder.Remove(value))
{
numRemoved++;
}
}
return(hashSetBuilder.ToImmutable());
}
public ImmutableHashSet <FindSymbolResult> FindPropertyOrFieldSymbols(SemanticModel model, ExpressionSyntax expression, CancellationToken token)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
ImmutableHashSet <FindSymbolResult> symbolResults = ImmutableHashSet <FindSymbolResult> .Empty;
ImmutableHashSet <FindSymbolResult> .Builder builder = symbolResults.ToBuilder();
token.ThrowIfCancellationRequested();
EnumerateNodes(ref builder, model, expression.DescendantNodesAndSelf(), token);
return(builder.ToImmutable());
}
public void Activate(ImmutableHashSet <ReplicationLink> replicationLinks = null)
{
if (replicationLinks is null)
{
var builder = replicationLinks.ToBuilder();
foreach (var replicationLink in replicationLinks)
{
if (replicationLink.Source.Acceptor != RemoteAcceptor)
{
builder.Remove(replicationLink);
}
}
TargetEndpoint.System.ActorOf(Props.Create(() => new Connector(this, builder.ToImmutable())));
}
else
{
TargetEndpoint.System.ActorOf(Props.Create(() => new Connector(this, null)));
}
}
public ReplicatorActor(ReplicaId myself, ReplicatorSettings settings)
{
this.myself = myself;
this.settings = settings;
replicatorRelativePath = Self.Path.ToStringWithoutAddress();
Receive <ClusterEvent.MemberUp>(up =>
{
if (HasRole(up.Member) && up.Member.Address != cluster.SelfAddress)
{
// send invitation to a new member
var path = up.Member.Address.ToString() + replicatorRelativePath;
Context.ActorSelection(path).Tell(new Invitation(myself, Self));
}
});
Receive <ClusterEvent.IMemberEvent>(_ => { /* ignore */ });
Receive <Broadcast <T> >(bcast =>
{
var version = localVersion.Increment(myself);
var versioned = new Versioned <T>(version, bcast.Message);
var send = new Send <T>(myself, myself, versioned);
if (log.IsInfoEnabled)
{
log.Info("Sending {0} to: {1}", send, string.Join(", ", members));
}
foreach (var member in members)
{
member.Value.Forward(send);
}
var pendingAck = new PendingAck <T>(myself, versioned, DateTime.UtcNow, members.Keys.ToImmutableHashSet());
this.pendingAcks = pendingAcks.Add(pendingAck);
this.localVersion = version;
});
Receive <Send <T> >(send =>
{
if (AlreadySeen(send.Versioned.Version))
{
log.Info("Received duplicate message {0}", send);
}
else
{
var receivers = members.Remove(send.Origin);
var forward = send.WithLastSeenBy(myself);
if (log.IsInfoEnabled)
{
log.Info("Broadcasting message {0} to: {1}", forward, string.Join(", ", receivers.Values));
}
foreach (var member in receivers.Values)
{
member.Forward(forward);
}
if (members.TryGetValue(send.LastSeenBy, out var sender))
{
sender.Tell(new SendAck(myself, send.Versioned.Version), ActorRefs.NoSender);
}
var deliver = new Deliver <T>(send.Origin, send.Versioned);
Self.Forward(deliver);
this.pendingDelivery = pendingDelivery.Add(deliver);
this.pendingAcks = pendingAcks.Add(new PendingAck <T>(myself, send.Versioned, DateTime.UtcNow, receivers.Keys.ToImmutableHashSet()));
}
});
Receive <SendAck>(ack =>
{
log.Info("Received ACK from {0} (version: {1})", Sender, ack.Version);
var pendingAck = this.pendingAcks.First(x => x.Versioned.Version == ack.Version);
var membersLeft = pendingAck.Members.Remove(ack.ReplicaId);
this.pendingAcks = pendingAcks.Remove(pendingAck);
if (!membersLeft.IsEmpty)
{
this.pendingAcks = pendingAcks.Add(pendingAck.WithMembers(membersLeft));
}
});
Receive <Deliver <T> >(deliver =>
{
TryToCasuallyDeliver(deliver);
remoteVersions = remoteVersions.SetItem(deliver.Origin, deliver.Versioned.Version);
latestStableVersion = UpdateStableVersion(remoteVersions);
});
Receive <Resend>(_ =>
{
var now = DateTime.UtcNow;
var builder = pendingAcks.ToBuilder();
foreach (var ack in pendingAcks)
{
if (now - ack.Timestamp > settings.RetryTimeout)
{
builder.Remove(ack);
var send = new Send <T>(myself, myself, ack.Versioned);
foreach (var replicaId in ack.Members)
{
if (members.TryGetValue(replicaId, out var member))
{
member.Tell(send, ActorRefs.NoSender);
}
}
builder.Add(ack.WithTimestamp(now));
}
}
pendingAcks = builder.ToImmutable();
});
Receive <Invitation>(invitation =>
{
log.Info("Received invitation from {0} (ID: {1})", invitation.ReplicatorRef, invitation.ReplicaId);
members = members.Add(invitation.ReplicaId, invitation.ReplicatorRef);
Context.Watch(invitation.ReplicatorRef);
});
Receive <StableReq>(sync =>
{
var reply = sync.Versions.Where(ver => latestStableVersion >= ver).ToArray();
Sender.Tell(new StableRep(reply));
});
Receive <Subscribe <T> >(subscribe =>
{
subscribers = subscribers.Add(subscribe.Ref);
if (subscribe.Ack != null)
{
subscribe.Ref.Tell(subscribe.Ack);
}
});
Receive <Unsubscribe>(unsubscribe =>
{
subscribers = subscribers.Remove(unsubscribe.Ref);
if (unsubscribe.Ack != null)
{
unsubscribe.Ref.Tell(unsubscribe.Ack);
}
});
Receive <Terminated>(terminated =>
{
subscribers = subscribers.Remove(terminated.ActorRef);
var replicaId = members.FirstOrDefault(kv => Equals(kv.Value, terminated.ActorRef));
members = members.Remove(replicaId.Key);
});
resendTask = Context.System.Scheduler
.ScheduleTellOnceCancelable(settings.ResendInterval, Self, Resend.Instance, ActorRefs.NoSender);
}
