cl ray.cpp /Ox /EHsc /Gr /GS- /GL

ocamlopt -inline 100 ray.ml -o ray

ray > out.txt

ocalmopt                                        MSVC 8 
(Microsoft-based native Win32 port  3.09.0)     (14.00.50727.42 for 80x86)

30,60 сек                                       18,54 сек
30,69 сек                                       18,54 сек
30,59 сек                                       18,55 сек

ocamlopt -inline 100 ray.ml -o ray -S

_camlRay__fun_209:
    sub esp, 8            ; 1*
L101:
    mov ecx, eax
    fldz                  ; 2*
    fld REAL8 PTR [ecx]   ; 2*
    fcompp                ; 2*
    fnstsw  ax            ; 2*
    and ah, 69            ; 2*
    jne L100
    mov eax, ecx
    add    esp, 8         ; 1*
    ret
L100:
    mov eax, DWORD PTR [ebx+8]
    add    esp, 8         ; 1*
    ret

    mov DWORD PTR [edx],OFFSET _camlRay__fun_209

    and ah, 69
    dec ah
    cmp ah, 64

    fld    REAL8 PTR [esi]
    fmul    REAL8 PTR [edx]
    fstp    REAL8 PTR [eax]
    fld    REAL8 PTR [esi]
    fmul    REAL8 PTR [edx+8]
    fstp    REAL8 PTR [eax+8]
    fld    REAL8 PTR [esi]
    fmul    REAL8 PTR [edx+16]
    fstp    REAL8 PTR [eax+16]

    fld1
    fchs
    fmul    REAL8 PTR [edx]
    fstp    REAL8 PTR [ecx]

    mov eax, 1
    mov DWORD PTR 0[esp], eax
    cmp eax, 7
    jg  L200
L201:
    mov ecx, 1
    mov DWORD PTR 20[esp], ecx
    cmp ecx, 7
    jg  L202

    mov DWORD PTR 0[esp], 1
    mov DWORD PTR 20[esp], 1

L196:
    mov eax, 1
    mov eax, 1
    add    esp, 40
    ret

-- ты зачем 2 перехода подряд поставил???
-- это на случай, если первый не сработает!!!

_camlRay__aux_106:
    sub esp, 24
L111:
    mov DWORD PTR 12[esp], eax
    mov DWORD PTR 8[esp], ecx
    mov eax, DWORD PTR [eax]
    mov DWORD PTR 4[esp], eax
    movzx   eax, BYTE PTR [ebx-4]
    test   eax, eax
    je  L109
    mov DWORD PTR 0[esp], ebx
    mov ebx, DWORD PTR [ebx]
    mov eax, DWORD PTR [ecx+12]
    call    _camlRay__ray_sphere_94
L112:
    fld REAL8 PTR [eax]
    fstp    REAL8 PTR 16[esp]
    mov eax, DWORD PTR 4[esp]
    fld REAL8 PTR [eax]
    fcomp   REAL8 PTR 16[esp]
    fnstsw  ax
    and ah, 69
    dec ah
    cmp ah, 64
    jae L110
    mov eax, DWORD PTR 12[esp]
    add    esp, 24
    ret

Просто откомпилируйте что-нибудь простое на окамле и си++ — увидите в чем разница

R>void test(int a, ...) {
R>        int* x = &a;
R>        x++;
R>        cout << *x;
R>}

R>int main() {
R>        test(5, 6);
R>        return 0;
R>}

R>Вы узнать хотите или что?

unsigned __fastcall fact_(unsigned n, unsigned accum)
{
  return n > 1 ? fact_(n-1, n*accum) : accum;
}

unsigned factorial(unsigned n)
{
  return fact_(n, 1);
}

unsigned __fastcall fact_(unsigned n, unsigned accum)
{
    return n > 1 ? fact_(n-1, n*accum) : accum;
00401000  cmp         ecx,1 
00401003  mov         eax,edx 
00401005  jbe         fact_+12h (401012h) 
00401007  mov         edx,ecx 
00401009  imul        edx,eax 
0040100C  dec         ecx  
0040100D  jmp         fact_ (401000h) 
}
00401012  ret

J>Хочу услышать: где язык С++ не такой быстрый, как мог бы (не знаю в сравнении с чем вы утверждали).

Везде, где возникает потребность для запуска профайлера.
Самый простейший пример из возможных: http://www.ffconsultancy.com/free/ray_tracer/languages.html

The fastest languages are Stalin-compiled Scheme and C++. OCaml and MLton-compiled SML are slightly slower.

R>Ну и вообще, если самому сесть писать компилятор окамла, то можно много чего

GN>>Вполне на уровне результаты для 90го года — в среднем 90% от лучшего компилятора.

*(int*)0 = 0;

GN>>Уже устал читать это. Объяснений, как я понял, не будет

R>>>>>Я таковыми считаю свойства исходного кода.
R>>>>>Это касается и игры со стеком и всего прочего.
R>>

