internal override List <BatchNode> GenerateBatchNodes()
{
return(BatchNode.GenerateList(cluster, batchPolicy, keys, sequenceAP, sequenceSC, batch));
}
public AsyncBatchExecutor(Cluster cluster, BatchPolicy policy, Key[] keys)
{
this.keys = keys;
this.batchNodes = BatchNode.GenerateList(cluster, policy, keys);
this.taskSize = batchNodes.Count;
}
public static void Execute(Cluster cluster, BatchPolicy policy, Key[] keys, bool[] existsArray, Record[] records, string[] binNames, int readAttr)
{
if (keys.Length == 0)
{
return;
}
if (policy.allowProleReads)
{
// Send all requests to a single node chosen in round-robin fashion in this transaction thread.
Node node = cluster.GetRandomNode();
BatchNode batchNode = new BatchNode(node, keys);
ExecuteNode(batchNode, policy, keys, existsArray, records, binNames, readAttr);
return;
}
List <BatchNode> batchNodes = BatchNode.GenerateList(cluster, policy, keys);
if (policy.maxConcurrentThreads == 1 || batchNodes.Count <= 1)
{
// Run batch requests sequentially in same thread.
foreach (BatchNode batchNode in batchNodes)
{
ExecuteNode(batchNode, policy, keys, existsArray, records, binNames, readAttr);
}
}
else
{
// Run batch requests in parallel in separate threads.
//
// Multiple threads write to the record/exists array, so one might think that
// volatile or memory barriers are needed on the write threads and this read thread.
// This should not be necessary here because it happens in Executor which does a
// volatile write (Interlocked.Increment(ref completedCount)) at the end of write threads
// and a synchronized WaitTillComplete() in this thread.
Executor executor = new Executor(batchNodes.Count * 2);
// Initialize threads.
foreach (BatchNode batchNode in batchNodes)
{
if (batchNode.node.UseNewBatch(policy))
{
// New batch
if (records != null)
{
MultiCommand command = new BatchGetArrayCommand(batchNode, policy, keys, binNames, records, readAttr);
executor.AddCommand(command);
}
else
{
MultiCommand command = new BatchExistsArrayCommand(batchNode, policy, keys, existsArray);
executor.AddCommand(command);
}
}
else
{
// There may be multiple threads for a single node because the
// wire protocol only allows one namespace per command. Multiple namespaces
// require multiple threads per node.
batchNode.SplitByNamespace(keys);
foreach (BatchNode.BatchNamespace batchNamespace in batchNode.batchNamespaces)
{
if (records != null)
{
MultiCommand command = new BatchGetArrayDirect(batchNode.node, batchNamespace, policy, keys, binNames, records, readAttr);
executor.AddCommand(command);
}
else
{
MultiCommand command = new BatchExistsArrayDirect(batchNode.node, batchNamespace, policy, keys, existsArray);
executor.AddCommand(command);
}
}
}
}
executor.Execute(policy.maxConcurrentThreads);
}
}
protected internal override List <BatchNode> GenerateBatchNodes(Cluster cluster)
{
return(BatchNode.GenerateList(cluster, policy, records, sequenceAP, sequenceSC, batch));
}