/// <summary>
/// 删除指定的任务
/// </summary>
/// <param name="jobName">任务名称</param>
/// <param name="jobGroup">任务组</param>
/// <returns></returns>
public async Task <ScheduleResult> DeleteJobAsync(string jobName, string jobGroup)
{
ScheduleResult result = new ScheduleResult();
try
{
JobKey jobKey = new JobKey(jobName, jobGroup);
if (await Scheduler.CheckExists(jobKey))
{
//先暂停，再移除
await Scheduler.PauseJob(jobKey);
await Scheduler.DeleteJob(jobKey);
}
else
{
result.ResultCode = -1;
result.ResultMsg = "任务不存在";
}
}
catch (Exception ex)
{
_logger.Error(nameof(AddJobAsync), ex, null);
result.ResultCode = -4;
result.ResultMsg = ex.ToString();
}
return(result);
}
/// <summary>
/// 暂停指定任务计划
/// </summary>
/// <param name="jobName">任务名</param>
/// <param name="jobGroup">任务分组</param>
/// <returns></returns>
public async Task <ScheduleResult> StopJobAsync(string jobName, string jobGroup)
{
ScheduleResult result = new ScheduleResult();
try
{
JobKey jobKey = new JobKey(jobName, jobGroup);
scheduler = await GetSchedulerAsync();
if (await scheduler.CheckExists(jobKey))
{
await scheduler.PauseJob(new JobKey(jobName, jobGroup));
}
else
{
result.Code = -1;
result.Message = "任务不存在";
}
}
catch (Exception ex)
{
_logger.LogException(ex);
result.Code = -4;
result.Message = ex.ToString();
}
return(result);//出现异常
}
/// <summary>
/// Starts the actual solvers, returns the best schedule when all solvers are done.
/// </summary>
/// <returns>The best schedule when all solvers are done</returns>
private ScheduleResult Solve()
{
// Initialize all variables:
Task[] tasks = new Task[ThreadCount];
stati = new SolverStatus[ThreadCount];
iterationCounters = new int[ThreadCount];
bestResults = new ScheduleResult[ThreadCount];
for (int i = 0; i < ThreadCount; i -= -1)
{
bestResults[i] = new ScheduleResult()
{
Score = double.MaxValue
}
}
;
// Start the statusupdater and leaderboard:
Task statusUpdater = Task.Factory.StartNew(() => StatusUpdater());
// Start the solvers:
for (int i = 0; i < ThreadCount; i++)
{
int index = i;
tasks[index] = Task.Factory.StartNew(() => SolveOne(index, ref bestResults[index]));
}
// Wait untill all solvers are done:
Task.WaitAll(tasks);
// Stop the statusupdater:
stopStatusUpdater = true;
statusUpdater.Wait();
// Return the best schedule:
return(best);
}
/// <summary>
/// 恢复指定的任务计划,如果是程序奔溃后 或者是进程杀死后的恢复，此方法无效
/// </summary>
/// <param name="jobName">任务名称</param>
/// <param name="jobGroup">任务组</param>
/// <returns></returns>
public async Task <ScheduleResult> ResumeJobAsync(string jobName, string jobGroup)
{
ScheduleResult result = new ScheduleResult();
try
{
JobKey jobKey = new JobKey(jobName, jobGroup);
if (await Scheduler.CheckExists(jobKey))
{
//resumejob 恢复
await Scheduler.PauseJob(jobKey);
await Scheduler.ResumeJob(jobKey);
}
else
{
result.ResultCode = -1;
result.ResultMsg = "任务不存在";
}
}
catch (Exception ex)
{
_logger.LogError(ex, nameof(ResumeJobAsync));
result.ResultCode = -4;
result.ResultMsg = ex.ToString();
}
return(result);
}
public async Task <ScheduleResult> ResumeJobAsync(string jobName, string jobGroup)
{
ScheduleResult scheduleResult = new ScheduleResult();
try
{
var jobKey = new JobKey(jobName, jobGroup);
if (await Scheduler.CheckExists(jobKey))
{
await Scheduler.PauseJob(jobKey);
await Scheduler.ResumeJob(jobKey);
}
else
{
scheduleResult.ResultCode = -1;
scheduleResult.ResultMsg = "任务不存在";
}
}
catch (Exception ex)
{
_logger.Error(nameof(AddJobAsync), ex, null);
scheduleResult.ResultCode = -4;
scheduleResult.ResultMsg = ex.ToString();
}
return(scheduleResult);
}
public void Variable_Initialize(ScheduleResult script_S)
{
if (script_S != null)
{
script_Schedule = script_S;
}
}
/// <summary>
/// 删除指定的任务
/// </summary>
/// <param name="jobName">任务名称</param>
/// <param name="jobGroup">任务组</param>
/// <returns></returns>
public async Task <ScheduleResult> DeleteJobAsync(string jobName, string jobGroup)
{
ScheduleResult result = new ScheduleResult();
try
{
JobKey jobKey = new JobKey(jobName, jobGroup);
if (await Scheduler.CheckExists(jobKey))
{
//先暂停，再移除
await Scheduler.PauseJob(jobKey);
await Scheduler.DeleteJob(jobKey);
}
else
{
result.Code = -1;
result.Message = "任务不存在";
}
}
catch (Exception ex)
{
_logger.LogException(ex);
result.Code = -4;
result.Message = ex.ToString();
}
return(result);
}
public async Task <ScheduleResult> Get(Guid id)
{
var customer = await scheduleReadOnlyRepository.Get(id);
ScheduleResult scheduleResult = resultConverter.Map <ScheduleResult>(customer);
return(scheduleResult);
}
/// <summary>
/// Constructor, initializes some variables.
/// </summary>
/// <param name="orders"></param>
public Solver(List <Order> orders)
{
best = new ScheduleResult()
{
Score = double.MaxValue
};
this.orders = orders;
}
public void TestInitialize()
{
this.timeService = Mock.Of <ITimeService>();
this.schedueResult = new ScheduleResult();
var dataProvider = Mock.Of <IScheduleDataProvider>(s => s.GetSchedules() == this.schedueResult);
this.factory = new MeetingSchedulerFactory(this.timeService, dataProvider);
}
/// <summary>
/// 添加调度任务
/// </summary>
/// <param name="JobName">任务名称</param>
/// <param name="JobGroup">任务分组</param>
/// <param name="JobNamespaceAndClassName">任务完全限定名</param>
/// <param name="JobAssemblyName">任务程序集名称</param>
/// <param name="CronExpress">Cron表达式</param>
/// <param name="StarTime">开始时间</param>
/// <param name="EndTime">结束时间</param>
/// <returns></returns>
public async Task <ScheduleResult> AddJobAsync(String JobName, String JobGroup, String JobNamespaceAndClassName, String JobAssemblyName, string CronExpress)
{
ScheduleResult result = new ScheduleResult();
try
{
if (string.IsNullOrEmpty(JobName) || string.IsNullOrEmpty(JobGroup) || string.IsNullOrEmpty(JobNamespaceAndClassName) || string.IsNullOrEmpty(JobAssemblyName) || string.IsNullOrEmpty(CronExpress))
{
result.ResultCode = -3;
result.ResultMsg = $"参数不能为空";
return(result);//出现异常
}
var starRunTime = DateTime.Now;
var EndTime = DateTime.MaxValue.AddDays(-1);
DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(EndTime, 1);
JobKey jobKey = new JobKey(JobName, JobGroup);
if (await Scheduler.CheckExists(jobKey))
{
await Scheduler.PauseJob(jobKey);
await Scheduler.DeleteJob(jobKey);
}
Assembly assembly = Assembly.LoadFile(JobAssemblyName);
Type jobType = assembly.GetType(JobNamespaceAndClassName);
//var jobType = Type.GetType(JobNamespaceAndClassName + "," + JobAssemblyName);
if (jobType == null)
{
result.ResultCode = -1;
result.ResultMsg = "系统找不到对应的任务，请重新设置";
return(result);//出现异常
}
IJobDetail job = JobBuilder.Create(jobType)
.WithIdentity(jobKey).UsingJobData("ServerName", Scheduler.SchedulerName)
.Build();
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
.StartAt(starRunTime)
.EndAt(endRunTime)
.WithIdentity(JobName, JobGroup)
.WithCronSchedule(CronExpress)
.Build();
await Scheduler.ScheduleJob(job, trigger);
if (!Scheduler.IsStarted)
{
await Scheduler.Start();
}
return(result);
}
catch (Exception ex)
{
_logger.LogError(ex, nameof(AddJobAsync));
result.ResultCode = -4;
result.ResultMsg = ex.ToString();
return(result);//出现异常
}
}
public void TestInitialize()
{
this.currentDate = new DateTime(2018, 01, 01);
this.scheduleResult = new ScheduleResult();
var timeService = Mock.Of <ITimeService>(s => s.CurrentDate == this.currentDate);
this.scheduler = new MeetingScheduler(timeService
, null);
}
public ScheduleResult deleteSchedule(string schedule_id)
{
Preconditions.checkArgument(schedule_id != null, (object)"schedule_id should not be empty");
Console.WriteLine(schedule_id);
ResponseWrapper responseWrapper = this.sendDelete("https://api.jpush.cn" + "/v3/schedules" + "/" + schedule_id, this.Authorization(), schedule_id);
ScheduleResult scheduleResult = new ScheduleResult();
scheduleResult.ResponseResult = responseWrapper;
ScheduleSuccess scheduleSuccess = (ScheduleSuccess)JsonConvert.DeserializeObject <ScheduleSuccess>(responseWrapper.responseContent);
return(scheduleResult);
}
/// <summary>
/// Prints the best solver result.
/// </summary>
/// <param name="best">The best schedule result</param>
/// <param name="writeToFile">if true saves the best result as string ready to put in the checker</param>
/// <param name="fileName">filename of the file in which the best result is saved, ignored if writeToFile=false</param>
private static void PrintResult(ScheduleResult best, bool writeToFile = true, string fileName = "result")
{
Console.Clear();
Console.WriteLine("===============" +
"\n= BEST RESULT =" +
"\n===============");
Console.WriteLine(best.Stats);
if (writeToFile)
{
File.WriteAllText($@".\{fileName}.txt", best.Check.ToString());
}
Console.WriteLine("===============");
}
//执行结果解析
public static string transResult(ScheduleResult result)
{
string str = string.Empty;
switch (result)
{
case ScheduleResult.UnExecute: str = Model_Data.Language.ScheduleStr.AwaitingExecution; break;
case ScheduleResult.Outdate: str = Model_Data.Language.ScheduleStr.Failure; break;
case ScheduleResult.Success: str = Model_Data.Language.ScheduleStr.success; break;
}
return(str);
}
public async Task <ScheduleResult> Process(UpdateScheduleCommand command)
{
Domain.Schedule.Schedule schedule = new Domain.Schedule.Schedule(command.ScheduleId, command.Day, command.Hour)
{
Customer = await customerReadOnlyRepository.Get(command.CustomerId),
Service = await serviceReadOnlyRepository.Get(command.ServiceId)
};
await scheduleWriteOnlyRepository.Update(schedule);
ScheduleResult scheduleResult = resultConverter.Map <ScheduleResult>(schedule);
return(scheduleResult);
}
public ScheduleResult sendSchedule(string schedulepayload)
{
Preconditions.checkArgument(!string.IsNullOrEmpty(schedulepayload), (object)"schedulepayload should not be empty");
Console.WriteLine(schedulepayload);
ResponseWrapper responseWrapper = this.sendPost("https://api.jpush.cn" + "/v3/schedules", this.Authorization(), schedulepayload);
ScheduleResult scheduleResult = new ScheduleResult();
scheduleResult.ResponseResult = responseWrapper;
ScheduleSuccess scheduleSuccess = (ScheduleSuccess)JsonConvert.DeserializeObject <ScheduleSuccess>(responseWrapper.responseContent);
scheduleResult.schedule_id = scheduleSuccess.schedule_id;
scheduleResult.name = scheduleSuccess.name;
return(scheduleResult);
}
public void TestInitialize()
{
this.currentDate = new DateTime(2018, 01, 01);
this.scheduleResult = new ScheduleResult();
var timeService = Mock.Of <ITimeService>(s => s.CurrentDate == this.currentDate);
var meetingSchedulerCalculator = Mock.Of <IMeetingSchedulerCalculator>(s => s.GetAvailableMeetings(It.IsAny <int>()
, It.IsAny <ISet <Guid> >()
, this.currentDate) == Enumerable.Empty <MeetingSchedulerResult>());
this.scheduler = new MeetingScheduler(timeService
, meetingSchedulerCalculator);
}
public override PayrollResult Evaluate(PayrollPeriod period, PayTagGateway tagConfig, IDictionary <TagRefer, PayrollResult> results)
{
ScheduleResult scheduleWorkResult = (ScheduleResult)GetResultBy(results, TAG_SCHEDULE_WORK);
int[] weekHours = scheduleWorkResult.WeekSchedule;
int[] hoursCalendar = ComputeResultValue(period, weekHours);
var resultValues = new Dictionary <string, object>()
{
{ "month_schedule", hoursCalendar }
};
return(new TimesheetResult(TagCode, Code, this, resultValues));
}
/// <summary>
/// Starts the solver.
/// Awaits until either:
/// - All solver instances are finished.
/// - Userinterrupt.
/// Then prints the best result.
/// </summary>
private static void AwaitAndPrintResults()
{
Task userInterruptAwaiter = Task.Factory.StartNew(() => AwaitUserInterrupt(solver));
results.Wait();
if (!userInterruptAwaiter.IsCompleted)
{
solverStillGoing = false;
}
userInterruptAwaiter.Wait();
ScheduleResult res = results.Result;
Console.Beep();
PrintResult(res);
}
public void ShouldBeAbleToGetSchedule()
{
const string url = "My URL";
const string json = "JSON";
var scheduleResult = new ScheduleResult();
this.urlProvider.Setup(s => s.GetUrl()).Returns(url);
this.jsonRepository.Setup(s => s.Get(url)).Returns(json);
this.jsonParser.Setup(s => s.ToObject <RootObject>(json)).Returns(new RootObject {
ScheduleResult = scheduleResult
});
var result = this.dataProvider.GetSchedules();
Assert.AreSame(scheduleResult, result);
}
public ScheduleResult sendSchedule(string schedulepayload)
{
Preconditions.checkArgument(!string.IsNullOrEmpty(schedulepayload), "schedulepayload should not be empty");
Console.WriteLine(schedulepayload);
String url = HOST_NAME_SSL;
url += PUSH_PATH;
ResponseWrapper result = sendPost(url, Authorization(), schedulepayload);
ScheduleResult messResult = new ScheduleResult();
messResult.ResponseResult = result;
ScheduleSuccess scheduleSuccess = JsonConvert.DeserializeObject <ScheduleSuccess>(result.responseContent);
messResult.schedule_id = scheduleSuccess.schedule_id;
messResult.name = scheduleSuccess.name;
return(messResult);
}
/// <summary>
/// 直接使用 BookAppService.UpdateAsync 来更新实体
/// </summary>
/// <returns></returns>
public async Task <IActionResult> OnPostAsync()
{
var jobInfoDto = await _jobInfoAppService.GetAsync(Id);
ScheduleResult result = new ScheduleResult();
if (jobInfoDto.JobStatus != JobInfo.JobStatus)
{
if (jobInfoDto.JobStatus == JobStatu.Deleted)
{
//如果之前的状态是已删除的话，先创建任务再进行操作
await _scheduleCenter.AddJobAsync(JobInfo.JobName,
JobInfo.JobGroup,
JobInfo.JobNamespace + "." + JobInfo.JobClassName,
JobInfo.JobAssemblyName,
JobInfo.CronExpress,
JobInfo.StarTime,
JobInfo.EndTime);
}
if (JobInfo.JobStatus == JobStatu.Deleted)
{
result = await _scheduleCenter.DeleteJobAsync(JobInfo.JobName, JobInfo.JobGroup);
if (result.Code == 0)
{
await _jobInfoAppService.DeleteAsync(Id);
}
return(NoContent());
}
else if (JobInfo.JobStatus == JobStatu.Running)
{
result = await _scheduleCenter.ResumeJobAsync(JobInfo.JobName, JobInfo.JobGroup);
}
else
{
result = await _scheduleCenter.StopJobAsync(JobInfo.JobName, JobInfo.JobGroup);
}
}
if (result.Code == 0)
{
await _jobInfoAppService.UpdateAsync(Id, JobInfo);
}
return(NoContent());
}
public void TestInitialize()
{
var jsonParser = new JsonParser();
var jsonRepository = new JsonRepository();
var urlProvider = new RESTfulURLProvider();
var dataProvider = new ScheduleDataProvider(jsonParser
, jsonRepository
, urlProvider
);
this.scheduleResult = dataProvider.GetSchedules();
var calculator = new MeetingSchedulerCalculator(this.scheduleResult);
this.timeService = new Mock <ITimeService>();
this.scheduler = new MeetingScheduler(this.timeService.Object
, calculator);
}
//DELETE https://api.jpush.cn/v3/schedules/{schedule_id}
//删除指定的Schedule任务
public ScheduleResult deleteSchedule(string schedule_id)
{
Preconditions.checkArgument(schedule_id != null, "schedule_id should not be empty");
Console.WriteLine(schedule_id);
String url = HOST_NAME_SSL;
url += PUSH_PATH;
url += DELETE_PATH;
url += schedule_id;
ResponseWrapper result = sendDelete(url, Authorization(), schedule_id);
ScheduleResult messResult = new ScheduleResult();
messResult.ResponseResult = result;
ScheduleSuccess scheduleSuccess = JsonConvert.DeserializeObject <ScheduleSuccess>(result.responseContent);
//messResult.schedule_id = scheduleSuccess.schedule_id;
//messResult.name = scheduleSuccess.name;
return(messResult);
}
/// <summary>
/// Writes the successfully scheduled recordings to an output CSV file.
/// </summary>
/// <param name="sessionMgr">The client in which holds the information about the sessions.</param>
/// <param name="sessionAuth">The authentication information for which to access the information from <paramref name="sessionMgr"/>.</param>
/// <param name="scheduleSuccesses">The list of unique identifiers for each successfully scheduled recording.</param>
/// <param name="sender">The BackgroundWorker to make this method asynchronous.</param>
public static void WriteSuccessFile(ISessionManagement sessionMgr,
Utilities.SessionManagement46.AuthenticationInfo sessionAuth,
List <Guid> scheduleSuccesses,
BackgroundWorker sender)
{
// Get the information for each scheduled session and put it into a ScheduleResult object.
List <ScheduleResult> scheduled = new List <ScheduleResult>();
Session[] session = sessionMgr.GetSessionsById(sessionAuth, scheduleSuccesses.ToArray());
for (int j = 0; j < session.Length; j++)
{
if (sender != null)
{
// NOTE: This method runs so quickly even at many lines, that this progress report may not be necessary
// to update the UI. Still good to have in the event this stalls here though.
sender.ReportProgress(j);
}
// Use 0 for RemoteRecorderIds since currently only dealing with 1 remote recorder.
ScheduleResult sr = new ScheduleResult(session[j].RemoteRecorderIds[0],
session[j].FolderId,
session[j].Id,
session[j].Name,
session[j].StartTime?.ToLocalTime(),
(session[j].StartTime + TimeSpan.FromSeconds(session[j].Duration.GetValueOrDefault()))?.ToLocalTime());
scheduled.Add(sr);
}
// write what was successfully scheduled to output.csv
// output.csv will only have a header if there were no session scheduled.
using (TextWriter writer = new StreamWriter(Properties.Settings.Default.LogsLocation + DateTime.Now.ToString("yyyyMMdd_HHmmss") + @"_success_output.csv"))
{
if (sender != null)
{
sender.ReportProgress(session.Length);
}
var csv = new CsvWriter(writer);
csv.WriteRecords(scheduled);
}
}
/// <summary>
/// Gets the best schedule on a fixed interval
/// if STATUS is defined:
/// Prints the status of each solver thread together with
/// - the current runtime.
/// - the best score so far.
/// This is updated each refreshTime miliseconds.
/// </summary>
/// <param name="threads">Amount of solvertasks started</param>
/// <param name="refreshTime">Refresh delay (in miliseconds)</param>
private void StatusUpdater()
{
Console.Clear();
Stopwatch watch = Stopwatch.StartNew();
int currBestIndex = -1;
while (!(stopStatusUpdater || UserInterrupt))
{
for (int i = 0; i < ThreadCount; i++)
{
ScheduleResult curr = bestResults[i];
if (curr.Score < best.Score)
{
currBestIndex = i;
best = curr;
}
if (ShowStatus)
{
SolverStatus stat = stati[i];
string extraInfo;
switch (stat)
{ // In order of most time on status:
case SolverStatus.Doing_All:
extraInfo = $", iteration: {iterationCounters[i]}";
break;
case SolverStatus.Done:
extraInfo = $", best: {bestResults[i].Score}";
break;
case SolverStatus.Doing_Add:
extraInfo = $", iteration: {iterationCounters[i]}";
break;
default: extraInfo = ""; break;
}
Console.SetCursorPosition(0, i);
Console.WriteLine($"Task {i}: {stat}{extraInfo}");
}
}
if (ShowStatus)
{
Console.SetCursorPosition(0, ThreadCount);
Console.WriteLine($"===\nBest result produced on task {currBestIndex}:\n{best.String}");
Console.WriteLine($"===\nCurrent runtime: {watch.Elapsed}");
}
Thread.Sleep(ConsoleUpdateInterval);
}
//Timer updater = new Timer(ConsoleUpdateInterval);
//updater.Elapsed += Updater_Elapsed;
//updater.Start();
//void Updater_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
//{
// if (stopStatusUpdater || UserInterrupt) updater.Stop();
// for (int i = 0; i < ThreadCount; i++)
// {
// ScheduleResult curr = bestResults[i];
// if (curr.Score < best.Score)
// {
// currBestIndex = i;
// best = curr;
// }
// if (ShowStatus)
// {
// SolverStatus stat = stati[i];
// string extraInfo;
// switch (stat)
// { // In order of most time on status:
// case SolverStatus.Doing_All:
// extraInfo = $", iteration: {iterationCounters[i]}";
// break;
// case SolverStatus.Done:
// extraInfo = $", best: {bestResults[i].Score}";
// break;
// case SolverStatus.Doing_Add:
// extraInfo = $", iteration: {iterationCounters[i]}";
// break;
// default: extraInfo = ""; break;
// }
// Console.SetCursorPosition(0, i);
// Console.WriteLine($"Task {i}: {stat}{extraInfo}");
// }
// }
// if (ShowStatus)
// {
// Console.SetCursorPosition(0, ThreadCount);
// Console.WriteLine($"===\nBest result produced on task {currBestIndex}:\n{best.String}");
// Console.WriteLine($"===\nCurrent runtime: {watch.Elapsed}");
// }
//}
//// Block while the updater is active:
//while (updater.Enabled) ;
}
public MeetingSchedulerCalculator(ScheduleResult scheduleResult)
{
this.ScheduleResult = scheduleResult;
}
void Run(SystemInfo[] systems, SystemType type, double time, int laneCount)
{
int typeCount = 0;
double averageTime = 0;
PrecisionTimer processTimer = new PrecisionTimer();
PrecisionTimer unitTimer = new PrecisionTimer();
Console.WriteLine("Test 1 - Adding All Systems at Once");
for (int i = 0; i < systems.Length; i++)
{
if (systems[i].Type == type)
{
typeCount++;
}
}
SafeSystemSchedule schedule = new SafeSystemSchedule(SystemType.Logic, laneCount, typeCount);
processTimer.Start();
for (int i = 0; i < systems.Length; i++)
{
unitTimer.Start();
SystemInfo sysInf = systems[i];
if (!sysInf.Active || sysInf.Type != type)
{
unitTimer.Stop();
averageTime = MathHelper.MovingAverage(averageTime, unitTimer.ElapsedSeconds, i + 1);
unitTimer.Reset();
continue;
}
schedule.Add(sysInf);
unitTimer.Stop();
processTimer.Stop();
averageTime = MathHelper.MovingAverage(averageTime, unitTimer.ElapsedSeconds, i + 1);
unitTimer.Reset();
processTimer.Start();
}
processTimer.Stop();
Console.WriteLine("Total Time to Register : " + processTimer.ElapsedSeconds);
Console.WriteLine("Average Time to Register : " + averageTime);
Console.WriteLine("Extrapolated Time to Register : " + (averageTime * systems.Length));
Console.WriteLine("Extrapolated Time without nonTypes : " + (averageTime * typeCount));
processTimer.Reset();
Console.ReadLine();
Console.WriteLine("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=");
Console.WriteLine("Test 2 - Adding Each System One at a Time");
averageTime = 0;
schedule.Clear();
processTimer.Start();
for (int i = 0; i < systems.Length; i++)
{
unitTimer.Start();
SystemInfo sysInf = systems[i];
if (!sysInf.Active || sysInf.Type != type)
{
unitTimer.Stop();
averageTime = MathHelper.MovingAverage(averageTime, unitTimer.ElapsedSeconds, i + 1);
unitTimer.Reset();
continue;
}
schedule.Add(sysInf);
unitTimer.Stop();
processTimer.Stop();
averageTime = MathHelper.MovingAverage(averageTime, unitTimer.ElapsedSeconds, i + 1);
unitTimer.Reset();
while (schedule.NextSystem(0, out SystemInfo sysInfo) != ScheduleResult.Finished)
{
sysInfo.Age = 1;
}
processTimer.Start();
}
processTimer.Stop();
Console.WriteLine("Total Time to Register : " + processTimer.ElapsedSeconds);
Console.WriteLine("Average Time to Register : " + averageTime);
Console.WriteLine("Extrapolated Time to Register : " + (averageTime * systems.Length));
Console.WriteLine("Extrapolated Time without nonTypes : " + (averageTime * typeCount));
processTimer.Reset();
Console.ReadLine();
Console.WriteLine("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=");
Console.WriteLine("Test 3 - Clear List and Readd");
SafeSystemSchedule copy = new SafeSystemSchedule(schedule);
foreach (SystemInfo sysinf in systems)
{
SystemUpdate(sysinf);
}
processTimer.Start();
schedule.Clear();
for (int i = 0; i < systems.Length; i++)
{
SystemInfo sysInf = systems[i];
if (!sysInf.Active || sysInf.Type != type)
{
continue;
}
schedule.Add(sysInf);
}
processTimer.Stop();
while (schedule.NextSystem(0, out SystemInfo sysInfo) != ScheduleResult.Finished)
{
Console.WriteLine(sysInfo);
}
Console.WriteLine("Total Time to clear then readd : " + processTimer.ElapsedSeconds);
Console.ReadLine();
Console.WriteLine("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=");
Console.WriteLine("Test 4 - Remove Individually and Register One at a time");
processTimer.Start();
copy.Reset();
for (int i = 0; i < systems.Length; i++)
{
SystemInfo sysInf = systems[i];
if (!sysInf.Active || sysInf.Type != type)
{
continue;
}
copy.Remove(sysInf);
copy.Add(sysInf);
}
processTimer.Stop();
while (copy.NextSystem(0, out SystemInfo sysInfo) != ScheduleResult.Finished)
{
Console.WriteLine(sysInfo);
}
Console.WriteLine("Total Time to remove then readd : " + processTimer.ElapsedSeconds);
Console.ReadLine();
Console.WriteLine("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=");
Console.WriteLine("Test 5 - System Run");
schedule.Clear();
for (int i = 0; i < systems.Length; i++)
{
SystemInfo sysInf = systems[i];
if (!sysInf.Active || sysInf.Type != type)
{
continue;
}
schedule.Add(sysInf);
}
double currentTime = 0;
int finishCount = 0;
double[] endTimes = new double[laneCount];
bool[] finished = new bool[laneCount];
averageTime = 0;
processTimer.Start();
while (!schedule.Finished && currentTime < time && finishCount < laneCount)
{
for (int i = 0; i < laneCount; i++)
{
if (endTimes[i] <= currentTime && !finished[i])
{
unitTimer.Start();
schedule.FinishLane(i);
ScheduleResult result = schedule.NextSystem(i, out SystemInfo sysInf);
if (result == ScheduleResult.Supplied)
{
sysInf.Age = 0;
if (sysInf.AverageRunTime + currentTime > time)
{
finished[i] = true;
finishCount++;
unitTimer.Stop();
continue;
}
endTimes[i] = currentTime + sysInf.AverageRunTime;
}
else if (result == ScheduleResult.Finished)
{
finished[i] = true;
finishCount++;
}
unitTimer.Stop();
processTimer.Stop();
averageTime = MathHelper.MovingAverage(averageTime, unitTimer.ElapsedSeconds, i + 1);
unitTimer.Reset();
processTimer.Start();
}
}
processTimer.Stop();
double nextTime = double.PositiveInfinity;
for (int i = 0; i < laneCount; i++)
{
if (endTimes[i] > currentTime && endTimes[i] < nextTime)
{
nextTime = endTimes[i];
}
}
if (nextTime != double.PositiveInfinity)
{
currentTime = nextTime;
}
processTimer.Start();
}
processTimer.Stop();
Console.WriteLine("Total Time to decide : " + processTimer.ElapsedSeconds);
Console.WriteLine("Average Time to decide : " + averageTime);
Console.WriteLine("Extrapolated Time to decide : " + (averageTime * typeCount));
Console.WriteLine("Total Time Used : " + (currentTime) + "/" + time);
processTimer.Reset();
Console.ReadLine();
}
/// <summary>
/// Main method for each solver task.
/// In each iteration it generates opCount neighbors using the following operators:
/// - Add
/// - Delete
/// - Transfer
/// - Swap
/// (for explanations see the Schedule class)
/// Then it uses a LocalSolver to pick the next state from the neighbors,
/// since each local solving algorithm uses a different method to determine the next state.
/// </summary>
/// <param name="taskID">The id of the task, used as index for the arrays</param>
/// <param name="best">The best schedule of this solver task</param>
private void SolveOne(int taskID, ref ScheduleResult best)
{
// Initialize variables
Schedule start = new Schedule(orders);
int i;
LocalSolver[] solvs;
int s;
// We first perform only the addition of orders to an empty schedule
// This way we end up with filled in schedule that,
// depending on the LocalSolver used, can be quite optimised already
#region AddOperation
stati[taskID] = SolverStatus.Doing_Add;
// Initialize some LocalSolvers
solvs = new LocalSolver[]
{
new RandomHillClimbLocalSolver(start),
new SaLocalSolver(start, 0.6, 0.99999)
};
foreach (LocalSolver ls in solvs)
{
ls.Init();
}
s = 0; // Used to choose which LocalSolver is used to get the next state
bool stopAdd = false;
i = 0; int noChangeAdd = 0; // Iteration counters
while (!stopAdd)
{
LocalSolver solver = solvs[s];
double[] probs = new double[] { 7 / 8.0, 1 / 8.0, 0, 0 };
if (solver.GetNext(probs, OperationCount)) //Add, Delete, Transfer, Swap
{
// The LocalSolver accepted a new state
noChangeAdd = 0;
// Check if next state is better than current best:
if (solver.schedule.Score < best.Score)
{
best = solver.schedule.ToResult();
}
}
else
{
noChangeAdd++;
}
if (i % OptimizeInterval == 0)
{
for (int opt = 0; opt < OptimizeIterations; opt++)
{
solver.schedule.OptimizeAllDays();
}
}
if (i % UpdateIterationStatusInverval == 0)
{
iterationCounters[taskID] = i;
}
if (i % SwitchSearchAlgorithmInterval_AddPhase == 0)
{
s = 1 - s; // Used to switch LocalSolver
}
stopAdd =
noChangeAdd == MaxNoChange_AddPhase ||
++i == MaxIterations_AddPhase ||
UserInterrupt;
}
#endregion
// Once we have a filled in schedule it makes more sense to perform the other operators
// We generate opCount neighbors using the Add, Delete, Transfer (first delete than add) and Swap
// Since opCount does not have to be equal to 4 (we have four operators) we use a probability distribution.
// For each neighbor then with the given chance one of the operators in picked and used to generate a neigbor
// Once again there is also the possibility to choose the LocalSolver
// that picks the next state from the neighbors
#region AllOperations
stati[taskID] = SolverStatus.Doing_All;
// Initialize some LocalSolvers:
solvs = new LocalSolver[]
{
new RandomHillClimbLocalSolver(start),
new SaLocalSolver(start, 1, 0.99999)
};
foreach (LocalSolver ls in solvs)
{
ls.Init();
}
s = 1;
bool stop = false;
i = 0; int noChange = 0; // Iteration counters
while (!stop)
{
LocalSolver solv = solvs[s];
// Try-out probability distributions, goal -> make them dynamic and dependent on iteration count
//double[] probs = new double[] { 1, 0, 0, 0 }; // Add only
//double[] probs = new double[] { 0, 0, 0, 1 }; // Swap only
//double[] probs = new double[] { 2 / 12.0, 5 / 12.0, 5 / 12.0, 0 / 12.0 };
double[] probs = new double[] { 1 / 12.0, 1 / 12.0, 5 / 12.0, 5 / 12.0 };
if (solv.GetNext(probs, OperationCount)) //Add, Delete, Transfer, Swap
{
// Solver accepted new state
noChange = 0;
// Check if next state is better than current best:
if (solv.schedule.Score < best.Score)
{
best = solv.schedule.ToResult();
}
}
else
{
noChange++;
}
if (i % OptimizeInterval == 0)
{
for (int opt = 0; opt < OptimizeInterval; opt++)
{
solv.schedule.OptimizeAllDays();
}
}
if (i % UpdateIterationStatusInverval == 0)
{
iterationCounters[taskID] = i;
}
//if (i % SwitchSearchAlgorithmInterval_AllPhase == 0) s = 1 - s; // Used to switch LocalSolver
stop = noChange == MaxNoChange_AllPhase ||
++i == MaxIterations_AllPhase ||
UserInterrupt;
}
#endregion
// Solver done, update status accordingly:
stati[taskID] = SolverStatus.Done;
}
