using System;

using System.Timers;

using System.Threading;

using System.Collections.Generic;

using System.Threading.Tasks;

​

​

// TASK:

// Change the Scheduler class such that it will ensure that SchedulerTask.Calculate() is executed regularly for each SchedulerTask

// with an interval that is as close as possible to the ScheulderTask.Interval.

//

// The accuracy of actual execution intervals should degrade gracefully when a large number of tasks is specified.

// Try to avoid 100% total CPU utilization (i.e. not all CPU cores should be at 100% all the time).

//

// you can assume:

//  - 8 CPU cores are available

//  - SchedulerTask.Calculate() takes up near 100% CPU utilization of a single core for the duration of the function call

​

public sealed class SchedulerTask

{ // this class should not be changed

    public TimeSpan Interval { get; }

​

    public SchedulerTask()

    {

        this.Interval = TimeSpan.FromSeconds(Random.Shared.Next(1, 30)); // run every 1 to 30 seconds

    }

​

    public void Calculate()

    {

        Console.WriteLine(this.Interval);

        var startTime = DateTime.UtcNow;

        var endTime = startTime + TimeSpan.FromMilliseconds(Random.Shared.Next(500, 1500)); // run for at least 0.5, max 1.5 seconds

        while (DateTime.UtcNow < endTime); // keep busy

    }

}

​

public class Scheduler

{   

    private Executor Executor;

​

    private Interval Interval;

    private List<SchedulerTask> Tasks;

    public Scheduler(List<SchedulerTask> tasks)

    {

        this.Tasks = tasks;

        this.Executor = new Executor();

​

        this.Interval = new Interval(this.Executor);

    }

    public Task Run()

    {   

        CancellationToken token = new CancellationToken();

        foreach (SchedulerTask task in this.Tasks)

        {

            this.Interval.Add(task.Interval, task.Calculate);

        }

        this.Interval.Run();

        return this.Executor.Run(token);

    }

}

​

public class Interval

{

    private Executor Executor;

​

    private List<System.Timers.Timer> Timers;

​

    public Interval(Executor executor)

    {

        this.Executor = executor;

        this.Timers = new List<System.Timers.Timer>();

    }

​

    public void Add(TimeSpan timeSpan, Action action)

    {       

        System.Timers.Timer timer = new System.Timers.Timer(timeSpan.TotalMilliseconds);

​

        timer.AutoReset = true;

        timer.Elapsed += (Object source, ElapsedEventArgs e) =>

        {

            this.Executor.Add(action);

        };

        this.Timers.Add(timer);

    }

    public void Run()

    {

        foreach (System.Timers.Timer timer in this.Timers)

        {

            timer.Enabled = true;

        }

    }

}

​

public class Executor

{

    private static int BatchSize = 8;

    private Queue<Action> Queue;

    public Executor()

    {

        this.Queue = new Queue<Action>();

    }

    public void Add(Action fn)

    {

        this.Queue.Enqueue(fn);

    }

    public async Task Run(CancellationToken cancellationToken)

    {

        while (true)

        {

            await this.RunBatch(cancellationToken);

        }

    }

    private async Task RunBatch(CancellationToken cancellationToken)

    {

        if (this.Queue.Count == 0)

        {

            await Task.Delay(50, cancellationToken);

        }

        List<Task> tasks = new List<Task>();

        for (int i = 0; i < Executor.BatchSize && this.Queue.Count > 0; i++) 

        {

            Action action = this.Queue.Dequeue();

            tasks.Add(Task.Run(action));

        }

        await Task.WhenAll(tasks.ToArray());

    }

}

​

public class Program

{

    public async static Task Main()

    {

        List<SchedulerTask> tasks = new List<SchedulerTask>();

        tasks.Add(new SchedulerTask());

        tasks.Add(new SchedulerTask());

        tasks.Add(new SchedulerTask());

        Scheduler scheduler = new Scheduler(tasks);

        await scheduler.Run();

    }

}