Question

我有我的C列表，我实现了push_back函数：

bool_t push_back_clist(clist_ptr pList, void* item)
{
    if(pList)
    {
        node_ptr pNode = new_node(item, pList->sizeof_item);
        if(!pNode) return FALSE;

        if(!pList->head)
            pList->head = pList->tail = pNode;
        else
        {
            pList->tail->next = pNode;
            pNode->prev = pList->tail;
            pList->tail = pNode;
        }

        pList->size++;
        return TRUE;
    }

    return FALSE;
}

static node_ptr new_node(void* data, size_t sizeof_item)
{
    node_ptr pNode = (node_ptr) malloc(sizeof(node_t));
    if(!pNode) return NULL;

     pNode->data = malloc(sizeof_item);

     if(!pNode->data)
     {
         free(pNode);
         return NULL;
     }

     memcpy(pNode->data, data, sizeof_item);
     pNode->next = pNode->prev = NULL;
     return pNode;
}

它有效，但是当我将push_back_clist函数与std::list.push_back方法进行比较时，我注意到我的函数需要大约两倍的时间。为什么？我怎样才能提高我的功能？感谢。

Answer 1

您可以一次性分配数据和节点，以节省malloc次呼叫的数量。

char* mem = malloc(sizeof(node_t)+sizeof_item);
// Check alloc here...
node_ptr pNode = (node_ptr)mem;
pNode->data = mem+sizeof(node_t);

Answer 2

我不认为你应该按照dasblinkenlight的建议进行单一分配，因为这是界面的隐式更改，另外很难记录：像这样分配的项目不能用于存储不同的数据并删除在其上找到的数据。

对于可能的优化，我认为在您的版本中，控制流可能过于复杂并且会抑制某些优化。通过直接向分配函数提供prev和next字段，尝试仅触摸新分配的项目一次。然后简化该分配函数的控制流程：

static node_ptr new_node(void* data, size_t sizeof_item, node_ptr prev, node_ptr next)
{
     void * cdata = malloc(sizeof_item);
     if(!cdata) return NULL;
     memcpy(cdata, data, sizeof_item);

     node_ptr pNode = malloc(sizeof *pNode);
     if(pNode)
       *pNode = (struct node){ .data = cdata, .prev = prev, .next = next, };
     return pNode;
}

只有拥有C99兼容编译器才能正常工作。如果不这样做，请重新考虑获得一个:)或将复合文字的使用更改为一系列赋值。

一些挑剔：

C现在有自己的布尔类型（自13年以来），如果包含bool，true，false和stdbool.h应该可以正常工作。
不会转发malloc
typedef的指针类型被C社区中的许多人认为是不好的风格

编辑：通过使用不同的版本，我发现以下内容，以使用我的设置（x86_64，linux，gcc或clang）生成最好的汇编程序

node_ptr new_node1(void* data, size_t sizeof_item, node_ptr next, node_ptr prev)
{
  node_ptr ret = NULL;
  void * nData = malloc(sizeof_item);
  if (!nData) return ret;
  struct node const nNode = {
    /* memcpy is unavoidable since nothing is known about the type of
       the data. But we can save a register by using the return value
       of memcpy. */
    memcpy(nData, data, sizeof_item),
    next,
    prev
  };
  /* Allocate the return value last so it may stay in the same return
     register */
  ret = malloc(sizeof *ret);
  if (!ret) return ret;
  /* Assignment is better than memcpy since this can just use "ret" as
     target address with offsets. */
  *ret = nNode;
  return ret;
}

Answer 3

就像人们在这里说的那样，你的列表速度是两倍，因为你每次插入都会执行2次堆操作（分配）。

从性能的角度来看，最好为节点+数据进行单一分配。此外，如果您的整体性能受到堆的显着影响，您可以（并且应该）使用备用堆。这样做可以提高性能和数量级，100倍甚至更多，这不是高估。

提高我的C list push_back功能的性能

3 个答案: