Операторы инлайнятся?

[Warn]

скажите, операторы инлайнятся? и насколько эффективно их использовать по сравнению с обычной ф-й?

program operators;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type vec3=packed record
  procedure values(const _x,_y,_z : Single);
  class operator add(const a, b : vec3):vec3;inline;
  class operator subtract(const a,b: vec3):vec3;inline;


	case byte of
	0: (v: array [0..3] of Single);
	1: (x, y, z: Single);
end;

class operator vec3.add(const a, b : vec3):vec3;
begin
	result.x := a.x + b.x;
	result.y := a.y + b.y;
	result.z := a.z + b.z;
end;
class operator vec3.subtract(const a,b: vec3):vec3;
begin
	result.x := a.x - b.x;
	result.y := a.y - b.y;
	result.z := a.z - b.z;
end;

procedure vec3.values(const _x,_y,_z : Single);
begin
	x:=_x;
	y:=_y;
	z:=_z;
end;

var
	a, b, c:vec3;
begin
a.values(1,2,3);
b.values(2,2,3);
c:=a+b;

writeln(Format('%f %f %f',[c.x, c.y, c.z]));
c.v[0]:=100;
c.z := 55;
writeln(Format('%f %f %f',[c.x, c.y, c.z]));

readln;

end.

[Пепел Феникса]

и насколько эффективно их использовать по сравнению с обычной ф-й?

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

Matrix3:=Matrix1.Add(Matrix2);

будет

Matrix3:=Matrix1+Matrix2;

[Warn]

перегрузка операторов служит лишь улучшению читабельности кода.

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

только к чему там wait ?

Команда WAIT переводит процессор в состояние ожидания. Процессор будет оставаться в неактивном состоянии, пока на входной линии TEST микропроцессора не появится сигнал. Эта команда позволяет синхронизировать микропроцессор внешними сигналами без использования запросов на прерывание.

[veniside]

к чему там wait ?

борладовский компилятор всегда генерит wait после записи из регистра фпу в память

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

Project12.dpr.60: c := addv(a, b);
0041C41E D905D03E4200     fld dword ptr [$00423ed0]
0041C424 D805E03E4200     fadd dword ptr [$00423ee0]
0041C42A D95DB0           fstp dword ptr [ebp-$50]
0041C42D 9B               wait 
0041C42E D905D43E4200     fld dword ptr [$00423ed4]
0041C434 D805E43E4200     fadd dword ptr [$00423ee4]
0041C43A D95DB4           fstp dword ptr [ebp-$4c]
0041C43D 9B               wait 
0041C43E D905D83E4200     fld dword ptr [$00423ed8]
0041C444 D805E83E4200     fadd dword ptr [$00423ee8]
0041C44A D95DB8           fstp dword ptr [ebp-$48]
0041C44D 9B               wait 
0041C44E 8D75B0           lea esi,[ebp-$50]
0041C451 BFF03E4200       mov edi,$00423ef0
0041C456 A5               movsd 
0041C457 A5               movsd 
0041C458 A5               movsd 
0041C459 A5               movsd

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

[Пепел Феникса]

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

у вас не метод.

только к чему там wait ?

ну FPU может закончить и позже чем проц, ждем его.

[veniside]

ну FPU может закончить и позже чем проц, ждем его

тем не менее, компилятор от мс такой фигней не страдает. Насколько я понимаю, с появлением пентиумов, единственное, для чего остался нужен wait — это выброс накопившихся к этому времени исключений фпу. С другой стороны, компилятор от мс маскирует все фпу исключения, в то время как борландовский компиль по старой досовской традиции продолжает их упорно обрабатывать.

[Warn]

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

[veniside]

> тело оператора на асме самому и заинлайнить его

асмовские функции (пока?) не инлайнятся.

Вобще, имхо, все это кошкины слёзы.
При больших объёмах вычислений эффективность их зависит в основном от выбранного алгоритма, а не от того, заинлайнится там что-то, или нет.
А при малых объёмах разницу никто не оценит.

[Warn]

проверил и точно -
[DCC Error] E2426 Inline function must not have asm block ((

Inline functions can not include an asm block. To avoid this error, remove the inline directive from your function or use Pascal code to express the statements in the asm block.

печально(

Вобще, имхо, все это кошкины слёзы.
При больших объёмах вычислений эффективность их зависит в основном от выбранного алгоритма, а не от того, заинлайнится там что-то, или нет.

заинлайном - экономим на вызовах.
и потом, там хоть и С vs asm, но тем не менее отрыв местами впечатляет

И много ли существует алгоритмов сложения двух векторов? умножения двух матриц? по-моему, там вся соль лишь, - будут ли это fpu или sse калькуляции и будет ли это блок или разовая акция.
вообщем пока я еще пишу для себя мат. модуль ака "glm for delphi", а потом выложу на ваш суд может чего подскажете по оптимизации вычислений)

[veniside]

> будут ли это fpu или sse калькуляции

это да, вот как выглядит аналогичный код в x64 проекте:

.text:0000000000426A5C                 cvtss2sd xmm0, cs:qword_434238
.text:0000000000426A65                 cvtss2sd xmm1, cs:qword_434248
.text:0000000000426A6E                 addsd   xmm0, xmm1
.text:0000000000426A72                 cvtsd2ss xmm0, xmm0
.text:0000000000426A77                 movss   dword ptr [rbp+80h], xmm0
.text:0000000000426A7F                 cvtss2sd xmm0, cs:qword_434238+4
.text:0000000000426A88                 cvtss2sd xmm1, cs:qword_434248+4
.text:0000000000426A91                 addsd   xmm0, xmm1
.text:0000000000426A95                 cvtsd2ss xmm0, xmm0
.text:0000000000426A9A                 movss   dword ptr [rbp+84h], xmm0
.text:0000000000426AA2                 cvtss2sd xmm0, cs:qword_434240
.text:0000000000426AAB                 cvtss2sd xmm1, cs:qword_434250
.text:0000000000426AB4                 addsd   xmm0, xmm1
.text:0000000000426AB8                 cvtsd2ss xmm0, xmm0
.text:0000000000426ABD                 movss   dword ptr [rbp+88h], xmm0
.text:0000000000426AC5                 lea     rdi, qword_434258
.text:0000000000426ACC                 lea     rsi, [rbp+80h]
.text:0000000000426AD3                 movsq
.text:0000000000426AD5                 movsq

А вобще, с векторами и матрицами лучше всего работать средствами GPU. Вот там действительно отрыв впечатляет, когда 128 шейдерных процессора лопатят вашу матрицу в 128 параллельных потока, это сила. И это на слабеньких карточках.