memcpy

в MSVC, если написать

Код (Text):

1. int x;
2. memcpy(buf,&x,sizrof(x));

тогда это соптимизируется в последовательность mov (тут "mov x,y")

так будет всегда со всеми арифметическими типами?
и что у других компиляторов, например у gcc?

 

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

 

ckunep
Используй нормальный компилятор и memcpy

 

а не "в виндовсе" что? и в чем правильность?

 

бредит он, memcpy к винде не имеет отношения

 

memcpy это ф-я рантайма С, причем тут винда вообще?

 

функция memcpy С\С++ не имеет никакого отношения к *dll.memcpy

 

Зачем чтото дизасмить? Достаточно собрать свой проект достойным компилятором (Intel'овским к примеру), а потом глянуть во что он превратит memcpy, поверь, под данную платформу он сгенерит для этой ф-ции оптимальный код(причем оптимизировано будет вплоть до учета зависимости от размера данных).
Я понял твою точку зрения, но всеже топик находиться в разделе LANG.C, а значит речь идет именно о Сишной memcpy. А ОС-зависимые реализации этой ф-ции скорее всего нужны только для отдельных компонент самой ОС, врятли ктото в здравом уме в обычном приложении откажется от CRT'шной реализации этой ф-ции.

 

Достаточно прочитать 1й пост чтобы понять что человек интересуется реализацией memcpy на разных компиляторах.

 

В VS6 реализованно через цикл.
В gcc раньше тоже было через обычный цикл.

А в VS2005(не знаю как 2003) уже соптимизированно и быстрее чем rep(*)....

P.S в коде ядра Linux до чес пор через цикл...

 

Ничего подобного.
Там шаблонов гораздо больше.
Всё зависит от размера копируемых данных.
Например memcpy(dst,src,20) будет реализовано не циклом, а примерно так:

Код (Text):

1. mov eax,[src+0]
2. mov [dst+0],eax
3. mov eax,[src+4]
4. mov [dst+4],eax
5. mov eax,[src+8]
6. mov [dst+8],eax
7. mov eax,[src+0Ch]
8. mov [dst+0Ch],eax
9. mov eax,[src+10h]
10. mov [dst+10h],eax

При других размерах будет другой код.
Проверялось на VC++ 6.0 Pro SP3, Standart Edition всегда на rep movs заменяет.

 

а не проще написать свои ф-ции для работы со строками и с памятью?

Код (Text):

1. void memcpy( ... )
2. {
3.         pushad
4.         mov     esi, [ szBuf_s ]
5.         mov     edi, [ szBuf_d ]
6.         mov     ecx, [ uLen ]
7.         rep     movsb
8.         popad
9. }

 

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

 

Функции работы с памятью memcpy,memset,memmove и т.д. реализованы не только в msvcrt.dll и ее модификациях, но и в Виндовых kernel32.dll и ntdll.dll. Если уж действительно интересует оптимизация - возьмите дизассемблер и посмотрите.

 

ктонить вообще 1й пост читает, или сразу бред в последних постах?
какая оптимизация? какие msvcrt.dll ?? я спрашивал про memcpy для арифметических типов, т.е. будет ли код
memcpy(buf,&x,sizeof(x); // int x;
эквивалентен коду
*(int*)buf=x; // int x;

 

GoldFinch
Зачем тебе это? Оптимизация по определению специфична.

 

Booster
затем что если это так, (а в msvc это так), то мне не надо писать отдельный "оптимальный" код для арифметических типов, а всё копировать через memcpy

 

GoldFinch
Веселишь однако. Какой ещё оптимальный код для арифметических типов? Зачем их сувать в memcpy? cl например любит копирование в цикле менять на memcpy. Но что с того? Будешь перелопачивать все компиляторы?

 

млять, мне нада выбрать, юзать такой код:

Код (Text):

1. //только memcpy
2.  
3. struct pod_type
4. {
5.     template<typename T>
6.     static void copy(T& t)
7.     {
8.         memcpy(buf,&t,sizeof(T));
9.     }
10. }
11. template<typename T>
12. void copy(T& t)
13. {
14.     boost::mpl::if_< boost::is_pod,
15.         pod_type,
16.     //else
17.         ...
18.     >::type::copy(t);
19. }

или такой:

Код (Text):

1. //для арифметических типов - присваивание
2.  
3. struct pod_type
4. {
5.     template<typename T>
6.     static void copy(T& t)
7.     {
8.         memcpy(buf,&t,sizeof(T));
9.     }
10. }
11. struct arithmetic_type
12. {
13.     template<typename T>
14.     static void copy(T& t)
15.     {
16.         *(T*)buf = t;
17.     }
18. }
19. template<typename T>
20. void copy(T& t)
21. {
22.     boost::mpl::if_< boost::is_arithmetic<T>,
23.         arithmetic_type,
24.     //else
25.     boost::mpl::if_< boost::is_pod<T>,
26.         pod_type,
27.     //else
28.         ...
29.     >::type
30.     >::type::copy(t);
31. }

 

Зачем memcpy? Почему присваивание не устраивает?