C# для S/390

И еще один немаловажный момент. Что легче оптимизировать - общий случай или частный? Для того, чтобы написать на современном Фортране аналог for, существует НЕ ТОЛЬКО do. А еще и массивные операции, FORALL, WHERE и т.д. Что существенно облегчает работу оптимизатора, коему такой синтаксис (чрезвычайно простой) прямо говорит, что можно распараллелить, а что сложно. И никаких дополнительных надстроек вроде указанных выше в этом треде для этого не требуется. Так сказать, "область начальной неопределености" для оптимизатора сужается и благодаря другим причинам. Например, элементы фортрановских массивов не обязаны лежать в памяти подряд.

Конечно, по идее все можно написать на всем. Бенчмарки с того же сайта Блитца показывают, что при применении надстроек и должного подхода можно добиться сопоставимых с Фортраном результатов. Однако непонятно и обидно мне, когда Фортран называют бесполезным старьем. С какой стати, если он позволяет добиться даже чуть лучших результатов куда меньшими силами? Сравни толщину Страуструпа (плюс толщину мануалов по всяким блитцам) с толщиной классического учебника Меткалфа-Рида.

Есть 2 очень хорошие книги, даже изданные в России. 1) Голуб и Ван-Лоан "Матричные вычисления", 2) Стандарт Фортрана-90. Прочтите их, и вам откроется истина. =)

А в Си есть возможность не делать сомнительных намеков компилятору, а вручную соптимизировать все под частный случай. Пусть мало кто пользуется, но возможность-то есть. А фортран - гоночный трехколесный велосипед ;) НЕТ, фортран - раллийный трамвай.

А еще у вас негров линчуют...

P.S. Это какой Голуб? А то тут читал одного, так он все больше про С/С++.

======

А в Си есть возможность не делать сомнительных намеков компилятору, а вручную соптимизировать все под частный случай. Пусть мало кто пользуется, но возможность-то есть. А фортран - гоночный трехколесный велосипед ;) НЕТ, фортран - раллийный трамвай. А еще у вас негров линчуют...

======

Вот соптимизируй мне руками хотя бы такой пример, как умножение матриц. =) В течение суток хотя бы. А ее еще погыгыкаю, на тебя глядючи. =)

======

P.S. Это какой Голуб? А то тут читал одного, так он все больше про С/С++.

======

Нет, другой. Который не болтолог. Сишники его не знают. :) При этом не могу не заметить, что тот, которого знают они, писал (в своей весьма живой манере), что только идиоты переходят с Кобола на Си в экономической области. :Р Думаю, про Фортран в области вычислений он сказал бы то же самое.

> Вот соптимизируй мне руками хотя бы такой пример, как умножение матриц

Заметано :) Но у меня правая рука сломана, надо подождать пока срастется кость :) Тогда дам объявление в газетах "Оптимизирую умножение матриц руками в присутствии заказчика".

> Нет, другой. Который не болтолог.

Список немых певцов и слепых художников в студию :)

> что только идиоты переходят с Кобола на Си в экономической области

Правильно писал. Нужно было переходить на forth :) Желательно за три дня, но можно и за неделю.

Это выглядело бы так: :)))

======

...мне в первую очередь интересно знать, зачем было менять Fortran на С. Принуждение программистов на языке Fortran использовать С всегда поражало меня своей большой глупостью. Fortran - великолепный язык для работы с многомерными массивами. У него есть встроенные примитивы, упрощающие выполнение задач, которые довольно трудны для С. С, в конце концов, был разработан для создания операционных систем, а не приложений в области численных методов. Довольно просто дополнить Fortran, чтобы он поддерживал битовые операции и рекурсию, если это единственная причина перехода на С.

======

(C) А.Голуб с точностью до замен имен языков и областей применения.

А вообще мне с вами надоело, сишные вы мои. Вас тут целое гагало, а до сих пор ничего, кроме философских рассуждений о божественной "близости си к ассемблеру" и величии ручной оптимизации, вы не родили. Я же привел вам достаточно примеров, где Си окакался.

Поэтому пока мне в мыльницу не упадет хотя бы 1 пример (сишный, плюсовый, блитцевский, etc.), превосходящий по скорости вычислений фортрановский аналог, я продолжать полемику не буду. Надоело метать бисер, знаете ли (не сочтите за оскорбление :) )...

LamerOk (*) (2002-11-22 02:43:39.496):
> не многовато ли у тебя printf'ов для оценки
> производительности то ??

Многовато!
Мысль была такая: тупо в лоб переписать типичный фортрановский код на Си и
сравнить. Просто - стандартные средства. Извини, но под Сями кроме printf'а ничего
высокоуровневого нет. И повторяющихся спецификаций формаирования нет - вообще,
printf - одна из самых тормознутых стандартных сишных фич, хотя и очень гибкая.

Кстати, один из немногих случаев, когда стандартные средствы ЦеПП оказываются
быстрее.

> ...лучше бы кластерный/факторный анализ прогнали бы на данных в пару гектар.
Знаешь, у меня своих дел хватает. Я и так тут толкусь чрезмерно:(

На счет Голуба - книжка действительно толковая.

А примерчик я вам навояю - пока времени не было - кроме звездежа на ЛОР у меня есть еще и работа :))) Иногда приходится работать и много. Но вот на выходных наваяю.

ARia

P.S. Я тот, что про газодинамику писал.

$ nslookup fortranrulez.front.ru

Server: XXXXXX Address: XXXXXX

*** XXXXXX can't find fortranrulez.front.ru: Non-existent domain

anonymous (*) (2002-11-22 18:27:23.175):

> до сих пор ничего, кроме философских рассуждений о божественной
> "близости си к ассемблеру" и величии ручной оптимизации, вы не
> родили.
IMHO наоборот.
Пока ты голословно, без единого аргумента утверждаешь о том, что в Фортране
"массивы быстрее работают" и, вообще, он "под матричные операции заточен",
мешая при этом в кучу язык, компиляторы и библиотеки.

> Я же привел вам достаточно примеров, где Си окакался.
Пока я ни одного не увидел.

Ты УТВЕРЖДАЕШЬ, что привел, не ты их НЕ приводил в том виде, чтобы я мог
тебя проверить.

напоследок 2 Di-Hard:

======

LamerOk (*) (2002-11-22 02:43:39.496): > не многовато ли у тебя printf'ов для оценки > производительности то ?? Многовато! Мысль была такая: тупо в лоб переписать типичный фортрановский код на Си и сравнить. Просто - стандартные средства. Извини, но под Сями кроме printf'а ничего высокоуровневого нет.

======

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

Ты сам посмотри: вывод мегабайта текста при обращении одной матрицы! Ты что меряешь-то? Часы или трусы?

И с чего ты назвал ЭТО типичным "фортрановским кодом"? Типичный фортрановский код записывает промежуточное насчитанное состояние раз эдак в полчаса. Прикинь сам, какой там процент ввода-вывода. Причем отнюдь не в текстовый файл.

====== Ты УТВЕРЖДАЕШЬ, что привел, не ты их НЕ приводил в том виде, чтобы я мог тебя проверить. ======

2 примера выложены с исходниками и экзешниками. Адреса для скачивания даны выше. Чего еще надо? Только не говори, что у тебя нет доступа ни к одному компу с виндами.

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

В общем, я пошел проверять мыльницу. Пока там не появится чего-либо интересного, сюда я заходить не буду. Так что можешь сказать в треде последнее слово, если это хоть немного утешит твое самолюбие. =)

2 anonymous (*) (2002-11-22 18:49:49.633) & all:

