Мерянье пи... э... попугаями. Быстродействие языков.

Тест №1. Функция Аккермана.

Функцию брал с www.programmist.info | 522: Connection timed out

[blue]
              + X+1,                 если N=0
              | X,                   если N=1,  Y=0,
              | 0,                   если N=2,  Y=0,
    A(N,X,Y)= | 1,                   если N=3,  Y=0,
              | 2,                   если N=>4, Y=0,
              + A(N-1,A(N,X,Y-1),X), если N#0,  Y#0;

     где N,X,Y - целые неотрицательные числа.
[/blue]

Тестирую на PIII-1200/SDRAM (124МГц). Сравниваются VC++ 7.0 и O'Caml 4.

Для начала программа на С++.

[blue]
#include <stdio.h>

void main(void)
{   
    printf("%dn",a(3,8,8));
}

int a(int n, int x, int y)
{  
    if(!n) 
        return x+1;

    if(y) 
        return a(n-1,a(n,x,y-1),x);
    
    switch(n)
    {  
        case 1:  return x;
        case 2:  return 0;
        case 3:  return 1;
    }

    return 2;
}

[/blue]

Компиляция: cl /Ox /O2 /F327680000 /Fa /FAsc /G6 accerman.c

Код получился классный. Даже switch разложен на

[blue]
; 16   :     
; 17   :     switch(n)
; 18   :     {  

  0002d 4e       dec     esi
  0002e 74 18        je  SHORT $L861
  00030 4e       dec     esi
  00031 74 13        je  SHORT $L869
  00033 4e       dec     esi
  00034 74 08        je  SHORT $L870
  00036 5f       pop     edi

; 22   :     }
[/blue]

Я уже молчу про то, что компилятор развернул один цикл рекурсии, как можно сократил внутренние переходы, распараллелил инструкции и проч.

В итоге имеем результат 16777216 за 4.07сек. В принципе, можно загнать в цикл и измерить точнее, что сделаю попозже.

Кстати, обращаю внимание на размер стека - 327680000. Изначально сделал 32768байт и потом дописывал нули, пока его хватило.

Теперь - O'Caml 4.

Итак, O'Caml.

С исходным текстом мудрить не стал.

let rec a n x y =
    match (n, y) with
        (0, y) -> x+1
      | (1, 0) -> x
      | (2, 0) -> 0
      | (3, 0) -> 1
      | (n, 0) -> 2
      | (n, y) -> (a (n-1) (a n x (y-1)) x)
    ;;


print_int(a 3 8 8);
print_newline();;

[/html_font]

Компиляция - ocamlopt.exe -S -inline 100 -o akkr.exe -ccopt /F32768000 akkr.ml

Как видим, стека хватает в 10 раз меньшего, чем на VC7.

Время работы программы - 2.23 сек!
При чём он даже не пытался делать внешнюю раскрутку функции.
Вот, если кому интересно, ассемблерный код функции:

[html_font size=+0]

[html_font color=blue]
_Akkr_a_49:
    sub esp, 8
L106:
    cmp eax, 7
    ja  L101
    mov edx, eax
    sar edx, 1
    jmp [edx * 4 + L107]
    .DATA
L107    DWORD   L105
    DWORD   L104
    DWORD   L103
    DWORD   L102
    .CODE
L105:
    add ebx, 2
    mov eax, ebx
    add    esp, 8
    ret
L104:
    cmp ecx, 1
    jne L101
    mov eax, ebx
    add    esp, 8
    ret
L103:
    cmp ecx, 1
    jne L101
    mov eax, 1
    add    esp, 8
    ret
L102:
    cmp ecx, 1
    jne L101
    mov eax, 3
    add    esp, 8
    ret
L101:
    cmp ecx, 1
    je  L100
    mov DWORD PTR 0[esp], eax
    mov DWORD PTR 4[esp], ebx
    add ecx, -2
    call    _Akkr_a_49
L108:
    mov ebx, eax
    mov eax, DWORD PTR 0[esp]
    add eax, -2
    mov ecx, DWORD PTR 4[esp]
    jmp L106
L100:
    mov eax, 5
    add    esp, 8
    ret

