Пляжный мяч/нужно принудительно закрыть приложений с USB-C адаптер подключен?

Если вам не нужны очень качественные случайность, и близко-к-равномерное распределение достаточно хорошо, вы можете пойти очень быстро, особенно на современном процессоре с эффективным Симд целочисленных векторов как x86 с поддержкой SSE2 или AVX2.

Это как @NominalAnimal ответ , так как мы оба имели ту же идею, но вручную векторизовать для x86. (И с с худшее качество случайных чисел, но, вероятно, достаточно хорош для многих случаев использования.) Это работает примерно в 15 или 30 раз быстрее, чем код @номинальное, в ~13 ГБ/с Выход ASCII на 2,5 ГГц процессор Intel Haswell с поддержкой AVX2. Это все равно меньше, чем теоретическая максимальная пропускная способность оперативной памяти (двухканальной DDR3-1600 составляет около 25,6 ГБ/С), но у меня было время писать в /dev/нуль, так что это на самом деле просто переписывать буфер, который остается в кэше. Планы должны запустить этот же код значительно быстрее, чем Хасвел (внизу ответа).

Предполагая, что вы на самом деле узкое место ввода-вывода на диск или трубопроводов это где-то, быстрое внедрение означает, что ваш процессор даже не придется часами выше, чем ожидания. Он использует гораздо меньше энергии для получения результата. (Батареи / тепло / глобальное потепление.)

Это так быстро, что вы, наверное, не хочу писать его на диск. Просто повторно генерировать по мере необходимости (от того же семени, если вы хотите одни и те же данные еще раз). Даже если вы хотите кормить его в многопоточный процесс, который может использовать все процессоры, работает это перенаправление данных уже не будет жарко в L3 кэш-памяти (и кэша L2 на ядро, который ее написал), и использовать очень мало процессорного времени. (Но обратите внимание, что окантовка добавляет много накладных расходов, и писать в /dev/нуль. На панелях с i7 процессор 6700K, трубопроводы в сан. узел-с или другую программу, которая просто читает + отбрасывает ее ввод, это примерно в 8 раз медленнее, чем запись в /dev/нуль, и использует только 70% процессора. Но это по-прежнему 4.0 ГБ/С на процессора 3.9 ГГц.

Регенерировать быстрее, чем перечитывать его еще из быстрого слота PCIe подключен SSD, но ИДК, если это более эффективно (вектор-целочисленный множитель хранится очень занят, и это, наверное, очень властолюбивый, вместе с поддержкой AVX2 256Б векторные Алу). Ото, я не знаю, сколько процессорного времени чтения с диска будет отнять от чего-то, что было максить все процессорные ядра на этом входе. Я думаю, что переключения контекста, чтобы повторно генерировать в 128К куски может быть низким при работающем файловой системы / код pagecache и распределении страниц для чтения данных с диска. Конечно, если это уже жарко случаев, это всего лишь функции memcpy. ОТО, мы уже пишут о так быстро, как функции memcpy! (который должен разделить основной пропускной способности памяти между чтения и письма). (Также обратите внимание, что запись в память, что уже не жарко в кэше обычно триггерами для чтения для владения для поддержания когерентности кэша, который можно избежать с невременные магазинах, или с x86 это рэп movsb (оптимизированную функцию memset, memcpy и в микрокод, который избегает РФО, поскольку Энди библиотеки GLEW это внедрению его в Р6 (Пентиум про))).

Пока это только доказательство концепции, и строки обработки лишь приблизительно правильно. Это неправильно по концам 2 в буфер. С больше времени для развития. Я уверена, что смогу найти более эффективный способ для вставки новых строк, что тоже абсолютно правильно, с накладными расходами по крайней мере до этого (по сравнению с выводом только пробелами). Я думаю, что это что-то вроде 10 до 20%. Мне только интересно знать, как быстро мы могли бы сделать это выполнить, не имея полированной версии, поэтому эту часть я оставлю в качестве упражнения для читателя, с комментариями, с описанием какой-то идеи.

На Хасвел i5 процессор на 2.5 ГГц макс турбо, с DDR3-1600МГц оперативной памяти, приуроченная производить 100GiB но уменьшенную. (Времени на cygwin64 на Win10 с gcc5.4 -О3 -март=родной, опущено -funroll-петли, так как у меня был жесткий достаточно времени, получая приличное время работает на этот заимствованный ноутбук. Надо просто загрузится с Linux на USB).

запись в /dev/нуль, если не указано иное.

• Джеймс Холлис так: (не проверял)
• Версия по номинальной fwrite: ~2.21 с
• это (с SSE2): ~0.142 сек (немасштабированный раз = реальный=14.232 с пользователей=13.999 с Сыс=0.187 сек).
• это (Аух-128): ~0.140 сек
• этим (поддержкой AVX2): ~0.073 сек (немасштабированный: реальный=0m7.291s, пользователь=0m7.125с, Сыс=0m0.155s).
• этим (поддержкой AVX2) под Cygwin трубы в туалет -с, с 128kiB размер буфера: 0.32 S с процессора на 2.38 ГГц (максимальная двухъядерный турбо). (немасштабированный раз: реальный=32.466 с пользователей=11.468 с Сыс=41.092, в том числе и туалет). Был на самом деле только половина данных, скопированных, хотя бы потому, что моя глупая программа предполагает, что пишете полный буфер, хотя это не так и Cygwin записать() не только 64К за звонок в трубу.

Так с поддержкой SSE2 это примерно в 15 раз быстрее, чем скалярный код @номинальная животного. С поддержкой AVX2, это примерно в 30 раз быстрее. Я не пробовал версию номинальная кода, который просто использует запись() вместо fwrite(), но, вероятно, большие буферы из stdio основном остается в стороне. Если это копирование данных, что объясняет большое замедление.

Раз, чтобы произвести 1 Гб данных на Core2Duo E6600 с частотой (Мером 2.4 ГГц, 32kiB частная Л1, Л2 4MiB общей кэш-памяти), память DDR2-533 МГц в 64-битной Linux 4.2 (Убунту 15.10). Еще с помощью 128kiB размер буфера для записи(), не исследовал этот аспект.

запись в /dev/нуль, если не указано иное.

• (С SSE2) с новой строки транспортная обработка и векторы 4 цифр от каждого вектора случайных байт: 0.183 сек (времени делать 100GiB в 18.3, но аналогичные результаты за 1 гиб работает). Инструкция по 1.85 за цикл.
• (С SSE2) это трубы в туалет -с: 0.593 сек (немасштабированный: Реал=59.266 с пользователь=20.148 с Сыс=1m6.548s, в том числе процессорное время туалета). Же число записать() системные вызовы как с использованием Cygwin, но на самом деле трубопроводов все данные, потому что Linux обрабатывает все 128К записи() в трубу.
• NominalAnimal по fwrite() версии (gcc5.2 -О3 -март=родной), работать с ./decdig 100 $((1024*1024*1024/200)) > /dev/нуль: 3.19 сек +/- 0.1%, с 1.40 инструкции за цикл. -funroll-петельки, может быть небольшая разница. лязг-3.8 -О3 -март=родной: 3.42 сек +/- 0.1%
• Номинал-fwrite трубы в туалет -с: Реал=3.980 с пользователей=3.176 с Сыс=2.080 с
• Джеймс Холлис линии на время версии (лязг++-3.8 -О3 -март=родной): 22.885 с +/- 0.07%, с 0,84 инструкции за цикл. (г++5.2 был немного медленнее: 22.98 ы). Писать только одну строку за один раз, вероятно, значительно пострадал.
• Стефан Chazelas по тр < с /dev/urandom | ...: реальный=41.430 с пользователей=26.832 с Сыс=40.120 С. тр получал все ядра процессора на себя большую часть времени, проводя почти все свое время в ядре драйвер генерации случайных байт и скопировав их в трубы. Другие ядра на этот двухъядерный машина работала остальной части трубопровода.
• время значение lc_all=c головка -c512M <файл/dev/urandom >/dev/нуль, т. е. просто читала, что много рандома без тубопровода: Реал=35.018 с пользователей=0.036 сек Сыс=34.940 С.
• Программа Perl Lưu составляется на основе рейтинга Фук (на языке Perl У5.20.2 из Ubuntu15.10):
  Ланг=en_CA.В UTF-8: Реал=4m32.Пользователь 634s=4м3.288s Сыс=0m29.364.
  Значение lc_all=C в Ланг=с: Реал=4m18.Пользователь 637s=3m50.324s Сыс=0m29.356-е. Еще очень медленно.
  
  

• (С SSE2) это не перевод строки обработки, и 3 или 4 вектора цифр из каждого вектора случайных байт (почти точно такой же скоростью: dig3 = в%10 Шаг о безубыточности на этом ГВ): 0.166 сек (1.82 инструкции за цикл). По сути, это нижняя граница того, что мы можем приблизиться к совершенно эффективными строки обработки.

• (С SSE2) старая версия с новой строки обработки, но только по одной цифре в uint16_t элемент, используя в%10, 0.222 секунд +/- 0.4%, 2.12 инструкции за цикл. (Составлено с gcc5.2, март=родной -О3 -funroll-петли. Раскатать петель происходит за этой помощью кода на этом оборудовании. Не используйте его слепо, особенно для больших программ).
• (С SSE2) старая версия, запись в файл (на RAID10f2 из 3 быстрых магнитных жестких дисков, не очень оптимизирована для записи): ~4 секунд. Мог бы идти быстрее по настройке ядра настройки ввода/вывода буфер, чтобы позволить намного более "грязные" данные, прежде чем написать() блоков. "Системе" времени еще ~1,0 секунды, гораздо выше, чем "пользователь" времени. На этой старой системы с медленной памятью DDR2-533 оперативная память, она занимает ~4 раза дольше, для ядра в функции memcpy данные в кэш страниц и запустить систему XFS функции, чем это делает для моей петли, чтобы держать переписав его в буфер, который остается в кэше.

Как это делается

Быстрый PRNG-это очень важно. xorshift128+ может быть векторизован, у вас есть два или четыре 64-разрядных генераторов в параллель, в элементы Симд вектор. Каждый шаг производит полный вектор случайных байтов. (256Б поддержкой AVX2 реализации здесь с корпорацией Intel встроенные функции). Я взял его за символическую выбор xorshift*, потому что 64-битных векторных целочисленное умножение возможно только в поддержкой SSE2/поддержкой AVX2 с расширенной точности методов.

Учитывая вектор случайных байтов, мы можем изрубить каждый 16-битный элемент на несколько десятичных цифр. Мы производим несколько векторов 16-разрядные элементы, каждый цифры ASCII + ASCII в пространстве. Мы храним, что прямо на наших буфер вывода.

Моей первоначальной версии просто использовали х / 6554 , чтобы получить одну случайную цифру от каждого uint16_t элемент вектора. Это всегда между 0 и 9 включительно. Это предвзятое от 9, потому что (2^16 -1 ) / 6554 только 9.99923. (6554 = Сэл((2^16-1)/10), которая гарантирует, что частное всегда < 10.)

х/6554 может быть вычислена один умножить на "волшебные" константы (с фиксированной точкой взаимные) и сдвига вправо на максимум-половина результата. Это лучший случай для деления на константу; некоторые делители взять несколько операций, и подписал отдел берет дополнительную работу. х % 10 имеет аналогичную предвзятость и не так дешево, чтобы вычислить. (ССАГПЗ АСМ вывод эквивалентен х - 10*(х/10), т. е. дополнительную умножать и вычитать на верхней части дивизии с использованием модульного мультипликативным обратным.) Также, чтобы низший разряд xorshift128+ это не как высокое качество, так что разделив взять энтропии от старших бит лучше (по качеству, а также скорости), чем по модулю принять энтропийный с низким бит.

Однако, мы можем использовать больше энтропии в каждом uint16_t, глядя на низкие цифры, как при номинальной по цифре() функция. Для максимальной производительности, я решил взять минимум 3 десятичных цифр и Х/6554, чтобы спасти одного PMULLW и PSUBW (и, вероятно, некоторые MOVDQA) и более высокого качества, возможность взять на 4 минимум десятичных цифр. х/6554 слегка затронуты минимум 3 десятичных цифр, так что есть какая-то корреляция между цифрами один и тот же элемент (8 или 16 разрядов, разделение на выход ASCII, в зависимости от ширины вектор).

Я думаю, что GCC является деление на 100 и на 1000, а не более длинную цепь, что последовательно делится на 10, так что это наверное не существенно сокращая продолжительность номера-кольцевая цепь зависимостей, которая производит 4 результатов от каждого выхода ГПСЧ. port0 (векторное умножение и сдвиг) является узким местом из-за модульной мультипликативными инверсиями, и сдвиги в xorshift+, так что это определенно полезно, чтобы сохранить вектор-умножение.

xorshift+ настолько быстро, что даже используя только ~3.3 бит случайности из всех 16 (т. е. 20% эффективности) не намного медленнее, чем рубить его на несколько десятичных цифр. Мы лишь приблизительно равномерное распределение, потому что этот ответ фокусируется на скорости качество не так уж плохо.

Любой вид условного поведения, который держит переменным числом элементов заняло бы гораздо больше работы. (Но может все еще быть сделано несколько эффективно используя Симд слева-упаковка техники. Однако, что становится менее эффективным для небольшой элемент размеры; гигантские перемешать-маска таблицы подстановки не жизнеспособны, и нет никакой поддержкой AVX2 переулок-пересечение перемешать с меньшим, чем 32-разрядные элементы. А 128b PSHUFB версии может все-таки удастся создать маску на лету с BMI2 PEXT/PDEP, как вы можете за поддержкой AVX2 с более крупных элементов, но это сложно, потому что 64-разрядное целое число только занимает 8 байт. Ссылка godbolt на что ответ имеет некоторый код, который может работать на более высоких элементов графов.)

Если задержка ГСЧ, это узкое место, мы могли бы ехать еще быстрее, запустив два вектора генераторов параллельно, чередуя которые мы используем. Компилятор все равно может легко держать все в регистры развернутого цикла, и позволяет две цепочки зависимостей выполняться параллельно.

В текущей версии, раздирая на выходе ГПСЧ, мы на самом деле узким местом в Порту 0 пропускная способность, задержки не ГПСЧ, так что нет никакой необходимости для этого.

Код: поддержкой AVX2 версия

Полную версию с большим количеством комментариев на Godbolt компилятор проводника.

Не очень аккуратно, извините, я собираюсь идти спать и хотите, чтобы получить это опубликовано.

Чтобы получить поддержкой SSE2 версия, с/_mm256/_mm, с/256/128/, с/v16u/v8u/, и изменение vector_size(32) до 16. Также измените строку прирост от 4*16 до 4*8. (Как я уже сказал, код грязный, а не для составления двух вариантах. Не изначально план по созданию поддержкой AVX2 версии, но тогда мне очень хотелось проверить на процессора Haswell, которые я имел доступ.)

#включить <immintrin.ч>
#включить <запустите.ч>
код #include <stdint.ч>
#включить заголовочный файл <stdio.ч>
//#включить <строка.ч>

// Это будет работать одинаково быстро 128b или 256Б одновременно (поддержкой AVX2):
// https://stackoverflow.com/questions/24001930/avx-sse-version-of-xorshift128
структура rngstate256 {
 __m256i state0;
 __m256i state1;
};

статический встроенный __m256i xorshift128plus_avx2(структура rngstate256 *СП)
{
 __m256i С1 = СП->state0;
 константный __m256i С0 = СП->state1;
 СП->state0 = С0;
 С1 = _mm256_xor_si256(С1, _mm256_slli_epi64(С1, 23));
 __m256i state1new = _mm256_xor_si256(_mm256_xor_si256(_mm256_xor_si256(С1, С0),
 _mm256_srli_epi64(С1, 18)),
 _mm256_srli_epi64(С0, 5));
 СП->state1 = state1new;
 возвращение _mm256_add_epi64(state1new, С0);
}



// Гну с родной векторы давайте компилятор делать такие вещи, как %10 каждый элемент
оператор typedef unsigned краткое v16u __атрибут__((vector_size(32)));

__m256i* vec_store_digit_and_space(__m256i ВМК, __m256i *ограничить п)
{
 v16u в = (v16u)ВМК;
 v16u десять = (v16u)_mm256_set1_epi16(10);

 v16u делитель = (v16u)_mm256_set1_epi16(6554); // метод ceil((2^16-1) / 10.0)
 v16u div6554 = в / делитель; // в принципе энтропии от верхних двух десятичных цифр: 0..65.
 // Вероятно, какая-то корреляция с по модулю значений, особенно dig3, но мы сделаем это вместо
 // dig4 для более ИЛП и меньше инструкции всего.

 v16u dig1 = в % десять;
 в /= десять;
 v16u dig2 = в % десять;
 в /= десять;
 v16u dig3 = в % десять;
 // dig4 будет перекрывать большую часть рандома, что div6554 получает

 константный v16u ascii_digitspace = (v16u)_mm256_set1_epi16( (' '<<8) | '0');

 v16u *vecbuf = (v16u*)п;
 vecbuf[0] = div6554 | ascii_digitspace;
 vecbuf[1] = dig1 | ascii_digitspace;
 vecbuf[2] = dig2 | ascii_digitspace;
 vecbuf[3] = dig3 | ascii_digitspace;
 возврат П + 4; // всегда постоянное количество полных векторов
}


пустота random_decimal_fill_buffer(типа char *ограничить буфер buf, size_t в Лен, структуры rngstate256 *ограничить rngstate)
{
 баф = __строение_считать_выравнивается(баф, 32);

 // скопировать в локальную, так что лязг может хранить состояние в регистре, даже в невстраиваемых версия
 // запретить строительство для ССЗ, но, видимо, лязг до сих пор думает, что *баф может псевдоним *rngstate
 структура rngstate256 rng_local = *rngstate;

 __m256i *ограничить п = (__m256i*ограничить)баф;
 __m256i *ограничить endbuf = (__m256i*)(баф+лен);
 статические неподписанных newline_pos = 0;
 делать {
 __m256i rvec = xorshift128plus_avx2(&rng_local);
 Р = vec_store_digit_and_space(rvec, п); // хранит несколько символов ASCII векторов от энтропии в rvec

#если 1
 // это багги в конце или начале 2 в буфер:
 // обычно там слишком короткие линии, иногда слишком длинные строки
 константный беззнаковый ncols = 100;
 newline_pos += 4*16;
 если (newline_pos >= ncols) {
 newline_pos -= ncols;
 голец *cur_pos = (тип char*)п;
 *(cur_pos - newline_pos*2 - 1) = '\п';
}
#за endif
 // Поворота каждого 100-го места в строки.
 // 1) с перекрытием магазин 1Б на место, которое выбрал счетчик. А счетчик будет эффективнее
 // 2) или, используя другой постоянный для ascii_digitspace поставить перевод строки в одном элементе

 // НОК(200, 16) находится в 400 байт, поэтому отматываем достаточно петли для производства двух полных строк делает полный векторов повторить
 // НОК(200, 32) находится в 800 байт
 // мощности от-2 размер буфера не провести целый ряд линий :/
 // Я уверен, что это может быть решена с низкие накладные расходы, как может быть 10% в худшем случае.
 } при(р <= endbuf-3);

 *rngstate = rng_local;
}



директива #define BUFFER_SIZE (128 * 1024)
константные статические типы size_t bufsz = BUFFER_SIZE;
__атрибут__((выровнены(64))) статический чар static_buf[BUFFER_SIZE];

тап_п(АГДС, типа char *переменной argv[])
{
 // Задачи: подобрать семена правильно. (Не влияет на скорость)
 структура rngstate256 xorshift_state = {
 _mm256_set_epi64x(123, 456, 0x123, 0x456),
 _mm256_set_epi64x(789, 101112, 0x789, 0x101112)
};

 для (int я=0; я < 1024ULL*1024*1024 / bufsz * 100; я++) {
 random_decimal_fill_buffer(static_buf, bufsz, &xorshift_state);
 значение size_t написано = пишите(1, static_buf, bufsz);
(недействительным)письменные;
 //fprintf(stderr, "указанное писал %#ЛК на %#ЛК\п", написано, bufsz);
}

}

Компиляции с помощью GCC, Clang в, или ЕРЦ (или, надеюсь, любой другой компилятор, который понимает Си GNU диалект С99, и Intel встроенные функции). Гну с векторными расширениями являются весьма удобный, чтобы заставить компилятор генерировать магические числа для деления/деления, используя модульный мультипликативными инверсиями, и время от времени __атрибут__с полезным.

Это может быть написан компактно, но это займет больше кода.

Производительность Примечания:

Перекрытия-магазин, чтобы вставить новые строки имеют значительные накладные расходы, чтобы решить, где его разместить (филиал mispredictions, и frontend узкие места на Сердечником2), но сам магазин не имеет никакого влияния на производительность. Комментируя только что инструкция хранить в компиляторе АСМ (оставив все разветвления одинаковые) слева на Сердечником2 абсолютно неизменным, при повторных запусков давая то же время +/- менее 1%. Поэтому я делаю вывод, что магазин буфер / кэш справиться с этим просто отлично.

Все равно, через какое-то вращающееся окно ascii_digitspace с одним элементом, имеющим строки может быть даже быстрее, если мы раскатать достаточно, чтобы любая счетчики/разветвления уходят.

Запись в /dev/null-это в основном пустой, так что буфер, вероятно, остается горячим в кэш L2 (для каждого ядра 256kiB на Haswell). Ожидается, что идеальный ускорения с векторами 128b к 256Б векторов: нет дополнительные инструкции, и все (включая магазины) происходит с удвоенной ширины. Новая строка-вставка ветка хоть и взяты в два раза чаще,. Я, к сожалению, не раз на мой Хасвел под Cygwin установки с той частью конструкции#ifdef, что нужно.

2.5 ГГц * 32Б / 13.7 ГБ/с = циклов 5.84 за поддержкой AVX2-магазине на Haswell. Это очень хорошо, но могло бы быть быстрее. Может быть, есть некоторые накладные расходы в системе с Cygwin звонки, чем я думал. Я не комментирую тех, кто в выходных данных компилятора АСМ (что бы убедиться, что ничего оптимизировать.)

Кэш L1 может поддерживать один магазин 32Б на часы, и Л2 не намного ниже пропускной способности (увеличению задержки, правда).

Когда я посмотрел на МАА несколько версий назад (без ветвления строки, но только в одном формате ASCII вектора на вектор ГСЧ), она предсказывала что-то вроде одного 32Б вектора магазине за 4 или 5 часов.

Я надеялся получить больше производительности извлечения данных из каждого ГСЧ результате, на основе глядя на АСМ себе, считая палочек agner туман руководств и других ресурсов, оптимизация которых я добавил ссылки Для в так для x86 метки.)

Скорее всего, это будет значительно быстрее, на грани реальности, где вектор целочисленных умножения и сдвига может работать в два раза больше портов (Р0 / Р1) по сравнению с Haswell (Р0 только). xorshift и цифра добычи используют много смен и умножается. (Обновление: Richland и Trinity работает на 3.02 МПК, что дает нам 3.77 циклов в 32-байтный поддержкой AVX2 магазине, временный 0.030 сек на 1 ГБ итерации, писать в /dev/нуль на Linux 4.15 на i7-процессор 6700K на частоте 3.9 ГГц.

Он не требует 64-битном режиме, чтобы хорошо работать. С поддержкой SSE2 версия так же быстро, при компиляции с -М32, ведь для этого не нужно очень много векторных регистров, и все 64-разрядные математические делается в векторах, а не регистров общего назначения.

Это на самом деле немного быстрее в 32-разрядном режиме на Сердечником2, потому что сравниваем/филиал макро-слияние работает только в 32-битном режиме, так что меньше uops для вышедших из строя основной (18.3 с (1.85 инструкций за такт) против 16,9 с (2.0 МПК)). Чем меньше код-размер от Рекса префиксы также помогает декодеры Сердечником2 по.

Кроме того, некоторые Рег-Рег вектор движения заменяются нагрузок, поскольку не все больше закрепить константы в векторе рэгс. Поскольку нагрузка на пропускную способность кэш-памяти L1 не является узким местом, это на самом деле помогает. (например, умножения на постоянный вектор набор1(10): movdqa xmm0, xmm10 / pmullw xmm0, xmm1 превращается в movdqa xmm0, [постоянный] / pmullw xmm0, xmm1.) С рег-Рег MOVDQA требуется порт АЛУ, он конкурирует с реальной работой, но нагрузка MOVDQA только конкурирует для декодирования трафика. (Имея 4-байтовый адрес внутри много инструкций и перечеркивает много выгоды от экономии Рекс префиксов.

Я не удивлюсь, если сохранение АЛУ MOVDQA uops, где реальная прибыль идет от них, так как интерфейс должен быть в ногу со средним МПК 2.0 очень хорошо.

Все эти различия исчезают на Haswell, где все это должно работать из декодированного-УГБ кэш, если не буфер шлейфа. Алю+филиал макро-фьюжн работает в обоих режимах с Нихалем.