R>>void test(int a, ...) {
R>>        int* x = &a;
R>>        x++;
R>>        cout << *x;
R>>}

R>>int main() {
R>>        test(5, 6);
R>>        return 0;
R>>}

R>что напечатает эта программа и почему?

GN>В некоторых случаях напечатает 2й параметр, переданный в test. Потому что в ISO/IEC 14882 ничего не говориться про стек.

Вот именно.
Это то, что я называю непредсказуемостью.
И это то, что создает проблемы для компилятора и еще какие.

GN>>>И какие проблемы это даёт для компилятора?
R>>Очень смешно.
GN>Это не смешно — постоянно уходить от ответа.

Я не пониаю почему я вообще должен отвечать на такие вопросы.

R>Думаете, его скорость нуждается в защите?

cyberax@scblinux:~/tests$ time ./ray >img.pgm

real 0m52.500s
user 0m52.023s
sys 0m0.072s

cyberax@scblinux:~/tests$ time ./ray2 > img2.pgm

real 0m39.509s
user 0m39.326s
sys 0m0.024s

cyberax@scblinux:~/tests$ ocamlopt -inline 100 -ffast-math ray.ml -o ray
cyberax@scblinux:~/tests$ time ./ray > img.pgm

real 0m48.036s
user 0m47.551s
sys 0m0.140s

#include "stdafx.h"

#pragma inline_recursion(on)
#pragma inline_depth(2)

__forceinline int __fastcall factorial (int f)
{
  return f <= 1 ? 1 : f*factorial(f-1);
}

void Print(int i)
{
    printf("%d\n", i);
}

__declspec(noinline) void Test()
{
    Print(factorial(7));
}

void main()
{
    __asm int 3;
    Test();
}

__forceinline int __fastcall factorial (int f)
{
00401000  push        ecx  
  return f <= 1 ? 1 : f*factorial(f-1);
00401001  cmp         ecx,1 
00401004  mov         dword ptr [esp],ecx 
00401007  jg          factorial+10h (401010h) 
00401009  mov         eax,1 
}
0040100E  pop         ecx  
0040100F  ret              
00401010  push        ebp  
  return f <= 1 ? 1 : f*factorial(f-1);
00401011  lea         ebp,[ecx-1] 
00401014  cmp         ebp,1 
00401017  jg          factorial+24h (401024h) 
00401019  mov         eax,1 
0040101E  imul        eax,ecx 
00401021  pop         ebp  
}
00401022  pop         ecx  
00401023  ret              
  return f <= 1 ? 1 : f*factorial(f-1);
00401024  push        ebx  
00401025  lea         ebx,[ebp-1] 
00401028  cmp         ebx,1 
0040102B  jg          factorial+3Ch (40103Ch) 
0040102D  mov         eax,1 
00401032  imul        eax,ebp 
00401035  pop         ebx  
00401036  imul        eax,ecx 
00401039  pop         ebp  
}
0040103A  pop         ecx  
0040103B  ret              
  return f <= 1 ? 1 : f*factorial(f-1);
0040103C  push        edi  
0040103D  lea         edi,[ebx-1] 
00401040  cmp         edi,1 
00401043  jg          factorial+58h (401058h) 
00401045  mov         eax,1 
0040104A  imul        eax,ebx 
0040104D  imul        eax,ebp 
00401050  pop         edi  
00401051  imul        eax,ecx 
00401054  pop         ebx  
00401055  pop         ebp  
}
00401056  pop         ecx  
00401057  ret              
  return f <= 1 ? 1 : f*factorial(f-1);
00401058  push        esi  
00401059  lea         esi,[edi-1] 
0040105C  cmp         esi,1 
0040105F  jg          factorial+78h (401078h) 
00401061  mov         eax,1 
00401066  imul        eax,edi 
00401069  imul        eax,ebx 
0040106C  imul        eax,ebp 
0040106F  pop         esi  
00401070  imul        eax,ecx 
00401073  pop         edi  
00401074  pop         ebx  
00401075  pop         ebp  
}
00401076  pop         ecx  
00401077  ret              
  return f <= 1 ? 1 : f*factorial(f-1);
00401078  lea         ecx,[esi-1] 
0040107B  call        factorial (401000h) 
00401080  imul        eax,esi 
00401083  imul        eax,edi 
00401086  mov         ecx,dword ptr [esp+10h] 
0040108A  imul        eax,ebx 
0040108D  imul        eax,ebp 
00401090  pop         esi  
00401091  imul        eax,ecx 
00401094  pop         edi  
00401095  pop         ebx  
00401096  pop         ebp  
}
00401097  pop         ecx  
00401098  ret

void test(int a, ...) {
        int* x = &a;
        x++;
        cout << *x;
}

int main() {
        test(5, 6);
        return 0;
}