[/html_font]

Если честно, я такого не ожидал

Сгрузил я O'Caml с inria и ввел программу Крона. И получил

Stack overflow during evaluation (looping recursion?). Как стек увеличить из среды?

=KRoN=>Итак, O'Caml.

=KRoN=>С исходным текстом мудрить не стал.
=KRoN=>

=KRoN=>let rec a n x y =
=KRoN=>    match (n, y) with
=KRoN=>        (0, y) -> x+1
=KRoN=>      | (1, 0) -> x
=KRoN=>      | (2, 0) -> 0
=KRoN=>      | (3, 0) -> 1
=KRoN=>      | (n, 0) -> 2
=KRoN=>      | (n, y) -> (a (n-1) (a n x (y-1)) x)
=KRoN=>    ;;


=KRoN=>print_int(a 3 8 8);
=KRoN=>print_newline();;
=KRoN=>

[/html_font]

=KRoN=>Компиляция - ocamlopt.exe -S -inline 100 -o akkr.exe -ccopt /F32768000 akkr.ml

=KRoN=>Как видим, стека хватает в 10 раз меньшего, чем на VC7.

И этому есть объснение - смотри ниже.

=KRoN=>Время работы программы - 2.23 сек!
=KRoN=>При чём он даже не пытался делать внешнюю раскрутку функции.
=KRoN=>Вот, если кому интересно, ассемблерный код функции:

Вот здесь я и прокомментирую.

=KRoN=>[html_font size=+0]

[html_font color=blue]
=KRoN=>_Akkr_a_49:
=KRoN=>    sub esp, 8 - налицо отсутствие оформления фрэйма 
                        стэка - в спорах на этом форуме я не
                        раз упоминал, что в современных языках
                        вызов процедуры одно из самых дорогих
                        удовольствий - фрэйм для локальных
                        переменных, передача параметров 
                        через стек и т.д. Здесь произведена
                        резервация под две временные
                        переменные. Надо еще сказать, что
                        параметры передаются через регистры -
                        n - eax, x - ebx, y - ecx. Результат
                        возвращается на eax.
      
=KRoN=>L106:             Запомните эту метку!!!!
=KRoN=>    cmp eax, 7    Все константы и вычисления сдвинуты
                         по формуле 2*n+1 иниыми словами это
                         сравнение  cmp eax,3
=KRoN=>    ja  L101      есла n больше 3, то это общий случай
=KRoN=>    mov edx, eax  иначе преобразуем это в индекс для
                         косвенного перехода - таким образом
                         закодирована первая часть match
=KRoN=>    sar edx, 1
=KRoN=>    jmp [edx * 4 + L107]
=KRoN=>    .DATA
                              Это собственно таблица 
                              косвенной адресации
=KRoN=>L107    DWORD   L105   n == 0
=KRoN=>    DWORD   L104       n == 1 
=KRoN=>    DWORD   L103       n == 2
=KRoN=>    DWORD   L102       n == 3
=KRoN=>    .CODE
=KRoN=>L105:
=KRoN=>    add ebx, 2           x + 1
=KRoN=>    mov eax, ebx         вернуть на eax
=KRoN=>    add    esp, 8        подровнять стек
=KRoN=>    ret
=KRoN=>L104:
=KRoN=>    cmp ecx, 1           сравнение y == 0
=KRoN=>    jne L10
=KRoN=>    mov eax, ebx         x
=KRoN=>    add    esp, 8
=KRoN=>    ret
=KRoN=>L103:
=KRoN=>    cmp ecx, 1              y == 0
=KRoN=>    jne L101
=KRoN=>    mov eax, 1               вернуть 0
=KRoN=>    add    esp, 8
=KRoN=>    ret
=KRoN=>L102:
=KRoN=>    cmp ecx, 1           y == 0
=KRoN=>    jne L101
=KRoN=>    mov eax, 3           вернуть 1
=KRoN=>    add    esp, 8
=KRoN=>    ret
=KRoN=>L101:                     общий случай
=KRoN=>    cmp ecx, 1            y == 0
=KRoN=>    je  L100
=KRoN=>    mov DWORD PTR 0[esp], eax  внимание, сохраним n
=KRoN=>    mov DWORD PTR 4[esp], ebx  и х во временные 
                                      переменные
=KRoN=>    add ecx, -2           y - 1
=KRoN=>    call    _Akkr_a_49    вызовем функцию для вычисления
                                 a n x ( y - 1 ) - внутренний
                                 вызов.
=KRoN=>L108:                  
                                А вот здесь начинается второе
                                место, где объектный верблюд
                                выигрывает. ВНИМАНИЕ.
                                Вместо вызова функции еще раз
                                верблюд подготовил параметры
                                на регистрах и перешел на ту
                                метку, которую я вам советовал
                                завпомнить - сразу после 
                                sub esp,8 - тем самым экономия
                                сразу в двух местах - нет
                                операции вызова - она заменена
                                переходом (нет работы со стеком
                                и т.д.) и еще - переиспользова-
                                ние временных переменных без их
                                дополнительного переразмещнния
                                на стеке!
=KRoN=>    mov ebx, eax         результат на eax - поместим 
                                его вторым параметром - как x  
=KRoN=>    mov eax, DWORD PTR 0[esp] востановим n
=KRoN=>    add eax, -2                и отнимем 1 - т.е. мы
                                      имеем n - 1 первым 
                                      параметром   
=KRoN=>    mov ecx, DWORD PTR 4[esp] а бывший x передадим пос-
                                      ледним
=KRoN=>    jmp L106                А вот и тот самый переход
                                   вместо вызова!!!!!
=KRoN=>L100:
=KRoN=>    mov eax, 5               здесь возратим 2
=KRoN=>    add    esp, 8
=KRoN=>    ret

[/html_font]

[ слишком длинный топик - автонарезка ]

Так что ничего неожиданного - просто хорошие проекции и хорошие идеи. Ровно в 2 раза меньше вызовов (один вызов заменен на переход) и соответсвенно в 2 раза меньше работы со стеком. Да и существующая работа значительно проще, чем в С++. При передаче параметров, когда их количество не сможет лечь на регистры - может быть проблемой.

Кстати, а возможно создание у верблюда локальных переменных?

Mishka>Stack overflow during evaluation (looping recursion?). Как стек увеличить из среды?

Из среды - не знаю, я компилил из командной строки, передавая параметр стека внешнему VC7 компилеру+линкеру:

ocamlopt.exe -S -inline 100 -o akkr.exe -ccopt /F32768000 akkr.ml

Mishka>Так что ничего неожиданного - просто хорошие проекции и хорошие идеи.

Гы. А что, есть другие пути оптимизации? Типа телепатического взаимодействия с процессором? Ну а если б он рекурсию придумал развернуть, то разница в скорости на МНОГО порядков была бы

Mishka>Кстати, а возможно создание у верблюда локальных переменных?

Точно не знаю, т.к. на его изучение я потратил минут 5, только чтобы написать вышеприведённую програмку Скорее всего - есть. Возможно даже (!) глобальные переменные есть, на правах goto в Си++ и т.п. Т.к. язык, в отличие от того же Хаскелла, насколько я знаю, создавался не как академический, а для реальной работы.

=KRoN=>Из среды - не знаю, я компилил из командной строки, передавая параметр стека внешнему VC7 компилеру+линкеру:

=KRoN=>ocamlopt.exe -S -inline 100 -o akkr.exe -ccopt /F32768000 akkr.ml

Да я тоже так сделал. Кстати, то, что вызовов в два раза меньше - это и экономия стека - отсюда те самые 10 раз.

Mishka>>Так что ничего неожиданного - просто хорошие проекции и хорошие идеи.

=KRoN=>Гы. А что, есть другие пути оптимизации? Типа телепатического взаимодействия с процессором? Ну а если б он рекурсию придумал развернуть, то разница в скорости на МНОГО порядков была бы

Насчет идей - нет. А насчет проекций - это начало. Есть еще граф исполнения программы. Я тут где-то уже говорил, что французы очень здорово здесь поработали. У них было много интересных работ по преобразования графа исполнения в эквивалентные для параллелизма. Но это же самое подходит и для обычных алгоритмов - появляются куски, которые можно двигать.

Про рекурсию - потому и сказал про Аккермана - он не выражается.

=KRoN=>Точно не знаю, т.к. на его изучение я потратил минут 5, только чтобы написать вышеприведённую програмку Скорее всего - есть. Возможно даже (!) глобальные переменные есть, на правах goto в Си++ и т.п. Т.к. язык, в отличие от того же Хаскелла, насколько я знаю, создавался не как академический, а для реальной работы.

Вроде ребята из Inria побывали там, если не ошибаюсь. Правда эта контора вроде нашей академии. Я сгрузил книжку по верблюду - на сайте и ссылка есть. Так что почитаю на досуге. Кстати, если будут локальные переменные, то раскрутить рекурсию таким образом не удасться - надо будет фрейм оформлять. На вызове можно (переход вместо вызова), а на фрейме нет.

Как все экономиться:
С++ примерно так^
push y - parameters
push x
push N
call ackerman

ackerman:
push bp - frame
mov bp, sp
sub sp,12 - local variables

....
push n
push x
push y-1
call ackerman
push n-1
push result
push x
call ackerman

mov sp,bp
ret

O'Caml:
subp sp, 8 - temp variables

l1:
...
mov ax,n
mov bx,x
mov cx,y-1
call acckerman
mov bx,ax - result as x
mov ax, n-1
mov cx,x
jmp l1

l2: ret

т.е. нет отведения 12 байт под временные переменные, а только 8 - экономия 4. Развернутая рекурсия - нет одного вызова - экономия адрес возврата. Параметры передаются через регистры, а не стек - 12 байт.

Итого на каждые 2 вызова

С++                           Верблюд
2*12 - параметры              0
2*12 - временные переменные   1*8 
2*4 - адрес возврата          1*4 - развернули один уровень
2*4 - оформление фрейма       0
2 возврата/вызова             один вызов, один переход
(двойная операция со стеком)

Итого
64 байта на вызов             12 байтов

Так что по моим оценкам не в 10, а в 5-6 раз больше стека надо.

Кстати, такую развертку никто не мешал бы сделать и на других языках - у нас в Алголе 68 было понятие процедуры без базы (без стекового фрейма). И мы применяли это. Только вот по причинам иного характера не разварачивали, а вроде обсуждали.

Кстати, на Форте я так написал:

[html_font color=blue]
: AA  ( x y n — an )
    ?DUP 0= IF DROP 1+ EXIT THEN
    ( x y n )
    SWAP ?DUP IF  ( x n y!=0 )
        >R 2DUP R> 1- ( x n x n y-1 ) SWAP RECURSE ( x n a )
        -ROT 1- RECURSE
        EXIT
    THEN
    ( x n )
    DUP 1 = IF DROP ( x ) EXIT THEN
    DUP 2 = IF 2DROP    0 EXIT THEN
        3 = IF 2DROP    1 EXIT THEN
    DROP 2
;        

    
: A  ( n x y — an )  ROT AA ;

3 3 3 A . CR
BYE

[/html_font]

Вот только на 3 9 9 дефолтового стека не хватает, а как увеличить его в SP-Forth пока не нашёл

Кстати, здесь сразу видны накладные расходы на чисто стековую архитектуру - нет неразрушающих операций - отсюда dup многократно. И нет специального регистра для хранения результатов операций сравнения - все кладем на стек. Я понимаю, что это все логично, но я бы добавил бы и их самих, и их помеси - для ортогональности.

Ну, локальные переменные в ANS-94 есть, но, ИМХО, они медленнее.

Кстати говоря, Крон прав - VC 6.0 в режиме оптимизации тоже один уровень рекурсии снижает - раскрывая его как верблюд. Так что похоже накладных расходов на лишний вызов нет - остается передача параметров.

Вот полный ассемблерный код с комментариями

_TEXT	SEGMENT
_n$ = 8               смещения до параметров на стеке
_x$ = 12              относительно esp
_y$ = 16
?a@@YAHHHH@Z PROC NEAR					; a, COMDAT
; File D:Testsackermanackerman.cpp
; Line 12
	push	esi    фрейм не оформляем - нет локальных переменных
; Line 14
	mov	esi, DWORD PTR _n$[esp]  загрузили n - потеря у верблюда уже на регистре
	test	esi, esi                 сравнили
	push	edi                      сохранили регистр - потеря
	je	SHORT $L768
	mov	ecx, DWORD PTR _y$[esp+4] теперь достаем y&x - потеря
	mov	eax, DWORD PTR _x$[esp+4]
$L764:
; Line 17
	test	ecx, ecx
	je	SHORT $L723
; Line 18
	dec	ecx          готовимся к внутреннему вызову - и 
                             edi еще пихаем - а потом восстанавливаем
	mov	edi, eax
	push	ecx          Подготовка параметров
	push	eax
	push	esi
	call	?a@@YAHHHH@Z				; a
	add	esp, 12					; 0000000cH выравнивание стека
	dec	esi
	mov	ecx, edi
	jne	SHORT $L764   вот она замена рекурсии!!!!
	pop	edi
	inc	eax
	pop	esi
; Line 27
	ret	0
$L768:
; Line 14
	mov	eax, DWORD PTR _x$[esp+4]
	pop	edi
; Line 15
	inc	eax
	pop	esi
; Line 27
	ret	0
$L723:
; Line 21
	dec	esi
	je	SHORT $L721
	dec	esi
	je	SHORT $L729
	dec	esi
	je	SHORT $L730
	pop	edi
; Line 26
	mov	eax, 2
	pop	esi
; Line 27
	ret	0
$L730:
	pop	edi
; Line 24
	mov	eax, 1
	pop	esi
; Line 27
	ret	0
$L729:
; Line 23
	xor	eax, eax
$L721:
	pop	edi
	pop	esi
; Line 27
	ret	0
?a@@YAHHHH@Z ENDP					; a
_TEXT	ENDS

Похоже, что у Форта тоже возникнут проблемы с пересылками на стеке

А еще говорят, что много регистров не надо - вот пример, когда это помогает просто дальше некуда. Поэтому и пул регистров надо делать здоровый. Вызов процедуры с 5 параметрами еще может быть ОК, а с 20 - уже через стек. Ну, вроде, если кто-то и пишет процедуры с 20 параметрами, то ему на скорость накакать.

Сегодня нашёл у cl.exe ключик /Gr (fastcall). С ним у VC7 вышло 2.56сек. И всё равно Ocaml чуть-чуть быстрее

[blue]
PUBLIC  @ackr@12
_y$ = 8
@ackr@12 PROC NEAR                  ; COMDAT
; _n$ = ecx
; _x$ = edx

; 9    : {  

  00000 56       push    esi
  00001 8b f1        mov     esi, ecx

; 10   :     if(!n) 

  00003 85 f6        test    esi, esi
  00005 57       push    edi
  00006 8b c2        mov     eax, edx
  00008 74 1c        je  SHORT $L884
  0000a 8b 4c 24 0c  mov     ecx, DWORD PTR _y$[esp+4]

; 23   : }

  0000e 8b ff        npad    2
$L882:

; 12   : 
; 13   :     if(y) 

  00010 85 c9        test    ecx, ecx
  00012 74 18        je  SHORT $L864

; 14   :         return ackr(n-1,ackr(n,x,y-1),x);

  00014 49       dec     ecx
  00015 51       push    ecx
  00016 8b d0        mov     edx, eax
  00018 8b ce        mov     ecx, esi
  0001a 8b f8        mov     edi, eax
  0001c e8 00 00 00 00   call    @ackr@12
  00021 4e       dec     esi
  00022 8b cf        mov     ecx, edi
  00024 75 ea        jne     SHORT $L882
$L884:
  00026 5f       pop     edi

; 11   :         return x+1;

  00027 40       inc     eax
  00028 5e       pop     esi

; 23   : }

  00029 c2 04 00     ret     4
$L864:

