вот тут...

void bzero(void* lpBuff, int BuffSize)
{
  _asm
  {
    xor eax, eax
    mov ecx, BuffSize
    mov edi, lpBuff
    cld
    rep stosb
  }
}

Здравствуйте, Аноним, Вы писали:

А>вот тут...
А>

А>void bzero(void* lpBuff, int BuffSize)
А>{
А>  _asm
А>  {
А>    xor eax, eax
А>    mov ecx, BuffSize
А>    mov edi, lpBuff
А>    cld
А>    rep stosb
А>  }
А>}
А>

Забивается нулями в количестве BuffSize. Только очень неэффективно.

Здравствуйте, ДимДимыч, Вы писали:

ДД>Здравствуйте, Аноним, Вы писали:

А>>вот тут...
А>>

А>>void bzero(void* lpBuff, int BuffSize)
А>>{
А>>  _asm
А>>  {
А>>    xor eax, eax
А>>    mov ecx, BuffSize
А>>    mov edi, lpBuff
А>>    cld
А>>    rep stosb
А>>  }
А>>}
А>>

ДД>Забивается нулями в количестве BuffSize. Только очень неэффективно.


ответ не по теме, надо отвечать, "что с буфером", а не с lpBuff

на самом деле эффективность достаточная на маленьких размерах.

Здравствуйте, ДимДимыч, Вы писали:

ДД>Здравствуйте, Аноним, Вы писали:

А>>вот тут...
А>>

А>>void bzero(void* lpBuff, int BuffSize)
А>>{
А>>  _asm
А>>  {
А>>    xor eax, eax
А>>    mov ecx, BuffSize
А>>    mov edi, lpBuff
А>>    cld
А>>    rep stosb
А>>  }
А>>}
А>>

ДД>Забивается нулями в количестве BuffSize. Только очень неэффективно.
Хм, а как сделать эффективнее? И зачем его вообще нулями забивать?

Здравствуйте, Аноним, Вы писали:

А>Здравствуйте, ДимДимыч, Вы писали:

ДД>>Здравствуйте, Аноним, Вы писали:

А>>>вот тут...
А>>>

А>>>void bzero(void* lpBuff, int BuffSize)
А>>>{
А>>>  _asm
А>>>  {
А>>>    xor eax, eax
А>>>    mov ecx, BuffSize
А>>>    mov edi, lpBuff
А>>>    cld
А>>>    rep stosb
А>>>  }
А>>>}
А>>>

ДД>>Забивается нулями в количестве BuffSize. Только очень неэффективно.
А>Хм, а как сделать эффективнее? И зачем его вообще нулями забивать?

Что-бы в (выделенной) памяти, не было мусора. Допустим скопируешь ты туда строку ( не забив нулями ) то у тебя там будет строка+мусор и функции работы со строками, будут работать не корректно.

Здравствуйте, Аноним, Вы писали:

ДД>>Забивается нулями в количестве BuffSize. Только очень неэффективно.
А>Хм, а как сделать эффективнее?

Хотя бы вот так:

    mov ecx,BuffSize
    mov edi,lpBuff
    mov edx,ecx
    xor eax,eax
    shr ecx,2
    cld
    rep stosd
    mov ecx,edx
    and ecx,3
    rep stosb

Есть и более эффективные способы, например с использованием MMX-регистров.

А>И зачем его вообще нулями забивать?

Инициализировать массив или структуру нулями, например.
Вообще в 4.3BSD есть библиотечная функция bzero(), но она объявлена как deprecated, вместо нее рекомендуется использовать memset() с нулем.

Здравствуйте, ДимДимыч, Вы писали:

ДД>>>Забивается нулями в количестве BuffSize. Только очень неэффективно.
А>>Хм, а как сделать эффективнее?

ДД>Хотя бы вот так:
ДД>

ДД>    mov ecx,BuffSize
ДД>    mov edi,lpBuff
ДД>    mov edx,ecx
ДД>    xor eax,eax
ДД>    shr ecx,2
ДД>    cld
ДД>    rep stosd
ДД>    mov ecx,edx
ДД>    and ecx,3
ДД>    rep stosb
ДД>

гм, а если lpBuff не выровнен будет ли это эффективно?

ДД>Есть и более эффективные способы, например с использованием MMX-регистров.

А>>И зачем его вообще нулями забивать?

ДД>Инициализировать массив или структуру нулями, например.
ДД>Вообще в 4.3BSD есть библиотечная функция bzero(), но она объявлена как deprecated, вместо нее рекомендуется использовать memset() с нулем.


не мудри. вызывай memset

Здравствуйте, Сергей Мухин, Вы писали:

СМ>гм, а если lpBuff не выровнен будет ли это эффективно?

Не проверял, но думаю все же быстрее, чем побайтово заполнять, хотя и не так эффективно.
Кстати, в glibc есть вот такая реализация bzero():

void
__bzero (dstpp, len)
     void *dstpp;
     size_t len;
{
  /* N.B.: This code is almost verbatim from memset.c.  */
  int d0;
  unsigned long int dstp = (unsigned long int) dstpp;

  /* This explicit register allocation
     improves code very much indeed.  */
  register op_t x asm ("ax");

  x = 0;

  /* Clear the direction flag, so filling will move forward.  */
  asm volatile ("cld");

  /* This threshold value is optimal.  */
  if (len >= 12)
    {
      /* Adjust LEN for the bytes handled in the first loop.  */
      len -= (-dstp) % OPSIZ;

      /* There are at least some bytes to set.
     No need to test for LEN == 0 in this alignment loop.  */

      /* Fill bytes until DSTP is aligned on a longword boundary.  */
      asm volatile ("rep\n"
            "stosb" /* %0, %2, %3 */ :
            "=D" (dstp), "=c" (d0) :
            "0" (dstp), "1" ((-dstp) % OPSIZ), "a" (x) :
            "memory");

      /* Fill longwords.  */
      asm volatile ("rep\n"
            "stosl" /* %0, %2, %3 */ :
            "=D" (dstp), "=c" (d0) :
            "0" (dstp), "1" (len / OPSIZ), "a" (x) :
            "memory");
      len %= OPSIZ;
    }

  /* Write the last few bytes.  */
  asm volatile ("rep\n"
        "stosb" /* %0, %2, %3 */ :
        "=D" (dstp), "=c" (d0) :
        "0" (dstp), "c" (len), "a" (x) :
        "memory");
}

СМ>не мудри. вызывай memset

А я так и делаю.

Хм, а как это узнать, быстрее или медленее, ведь визуально это будет в ряд ли сразу заметно, может есть способ как это протестить?

Здравствуйте, Аноним, Вы писали:

А>Хм, а как это узнать, быстрее или медленее, ведь визуально это будет в ряд ли сразу заметно, может есть способ как это протестить?

Если визуально не заметно, то нечего и замерять.

Здравствуйте, Аноним, Вы писали:

А>может есть способ как это протестить?

Например замерять разность в показаниях tsc перед вызовом и после. Только замерять надо в однозадачной среде с выключенными прерываниями и для разных моделей процессора/памяти показания будут отличаться.
Как правильно заметили выше, если "визуально" не заметно, то не стоит беспокоиться.

Здравствуйте, ДимДимыч, Вы писали:

ДД>Здравствуйте, Аноним, Вы писали:

А>>может есть способ как это протестить?

ДД>Например замерять разность в показаниях tsc перед вызовом и после. Только замерять надо в однозадачной среде с выключенными прерываниями и для разных моделей процессора/памяти показания будут отличаться.
ДД>Как правильно заметили выше, если "визуально" не заметно, то не стоит беспокоиться.

А вот если с ммх, то это персонально для определенного процессора или не имеет значения,как это будет выглядеть без memset, у меня виндовс.

Здравствуйте, Аноним, Вы писали:

А>А вот если с ммх, то это персонально для определенного процессора или не имеет значения,как это будет выглядеть без memset, у меня виндовс.

Это вопрос или утверждение?

Теоретически обнуление с MMX на любом процессоре будет быстрее, чем без него. Но из-за использования MMX может быть дополнительная затрата времени на сохранение/восстановление FPU-контекста.
Вот как выглядит обнуление страницы в ядре linux:

