static TimeSpan WorkingTime(IExamSystem system, int numberOfMoves, int numberOfThreads, int numberOfStudents = 1000, int numberOfCourses = 5)
{
int numberOfMovesForThread = numberOfMoves / numberOfThreads;
List <Thread> threads = new List <Thread>(numberOfThreads);
for (int i = 0; i < numberOfThreads; ++i)
{
threads.Add(new Thread(() => WorkIteration(system, numberOfMovesForThread, numberOfStudents, numberOfCourses)));
}
DateTime startTime = DateTime.Now;
foreach (var t in threads)
{
t.Start();
}
foreach (var t in threads)
{
t.Join();
}
return(DateTime.Now - startTime);
}
static async Task QueryStudents([NotNull] IExamSystem system, StudentDataRange range) => await Task.Run(() =>
{
for (long studentId = range.FromStudentId; studentId < range.ToStudentId; studentId += 1)
{
for (long courseId = range.FromCourseId; courseId < range.ToCourseId; courseId += 1)
{
system.Contains(studentId, courseId);
}
}
});
static async Task <ProfileResult> EmulateWork([NotNull] IExamSystem system, int scale)
{
int readActionsNumber = 90 * scale;
int addActionsNumber = 9 * scale;
int removeActionsNumber = 1 * scale;
var readActions = RepeatOperation(
(studentId, courseId) => system.Contains(studentId, courseId),
readActionsNumber
);
var addActions = RepeatOperation(system.Add, addActionsNumber);
var removeActions = RepeatOperation(system.Remove, removeActionsNumber);
return(new ProfileResult(
addRequests: await addActions,
removeRequests: await removeActions,
containsRequests: await readActions
));
}
private void MakeRequests(object parameter)
{
if (parameter as IExamSystem == null)
{
throw new ArgumentException("Invalid argument\n");
}
IExamSystem examSystem = (IExamSystem)parameter;
for (int i = 0; i < 1024; i++)
{
int studentID = Math.Abs(Guid.NewGuid().GetHashCode());
int courseID = Math.Abs(Guid.NewGuid().GetHashCode());
examSystem.Add(studentID, courseID);
Assert.IsTrue(examSystem.Contains(studentID, courseID));
examSystem.Remove(studentID, courseID);
Assert.IsFalse(examSystem.Contains(studentID, courseID));
}
}
static void WorkIteration(IExamSystem system, int numberOfMoves, int numberOfStudents, int numberOfCourses)
{
int numberOfCotainsMoves = Convert.ToInt32(0.9 * numberOfMoves);
int numberOfAdditions = Convert.ToInt32(0.09 * numberOfMoves);
int numberOfDeletions = Convert.ToInt32(0.01 * numberOfMoves);
Random random = new Random(DateTime.Now.Millisecond);
for (int i = 0; i < numberOfAdditions; i++)
{
system.Add(random.Next(numberOfMoves), random.Next(numberOfCourses));
}
for (int i = 0; i < numberOfCotainsMoves; i++)
{
system.Contains(random.Next(numberOfMoves), random.Next(numberOfCourses));
}
for (int i = 0; i < numberOfDeletions; i++)
{
system.Remove(random.Next(numberOfMoves), random.Next(numberOfCourses));
}
}
static void Main(string[] args)
{
Console.WriteLine("Working time tests for ExamSystem using variously multithreaded" +
" synchronized data structures started...\n");
examSystem = new LockFreeListHashTable(256);
TasksInitialize(65536);
Console.Write($"ExamSystem work time using LockFreeListHashTable: ");
double resultLFLHT = WorkingTimeTest();
Console.WriteLine(resultLFLHT + " ms.\n");
examSystem = new StripedHashTable(256);
TasksInitialize(65536);
Console.Write($"ExamSystem work time using StripedHashTable: ");
double resultSHT = WorkingTimeTest();
Console.WriteLine(resultSHT + " ms.\n");
if (resultLFLHT > resultSHT)
{
Console.WriteLine($"ExamSystem using LockFreeListHashTable works {resultLFLHT - resultSHT} ms." +
$" faster then ExamSystem using StripedHashTable");
}
else if (resultLFLHT < resultSHT)
{
Console.WriteLine($"ExamSystem using StripedHashTable works {resultSHT - resultLFLHT} ms." +
$" faster then ExamSystem using LockFreeListHashTable");
}
else
{
Console.WriteLine($"ExamSystem using LockFreeListHashTable works the same time" +
$" with ExamSystem using StripedHashTable");
}
Console.ReadKey();
}
