Добрый вечер

Вопрос конечно "теоретический" но все же интересно разобраться/понять. "С детства" (ну отрочества) вдалбливалось: целочисленная арифметика (намного) быстрее, всегда используйте shl вместо div и.т.п. Но так ли это сейчас (на дворе 2011 год, времена (со)процессоров давно канули в Лету)? Главное что смущает - RISC архитектура. Ведь если RISC - то (в общих чертах) все команды исполняются за 1 такт. Следовательно операции с флотами "столь же быстры" как и с int (ведь и те и те 1 такт). О каком же преимуществе int тогда идет речь?

Лично мои тесты (когда у меня есть такая возможность) показывают что целочисленная арифметика пошустрее но ни о каких "разах" не может быть и речи. А у Вас?

Спасибо

вот что у меня получилось:
конечно не разы, но 2 раза есть

C
#include <time.h>
#include <unistd.h>
#include <stdio.h>
 
double processCpuTime()
{
	struct timespec tp;
	clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &tp);
	return tp.tv_sec + tp.tv_nsec * 1.0e-9;
}
 
int main()
{
	int i;
	int ii;
	const int maxii=0xfffffff;
	double id;
	const int maxid=maxii;
	double time=processCpuTime();
 
	for(ii=0;ii<maxii;ii++);
	printf("int sum time: %g\n",processCpuTime()-time);
 
	time = processCpuTime();
	for(id=0;id<maxid;id++);
	printf("double sum time: %g\n",processCpuTime()-time);
 
	printf("=================================================\n",processCpuTime()-time);
 
	time = processCpuTime();
	for(i=0;i<10000;i++)
		for(ii=maxii;ii>1;ii/=2);
	printf("int div2 time: %g\n",processCpuTime()-time);
 
	time = processCpuTime();
	for(i=0;i<10000;i++)
		for(ii=maxii;ii>1;ii>>=2);
	printf("int shift div2 time: %g\n",processCpuTime()-time);
 
	time = processCpuTime();
	for(i=0;i<10000;i++)
		for(id=maxid;id>1;id/=2);
	printf("double div2 time: %g\n",processCpuTime()-time);
 
	printf("=================================================\n",processCpuTime()-time);
 
	time = processCpuTime();
	for(i=0;i<10000;i++)
		for(ii=maxii;ii>1;ii/=3);
	printf("int div3 time: %g\n",processCpuTime()-time);
 
	time = processCpuTime();
	for(i=0;i<10000;i++)
		for(id=maxid;id>1;id/=3);
	printf("double div3 time: %g\n",processCpuTime()-time);
 
	printf("=================================================\n",processCpuTime()-time);
 
	time = processCpuTime();
	for(i=0;i<10000;i++)
		for(ii=maxii;ii>1;ii/=7);
	printf("int div7 time: %g\n",processCpuTime()-time);
 
	time = processCpuTime();
	for(i=0;i<10000;i++)
		for(id=maxid;id>1;id/=7);
	printf("double div7 time: %g\n",processCpuTime()-time);
 
 
}
 

xmm так вроде регистры sse называются. Но всё это уже совсем другие яица... я так понял сабж именно про FPU  и на сколько он реально отстаёт от обычной целочисленной арифметики. Да и понятно, почему не большая разница в скорости, всё же sse появился сильно позже mmx.

сейчас самые задержки в процессоре на сбоях конвейера, потому что с памятью (и даже кэшем) работа намного медленнее, чем с регистрами. Один останов и перезаполнение конвейера могут стоить дороже нескольких арифметик. Даже если согласиться, что инты и правда 'по определению быстрее', то остаётся вопрос на сколько. Если на 0.01% то это всё равно что не быстрее. Если же на 50% то другое дело.

мне показалось тест не очень чистый но сейчас смотрю -- нормальный тест. Надо ещё с SSE2 сравнить. SSE2 должен инты побить

а почему не -O3?


хочется циклы немного развернуть вообще, чтобы больше обращений к памяти было, а то на холостом ходу крутится в регистрах. Ещё хотел с CUDA посравнивать, но сейчас времени нет, если руки дойдут опубликую.

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