protected virtual void GetAllInternal(ICollection <IData> keyDatas, List <object> resultingKeyValuePairs)
{
var partitionToKeyData = GetPartitionKeyData(keyDatas);
var invocationService = GetContext().GetInvocationService();
var futures = new List <IFuture <IClientMessage> >(partitionToKeyData.Count);
foreach (var kvp in partitionToKeyData)
{
var partitionId = kvp.Key;
var keyList = kvp.Value;
if (keyList.Count > 0)
{
var request = MapGetAllCodec.EncodeRequest(GetName(), keyList);
futures.Add(invocationService.InvokeOnPartition(request, partitionId));
}
}
var messages = ThreadUtil.GetResult(futures);
foreach (var clientMessage in messages)
{
var items = MapGetAllCodec.DecodeResponse(clientMessage).response;
foreach (var entry in items)
{
resultingKeyValuePairs.Add(entry.Key);
resultingKeyValuePairs.Add(entry.Value);
}
}
}
public IDictionary <TKey, TValue> GetAll(ICollection <TKey> keys)
{
var partitionToKeyData = GetPartitionKeyData(keys);
var result = new Dictionary <TKey, TValue>();
if (_nearCache != null)
{
// remove items from list which are already found in the cache
foreach (var kvp in partitionToKeyData)
{
var list = kvp.Value;
for (var i = list.Count - 1; i >= 0; i--)
{
var keyData = kvp.Value[i];
var cached = _nearCache.Get(keyData);
if (cached != null && cached != ClientNearCache.NullObject)
{
list.RemoveAt(i);
result.Add(ToObject <TKey>(keyData), (TValue)cached);
}
}
}
}
var invocationService = GetContext().GetInvocationService();
var futures = new List <IFuture <IClientMessage> >(partitionToKeyData.Count);
foreach (var kvp in partitionToKeyData)
{
if (kvp.Value.Count > 0)
{
var request = MapGetAllCodec.EncodeRequest(GetName(), kvp.Value);
futures.Add(invocationService.InvokeOnPartition(request, kvp.Key));
}
}
var messages = ThreadUtil.GetResult(futures);
foreach (var clientMessage in messages)
{
var items = MapGetAllCodec.DecodeResponse(clientMessage).entrySet;
foreach (var entry in items)
{
var key = ToObject <TKey>(entry.Key);
var value = ToObject <TValue>(entry.Value);
result.Add(key, value);
if (_nearCache != null)
{
_nearCache.Put(entry.Key, value);
}
}
}
return(result);
}
public IDictionary <K, V> GetAll(ICollection <K> keys)
{
var keySet = new HashSet <IData>();
IDictionary <K, V> result = new Dictionary <K, V>();
foreach (object key in keys)
{
keySet.Add(ToData(key));
}
if (_nearCache != null)
{
foreach (var keyData in keySet)
{
var cached = _nearCache.Get(keyData);
if (cached != null)
{
if (!cached.Equals(ClientNearCache.NullObject))
{
result.Add(ToObject <K>(keyData), (V)cached);
keySet.Remove(keyData);
}
}
}
}
if (keySet.Count == 0)
{
return(result);
}
var request = MapGetAllCodec.EncodeRequest(GetName(), keySet);
var entrySet = Invoke(request, m => MapGetAllCodec.DecodeResponse(m).entrySet);
foreach (var entry in entrySet)
{
var value = ToObject <V>(entry.Value);
var key_1 = ToObject <K>(entry.Key);
result[key_1] = value;
if (_nearCache != null)
{
_nearCache.Put(entry.Key, value);
}
}
return(result);
}
protected virtual void GetAllInternal(ArrayList partitionToKeyData,
ConcurrentQueue <KeyValuePair <IData, object> > resultingKeyValuePairs)
{
var invocationService = GetContext().GetInvocationService();
var futures = new ConcurrentQueue <IFuture <IClientMessage> >();
Parallel.For(0, partitionToKeyData.Count, partitionId =>
{
var keyList = (ArrayList)partitionToKeyData[partitionId];
if (keyList.Count > 0)
{
var request = MapGetAllCodec.EncodeRequest(GetName(), keyList);
futures.Enqueue(invocationService.InvokeOnPartition(request, partitionId));
}
});
var messages = ThreadUtil.GetResult(futures);
Parallel.ForEach(messages,
clientMessage => { MapGetAllCodec.DecodeResponse(clientMessage, resultingKeyValuePairs); });
}
/// <summary>
/// Gets all entries for keys.
/// </summary>
/// <param name="ownerKeys">Keys.</param>
/// <param name="cancellationToken">A cancellation token.</param>
/// <returns>The values for the specified keys.</returns>
protected virtual async Task <ReadOnlyLazyDictionary <TKey, TValue> > GetAsync(Dictionary <Guid, Dictionary <int, List <IData> > > ownerKeys, CancellationToken cancellationToken)
{
// create parallel tasks to fire a request for each owner
var tasks = new List <Task <ClientMessage> >();
foreach (var(ownerId, part) in ownerKeys)
{
foreach (var(partitionId, list) in part)
{
if (list.Count == 0)
{
continue;
}
var requestMessage = MapGetAllCodec.EncodeRequest(Name, list);
requestMessage.PartitionId = partitionId;
var task = Cluster.Messaging.SendToMemberAsync(requestMessage, ownerId, cancellationToken);
tasks.Add(task);
}
}
// and wait on all tasks, gathering the responses
await Task.WhenAll(tasks).CAF();
// decode all responses, in 1 thread: this is CPU-bound
// (we may want to introduce some parallelism, though, depending on # of cores)
var result = new ReadOnlyLazyDictionary <TKey, TValue>(SerializationService);
// ReSharper disable once ForeachCanBePartlyConvertedToQueryUsingAnotherGetEnumerator
foreach (var task in tasks)
{
var responseMessage = task.Result; // safe: we know the task has completed
var response = MapGetAllCodec.DecodeResponse(responseMessage).Response;
result.Add(response);
}
return(result);
}
protected virtual void GetAllInternal(List <List <IData> > partitionToKeyData,
List <KeyValuePair <IData, object> > resultingKeyValuePairs)
{
var invocationService = Client.InvocationService;
var futures = new List <IFuture <ClientMessage> >();
for (var partitionId = 0; partitionId < partitionToKeyData.Count; partitionId++)
{
ICollection <IData> keyList = partitionToKeyData[partitionId];
if (keyList.Count > 0)
{
var request = MapGetAllCodec.EncodeRequest(Name, keyList);
futures.Add(invocationService.InvokeOnPartitionOwner(request, partitionId));
}
}
foreach (var future in futures)
{
foreach (var kvp in MapGetAllCodec.DecodeResponse(future.Result).Response)
{
resultingKeyValuePairs.Add(new KeyValuePair <IData, object>(kvp.Key, kvp.Value));
}
}
}
