ИМХО и так я сно, что если на скорость мерять, то получится:

1) VC
2) builder
3) g++

Билдер изначально для дельфи был, вот и компилит с++ медленно.

Зато Дельфи сорсы сделает быстрее чем VC с++ сорсы похожего обьёма. Но это уже фичи языка.

Цитата(Perchilla @ 9.3.2005, 08:38)

А как производительность мерить будем? Прогу напишем, которая этот STLPort юзает?

Производительность на других примерах можно проверить.
sergej.z, хм.. мне всёж таки хотелось бы реальных цифр

Это сообщение отредактировал(а) chipset - 9.3.2005, 20:15

chipset блин, я не знаю, а BCB поддерживается STLPort ом?
http://www.stlport.com/dcforum/DCForumID7/2230.html
Добавлено @ 21:33
Так и знал, что с ним геморрой выйдет.

Короче говоря, если вам нужен реальный пример вот он:
Попробуйте собрать Qt с разными компилерами, ну а там скорось налицо.
У меня на машине (AMD Athlon XP+ 2200, 256 RAM, HDD 7200) под g++ собиралась 6 часиков, под Мicrosoft Visual C++ 6.0 около 30 - 40 минут.

Я думаю разница чуствуется.

При современной производительности процессоров важна не
скорость компиляции а качество кода
здесь имеет смысл сравнивать VC6/VC7/Intel
остальные отдыхают
замерять же тайминг надо у кусков кода заведомо важных
для оптимизации... скажем,
vc6 - floor() - медленный
vc71 - быстрый так как использует SSE2
intel - анологично...
и тп...
код для тайминга:
//---------------------------------------------
// CPUID use gives more accurate count
INLINE void __FASTCALL __GetTimestamp(__int64 *pTimestamp) {
__asm {
xor eax, eax ///mov eax, 0
cpuid
rdtsc
mov ebx, pTimestamp
mov dword ptr [ebx], eax
mov dword ptr [ebx+4], edx
xor eax, eax ///mov eax, 0
cpuid
}
}

or

#pragma warning(disable:4100)
// CPUID use gives more accurate count
void __fastcall GetTimestamp(__int64 *pTimestamp) {
__asm {
xor eax, eax ///mov eax, 0
cpuid
rdtsc
mov ebx, pTimestamp
mov dword ptr [ebx], eax
mov dword ptr [ebx+4], edx
xor eax, eax ///mov eax, 0
cpuid
}
}

далее что то типа


//---------------------------------------------
///NB: clicks_correct: prev return GetTimeFinalPerf() for empty f() or 0.0
/// nCountInternal: count array and oth cycle or 1
double __fastcall GetFinalPerf(double *aTics, ulong nCount, double clicks_correct, LPTSTR strmsg, ulong nCountInternal) {
ulong nCountUse;
double clicks;
if(nCount > 1) {
qsort_d(aTics, nCount);
clicks = 0;
ulong ibegin;
ibegin = nCount/3; ///calc interval 1/3: [1/3, 2/3]
register ulong i, end;
end = ibegin<<1;
for(i = ibegin; i < end; ++i)
clicks += aTics[i];

nCountUse = (end - ibegin);//(nCount/3);
clicks /= (double)nCountUse;
}
else {
nCountUse = 1;
clicks = aTics[0];
}

clicks = (clicks/GetCPUtime()) * 1000.0 - clicks_correct;
////////////////////////////////////////////////////////////////
if(strmsg)
flog("%30.40s\t%u|%d\t%15.1f ms\t%15.1f ms/cycle", strmsg, ///?strmsg:"",
nCount,
nCountUse,
clicks, clicks/(nCountInternal?nCountInternal:1));
return clicks;
}


........
//-----------------------------------------------------
///very fast !!!!!!!!!
///libNR (SCIENTIFIC COMPUTING)
void __fastcall QSORT(DTYPE_QS arr[], int n) {
--arr; ///todo: remove decrement! тяжелое наследие NRC
////////
#ifndef __CLIB_MT
static int istack[NSTACK];
#else
int istack[NSTACK];
#endif
int jstack;
jstack = 0;
int l;
l = 1;
register int ir;
ir = n;
for(;;) {
if(ir - l < M_OFF2) {
register int j;
for(j = l + 1; j <= ir; ++j) {
register DTYPE_QS a;
a = arr[j];
register int i;
for(i = j - 1; i >= l; --i) {
if(arr[i] <= a)
break;
arr[i+1] = arr[i];
}
arr[i+1] = a;
}
if(jstack == 0)
break;
ir = istack[jstack--];
l = istack[jstack--];
}
else {
register DTYPE_QS temp;
{
register int k;
k = (l + ir) >> 1;
__SWAP(arr[k],arr[l+1])
}

if(arr[l] > arr[ir]) {
__SWAP(arr[l],arr[ir])
}
if(arr[l+1] > arr[ir]) {
__SWAP(arr[l+1],arr[ir])
}
if(arr[l] > arr[l+1]) {
__SWAP(arr[l],arr[l+1])
}

register int j;
j = ir;
register DTYPE_QS a;
register int i;
i = l + 1;
a = arr[i];
for(;;) {
do i++; while (arr[i] < a);
do j--; while (arr[j] > a);
if (j < i) break;
__SWAP(arr[i], arr[j])
}
arr[l + 1] = arr[j];
arr[j] = a;
jstack += 2;
__ALGASSERT(jstack < NSTACK, "NSTACK too small in sort.", ;)
if(ir-i+1 >= j-l) {
istack[jstack] = ir;
istack[jstack - 1] = i;
ir = j-1;
}
else {
istack[jstack] = j - 1;
istack[jstack - 1] = l;
l = i;
}
}
}
}

