/// <summary>
/// Returns a string indicating that the entity cannot use an ability because it doesn't have enough
/// health.
/// </summary>
/// <param name="entity">The CombatEntity of focus.</param>
/// <param name="ability">The ability being used.</param>
public static string WriteInsufficientHealth(CombatEntity entity, Ability ability)
{
int totalHealthCost = ResourceCalculator.GetTotalHealthCost(entity, ability);
return($"{entity.Name} does not have enough Health to use {ability.Name}. {ability.Name} " +
$"requires {totalHealthCost} Health, {entity.Name} has {entity.Resources.CurrentHealth}.");
}
public virtual NodeId GetNodeIdToUnreserve(Priority priority, Org.Apache.Hadoop.Yarn.Api.Records.Resource
resourceNeedUnreserve, ResourceCalculator rc, Org.Apache.Hadoop.Yarn.Api.Records.Resource
clusterResource)
{
lock (this)
{
// first go around make this algorithm simple and just grab first
// reservation that has enough resources
IDictionary <NodeId, RMContainer> reservedContainers = this.reservedContainers[priority
];
if ((reservedContainers != null) && (!reservedContainers.IsEmpty()))
{
foreach (KeyValuePair <NodeId, RMContainer> entry in reservedContainers)
{
NodeId nodeId = entry.Key;
Org.Apache.Hadoop.Yarn.Api.Records.Resource containerResource = entry.Value.GetContainer
().GetResource();
// make sure we unreserve one with at least the same amount of
// resources, otherwise could affect capacity limits
if (Resources.LessThanOrEqual(rc, clusterResource, resourceNeedUnreserve, containerResource
))
{
if (Log.IsDebugEnabled())
{
Log.Debug("unreserving node with reservation size: " + containerResource + " in order to allocate container with size: "
+ resourceNeedUnreserve);
}
return(nodeId);
}
}
}
return(null);
}
}
/// <summary>
/// Returns a string indicating that the entity cannot use an ability because it doesn't have enough
/// action points.
/// </summary>
/// <param name="entity">The CombatEntity of focus.</param>
/// <param name="ability">The ability being used.</param>
public static string WriteInsufficientActionPoints(CombatEntity entity, Ability ability)
{
int totalActionPointCost = ResourceCalculator.GetTotalActionPointCost(entity, ability);
return($"{entity.Name} does not have enough Action Points to use {ability.Name}. {ability.Name} " +
$"requires {totalActionPointCost} Action Points, {entity.Name} has {entity.Resources.CurrentActionPoints}.");
}
public virtual void Setup()
{
// 24h window
timeWindow = 86400000L;
// 1 sec step
step = 1000L;
// 25% avg cap on capacity
avgConstraint = 25;
// 70% instantaneous cap on capacity
instConstraint = 70;
initTime = Runtime.CurrentTimeMillis();
minAlloc = Org.Apache.Hadoop.Yarn.Api.Records.Resource.NewInstance(1024, 1);
res = new DefaultResourceCalculator();
maxAlloc = Org.Apache.Hadoop.Yarn.Api.Records.Resource.NewInstance(1024 * 8, 8);
mAgent = Org.Mockito.Mockito.Mock <ReservationAgent>();
ReservationSystemTestUtil testUtil = new ReservationSystemTestUtil();
QueueMetrics rootQueueMetrics = Org.Mockito.Mockito.Mock <QueueMetrics>();
string reservationQ = testUtil.GetFullReservationQueueName();
Org.Apache.Hadoop.Yarn.Api.Records.Resource clusterResource = ReservationSystemTestUtil
.CalculateClusterResource(totCont);
ReservationSchedulerConfiguration conf = ReservationSystemTestUtil.CreateConf(reservationQ
, timeWindow, instConstraint, avgConstraint);
CapacityOverTimePolicy policy = new CapacityOverTimePolicy();
policy.Init(reservationQ, conf);
plan = new InMemoryPlan(rootQueueMetrics, policy, mAgent, clusterResource, step,
res, minAlloc, maxAlloc, "dedicated", null, true);
}
/// <summary>
/// Returns true if the provided CombatEntity has enough resources to use an Ability.
/// </summary>
/// <param name="attacker">The attacking CombatEntity.</param>
/// <param name="ability">The ability being used by the CombatEntity.</param>
/// <returns></returns>
private bool HasEnoughResources(CombatEntity attacker, Ability ability, out string failureReason)
{
failureReason = "";
int actionPointCost = ResourceCalculator.GetTotalActionPointCost(attacker, ability);
int manaCost = ResourceCalculator.GetTotalManaCost(attacker, ability);
int healthCost = ResourceCalculator.GetTotalHealthCost(attacker, ability);
if (attacker.Resources.CurrentActionPoints < actionPointCost)
{
failureReason = BattleErrorWriter.WriteInsufficientActionPoints(attacker, ability);
return(false);
}
if (attacker.Resources.CurrentMana < manaCost)
{
failureReason = BattleErrorWriter.WriteInsufficientMana(attacker, ability);
return(false);
}
if (attacker.Resources.CurrentHealth < healthCost)
{
failureReason = BattleErrorWriter.WriteInsufficientHealth(attacker, ability);
return(false);
}
return(true);
}
public virtual void TearDown()
{
user = null;
planName = null;
resCalc = null;
minAlloc = null;
}
/// <summary>
/// This method produces an Allocation that includes the current view
/// of the resources that will be allocated to and preempted from this
/// application.
/// </summary>
/// <param name="rc"/>
/// <param name="clusterResource"/>
/// <param name="minimumAllocation"/>
/// <returns>an allocation</returns>
public virtual Allocation GetAllocation(ResourceCalculator rc, Org.Apache.Hadoop.Yarn.Api.Records.Resource
clusterResource, Org.Apache.Hadoop.Yarn.Api.Records.Resource minimumAllocation)
{
lock (this)
{
ICollection <ContainerId> currentContPreemption = Sharpen.Collections.UnmodifiableSet
(new HashSet <ContainerId>(containersToPreempt));
containersToPreempt.Clear();
Org.Apache.Hadoop.Yarn.Api.Records.Resource tot = Org.Apache.Hadoop.Yarn.Api.Records.Resource
.NewInstance(0, 0);
foreach (ContainerId c in currentContPreemption)
{
Resources.AddTo(tot, liveContainers[c].GetContainer().GetResource());
}
int numCont = (int)Math.Ceil(Resources.Divide(rc, clusterResource, tot, minimumAllocation
));
ResourceRequest rr = ResourceRequest.NewInstance(Priority.Undefined, ResourceRequest
.Any, minimumAllocation, numCont);
SchedulerApplicationAttempt.ContainersAndNMTokensAllocation allocation = PullNewlyAllocatedContainersAndNMTokens
();
Org.Apache.Hadoop.Yarn.Api.Records.Resource headroom = GetHeadroom();
SetApplicationHeadroomForMetrics(headroom);
return(new Allocation(allocation.GetContainerList(), headroom, null, currentContPreemption
, Sharpen.Collections.SingletonList(rr), allocation.GetNMTokenList()));
}
}
public static void UpdateQueueStatistics(ResourceCalculator calculator, CSQueue childQueue
, CSQueue parentQueue, Org.Apache.Hadoop.Yarn.Api.Records.Resource clusterResource
, Org.Apache.Hadoop.Yarn.Api.Records.Resource minimumAllocation)
{
Org.Apache.Hadoop.Yarn.Api.Records.Resource queueLimit = Resources.None();
Org.Apache.Hadoop.Yarn.Api.Records.Resource usedResources = childQueue.GetUsedResources
();
float absoluteUsedCapacity = 0.0f;
float usedCapacity = 0.0f;
if (Resources.GreaterThan(calculator, clusterResource, clusterResource, Resources
.None()))
{
queueLimit = Resources.Multiply(clusterResource, childQueue.GetAbsoluteCapacity()
);
absoluteUsedCapacity = Resources.Divide(calculator, clusterResource, usedResources
, clusterResource);
usedCapacity = Resources.Equals(queueLimit, Resources.None()) ? 0 : Resources.Divide
(calculator, clusterResource, usedResources, queueLimit);
}
childQueue.SetUsedCapacity(usedCapacity);
childQueue.SetAbsoluteUsedCapacity(absoluteUsedCapacity);
Org.Apache.Hadoop.Yarn.Api.Records.Resource available = Resources.Subtract(queueLimit
, usedResources);
childQueue.GetMetrics().SetAvailableResourcesToQueue(Resources.Max(calculator, clusterResource
, available, Resources.None()));
}
/// <summary>
/// Utility method to normalize a resource request, by insuring that the
/// requested memory is a multiple of minMemory and is not zero.
/// </summary>
public static void NormalizeRequest(ResourceRequest ask, ResourceCalculator resourceCalculator
, Org.Apache.Hadoop.Yarn.Api.Records.Resource clusterResource, Org.Apache.Hadoop.Yarn.Api.Records.Resource
minimumResource, Org.Apache.Hadoop.Yarn.Api.Records.Resource maximumResource)
{
Org.Apache.Hadoop.Yarn.Api.Records.Resource normalized = Resources.Normalize(resourceCalculator
, ask.GetCapability(), minimumResource, maximumResource, minimumResource);
ask.SetCapability(normalized);
}
/// <summary>
/// Consumes the resources required to use the ability from the attacker.
/// </summary>
/// <param name="attacker">The CombatEntity using the ability.</param>
/// <param name="ability">The Ability to get consumed resource amounts from.</param>
private static void ConsumeResources(CombatEntity attacker, Ability ability)
{
int actionPointCost = ResourceCalculator.GetTotalActionPointCost(attacker, ability);
int manaCost = ResourceCalculator.GetTotalManaCost(attacker, ability);
int healthCost = ResourceCalculator.GetTotalHealthCost(attacker, ability);
attacker.Resources.CurrentActionPoints -= actionPointCost;
attacker.Resources.CurrentMana -= manaCost;
attacker.Resources.CurrentHealth -= healthCost;
}
protected internal override Org.Apache.Hadoop.Yarn.Api.Records.Resource GetPlanQueueCapacity
(string planQueueName)
{
Org.Apache.Hadoop.Yarn.Api.Records.Resource minAllocation = GetMinAllocation();
ResourceCalculator rescCalc = GetResourceCalculator();
CSQueue planQueue = capScheduler.GetQueue(planQueueName);
return(rescCalc.MultiplyAndNormalizeDown(capScheduler.GetClusterResource(), planQueue
.GetAbsoluteCapacity(), minAllocation));
}
/// <summary>
/// Utility method to normalize a list of resource requests, by insuring that
/// the memory for each request is a multiple of minMemory and is not zero.
/// </summary>
public static void NormalizeRequests(IList <ResourceRequest> asks, ResourceCalculator
resourceCalculator, Org.Apache.Hadoop.Yarn.Api.Records.Resource clusterResource
, Org.Apache.Hadoop.Yarn.Api.Records.Resource minimumResource, Org.Apache.Hadoop.Yarn.Api.Records.Resource
maximumResource, Org.Apache.Hadoop.Yarn.Api.Records.Resource incrementResource)
{
foreach (ResourceRequest ask in asks)
{
NormalizeRequest(ask, resourceCalculator, clusterResource, minimumResource, maximumResource
, incrementResource);
}
}
public virtual void TearDown()
{
resCalc = null;
minAlloc = null;
maxAlloc = null;
totalCapacity = null;
clock = null;
queueMetrics = null;
policy = null;
replanner = null;
}
private bool Check(ReservationAllocation cs, long start, long end, int containers
, int mem, int cores)
{
bool res = true;
for (long i = start; i < end; i++)
{
res = res && Resources.Equals(cs.GetResourcesAtTime(i), Org.Apache.Hadoop.Yarn.Api.Records.Resource
.NewInstance(mem * containers, cores * containers));
}
return(res);
}
public void ResourcesToCurrencyTest(float type1, float type2, float type3, float result)
{
calculator = new ResourceCalculator();
calculator.AddResource(type1, ResourceType.Food);
calculator.AddResource(type2, ResourceType.Stone);
calculator.AddResource(type3, ResourceType.Wood);
float actual = calculator.CalculateResourceWorth();
// this test contains an error
Assert.AreEqual(result, actual);
}
public virtual void SetUp()
{
resCalc = new DefaultResourceCalculator();
minAlloc = Org.Apache.Hadoop.Yarn.Api.Records.Resource.NewInstance(1024, 1);
maxAlloc = Org.Apache.Hadoop.Yarn.Api.Records.Resource.NewInstance(64 * 1024, 20);
totalCapacity = Org.Apache.Hadoop.Yarn.Api.Records.Resource.NewInstance(100 * 1024
, 100);
clock = Org.Mockito.Mockito.Mock <Clock>();
queueMetrics = Org.Mockito.Mockito.Mock <QueueMetrics>();
policy = Org.Mockito.Mockito.Mock <SharingPolicy>();
replanner = Org.Mockito.Mockito.Mock <Planner>();
Org.Mockito.Mockito.When(clock.GetTime()).ThenReturn(1L);
}
/// <summary>
/// TODO move to (new) BalanceManager-class
/// Calculates balance based on income and upkeep.
/// </summary>
/// <param name="sender"></param>
/// <param name="eventArgs"></param>
private void OnDayPassed(object sender, EventArgsWithPayload <IngameTime> eventArgs)
{
double balance = 0;
using (ResourceCalculator resourceCalculator = new ResourceCalculator())
{
foreach (ResourceFactoryController resourceFactory in FactionModel.ResourceFactories)
{
resourceCalculator.AddResource(resourceFactory.ResourceValue, resourceFactory.ResourceType);
}
balance += resourceCalculator.CalculateResourceWorth();
}
balance -= FactionModel.Buildings.Sum(structure => structure.Def.UpkeepCost);
balance -= FactionModel.Units.Sum(unit => unit.UnitModel.Def.Upkeep);
CurrencyController.AlterCurrency((float)balance);
}
internal InMemoryPlan(QueueMetrics queueMetrics, SharingPolicy policy, ReservationAgent
agent, Org.Apache.Hadoop.Yarn.Api.Records.Resource totalCapacity, long step, ResourceCalculator
resCalc, Org.Apache.Hadoop.Yarn.Api.Records.Resource minAlloc, Org.Apache.Hadoop.Yarn.Api.Records.Resource
maxAlloc, string queueName, Planner replanner, bool getMoveOnExpiry, Clock clock
)
{
this.queueMetrics = queueMetrics;
this.policy = policy;
this.agent = agent;
this.step = step;
this.totalCapacity = totalCapacity;
this.resCalc = resCalc;
this.minAlloc = minAlloc;
this.maxAlloc = maxAlloc;
this.rleSparseVector = new RLESparseResourceAllocation(resCalc, minAlloc);
this.queueName = queueName;
this.replanner = replanner;
this.getMoveOnExpiry = getMoveOnExpiry;
this.clock = clock;
}
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/>
protected internal virtual Plan InitializePlan(string planQueueName)
{
string planQueuePath = GetPlanQueuePath(planQueueName);
SharingPolicy adPolicy = GetAdmissionPolicy(planQueuePath);
adPolicy.Init(planQueuePath, GetReservationSchedulerConfiguration());
// Calculate the max plan capacity
Resource minAllocation = GetMinAllocation();
Resource maxAllocation = GetMaxAllocation();
ResourceCalculator rescCalc = GetResourceCalculator();
Org.Apache.Hadoop.Yarn.Api.Records.Resource totCap = GetPlanQueueCapacity(planQueueName
);
Plan plan = new InMemoryPlan(GetRootQueueMetrics(), adPolicy, GetAgent(planQueuePath
), totCap, planStepSize, rescCalc, minAllocation, maxAllocation, planQueueName,
GetReplanner(planQueuePath), GetReservationSchedulerConfiguration().GetMoveOnExpiry
(planQueuePath));
Log.Info("Intialized plan {0} based on reservable queue {1}", plan.ToString(), planQueueName
);
return(plan);
}
/// <exception cref="Org.Apache.Hadoop.Yarn.Server.Resourcemanager.Reservation.Exceptions.PlanningException
/// "/>
public virtual void Plan(Org.Apache.Hadoop.Yarn.Server.Resourcemanager.Reservation.Plan
plan, IList <ReservationDefinition> contracts)
{
if (contracts != null)
{
throw new RuntimeException("SimpleCapacityReplanner cannot handle new reservation contracts"
);
}
ResourceCalculator resCalc = plan.GetResourceCalculator();
Org.Apache.Hadoop.Yarn.Api.Records.Resource totCap = plan.GetTotalCapacity();
long now = clock.GetTime();
// loop on all moment in time from now to the end of the check Zone
// or the end of the planned sessions whichever comes first
for (long t = now; (t < plan.GetLastEndTime() && t < (now + lengthOfCheckZone));
t += plan.GetStep())
{
Org.Apache.Hadoop.Yarn.Api.Records.Resource excessCap = Resources.Subtract(plan.GetTotalCommittedResources
(t), totCap);
// if we are violating
if (Resources.GreaterThan(resCalc, totCap, excessCap, ZeroResource))
{
// sorted on reverse order of acceptance, so newest reservations first
ICollection <ReservationAllocation> curReservations = new TreeSet <ReservationAllocation
>(plan.GetReservationsAtTime(t));
for (IEnumerator <ReservationAllocation> resIter = curReservations.GetEnumerator()
; resIter.HasNext() && Resources.GreaterThan(resCalc, totCap, excessCap, ZeroResource
);)
{
ReservationAllocation reservation = resIter.Next();
plan.DeleteReservation(reservation.GetReservationId());
excessCap = Resources.Subtract(excessCap, reservation.GetResourcesAtTime(t));
Log.Info("Removing reservation " + reservation.GetReservationId() + " to repair physical-resource constraints in the plan: "
+ plan.GetQueueName());
}
}
}
}
/// <exception cref="System.IO.IOException"/>
public AbstractCSQueue(CapacitySchedulerContext cs, string queueName, CSQueue parent
, CSQueue old)
{
// Track resource usage-by-label like used-resource/pending-resource, etc.
// Track capacities like used-capcity/abs-used-capacity/capacity/abs-capacity,
// etc.
this.labelManager = cs.GetRMContext().GetNodeLabelManager();
this.parent = parent;
this.queueName = queueName;
this.resourceCalculator = cs.GetResourceCalculator();
// must be called after parent and queueName is set
this.metrics = old != null?old.GetMetrics() : QueueMetrics.ForQueue(GetQueuePath
(), parent, cs.GetConfiguration().GetEnableUserMetrics(), cs.GetConf());
this.csContext = cs;
this.minimumAllocation = csContext.GetMinimumResourceCapability();
// initialize ResourceUsage
queueUsage = new ResourceUsage();
queueEntity = new PrivilegedEntity(PrivilegedEntity.EntityType.Queue, GetQueuePath
());
// initialize QueueCapacities
queueCapacities = new QueueCapacities(parent == null);
}
public virtual void Setup()
{
// 1 sec step
step = 1000L;
initTime = Runtime.CurrentTimeMillis();
minAlloc = Org.Apache.Hadoop.Yarn.Api.Records.Resource.NewInstance(1024, 1);
res = new DefaultResourceCalculator();
maxAlloc = Org.Apache.Hadoop.Yarn.Api.Records.Resource.NewInstance(1024 * 8, 8);
mAgent = Org.Mockito.Mockito.Mock <ReservationAgent>();
ReservationSystemTestUtil testUtil = new ReservationSystemTestUtil();
string reservationQ = testUtil.GetFullReservationQueueName();
QueueMetrics rootQueueMetrics = Org.Mockito.Mockito.Mock <QueueMetrics>();
Org.Apache.Hadoop.Yarn.Api.Records.Resource clusterResource = ReservationSystemTestUtil
.CalculateClusterResource(totCont);
ReservationSchedulerConfiguration conf = Org.Mockito.Mockito.Mock <ReservationSchedulerConfiguration
>();
NoOverCommitPolicy policy = new NoOverCommitPolicy();
policy.Init(reservationQ, conf);
plan = new InMemoryPlan(rootQueueMetrics, policy, mAgent, clusterResource, step,
res, minAlloc, maxAlloc, "dedicated", null, true);
}
public virtual void SetUp()
{
resCalc = new DefaultResourceCalculator();
minAlloc = Org.Apache.Hadoop.Yarn.Api.Records.Resource.NewInstance(1, 1);
}
internal InMemoryPlan(QueueMetrics queueMetrics, SharingPolicy policy, ReservationAgent
agent, Org.Apache.Hadoop.Yarn.Api.Records.Resource totalCapacity, long step, ResourceCalculator
resCalc, Org.Apache.Hadoop.Yarn.Api.Records.Resource minAlloc, Org.Apache.Hadoop.Yarn.Api.Records.Resource
maxAlloc, string queueName, Planner replanner, bool getMoveOnExpiry)
: this(queueMetrics, policy, agent, totalCapacity, step, resCalc, minAlloc, maxAlloc
, queueName, replanner, getMoveOnExpiry, new UTCClock())
{
}
internal InMemoryReservationAllocation(ReservationId reservationID, ReservationDefinition
contract, string user, string planName, long startTime, long endTime, IDictionary
<ReservationInterval, ReservationRequest> allocationRequests, ResourceCalculator
calculator, Org.Apache.Hadoop.Yarn.Api.Records.Resource minAlloc)
{
this.contract = contract;
this.startTime = startTime;
this.endTime = endTime;
this.reservationID = reservationID;
this.user = user;
this.allocationRequests = allocationRequests;
this.planName = planName;
resourcesOverTime = new RLESparseResourceAllocation(calculator, minAlloc);
foreach (KeyValuePair <ReservationInterval, ReservationRequest> r in allocationRequests)
{
resourcesOverTime.AddInterval(r.Key, r.Value);
if (r.Value.GetConcurrency() > 1)
{
hasGang = true;
}
}
}
public RLESparseResourceAllocation(ResourceCalculator resourceCalculator, Org.Apache.Hadoop.Yarn.Api.Records.Resource
minAlloc)
{
this.resourceCalculator = resourceCalculator;
this.minAlloc = minAlloc;
}
