Описание тега vdpau

Мас OS X позволяет выделить "много", хотя система может цеп отчаянно или быть просто штраф, в зависимости от того, как , что выделенная память используется любой последующий код. Я, наверное, должен был вводиться следующий код после того, как он выделил "много" чисел (по -М флаг), хотя это было время, так как я протестировал на Mac ОС Х.

/*
 # (АБ)использует память через выделение блока памяти, с учетом
 # количество рабочих потоков, а затем читать и писать значения в случайном порядке
 # в этом пространстве. Этот код был мотивирован тем, что во время
 # `на Perl -е '1 а 1' &` может работать до процессора, более вероятно, будет работать
 # в пределах вилки, чем узких мест процессора на современных многопроцессорных
 систем#. Этот код лучше упражнения системы. В основном, он предлагает
 # значит в болоте системы, предположительно для целей тестирования, гонки
 # разведочное состояние, или насолить местным сисадмином.
#
 # Лимиты системных ресурсов, возможно, должны быть скорректированы; см. логин.конф(5) на
 # В OpenBSD, например. Там также может быть в процессе ограничения. А
 # хороший способ болотники систему, чтобы запустить что-то вроде:
#
 # я В ...; делать ./usemem -М -Т ... & сделано
#
 # Где количество процессов для запуска и отсчета резьбы
 # подходит для числа процессоров или желаемого уровня маразма. Приурочен
 # команду killall(1) или удобный доступ к сбросу испытания системы должны быть организованы
 # для, учитывая, что слишком много экземпляров этой программы может вынести
 система # совсем неработоспособен--настольные системы Linux `vmstat с 1` записали
 # 12 миллионов переключений контекста в запись, предположительно через какое-то время
 # период дольше, чем второй, учитывая, как плохо, что система была
 # выполнении. Вскоре после этого, на экране замер, и система
 # должен быть выключен и снова (я все еще мог пинг поле).
#
 # Первоначальный замысел этот код, чтобы попытаться спровоцировать гонку
 # состояние на:
#
 # сигнализация(...);
 # somethingthatblocksforever();
 # сигнализация(0);
 # // -- записано со слов Стивенса, APUE (1-е издание), стр. 286.
#
 # когда система занята настолько, что произойдет истечении отправляет
 # перед somethingthatblocks() вызов может быть запущен, но после
 # сигнализация(...) установлено, что процесс блокирует навсегда.
 # Это, пожалуй, гораздо более вероятно, что система будет оказана
 # непригодным (и мониторинг заметили этого), чем ударить это маловероятно край
 дело№. Если система была чрезмерно занята или медленно, перезагрузка может
 # хорошо быть в порядке, как только практично. Это позволит устранить
 # possiblilty, что любой процесс застрял на какой-то редкий крайний случай
 # такие, как выше.
#
 Переносимость#: - М делает разумные вещи на OpenBSD; в Linux и Mac ОС
 # Х это идет вразрез с различным количеством глупость или маразм, что может
 # требуется-м -м верхняя граница`, чтобы установить максимально допустимое выделение.
 # Это поможет предотвратить убийца ООМ от палить или
 # ядра оптимистично пытается выделить 17,592,186,044,416 чисел
 # а потом как-то погрязнуть.
#
 # Используемые, чтобы попытаться realloc() массив вверх, если это возможно код,
 # хотя, что на Linux убегала убийца ООМ. С мертвых процессов
 # не намного налоговую систему, только сворачивает. Запуск больше
 # экземпляров этого скрипта использовать оставшуюся память.
#
 Подкачка # может быть вызвано запуска экземпляра, а затем отправить его
 # в прод сигнал, запуская несколько экземпляров? Нужно проверить это.
*/

#включить <заблуждаться.ч>
код #include <errno значение.ч>
#включить <флагов.ч>
#Включить <ограничения.ч>
код #include <pthread в.ч>
#включить <сигнал.ч>
код #include <stdbool.ч>
#включить заголовочный файл <stdio.ч>
#включить <stdlib.ч>
#включить <строка.ч>
#включить <sysexits.ч>
#включить <запустите.ч>

// https://github.com/thrig/goptfoo
#включить <goptfoo.ч>

// https://github.com/thrig/libjkiss
#включить <jkiss.ч>

#определить MOSTMEMPOSSIBLE ( (ULONG_MAX < SIZE_MAX) ? ULONG_MAX : SIZE_MAX )

