public static ActivationAddress GetAddress(SiloAddress silo, GrainId grain, ActivationId activation, MultiClusterStatus status = MultiClusterStatus.Owned)
        {
            // Silo part is not mandatory
            if (grain == null) throw new ArgumentNullException("grain");

            return new ActivationAddress(silo, grain, activation, status);
        }

        public static ActivationAddress GetAddress(SiloAddress silo, GrainId grain, ActivationId activation)
        {
            // Silo part is not mandatory
            if (grain == null) throw new ArgumentNullException("grain");

            return new ActivationAddress(silo, grain, activation);
        }

 private ActivationAddress(SiloAddress silo, GrainId grain, ActivationId activation, MultiClusterStatus status)
 {
     Silo = silo;
     Grain = grain;
     Activation = activation;
     Status = status;
 }

 public ActivationAddress AddSingleActivation(GrainId grain, ActivationId act, SiloAddress silo)
 {
     SingleInstance = true;
     if (Instances.Count > 0)
     {
         var item = Instances.First();
         return ActivationAddress.GetAddress(item.Value.SiloAddress, grain, item.Key);
     }
     else
     {
         Instances.Add(act, new ActivationInfo(silo));
         VersionTag = rand.Next();
         return ActivationAddress.GetAddress(silo, grain, act);
     }
 }

 public ActivationAddress AddSingleActivation(GrainId grain, ActivationId act, SiloAddress silo, MultiClusterStatus registrationStatus = MultiClusterStatus.Owned)
 {
     SingleInstance = true;
     if (Instances.Count > 0)
     {
         var item = Instances.First();
         return ActivationAddress.GetAddress(item.Value.SiloAddress, grain, item.Key);
     }
     else
     {
         Instances.Add(act, new ActivationInfo(silo, registrationStatus));
         VersionTag = rand.Next();
         return ActivationAddress.GetAddress(silo, grain, act, registrationStatus);
     }
 }

 public bool AddActivation(ActivationId act, SiloAddress silo)
 {
     if (SingleInstance && (Instances.Count > 0) && !Instances.ContainsKey(act))
     {
         throw new InvalidOperationException(
             "Attempting to add a second activation to an existing grain in single activation mode");
     }
     IActivationInfo info;
     if (Instances.TryGetValue(act, out info))
     {
         if (info.SiloAddress.Equals(silo))
         {
             // just refresh, no need to generate new VersionTag
             return false;
         }
     }
     Instances[act] = new ActivationInfo(silo);
     VersionTag = rand.Next();
     return true;
 }

        public void CacheOrUpdateRemoteClusterRegistration(GrainId grain, ActivationId oldActivation, ActivationAddress otherClusterAddress)
        {
            lock (lockable)
            {
                if (partitionData.ContainsKey(grain))
                {
                    partitionData[grain].CacheOrUpdateRemoteClusterRegistration(grain, oldActivation,
                        otherClusterAddress.Activation, otherClusterAddress.Silo);

                }
                else
                {
                    AddSingleActivation(grain, otherClusterAddress.Activation, otherClusterAddress.Silo,
                        GrainDirectoryEntryStatus.Cached);
                }
            }
        }

        public void DeactivateOnIdle(ActivationId id)
        {
            ActivationData data;
            if (!Catalog.TryGetActivationData(id, out data)) return; // already gone

            data.ResetKeepAliveRequest(); // DeactivateOnIdle method would undo / override any current “keep alive” setting, making this grain immideately avaliable for deactivation.
            Catalog.DeactivateActivationOnIdle(data);
        }

 /// <summary>
 /// Removes an activation of the given grain from the partition
 /// </summary>
 /// <param name="grain"></param>
 /// <param name="activation"></param>
 /// <param name="force"></param>
 internal void RemoveActivation(GrainId grain, ActivationId activation, bool force)
 {
     lock (lockable)
     {
         if (partitionData.ContainsKey(grain) && partitionData[grain].RemoveActivation(activation, force))
         {
             partitionData.Remove(grain);
         }
     }
     if (log.IsVerbose3) log.Verbose3("Removing activation for grain {0}", grain.ToString());
 }

 internal bool IsReentrantGrain(ActivationId running)
 {
     ActivationData target;
     GrainTypeData data;
     return TryGetActivationData(running, out target) &&
         target.GrainInstance != null &&
         GrainTypeManager.TryGetData(TypeUtils.GetFullName(target.GrainInstanceType), out data) &&
         data.IsReentrant;
 }

 internal bool CanInterleave(ActivationId running, Message message)
 {
     ActivationData target;
     GrainTypeData data;
     return TryGetActivationData(running, out target) &&
         target.GrainInstance != null &&
         GrainTypeManager.TryGetData(TypeUtils.GetFullName(target.GrainInstanceType), out data) &&
         (data.IsReentrant || data.MayInterleave((InvokeMethodRequest)message.BodyObject));
 }

        /// <summary>
        /// Returns a list of activations (along with the version number of the list) for the given grain.
        /// If the grain is not found, null is returned.
        /// </summary>
        /// <param name="grain"></param>
        /// <returns></returns>
        internal AddressesAndTag LookUpActivations(GrainId grain)
        {
            var result = new AddressesAndTag();
            ActivationId[] activationIds;
            IActivationInfo[] activationInfos;
            const int arrayReusingThreshold = 100;
            int grainInfoInstancesCount;

            lock (lockable)
            {
                IGrainInfo graininfo;
                if (!partitionData.TryGetValue(grain, out graininfo))
                {
                    return result;
                }

                result.VersionTag = graininfo.VersionTag;

                grainInfoInstancesCount = graininfo.Instances.Count;
                if (grainInfoInstancesCount < arrayReusingThreshold)
                {
                    if ((activationIds = activationIdsHolder) == null)
                    {
                        activationIdsHolder = activationIds = new ActivationId[arrayReusingThreshold];
                    }

                    if ((activationInfos = activationInfosHolder) == null)
                    {
                        activationInfosHolder = activationInfos = new IActivationInfo[arrayReusingThreshold];
                    }
                }
                else
                {
                    activationIds = new ActivationId[grainInfoInstancesCount];
                    activationInfos = new IActivationInfo[grainInfoInstancesCount];
                }


                graininfo.Instances.Keys.CopyTo(activationIds, 0);
                graininfo.Instances.Values.CopyTo(activationInfos, 0);
            }

            result.Addresses = new List<ActivationAddress>(grainInfoInstancesCount);
            for (var i = 0; i < grainInfoInstancesCount; i++)
            {
                var activationInfo = activationInfos[i];
                if (IsValidSilo(activationInfo.SiloAddress))
                {
                    result.Addresses.Add(ActivationAddress.GetAddress(activationInfo.SiloAddress, grain, activationIds[i]));
                }

                activationInfos[i] = null;
                activationIds[i] = null;
            }

            return result;
        }

        /// <summary>
        /// Adds a new activation to the directory partition
        /// </summary>
        /// <param name="grain"></param>
        /// <param name="activation"></param>
        /// <param name="silo"></param>
        /// <returns>The version associated with this directory mapping</returns>
        internal virtual int AddActivation(GrainId grain, ActivationId activation, SiloAddress silo)
        {
            if (!IsValidSilo(silo))
            {
                return GrainInfo.NO_ETAG;
            }

            IGrainInfo grainInfo;
            lock (lockable)
            {
                if (!partitionData.TryGetValue(grain, out grainInfo))
                {
                    partitionData[grain] = grainInfo = new GrainInfo();
                }

                grainInfo.AddActivation(activation, silo);
            }

            if (log.IsVerbose3) log.Verbose3("Adding activation for grain {0}", grain.ToString());
            return grainInfo.VersionTag;
        }

 public bool UpdateClusterRegistrationStatus(GrainId grain, ActivationId activationId, MultiClusterStatus registrationStatus, MultiClusterStatus? compareWith = null)
 {
     lock (lockable)
     {
         if (partitionData.ContainsKey(grain))
         {
             return partitionData[grain].UpdateClusterRegistrationStatus(activationId, registrationStatus, compareWith);
         }
         return false;
     }
 }

 public bool UpdateClusterRegistrationStatus(GrainId grain, ActivationId activationId, GrainDirectoryEntryStatus registrationStatus, GrainDirectoryEntryStatus? compareWith = null)
 {
     lock (lockable)
     {
         IGrainInfo graininfo;
         if (partitionData.TryGetValue(grain, out graininfo))
         {
             return graininfo.UpdateClusterRegistrationStatus(activationId, registrationStatus, compareWith);
         }
         return false;
     }
 }

 /// <summary> Write a <c>ActivationId</c> value to the stream. </summary>
 internal void Write(ActivationId id)
 {
     Write(id.Key);
 }

 public bool RemoveActivation(ActivationId act, UnregistrationCause cause, out IActivationInfo info, out bool wasRemoved)
 {
     info = null;
     wasRemoved = false;
     if (Instances.TryGetValue(act, out info) && info.OkToRemove(cause))
     {
         Instances.Remove(act);
         wasRemoved = true;
         VersionTag = rand.Next();
     }
     return Instances.Count == 0;
 }

        /// <summary>
        /// Try to get runtime data for an activation
        /// </summary>
        /// <param name="activationId"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public bool TryGetActivationData(ActivationId activationId, out ActivationData data)
        {
            data = null;
            if (activationId.IsSystem) return false;

            data = activations.FindTarget(activationId);
            return data != null;
        }

        /// <summary>
        /// Adds a new activation to the directory partition
        /// </summary>
        /// <param name="grain"></param>
        /// <param name="activation"></param>
        /// <param name="silo"></param>
        /// <param name="registrationStatus"></param>
        /// <returns>The registered ActivationAddress and version associated with this directory mapping</returns>
        internal virtual AddressAndTag AddSingleActivation(GrainId grain, ActivationId activation, SiloAddress silo, GrainDirectoryEntryStatus registrationStatus)
        {
            if (log.IsVerbose3) log.Verbose3("Adding single activation for grain {0}{1}{2}", silo, grain, activation);

            AddressAndTag result = new AddressAndTag();

            if (!IsValidSilo(silo))
                return result;
            
            lock (lockable)
            {
                if (!partitionData.ContainsKey(grain))
                {
                    partitionData[grain] = new GrainInfo();
                }
                var grainInfo = partitionData[grain];
                result.Address = grainInfo.AddSingleActivation(grain, activation, silo, registrationStatus);
                result.VersionTag = grainInfo.VersionTag;
            }
            return result;
        }

 public void DeactivateOnIdle(ActivationId id)
 {
     throw new InvalidOperationException();
 }