public List <ExecutionStatistics> Start <TStringCollection>(string executionName, int numberOfExecutionIterations)
where TStringCollection : IStringCollection, new()
{
_stringCollection = new TStringCollection();
_executionName = executionName;
List <ExecutionStatistics> executionStatistics = new List <ExecutionStatistics>();
for (int executionIteration = 0; executionIteration < numberOfExecutionIterations; executionIteration++)
{
_stopWatch.Start();
ParallelLoopResult loopResult = Parallel.ForEach(_wordsToPopulate, (word) =>
{
_stringCollection.AddString(word);
});
_stopWatch.Stop();
SpinWait.SpinUntil(() => loopResult.IsCompleted);
executionStatistics.Add(new ExecutionStatistics()
{
WordCount = _wordsToPopulate.Length,
PopulatedWordCount = _stringCollection.NumberOfWords,
ExecutionTime = _stopWatch.Elapsed,
});
_stringCollection.Reset();
_stopWatch.Reset();
}
return(executionStatistics);
}
public ChooseJobTemplate(string cluster)
{
InitializeComponent();
lstTemplates.Items.Clear();
if (cluster != "")
{
try
{
Scheduler scheduler = new Scheduler();
scheduler.Connect(cluster);
IStringCollection ngs = scheduler.GetJobTemplateList();
foreach (String ng in ngs)
{
lstTemplates.Items.Add(ng /*+ " (" + scheduler.GetNodesInNodeGroup(ng).Count().ToString() + ")" */);
}
}
catch
{
}
}
Mouse.OverrideCursor = null;
}
static void Inner(IStringCollection collection, int i, ISerializer s2)
{
var concrete = (ListStringCollection)collection;
while (collection.Count <= i)
{
concrete.Add(null);
}
concrete[i] = s2.FixedLengthString(null, concrete[i], StringSize);
}
public static List <string> convert(IStringCollection collection)
{
List <string> list = new List <string>();
foreach (string item in collection)
{
list.Add(item);
}
return(list);
}
} // FormatCommaSeparated
// ----------------------------------------------------------------------
/// <summary>
/// Removes all items in the given list from this instance.
/// </summary>
/// <param name="items">the items to remove</param>
public void RemoveAll(IStringCollection items)
{
if (items == null)
{
throw new ArgumentNullException("items");
}
foreach (string item in items)
{
Remove(item);
}
} // RemoveAll
} // Add
// ----------------------------------------------------------------------
/// <summary>
/// Adds all items in the given list to this instance.
/// </summary>
/// <param name="items">the items to add</param>
public void AddAll(IStringCollection items)
{
if (items == null)
{
throw new ArgumentNullException("items");
}
foreach (string item in items)
{
InnerList.Add(item);
}
} // AddAll
string LoadStringCore(StringId id, string language)
{
language ??= Resolve <IGameplaySettings>().Language;
var asset = _modApplier.LoadAsset(id.Id, language);
return(asset switch
{
IStringCollection collection => collection.GetString(id, language),
string s => s,
_ => null
});
} // StringCollection
// ----------------------------------------------------------------------
/// <summary>
/// Creates a new instance with all the items of the given collection.
/// </summary>
/// <param name="collection">the items to add. may not be null. any non-string items
/// in this collection will be returned as null when trying to access them later.</param>
public StringCollection(IStringCollection collection)
{
if (collection == null)
{
throw new ArgumentNullException("collection");
}
InnerList.Capacity = collection.Count;
foreach (string item in collection)
{
InnerList.Add(item);
}
} // StringCollection
// ----------------------------------------------------------------------
/// <summary>
/// Creates a new instance with all the items of the given collection.
/// </summary>
/// <param name="collection">the items to add. may not be null. any non-string items
/// in this collection will be returned as null when trying to access them later.</param>
public StringCollection( IStringCollection collection )
{
if ( collection == null )
{
throw new ArgumentNullException( "collection" );
}
InnerList.Capacity = collection.Count;
foreach ( string item in collection )
{
InnerList.Add( item );
}
}
private static ISchedulerTask AddCleanupTaskToJob(ClusterSubmitterArgs clusterArgs, IScheduler scheduler, ISchedulerJob job, IDistributable distributableJob)
{
ISchedulerCollection taskList = job.GetTaskList(scheduler.CreateFilterCollection(), scheduler.CreateSortCollection(), true);
IStringCollection dependencyTasks = scheduler.CreateStringCollection();
if (!clusterArgs.OnlyDoCleanup)
{
dependencyTasks.Add(((ISchedulerTask)taskList[0]).Name);
}
ISchedulerTask cleanupTask = CreateCleanupTask(job, clusterArgs.ExternalRemoteDirectoryName, clusterArgs.StdErrRelativeDirName, clusterArgs.StdOutRelativeDirName, "cleanup", isFinalCleanup: true);
Locally local = new Locally()
{
Cleanup = true,
TaskCount = clusterArgs.TaskCount,
Tasks = new RangeCollection(),
ParallelOptions = new ParallelOptions()
{
MaxDegreeOfParallelism = 1
}
};
DistributeApp.Distribute distributeExe = new DistributeApp.Distribute()
{
Distributor = local,
Distributable = distributableJob
};
string exeName = distributableJob is DistributableWrapper ? clusterArgs.ExeName : distributeExe.GetType().Assembly.GetName().Name;
string taskCommandLine = string.Format("{0}\\{1} {2}", clusterArgs.ExeRelativeDirectoryName, exeName, CreateTaskString(distributeExe, clusterArgs.MinimalCommandLine));
cleanupTask.CommandLine = taskCommandLine;
if (!clusterArgs.OnlyDoCleanup)
{
cleanupTask.DependsOn = dependencyTasks;
}
job.AddTask(cleanupTask);
return(cleanupTask);
}
/// <summary>
/// commands are special job that contains a single task and cab be run only by administrators
/// A command job is not scheduled (it runs immediately)
/// </summary>
/// <param name="commandLine">the command to execute</param>
/// <param name="info">provides additional property values used by command. if no additional property values, set to null</param>
/// <param name="nodes">indentify the nodes on which the command will run.</param>
/// <param name="userName">the name of the runas user, in the form domain\username</param>
/// <param name="password">the password for the runas user</param>
public void CreateCommand(string commandLine, ICommandInfo info, IStringCollection nodes, string userName, string password)
{
if (UserPrivilege.Admin != _scheduler.GetUserPrivilege())
{
return;
}
manualReset.Reset();
//create the command
IRemoteCommand command = _scheduler.CreateCommand(commandLine, info, nodes);
//subscribe to one or more events before starting the command
command.OnCommandJobState += OnJobStateCallback;
command.OnCommandTaskState += OnCommandTaskStateCallback;
command.OnCommandOutput += OnCommandOutputCallback;
command.OnCommandRawOutput += OnCommandRawOutputCallback;
command.StartWithCredentials(userName, password);
manualReset.WaitOne();
}
private static IStringCollection GetNodesToUse(ClusterSubmitterArgs clusterArgs, IScheduler scheduler, ISchedulerJob job)
{
job.AutoCalculateMax = false;
job.AutoCalculateMin = false;
var availableNodes = scheduler.GetNodeList(null, null);
IStringCollection nodesToUse = scheduler.CreateStringCollection();
List <string> nodesFound = new List <string>();
foreach (var node in availableNodes)
{
string nodeName = ((Microsoft.Hpc.Scheduler.SchedulerNode)node).Name;
if (!clusterArgs.NodeExclusionList.Contains(nodeName))
{
nodesToUse.Add(nodeName);
}
else
{
nodesFound.Add(nodeName);
}
}
Helper.CheckCondition(nodesFound.Count != clusterArgs.NodeExclusionList.Count, "not all nodes in exclusion list found: check for typo " + clusterArgs.NodeExclusionList);
return(nodesToUse);
}
private static ISchedulerTask CreateTask(int?taskNumber, ClusterSubmitterArgs clusterArgs, ISchedulerJob job, IDistributable distributableObj, IStringCollection nodesToUse)
{
Locally local = new Locally()
{
Cleanup = false,
TaskCount = clusterArgs.TaskCount,
Tasks = taskNumber.HasValue ? new RangeCollection(taskNumber.Value) : null,
};
ISchedulerTask task = job.CreateTask();
if (nodesToUse != null)
{
task.RequiredNodes = nodesToUse;
}
if (clusterArgs.NumCoresPerTask != null)
{
task.MinimumNumberOfCores = clusterArgs.NumCoresPerTask.Value;
task.MaximumNumberOfCores = clusterArgs.NumCoresPerTask.Value;
task.MaximumNumberOfNodes = 1;
local.ParallelOptions.MaxDegreeOfParallelism = clusterArgs.NumCoresPerTask.Value;
}
if (!clusterArgs.IsExclusive)
{
local.ParallelOptions = new ParallelOptions()
{
MaxDegreeOfParallelism = 1
};
}
task.WorkDirectory = clusterArgs.ExternalRemoteDirectoryName;
DistributeApp.Distribute distributeExe = new DistributeApp.Distribute()
{
Distributable = distributableObj,
Distributor = local
};
string taskArgString = CreateTaskString(distributeExe, clusterArgs.MinimalCommandLine);
string exeName = distributeExe.Distributable is DistributableWrapper ? clusterArgs.ExeName : distributeExe.GetType().Assembly.GetName().Name;
string taskCommandLine = null;
if (clusterArgs.UseMPI)
{
taskCommandLine = string.Format("mpiexec -n {0} {1}\\{2} {3}", clusterArgs.NumCoresPerTask, clusterArgs.ExeRelativeDirectoryName, exeName, taskArgString);
}
else
{
taskCommandLine = string.Format("{0}\\{1} {2}", clusterArgs.ExeRelativeDirectoryName, exeName, taskArgString);
}
task.CommandLine = taskCommandLine;
string taskNumberAsString = taskNumber.HasValue ? taskNumber.Value.ToString() : "*";
task.Name = Helper.CreateDelimitedString(" ", distributableObj.JobName, taskNumberAsString);
Console.WriteLine(Resource.StdOutRelativeDirName + clusterArgs.StdOutRelativeDirName);
task.StdErrFilePath = string.Format(@"{0}\{1}.txt", clusterArgs.StdErrRelativeDirName, taskNumberAsString);
task.StdOutFilePath = string.Format(@"{0}\{1}.txt", clusterArgs.StdOutRelativeDirName, taskNumberAsString);
Console.WriteLine(Resource.CreateTask, task.CommandLine.Length, task.CommandLine);
if (task.StdErrFilePath.Length >= 160)
{
Console.WriteLine(Resource.Caution, task.StdErrFilePath.Length);
}
return(task);
}
private static void SubmitViaAPI3(ClusterSubmitterArgs clusterArgs, IDistributable distributableObj)
{
Console.WriteLine(string.Format("Connecting to cluster {0} using API version 3 .", clusterArgs.Cluster));
using (IScheduler scheduler = new Scheduler())
{
scheduler.Connect(clusterArgs.Cluster);
ISchedulerJob job = scheduler.CreateJob();
job.Name = distributableObj.JobName;
job.Priority = clusterArgs.Priority;
if (clusterArgs.JobTemplate != null)
{
Microsoft.Hpc.Scheduler.IStringCollection jobTemplates = scheduler.GetJobTemplateList();
string decodedJobTemplate = System.Web.HttpUtility.UrlDecode(clusterArgs.JobTemplate);
if (jobTemplates.Contains(decodedJobTemplate))
{
job.SetJobTemplate(decodedJobTemplate);
}
else
{
Console.WriteLine(string.Format(Resource.Job_template, decodedJobTemplate));
foreach (var template in jobTemplates)
{
Console.Write("'" + template + "' ");
}
Console.WriteLine(Resource.SubmitViaAPI3);
}
}
if (clusterArgs.NumCoresPerTask != null)
{
clusterArgs.IsExclusive = false;
}
IStringCollection nodesToUse = null;
if (clusterArgs.NodeExclusionList != null && clusterArgs.NodeExclusionList.Count > 0)
{
nodesToUse = GetNodesToUse(clusterArgs, scheduler, job);
}
else if (clusterArgs.NodesToUseList != null && clusterArgs.NodesToUseList.Count > 0)
{
nodesToUse = scheduler.CreateStringCollection();
foreach (string nodeName in clusterArgs.NodesToUseList)
{
nodesToUse.Add(nodeName);
}
}
else if (clusterArgs.NumCoresPerTask != null)
{
job.AutoCalculateMax = true;
job.AutoCalculateMin = true;
}
else if (clusterArgs.IsExclusive)
{
job.UnitType = Microsoft.Hpc.Scheduler.Properties.JobUnitType.Node;
if (clusterArgs.MinimumNumberOfNodes != null)
{
job.MaximumNumberOfNodes = clusterArgs.MaximumNumberOfNodes.Value;
job.MinimumNumberOfNodes = clusterArgs.MinimumNumberOfNodes.Value;
}
}
else if (clusterArgs.MinimumNumberOfCores != null)
{
if (clusterArgs.MaximumNumberOfCores == null)
{
job.AutoCalculateMax = true;
}
else
{
job.AutoCalculateMax = false;
job.MaximumNumberOfCores = clusterArgs.MaximumNumberOfCores.Value;
}
job.MaximumNumberOfCores = clusterArgs.MaximumNumberOfCores ?? Math.Max(clusterArgs.TaskCount, scheduler.GetCounters().TotalCores);
job.MinimumNumberOfCores = clusterArgs.MinimumNumberOfCores.Value;
job.AutoCalculateMin = false;
}
else
{
job.AutoCalculateMax = true;
job.AutoCalculateMin = true;
}
if (!clusterArgs.OnlyDoCleanup)
{
if (clusterArgs.TaskRange.IsContiguous())
{
if (clusterArgs.TaskRange.LastElement > clusterArgs.TaskCount - 1)
{
clusterArgs.TaskRange = new RangeCollection(clusterArgs.TaskRange.FirstElement, clusterArgs.TaskCount - 1);
}
ISchedulerTask task = CreateTask(null, clusterArgs, job, distributableObj, nodesToUse);
task.Type = TaskType.ParametricSweep;
task.StartValue = 0;
task.EndValue = clusterArgs.TaskCount - 1;
job.AddTask(task);
}
else
{
job.AddTasks(clusterArgs.TaskRange.Select(taskNum => CreateTask((int)taskNum, clusterArgs, job, distributableObj, nodesToUse)).ToArray());
}
}
else
{
clusterArgs.Cleanup = true;
}
ISchedulerTask cleanupTask = null;
if (clusterArgs.Cleanup)
{
cleanupTask = AddCleanupTaskToJob(clusterArgs, scheduler, job, distributableObj);
}
Console.WriteLine(Resource.Submitting_job);
scheduler.SubmitJob(job, null, null);
clusterArgs.JobID = job.Id;
Console.WriteLine(job.Name + Resource.submitted);
}
}
// ----------------------------------------------------------------------
/// <summary>
/// Removes all items in the given list from this instance.
/// </summary>
/// <param name="items">the items to remove</param>
public void RemoveAll( IStringCollection items )
{
if ( items == null )
{
throw new ArgumentNullException( "items" );
}
foreach ( string item in items )
{
Remove( item );
}
}
// ----------------------------------------------------------------------
/// <summary>
/// Adds all items in the given list to this instance.
/// </summary>
/// <param name="items">the items to add</param>
public void AddAll( IStringCollection items )
{
if ( items == null )
{
throw new ArgumentNullException( "items" );
}
foreach ( string item in items )
{
InnerList.Add( item );
}
}
public static bool Compare(this IStringCollection source, IStringCollection n, Func <string, string, Action <string, string>, bool> checkitem, Action <string, string> errAct)
{
return(Compare <string>(source, n, checkitem, errAct));
}
//for best results, run this sample code in queued scheduling mode
static void Main(string[] args)
{
string clusterName = Environment.GetEnvironmentVariable("CCP_SCHEDULER");
using (IScheduler scheduler = new Scheduler())
{
Console.WriteLine("Connecting to {0}", clusterName);
scheduler.Connect(clusterName);
//assume you have two nodegroups, NodeGroup1 and NodeGroup2
IStringCollection nodeGroup1 = scheduler.GetNodesInNodeGroup("NodeGroup1");
IStringCollection nodeGroup2 = scheduler.GetNodesInNodeGroup("NodeGroup2");
if (nodeGroup1.Count == 0 || nodeGroup2.Count == 0)
{
Console.WriteLine("Node groups are not set up correctly");
return;
}
//and nodes in NodeGroup2 are not in NodeGroup1, and vise versa.
string nodeToMove = "";
foreach (string node in nodeGroup2)
{
if (!nodeGroup1.Contains(node))
{
nodeToMove = node;
break;
}
}
if (string.IsNullOrEmpty(nodeToMove))
{
Console.WriteLine("No eligible nodes to move");
return;
}
//create a job to run on NodeGroup1
ISchedulerJob job = scheduler.CreateJob();
job.NodeGroups.Add("NodeGroup1");
//Set unit type to node, but let it autocalculate resources
job.UnitType = JobUnitType.Node;
ISchedulerTask task = job.CreateTask();
task.CommandLine = "ver";
task.Type = TaskType.Service;
job.AddTask(task);
job.OnTaskState += new EventHandler <TaskStateEventArg>(job_OnTaskState);
Console.WriteLine("Submitting job on NodeGroup1");
scheduler.SubmitJob(job, null, null);
Console.WriteLine("Job {0} Submitted", job.Id);
//wait for the job to start running
running.WaitOne();
job.Refresh();
int allocationCount = job.AllocatedNodes.Count;
Console.WriteLine("Number of allocated nodes: {0}", allocationCount);
//Check the status of NodeGroup1 nodes
int idleCores = 0;
foreach (string nodename in nodeGroup1)
{
ISchedulerNode node = scheduler.OpenNodeByName(nodename);
idleCores += node.GetCounters().IdleCoreCount;
}
//There are no more idle cores remaining in this node group
//So we'll place one of the nodes from NodeGroup2 allow the job to grow
if (idleCores == 0)
{
running.Reset();
//Changing nodegroups is available through the UI or PowerShell
string powershellScript = String.Format("add-pssnapin microsoft.hpc; " +
"add-hpcgroup -scheduler {0} -name {1} -nodename {2}",
clusterName, "NodeGroup1", nodeToMove);
using (PowerShell ps = PowerShell.Create())
{
ps.AddScript(powershellScript, true);
ps.Invoke();
}
running.WaitOne();
Console.WriteLine("(Waiting 5 seconds for job to update the scheduler)");
Thread.Sleep(5 * 1000);
job.Refresh();
int newAllocationCount = job.AllocatedNodes.Count;
//verify that job has grown
if (newAllocationCount > allocationCount)
{
Console.WriteLine("Job has grown to {0} nodes", newAllocationCount);
}
}
else
{
Console.WriteLine("There are still idle cores in the nodegroup");
}
}
}
public static bool Compare(this IStringCollection source, IStringCollection n)
{
return Compare<string>(source,n);
}
public static bool Compare(this IStringCollection source, IStringCollection n, Func<string, string, Action<string, string>, bool> checkitem, Action<string, string> errAct)
{
return Compare<string>(source,n,checkitem,errAct);
}
public Microsoft.Hpc.Scheduler.IRemoteCommand CreateCommand(string commandLine, ICommandInfo info, IStringCollection nodes, bool redirectOutput)
{
lock (SyncRoot) { return(Instance.CreateCommand(commandLine, info, nodes, redirectOutput)); }
}
public static bool Compare(this IStringCollection source, IStringCollection n)
{
return(Compare <string>(source, n));
}
