御笔剑客 发表于 2019-1-27 23:41:57

关于fill函数和memset函数的效率问题

在同样的环境下，用fill函数和memset函数填充同一个数组，哪个效率更高呢？ fill函数和for循环比较呢？

行客 发表于 2019-1-28 08:32:45

本帖最后由 行客 于 2019-1-28 10:50 编辑

memset>for>fill

memset约等于用{0}初始化数组

御笔剑客 发表于 2019-1-28 13:28:04

行客 发表于 2019-1-28 08:32
memset>for>fill

memset约等于用{0}初始化数组

为神马fill函数的效率会比for循环差呢？

人造人 发表于 2019-1-28 14:09:07

在同样的环境下，用fill函数和memset函数填充同一个数组，哪个效率更高呢？ fill函数和for循环比较呢？

答案是不确定，不知道
完全取决于这个环境下的fill函数和memset函数的实现

下面贴两个memset函数的实现

/* Copyright (C) 1991 Free Software Foundation, Inc.
This file is part of the GNU C Library.

The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.

The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the GNU
Library General Public License for more details.

You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB.If
not, write to the Free Software Foundation, Inc., 675 Mass Ave,
Cambridge, MA 02139, USA.*/

#include <ansidecl.h>
#include <string.h>
#include <memcopy.h>

PTR
DEFUN(memset, (dstpp, c, len), PTR dstpp AND int c AND size_t len)
{
long int dstp = (long int) dstpp;

if (len >= 8)
    {
      size_t xlen;
      op_t cccc;

      cccc = (unsigned char) c;
      cccc |= cccc << 8;
      cccc |= cccc << 16;
      if (OPSIZ > 4)
        cccc |= cccc << 32;

      /* There are at least some bytes to set.
       No need to test for LEN == 0 in this alignment loop.*/
      while (dstp % OPSIZ != 0)
        {
          ((byte *) dstp) = c;
          dstp += 1;
          len -= 1;
        }

      /* Write 8 `op_t' per iteration until less than 8 `op_t' remain.*/
      xlen = len / (OPSIZ * 8);
      while (xlen > 0)
        {
          ((op_t *) dstp) = cccc;
          ((op_t *) dstp) = cccc;
          ((op_t *) dstp) = cccc;
          ((op_t *) dstp) = cccc;
          ((op_t *) dstp) = cccc;
          ((op_t *) dstp) = cccc;
          ((op_t *) dstp) = cccc;
          ((op_t *) dstp) = cccc;
          dstp += 8 * OPSIZ;
          xlen -= 1;
        }
      len %= OPSIZ * 8;

      /* Write 1 `op_t' per iteration until less than OPSIZ bytes remain.*/
      xlen = len / OPSIZ;
      while (xlen > 0)
        {
          ((op_t *) dstp) = cccc;
          dstp += OPSIZ;
          xlen -= 1;
        }
      len %= OPSIZ;
    }

/* Write the last few bytes.*/
while (len > 0)
    {
      ((byte *) dstp) = c;
      dstp += 1;
      len -= 1;
    }

return dstpp;
}


static inline void * memset(void * s,char c,int count)
{
__asm__("cld\n\t"
        "rep\n\t"
        "stosb"
        ::"a" (c),"D" (s),"c" (count)
        );
return s;
}

页: [1]
查看完整版本: 关于fill函数和memset函数的效率问题