public void AsyncTask_Should_Run_Actions_In_Created_RoundRobinPool_With_GivenSize2()
{
var waitHandle = new CountdownEvent(5);
Func <int> runTask = () => {
waitHandle.Signal();
return(Thread.CurrentThread.ManagedThreadId);
};
int poolSize = 2;
int threadId1 = 0, threadId2 = 0, threadId3 = 0, threadId4 = 0, threadId5 = 0;
lock (_lock)
{
var pool = new RoundRobinPool(poolSize);
AsyncTasks.AddPool("testPool5", pool);
}
AsyncTasks.Run(() => { threadId1 = runTask(); }, "testPool5");
AsyncTasks.Run(() => { threadId2 = runTask(); }, "testPool5");
AsyncTasks.Run(() => { threadId3 = runTask(); }, "testPool5");
AsyncTasks.Run(() => { threadId4 = runTask(); }, "testPool5");
AsyncTasks.Run(() => { threadId5 = runTask(); }, "testPool5");
waitHandle.Wait();
AsyncTasks.RemoveAll();
Assert.AreEqual(threadId1, threadId3);
Assert.AreEqual(threadId1, threadId5);
Assert.AreEqual(threadId2, threadId2);
Assert.AreNotEqual(threadId1, threadId2);
}
public void Should_Be_Able_To_Configure_Default_Task_Pool_With_Default_Size()
{
var threadIds = new ConcurrentBag <int>();
var waitHandle = new CountdownEvent(10);
Action runTask = () => {
Thread.Sleep(1000);
threadIds.Add(Thread.CurrentThread.ManagedThreadId);
waitHandle.Signal();
};
lock (_lock)
{
AsyncTasks.UseDefaultPool();
AsyncTasks.AddPool("testPool");
}
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
waitHandle.Wait();
AsyncTasks.RemoveAll();
Assert.AreEqual(Environment.ProcessorCount, threadIds.Distinct().Count());
}
public void Actions_Should_Be_Enqueued_In_RoundRobin_Manner()
{
var waitHandle = new CountdownEvent(5);
Func <int> runTask = () => {
waitHandle.Signal();
return(Thread.CurrentThread.ManagedThreadId);
};
int poolSize = 2;
int threadId1 = 0, threadId2 = 0, threadId3 = 0, threadId4 = 0, threadId5 = 0;
lock (_lock)
{
AsyncTasks.UseRoundRobinPool();
AsyncTasks.AddPool("testPool4", poolSize);
}
AsyncTasks.Run(() => { threadId1 = runTask(); }, "testPool4");
AsyncTasks.Run(() => { threadId2 = runTask(); }, "testPool4");
AsyncTasks.Run(() => { threadId3 = runTask(); }, "testPool4");
AsyncTasks.Run(() => { threadId4 = runTask(); }, "testPool4");
AsyncTasks.Run(() => { threadId5 = runTask(); }, "testPool4");
waitHandle.Wait();
AsyncTasks.RemoveAll();
Assert.AreEqual(threadId1, threadId3);
Assert.AreEqual(threadId1, threadId5);
Assert.AreEqual(threadId2, threadId2);
Assert.AreNotEqual(threadId1, threadId2);
}
public void LoadAsync(Frame.IProgressBar owner, string tips, AsyncTasks tasks, Action onEnd = null)
{
Frame.Executer.SetProgressText(tips);
owner.Show();
Debug.Assert(false);
//owner.StartCoroutine(InnerLoadAsync(tasks, onEnd));
}
public void Should_Be_Able_To_Configure_Roundrobin_Taskpool_With_A_Given_Size()
{
var waitHandle = new CountdownEvent(5);
Func <int> runTask = () => {
waitHandle.Signal();
return(Thread.CurrentThread.ManagedThreadId);
};
int poolSize = 3;
int threadId1 = 0, threadId2 = 0, threadId3 = 0, threadId4 = 0, threadId5 = 0;
lock (_lock)
{
AsyncTasks.UseRoundRobinPool();
AsyncTasks.AddPool("testPool4", poolSize);
}
AsyncTasks.Run(() => { threadId1 = runTask(); }, "testPool4");
AsyncTasks.Run(() => { threadId2 = runTask(); }, "testPool4");
AsyncTasks.Run(() => { threadId3 = runTask(); }, "testPool4");
AsyncTasks.Run(() => { threadId4 = runTask(); }, "testPool4");
AsyncTasks.Run(() => { threadId5 = runTask(); }, "testPool4");
waitHandle.Wait();
AsyncTasks.RemoveAll();
Assert.AreEqual(threadId1, threadId4);
Assert.AreEqual(threadId2, threadId5);
Assert.AreNotEqual(threadId1, threadId2);
Assert.AreNotEqual(threadId1, threadId3);
}
public override Task SubmitDownload(MusicItem track)
{
// does intentionally not await completion of download
var t = DownloadAsync(track);
return(AsyncTasks.Noop());
}
public void Should_Be_Able_To_Enqueue_Action_In_Configured_Taskpool()
{
var isActionExcecuted = new ConcurrentBag <bool>();
var waitHandle = new CountdownEvent(10);
Action runTask = () => {
Thread.Sleep(1000);
isActionExcecuted.Add(true);
waitHandle.Signal();
};
lock (_lock)
{
AsyncTasks.UseDefaultPool();
AsyncTasks.AddPool("testPool");
}
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
AsyncTasks.Run(runTask, "testPool");
waitHandle.Wait();
AsyncTasks.RemoveAll();
var expected = 10;
Assert.AreEqual(expected, isActionExcecuted.Count);
}
public void Should_Be_Able_To_Configure_Default_Taskpool_With_Specific_Size()
{
var threadIds = new ConcurrentBag <int>();
var waitHandle = new CountdownEvent(4);
Action runTask = () => {
Thread.Sleep(1000);
threadIds.Add(Thread.CurrentThread.ManagedThreadId);
waitHandle.Signal();
};
int poolSize = 2;
lock (_lock)
{
AsyncTasks.UseDefaultPool();
AsyncTasks.AddPool("testPool1", poolSize);
}
AsyncTasks.Run(runTask, "testPool1");
AsyncTasks.Run(runTask, "testPool1");
AsyncTasks.Run(runTask, "testPool1");
AsyncTasks.Run(runTask, "testPool1");
waitHandle.Wait();
AsyncTasks.RemoveAll();
Assert.AreEqual(poolSize, threadIds.Distinct().Count());
}
private async Task DisablePush(PushClient helper, Uri uri)
{
LoadingText = "Disabling...";
await Utils.SuppressAsync <TimeoutException>(async() => {
await AsyncTasks.Within2(helper.Deregister(uri), TimeSpan.FromSeconds(5));
});
}
public void Should_Be_Able_To_Enqueue_Actions_Without_Configuring_Taskpool_And_Name()
{
var threadIds = new ConcurrentBag <int>();
var waitHandle = new CountdownEvent(10);
Action runTask = () => {
Thread.Sleep(1000);
threadIds.Add(Thread.CurrentThread.ManagedThreadId);
waitHandle.Signal();
};
AsyncTasks.Run(runTask);
AsyncTasks.Run(runTask);
AsyncTasks.Run(runTask);
AsyncTasks.Run(runTask);
AsyncTasks.Run(runTask);
AsyncTasks.Run(runTask);
AsyncTasks.Run(runTask);
AsyncTasks.Run(runTask);
AsyncTasks.Run(runTask);
AsyncTasks.Run(runTask);
waitHandle.Wait();
AsyncTasks.RemoveAll();
Assert.AreEqual(Environment.ProcessorCount, threadIds.Distinct().Count());
}
public void Should_Be_Able_To_Enqueue_Actions_From_Multiple_Threads()
{
var threadIds = new ConcurrentBag <int>();
var waitHandle = new CountdownEvent(4);
Action runTask = () => {
Thread.Sleep(1000);
threadIds.Add(Thread.CurrentThread.ManagedThreadId);
waitHandle.Signal();
};
AsyncTasks.AddPool("testPool7", 2);
Parallel.Invoke(
() => {
AsyncTasks.Run(runTask, "testPool7");
},
() => {
AsyncTasks.AddPool("testPool8", 1);
AsyncTasks.Run(runTask, "testPool8");
},
() => {
AsyncTasks.Run(runTask, "testPool7");
},
() => {
AsyncTasks.AddPool("testPool9", 1);
AsyncTasks.Run(runTask, "testPool9");
}
);
waitHandle.Wait();
AsyncTasks.RemoveAll();
Assert.AreEqual(4, threadIds.Distinct().Count());
}
private async Task TryEnablePush(PushClient helper, Uri uri, bool silent = false)
{
if (!silent)
{
LoadingText = "Enabling...";
}
await AsyncTasks.Within2(helper.Register(uri), TimeSpan.FromSeconds(10));
}
public override Task Send(string content)
{
if (IsConnected && ws.State == WebSocketState.Open)
{
ws.Send(content);
}
return(AsyncTasks.Noop());
}
private Task ProcessAndWriteLogAsync(ILog log)
{
AsyncTasks.Run(() =>
{
var sanitized = ApplyFilters(log);
WriteLogAsync(sanitized).GetAwaiter().GetResult();
}, "logging");
return(Task.CompletedTask);
}
public Task UninstallPlayer()
{
return(WebAware(async() => {
if (player != null)
{
player.Unsubscribe();
player.PlayerStateChanged -= p_PlayerStateChanged;
}
await AsyncTasks.Noop();
}));
}
public void AsyncTask_Default_Pool_Should_Execute_Action_In_FIFO_manner()
{
var threadIds = new ConcurrentBag <int>();
var waitHandle = new CountdownEvent(3);
DateTime dateTime1 = new DateTime(), dateTime2 = new DateTime(), dateTime3 = new DateTime(), dateTime4 = new DateTime();
Action runTask1 = () => {
Thread.Sleep(1000);
waitHandle.Signal();
dateTime1 = DateTime.Now;
};
Action runTask2 = () => {
Thread.Sleep(1000);
waitHandle.Signal();
dateTime2 = DateTime.Now;
};
Action runTask3 = () => {
Thread.Sleep(1000);
waitHandle.Signal();
dateTime3 = DateTime.Now;
};
int poolSize = 2;
lock (_lock)
{
AsyncTasks.UseDefaultPool();
AsyncTasks.AddPool("testPool10", poolSize);
}
Parallel.Invoke(
() => {
Thread.Sleep(500);
AsyncTasks.Run(runTask1, "testPool10");
},
() => {
AsyncTasks.Run(runTask2, "testPool10");
},
() => {
Thread.Sleep(200);
AsyncTasks.Run(runTask3, "testPool10");
}
);
waitHandle.Wait();
AsyncTasks.RemoveAll();
Assert.IsTrue(dateTime1 > dateTime2);
Assert.IsTrue(dateTime1 > dateTime3);
Assert.IsTrue(dateTime3 > dateTime2);
}
IEnumerator InnerLoadAsync(AsyncTasks tasks, Action onEnd = null)
{
Frame.Helper.BeginWatch("LoadAsync");
int len = 0;
for (int i = 0; i < tasks.Count; ++i)
{
try {
var task = tasks[i];
task.CalcTargetCount();
len += task.targetCount;
} catch (System.Exception ex) {
Debug.LogError(ex.Message);
}
}
Debug.Log("Load AB Count: " + len.ToString());
int cursor = 0;
for (int i = 0; i < tasks.Count; ++i)
{
var task = tasks[i];
for (int j = 0; j < task.targetCount; ++j)
{
task.DoStep(j);
cursor++;
Frame.Executer.SetProgress(cursor, len);
yield return(0);
}
}
if (len == 0)
{
Frame.Executer.SetProgress(1, 1);
yield return(0);
}
if (onEnd != null)
{
onEnd();
}
Frame.Helper.EndWatch();
yield return(0);
Frame.Executer.HideProgressBar();
}
public void Update()
{
if (AsyncTasks.Count > 0)
{
int i = 0;
while (i++ < 2 && AsyncTasks.Count > 0)
{
AsyncTasks.Dequeue().Invoke();
}
}
Animator.Instance.Update();
Duel.Update();
foreach (var act in FrameActions)
{
act();
}
}
public async Task TaskTests()
{
Debug.WriteLine("Testing tasks...");
var winner = await AsyncTasks.FirstSuccessfulWithin(BuildTasks(), TimeSpan.FromMilliseconds(2000));
Assert.AreEqual("done sleeping", winner);
try {
string noWinners = await AsyncTasks.FirstSuccessfulWithin(BuildTasks(), TimeSpan.FromMilliseconds(200));
Debug.WriteLine(noWinners);
Assert.Fail("Expected timeout, got success.");
} catch (TimeoutException) {
}
try {
var noWinners = await AsyncTasks.FirstSuccessfulWithin(BuildTasks().Skip(2).ToList(), TimeSpan.FromMilliseconds(5000));
Assert.Fail("Expected failure, got success.");
} catch (NoResultsException) {
}
}
/// <summary>
/// Syncs cache data using sync action.
/// </summary>
private static void Async()
{
while (true)
{
while (PendingAsyncQueue.Count > 0)
{
var task = PendingAsyncQueue.Dequeue();
CacheAsyncTask actionTask;
if (AsyncTasks.TryGetValue(task.Key, out actionTask))
{
actionTask.SyncAction(task.Key, data =>
{
Add(task.Key, data, actionTask.DataExpires);
task.Callback(data);
});
}
}
Thread.Sleep(TimeSpan.FromSeconds(60));
}
}
public void Should_Be_Able_To_Configure_Roundrobin_Taskpool()
{
var waitHandle = new CountdownEvent(10);
Func <int> runTask = () => {
waitHandle.Signal();
return(Thread.CurrentThread.ManagedThreadId);
};
int threadId1 = 0, threadId2 = 0, threadId3 = 0, threadId4 = 0, threadId5 = 0;
int threadId6 = 0, threadId7 = 0, threadId8 = 0, threadId9 = 0, threadId10 = 0;
lock (_lock)
{
AsyncTasks.UseRoundRobinPool();
AsyncTasks.AddPool("testPool3");
}
AsyncTasks.Run(() => { threadId1 = runTask(); }, "testPool3");
AsyncTasks.Run(() => { threadId2 = runTask(); }, "testPool3");
AsyncTasks.Run(() => { threadId3 = runTask(); }, "testPool3");
AsyncTasks.Run(() => { threadId4 = runTask(); }, "testPool3");
AsyncTasks.Run(() => { threadId5 = runTask(); }, "testPool3");
AsyncTasks.Run(() => { threadId6 = runTask(); }, "testPool3");
AsyncTasks.Run(() => { threadId7 = runTask(); }, "testPool3");
AsyncTasks.Run(() => { threadId8 = runTask(); }, "testPool3");
AsyncTasks.Run(() => { threadId9 = runTask(); }, "testPool3");
AsyncTasks.Run(() => { threadId10 = runTask(); }, "testPool3");
waitHandle.Wait();
AsyncTasks.RemoveAll();
//Works only if Environment.ProcessorCount = 8
Assert.AreEqual(threadId1, threadId9);
Assert.AreEqual(threadId2, threadId10);
Assert.AreNotEqual(threadId1, threadId5);
Assert.AreNotEqual(threadId4, threadId8);
}
public override Task SetBackground(Uri uri)
{
RootPageViewModel.Instance.SetBackgroundUri(uri);
return(AsyncTasks.Noop());
}
public override Task Ping()
{
return(AsyncTasks.Noop());
}
public override Task Upload(MusicItem song, string resource, PimpSession destSession)
{
MessagingService.Instance.Send("Sorry, MusicBeaming is not supported with Subsonic as music source. The music source must be a MusicPimp server or your local device.");
return(AsyncTasks.Noop());
}
public void Timer(string name, ulong value)
{
AsyncTasks.Run(() => _meter.Timer(name, value), "metering");
}
public void Set(string name, string value)
{
AsyncTasks.Run(() => _meter.Set(name, value), "metering");
}
public void Meter(string name)
{
AsyncTasks.Run(() => _meter.Meter(name), "metering");
}
public void Gauge(string name, ulong value)
{
AsyncTasks.Run(() => _meter.Gauge(name, value), "metering");
}
public void Counter(string name, long value, double sampleRate)
{
AsyncTasks.Run(() => _meter.Counter(name, value, sampleRate), "metering");
}
public void Counter(string name, long value)
{
AsyncTasks.Run(() => _meter.Counter(name, value), "metering");
}