static void fast_clear_page(void *page)
{
    int i;

    kernel_fpu_begin();
    
    __asm__ __volatile__ (
        "  pxor %%mm0, %%mm0\n" : :
    );

    for(i=0;i<4096/64;i++)
    {
        __asm__ __volatile__ (
        "  movntq %%mm0, (%0)\n"
        "  movntq %%mm0, 8(%0)\n"
        "  movntq %%mm0, 16(%0)\n"
        "  movntq %%mm0, 24(%0)\n"
        "  movntq %%mm0, 32(%0)\n"
        "  movntq %%mm0, 40(%0)\n"
        "  movntq %%mm0, 48(%0)\n"
        "  movntq %%mm0, 56(%0)\n"
        : : "r" (page) : "memory");
        page+=64;
    }
    /* since movntq is weakly-ordered, a "sfence" is needed to become
     * ordered again.
     */
    __asm__ __volatile__ (
        "  sfence \n" : :
    );
    kernel_fpu_end();
}

Но я бы советовал Вам использовать memset() и не заморачиваться.

А если вот так?

 mov  esi, [lpBuff]
    mov  ecx, [BuffSize]
    lea  esi, [esi+ecx*8]
    neg  ecx

    pxor mm0, mm0

copyloop:

    prefetchnta  [esi+ecx*8 + 512]

    movntq  qword ptr [esi+ecx*8],    mm0
    movntq  qword ptr [esi+ecx*8+8],  mm1
    movntq  qword ptr [esi+ecx*8+16], mm2
    movntq  qword ptr [esi+ecx*8+24], mm3
    movntq  qword ptr [esi+ecx*8+32], mm4
    movntq  qword ptr [esi+ecx*8+40], mm5
    movntq  qword ptr [esi+ecx*8+48], mm6
    movntq  qword ptr [esi+ecx*8+56], mm7

    add  ecx, 8
    jnz  copyloop

    sfence
    emms

Здравствуйте, Аноним, Вы писали:

А>А если вот так?

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

Здравствуйте, Аноним, Вы писали:

А>А если вот так?
А так работать не будет Я в спешке mmx-регистры забыл подправить. Так что бегом на сорсы, за нормальным вариантом Только учти, что я дал тебе не самый быстрый вариант, а наиболее универсальный, как для Intel, так и для AMD-платформы. А самый быстрый вариант будет работать еще примерно в два раза быстрее, но там придется писать два отдельных варианта, под каждый процессор.

Здравствуйте, Аноним, Вы писали:

А>Здравствуйте, Аноним, Вы писали:

А>>А если вот так?
А>А так работать не будет Я в спешке mmx-регистры забыл подправить. Так что бегом на сорсы, за нормальным вариантом Только учти, что я дал тебе не самый быстрый вариант, а наиболее универсальный, как для Intel, так и для AMD-платформы. А самый быстрый вариант будет работать еще примерно в два раза быстрее, но там придется писать два отдельных варианта, под каждый процессор.
не, с ним у меня переполнение буфера...

_crt_debugger_hook:
00402068  jmp         dword ptr [__imp___crt_debugger_hook (403058h)] 
....
00401CF9  pop         ecx  
....
00401385  mov         esp,ebp

вот с этим

    mov  esi, [lpBuff]
    mov  ecx, [BuffSize]
    lea  esi, [esi+ecx*8]
    neg  ecx

    pxor mm0, mm0

copyloop:

    prefetchnta  [esi+ecx*8 + 512]

    movntq  qword ptr [esi+ecx*8],    mm0
    movntq  qword ptr [esi+ecx*8+8],  mm0
    movntq  qword ptr [esi+ecx*8+16], mm0
    movntq  qword ptr [esi+ecx*8+24], mm0
    movntq  qword ptr [esi+ecx*8+32], mm0
    movntq  qword ptr [esi+ecx*8+40], mm0
    movntq  qword ptr [esi+ecx*8+48], mm0
    movntq  qword ptr [esi+ecx*8+56], mm0

    add  ecx, 8
    jnz  copyloop

    sfence
    emms