Flag_Auto_Mem типа bool; // -м
беззнаковый Long Flag_Memory; // -м (сумма, хотя внутренне # о Интс)
беззнаковый Long Flag_Threads; // -Т

инт *память;

pthread_mutex_t замок = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t Done_Malloc = PTHREAD_COND_INITIALIZER;
pthread_cond_t Never_Happens = PTHREAD_COND_INITIALIZER;

emit_help недействительным(ничтожным);
пустота *работник(недействительными *неиспользованный);

тап_п(АГДС, типа char *переменной argv[])
{
 инт ч;
 pthread_t *БТИ;

jkiss64_init(нулем);

 пока ((ч = использования getopt(argc, необходимо агду, "ч?Мм:Т:")) != -1) {
 переключатель (ч) {

 корпус "м":
 Flag_Auto_Mem = истина;
перерыв;

 корпус "м":
 Flag_Memory = flagtoul(ч, optarg, 1UL, MOSTMEMPOSSIBLE);
перерыв;

 случае 'Т':
 Flag_Threads = flagtoul(ч, optarg, 1UL, ULONG_MAX);
перерыв;

 случае 'ч':
 дело '?':
по умолчанию:
emit_help();
 /* NOTREACHED */
}
}
 АГДС -= optind;
 агду += optind;

 если ((Flag_Memory == 0 && !Flag_Auto_Mem) || Flag_Threads == 0)
emit_help();

 /* Аааа Джи Эм. Сложно. Смотрите, если вы malloc() в самой памяти
 * возможно, тогда нет места для резьбы. Так должен вращаться
 * потоки, в первую очередь, а потом бинарным поиском realloc (), чтобы найти
 * наиболее возможные памяти. Предположительно другие экземпляры этого
 * программа или другие процессы будут запущены доедать все оставшиеся
 * память в системе.
*/

 если ((пив = памятью(размером sizeof(pthread_t), Flag_Threads)) == нуль)
 подстраховаться(EX_OSERR, "не могли с памятью() список потоков");

 для (беззнаковый long I = 0; я < Flag_Threads; я++) {
 если (pthread_create(&пив[я], нулем, работник, значение null) != 0)
 подстраховаться(EX_OSERR, "не может pthread_create() нить %Лу", я);
}

 если (Flag_Auto_Mem) {
 если (!Flag_Memory)
 Flag_Memory = MOSTMEMPOSSIBLE;

 Flag_Memory /= оператор sizeof(тип int);

 пока (Flag_Memory) {
 если ((память = функция malloc(Flag_Memory * оператор sizeof(тип int))) == нуль) {
 Flag_Memory >>= 1;
 } еще {
перерыв;
}
}

 если (память) {
 fprintf(stderr, "указанное информация: авто-запас берет %Лу ИНЦ\п", Flag_Memory);
 } еще {
 подстраховаться(EX_OSERR, "не может Авто-функции malloc() %Лу Интс", Flag_Memory);
}
 } еще {
 Flag_Memory /= оператор sizeof(тип int);
 если ((память = функция malloc(Flag_Memory * оператор sizeof(тип int))) == нуль)
 подстраховаться(EX_OSERR, "не может malloc () в %ЛУ Интс", Flag_Memory);
}

 функцию memset(память, 1, Flag_Memory * оператор sizeof(тип int));

pthread_cond_broadcast(&Done_Malloc);

pthread_mutex_lock(&замок);
 pthread_cond_wait(&Never_Happens, и блокировки);
pthread_mutex_unlock(&замок);

 /* NOTREACHED */
выход(1);
}

emit_help недействительным(ничтожным)
{
 fprintf(stderr, "использование: usemem [-г|-г памяти|-м -м "мэм"] - нити т\п");
выход(EX_USAGE);
}

пустота *работник(недействительными *неиспользованный)
{
 беззнаковый Long в IDx;

pthread_mutex_lock(&замок);
 pthread_cond_wait(&Done_Malloc, и блокировки);
pthread_mutex_unlock(&замок);

 для (;;) {
 // не (много) заботиться о предвзятости по модулю, так как наибольший объем памяти
 // значительно меньше, чем UINT64_MAX
 в IDx = jkiss64_rand() % Flag_Memory;
 Память[индекс] = (индекс % 2 == 1)
 ? Память[jkiss64_rand() % Flag_Memory]
 : слчис();
}

 /* NOTREACHED */
}

В OpenBSD же, напротив, проваливает Танос, если вы просите больше, чем доступно.