Плавающая арифметика в системных потоках - Низкоуровневое программирование

Приспичило задействовать плавающую арифметику для умножения/деления 64-разрядных чисел, которое в целочисленной арифметике дает или переполнение, или слишком большую погрешность. Использовать хочу исключительно в системных потоках, создаваемых через PsCreateSystemThread, и только на PASSIVE_LEVEL. Можно ли в таких условиях избежать обертывания каждой группы операций в KeSaveFloatingPointState/KeRestoreFloatingPointState, чтобы не блокировать переключение контекста? То есть, сохраняет ли ядро состояние FPU/SSE при переключении контекста с пользовательского потока на системный? В документации MS на эту тему навскидку ничего не нашел.

в x64 сохраняет
в x32 нет

Здравствуйте, reversecode, Вы писали:

R>в x64 сохраняет
R>в x32 нет

То есть, в x86, даже в собственном потоке, без сохранения состояния FPU и запрета переключения контекста не обойтись?

что означает запрет переключения контекста, цпу афинити ?
если да то это не играет роли
регистры не сохраняются в контексте и при переключении теряются

кстати погуглите как в касперском с этим нюансом столкнулись
аж целый доклад на какой то конфе по моему был

Здравствуйте, reversecode, Вы писали:

R>что означает запрет переключения контекста, цпу афинити ?

KeSaveFloatingPointState целиком запрещает прерывания, хотя в описании об этом ни слова.

R>регистры не сохраняются в контексте и при переключении теряются
R>кстати погуглите как в касперском с этим нюансом столкнулись
R>аж целый доклад на какой то конфе по моему был

Странно, что внезапно столкнулись — я вот изначально это подозревал, просто некогда самому копать, вот и спросил тут.

Здравствуйте, Евгений Музыченко, Вы писали:

ЕМ>Приспичило задействовать плавающую арифметику

В тот раз я выкрутился вычислениями в рациональной арифметике, так что на несколько лет вопрос отпал, но недавно всплыл снова. По сути, как тут уже было отмечено, в x64 (и в ARM64) контекст сохраняется всегда, KeSaveFloatingPointState/KeRestoreFloatingPointState определены пустышками, так что проблема сохранения существует лишь в x86. Но, коль скоро я продолжаю поддерживать 32-разрядные системы, пришлось этим заниматься.

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

Функции KeSaveFloatingPointState/KeRestoreFloatingPointState везде (начиная с документации MS) подаются, как "сохраняющие/восстанавливающие контекст". Большинству этого вполне достаточно, чтобы тупо оборачивать работу с плавучкой в эти вызовы, но кое-кто все-таки мыслит чуть глубже, и задается вопросом "а что, если во время работы с плавучкой случится переключение контекста?". Это наводит на мысль, что KeSaveFloatingPointState ограничивает переключение контекста. И действительно, в ее коде это делается, и кое-где (например, здесь) считается, что прерывания остаются запрещенными до вызова KeRestoreFloatingPointState, но это не так — перед выходом прерывания разрешаются.

Я долгое время считал, что запрет переключения контекста, явно устанавливаемый, но явно не отменяемый в KeSaveFloatingPointState, сохраняется до вызова KeRestoreFloatingPointState, однако на практике это не подтверждается — потоки, вызвавшие KeSaveFloatingPointState, продолжают переключаться, IRQL не изменяется.

Уже при первом взгляде на структуру KFLOATING_SAVE размером 32 байта, используемую этими функциями, понятно, что именно в ней контекст в пятьсот с лишним байтов сохраняться не может. К сожалению, я не настолько плотно изучал код управления процессорами и потоками, чтоб однозначно понять, что происходит, но пока все указывает на то, что в стеке любого потока, включая системные, созданные PsCreateSystemThread, всегда выделяется область для сохранения FP-контекста, но по умолчанию она используется только для потоков, имеющих пользовательский стек. Судя по всему, KeSaveFloatingPointState активирует режим сохранения при переключении контекста, а KeRestoreFloatingPointState деактивирует его обратно.

Если это так, то реализовано это все крайне криво.

Имея целью сократить время переключения контекста между системными потоками, логично было отказаться и от выделения памяти в их стеках — при ограничении в 12 кб на общий размер ядерного стека, полкилобайта составляют довольно заметную часть. В этом случае структуру KFLOATING_SAVE можно было бы сделать достаточного размера, а KeSaveFloatingPointState просто заносила бы ее адрес в KTHREAD и вызывала функции сохранения контекста, обходясь без этих странных манипуляций. А уж поток, вызывающий KeSaveFloatingPointState, сам бы решал, где разместить эту структуру — в стеке, если ему там свободно, или в отдельной памяти, если размеры стека поджимают.

В общем, если я правильно понял, KeSaveFloatingPointState можно вызывать хоть при входе в функцию потока, а KeRestoreFloatingPointState — непосредственно перед завершением, и никаких ограничений на работу между ними не возникает, просто при переключении контекста дополнительно сохраняются/восстанавливаются регистры FPU/SSE. Используется ли при этом "ленивый" режим, как для пользовательских потоков, я не выяснял.

Здравствуйте, Евгений Музыченко, Вы писали:

ЕМ>Приспичило задействовать плавающую арифметику для умножения/деления 64-разрядных чисел, которое в целочисленной арифметике дает или переполнение, или слишком большую погрешность. Использовать хочу исключительно в системных потоках, создаваемых через PsCreateSystemThread, и только на PASSIVE_LEVEL. Можно ли в таких условиях избежать обертывания каждой группы операций в KeSaveFloatingPointState/KeRestoreFloatingPointState, чтобы не блокировать переключение контекста? То есть, сохраняет ли ядро состояние FPU/SSE при переключении контекста с пользовательского потока на системный? В документации MS на эту тему навскидку ничего не нашел.

Тебе в риалтайме много надо?
Можешь попробовать мои целочисленные числа с плавающей точкой произвольной размерности — https://github.com/al-martyn1/marty_decimal

Деление совсем медленное, да, лучше минимизировать количество делений

Здравствуйте, Marty, Вы писали:

M>Тебе в риалтайме много надо?

В соответствии с потоками данных — в среднем 96000 x 8 отсчетов в секунду на каждый поток.

M>Можешь попробовать мои целочисленные числа с плавающей точкой произвольной размерности

Для целочисленных вычислений мне хватает и рациональной арифметики. Сейчас вопрос именно в том, чтобы принимать плавучку на входе и отдавать ее же на выходе, это будет всяко быстрее, если задействовать FPU.

Здравствуйте, Евгений Музыченко, Вы писали:

M>>Тебе в риалтайме много надо?

ЕМ>В соответствии с потоками данных — в среднем 96000 x 8 отсчетов в секунду на каждый поток.

Сложение-вычитание у меня тормознее плавучки в 20 раз, умножение — в 50 раз, деление вообще мегатормоз. Это при 50ти знаках после запятой

M>>Можешь попробовать мои целочисленные числа с плавающей точкой произвольной размерности

ЕМ>Для целочисленных вычислений мне хватает и рациональной арифметики. Сейчас вопрос именно в том, чтобы принимать плавучку на входе и отдавать ее же на выходе, это будет всяко быстрее, если задействовать FPU.

У меня десятичная плавучка произвольной размерности, но все вычисления целочисленные.

Но да, тебе наверное не подойдёт, слишком медленно

Здравствуйте, Евгений Музыченко, Вы писали:

Да, кстати, можешь попробовать boost/multiprecision/cpp_dec_float.hpp, оно на +, - и * всего в два раза медленнее плавучки, а на делении — всего в 10-12 раз тормознее. Это тоже я тестил на 50 знаках после десятичной точки.

Ну и вообще, можешь поковырять boost/multiprecision, там много разного, глядишь, что-то и подойдёт

Здравствуйте, Евгений Музыченко, Вы писали:

Упс, сорян, я люто наврал про супер скорость cpp_dec_float, это он побыстрее моего класса в два-три раза, от встроенного double он таки сильно отличается, но деление всего в 250 раз тормознее дабла, а у меня в 2500 раз.

Но можно поменьше знаков использовать, наверное, будет пошустрее, ну, и не обязательно десятичное, мне-то надо было для самописной бухгалтерии, поэтому завязывался на десятичку, но в бусте вроде есть и без такой привязки, должно быть пошустрее

https://www.boost.org/doc/libs/1_78_0/boost/multiprecision/float128.hpp
https://www.boost.org/doc/libs/1_78_0/boost/multiprecision/cpp_bin_float.hpp

Вот результаты моих перф тестов

Скрытый текст

Platform: x86
BCD storage type: std::basic_string

double               , normal precision,  normal numbers, '+'  elapsed time: 1390
cpp_dec_float<50>    , normal precision,  normal numbers, '+'  elapsed time: 11438
marty::Decimal(50)   , normal precision,  normal numbers, '+'  elapsed time: 27750
  Performance log
    double           : 5.01%, x 19.96
    cpp_dec_float    : 41.22%, x 2.43
    Decimal          : 100%, x 1

double               , normal precision,  normal numbers, '-'  elapsed time: 1390
cpp_dec_float<50>    , normal precision,  normal numbers, '-'  elapsed time: 11688
marty::Decimal(50)   , normal precision,  normal numbers, '-'  elapsed time: 29297
  Performance log
    double           : 4.74%, x 21.1
    cpp_dec_float    : 39.89%, x 2.51
    Decimal          : 100%, x 1

double               , normal precision,  normal numbers, '==' elapsed time: 1578
cpp_dec_float<50>    , normal precision,  normal numbers, '==' elapsed time: 5359
marty::Decimal(50)   , normal precision,  normal numbers, '==' elapsed time: 8047
  Performance log
    double           : 19.61%, x 5.1
    cpp_dec_float    : 66.6%, x 1.50
    Decimal          : 100%, x 1

double               , normal precision,  normal numbers, '*'  elapsed time: 1391
cpp_dec_float<50>    , normal precision,  normal numbers, '*'  elapsed time: 37453
marty::Decimal(50)   , normal precision,  normal numbers, '*'  elapsed time: 66219
  Performance log
    double           : 2.10%, x 47.62
    cpp_dec_float    : 56.56%, x 1.77
    Decimal          : 100%, x 1

double               , normal precision,  normal numbers, '/'  elapsed time: 1390
cpp_dec_float<50>    , normal precision,  normal numbers, '/'  elapsed time: 292672
marty::Decimal(50)   , normal precision,  normal numbers, '/'  elapsed time: 3434047
  Performance log
    double           : 0.04%, x 2500
    cpp_dec_float    : 8.52%, x 11.74
    Decimal          : 100%, x 1

------------------------------
double               , normal precision,  accounting numbers, '+'  elapsed time: 1328
cpp_dec_float<50>    , normal precision,  accounting numbers, '+'  elapsed time: 12515
marty::Decimal(50)   , normal precision,  accounting numbers, '+'  elapsed time: 30719
  Performance log
    double           : 4.32%, x 23.15
    cpp_dec_float    : 40.74%, x 2.45
    Decimal          : 100%, x 1

double               , normal precision,  accounting numbers, '-'  elapsed time: 1344
cpp_dec_float<50>    , normal precision,  accounting numbers, '-'  elapsed time: 12859
marty::Decimal(50)   , normal precision,  accounting numbers, '-'  elapsed time: 32610
  Performance log
    double           : 4.12%, x 24.27
    cpp_dec_float    : 39.43%, x 2.54
    Decimal          : 100%, x 1

double               , normal precision,  accounting numbers, '==' elapsed time: 1500
cpp_dec_float<50>    , normal precision,  accounting numbers, '==' elapsed time: 5734
marty::Decimal(50)   , normal precision,  accounting numbers, '==' elapsed time: 8109
  Performance log
    double           : 18.5%, x 5.41
    cpp_dec_float    : 70.71%, x 1.41
    Decimal          : 100%, x 1

double               , normal precision,  accounting numbers, '*'  elapsed time: 1344
cpp_dec_float<50>    , normal precision,  accounting numbers, '*'  elapsed time: 40516
marty::Decimal(50)   , normal precision,  accounting numbers, '*'  elapsed time: 113922
  Performance log
    double           : 1.18%, x 84.75
    cpp_dec_float    : 35.56%, x 2.81
    Decimal          : 100%, x 1

double               , normal precision,  accounting numbers, '/'  elapsed time: 1375
cpp_dec_float<50>    , normal precision,  accounting numbers, '/'  elapsed time: 290765
marty::Decimal(50)   , normal precision,  accounting numbers, '/'  elapsed time: 3527235
  Performance log
    double           : 0.04%, x 2500
    cpp_dec_float    : 8.24%, x 12.14
    Decimal          : 100%, x 1

------------------------------
double               , long precision  ,  big numbers, '+'  elapsed time: 31
cpp_dec_float<1000>  , long precision  ,  big numbers, '+'  elapsed time: 1781
marty::Decimal(1000) , long precision  ,  big numbers, '+'  elapsed time: 7969
  Performance log
    double           : 0.39%, x 256.41
    cpp_dec_float    : 22.35%, x 4.47
    Decimal          : 100%, x 1

double               , long precision  ,  big numbers, '-'  elapsed time: 31
cpp_dec_float<1000>  , long precision  ,  big numbers, '-'  elapsed time: 1781
marty::Decimal(1000) , long precision  ,  big numbers, '-'  elapsed time: 8453
  Performance log
    double           : 0.37%, x 270.27
    cpp_dec_float    : 21.07%, x 4.75
    Decimal          : 100%, x 1

double               , long precision  ,  big numbers, '==' elapsed time: 47
cpp_dec_float<1000>  , long precision  ,  big numbers, '==' elapsed time: 344
marty::Decimal(1000) , long precision  ,  big numbers, '==' elapsed time: 1609
  Performance log
    double           : 2.92%, x 34.25
    cpp_dec_float    : 21.38%, x 4.68
    Decimal          : 100%, x 1

double               , long precision  ,  big numbers, '*'  elapsed time: 0
cpp_dec_float<1000>  , long precision  ,  big numbers, '*'  elapsed time: 875
marty::Decimal(1000) , long precision  ,  big numbers, '*'  elapsed time: 13141
  Performance log
    double           : 0.00761%, x 13140.60
    cpp_dec_float    : 6.66%, x 15.02
    Decimal          : 100%, x 1

double               , long precision  ,  big numbers, '/'  elapsed time: 0
cpp_dec_float<1000>  , long precision  ,  big numbers, '/'  elapsed time: 4656
marty::Decimal(1000) , long precision  ,  big numbers, '/'  elapsed time: 547469
  Performance log
    double           : 0.000183%, x 546448.09
    cpp_dec_float    : 0.85%, x 117.65
    Decimal          : 100%, x 1

----------

Total time elapsed: 8601.187 seconds

------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Platform: x64
BCD storage type: std::basic_string

double               , normal precision,  normal numbers, '+'  elapsed time: 3047
cpp_dec_float<50>    , normal precision,  normal numbers, '+'  elapsed time: 10203
marty::Decimal(50)   , normal precision,  normal numbers, '+'  elapsed time: 23735
  Performance log
    double           : 12.84%, x 7.79
    cpp_dec_float    : 42.99%, x 2.33
    Decimal          : 100%, x 1

double               , normal precision,  normal numbers, '-'  elapsed time: 3047
cpp_dec_float<50>    , normal precision,  normal numbers, '-'  elapsed time: 10422
marty::Decimal(50)   , normal precision,  normal numbers, '-'  elapsed time: 25421
  Performance log
    double           : 11.99%, x 8.34
    cpp_dec_float    : 41%, x 2.44
    Decimal          : 100%, x 1

double               , normal precision,  normal numbers, '==' elapsed time: 3079
cpp_dec_float<50>    , normal precision,  normal numbers, '==' elapsed time: 5703
marty::Decimal(50)   , normal precision,  normal numbers, '==' elapsed time: 9047
  Performance log
    double           : 34.03%, x 2.94
    cpp_dec_float    : 63.04%, x 1.59
    Decimal          : 100%, x 1

double               , normal precision,  normal numbers, '*'  elapsed time: 3031
cpp_dec_float<50>    , normal precision,  normal numbers, '*'  elapsed time: 13250
marty::Decimal(50)   , normal precision,  normal numbers, '*'  elapsed time: 56094
  Performance log
    double           : 5.40%, x 18.52
    cpp_dec_float    : 23.62%, x 4.23
    Decimal          : 100%, x 1

double               , normal precision,  normal numbers, '/'  elapsed time: 3031
cpp_dec_float<50>    , normal precision,  normal numbers, '/'  elapsed time: 97687
marty::Decimal(50)   , normal precision,  normal numbers, '/'  elapsed time: 2659094
  Performance log
    double           : 0.11%, x 909.09
    cpp_dec_float    : 3.67%, x 27.25
    Decimal          : 100%, x 1

------------------------------
double               , normal precision,  accounting numbers, '+'  elapsed time: 3047
cpp_dec_float<50>    , normal precision,  accounting numbers, '+'  elapsed time: 11203
marty::Decimal(50)   , normal precision,  accounting numbers, '+'  elapsed time: 26594
  Performance log
    double           : 11.46%, x 8.73
    cpp_dec_float    : 42.13%, x 2.37
    Decimal          : 100%, x 1

double               , normal precision,  accounting numbers, '-'  elapsed time: 3047
cpp_dec_float<50>    , normal precision,  accounting numbers, '-'  elapsed time: 11531
marty::Decimal(50)   , normal precision,  accounting numbers, '-'  elapsed time: 27812
  Performance log
    double           : 10.96%, x 9.12
    cpp_dec_float    : 41.46%, x 2.41
    Decimal          : 100%, x 1

double               , normal precision,  accounting numbers, '==' elapsed time: 3063
cpp_dec_float<50>    , normal precision,  accounting numbers, '==' elapsed time: 6125
marty::Decimal(50)   , normal precision,  accounting numbers, '==' elapsed time: 9078
  Performance log
    double           : 33.74%, x 2.96
    cpp_dec_float    : 67.47%, x 1.48
    Decimal          : 100%, x 1

double               , normal precision,  accounting numbers, '*'  elapsed time: 3047
cpp_dec_float<50>    , normal precision,  accounting numbers, '*'  elapsed time: 14281
marty::Decimal(50)   , normal precision,  accounting numbers, '*'  elapsed time: 94094
  Performance log
    double           : 3.24%, x 30.86
    cpp_dec_float    : 15.18%, x 6.59
    Decimal          : 100%, x 1

double               , normal precision,  accounting numbers, '/'  elapsed time: 3031
cpp_dec_float<50>    , normal precision,  accounting numbers, '/'  elapsed time: 98906
marty::Decimal(50)   , normal precision,  accounting numbers, '/'  elapsed time: 2749797
  Performance log
    double           : 0.11%, x 909.09
    cpp_dec_float    : 3.6%, x 27.78
    Decimal          : 100%, x 1

------------------------------
double               , long precision  ,  big numbers, '+'  elapsed time: 78
cpp_dec_float<1000>  , long precision  ,  big numbers, '+'  elapsed time: 1469
marty::Decimal(1000) , long precision  ,  big numbers, '+'  elapsed time: 5969
  Performance log
    double           : 1.31%, x 76.34
    cpp_dec_float    : 24.61%, x 4.06
    Decimal          : 100%, x 1

double               , long precision  ,  big numbers, '-'  elapsed time: 62
cpp_dec_float<1000>  , long precision  ,  big numbers, '-'  elapsed time: 1485
marty::Decimal(1000) , long precision  ,  big numbers, '-'  elapsed time: 6328
  Performance log
    double           : 0.98%, x 102.04
    cpp_dec_float    : 23.47%, x 4.26
    Decimal          : 100%, x 1

