How the compiler works to make code a bit like a "dare" - General

Dmitry Fedoseev 2020.05.30 18:10 #691

Maxim Kuznetsov:

this is called "loop unrolling" and is done by the compiler without any OO and templates (at least it should be).

If you look into the intermediate code (assembler), there are just consecutive N operations instead of a loop.

And can you tell us what happens when a function is called recursively?

Maxim Kuznetsov 2020.05.30 18:51 #692

Dmitry Fedoseev:

Can you tell me what happens when a function is called recursively?

there's no recursive call to the target functions :-)

In the given above example N:=const, the recursion occurs only when code is generated from a template and that one is tailored. At the link, a clever twist is to collapse the const-cycle into template recursion and call it a clever word

if macros had loops it would be written like this

#for x=0, x<N, x++

print("x=%d",x);

#endfor

and after the macro processor it would unfold into a sequence of N prints. (which actually happened, only through template classes)

That is, the trick works only if N is known at compile time

Special operators '#' and Errors, bugs, questions Could a class call

Dmitry Fedoseev 2020.05.30 19:08 #693

Maxim Kuznetsov:

and there is no recursive call to the target functions :-)

In the example given at the link N:=const, recursion is only at code generation from a template and that one is tail. At the link, a clever twist is to collapse the const-cycle into template recursion and call it a clever word

if macros had loops it would be written like this

#for x=0, x<N, x++

print("x=%d",x);

#endfor

and after the macro processor it would unfold into a sequence of N princes. (which actually happened, only through template classes)

So the trick works only if N is known at compile time

You won't believe it, but I know how templates work and what N there is, and what the result is. And my question about recursive function call was exactly about recursive function call, not about how there?

Maxim Kuznetsov 2020.05.30 19:30 #694

Dmitry Fedoseev:

You won't believe it, but I know how templates work and what the N is and what the result is. And my question about recursive function call was exactly about recursive function call, not about how there?

is it like a "dare?" exam? :-) I somehow thought that this example was being discussed... I was wrong :-)

If the compiler can convert the recursion into a tail (or it is explicitly such, or he was told to), then physically there will be no recursion - it will make a loop (switch back) and each iteration will "trample" the previous stack frame.

Questions from Beginners MQL5 Using the while operator Questions from Beginners MQL4

Dmitry Fedoseev 2020.05.30 19:34 #695

Maxim Kuznetsov:

is this some kind of a "dare" exam? :-) I somehow thought that this example was being discussed...I was wrong :-)

If the compiler can convert the recursion into a tail recursion (or it is explicitly such or has been told to do so), then physically there will be no recursion - it will make a loop (switch back) and each iteration will "trample" the previous stack frame.

What does this have to do with weakness? Just a question. Well, no, so no.

Vladimir Simakov 2020.05.31 12:17 #696

fxsaber:

I don't even want to bother. I made simple structures.

For what reason access to the first field of a simple structure depends on its size - I don't understand.

Huh. It's trivial - the number of bits to multiply is more)))) Make sure that the number of bits in the binary representation of the size of the structure was the same)))) Stupidly processor, as well as a man, longer to multiply 1111*101 than 1111*10)

Intraday Time filter From theory to practice i cant seem to

fxsaber 2020.05.31 13:05 #697

Vladimir Simakov:
Huh. It's trivial - the number of bits for multiplication is more)))) Make sure that the number of bits in the binary representation of the size of the structure was the same))) Stupidly processor, as well as a man, longer to multiply 1111*101 than 1111*10)

I won't check, there are plenty of other tasks. But I find it hard to believe.

fxsaber 2020.05.31 13:11 #698

In ME, I work with mqh, press ALT+N - the tree view in the Navigator window shows the location of the file.

Now I want to make an incluate it into an open mq5-file. I drag mqh from tree to mq5, but no appropriate include line is generated.

Errors, bugs, questions How to add external Can't open include mqh

Vladimir Simakov 2020.05.31 18:06 #699

fxsaber:

I won't check, there are plenty of other tasks. But I find it hard to believe.