..........

///////////////////////////////////////////////////
static double __cpu_ticks = 0.0;

#define __CPU_CHECK_TO_TIME 1
//--------------------------------------
///Time in seconds since UTC 1/1/70
double __fastcall GetCPUtime(void) {
double tmp;
if(0 == (tmp = __cpu_ticks)) {
__int64 t, t_end;
volatile time_t timer;

timer = time(NULL);
while(timer == time(NULL));
timer = time(NULL);

__GetTimestamp(&t);
while((timer + __CPU_CHECK_TO_TIME) > time(NULL));
__GetTimestamp(&t_end);

tmp = (t_end - t)/(__CPU_CHECK_TO_TIME*1000000.0);
__cpu_ticks = tmp;
}
return tmp;
}
--------------------------
использование например так:

__int64 start = 0, stop = 0;
double clicks, clicks_correct = 0;

__TYPE_OUT __FASTCALL __test1_correct(void) {
__TYPE_OUT res;
res = 0;
/////////////
start = stop = 0;
int64 start_inter, stop_inter;
for(int i = 0; i < COUNT_INTER; ++i) {
res = 0;
GetTimestamp(&start_inter);
/////////////////////////
register int j;
for(j = BEGIN_TEST_VAL; j < END_TEST_VAL; j++) {
res = res + __f1(j*TEST_STEP_D);
}
/////////////////////////
GetTimestamp(&stop_inter);
aTimes[i] = (double)(stop_inter - start_inter);
}
///////////////////////
clicks_correct = GetFinalPerf(aTimes, COUNT_INTER, 0.0, TEXT("Correct"), COUNT_TEST);
return res;
}

//--------------------------------------------------
__TYPE_OUT __FASTCALL __test1_f1_1(void) {
__TYPE_OUT res;
res = 0;
/////////////
start = stop = 0;
int64 start_inter, stop_inter;
for(int i = 0; i < COUNT_INTER; ++i) {
res = 0;
GetTimestamp(&start_inter);
/////////////////////////
register int j;
for(j = 0; j < ARRAY_SIZE; j++) {
res = res + FUNC(in[j]);
}
/////////////////////////
GetTimestamp(&stop_inter);
aTimes[i] = (double)(stop_inter - start_inter);
}
///////////////////////
GetFinalPerf(aTimes, COUNT_INTER, clicks_correct, FUNC_NAME, ARRAY_SIZE);
return res;
}

----------------------------------
main(){


res =__test1_correct_1();

res =__test1_f1_1();

}


[email protected]
http://www.sao.ru/hq/slkom

Стряхну пыль с темы..
Нам бы что-нить, чтоп можно было BC++ и VC++ сравнить

Да да да да! . Что будем компилить? STLPort в бильдере не компилиться.

Qt?

Кто сегодня самый шустрый

Dark Elf, хм, оригинально - сравнивать VB6 и C++
Однако ж, BCB там нету..

Цитата(chipset @ 28.3.2005, 10:52)

Dark Elf, хм, оригинально - сравнивать VB6 и C++

Не я ж это придумал

Цитата(chipset @ 28.3.2005, 10:52)

Однако ж, BCB там нету..

Тогда вот тебе ещё статья (смотри итоговую таблицу в конце)
Альтернативные средства разработки для Windows
А также:
Кто сегодня самый шустрый-2?

Кто сегодня самый шустрый-3?

Это сообщение отредактировал(а) Dark Elf - 28.3.2005, 11:38

Итак, для тех, кому лень просматривать эти тесты - подытожим - VC выиграл у BCB в общем случае... что большинство и так уже давно знали

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

И вероятность того что каждый может выигрывать в 1-м и проигрывать в другом. И что тогда сАмое вАжное.

Но я не против такого теста, только за

Ещё один тест

Хм. Поставил себе эклипс, и малость опупел от скорости g++
Добавлено @ 00:07
Dark Elf, супер!