public MaxRunningAppsEnforcer(FairScheduler scheduler)
{
// Tracks the number of running applications by user.
this.scheduler = scheduler;
this.usersNumRunnableApps = new Dictionary <string, int>();
this.usersNonRunnableApps = ArrayListMultimap.Create();
}
public FairSchedulerInfo(FairScheduler fs)
{
// JAXB needs this
scheduler = fs;
rootQueue = new FairSchedulerQueueInfo(scheduler.GetQueueManager().GetRootQueue()
, scheduler);
}
public virtual void TestHeadroom()
{
FairScheduler mockScheduler = Org.Mockito.Mockito.Mock <FairScheduler>();
Org.Mockito.Mockito.When(mockScheduler.GetClock()).ThenReturn(scheduler.GetClock(
));
FSLeafQueue mockQueue = Org.Mockito.Mockito.Mock <FSLeafQueue>();
Resource queueMaxResources = Resource.NewInstance(5 * 1024, 3);
Org.Apache.Hadoop.Yarn.Api.Records.Resource queueFairShare = Resources.CreateResource
(4096, 2);
Org.Apache.Hadoop.Yarn.Api.Records.Resource queueUsage = Org.Apache.Hadoop.Yarn.Api.Records.Resource
.NewInstance(2048, 2);
Org.Apache.Hadoop.Yarn.Api.Records.Resource queueStarvation = Resources.Subtract(
queueFairShare, queueUsage);
Org.Apache.Hadoop.Yarn.Api.Records.Resource queueMaxResourcesAvailable = Resources
.Subtract(queueMaxResources, queueUsage);
Org.Apache.Hadoop.Yarn.Api.Records.Resource clusterResource = Resources.CreateResource
(8192, 8);
Org.Apache.Hadoop.Yarn.Api.Records.Resource clusterUsage = Resources.CreateResource
(2048, 2);
Org.Apache.Hadoop.Yarn.Api.Records.Resource clusterAvailable = Resources.Subtract
(clusterResource, clusterUsage);
QueueMetrics fakeRootQueueMetrics = Org.Mockito.Mockito.Mock <QueueMetrics>();
Org.Mockito.Mockito.When(mockQueue.GetMaxShare()).ThenReturn(queueMaxResources);
Org.Mockito.Mockito.When(mockQueue.GetFairShare()).ThenReturn(queueFairShare);
Org.Mockito.Mockito.When(mockQueue.GetResourceUsage()).ThenReturn(queueUsage);
Org.Mockito.Mockito.When(mockScheduler.GetClusterResource()).ThenReturn(clusterResource
);
Org.Mockito.Mockito.When(fakeRootQueueMetrics.GetAllocatedResources()).ThenReturn
(clusterUsage);
Org.Mockito.Mockito.When(mockScheduler.GetRootQueueMetrics()).ThenReturn(fakeRootQueueMetrics
);
ApplicationAttemptId applicationAttemptId = CreateAppAttemptId(1, 1);
RMContext rmContext = resourceManager.GetRMContext();
FSAppAttempt schedulerApp = new FSAppAttempt(mockScheduler, applicationAttemptId,
"user1", mockQueue, null, rmContext);
// Min of Memory and CPU across cluster and queue is used in
// DominantResourceFairnessPolicy
Org.Mockito.Mockito.When(mockQueue.GetPolicy()).ThenReturn(SchedulingPolicy.GetInstance
(typeof(DominantResourceFairnessPolicy)));
VerifyHeadroom(schedulerApp, Min(queueStarvation.GetMemory(), clusterAvailable.GetMemory
(), queueMaxResourcesAvailable.GetMemory()), Min(queueStarvation.GetVirtualCores
(), clusterAvailable.GetVirtualCores(), queueMaxResourcesAvailable.GetVirtualCores
()));
// Fair and Fifo ignore CPU of queue, so use cluster available CPU
Org.Mockito.Mockito.When(mockQueue.GetPolicy()).ThenReturn(SchedulingPolicy.GetInstance
(typeof(FairSharePolicy)));
VerifyHeadroom(schedulerApp, Min(queueStarvation.GetMemory(), clusterAvailable.GetMemory
(), queueMaxResourcesAvailable.GetMemory()), Math.Min(clusterAvailable.GetVirtualCores
(), queueMaxResourcesAvailable.GetVirtualCores()));
Org.Mockito.Mockito.When(mockQueue.GetPolicy()).ThenReturn(SchedulingPolicy.GetInstance
(typeof(FifoPolicy)));
VerifyHeadroom(schedulerApp, Min(queueStarvation.GetMemory(), clusterAvailable.GetMemory
(), queueMaxResourcesAvailable.GetMemory()), Math.Min(clusterAvailable.GetVirtualCores
(), queueMaxResourcesAvailable.GetVirtualCores()));
}
/// <summary>
/// Assign a container to this node to facilitate
/// <paramref name="request"/>
/// . If node does
/// not have enough memory, create a reservation. This is called once we are
/// sure the particular request should be facilitated by this node.
/// </summary>
/// <param name="node">The node to try placing the container on.</param>
/// <param name="request">The ResourceRequest we're trying to satisfy.</param>
/// <param name="type">The locality of the assignment.</param>
/// <param name="reserved">Whether there's already a container reserved for this app on the node.
/// </param>
/// <returns>
/// If an assignment was made, returns the resources allocated to the
/// container. If a reservation was made, returns
/// FairScheduler.CONTAINER_RESERVED. If no assignment or reservation was
/// made, returns an empty resource.
/// </returns>
private Org.Apache.Hadoop.Yarn.Api.Records.Resource AssignContainer(FSSchedulerNode
node, ResourceRequest request, NodeType type, bool reserved)
{
// How much does this request need?
Org.Apache.Hadoop.Yarn.Api.Records.Resource capability = request.GetCapability();
// How much does the node have?
Org.Apache.Hadoop.Yarn.Api.Records.Resource available = node.GetAvailableResource
();
Container container = null;
if (reserved)
{
container = node.GetReservedContainer().GetContainer();
}
else
{
container = CreateContainer(node, capability, request.GetPriority());
}
// Can we allocate a container on this node?
if (Resources.FitsIn(capability, available))
{
// Inform the application of the new container for this request
RMContainer allocatedContainer = Allocate(type, node, request.GetPriority(), request
, container);
if (allocatedContainer == null)
{
// Did the application need this resource?
if (reserved)
{
Unreserve(request.GetPriority(), node);
}
return(Resources.None());
}
// If we had previously made a reservation, delete it
if (reserved)
{
Unreserve(request.GetPriority(), node);
}
// Inform the node
node.AllocateContainer(allocatedContainer);
// If this container is used to run AM, update the leaf queue's AM usage
if (GetLiveContainers().Count == 1 && !GetUnmanagedAM())
{
((FSLeafQueue)GetQueue()).AddAMResourceUsage(container.GetResource());
SetAmRunning(true);
}
return(container.GetResource());
}
else
{
if (!FairScheduler.FitsInMaxShare(((FSLeafQueue)GetQueue()), capability))
{
return(Resources.None());
}
// The desired container won't fit here, so reserve
Reserve(request.GetPriority(), node, container, reserved);
return(FairScheduler.ContainerReserved);
}
}
public override void Init(Clock clock, ResourceScheduler sched, ICollection <Plan>
plans)
{
base.Init(clock, sched, plans);
fs = (FairScheduler)sched;
Log.Info("Initializing Plan Follower Policy:" + this.GetType().GetCanonicalName()
);
}
public FSQueue(string name, FairScheduler scheduler, FSParentQueue parent)
{
this.name = name;
this.scheduler = scheduler;
this.metrics = ((FSQueueMetrics)FSQueueMetrics.ForQueue(GetName(), parent, true,
scheduler.GetConf()));
metrics.SetMinShare(GetMinShare());
metrics.SetMaxShare(GetMaxShare());
this.parent = parent;
}
public FSAppAttempt(FairScheduler scheduler, ApplicationAttemptId applicationAttemptId
, string user, FSLeafQueue queue, ActiveUsersManager activeUsersManager, RMContext
rmContext)
: base(applicationAttemptId, user, queue, activeUsersManager, rmContext)
{
this.scheduler = scheduler;
this.startTime = scheduler.GetClock().GetTime();
this.priority = Priority.NewInstance(1);
this.resourceWeights = new ResourceWeights();
}
/// <exception cref="System.IO.IOException"/>
private static FairScheduler MockFairScheduler()
{
FairScheduler fs = new FairScheduler();
FairSchedulerConfiguration conf = new FairSchedulerConfiguration();
fs.SetRMContext(new RMContextImpl(null, null, null, null, null, null, new RMContainerTokenSecretManager
(conf), new NMTokenSecretManagerInRM(conf), new ClientToAMTokenSecretManagerInRM
(), null));
fs.Init(conf);
return(fs);
}
public FSLeafQueue(string name, FairScheduler scheduler, FSParentQueue parent)
: base(name, scheduler, parent)
{
// apps that are runnable
// get a lock with fair distribution for app list updates
// Variables used for preemption
// Track the AM resource usage for this queue
this.lastTimeAtMinShare = scheduler.GetClock().GetTime();
this.lastTimeAtFairShareThreshold = scheduler.GetClock().GetTime();
activeUsersManager = new ActiveUsersManager(GetMetrics());
amResourceUsage = Org.Apache.Hadoop.Yarn.Api.Records.Resource.NewInstance(0, 0);
}
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/>
public override void Reinitialize(Configuration conf, RMContext rmContext)
{
// Validate if the scheduler is fair scheduler
ResourceScheduler scheduler = rmContext.GetScheduler();
if (!(scheduler is FairScheduler))
{
throw new YarnRuntimeException("Class " + scheduler.GetType().GetCanonicalName()
+ " not instance of " + typeof(FairScheduler).GetCanonicalName());
}
fairScheduler = (FairScheduler)scheduler;
this.conf = conf;
base.Reinitialize(conf, rmContext);
}
public virtual void TearDown()
{
logFile.Delete();
logFile.GetParentFile().Delete();
// fairscheduler/
if (scheduler != null)
{
scheduler.Stop();
scheduler = null;
}
if (resourceManager != null)
{
resourceManager.Stop();
resourceManager = null;
}
}
public FairSchedulerQueueInfo(FSQueue queue, FairScheduler scheduler)
{
AllocationConfiguration allocConf = scheduler.GetAllocationConfiguration();
queueName = queue.GetName();
schedulingPolicy = queue.GetPolicy().GetName();
clusterResources = new ResourceInfo(scheduler.GetClusterResource());
usedResources = new ResourceInfo(queue.GetResourceUsage());
fractionMemUsed = (float)usedResources.GetMemory() / clusterResources.GetMemory();
steadyFairResources = new ResourceInfo(queue.GetSteadyFairShare());
fairResources = new ResourceInfo(queue.GetFairShare());
minResources = new ResourceInfo(queue.GetMinShare());
maxResources = new ResourceInfo(queue.GetMaxShare());
maxResources = new ResourceInfo(Resources.ComponentwiseMin(queue.GetMaxShare(), scheduler
.GetClusterResource()));
fractionMemSteadyFairShare = (float)steadyFairResources.GetMemory() / clusterResources
.GetMemory();
fractionMemFairShare = (float)fairResources.GetMemory() / clusterResources.GetMemory
();
fractionMemMinShare = (float)minResources.GetMemory() / clusterResources.GetMemory
();
fractionMemMaxShare = (float)maxResources.GetMemory() / clusterResources.GetMemory
();
maxApps = allocConf.GetQueueMaxApps(queueName);
childQueues = new AList <Org.Apache.Hadoop.Yarn.Server.Resourcemanager.Webapp.Dao.FairSchedulerQueueInfo
>();
if (allocConf.IsReservable(queueName) && !allocConf.GetShowReservationAsQueues(queueName
))
{
return;
}
ICollection <FSQueue> children = queue.GetChildQueues();
foreach (FSQueue child in children)
{
if (child is FSLeafQueue)
{
childQueues.AddItem(new FairSchedulerLeafQueueInfo((FSLeafQueue)child, scheduler)
);
}
else
{
childQueues.AddItem(new Org.Apache.Hadoop.Yarn.Server.Resourcemanager.Webapp.Dao.FairSchedulerQueueInfo
(child, scheduler));
}
}
}
public virtual void SetUp()
{
scheduler = new FairScheduler();
Configuration conf = new YarnConfiguration();
conf.SetClass(YarnConfiguration.RmScheduler, typeof(FairScheduler), typeof(ResourceScheduler
));
conf.Set("yarn.scheduler.fair.event-log-enabled", "true");
// All tests assume only one assignment per node update
conf.Set(FairSchedulerConfiguration.AssignMultiple, "false");
resourceManager = new ResourceManager();
resourceManager.Init(conf);
((AsyncDispatcher)resourceManager.GetRMContext().GetDispatcher()).Start();
scheduler.Init(conf);
scheduler.Start();
scheduler.Reinitialize(conf, resourceManager.GetRMContext());
}
public virtual void SetUp()
{
conf = new FairSchedulerConfiguration();
FairScheduler scheduler = Org.Mockito.Mockito.Mock <FairScheduler>();
AllocationConfiguration allocConf = new AllocationConfiguration(conf);
Org.Mockito.Mockito.When(scheduler.GetAllocationConfiguration()).ThenReturn(allocConf
);
Org.Mockito.Mockito.When(scheduler.GetConf()).ThenReturn(conf);
SystemClock clock = new SystemClock();
Org.Mockito.Mockito.When(scheduler.GetClock()).ThenReturn(clock);
notEmptyQueues = new HashSet <FSQueue>();
queueManager = new _QueueManager_47(this, scheduler);
FSQueueMetrics.ForQueue("root", null, true, conf);
queueManager.Initialize(conf);
}
/// <exception cref="System.IO.IOException"/>
public static FairScheduler SetupFairScheduler(ReservationSystemTestUtil testUtil
, RMContext rmContext, Configuration conf, int numContainers)
{
FairScheduler scheduler = new FairScheduler();
scheduler.SetRMContext(rmContext);
Org.Mockito.Mockito.When(rmContext.GetScheduler()).ThenReturn(scheduler);
scheduler.Init(conf);
scheduler.Start();
scheduler.Reinitialize(conf, rmContext);
Resource resource = ReservationSystemTestUtil.CalculateClusterResource(numContainers
);
RMNode node1 = MockNodes.NewNodeInfo(1, resource, 1, "127.0.0.1");
NodeAddedSchedulerEvent nodeEvent1 = new NodeAddedSchedulerEvent(node1);
scheduler.Handle(nodeEvent1);
return(scheduler);
}
public FairSchedulerAppsBlock(ResourceManager rm, View.ViewContext ctx, Configuration
conf)
: base(ctx)
{
FairScheduler scheduler = (FairScheduler)rm.GetResourceScheduler();
fsinfo = new FairSchedulerInfo(scheduler);
apps = new ConcurrentHashMap <ApplicationId, RMApp>();
foreach (KeyValuePair <ApplicationId, RMApp> entry in rm.GetRMContext().GetRMApps(
))
{
if (!(RMAppState.New.Equals(entry.Value.GetState()) || RMAppState.NewSaving.Equals
(entry.Value.GetState()) || RMAppState.Submitted.Equals(entry.Value.GetState())))
{
apps[entry.Key] = entry.Value;
}
}
this.conf = conf;
this.rm = rm;
}
public virtual void TestFairReservationSystemReinitialize()
{
ReservationSystemTestUtil.SetupFSAllocationFile(AllocFile);
ReservationSystemTestUtil testUtil = new ReservationSystemTestUtil();
// Setup
RMContext mockRMContext = ReservationSystemTestUtil.CreateRMContext(conf);
scheduler = ReservationSystemTestUtil.SetupFairScheduler(testUtil, mockRMContext,
conf, 10);
FairReservationSystem reservationSystem = new FairReservationSystem();
reservationSystem.SetRMContext(mockRMContext);
try
{
reservationSystem.Reinitialize(scheduler.GetConf(), mockRMContext);
}
catch (YarnException e)
{
NUnit.Framework.Assert.Fail(e.Message);
}
// Assert queue in original config
string planQNam = testUtil.GetFullReservationQueueName();
ReservationSystemTestUtil.ValidateReservationQueue(reservationSystem, planQNam);
// Dynamically add a plan
ReservationSystemTestUtil.UpdateFSAllocationFile(AllocFile);
scheduler.Reinitialize(conf, mockRMContext);
try
{
reservationSystem.Reinitialize(conf, mockRMContext);
}
catch (YarnException e)
{
NUnit.Framework.Assert.Fail(e.Message);
}
string newQueue = "root.reservation";
ReservationSystemTestUtil.ValidateNewReservationQueue(reservationSystem, newQueue
);
}
public virtual void Setup()
{
Configuration conf = new Configuration();
clock = new FairSchedulerTestBase.MockClock();
scheduler = Org.Mockito.Mockito.Mock <FairScheduler>();
Org.Mockito.Mockito.When(scheduler.GetConf()).ThenReturn(new FairSchedulerConfiguration
(conf));
Org.Mockito.Mockito.When(scheduler.GetClock()).ThenReturn(clock);
AllocationConfiguration allocConf = new AllocationConfiguration(conf);
Org.Mockito.Mockito.When(scheduler.GetAllocationConfiguration()).ThenReturn(allocConf
);
queueManager = new QueueManager(scheduler);
queueManager.Initialize(conf);
queueMaxApps = allocConf.queueMaxApps;
userMaxApps = allocConf.userMaxApps;
maxAppsEnforcer = new MaxRunningAppsEnforcer(scheduler);
appNum = 0;
rmContext = Org.Mockito.Mockito.Mock <RMContext>();
Org.Mockito.Mockito.When(rmContext.GetEpoch()).ThenReturn(0L);
}
public virtual void SetUp()
{
conf = CreateConfiguration();
ReservationSystemTestUtil.SetupFSAllocationFile(AllocFile);
ReservationSystemTestUtil testUtil = new ReservationSystemTestUtil();
// Setup
rmContext = TestUtils.GetMockRMContext();
spyRMContext = Org.Mockito.Mockito.Spy(rmContext);
fs = ReservationSystemTestUtil.SetupFairScheduler(testUtil, spyRMContext, conf, 125
);
scheduler = fs;
ConcurrentMap <ApplicationId, RMApp> spyApps = Org.Mockito.Mockito.Spy(new ConcurrentHashMap
<ApplicationId, RMApp>());
RMApp rmApp = Org.Mockito.Mockito.Mock <RMApp>();
Org.Mockito.Mockito.When(rmApp.GetRMAppAttempt((ApplicationAttemptId)Matchers.Any
())).ThenReturn(null);
Org.Mockito.Mockito.DoReturn(rmApp).When(spyApps)[(ApplicationId)Matchers.Any()];
Org.Mockito.Mockito.When(spyRMContext.GetRMApps()).ThenReturn(spyApps);
ReservationSystemTestUtil.SetupFSAllocationFile(AllocFile);
SetupPlanFollower();
}
public virtual void TestFairReservationSystemInitialize()
{
ReservationSystemTestUtil.SetupFSAllocationFile(AllocFile);
ReservationSystemTestUtil testUtil = new ReservationSystemTestUtil();
// Setup
RMContext mockRMContext = ReservationSystemTestUtil.CreateRMContext(conf);
scheduler = ReservationSystemTestUtil.SetupFairScheduler(testUtil, mockRMContext,
conf, 10);
FairReservationSystem reservationSystem = new FairReservationSystem();
reservationSystem.SetRMContext(mockRMContext);
try
{
reservationSystem.Reinitialize(scheduler.GetConf(), mockRMContext);
}
catch (YarnException e)
{
NUnit.Framework.Assert.Fail(e.Message);
}
ReservationSystemTestUtil.ValidateReservationQueue(reservationSystem, testUtil.GetFullReservationQueueName
());
}
public FSParentQueue(string name, FairScheduler scheduler, Org.Apache.Hadoop.Yarn.Server.Resourcemanager.Scheduler.Fair.FSParentQueue
parent)
: base(name, scheduler, parent)
{
}
public FairSchedulerLeafQueueInfo(FSLeafQueue queue, FairScheduler scheduler)
: base(queue, scheduler)
{
numPendingApps = queue.GetNumPendingApps();
numActiveApps = queue.GetNumActiveApps();
}
internal QueuesBlock(ResourceManager rm, FairSchedulerPage.FSQInfo info)
{
fs = (FairScheduler)rm.GetResourceScheduler();
fsqinfo = info;
}
public QueueManager(FairScheduler scheduler)
{
this.scheduler = scheduler;
}
public _QueueManager_47(TestQueueManager _enclosing, FairScheduler baseArg1)
: base(baseArg1)
{
this._enclosing = _enclosing;
}