template <typename T>
size_t Func(T* arr,size_t arrSize)
{
000000013 FFC1DA0  mov         qword ptr [rsp+10 h],rdx  
000000013 FFC1DA5  mov         qword ptr [rsp+8],rcx  
000000013 FFC1DAA  push        rbp  
000000013 FFC1DAB  push        rdi  
000000013 FFC1DAC  sub         rsp,148 h  
000000013 FFC1DB3  lea         rbp,[rsp+20 h]  
000000013 FFC1DB8  mov         rdi,rsp  
000000013 FFC1DBB  mov         ecx,52 h  
000000013 FFC1DC0  mov         eax,0 CCCCCCCCh  
000000013 FFC1DC5  rep stos    dword ptr [rdi]  
000000013 FFC1DC7  mov         rcx,qword ptr [rsp+168 h]  
000000013 FFC1DCF  lea         rcx,[__116109BC_Test@cpp (013 FFD5029h)]  
000000013 FFC1DD6  call        __CheckForDebuggerJustMyCode (013 FFC10B9h)  
    // Write
    for (size_t i = 0; i <arrSize; ++i)
000000013 FFC1DDB  mov         qword ptr [rbp+8],0  
000000013 FFC1DE3  jmp         Func<STRUCT1>+50 h (013 FFC1DF0h)  
000000013 FFC1DE5  mov         rax,qword ptr [rbp+8]  
000000013 FFC1DE9  inc         rax  
000000013 FFC1DEC  mov         qword ptr [rbp+8],rax  
000000013 FFC1DF0  mov         rax,qword ptr [arrSize]  
000000013 FFC1DF7  cmp         qword ptr [rbp+8],rax  
000000013 FFC1DFB  jae         Func<STRUCT1>+71 h (013 FFC1E11h)  
        arr[i].i = i;
000000013 FFC1DFD  imul        rax,qword ptr [rbp+8],18 h  
000000013 FFC1E02  mov         rcx,qword ptr [arr]  
000000013 FFC1E09  mov         edx,dword ptr [rbp+8]  
000000013 FFC1E0C  mov         dword ptr [rcx+rax],edx  
000000013 FFC1E0F  jmp         Func<STRUCT1>+45 h (013 FFC1DE5h)  

    size_t Sum = 0;
000000013 FFC1E11  mov         qword ptr [Sum],0  

    // Read
    for (size_t i = 0; i < arrSize; ++i)
000000013 FFC1E19  mov         qword ptr [rbp+48 h],0  
000000013 FFC1E21  jmp         Func<STRUCT1>+8 Eh (013 FFC1E2Eh)  
000000013 FFC1E23  mov         rax,qword ptr [rbp+48 h]  
000000013 FFC1E27  inc         rax  
000000013 FFC1E2A  mov         qword ptr [rbp+48 h],rax  
000000013 FFC1E2E  mov         rax,qword ptr [arrSize]  
000000013 FFC1E35  cmp         qword ptr [rbp+48 h],rax  
000000013 FFC1E39  jae         Func<STRUCT1>+0 BBh (013 FFC1E5Bh)  
        Sum += arr[i].i;
000000013 FFC1E3B  imul        rax,qword ptr [rbp+48 h],18 h  
000000013 FFC1E40  mov         rcx,qword ptr [arr]  
000000013 FFC1E47  movsxd      rax,dword ptr [rcx+rax]  
000000013 FFC1E4B  mov         rcx,qword ptr [Sum]  
000000013 FFC1E4F  add         rcx,rax  
000000013 FFC1E52  mov         rax,rcx  
000000013 FFC1E55  mov         qword ptr [Sum],rax  
000000013 FFC1E59  jmp         Func<STRUCT1>+83 h (013 FFC1E23h)  

    return Sum + arrSize;
000000013 FFC1E5B  mov         rax,qword ptr [arrSize]  
000000013 FFC1E62  mov         rcx,qword ptr [Sum]  
000000013 FFC1E66  add         rcx,rax  
000000013 FFC1E69  mov         rax,rcx  
}
000000013 FFC1E6C  lea         rsp,[rbp+128 h]

It's for a small structure.