fortranrulez.front.ru/testvector.zip fortranrulez.front.ru/testmatmul.zip

HTML-ей там нет.

2 ARia:

Ваш пример был бы действительно интересен. Жду с нетерпением. Адрес вы знаете.

anonymous (*) (2002-11-22 19:00:15.319):
> Только не говори, что у тебя нет доступа ни к одному компу с виндами.
Нету.

> Адреса для скачивания даны выше.
"На деревню дедушке" ?

> fortranrulez.front.ru/testvector.zip fortranrulez.front.ru
Что это такое?

> вывод мегабайта текста при обращении одной матрицы!
Ок, закомментарь вывод в обеих прогах.

То же самое, что с массивами по столбцам.
Прежде, чем впадать в религиозный экстаз,
1. Попробуй сам.
2. Подумай, почему так получилось.

Нет такого домена fortranrulez.front.ru, как я и написал выше

Специально для пуристов (для тех, у кого нет Винды):

<pre>

1.======

#include <stdio.h> #include <time.h>

extern void MATMULDO_1(); extern void MATMULDO_2();

int main(){ clock_t start, end; start = clock(); MATMULDO_1(); end = clock(); printf("MATMULDO_1: %f\n",(end-start)/((double)CLOCKS_PER_SEC)); start = clock(); MATMULDO_2(); end = clock(); printf("MATMULDO_2: %f\n",(end-start)/((double)CLOCKS_PER_SEC)); start = clock(); matmulc(); end = clock(); printf("matmulc : %f\n",(end-start)/((double)CLOCKS_PER_SEC)); }

2.======

#include <stdio.h>

#define IS 400

int i[IS][IS],j[IS][IS],r[IS][IS];

void matmulc(void) { register int m,k,l,n; FILE* fp;

for(n=0;n<20;n++) {

for(k=0;k<IS; k++) for(l=0;l<IS; l++){ i[k][l]=3; j[k][l]=4; }

for(k=0;k<IS; k++) for(l=0;l<IS; l++){ r[k][l]=0; for(m=0;m<IS; m++) r[k][l]+=i[k][m]*j[m][l]; }

}

fp = fopen("matmulc.txt","w"); fprintf(fp, " %d\n",r[1][1]); fclose(fp);

}

3.======

SUBROUTINE MATMULDO_1

PARAMETER (IS=400) INTEGER R(IS,IS),I(IS,IS),J(IS,IS),K,L,M,N

DO N=1,20

DO K = 1, IS DO L = 1, IS I(K,L) = 3 J(K,L) = 4 ENDDO ENDDO

DO K = 1, IS DO L = 1, IS R(K,L) = 0 DO M = 1, IS R(K,L) = R(K,L)+I(K,M)*J(M,L) ENDDO ENDDO ENDDO

END DO OPEN (13, FILE='matmuldo1.txt') WRITE(13,10) R(2,2) 10 FORMAT(400(' ',I5)) CLOSE(13)

END

4.======

SUBROUTINE MATMULDO_2

PARAMETER (IS=400) INTEGER R(IS,IS),I(IS,IS),J(IS,IS),K,L,M,N

DO N=1,20

I = 3 J = 4

R = MATMUL(I,J)

END DO

OPEN (13, FILE='matmuldo2.txt') WRITE(13,10) R(2,2) 10 FORMAT(400(' ',I5)) CLOSE(13)

END

===RESULTS:=== Compaq Fortran DF 6.6B & MSVC 6 SP5 на P||| 800:

F:\>cl /c /O2 main.c matmulc.c Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 12.00.8804 for 80x86 Copyright (C) Microsoft Corp 1984-1998. All rights reserved.

main.c matmulc.c Generating Code...

F:\>df /optimize:5 /c matmuldo1.f90 matmuldo2.f90 Compaq Visual Fortran Optimizing Compiler Version 6.6 (Update B) Copyright 2001 Compaq Computer Corp. All rights reserved.

matmuldo1.f90 df: info: Some interprocedural optimizations may be disabled when compiling into separate object files matmuldo2.f90

F:\>link main.obj matmulc.obj matmuldo1.obj matmuldo2.obj Microsoft (R) Incremental Linker Version 6.00.8447 Copyright (C) Microsoft Corp 1992-1998. All rights reserved.

F:\>main.exe MATMULDO_1: 7.400000 MATMULDO_2: 5.208000 matmulc : 22.212000

</pre>

2 anonymous (*) (2002-11-22 20:06:25.105)

Я не знаю что там есть и чего нет, но если засунуть 2 указанные адреса зип-файлов в качалку, все прекрасно скачивается. Только что проверил.

ЗЫ: как у вас форматирование включают, блин?

А, вот как:

1.

#include <stdio.h>
#include <time.h>

extern void MATMULDO_1();
extern void MATMULDO_2();

int main(){
   clock_t start, end;
   start = clock();
   MATMULDO_1();
   end = clock();
   printf("MATMULDO_1: %f\n",(end-start)/((double)CLOCKS_PER_SEC));
   start = clock();
   MATMULDO_2();
   end = clock();
   printf("MATMULDO_2: %f\n",(end-start)/((double)CLOCKS_PER_SEC));
   start = clock();
   matmulc();
   end = clock();
   printf("matmulc   : %f\n",(end-start)/((double)CLOCKS_PER_SEC));
}

2.

#include <stdio.h>

#define IS 400


int i[IS][IS],j[IS][IS],r[IS][IS];

void matmulc(void)
{
   register int m,k,l,n;
   FILE* fp;

   for(n=0;n<20;n++) {

   for(k=0;k<IS; k++)
   for(l=0;l<IS; l++){
      i[k][l]=3;
      j[k][l]=4;
   }

   for(k=0;k<IS; k++)
   for(l=0;l<IS; l++){
      r[k][l]=0;
      for(m=0;m<IS; m++)
         r[k][l]+=i[k][m]*j[m][l];
   }

   }

   fp = fopen("matmulc.txt","w");
   fprintf(fp, " %d\n",r[1][1]);
   fclose(fp);

}

3.

      SUBROUTINE MATMULDO_1

      PARAMETER (IS=400)
      INTEGER R(IS,IS),I(IS,IS),J(IS,IS),K,L,M,N

      DO N=1,20

      DO K = 1, IS
      DO L = 1, IS
      I(K,L) = 3
      J(K,L) = 4
      ENDDO
      ENDDO

      DO K = 1, IS
      DO L = 1, IS
      R(K,L) = 0
      DO M = 1, IS
      R(K,L) = R(K,L)+I(K,M)*J(M,L)
      ENDDO
      ENDDO
      ENDDO

      END DO
      
      OPEN (13, FILE='matmuldo1.txt')
      WRITE(13,10) R(2,2)
 10   FORMAT(400(' ',I5))
      CLOSE(13)

      END

4.

      SUBROUTINE MATMULDO_2

      PARAMETER (IS=400)
      INTEGER R(IS,IS),I(IS,IS),J(IS,IS),K,L,M,N

      DO N=1,20

      I = 3
      J = 4

      R = MATMUL(I,J) 

      END DO

      OPEN (13, FILE='matmuldo2.txt')
      WRITE(13,10) R(2,2)
 10   FORMAT(400(' ',I5))
      CLOSE(13)

      END

5.

F:\>cl /c /O2 main.c matmulc.c
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 12.00.8804 for 80x86
Copyright (C) Microsoft Corp 1984-1998. All rights reserved.

main.c
matmulc.c
Generating Code...

F:\>df /optimize:5 /c matmuldo1.f90 matmuldo2.f90
Compaq Visual Fortran Optimizing Compiler Version 6.6 (Update B)
Copyright 2001 Compaq Computer Corp. All rights reserved.

matmuldo1.f90
df: info: Some interprocedural optimizations may be disabled when compiling into separate object files
matmuldo2.f90

F:\>link main.obj matmulc.obj matmuldo1.obj matmuldo2.obj
Microsoft (R) Incremental Linker Version 6.00.8447
Copyright (C) Microsoft Corp 1992-1998. All rights reserved.


F:\>main.exe
MATMULDO_1: 7.400000
MATMULDO_2: 5.208000
matmulc   : 22.212000

Теперь всем видно?

И заодно повторяю самый первый тест:

1.

#include <stdio.h>
#include <time.h>
extern void XORSWAP();
extern void XORSWAPDO();
int main(){
   clock_t start, end;
   start = clock();
   xorswap_c();
   end = clock();
   printf("xorswap_c: %f\n",(end-start)/((double)CLOCKS_PER_SEC));
   start = clock();
   XORSWAPDO();
   end = clock();
   printf("XORSWAPDO.f: %f\n",(end-start)/((double)CLOCKS_PER_SEC));
   start = clock();
   XORSWAP();
   end = clock();
   printf("XORSWAP.f: %f\n",(end-start)/((double)CLOCKS_PER_SEC));
}

2.

#include <stdio.h>
#include <time.h>
void xorswap_c() {
   int i[260][260], j[260][260], k, l, m;
   FILE* fp;
   clock_t start, end;
   start = clock();
   for (l = 0; l < 260; ++l) {
      for (m = 0; m < 260; ++m) {
         i[l][m] = 1;
         j[l][m] = 2;
      }
   }
   for (k = 0; k < 1000001; ++k) {
      for (l = 20; l < 200; ++l) {
         for (m = 60; m < 195; ++m) {
            i[l][m] ^= j[l][m];
            j[l][m] ^= i[l][m];
            i[l][m] ^= j[l][m];
         }
      }
   }
   fp = fopen("out_c.txt","w");
   for (l = 0; l < 260; ++l) {
      for (m = 0; m < 260; ++m) {
         fprintf(fp, "%2d", i[l][m]);
      }
      fprintf(fp, "\n");
   }
   fclose(fp);
   end = clock();
}

3.

      SUBROUTINE XORSWAPDO
      INTEGER, PARAMETER :: ILU = 20, JLU = 60, L = 180, M = 135,
     *                      IM = 260, JM = 260, KMAX = 1000001
      INTEGER, DIMENSION(IM,JM) :: I, J
      DO JJ = 1, JM
         DO II = 1, IM
            I(II,JJ) = 1
            J(II,JJ) = 2
         END DO
      END DO
      DO K = 1, KMAX
         DO JJ = JLU, JLU+M
            DO II = ILU, ILU+L
               I(II,JJ) = IEOR(I(II,JJ),J(II,JJ))
               J(II,JJ) = IEOR(J(II,JJ),I(II,JJ))
               I(II,JJ) = IEOR(I(II,JJ),J(II,JJ))
            END DO
         END DO
      END DO
      OPEN(13, file='out_fdo_2.txt')
      WRITE(13,'(100I2)') I
      CLOSE(13)
      END

4.

      SUBROUTINE XORSWAP
      INTEGER, PARAMETER :: ILU = 20, JLU = 60, L = 180, M = 135,
     *                      IM = 260, JM = 260, KMAX = 1000001
      INTEGER, DIMENSION(IM,JM) :: I, J
      DO K = 1, KMAX
         I(ILU:ILU+L,ILU:ILU+M) =
     *      IEOR(I(ILU:ILU+L,ILU:ILU+M),
     *           J(JLU:JLU+L,JLU:JLU+M))
         J(JLU:JLU+L,JLU:JLU+M) =
     *      IEOR(J(JLU:JLU+L,JLU:JLU+M),
     *           I(ILU:ILU+L,ILU:ILU+M))
         I(ILU:ILU+L,ILU:ILU+M) =
     *      IEOR(I(ILU:ILU+L,ILU:ILU+M),
     *           J(JLU:JLU+L,JLU:JLU+M))
      END DO
      OPEN(13, file='out_f90_2.txt')
      WRITE(13,'(100I2)') I
      CLOSE(13)
      END

[тут 2 варианта оптимизации, дабы показать, что в зависимости от типа оптимизации Си может быть выпорот как циклами, так и массивными операциями]

5.1.

F:\MyWork\TEST\FROMMAIN>cl /O2 /c main.c xorswap.c
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 12.00.8804 for 80x86
Copyright (C) Microsoft Corp 1984-1998. All rights reserved.

main.c
xorswap.c
Generating Code...

F:\MyWork\TEST\FROMMAIN>df /compile_only /optimize:5 /object:fortran.obj xorswapdo.f xorswapf.f
Compaq Visual Fortran Optimizing Compiler Version 6.6 (Update B)
Copyright 2001 Compaq Computer Corp. All rights reserved.

xorswapdo.f
xorswapf.f

F:\MyWork\TEST\FROMMAIN>link main.obj xorswap.obj fortran.obj
Microsoft (R) Incremental Linker Version 6.00.8447
Copyright (C) Microsoft Corp 1992-1998. All rights reserved.


F:\MyWork\TEST\FROMMAIN>main.exe
xorswap_c: 318.508000
XORSWAPDO.f: 375.089000
XORSWAP.f: 148.594000

5.2

F:\MyWork\TEST\FROMMAIN>cl /O2 /c main.c xorswap.c
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 12.00.8804 for 80x86
Copyright (C) Microsoft Corp 1984-1998. All rights reserved.

main.c
xorswap.c
Generating Code...

F:\MyWork\TEST\FROMMAIN>df /compile_only /fast /object:fortran.obj xorswapdo.f xorswapf.f
Compaq Visual Fortran Optimizing Compiler Version 6.6 (Update B)
Copyright 2001 Compaq Computer Corp. All rights reserved.

xorswapdo.f
xorswapf.f

F:\MyWork\TEST\FROMMAIN>link main.obj xorswap.obj fortran.obj
Microsoft (R) Incremental Linker Version 6.00.8447
Copyright (C) Microsoft Corp 1992-1998. All rights reserved.


F:\MyWork\TEST\FROMMAIN>main.exe
xorswap_c: 314.842000
XORSWAPDO.f: 179.198000
XORSWAP.f: 377.913000

Всем видно?

Вот так то.

anonymous (*) (2002-11-22 20:21:36.44):
Ну, ты даешь...

> Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 12.00.8804
> for 80x86
сравнивать с
> Compaq Visual Fortran Optimizing Compiler Version 6.6 (Update B)

Короче, дабы не зацикливаться на библиотеках, я твой MATMULDO_2 выкинул,
и прогнал твой пример на ОДНОМ И ТОМ ЖЕ компилере - g77/gcc.
Результат меня потряс:
MATMULDO_1: 266.606002
matmulc : 71.213818

Ок, спишем на то, что g77 вряд ли кто всерьез рассматривает как
работоспособную приблуду, хотя это IMHO как раз демонстрирует трудности
Фортрана - ядро-то одно! - и повторим тест на "компаковских" компилерах.
(DIGITAL Fortran 90 compiler и DEC C V5.8-009 on Digital UNIX V4.0)
Конечно, не один и тот же компилер, но все ж родственники.
Результат:
MATMULDO_1: 36.931856
matmulc : 35.281922

Короче, нравится Фортран юзать - продолжай. Привет от Леопольда фон Мазоха!
:-)

Die-Hard