double               , long precision  ,  big numbers, '==' elapsed time: 78
cpp_dec_float<1000>  , long precision  ,  big numbers, '==' elapsed time: 281
marty::Decimal(1000) , long precision  ,  big numbers, '==' elapsed time: 1391
  Performance log
    double           : 5.61%, x 17.83
    cpp_dec_float    : 20.20%, x 4.95
    Decimal          : 100%, x 1

double               , long precision  ,  big numbers, '*'  elapsed time: 0
cpp_dec_float<1000>  , long precision  ,  big numbers, '*'  elapsed time: 500
marty::Decimal(1000) , long precision  ,  big numbers, '*'  elapsed time: 7562
  Performance log
    double           : 0.01%, x 10000
    cpp_dec_float    : 6.61%, x 15.13
    Decimal          : 100%, x 1

double               , long precision  ,  big numbers, '/'  elapsed time: 0
cpp_dec_float<1000>  , long precision  ,  big numbers, '/'  elapsed time: 2579
marty::Decimal(1000) , long precision  ,  big numbers, '/'  elapsed time: 381062
  Performance log
    double           : 0.000262%, x 381679.39
    cpp_dec_float    : 0.68%, x 147.06
    Decimal          : 100%, x 1

----------

Total time elapsed: 6399.391 seconds

------------------------------------------------------------------------------------------------------------------------------------------------------------------------

ЕМ>В документации MS на эту тему навскидку ничего не нашел.

Ну я вот навскидку нашел, оно?
https://learn.microsoft.com/en-us/windows-hardware/drivers/kernel/using-floating-point-or-mmx-in-a-wdm-driver

Здравствуйте, ononim, Вы писали:

O>Ну я вот навскидку нашел, оно?

Э-э-э... Может, стоило сперва прочитать конец темы, перед ответом на вопрос шестилетней давности?

O>>Ну я вот навскидку нашел, оно?
ЕМ>Э-э-э... Может, стоило сперва прочитать конец темы, перед ответом на вопрос шестилетней давности?

..вот так я случайно стал ~~некрофилом~~ некропостером, чтож все надо попробовать в жизни

Здравствуйте, Евгений Музыченко, Вы писали:

ЕМ>сохраняет ли ядро состояние FPU/SSE при переключении контекста с пользовательского потока на системный? В документации MS на эту тему навскидку ничего не нашел.

Не сохраняет на x86, сохраняет на arm64/amd64. Вот например МСДН:

Note: Arm64 in general, is similar to AMD64 in that you don’t need to call save floating point state first. However, code that needs to be portable to x86 on kernels may still need to do that to be cross-platform.

Здравствуйте, Евгений Музыченко, Вы писали:

ЕМ>KeSaveFloatingPointState целиком запрещает прерывания, хотя в описании об этом ни слова.

Ну как ни слова — написано что на In Windows Vista and earlier versions of Windows ты должен вызывать KeSaveFloatingPointState внутри guarded region, а KeEnterGuardedRegion disables all kernel-mode APC delivery to the current thread. Ну и No such requirement exists in Windows 7 and later versions of Windows., т.е. очевидно, что теперь это делается автоматически, хотя явно не написано. Просто надо уметь читать документацию.

От:	Евгений Музыченко	https://software.muzychenko.net/ru
Дата:	10.06.19 20:57
Оценка:

От:	reversecode	google
Дата:	10.06.19 23:28
Оценка:

От:	Евгений Музыченко	https://software.muzychenko.net/ru
Дата:	11.06.19 07:34
Оценка:

От:	reversecode	google
Дата:	11.06.19 15:07
Оценка:

От:	Евгений Музыченко	https://software.muzychenko.net/ru
Дата:	11.06.19 15:58
Оценка:

От:	Marty	https://www.youtube.com/channel/UChp5PpQ6T4-93HbNF-8vSYg
Дата:	16.04.25 10:28
Оценка:

	От:	ononim
	Дата:	20.04.25 10:08
	Оценка:

	От:	ononim
	Дата:	20.04.25 10:50
	Оценка:

	От:	mike_rs
	Дата:	01.05.25 08:13
	Оценка:

	От:	mike_rs
	Дата:	01.05.25 08:16
	Оценка: