public async Task StressTaskScheduling()
{
var logger = new CountTasksLogger();
var taskScheduler = new MultiThreadTaskScheduler(logger);
taskScheduler.SetSchedulingOptions(new MultiThreadSchedulingSettings
{
Mode = MultiThreadCreationMode.OneThreadPerCpuCore,
ThreadPriority = System.Threading.ThreadPriority.BelowNormal
});
var numThreads = taskScheduler.SchedulingOptions.NumberOfThreads;
var tasks = new Task[numThreads * 50];
int overflowCount = 0;
// Deliberately make the work unbalanced
int GetNumChildTasks(int i) => 1000 + (i * 800) / numThreads;
int totalChildTasks = Enumerable.Range(0, tasks.Length).Select(GetNumChildTasks).Sum();
for (int i = 0; i < tasks.Length; ++i)
{
var iCopy = i;
// This task goes to the global queue
tasks[i] = TaskExtensions.Unwrap(Task.Factory.StartNew(async() =>
{
var subtasks = new Task <(int, int)> [GetNumChildTasks(iCopy)];
public async Task LocallyQueuedTasks()
{
var logger = new CountTasksLogger();
var taskScheduler = new MultiThreadTaskScheduler(logger);
taskScheduler.SetSchedulingOptions(new MultiThreadSchedulingSettings
{
NumberOfThreads = 4,
ThreadPriority = System.Threading.ThreadPriority.BelowNormal
});
var tasks = new Task[6];
int stolenTasksCount = 0;
const int numChildTasks = 50;
for (int i = 0; i < tasks.Length; ++i)
{
var iCopy = i;
tasks[i] = TaskExtensions.Unwrap(Task.Factory.StartNew(async() =>
{
var random = new Random();
var subtasks = new Task[numChildTasks];
var threadId = Environment.CurrentManagedThreadId;
for (int j = 0; j < subtasks.Length; ++j)
{
var jCopy = j;
var delayMs = random.Next(10, 80);
// This child task goes to the local queue
subtasks[j] = Task.Factory.StartNew(() =>
{
if (Environment.CurrentManagedThreadId != threadId)
{
Interlocked.Increment(ref stolenTasksCount);
}
// Pretend to be doing work.
Thread.Sleep(delayMs);
return(iCopy, jCopy);
});
}
await Task.WhenAll(subtasks);
}, CancellationToken.None, TaskCreationOptions.None, taskScheduler));
}
await Task.WhenAll(tasks);
Assert.Equal(stolenTasksCount, logger.StolenTasksCount);
Assert.Equal(tasks.Length, logger.GlobalTasksCount);
Assert.Equal(tasks.Length * numChildTasks - stolenTasksCount, logger.LocalTasksCount);
await taskScheduler.DisposeAsync();
}
public async Task TaskInterruption()
{
MultiThreadTaskScheduler taskScheduler = new MultiThreadTaskScheduler(14);
bool afterDelay = false;
await Task.Factory.StartNew(async() =>
{
await Task.Delay(100);
afterDelay = true;
},
new CancellationToken(),
TaskCreationOptions.DenyChildAttach,
taskScheduler);
taskScheduler.Dispose();
await Task.Delay(200);
Assert.False(afterDelay);
}
public async Task GloballyQueuedTasks()
{
var logger = new CountTasksLogger();
var taskScheduler = new MultiThreadTaskScheduler(logger);
taskScheduler.SetSchedulingOptions(new MultiThreadSchedulingSettings
{
NumberOfThreads = 4,
ThreadPriority = System.Threading.ThreadPriority.BelowNormal
});
var random = new Random();
var subtasks = new Task <int> [300];
for (int i = 0; i < subtasks.Length; ++i)
{
var delayMs = random.Next(10, 80);
int iCopy = i; // freeze for lambda capture
subtasks[i] = Task.Factory.StartNew(() =>
{
// Pretend to be doing work.
Thread.Sleep(delayMs);
return(iCopy);
}, CancellationToken.None, TaskCreationOptions.None, taskScheduler);
}
await Task.WhenAll(subtasks);
for (int i = 0; i < subtasks.Length; ++i)
{
Assert.Equal(i, subtasks[i].Result);
}
Assert.Equal(subtasks.Length, logger.GlobalTasksCount);
await taskScheduler.DisposeAsync();
Assert.InRange(logger.WorkersCount, 1, taskScheduler.SchedulingOptions.NumberOfThreads);
Assert.Equal(logger.WorkersStopped, logger.WorkersCount);
}
public async Task TaskExecution()
{
MultiThreadTaskScheduler taskScheduler = new MultiThreadTaskScheduler(1);
int threadId1 = -1;
int threadId2 = -1;
int threadId3 = -1;
await await Task.Factory.StartNew(async() =>
{
threadId1 = Thread.CurrentThread.ManagedThreadId;
await Task.Delay(10);
threadId2 = Thread.CurrentThread.ManagedThreadId;
await Task.Delay(10);
threadId3 = Thread.CurrentThread.ManagedThreadId;
},
new CancellationToken(),
TaskCreationOptions.DenyChildAttach,
taskScheduler);
Assert.Equal(threadId1, threadId2);
Assert.Equal(threadId2, threadId3);
}
public RabbitMQDriver(string connectionString)
{
Dictionary <string, string> settings = connectionString.ParseConnStr();
//creates the connection
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.HostName = settings["Host"];
connectionFactory.VirtualHost = settings["VHost"];
connectionFactory.Port = int.Parse(settings["Port"]);
connectionFactory.UserName = settings["User"];
connectionFactory.Password = settings["Password"];
connectionFactory.AutomaticRecoveryEnabled = true;
_connection = connectionFactory.CreateConnection();
//creates channels
_requestChannel = _connection.CreateModel();
_notifyChannel = _connection.CreateModel();
_responderChannel = _connection.CreateModel();
_responderChannel.BasicQos(0, RESPONDER_PREFETCHCOUNT, false);
_eventHandlerChannel = _connection.CreateModel();
_eventHandlerChannel.BasicQos(0, EVENT_HANDLER_PREFETCHCOUNT, false);
_deadLetterQueueChannel = _connection.CreateModel();
//application identifier
_appId = settings["AppId"];
//builder for container
Injection = new ServiceCollection();
//response queue
_responseQueue = new MessageGroupQueue(REQUEST_TIMEOUT);
//response listener
EventingBasicConsumer consumer = new EventingBasicConsumer(_requestChannel);
consumer.Received += (obj, args) =>
{
_responseQueue.AddMessage(Encoding.UTF8.GetString(args.Body.ToArray()), args.BasicProperties.CorrelationId);
};
_requestChannel.BasicConsume(DIRECT_REPLY_QUEUE, true, consumer);
//dependency injection container
_serviceProvider = null;
//list of to activate consumers
_toActivateConsumers = new List <Tuple <IModel, string, EventingBasicConsumer> >();
//custom task schedulers
_sendTaskScheduler = new MultiThreadTaskScheduler(SEND_NUMBER_OF_THREADS);
_receiveTaskScheduler = new MultiThreadTaskScheduler(RECEIVE_NUMBER_OF_THREADS);
_deadLetterQueueTaskScheduler = new MultiThreadTaskScheduler(DEAD_LETTER_QUEUE_NUMBER_OF_THREADS);
//cancellation token
_cancellationTokenSource = new CancellationTokenSource();
//default logger
_loggerType = typeof(DefaultLogger);
//default tracer
_tracerType = typeof(DefaultTracer);
//json converter
_jsonConverter = new JsonConverter();
//cache handler
_cacheHandler = new CacheHandler(CACHE_LIMIT, CACHE_DURATION);
}
public Logger()
{
_taskScheduler = new MultiThreadTaskScheduler(NUMBER_OF_THREADS);
_cancellationTokenSource = new CancellationTokenSource();
_cancellationToken = _cancellationTokenSource.Token;
}