> Знаешь, у меня своих дел хватает. Я и так тут толкусь чрезмерно:(

Дык я и сам сделаю. Мне просто данные нужны в мало-мальски приличном объеме. Я пошарился по сайтам со статистикой (давно уже ищу) - НИИфига подходящего... :-((

from ARia:

Так, только что письмо пришло из окамловой рассылки. Как раз в тему.

Introduction
------------

The language shootout page has some nice examples where Bigloo and OCaml stacked up well when compared to C. But I think this is only valid for the micro benchmarks. Take the matrix-matrix multiplication (MM) for example. Though, rarely ever will you be in dire need for a matrix-matrix multiplication, because there exists better methods for solving problems in linear algebra. However, the matrix-matrix multiplication is useful to check some facts.

Method
------

I downloaded the codes for the MM from the language shootout page and adapted the examples as follows: The overall code scaffolding has been left as it was with the original version on the language shootout page:

a) The dimension is increased to 512x512
b) The run is just performed for one MM
c) The arrays are double precision


Results and Discussion
-----------------------

Though, the published MM codes at the language shootout page do not use any sophisticated constructs like loop unrolling or the like, they can nevertheless be used because they are consistent within their specific programming language namely C, C++, Scheme (Bigloo), OCaml, Python and Fortran 90/95. However, I have assumed that the posted codes there are posted by masters of their specific language (not every code has been written by the owner of the language shootout page).

The code can be found at the end of this post. It is easy to copy and paste it for own tests: memory has been observed via "top":

compile
			real/usr/sys  		memory
--------------------------------------------------------------
bigloo -Obench bench.scm	22s/22s/0.1s		6%
bigloo -Obench bench.scm	1m30s/1m30s/0.3s	30%	
ocamlopt bench.ml		38s/38s/0.1s		3%
g++ -O6 bench.c			8s/8s/0.1s		3%
g++ -O6 bench.cpp               8.5s/8.5s/0.1s          5%
python bench.py                 4m16s/4m16s/0.1s        6%
ifc -O3 bench.f90               13s/13s/0.04s           3%

[suffixes: scm...Scheme (Bigloo); ml...OCaml; c...gnu C; cpp...gnu C++; py...Python; f90...Fortran 90/95]
	
[Machine: laptop Celeron 1000MHz, RAM 256MB, SuSE Linux 8.0, gcc, bigloo 2.5a, ocaml 3.04, Python 2.2, Intel Fortran 90/95]

The second Bigloo version uses ordinary "+" and "-" operators. The first version uses Bigloo's operators "+fl", "+fx",... It is incomprehensible why the second ordinary Bigloo version uses that much on memory! For a dimension of 1024x1024 the overall timing picture is the same, except that the normal Bigloo version consumes 80% of the memory as compared to the C version which consumes 20%.

Especially important is the fact that the Python version stacks up very well; you may not forget Python is just interpreted and not compiled.

The elegant C++ version is of interest too, because it relies on the vector container and it is possible to completely avoid the awful "*".

Some note to the Fortran version: Fortran starts at 1 (C starts at 0) when indexing arrays; and the first index runs faster (in C the second index runs faster). Reading from left to right is more natural (index wise), so using C arrays is way more pleasant. Bigloo uses C's array indexing scheme. I hate Fortran for this array indexing nightmare and hope I didn't mix things up because I was a little bit surprised that C is faster than Fortran 90. The Fortran 90/95 compiler stems from Intel and is the one and only free  Fortran 90/95 compiler available for Linux (go to the Intel site and download the 50MB if you need a Fortran 90/95 compiler). Nowadays times are over were Fortran is that much faster than C/C++ on ordinary home PCs. Computing in Science and Engineering had once a nice article (Theurich, G., et al., 2001: "Making the Fortran-To-C
Transition: How Painful is it Really?", January/February 2001, p.21) about translating  a 20,000 lines of code program (in the field of
chemistry) from Fortran 77 to C. Everybody would have excpected that the C version runs slower than the original Fortran version, but it turned out that the C version runs even slightly faster than the Fortran version.


Before you scream:

a) I am sure there exists an ocaml option for further optimizations; "ocamlopt --help" did not unveil it.

b) The Bigloo (Scheme) version could surely be improved but how? /I mean not the code scheme itslef, because this should remain consistent as compared to the other code versions./ Fore example transposing one array is not allowed, because this would not only reduce Bigloo's execution time but also the time of the C version would be reduced by a factor of 2. Surely, there exists the caveat: But mum told me, we should not use the same algorithms for every programming language. But mum didn't tell  that often the reality does not let you do so. And in addition mum did not tell you that you are not a Forth programmer.

c) I post it here for soliciting comments. I could have gone to bed to construe my own explanations and theories. But this would likely result in a desaster, because most of the time it isn't how I would like that it is.

The original language shootout page results on the MM are misleading:

a) Pure integers are hardly ever used in reality
b) Problems often do not fit into the cache
c) A comparsion of the FFT would be more interesting


Conclusion
----------

Nevertheless Bigloo remains still a very decent compiler in my opinion, and I do not regret that I have made the transition from Python (which is one of the most confusing programming languages out there) to Scheme speak Bigloo. People should be more wary that consulting the language shootout page can result in misleading conclusions; as you know: benchmarking is black art.

S. Gonzi
APPENDIX:
===============================
Normal Bigloo version
original v.: (C) M. Serrano
usage: bigloo -Obench bench.scm
       time ./a.out
===============================
(module bench-matrix)


(define (mkmatrix rows cols)
  (let ((mx (make-vector rows 0.0))
	(count 1.0))
    (do ((i 0 (+ i 1)))
	((= i rows))
      (let ((row (make-vector cols 0.0)))
	(do ((j 0 (+ j 1)))
	    ((= j cols))
	  (vector-set! row j count)
	  (set! count (+ count 1.0)))
	(vector-set! mx i row)))
    mx))

(define (num-cols mx)
  (let ((row (vector-ref mx 0)))
    (vector-length row)))

(define (num-rows mx)
  (vector-length mx))

(define (mmult rows cols m1 m2)
  (let ((m3 (make-vector rows 0.0)))
    (do ((i 0 (+ 1 i)))
	((= i rows))
      (let ((m1i (vector-ref m1 i))
	    (row (make-vector cols 0.0)))
	(do ((j 0 (+ 1 j)))
	    ((= j cols))
	  (let ((val 0.0))
	    (do ((k 0 (+ 1 k)))
		((= k cols))
	      (set! val (+ val (* (vector-ref m1i k)
				  (vector-ref (vector-ref m2 k) j)))))
	    (vector-set! row j val)))
	(vector-set! m3 i row)))
    m3))


(define (do-main size)
  (let ((mm 0.0)
	(m1 (mkmatrix size size))
	(m2 (mkmatrix size size)))
    (set! mm (mmult size size m1 m2))
    (let ((r0 (vector-ref mm 0))
	  (r2 (vector-ref mm 2))
	  (r3 (vector-ref mm 3))
	  (r4 (vector-ref mm 4)))
      (print (vector-ref r0 0) " " (vector-ref r2 3) " "
		  (vector-ref r3 2) " " (vector-ref r4 4)))))

(do-main 512)
====

===============================
Bigloo version based on +fl,...
original v.: (C) M. Serrano
usage: bigloo -Obench bench.scm
       time ./a.out
===============================
(module bench-matrix
	(option (set! *genericity* #f)))


(define (mkmatrix rows cols)
  (let ((mx (make-vector rows 0.0))
	(count 1.0))
    (do ((i 0 (+fx i 1)))
	((=fx i rows))
      (let ((row (make-vector cols 0.0)))
	(do ((j 0 (+fx j 1)))
	    ((=fx j cols))
	  (vector-set! row j count)
	  (set! count (+fl count 1.0)))
	(vector-set! mx i row)))
    mx))

(define (num-cols mx)
  (let ((row (vector-ref mx 0)))
    (vector-length row)))

(define (num-rows mx)
  (vector-length mx))

(define (mmult rows cols m1 m2)
  (let ((m3 (make-vector rows 0.0)))
    (do ((i 0 (+fx 1 i)))
	((=fx i rows))
      (let ((m1i (vector-ref m1 i))
	    (row (make-vector cols 0.0)))
	(do ((j 0 (+fx 1 j)))
	    ((=fx j cols))
	  (let ((val 0.0))
	    (do ((k 0 (+fx 1 k)))
		((=fx k cols))
	      (set! val (+fl val (*fl (vector-ref m1i k)
				  (vector-ref (vector-ref m2 k) j)))))
	    (vector-set! row j val)))
	(vector-set! m3 i row)))
    m3))


(define (do-main size)
  (let ((mm 0.0)
	(m1 (mkmatrix size size))
	(m2 (mkmatrix size size)))
    (set! mm (mmult size size m1 m2))
    (let ((r0 (vector-ref mm 0))
	  (r2 (vector-ref mm 2))
	  (r3 (vector-ref mm 3))
	  (r4 (vector-ref mm 4)))
      (print (vector-ref r0 0) " " (vector-ref r2 3) " "
		  (vector-ref r3 2) " " (vector-ref r4 4)))))

(do-main 512)
====


=========================
Ocaml version
original v.: (C) M. Mottl
usage: 	ocamlopt bench.ml
        time ./a.out
=========================
let mkmatrix rows cols =
  let count = ref 1 and last_col = cols - 1
  and m = Array.make_matrix rows cols 0.0 in
  for i = 0 to rows - 1 do
    let mi = m.(i) in
    for j = 0 to last_col do
        mi.(j) <- float_of_int(!count);
        incr count done;
  done;
  m

let rec inner_loop k v m1i m2 j =
  if k < 0 then v
  else inner_loop (k - 1) (v +. m1i.(k) *. m2.(k).(j)) m1i m2 j

let mmult rows cols m1 m2 m3 =
  let last_col = cols - 1 and last_row = rows - 1 in
  for i = 0 to last_row do
    let m1i = m1.(i) and m3i = m3.(i) in
    for j = 0 to last_col do m3i.(j) <- inner_loop last_row 0.0 m1i m2 j done;
  done

let size = 512
let m1 = mkmatrix size size and m2 = mkmatrix size size
let m3 = Array.make_matrix size size 0.0;;
mmult size size m1 m2 m3;
Printf.printf "%f %f %f %f\n" m3.(0).(0) m3.(2).(3) m3.(3).(2) m3.(4).(4) ====

=======================
C version
usage: 	g++ -O6 bench.c
	time ./a.out
=======================
#include <iostream>
#include <stdlib.h>

using namespace std;

double **mkmatrix(int rows, int cols) {
    int i, j, count = 1;
    double **m = (double **) malloc(rows * sizeof(double *));
    for (i=0; i<rows; i++) {
	m[i] = (double *) malloc(cols * sizeof(double));
	for (j=0; j<cols; j++) {
	    m[i][j] = count++;
	}
    }
    return(m);
}

void zeromatrix(int rows, int cols, double **m) {
    int i, j;
    for (i=0; i<rows; i++)
	for (j=0; j<cols; j++)
	    m[i][j] = 0;
}

void freematrix(int rows, double **m) {
    while (--rows > -1) { free(m[rows]); }
    free(m);
}

double **mmult(int rows, int cols, double **m1, double **m2, double **m3) {
    int i, j, k;
    double val;
    for (i=0; i<rows; i++) {
	for (j=0; j<cols; j++) {
	    val = double(0.0);
	    for (k=0; k<cols; k++) {
		val += m1[i][k] * m2[k][j];
	    }
	    m3[i][j] = val;
	}
    }
    return(m3);
}

int main()
{
    int i, SIZE=512;

    double **m1 = mkmatrix(SIZE, SIZE);
    double **m2 = mkmatrix(SIZE, SIZE);
    double **mm = mkmatrix(SIZE, SIZE);

    mm = mmult(SIZE, SIZE, m1, m2, mm);

    cout << mm[0][0] << " " << mm[2][3] << " " << mm[3][2] << " " << mm[4][4] << endl;

    freematrix(SIZE, m1);
    freematrix(SIZE, m2);
    freematrix(SIZE, mm);
    return(0);
}
====

=========================
C++ version
(C) S. Gonzi
usage: 	g++ -O6 bench.cpp
	time ./a.out
=========================
#include <iostream>
#include <vector>

using namespace std;

vector<vector<double> > mkmatrix(int rows, int cols)
{
    double counter=double(0.0);
    vector<vector<double> > m;


    for(int i=0; i<rows; i++)
    {
	vector<double> row_vec;
	for(int j=0; j<cols; j++)
	{
	    counter = counter + 1.0;
	    row_vec.push_back(counter);
	}
	m.push_back(row_vec);
    }
	return(m);
}




vector<vector<double> > mmult(int rows, int cols,
				vector<vector<double> > m1,
			      	vector<vector<double> > m2,
			 	vector<vector<double> > m3)
{
    double val;
    for(int i=0; i<rows; i++)
    {
	for(int j=0; j<rows; j++)
	{
	    val = double(0.0);
	    for(int k=0; k<cols; k++)
	    {
		val += m1[i][k] * m2[k][j];
	    }
	    m3[i][j] = val;
	}
    }
    return(m3);
}


int main()
{
    int SIZE=512;

    vector<vector<double> > m1 = mkmatrix(SIZE,SIZE);
    vector<vector<double> > m2 = mkmatrix(SIZE,SIZE);
    vector<vector<double> > mm = mkmatrix(SIZE,SIZE);

    mm = mmult(SIZE,SIZE,m1,m2,mm);

    cout << mm[0][0] << " " << mm[2][3] << " " << mm[3][2] << " " << mm[4][4] << endl;

    return(0);
}
====


=============================
Python version
usage: 	time python  bench.py
=============================
def mkmatrix(rows, cols):
    count = 1.0
    mx = [ None ] * rows
    for i in xrange(rows):
        mx[i] = [0] * cols
        for j in xrange(cols):
            mx[i][j] = count
            count += 1.0
    return mx

def mmult(rows, cols, m1, m2):
    m3 = [ None ] * rows
    for i in xrange( rows ):
        m3[i] = [0] * cols
        for j in xrange( cols ):
            val = 0.0
            for k in xrange( cols ):
                val += m1[i][k] * m2[k][j]
            m3[i][j] = val
    return m3

size = 512

def main():
    m1 = mkmatrix(size, size)
    m2 = mkmatrix(size, size)
    mm = mmult(size, size, m1, m2)
    print mm[0][0], mm[2][3], mm[3][2], mm[4][4]

main()
====

=============================
Intel Fortran 90/95 version
(C) Siegfried Gonzi
usage: 	ifc -O3  bench.f90
        timer ./a.out
=============================
program main
  integer:: size=512
  double precision, POINTER,dimension(:,:):: m1, m2, mm

  call mkmatrix(size,size,m1)
  call mkmatrix(size,size,m2)
  call mkmatrix(size,size,mm)

  call mmult(size,size,m1,m2,mm)

  print *, mm(1,1)

  deallocate(m1)
  deallocate(m2)
  deallocate(mm)

contains

subroutine mkmatrix(rows, cols,m)
  integer, intent(in):: rows, cols
  double precision, POINTER, dimension(:,:):: m
  double precision:: counter
  integer:: i,j

  allocate(m(rows,cols))

  counter = 1.0
  do i=1,cols
     do j=1,rows
        counter = counter + 1.0
        m(j,i) = counter
     end do
  end do
end subroutine mkmatrix


subroutine mmult(rows, cols, m1, m2, m3)
  integer, intent(in):: rows, cols
  double precision, dimension(rows,cols), intent(in):: m1, m2
  double precision, dimension(rows,cols), intent(in out):: m3
  double precision:: val
  integer:: i,j,k

  do i=1,rows
     do j=1,rows
        val = 0.0
        do k=1,cols
           val = val + m1(k,i)*m2(j,k)
        end do
      m3(j,i) = val
      end do
   end do
end subroutine mmult
end program main
====

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/ Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Сорри, не переключил.

2 Die-Hard (& 2 ARia too)

======

Ну, ты даешь...

> Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 12.00.8804 > for 80x86 сравнивать с > Compaq Visual Fortran Optimizing Compiler Version 6.6 (Update B)

[плюс тесты с участием интеловских компилеров]

======

Конечно, из преимущества одного компилятора над другим еще не следует, что язык А превосходит язык B. Однако хочу заметить, что лично я этим летом пробовал (как для реальных задач, так и для этих примеров) на 2-х одинаковых PIII gcc (Linux & Windows), Intel С++ (Linux), IBM VA C++ (Windows), Intel Fortran (Linux), а также все компиляторы Фортрана и F, которые удалось достать под Windows. Дековского С у меня не оказалось к сожалению, поэтому лично проверить не могу (не знаю, кстати, есть ли он под винду, потому что сейчас линукс мне не подходит). Короче, все вышеуказанное, будучи опробованным, лично в моей практике на моих примерах оказалось хуже компаковского фортрана. А MSVC при этом в большинстве случаев тормозил лишь немного сильнее, чем icc и gcc. Повторять же снова летние исследования производительности десятка-другого компиляторов только для того, чтобы показать их Дай-Харду (тем более что в него олько Линукс), мне немного впадлу и некогда. Единственное что я хочу сказать здесь - MSVC не так ужасен на самом деле в плане производительности.

Кстати, Дай-Хард, а все-таки в каких условиях ты теституешь? Что-то твоя "числодробилка" показывает существенно худшее время по сравнению с простым третьим пнем. Она что, древняя? Или другими задачами перегружена? От тебя ведь после мега текста на одну матрицу всего ожидать можно. =)

Дальше, Дай-Харду не понравился вызов matmul и он, сославшись на "библиотеки", выкинул чисто фортрановский пример. Ладно. Но давай тогда вернемся к примеру с ксорами. Там на "библиотеки" не спишешь (т.к. битовые операции для Си даже более естественны). Допустим (если поверить тебе на слово о твоем тестировании с использованием дековского С; сам я такого пока нигде не видел), что тупую раскрутку циклов на С действительно можно сделать не хуже, чем на Фортране. Однако лучшее время для 2-х фортрановских версий (с использованием одного и того же компилятора) тоже разное, причем заметно разное. 148 и 179 (будем считать согласно твоему эксперименту, что дековский Си тоже дает примерно 179). Даже для однопроцессорного компьютера. Что и доказывает главную мысль: если в фортране не использовать везде один только do (как делается в Си согласно логике средневековых мужиков, считавших, что кроме топора, больше ничего не надо), а использовать средства языка, призванные облегчить работу с массивами (как программисту, так и компилятору), то мы добиваемся лучших результатов. Даже без помощи "библиотек" (которых лишены сишники ввиду отсутствия в Си элементных функций и которые дают не только удобство записи, но и скорость работы - не случайно же Дай-Хард выкинул тот пример. А под виндой результаты примера были при использовании одного и того же компилятора 7.4 и 5.2, неплохая ИМХО разница).

Так что буду я лучше писать на Фортране. А сишники - сами себе злобные религиозные буратины. =)

2 ARia: а как же газодинамический пример?

to last anonymous:

К сожалению, у меня сейчас нет времени на это. Как появится, напишу и протестирую.

ARia

> Но давай тогда вернемся к примеру с ксорами.

Вроде ты умный человек - вон и Голуба (который болтолог) читал. Ну так почитай его еще раз - правило

Блин, обрезало ;)

> Но давай тогда вернемся к примеру с ксорами.

Вроде ты умный человек - вон и Голуба (который болтолог) читал. Ну так почитай его еще раз - правило номер 88. И догадайся, почему твое троекратное вычисление i[l][m] j[l][m] ублюдочно в принципе.

2 IoP:

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

Да, я допускаю, что если в Си начать масштабно жонглировать памятью и указателями (думая над этим больше, чем собственно над работой), то в общем случае может и можно достичь чуть лучших результатов, чем с []. Однако не надо забывать, что разработчики встроенных подпрограмм и функций для фортрановских компиляторов тоже едят свой хлеб недаром. =)

2all:

А тот чувак, который делал запощенные выше тесты (с участием камла и интеловского фортрана), лошок похоже. Си толком не знает, Фортрана тоже толком не знает. Не знает даже того, что в целях оптимизации очень глупо ставить 512. =) Когда поставил 513 и откомпилил gcc под Линуксом (могу специально сходить еще раз в соседнюю комнату и запостить сюда листинг) те же самые варианты (после исправления ошибок), получил 4.06. Под виндой компаковский фортран выдал 3.94. Так что тот тест можно рассматривать только как глубокую бету. И то, что Фортран в полтора раза медленнее - опять глупость, опять пустые слова.

[вдогонку]

Несмотря на то, что у него

======

Machine: laptop Celeron 1000MHz, RAM 256MB, SuSE Linux 8.0, gcc, bigloo 2.5a, ocaml 3.04, Python 2.2, Intel Fortran 90/95

======

а у меня Intel PIII 800, RAM 512M и мастдай NT 4.0. Научился бы сначала на своей тачке компьютинг байтинга делать. =)

> а ты сам-то то правило внимательно дочитал до конца? Включая последний абзац?

Да, дочитал. Именно до конца. Это ты остановился после слов "оптимизатор часто может".

> Прошло то время, когда кулхацкер Вася Пупкин был умнее оптимизирующих компиляторов

Твой код опровергает это твое заявление. Увы.

> Да, я допускаю, ...

Я счастлив.

2all:

на самом деле надоело обсуждать всякую дурь. В конце концов, какая разница, если какой-нибудь шибко продвинутый сишный компилятор сможет систематически не отставать от фортрана. Это еще не будет поводом уходить с фортрана. =)

Весь этот флейм пошел из-за того, что было заявлено, якобы некий с++-аналог фортрановского кода был выполнен на порядок быстрее (не потому, что было спагетти, а потому, что был фортран). Вот на пример, доказывающий _столь существенное_ преимущество (или хотя бы раза в полтора-два) именно в традиционно фортрановской области (как бы дико не выглядел сиплюсплюсный код с какими-нибудь надстройками, ну да это дело вкуса), было бы интересно взглянуть.

Фортран я не идеализирую, и сам могу привести примеры, когда все фортрановские компиляторы генерят код тормознее сишного в десяток раз и больше (вот только это не к массивам и не к численным методам относится). =) Но мораль такая, что сишникам не надо думать, что их язык вообще самый крутой на свете - независимо от области применения.

Так что подождем, когда Aria разродится-таки примером, достойным сенсационно попасть в бенчмарки Blitz++. Вот только боюсь, что этого не произойдет в обозримом будущем. =)

Хм...

> а ты сам-то то правило внимательно дочитал до конца? Включая последний абзац? Да, дочитал. Именно до конца. Это ты остановился после слов "оптимизатор часто может".

Ничего подобного. Ты уж извини, но стиль "C = MATMUL(A,B)" - куда лучше, чем полстраницы циклов с адресной арифметикой. ИМХО. И при этом позволяющий получить по меньшей мере не менее, а часто более быстрый код.

> Прошло то время, когда кулхацкер Вася Пупкин был умнее оптимизирующих компиляторов Твой код опровергает это твое заявление. Увы.

Он ничего не опровергает. Он доказывает, что можно и нужно выбрать нормальный инструмент и писать на естественном языке задачи, а не заниматься полуассемблерным вышиванием. И в первую очередь просто не мешать работать оптимизирующему компилятору вместо того, чтобы тешить свою кулхацкерность. Так даже Керниган & Пайк писали. =)

> Да, я допускаю, ... Я счастлив.

Взаимно. =)

Вот еще интересно - как, согласно рекомендациям Голуба, правильно "соптимизировать руками" (С), например, вот такой код на С или на С++:

            CALL BIGVARFIXED(R(1), -U(1), P(1), R(1), U(1), P(1), &
                             RG(0), UG(0), PG(0), EG(0), D1O(0), D2O(0))
            DO I = 1, N-1
TAU*MATMUL(MAKEAOBR((/ R(I), U(I), P(I) /)), MAKEB((/ R(I), U(I), P(I) /))), DRUP1)
!            RUP2 = (/ R(I+1), U(I+1), P(I+1) /) - .5*MATMUL(DX(I+1)*ED + TAU*MATMUL(MAKEAOBR((/ R(I+1), U(I+1), P(I+1) /)), MAKEB((/ R(I+1), U(I+1), P(I+1) /))), DRUP2)
            CALL VBIGVARFIXED( &
(/ R(I), U(I), P(I) /) + .5*MATMUL(DX(I)*ED - TAU*MATMUL(MAKEAOBR((/ R(I), U(I), P(I) /)), &
MAKEB((/ R(I), U(I), P(I) /))), (/ DR(I), DU(I), DP(I) /)), &
(/ R(I+1), U(I+1), P(I+1) /) - .5*MATMUL(DX(I+1)*ED + TAU*MATMUL(MAKEAOBR((/ R(I+1), U(I+1), P(I+1) /)), &
MAKEB((/ R(I+1), U(I+1), P(I+1) /))), (/ DR(I+1), DU(I+1), DP(I+1) /)), &
                 RG(I), UG(I), PG(I), EG(I), D1O(I), D2O(I))
            END DO
            CALL BIGVARFIXED(R(N), U(N), P(N), R(N), -U(N), P(N), &
                             RG(N), UG(N), PG(N), EG(N), D1O(N), D2O(N))

            JJ(0) = PG(0)
            MM(1:N-1) = RG(1:N-1)*UG(1:N-1)
            JJ(1:N-1) = PG(1:N-1) + MM(1:N-1)*UG(1:N-1)
            EE(1:N-1) = MM(1:N-1)*(EG(1:N-1)+.5*UG(1:N-1)**2) + PG(1:N-1)*UG(1:N-1)
            JJ(N) = PG(N)

Любопытно было бы взглянуть! :)

Блин, не то вставил:

            CALL BIGVARFIXED(R(1), -U(1), P(1), R(1), U(1), P(1), &
                             RG(0), UG(0), PG(0), EG(0), D1O(0), D2O(0))
            DO I = 1, N-1
            CALL VBIGVARFIXED( &
(/ R(I), U(I), P(I) /) + .5*MATMUL(DX(I)*ED - TAU*MATMUL(MAKEAOBR((/ R(I), U(I), P(I) /)), &
MAKEB((/ R(I), U(I), P(I) /))), (/ DR(I), DU(I), DP(I) /)), &
(/ R(I+1), U(I+1), P(I+1) /) - .5*MATMUL(DX(I+1)*ED + TAU*MATMUL(MAKEAOBR((/ R(I+1), U(I+1), P(I+1) /)), &
MAKEB((/ R(I+1), U(I+1), P(I+1) /))), (/ DR(I+1), DU(I+1), DP(I+1) /)), &
                 RG(I), UG(I), PG(I), EG(I), D1O(I), D2O(I))
            END DO
            CALL BIGVARFIXED(R(N), U(N), P(N), R(N), -U(N), P(N), &
                             RG(N), UG(N), PG(N), EG(N), D1O(N), D2O(N))


            JJ(0) = PG(0)
            MM(1:N-1) = RG(1:N-1)*UG(1:N-1)
            JJ(1:N-1) = PG(1:N-1) + MM(1:N-1)*UG(1:N-1)
            EE(1:N-1) = MM(1:N-1)*(EG(1:N-1)+.5*UG(1:N-1)**2) + PG(1:N-1)*UG(1:N-1)
            JJ(N) = PG(N)

Ээээ нууу

MATMUL - плохой пример

Никто мне не мешает написать перемножение матриц заоптимизированное на ассемблере под определенный камень

Вот она, типичная психология сишника. :) Книги же даже указал, а вы читать не изволите.

======

Ээээ нууу MATMUL - плохой пример

Никто мне не мешает написать перемножение матриц заоптимизированное на ассемблере под определенный камень

======

1. Даже для того, чтобы заоптимизировать такую банальность, как перемножение матриц, нужно-таки для начала обратиться не к Голубу-болтолологу, а к Голубу-численнику. Прочесть хотя бы 1.1 и 1.4 и понять, что оптимизация эта зависит от 88-го правила Голуба-болтолога в последнюю очередь. А в первую очередь она зависит от совершенно других вещей. Сходите в магазин, полистайте книгу хоть на полке. И выясните для себя 2 момента: а) это весьма объемная задача б) способ ее решения не состоит в кодировании на ассемблере.

2. Нужно хотя бы общее понимать иметь, что вызовы в фортране функций и подпрограмм вроде matmul не являются просто аналогами ассемблерных вставок. Подумай например, что произойдет в реализации Си, если в самописную (ибо все нормальные коммерческие численные библиотеки фортрановские) сишную функцию, аналогичную matmul, передать на умножение блок из одной матрицы и блок из другой матрицы. А потом сделай над собой усилие, открой книжку по Фортрану, и почитай, что будет в реализации Фортрана.

Надоело общаться с кулхацкерами. ARia! Пример давай! :)

anonymous (*) (2002-11-26 11:31:56.847):

Слышь, ты уже утомил своей религиозной пургой. Найди (построй) себе Фортран-храм
и иди туда проповедовать.

ТЫ ПОРЕШЬ ЧУШЬ!!!
:-)

======

Слышь, ты уже утомил своей религиозной пургой. Найди (построй) себе Фортран-храм и иди туда проповедовать.

ТЫ ПОРЕШЬ ЧУШЬ!!! :-)

======

А нервишки-то сдают. :-)

ЗЫ: Фортран-храм уже существует и находится по адресу www.fortran.com.

Насчет фортрана для математики он хорошо подходит..... Но в свое время когда писал диплом (ничего сложного просто метод конечных элементов) считал оболочки

