private async ValueTask <PlacementResult> GetOrPlaceActivationAsync(
ValueTask <PlacementResult> selectActivationTask,
PlacementTarget target,
PlacementStrategy strategy,
IPlacementRuntime placementRuntime,
IPlacementDirector director)
{
var placementResult = await selectActivationTask;
if (placementResult is object)
{
return(placementResult);
}
var siloAddress = await director.OnAddActivation(strategy, target, placementRuntime);
ActivationId activationId;
if (strategy.IsDeterministicActivationId)
{
// Use the grain id as the activation id.
activationId = ActivationId.GetDeterministic(target.GrainIdentity);
}
else
{
activationId = ActivationId.NewId();
}
return(PlacementResult.SpecifyCreation(
siloAddress,
activationId,
strategy));
}
/// <summary>
/// Run the code example.
/// </summary>
/// <param name="user">The Dfa user object running the code example.
/// </param>
public override void Run(DfaUser user)
{
// Create PlacementStrategyRemoteService instance.
PlacementStrategyRemoteService service = (PlacementStrategyRemoteService) user.GetService(
DfaService.v1_20.PlacementStrategyRemoteService);
String placementStrategyName = _T("INSERT_PLACEMENT_STRATEGY_NAME_HERE");
// Create placement strategy structure.
PlacementStrategy placementStrategy = new PlacementStrategy();
placementStrategy.id = 0;
placementStrategy.name = placementStrategyName;
try {
// Create placement strategy.
PlacementStrategySaveResult placementStrategySaveResult =
service.savePlacementStrategy(placementStrategy);
if (placementStrategySaveResult != null) {
// Display placement strategy id.
Console.WriteLine("Placement Strategy with id \"{0}\" was created.",
placementStrategySaveResult.id);
}
} catch (Exception e) {
Console.WriteLine("Failed to create placement strategy. Exception says \"{0}\"",
e.Message);
}
}
public Task <SiloAddress> OnAddActivation(PlacementStrategy strategy, PlacementTarget target, IPlacementContext context)
{
var silos = context.GetCompatibleSilos(target).OrderBy(x => x).ToArray();
if (Constants.DefaultNumGrainsInOneLayer == 0)
{
Constants.DefaultNumGrainsInOneLayer = 2 * (silos.Length - 1);
}
var targetSilo = RequestContext.Get("targetSilo");
if (targetSilo != null)
{
foreach (SiloAddress silo in silos)
{
if (silo.Endpoint.Address.ToString().Equals(targetSilo))
{
return(Task.FromResult(silo));
}
}
}
var excludeSilo = RequestContext.Get("excludeSilo");
if (excludeSilo != null)
{
silos = silos.Where(x => !x.Endpoint.Address.ToString().Equals(excludeSilo)).ToArray();
}
object index = RequestContext.Get("grainIndex");
if (index == null)
{
index = new Random().Next(0, silos.Count());
}
return(Task.FromResult(silos[(int)index % silos.Count()]));
}
/// <summary>
/// Selects the best match from list of silos, updates local statistics.
/// </summary>
/// <note>
/// This is equivalent with SelectSiloPowerOfK() with chooseHowMany = #Silos
/// </note>
private Task <SiloAddress> SelectSiloGreedy(PlacementStrategy strategy, GrainId grain, IPlacementRuntime context)
{
int minLoad = int.MaxValue;
CachedLocalStat minLoadedSilo = null;
foreach (CachedLocalStat current in localCache.Values)
{
if (IsSiloOverloaded(current.SiloStats))
{
continue;
}
int load = SiloLoad_ByRecentActivations(current);
if (load >= minLoad)
{
continue;
}
minLoadedSilo = current;
minLoad = load;
}
if (minLoadedSilo != null)
{
return(MakePlacement(minLoadedSilo));
}
var debugLog = string.Format("Unable to select a candidate from {0} silos: {1}", localCache.Count,
Utils.EnumerableToString(
localCache,
kvp => String.Format("SiloAddress = {0} -> {1}", kvp.Key.ToString(), kvp.Value.ToString())));
logger.Warn(ErrorCode.Placement_ActivationCountBasedDirector_NoSilos, debugLog);
throw new OrleansException(debugLog);
}
public static List <PlacementStrategy> ConvertPlacementStrategy(string[] values)
{
if (values == null || values.Length == 0)
{
return(null);
}
var list = new List <PlacementStrategy>();
foreach (var value in values)
{
var tokens = value.Split('=');
var constraint = new PlacementStrategy
{
Type = tokens[0]
};
if (tokens.Length > 1)
{
constraint.Field = tokens[1];
}
list.Add(constraint);
}
return(list);
}
internal override Task <PlacementResult> OnAddActivation(PlacementStrategy strategy, GrainId grain, IPlacementContext context)
{
var grainType = context.GetGrainTypeName(grain);
return(Task.FromResult(
PlacementResult.SpecifyCreation(context.LocalSilo, strategy, grainType)));
}
public virtual Task <SiloAddress> OnAddActivation(
PlacementStrategy strategy, PlacementTarget target, IPlacementContext context)
{
var allSilos = context.GetCompatibleSilos(target);
return(Task.FromResult(allSilos[random.Next(allSilos.Length)]));
}
internal override async Task <PlacementResult> OnSelectActivation(
PlacementStrategy strategy, GrainId target, IPlacementContext context)
{
List <ActivationAddress> places = await context.Lookup(target);
if (places.Count <= 0)
{
// we return null to indicate that we were unable to select a target from places activations.
return(null);
}
if (places.Count == 1)
{
return(PlacementResult.IdentifySelection(places[0]));
}
// places.Count > 0
// Choose randomly if there is one, else make a new activation of the target
// pick local if available (consider making this a purely random assignment of grains).
var here = context.LocalSilo;
var local = places.Where(a => a.Silo.Equals(here)).ToList();
if (local.Count > 0)
{
return(PlacementResult.IdentifySelection(local[random.Next(local.Count)]));
}
if (places.Count > 0)
{
return(PlacementResult.IdentifySelection(places[random.Next(places.Count)]));
}
// we return null to indicate that we were unable to select a target from places activations.
return(null);
}
public override async Task <PlacementResult> OnSelectActivation(PlacementStrategy strategy, GrainId target, IPlacementContext context)
{
// first, check if we can find an activation for this client in the cache or local directory partition
AddressesAndTag addresses;
if (context.FastLookup(target, out addresses))
{
return(ChooseRandomActivation(addresses.Addresses, context));
}
// we need to look up the directory entry for this grain on a remote silo
switch (target.Category)
{
case UniqueKey.Category.Client:
{
addresses = await context.FullLookup(target);
return(ChooseRandomActivation(addresses.Addresses, context));
}
case UniqueKey.Category.GeoClient:
{
// we need to look up the activations in the remote cluster
addresses = await context.LookupInCluster(target, target.Key.ClusterId);
return(ChooseRandomActivation(addresses.Addresses, context));
}
default:
throw new InvalidOperationException("Unsupported client type. Grain " + target);
}
}
public Task <SiloAddress> OnAddActivation(PlacementStrategy strategy, PlacementTarget target, IPlacementContext context)
{
IReadOnlyList <SiloAddress> silos;
if (target.InterfaceVersion == 0)
{
silos = (IReadOnlyList <SiloAddress>)context.GetCompatibleSilos(target);
}
else
{
var silosByVersion = context.GetCompatibleSilosWithVersions(target);
var maxSiloCount = 0;
ushort version = 0;
foreach (var kvp in silosByVersion)
{
if (kvp.Value.Count > maxSiloCount)
{
version = kvp.Key;
maxSiloCount = kvp.Value.Count;
}
}
silos = silosByVersion[version];
}
return(Task.FromResult(silos[random.Next(silos.Count)]));
}
public async Task <PlacementResult> SelectOrAddActivation(
ActivationAddress sendingAddress,
PlacementTarget targetGrain,
IPlacementRuntime context,
PlacementStrategy strategy)
{
if (targetGrain.IsClient)
{
var res = await clientObserversPlacementDirector.OnSelectActivation(strategy, (GrainId)targetGrain.GrainIdentity, context);
if (res == null)
{
throw new ClientNotAvailableException(targetGrain.GrainIdentity);
}
return(res);
}
var actualStrategy = strategy ?? defaultPlacementStrategy;
var director = ResolveSelector(actualStrategy);
var result = await director.OnSelectActivation(strategy, (GrainId)targetGrain.GrainIdentity, context);
if (result != null)
{
return(result);
}
return(await AddActivation(targetGrain, context, actualStrategy));
}
private void ResolveBuiltInStrategies()
{
var statelessWorker = new StatelessWorkerPlacement();
var placementStrategies = new PlacementStrategy[]
{
RandomPlacement.Singleton,
ActivationCountBasedPlacement.Singleton,
statelessWorker,
PreferLocalPlacement.Singleton
};
foreach (var strategy in placementStrategies)
{
this.ResolveDirector(strategy);
}
var selectorStrategies = new PlacementStrategy[]
{
RandomPlacement.Singleton,
statelessWorker,
};
foreach (var strategy in selectorStrategies)
{
this.ResolveSelector(strategy, true);
}
}
/// <summary>
/// Run the code example.
/// </summary>
/// <param name="user">The Dfa user object running the code example.
/// </param>
public override void Run(DfaUser user)
{
// Create PlacementStrategyRemoteService instance.
PlacementStrategyRemoteService service = (PlacementStrategyRemoteService)user.GetService(
DfaService.v1_20.PlacementStrategyRemoteService);
String placementStrategyName = _T("INSERT_PLACEMENT_STRATEGY_NAME_HERE");
// Create placement strategy structure.
PlacementStrategy placementStrategy = new PlacementStrategy();
placementStrategy.id = 0;
placementStrategy.name = placementStrategyName;
try {
// Create placement strategy.
PlacementStrategySaveResult placementStrategySaveResult =
service.savePlacementStrategy(placementStrategy);
if (placementStrategySaveResult != null)
{
// Display placement strategy id.
Console.WriteLine("Placement Strategy with id \"{0}\" was created.",
placementStrategySaveResult.id);
}
} catch (Exception ex) {
Console.WriteLine("Failed to create placement strategy. Exception says \"{0}\"",
ex.Message);
}
}
public virtual async Task <PlacementResult> OnSelectActivation(
PlacementStrategy strategy, GrainId target, IPlacementContext context)
{
List <ActivationAddress> places = (await context.Lookup(target)).Addresses;
return(ChooseRandomActivation(places, context));
}
internal override Task<PlacementResult> OnSelectActivation(
PlacementStrategy strategy, GrainId target, IPlacementContext context)
{
if (target.IsClient)
throw new InvalidOperationException("Cannot use StatelessWorkerStrategy to route messages to client grains.");
// If there are available (not busy with a request) activations, it returns the first one.
// If all are busy and the number of local activations reached or exceeded MaxLocal, it randomly returns one of them.
// Otherwise, it requests creation of a new activation.
List<ActivationData> local;
if (!context.LocalLookup(target, out local) || local.Count == 0)
return Task.FromResult((PlacementResult)null);
var placement = (StatelessWorkerPlacement)strategy;
foreach (var activation in local)
{
ActivationData info;
if (!context.TryGetActivationData(activation.ActivationId, out info) ||
info.State != ActivationState.Valid || !info.IsInactive) continue;
return Task.FromResult(PlacementResult.IdentifySelection(ActivationAddress.GetAddress(context.LocalSilo, target, activation.ActivationId)));
}
if (local.Count >= placement.MaxLocal)
{
var id = local[local.Count == 1 ? 0 : random.Next(local.Count)].ActivationId;
return Task.FromResult(PlacementResult.IdentifySelection(ActivationAddress.GetAddress(context.LocalSilo, target, id)));
}
return Task.FromResult((PlacementResult)null);
}
public async Task <PlacementResult> SelectOrAddActivation(
ActivationAddress sendingAddress,
GrainId targetGrain,
IPlacementContext context,
PlacementStrategy strategy)
{
if (targetGrain.IsClient)
{
var res = await clientObserversPlacementDirector.OnSelectActivation(strategy, targetGrain, context);
if (res == null)
{
throw new KeyNotFoundException("No activation for client " + targetGrain);
}
return(res);
}
var actualStrategy = strategy ?? defaultPlacementStrategy;
var result = await SelectActivation(targetGrain, context, actualStrategy);
if (result != null)
{
return(result);
}
return(await AddActivation(targetGrain, context, actualStrategy));
}
private async Task <PlacementResult> AddActivation(
PlacementTarget target,
IPlacementRuntime context,
PlacementStrategy strategy)
{
if (target.IsClient)
{
throw new InvalidOperationException("Client grains are not activated using the placement subsystem.");
}
var director = ResolveDirector(strategy);
var siloAddress = await director.OnAddActivation(strategy, target, context);
var grainTypeName = context.GetGrainTypeName(target.GrainIdentity.TypeCode);
ActivationId activationId;
if (strategy.IsDeterministicActivationId)
{
// Use the grain id as the activation id.
activationId = ActivationId.GetActivationId(((GrainId)target.GrainIdentity).Key);
}
else
{
activationId = ActivationId.NewId();
}
return(PlacementResult.SpecifyCreation(
siloAddress,
activationId,
strategy,
grainTypeName));
}
public override Task <SiloAddress> OnAddActivation(
PlacementStrategy strategy,
PlacementTarget target,
IPlacementContext context)
{
throw new InvalidOperationException("Client Observers are not activated using the placement subsystem. Grain " + target.GrainIdentity);
}
public override async Task<PlacementResult> OnSelectActivation(PlacementStrategy strategy, GrainId target, IPlacementContext context)
{
// first, check if we can find an activation for this client in the cache or local directory partition
AddressesAndTag addresses;
if (context.FastLookup(target, out addresses))
return ChooseRandomActivation(addresses.Addresses, context);
// we need to look up the directory entry for this grain on a remote silo
switch (target.Category)
{
case UniqueKey.Category.Client:
{
addresses = await context.FullLookup(target);
return ChooseRandomActivation(addresses.Addresses, context);
}
case UniqueKey.Category.GeoClient:
{
// we need to look up the activations in the remote cluster
addresses = await context.LookupInCluster(target, target.Key.ClusterId);
return ChooseRandomActivation(addresses.Addresses, context);
}
default:
throw new InvalidOperationException("Unsupported client type. Grain " + target);
}
}
internal override Task<PlacementResult> OnAddActivation(
PlacementStrategy strategy, GrainId grain, IPlacementContext context)
{
var grainType = context.GetGrainTypeName(grain);
var allSilos = context.AllActiveSilos;
return Task.FromResult(
PlacementResult.SpecifyCreation(allSilos[random.Next(allSilos.Count)], strategy, grainType));
}
internal static void InitDefaultGrainStrategies()
{
RandomPlacement = Orleans.Runtime.RandomPlacement.Singleton;
PreferLocalPlacement = Orleans.Runtime.PreferLocalPlacement.Singleton;
ActivationCountBasedPlacement = Orleans.Runtime.ActivationCountBasedPlacement.Singleton;
}
public virtual Task <SiloAddress> OnAddActivation(
PlacementStrategy strategy, PlacementTarget target, IPlacementContext context)
{
var allSilos = context.GetCompatibleSilos(target).OrderBy(s => s).ToArray(); // need to sort the list, so that the outcome is deterministic
int hash = (int)(target.GrainIdentity.GetUniformHashCode() & 0x7fffffff); // reset highest order bit to avoid negative ints
return(Task.FromResult(allSilos[hash % allSilos.Length]));
}
public virtual Task <SiloAddress> OnAddActivation(
PlacementStrategy strategy, PlacementTarget target, IPlacementContext context)
{
var allSilos = context.GetCompatibleSilos(target);
int hash = (int)(target.GrainIdentity.GetUniformHashCode() & 0x7fffffff); // reset highest order bit to avoid negative ints
return(Task.FromResult(allSilos[hash % allSilos.Count]));
}
public virtual Task <PlacementResult> OnAddActivation(
PlacementStrategy strategy, PlacementTarget target, IPlacementContext context)
{
var grainType = context.GetGrainTypeName(target.GrainId);
var allSilos = context.GetCompatibleSiloList(target);
return(Task.FromResult(
PlacementResult.SpecifyCreation(allSilos[random.Next(allSilos.Count)], strategy, grainType)));
}
protected PlacementAttribute(PlacementStrategy placement)
{
if (placement == null)
{
throw new ArgumentNullException(nameof(placement));
}
PlacementStrategy = placement;
}
public virtual Task <PlacementResult> OnAddActivation(
PlacementStrategy strategy, GrainId grain, IPlacementContext context)
{
var grainType = context.GetGrainTypeName(grain);
var allSilos = context.AllActiveSilos;
return(Task.FromResult(
PlacementResult.SpecifyCreation(allSilos[random.Next(allSilos.Count)], strategy, grainType)));
}
private Task <PlacementResult> SelectActivation(
GrainId targetGrain,
IPlacementContext context,
PlacementStrategy strategy)
{
var director = ResolveDirector(strategy);
return(director.OnSelectActivation(strategy, targetGrain, context));
}
/// <summary>
/// Generate one GrainReference class for each Grain Type in the inputLib file
/// and output one GrainClient.dll under outputLib directory
/// </summary>
private bool CreateGrainClient(CodeGenOptions options)
{
PlacementStrategy.Initialize();
// Load input assembly
ConsoleText.WriteLine("");
var assemblyName = AssemblyName.GetAssemblyName(options.InputLib.FullName);
var grainAssembly = (Path.GetFileName(options.InputLib.FullName) != "Orleans.dll")
? Assembly.LoadFrom(options.InputLib.FullName)
: Assembly.Load(assemblyName);
// special case Orleans.dll because there is a circular dependency.
// Create sources directory
if (!Directory.Exists(options.SourcesDir))
{
Directory.CreateDirectory(options.SourcesDir);
}
// Generate source
var outputFileName = Path.Combine(
options.SourcesDir,
Path.GetFileNameWithoutExtension(options.InputLib.Name) + ".codegen.cs");
ConsoleText.WriteStatus("Orleans-CodeGen - Generating file {0}", outputFileName);
var codeGenerator = RoslynCodeGenerator.Instance;
using (var sourceWriter = new StreamWriter(outputFileName))
{
if (options.TargetLanguage != Language.CSharp)
{
var message = "Compile-time code generation is supported for C# only. "
+ "Remove code generation from your project in order to use run-time code generation.";
ConsoleText.WriteLine("ERROR: " + message);
throw new NotSupportedException(message);
}
sourceWriter.WriteLine("#if !EXCLUDE_CODEGEN");
DisableWarnings(sourceWriter, suppressCompilerWarnings);
sourceWriter.WriteLine(codeGenerator.GenerateSourceForAssembly(grainAssembly));
RestoreWarnings(sourceWriter, suppressCompilerWarnings);
sourceWriter.WriteLine("#endif");
}
ConsoleText.WriteStatus("Orleans-CodeGen - Generated file written {0}", outputFileName);
// Copy intermediate file to permanent location, if newer.
ConsoleText.WriteStatus(
"Orleans-CodeGen - Updating IntelliSense file {0} -> {1}",
outputFileName,
options.CodeGenFile);
UpdateIntellisenseFile(options.CodeGenFile, outputFileName);
return(true);
}
public PlacementDirectorsManager(
IServiceProvider services,
DefaultPlacementStrategy defaultPlacementStrategy,
ClientObserversPlacementDirector clientObserversPlacementDirector)
{
this.serviceProvider = services;
this.defaultPlacementStrategy = defaultPlacementStrategy.PlacementStrategy;
this.clientObserversPlacementDirector = clientObserversPlacementDirector;
this.ResolveBuiltInStrategies();
}
/// <summary>
/// Create a <see cref="PlacementStrategyResolver"/> instance.
/// </summary>
public PlacementStrategyResolver(
IServiceProvider services,
IEnumerable <IPlacementStrategyResolver> resolvers,
GrainPropertiesResolver grainPropertiesResolver)
{
_getStrategyInternal = GetPlacementStrategyInternal;
_resolvers = resolvers.ToArray();
_services = services;
_grainPropertiesResolver = grainPropertiesResolver;
_defaultPlacementStrategy = services.GetService <PlacementStrategy>();
_strategies = GetAllStrategies(services);
OnAddActivation(PlacementStrategy strategy, PlacementTarget target, IPlacementContext context)
{
// if local silo is not active or does not support this type of grain, revert to random placement
if (context.LocalSiloStatus != SiloStatus.Active || !context.GetCompatibleSilos(target).Contains(context.LocalSilo))
{
return(base.OnAddActivation(strategy, target, context));
}
cachedLocalSilo = cachedLocalSilo ?? Task.FromResult(context.LocalSilo);
return(cachedLocalSilo);
}
public async Task DefaultPlacementShouldBeRandom()
{
await this.HostedCluster.WaitForLivenessToStabilizeAsync();
logger.Info("********************** Starting the test DefaultPlacementShouldBeRandom ******************************");
TestSilosStarted(2);
Assert.Equal(
RandomPlacement.Singleton,
PlacementStrategy.GetDefault());
}
public override Task <SiloAddress> OnAddActivation(
PlacementStrategy strategy, PlacementTarget target, IPlacementContext context)
{
// If the cache was not populated, just place locally
if (this.localCache.IsEmpty)
{
return(Task.FromResult(this.localAddress));
}
return(SelectSilo(strategy, target, context));
}
public GrainInterfaceMap(bool localTestMode, PlacementStrategy defaultPlacementStrategy)
{
table = new Dictionary<int, GrainInterfaceData>();
typeToInterfaceData = new Dictionary<string, GrainInterfaceData>();
primaryImplementations = new Dictionary<string, string>();
implementationIndex = new Dictionary<int, GrainClassData>();
unordered = new HashSet<int>();
this.localTestMode = localTestMode;
this.defaultPlacementStrategy = defaultPlacementStrategy;
if(localTestMode) // if we are running in test mode, we'll build a list of loaded grain assemblies to help with troubleshooting deployment issue
loadedGrainAsemblies = new HashSet<string>();
}
private Task<PlacementResult> MakePlacement(PlacementStrategy strategy, GrainId grain, IPlacementContext context, CachedLocalStat minLoadedSilo)
{
// Increment placement by number of silos instead of by one.
// This is our trick to get more balanced placement, accounting to the probable
// case when multiple silos place on the same silo at the same time, before stats are refreshed.
minLoadedSilo.IncrementActivationCount(localCache.Count);
return Task.FromResult(PlacementResult.SpecifyCreation(
minLoadedSilo.Address,
strategy,
context.GetGrainTypeName(grain)));
}
private Task <PlacementResult> MakePlacement(PlacementStrategy strategy, GrainId grain, IPlacementContext context, CachedLocalStat minLoadedSilo)
{
// Increment placement by number of silos instead of by one.
// This is our trick to get more balanced placement, accounting to the probable
// case when multiple silos place on the same silo at the same time, before stats are refreshed.
minLoadedSilo.IncrementActivationCount(localCache.Count);
return(Task.FromResult(PlacementResult.SpecifyCreation(
minLoadedSilo.Address,
strategy,
context.GetGrainTypeName(grain))));
}
public GrainTypeManager(bool localTestMode, SiloAssemblyLoader loader, DefaultPlacementStrategy defaultPlacementStrategy)
{
this.defaultPlacementStrategy = defaultPlacementStrategy.PlacementStrategy;
this.loader = loader;
grainInterfaceMap = new GrainInterfaceMap(localTestMode, this.defaultPlacementStrategy);
lock (lockable)
{
if (Instance != null)
throw new InvalidOperationException("An attempt to create a second insance of GrainTypeManager.");
Instance = this;
}
}
public PlacementDirectorsManager(
IServiceProvider services,
PlacementStrategy defaultPlacementStrategy,
ClientObserversPlacementDirector clientObserversPlacementDirector)
{
this.serviceProvider = services;
this.defaultPlacementStrategy = defaultPlacementStrategy;
this.clientObserversPlacementDirector = clientObserversPlacementDirector;
this.ResolveBuiltInStrategies();
// TODO: Make default selector configurable
this.defaultActivationSelector = ResolveSelector(RandomPlacement.Singleton, true);
}
/// <summary>
/// Run the code example.
/// </summary>
/// <param name="service">An initialized Dfa Reporting service object
/// </param>
public override void Run(DfareportingService service) {
long profileId = long.Parse(_T("INSERT_USER_PROFILE_ID_HERE"));
string placementStrategyName = _T("INSERT_PLACEMENT_STRATEGY_NAME_HERE");
// Create the placement strategy.
PlacementStrategy placementStrategy = new PlacementStrategy();
placementStrategy.Name = placementStrategyName;
// Insert the placement strategy.
PlacementStrategy result =
service.PlacementStrategies.Insert(placementStrategy, profileId).Execute();
// Display the new placement strategy ID.
Console.WriteLine("Placement strategy with ID {0} was created.", result.Id);
}
internal void AddEntry(int interfaceId, Type iface, int grainTypeCode, string grainInterface, string grainClass, string assembly,
bool isGenericGrainClass, PlacementStrategy placement, bool primaryImplementation = false)
{
lock (this)
{
GrainInterfaceData grainInterfaceData;
if (table.ContainsKey(interfaceId))
{
grainInterfaceData = table[interfaceId];
}
else
{
grainInterfaceData = new GrainInterfaceData(interfaceId, iface, grainInterface);
table[interfaceId] = grainInterfaceData;
var interfaceTypeKey = GetTypeKey(iface, isGenericGrainClass);
typeToInterfaceData[interfaceTypeKey] = grainInterfaceData;
}
var implementation = new GrainClassData(grainTypeCode, grainClass, isGenericGrainClass, grainInterfaceData, placement);
if (!implementationIndex.ContainsKey(grainTypeCode))
implementationIndex.Add(grainTypeCode, implementation);
grainInterfaceData.AddImplementation(implementation, primaryImplementation);
if (primaryImplementation)
{
primaryImplementations[grainInterface] = grainClass;
}
else
{
if (!primaryImplementations.ContainsKey(grainInterface))
primaryImplementations.Add(grainInterface, grainClass);
}
if (localTestMode)
{
if (!loadedGrainAsemblies.Contains(assembly))
loadedGrainAsemblies.Add(assembly);
}
}
}
SpecifyCreation(
SiloAddress silo,
PlacementStrategy placement,
string grainType)
{
if (silo == null)
throw new ArgumentNullException("silo");
if (placement == null)
throw new ArgumentNullException("placement");
if (string.IsNullOrWhiteSpace(grainType))
throw new ArgumentException("'grainType' must contain a valid typename.");
return
new PlacementResult
{
Activation = ActivationId.NewId(),
Silo = silo,
PlacementStrategy = placement,
GrainType = grainType
};
}
internal override async Task<PlacementResult> OnSelectActivation(
PlacementStrategy strategy, GrainId target, IPlacementContext context)
{
List<ActivationAddress> places = await context.Lookup(target);
if (places.Count <= 0)
{
// we return null to indicate that we were unable to select a target from places activations.
return null;
}
if (places.Count == 1) return PlacementResult.IdentifySelection(places[0]);
// places.Count > 0
// Choose randomly if there is one, else make a new activation of the target
// pick local if available (consider making this a purely random assignment of grains).
var here = context.LocalSilo;
var local = places.Where(a => a.Silo.Equals(here)).ToList();
if (local.Count > 0)
return PlacementResult.IdentifySelection(local[random.Next(local.Count)]);
if (places.Count > 0)
return PlacementResult.IdentifySelection(places[random.Next(places.Count)]);
// we return null to indicate that we were unable to select a target from places activations.
return null;
}
internal PlacementAttribute(PlacementStrategy placement)
{
if (placement == null) throw new ArgumentNullException(nameof(placement));
PlacementStrategy = placement;
}
internal override Task<PlacementResult> OnAddActivation(
PlacementStrategy strategy, GrainId grain, IPlacementContext context)
{
return SelectSilo(strategy, grain, context);
}
/// <summary>
/// Selects the best match from list of silos, updates local statistics.
/// </summary>
/// <note>
/// This is equivalent with SelectSiloPowerOfK() with chooseHowMany = #Silos
/// </note>
private Task<PlacementResult> SelectSiloGreedy(PlacementStrategy strategy, GrainId grain, IPlacementContext context)
{
int minLoad = int.MaxValue;
CachedLocalStat minLoadedSilo = null;
foreach (CachedLocalStat current in localCache.Values)
{
if (IsSiloOverloaded(current.SiloStats)) continue;
int load = SiloLoad_ByRecentActivations(current);
if (load >= minLoad) continue;
minLoadedSilo = current;
minLoad = load;
}
if (minLoadedSilo != null)
return MakePlacement(strategy, grain, context, minLoadedSilo);
var debugLog = string.Format("Unable to select a candidate from {0} silos: {1}", localCache.Count,
Utils.EnumerableToString(
localCache,
kvp => String.Format("SiloAddress = {0} -> {1}", kvp.Key.ToString(), kvp.Value.ToString())));
logger.Warn(ErrorCode.Placement_ActivationCountBasedDirector_NoSilos, debugLog);
throw new OrleansException(debugLog);
}
public static void GetGrainTypeInfo(this IPlacementContext @this, GrainId grainId, out string grainClass, out PlacementStrategy placement, string genericArguments = null)
{
@this.GetGrainTypeInfo(grainId.GetTypeCode(), out grainClass, out placement, genericArguments);
}
public Task<PlacementResult> SelectSiloPowerOfK(PlacementStrategy strategy, GrainId grain, IPlacementContext context)
{
// Exclude overloaded silos
var relevantSilos = new List<CachedLocalStat>();
foreach (CachedLocalStat current in localCache.Values)
{
if (IsSiloOverloaded(current.SiloStats)) continue;
relevantSilos.Add(current);
}
if (relevantSilos.Count > 0)
{
int chooseFrom = Math.Min(relevantSilos.Count, chooseHowMany);
var chooseFromThoseSilos = new List<CachedLocalStat>();
while (chooseFromThoseSilos.Count < chooseFrom)
{
int index = random.Next(relevantSilos.Count);
var pickedSilo = relevantSilos[index];
relevantSilos.RemoveAt(index);
chooseFromThoseSilos.Add(pickedSilo);
}
CachedLocalStat minLoadedSilo = chooseFromThoseSilos.First();
foreach (CachedLocalStat s in chooseFromThoseSilos)
{
if (SiloLoad_ByRecentActivations(s) < SiloLoad_ByRecentActivations(minLoadedSilo))
minLoadedSilo = s;
}
return MakePlacement(strategy, grain, context, minLoadedSilo);
}
var debugLog = string.Format("Unable to select a candidate from {0} silos: {1}", localCache.Count,
Utils.EnumerableToString(
localCache,
kvp => String.Format("SiloAddress = {0} -> {1}", kvp.Key.ToString(), kvp.Value.ToString())));
logger.Warn(ErrorCode.Placement_ActivationCountBasedDirector_NoSilos, debugLog);
throw new OrleansException(debugLog);
}
OnAddActivation(PlacementStrategy strategy, GrainId grain, IPlacementContext context)
{
var grainType = context.GetGrainTypeName(grain);
return Task.FromResult(
PlacementResult.SpecifyCreation(context.LocalSilo, strategy, grainType));
}
public ActivationData(ActivationAddress addr, string genericArguments, PlacementStrategy placedUsing, MultiClusterRegistrationStrategy registrationStrategy, IActivationCollector collector, TimeSpan ageLimit)
{
if (null == addr) throw new ArgumentNullException("addr");
if (null == placedUsing) throw new ArgumentNullException("placedUsing");
if (null == collector) throw new ArgumentNullException("collector");
logger = LogManager.GetLogger("ActivationData", LoggerType.Runtime);
ResetKeepAliveRequest();
Address = addr;
State = ActivationState.Create;
PlacedUsing = placedUsing;
RegistrationStrategy = registrationStrategy;
if (!Grain.IsSystemTarget && !Constants.IsSystemGrain(Grain))
{
this.collector = collector;
}
CollectionAgeLimit = ageLimit;
GrainReference = GrainReference.FromGrainId(addr.Grain, genericArguments,
Grain.IsSystemTarget ? addr.Silo : null);
}
internal abstract Task<PlacementResult> OnSelectActivation(
PlacementStrategy strategy, GrainId target, IPlacementContext context);
internal abstract Task<PlacementResult> OnAddActivation(
PlacementStrategy strategy, GrainId grain, IPlacementContext context);
public void GetGrainTypeInfo(int typeCode, out string grainClass, out PlacementStrategy placement, string genericArguments = null)
{
GrainTypeManager.GetTypeInfo(typeCode, out grainClass, out placement, genericArguments);
}
public PlacementStrategySaveResult savePlacementStrategy(PlacementStrategy placementStrategy) {
object[] results = this.Invoke("savePlacementStrategy", new object[] {placementStrategy});
return ((PlacementStrategySaveResult) (results[0]));
}
public void GetGrainTypeInfo(int typeCode, out string grainClass, out PlacementStrategy placement, out MultiClusterRegistrationStrategy activationStrategy, string genericArguments = null)
{
GrainTypeManager.GetTypeInfo(typeCode, out grainClass, out placement, out activationStrategy, genericArguments);
}
internal bool TryGetTypeInfo(int typeCode, out string grainClass, out PlacementStrategy placement, string genericArguments = null)
{
lock (this)
{
grainClass = null;
placement = null;
if (!implementationIndex.ContainsKey(typeCode))
return false;
var implementation = implementationIndex[typeCode];
grainClass = implementation.GetClassName(genericArguments);
placement = implementation.PlacementStrategy;
return true;
}
}
internal GrainClassData(int grainTypeCode, string grainClass, bool isGeneric, GrainInterfaceData interfaceData, PlacementStrategy placement)
{
GrainTypeCode = grainTypeCode;
GrainClass = grainClass;
this.isGeneric = isGeneric;
this.interfaceData = interfaceData;
genericClassNames = new Dictionary<string, string>(); // TODO: initialize only for generic classes
placementStrategy = placement ?? PlacementStrategy.GetDefault();
}
OnAddActivation(PlacementStrategy strategy, GrainId grain, IPlacementContext context)
{
throw new InvalidOperationException("Client Observers are not activated using the placement subsystem. Grain " + grain);
}
public static void GetGrainTypeInfo(this IPlacementContext @this, GrainId grainId, out string grainClass, out PlacementStrategy placement, out MultiClusterRegistrationStrategy activationStrategy, string genericArguments = null)
{
@this.GetGrainTypeInfo(grainId.GetTypeCode(), out grainClass, out placement, out activationStrategy, genericArguments);
}
internal void GetTypeInfo(int typeCode, out string grainClass, out PlacementStrategy placement, string genericArguments = null)
{
if (!grainInterfaceMap.TryGetTypeInfo(typeCode, out grainClass, out placement, genericArguments))
throw new OrleansException(String.Format("Unexpected: Cannot find an implementation class for grain interface {0}", typeCode));
}
internal override async Task<PlacementResult> OnSelectActivation(
PlacementStrategy strategy, GrainId target, IPlacementContext context)
{
List<ActivationAddress> places = (await context.Lookup(target)).Addresses;
return ChooseRandomActivation(places, context);
}