template <typename T>
size_t Func(T* arr,size_t arrSize)
{
000000013 FFC1EB0  mov         qword ptr [rsp+10 h],rdx  
000000013 FFC1EB5  mov         qword ptr [rsp+8],rcx  
000000013 FFC1EBA  push        rbp  
000000013 FFC1EBB  push        rdi  
000000013 FFC1EBC  sub         rsp,148 h  
000000013 FFC1EC3  lea         rbp,[rsp+20 h]  
000000013 FFC1EC8  mov         rdi,rsp  
000000013 FFC1ECB  mov         ecx,52 h  
000000013 FFC1ED0  mov         eax,0 CCCCCCCCh  
000000013 FFC1ED5  rep stos    dword ptr [rdi]  
000000013 FFC1ED7  mov         rcx,qword ptr [rsp+168 h]  
000000013 FFC1EDF  lea         rcx,[__116109BC_Test@cpp (013 FFD5029h)]  
000000013 FFC1EE6  call        __CheckForDebuggerJustMyCode (013 FFC10B9h)  
    // Write
    for (size_t i = 0; i <arrSize; ++i)
000000013 FFC1EEB  mov         qword ptr [rbp+8],0  
000000013 FFC1EF3  jmp         Func<STRUCT3>+50 h (013 FFC1F00h)  
000000013 FFC1EF5  mov         rax,qword ptr [rbp+8]  
000000013 FFC1EF9  inc         rax  
000000013 FFC1EFC  mov         qword ptr [rbp+8],rax  
000000013 FFC1F00  mov         rax,qword ptr [arrSize]  
000000013 FFC1F07  cmp         qword ptr [rbp+8],rax  
000000013 FFC1F0B  jae         Func<STRUCT3>+71 h (013 FFC1F21h)  
        arr[i].i = i;
000000013 FFC1F0D  imul        rax,qword ptr [rbp+8],58 h  
000000013 FFC1F12  mov         rcx,qword ptr [arr]  
000000013 FFC1F19  mov         edx,dword ptr [rbp+8]  
000000013 FFC1F1C  mov         dword ptr [rcx+rax],edx  
000000013 FFC1F1F  jmp         Func<STRUCT3>+45 h (013 FFC1EF5h)  

    size_t Sum = 0;
000000013 FFC1F21  mov         qword ptr [Sum],0  

    // Read
    for (size_t i = 0; i < arrSize; ++i)
000000013 FFC1F29  mov         qword ptr [rbp+48 h],0  
000000013 FFC1F31  jmp         Func<STRUCT3>+8 Eh (013 FFC1F3Eh)  
000000013 FFC1F33  mov         rax,qword ptr [rbp+48 h]  
000000013 FFC1F37  inc         rax  
000000013 FFC1F3A  mov         qword ptr [rbp+48 h],rax  
000000013 FFC1F3E  mov         rax,qword ptr [arrSize]  
000000013 FFC1F45  cmp         qword ptr [rbp+48 h],rax  
000000013 FFC1F49  jae         Func<STRUCT3>+0 BBh (013 FFC1F6Bh)  
        Sum += arr[i].i;
000000013 FFC1F4B  imul        rax,qword ptr [rbp+48 h],58 h  
000000013 FFC1F50  mov         rcx,qword ptr [arr]  
000000013 FFC1F57  movsxd      rax,dword ptr [rcx+rax]  
000000013 FFC1F5B  mov         rcx,qword ptr [Sum]  
000000013 FFC1F5F  add         rcx,rax  
000000013 FFC1F62  mov         rax,rcx  
000000013 FFC1F65  mov         qword ptr [Sum],rax  
000000013 FFC1F69  jmp         Func<STRUCT3>+83 h (013 FFC1F33h)  

    return Sum + arrSize;
000000013 FFC1F6B  mov         rax,qword ptr [arrSize]  
000000013 FFC1F72  mov         rcx,qword ptr [Sum]  
000000013 FFC1F76  add         rcx,rax  
000000013 FFC1F79  mov         rax,rcx  
}
000000013 FFC1F7C  lea         rsp,[rbp+128 h]

This is for a large one.

VS2019, Debug x64, in the release it inlined them, but the speed is the same.

The only difference is in the imul instructions, the third operand, in two places. The instruction is just that, calculating the offset in the array, and the third operand isthe size of the structure in bytes.

So, no mysticism - laws of physics in action.

Errors, bugs, questions Quantum analysis Duca Questions from Beginners MQL5

Igor Makanu 2020.05.31 19:07 #700

Vladimir Simakov:

So, no mysticism - the laws of physics are in action.

if you write such classes:

//+------------------------------------------------------------------+
struct STRUCT
{
   int i;
   double d;
   uchar uc[16];
};
//+------------------------------------------------------------------+
class A
{
private:
   int i;
   double d;
   uchar uc[16];
public:
   A(const STRUCT &ini) { i = ini.i; d = ini.d; ArrayCopy(uc,ini.uc); }
};
//+------------------------------------------------------------------+
class B
{
private:
   STRUCT data;
public:
   B(const STRUCT &ini) { data = ini; }
};
//+------------------------------------------------------------------+

judging by your research, class B will be slower to execute if you use structure fields frequently in calculations?

Questions on OOP in MQL5 - page 70