Я использовал фортран т.к. на нем было написанно много нужных мне процедур (преподами с кафедры) к сожалению в стадарте 77 фортрана. Да как вспомнишь как я это разбирался жуть берет. Все эти бесчисленные goto из одного конца в другой и т.д. 5 continue goto 10 ......... 20 .......... goto 30 10 ......... goto 20 30 ........ goto 5 В 90 без этих прелестей уже можно обойтись.... Но всеравно эти приколы с типом переменной по первой букве + какойнибудь клоун их переназначит в одном месте так а в другом сяк..... Все таки на мой взгляд фортрановский синтаксис из-за этих приколов малочитаем Хотя фортран врядли умрет..... а если здохнет уж точно его заменит не С\С++ (IMHO)

Zzz

Те преподы были кулхацкерами прошлого. :) К сожалению. Именно они во многом и создали имидж Фотрана, каким его представляют многие.

По своему опыту знаю, что переписанные в нормальной структурной манере процедуры такого рода начинают работать значительно быстрее (в моем случае стало лучше от полутора до двух раз).

А насчет С++ ты зря. Он, конечно, не вытеснит в обозримом будущем Фортран, особенно в параллельных вычислениях. Но он удобен и эффективен для организации расчетов не на массивах, а на сложных структурах данных. Вряд ли тут есть серьезные альтернативы ИМХО.

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

кольцевой двунаправленный список, содержащий, в свою очередь кольцевой двунаправленный список, который в свою очередь содержит кольцевой двунаправенный список ,,, и т.д. с уровнем вложенности 6. Каждое колечко в назависимости от вложенности содержит по 66 элементов. Создать список и распечатать его - вот и вся задачка. А потом и сравним C и Fortran при работе со сложными структурах данных, а не только с матрицами. (То же самое можно проделать и для деревьев (ау, фортранутый, мы хотим знать хотя бы одну современную СУБД, написанную на фортране, поделитесь, может Оракле на фортране написан? Или DB2? Или PostgreSQL?) & etc.)

А то якобы "неудачная" статистика нашего фортранофила по поводу перевода проектов c отстойных мейнфреймов (т.е.металлолома) на нормальные архитектуры напоминает следующую логику: "В Ялте больше всего людей померло от туберкулеза. Следовательно, в Ялте самый нездоровый климат."

anonymous (*) (2002-11-27 10:04:28.518):
> Хотя фортран врядли умрет...
Ну, окончательно он, конечно, не умрет, будет влачить ограниченное существование
подобно Коболу. Пока что он держится в лидерах благодаря ЦЕРНу и Дези.

> а если здохнет уж точно его заменит не С\С++
К сожалению, тенденция налицо: и в ЦЕРНе, и в Дези все библиотеки
ТОТАЛЬНО переписываются на ЦеПП. IMHO это - глупость, но дело идет к тому,
что лет через 10 Фортран вообще исчезнет (как ведущий язык) и будет заменен
именно ЦеПП.

С одной стороны это не так уж и плохо, поскольку приведет к созданию
сильнооптимизированных численных библиотек для ЦеПП, но с другой стороны -
глупость, поскольку
1) тратятся человеко-тысячелетия на лишнюю, в общем-то, работу;
2) программы, которые пишутся физиками на ЦеПП, на порядки тормознутее
программ, которые пишутся физиками на Фортране;
3) (почти) всякий физик способен одолеть Фортран, но (далеко) не всякий физик
способен выучить ЦеПП.

Возвращаясь к топику: самое печальное (гипотетическое) развитие событий -
ВСЕ языки вытесняются C# - имеет ненулевую вероятность произойти:(. Вот
уж попаримся тогда!

Кстати, фортранофил, раз вы пришли лечить сюда линуксоидов, а не линуксоиды пришли к вам в ваше застойное болото fortran.com вопрос для проверки на вшивость:

Как называется GNU asm+C библиотека для научных и инженерных расчетов, входящая в Linux для x86 и Itanium?

Если ответа не знаете, сходите в детский сад, подучитесь.

Жлу ответа, раз уж такой крутой специалист по матрицам пришел сюда народ смешить.

>>>>>

(гипотетическое) развитие событий - ВСЕ языки вытесняются C# - имеет ненулевую вероятность произойти

>>>

Скорее бы дожить до единого стандартного языка программирования C#! ;)

Эк вас набежало! :-)

======

фортранолюбивый анонимус написать програмку типа следующую: кольцевой двунаправленный список, содержащий, в свою очередь кольцевой двунаправленный список, который в свою очередь содержит кольцевой двунаправенный список ,,, и т.д. с уровнем вложенности 6

======

Фортранолюбивый анонимус заранее намекнул, что в задачах такого рода (при условии, что удельный вес операций по манипулированию данными относительно велик, конечно, в противном случае даже 88-е правило Голуба теряет смысл :) ) фортран не крут, и что такие задачи делаются не на Фортране (лично им самим на С++). Так что тренируйте внимательность и не будьте религиозны.

Кстати о птичках: есть 6-ти вложенные списки, а есть и 6-мерные массивы.

====== якобы "неудачная" статистика нашего фортранофила по поводу перевода проектов c отстойных мейнфреймов (т.е.металлолома) на нормальные архитектуры ======

Гы! :) А на каком месте в рейтинге Fortune 500 находится компания, на которую вы работаете (занимаясь не научным хобби, а зарабатывая деньги)? :)

Читать до просветления: 1) Голуба (раз уж он для вас программер в законе), 2) http://www.computerworld.com/careertopics/careers/training/story/0,10801,6068...

На ночь в качестве факультатива учите определение: "mainframe n. An obsolete device still used by thousands of obsolete companies serving billions of obsolete customers and making huge obsolete profits for their obsolete shareholders. And this year's run twice as fast as last year's.".

======

Как называется GNU asm+C библиотека для научных и инженерных расчетов, входящая в Linux для x86 и Itanium?

======

Не ибет. Как и названия иномарок, призводящихся на Украине.

Предъявите бенчмарки, где она быстрее коммерческих фортрановских библиотек. Иначе лечитесь от словоблудия.

>> Иначе лечитесь от словоблудия.

Это ты про себя? Тебя же ткнули "фэйсом об тэйбл" в то, что ты, не зная GNU MP флеймишь в линуксовом форуме. А то, что тебя не интересует, что для Cи уже давно существуют математические библиотеки не хуже фортрановских, говорит только о том, что ты просто глуп.

>>Это ты про себя? Тебя же ткнули "фэйсом об тэйбл" в то, что ты, не >>зная GNU MP

А ты хотя бы одну другую (не содержащуюся в твоем линуксовом дистрибутиве) знаешь? :)

>> флеймишь в линуксовом форуме.

Дык я ж не о Линуксе флеймлю. =)

>>А то, что тебя не интересует, что для Cи уже давно существуют >>математические библиотеки не хуже фортрановских,

На свете много чего существует. Вот возьми и приведи бенчмарки, что они не хуже. Или слабО? ,) А то тут один товарищ бенчмарки Blitz++ уже показывал. :) А после обещания пример написать исчез.

>> ты просто глуп.

Употребление соперником этого главного и последнего аргумента всегда говорит о многом. :)

anonymous (*) (2002-11-27 14:53:18.084):
> Скорее бы дожить до единого стандартного языка программирования C#! ;)
Чур на тебя! :)

Это даже круче, чем попытки насильственного введения Эсперанто на государственном уровне!

2 anonymous (*) (2002-11-27 14:42:30.391) :

Ч т о т а к о е C I C S ? :-)

>> А ты хотя бы одну другую (не содержащуюся в твоем линуксовом дистрибутиве) знаешь? :)

Не знаю. А мне это надо? Ты GNU MP сначала выучи, а потом говори, что на матричных тестах фортран делает Cи. Сидишь со своим доисторическим фортраном и сиди на здоровье, только не лезь туда, в чем не понимаешь.