Многопоточность - исследование длительности квантов времени

В развлекательных целях разработал программу для измерения длительности квантов времени. В программе необходимо указать количество запускаемых потоков, а в диспетчере задач выполнить привязку процесса к одному ядру. Затем нажать кнопку "Запустить потоки на 5 секунд".

Код метода TCalcQuantThread.Execute:



Ссылка на архив с программой (исходники + исполняемый файл):


Вот такие выводы у меня получились:
1) привязка потока к ядру процессора не является постоянной. Это хорошо видно, если запустить только один поток и не привязывать его к ядру в диспетчере задач. При этом часто оказываются загружены несколько ядер (суммарная загрузка не более 100%).
2) ОС старается распределить загрузку по всем доступным ядрам. Если запущены 4 вычислительных потока, то ОС распределит нагрузку по 4-м ядрам (у меня 4-ядерный процессор без гипертрединга).
3) если за одном ядре запущен только один такой поток (вычислительный), то определить длительность кванта времени не удаётся. Предполагаю, что поток отработал свой квант (предположим 50 мс), затем ОС его усыпила, но поскольку нет других потоков, которым нужен процессор, ОС тут же его пробуждает.
4) квант времени - не такая уж маленькая величина. Типичная длительность кванта времена на моём ноутбуке с Intel Core i3 (поколение не знаю) составляет 95мс. Подчеркну - именно для потоков, выполняющих тяжёлые вычислительные задачи (т.е. грузят процессор на 100% и сами по своей воле не засыпают).
5) если запускать потоки с максимальным приоритетом на одном ядре, то происходит их последовательное выполнение. Т.е. если мы создадим 10 потоков с максимальным приоритетом на одном ядре, то будем ждать их завершения 50 сек (примерно так, но тут я недостаточно исследовал :)
6) с помощью функции GetTickCount невозможно решить данную задачу (пытался с ней вначале), т.к. она начинает возвращать новое значение лишь спустя 16 мс. Такая у неё разрешающая способность. А у функции QueryPerformanceCounter точность гораздо выше: менее 1 микросекунды.


Разработанный пример может оказаться полезен начинающим программистам, изучающим тему многопоточности.
Особенности программы следующие:
1) За уничтожение объекта потока отвечает форма TForm1. Объект потока не уничтожается автоматически при завершении работы метода Execute. При завершении работы потока выставляется поле "IsFinish := True", которое анализируется в событии таймера "TForm1.Timer1Timer".
2) Программа может создать любое количество потоков, которое укажет пользователь (в разумных пределах). Каждому потоку назначается порядковый номер, который передаётся при создании объекта потока с помощью конструктора "TCalcQuantThread.Create"
3) Для хранения ссылок на созданные объекты потоков используется список FList: TList.
4) При срабатывании таймера осужествляется обход списка FList в обратном порядке и для всех потоков, у которых выставлено IsFinish=True, осуществляется вывод собранной информации в компонент Memo1: TMemo, после чего объект потока уничтожается (T.Free), а соответствующий ему элемент удаляется из списка FList.
5) В том случае, если пользователь решил закрыть программу раньше, чем окончатся 5 секунд, в событии TForm1.FormDestroy произойдёт обход списка FList и для каждого объекта потока последовательно будет вызван метод Free. Посколько все потоки выполняются 5 секунд и заканчиваются почти в одно время, то вызов метода Free займет время только для самого первого элемента списка FList. Остальные вызовы Free выполнятся моментально, т.к. к этому времени все потоки уже завершат свою работу.

Я тоже ожидал примерно такого значения. А по факту чаще 95 мс наблюдаю :)