; 15   :     
; 16   :     switch(n)
; 17   :     {  

  0002c 4e       dec     esi
  0002d 74 1c        je  SHORT $L862
  0002f 4e       dec     esi
  00030 74 17        je  SHORT $L870
  00032 4e       dec     esi
  00033 74 0a        je  SHORT $L871
  00035 5f       pop     edi

; 21   :     }
; 22   :     return 2;

  00036 b8 02 00 00 00   mov     eax, 2
  0003b 5e       pop     esi

; 23   : }

  0003c c2 04 00     ret     4
$L871:
  0003f 5f       pop     edi

; 20   :         case 3: return 1;

  00040 b8 01 00 00 00   mov     eax, 1
  00045 5e       pop     esi

; 23   : }

  00046 c2 04 00     ret     4
$L870:

; 18   :         case 1: return x;
; 19   :         case 2: return 0;

  00049 33 c0        xor     eax, eax
$L862:
  0004b 5f       pop     edi
  0004c 5e       pop     esi

; 23   : }

  0004d c2 04 00     ret     4
@ackr@12 ENDP

PUBLIC  _main
_main   PROC NEAR                   ; COMDAT

; 5    :     printf("%dn",ackr(3,8,8));

  00000 6a 08        push    8
  00002 6a 07        push    7
  00004 ba 08 00 00 00   mov     edx, 8
  00009 b9 03 00 00 00   mov     ecx, 3
  0000e e8 00 00 00 00   call    @ackr@12
  00013 8b d0        mov     edx, eax
  00015 b9 02 00 00 00   mov     ecx, 2
  0001a e8 00 00 00 00   call    @ackr@12
  0001f 50       push    eax
  00020 68 00 00 00 00   push    OFFSET FLAT:??_C@_03PMGGPEJJ@?$CFd?6?$AA@
  00025 e8 00 00 00 00   call    _printf
  0002a 83 c4 08     add     esp, 8

; 6    : }

  0002d 33 c0        xor     eax, eax
  0002f c3       ret     0
_main   ENDP

[/blue]

Хотел сегодня на C# измерить, благо практически C++ по коду:

[blue]using System;

class test
{
static int a(int n, int x, int y)
{
if(n==0)
return x+1;

if(y!=0)
return a(n-1,a(n,x,y-1),x);

switch(n)
{
case 1: return x;
case 2: return 0;
case 3: return 1;
}

return 2;
}

static void Main(string[] args)
{
Console.Write(a(3,8,8));
}

}[/blue]

Но увы, стека, как обычно, не хватает, а как его увеличить нигде не нашёл :-/

Блин, захотел на Хаскелле (ghc) попробовать:

import System

a 0 x y = x+1
a 1 x 0 = x
a 2 x 0 = 0
a 3 x 0 = 1
a n x 0 = 2
a n x y = (a (n-1) (a n x (y-1)) x)

main = do print(a 3 8 8)


Увы, через 6 мин. работы: "ackr.exe: fatal error: Windows programs can only use 256Mb of heap; sorry!"

Это при том, что:
" -M
Запустил сейчас с -M1G - посмотрим...

P.S. Нет, пофиг

Есть. C# после ручного копания заголовка EXE-шника (спасибо MaxMP) дал результат 3.96сек. По-моему очень и очень неплохо! У C#, думаю, есть все шансы потеснить C++ и, тем более, Java/VB.

Не поленился написать "лобовое" решение на Асме. На отладку ушло ~45мин

      iackr: ; ebx = n, ecx = x, edx = y -> eax = ackr(n,x,y)
        test ebx, ebx
        jnz iackr_1
        lea eax, [ecx+1]
        ret
      iackr_1:
        test edx, edx
        jz iackr_2
        push ebx
        push ecx
        push edx
        dec edx
        call iackr
        mov edx, ecx
        mov ecx, eax
        dec ebx
        call iackr
        pop edx
        pop ecx
        pop ebx
        ret
      iackr_2:
        push ebx
        dec ebx
        jnz iackr_3
        mov eax, ecx ;1
        pop ebx
        ret
      iackr_3:
        dec ebx
        jnz iackr_4
        xor eax, eax ;2
        pop ebx
        ret
      iackr_4:
        dec ebx
        jnz iackr_5
        mov eax, 1 ;3
        pop ebx
        ret
      iackr_5:
        mov eax, 2
        pop ebx
        ret

