Олег Цилюрик - QNX/UNIX: Анатомия параллелизма

Сутью спорадической диспетчеризации в QNX является установка для соответствующего потока двух значений приоритета: основного (normal) и фонового (foreground). В момент запуска потока, подчиняющегося спорадической диспетчеризации (момент времени 0), поток имеет запас времени (С), называемый начальным бюджетом(initial budget) потока, в течение которого поток выполняется со своим основным приоритетом (N). Когда же запас времени исчерпывается, его приоритет понижается до уровня фонового (L). Через некоторый период времени T происходит пополнение(replenishment) запаса времени потока до значения начального бюджета, и он снова может выполняться с основным приоритетом.

Рассмотрим порядок выполнения такого потока подробнее. В начальный момент времени после запуска поток имеет приоритет N и время С для выполнения с этим приоритетом. Если поток блокируется на время R, то запас времени все равно расходуется и пополнение этого запаса может произойти только через период T после начала выполнения потока. Если же поток вытесняется более приоритетным, то расход его запаса времени прекращается. Когда управление возвращается к потоку, он вновь начинает тратить оставшееся количество времени на основном приоритете. Однако с момента повторного начала выполнения потока начинается отсчет нового периода до момента пополнения.

На рис. 2.6 проиллюстрирована работа спорадического потока. После запуска (момент времени 0) поток переходит в блокированное состояние на время R (10 мс), но его бюджет все равно расходуется. Поток становится активным, но через 3 мс (13 мс от начала выполнения) вытесняется более приоритетным потоком. Факт вытеснения означает, что через период пополнения T (40 мс) бюджет потока будет пополнен на израсходованную величину (13 мс). Еще через 3 мс более приоритетный поток заканчивает свою работу и управление возвращается назад. От начального бюджета потока С (20 мс) осталось еще 7 мс, и поток выполняется это время с основным приоритетом. При этом от повторного начала его выполнения (16 мс) отсчитывается новый период пополнения, то есть через 56 мс бюджет потока будет пополнен на 7 мс. После полного исчерпания бюджета приоритет потока понижается до фонового (L) и поток может вытесняться или нет в зависимости от приоритетов остальных потоков в системе. После наступления очередного времени пополнения бюджет потока восстанавливается на израсходованную в этом периоде величину и т.д.

Рис. 2.6. Периодическое выполнение спорадической задачи

Если поток много раз вытесняется в период своей работы с основным приоритетом, то его выполнение может превратиться в многократное колебание с высокой частотой между основным и фоновым приоритетами. Поэтому в QNX 6.2.1 в параметрах для спорадической диспетчеризации можно установить (ограничить) максимальное количество пополнений бюджета за период.

Как уже описывалось выше, структура shed_paramсодержит в своем составе, в частности, еще и структуру параметров для спорадической диспетчеризации (при других типах диспетчеризации эта часть не используется):

struct {

_INT32 __ss_low_priority;

_INT32 __ss_max_repl;

struct timespec __ss_repl_period;

struct timespec __ss_init_budget;

} __ss;

где low_priority— фоновый приоритет; max_repl— максимальное количество пополнений бюджета за период; repl_period— период пополнения бюджета и init_budget — начальный бюджет.

Выполним «симметричный» тест аналогично тому, как это делалось для переключения контекстов процессов (стр. 44), но теперь применительно к потокам ( файл p5t.cc ). При этом мы постараемся максимально сохранить принципы функционирования, имевшие место в приложении «Затраты на взаимное переключение процессов» ( файл p5.сс ) (естественно, из-за принципиального различия механизмов тексты кодов будут существенно отличаться).

#include

#include

#include

#include

#include

#include

#include

#include

unsigned long N = 1000;

// потоковая функция:

void* threadfunc(void* data) {

uint64_t t = ClockCycles();

for (unsigned long i = 0; i < N; i++) sched_yield();

t = ClockCycles() - t;

// дать спокойно завершиться 2-му потоку до начала вывода

delay(100);

cout << pthread_self() << "\t: cycles - " << t

<< ", on sched - " << (t / N) / 2 << endl;

return NULL;

}

int main(int argc, char* argv[]) {

int opt, val;

while ((opt = getopt(argc, argv, "n:")) != -1) {

switch(opt) {

case 'n': // переопределения числа переключений

if (sscanf(optarg, "%i", &val) != 1)

cout << "parse command line error" << endl, exit(EXIT_FAILURE);

if (val > 0) N = val;

break;

default:

exit(EXIT_FAILURE);

}

}

const int T = 2;

pthread_t tid[T];

// создать взаимодействующие потоки

for (int i = 0; i < T; i++)

if (pthread_create(tid + i, NULL, threadfunc, NULL) != EOK)

cout << "thread create error", exit(EXIT_FAILURE);

// и дожидаться их завершения ...

for (int i = 0; i < T; i++)

pthread_join(tid[i], NULL);

exit(EXIT_SUCCESS);

}

Результаты выполнения программы:

# nice -n-19 p5t -n100

2 : cycles - 79490; on sched - 397

3 : cycles - 78350; on sched — 391

# nice -n-19 p5t -n1000

2 : cycles - 753269; on sched - 376

3 : cycles - 752069; on sched - 376

# nice -n-19 p5t -n10000

2 : cycles - 7494255; on sched - 374

3 : cycles - 7493225; on sched - 374

# nice -n-19 p5t -n100000

2 : cycles - 74897795; on sched - 374

3 : cycles - 74895800; on sched — 374

# nice -n-19 p5t -n1000000

2 : cycles - 748850811, on sched - 374

3 : cycles - 748850432; on sched - 374

Как и в случае с процессами, результаты отличаются очень высокой устойчивостью при изменении «объема вычислений» на 4 порядка, однако по своим величинам значения для потоков почти в 2 раза меньше, чем для процессов (стр. 45).

Как и в случае обсуждавшегося ранее завершения процесса, для потоков мы будем отчетливо различать случаи:

• «естественного» завершения выполнения потока из кода самого потока;

• завершения потока извне, из кода другого потока или по сигналу. Для этого действия, в отличие от «естественного» завершения, будем использовать другой термин — отмена.

Завершение потока происходит при достижении функцией потока своего естественного конца и выполнения оператора return(явно или неявно) или выполнения потоком вызова:

void pthread_exit(void* value_ptr)

где value_ptr— указатель на результат выполнения потока.

При выполнении pthread_exit()поток завершается. Если этот поток принадлежит к категории ожидаемых, он может возвратить результат своей работы другому потоку, ожидающему его завершения на вызове pthread_join()(только один поток может получить результат завершения). Если же этот поток отсоединенный, то по его завершении все системные ресурсы, задействованные потоком, освобождаются немедленно.