R>open Array;;
R>let msort xs = 
R>    let rec sort bgn fin =
R>        let rec merge bgn mid fin =
R>            let shift () = blit xs bgn xs (bgn + 1) (mid - bgn) in
R>            if mid >= fin || bgn >= mid then ()
R>            else let x, y = xs.(bgn), xs.(mid) in
R>                 let change () = (shift (); xs.(bgn) <- y) in
R>                 let bgn, mid = if x <= y then (bgn + 1, mid)
R>                                else (change (); (bgn, mid + 1))
R>                 in merge bgn mid fin in
R>        if fin - bgn <= 1 then ()
R>        else let mid = (fin + bgn) / 2 in
R>             let () = sort bgn mid; sort mid fin
R>             in merge bgn mid fin
R>    in sort 0 (length xs);;
R>

static void SmartQSort<T>(T[] arr, int lo, int hi, IsLess<T> isLess)
{
    int i = lo;
    int j = hi;
    T sep = arr[(lo + hi) >> 1];
    while (i <= j)
    {
        while (isLess(arr[i], sep))
            i++;
        while (isLess(sep, arr[j]))
            j--;

        if (i <= j)
        {
            T tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
            i++;
            j--;
        }
    }

    if (lo < j)
        SmartQSort(arr, lo, j, isLess);
    if (i < hi)
        SmartQSort(arr, i, hi, isLess);
}

static void SmartQSort<T>(T[] arr, int lo, int hi, IsLess<T> isLess)
{
    int i = lo, j = hi;    T sep = arr[(lo + hi) >> 1];
    while (i <= j) {
        while (isLess(arr[i], sep)) i++; while (isLess(sep, arr[j])) j--;
        if (i <= j) { T tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; i++; j--; }
    }

    if (lo < j) SmartQSort(arr, lo, j, isLess);
    if (i < hi) SmartQSort(arr, i, hi, isLess);
}

cout << factorial(7);
...

int factorial (int f)
{
  return f <= 1 ? 1 : f*factorial(f-1);
}

1.1.4 stable rev. 510

V>Я не совсем понимаю принцип действия этого предполагаемого restrict. Это мы как бы "обещаем" компилятору что-то? А кто контоллирует выполнение обещания?

There are three reasons that "restrict" isn't part of C++ already:

— The committee felt that enough was being added to C++ already so that new features should be minimized. An isolated feature such as "restrict" could and should be tried out in the communities in which it is most needed before it is added it to Standard C++.
— The "restrict" feature cannot in general be verified to be safe by a compiler. The committee felt that more work was needed to see if a better-behaved alternative could be found.
— The C++ Standard Library provides valarray as a mechanism to support high-performance Fortran-like vector computation.

The reasons for reconsidering "restrict" are:

— "restrict" appears to be becoming increasingly useful as more processors acquire architectural features such as long pipelines and parallel execution. When "restrict" was first discussed by the C++ committee, maybe 5 percent of all processors used by the -- C++ community had the high-performance features that made "restrict" valuable. Today, I suspect that percentage is closer to 95 percent.
— We have not (to the best of my knowledge) found an alternative that lends itself to static type checking in a general C++ environment.
— The valarray part of the C++ Standard Library has not yet taken hold on a significant scale. If it does, valarray will have no problem coexisting with "restrict." Thus, the bigger issue is the coordination between the C and C++ national and ISO committees. However, every vendor of C and C++ implementations face a dilemma between conformance to a divergent standard and making the full set of facilities available in all contexts.

Interview With Bjarne Stroustrup http://www.research.att.com/~bs/devXinterview.html

To contrast, the committee has rejected many proposals. For example:

Several proposals for direct support for concurrency
Renaming of inherited names (sec12.8)
Keyword arguments (sec6.5.1)
Several proposals for slight modifications of the data hiding rules
Restricted pointers (``son of noalias'') (sec6.5.2)
Exponentiation operator (sec11.5.2)
Automatically generated composite operators
User­defined operator.() (sec11.5.2)
Nested functions
Binary literals
General initialization of members within a class declaration.

Bjarne Stroustrup:
The Design and Evolution of C++

cyberax@scblinux:~/tests$ time ./a.out >aa

real 0m46.653s
user 0m45.991s
sys 0m0.224s

GN>>

On a 1.2GHz Athlon Thunderbird Linux box, the two programs can be compiled with (g++ 4.0.1 and ocamlopt 3.08.3)
OCaml is 7% faster than C++.

On a 1.6GHz Athlon 64 (running pure64 Debian Linux), the two programs can be compiled with (g++ 4.0.1 and ocamlopt 3.08.3)
OCaml is 5% slower than C++.

void copy(restrict int *a, restrict int *b)
{
    while(a!=b) *b=*(a++);
}

This comparison is as much about simplicity as it is about performance. All of these programs are largely unoptimised. Slight changes to the compile-line arguments or source code can substantially alter run-time performance. Consequently, our performance measurements are only a rough guide to the performance of the languages.

GN>void foo() { static const i = 0; } 
GN>

let rec qsort array = match array with 
     []              -> []
     | pivot::rest   -> let left,right = List.partition (function x -> x < pivot) rest
                        in (qsort left) @ pivot::(qsort right);;