Время работы - 2.88 сек.

Кстати, среднее время работы для 10 вызовов a 3 8 8 на Ocaml оказалось 2.08 сек, а не 2.23, как было указано ранее

>У C#, думаю, есть все шансы потеснить C++ и, тем более, Java/VB.

Только разве что из-за маркетинга... Даже Java, не говоря уж о C++...

[ 25-11-2002: Message edited by: avmich ]

C# компилит в нативный код, в отличие от Java. И снабжён целой кучей вкусностей, которых нет в С++ - от сборки мусора, до массивов массивов и т.п. Кроме того, на C# после C++ переучиваться практически не нужно.

Если кто-то для теста сгенерит консольный .class для функции Аккермана для 3,8,8 - я прогоню его у себя и скажу, сколько времени он будет работать

>C# компилит в нативный код, в отличие от Java.

Ерунда. Непринципиально в данном случае.

>И снабжён целой кучей вкусностей, которых нет в С++



>от сборки мусора

"Одни программисты считают, что управление памятью - это очень важная вещь, и ею должна заниматься только операционная система. Другие программисты считают, что управление памятью - жто очень важная вещь, и её никак нельзя поручить операционной системе, а нужно делать самим.

При этом и те, и другие согласны, что управление памятью - это очень важная вещь."

© фольклор

>до массивов массивов

Ну, формально массивы массивов есть чуть ли не везде... уж в C++ и Java точно.

>Кроме того, на C# после C++ переучиваться практически не нужно.

О, вот это действительно важное качество . Особенно по сравнению с Java .

>Если кто-то для теста сгенерит консольный .class для функции Аккермана для 3,8,8 - я прогоню его у себя и скажу, сколько времени он будет работать

Лучше скажи, зачем... нет, правда, Крон... на бенчмарки тестов по реальным программам смотрел?..

Это, кстати, тоже неважно. Стоимость разработки - один из основных критериев сегодня.

>>C# компилит в нативный код, в отличие от Java.
avmich>Ерунда. Непринципиально в данном случае.

Ну-ну...

avmich>При этом и те, и другие согласны, что управление памятью - это очень важная вещь."

Слава Богу, со времён этой шутки уже не одно поколение еомпиляторов сменилось, и сегодня сборка мусора мало того, что хорошо работает, иногда без неё в принципе никак. Обычно фанаты Ocaml и Haskell любят показывать древовидные структуры с циклическими ссылками, которые на классическом Си++ невозможны без утечек памяти По-моему, сейчас как раз очередной виток в fido7.su.softw идёт (не вчитывался)

>>до массивов массивов
avmich>Ну, формально массивы массивов есть чуть ли не везде... уж в C++ и Java точно.

Я с C++ сравниваю, т.к. массив указателей - это не то

>>Кроме того, на C# после C++ переучиваться практически не нужно.
avmich>О, вот это действительно важное качество . Особенно по сравнению с Java .

Всё же, Java от Си++ отличается гораздо сильнее, чем C#.

avmich>Лучше скажи, зачем... нет, правда, Крон... на бенчмарки тестов по реальным программам смотрел?..

Ну, вот, например - RSDN

avmich>Это, кстати, тоже неважно. Стоимость разработки - один из основных критериев сегодня.

Вот тут у C# шансов оказывается очень много

>Вот тут у C# шансов оказывается очень много

Не может быть

А бенчмарки вроде как вполне мою точку зрения подтверждают.

> Первый – к любым тестам нужно относиться со здравой долей скептицизма.

> Второй – практически все компиляторы производят на свет довольно быстрый код.

> Третье – новые платформы (Java и .Net), а вместе с ними и так любимая у нас Delphi, практически не уступают C++-компиляторам по скорости производимого кода

(тут откусил часть фразы)

> Четвертое – мнение о том, что управляемые среды типа Java и .Net медленны и из-за этого не могут рассматриваться всерьез как универсальные языки, на которых можно создавать быстрое ПО, ошибочно.