Question

我和我的朋友正在尝试在linux ubuntu 16.04中开发自定义内存分配器。我们因为错误而陷入困境，这是我们的第一次我们正在尝试编写类似的代码，因此我们不是错误的最佳调试器：分段错误（核心转储）这是代码。任何人都可以帮助我们理解什么是错的？谢谢！

#include <unistd.h>
#include <string.h>
#include <pthread.h> 
#include <stdio.h>

struct header_t {   
size_t size;
unsigned is_free;
struct header_t *next; };

struct header_t *head = NULL, *tail = NULL; 
pthread_mutex_t global_malloc_lock;

struct header_t *get_free_block(size_t size)
 {  
struct header_t *curr = head;   
while(curr) {   
/* see if there's a free block that can accomodate requested size */        
if (curr->is_free && curr->size >= size)
        return curr;
    curr = curr->next; 
}   
return NULL; 
}

void free(void *block) 
{   
struct header_t *header, *tmp;
/* program break is the end of the 
process's data segment */   
void *programbreak;

if (!block)         
return;
pthread_mutex_lock(&global_malloc_lock);
header = (struct header_t*)block - 1;

/* sbrk(0) gives the current program break address */


programbreak = sbrk(0);

/*
   Check if the block to be freed is the last one in the
   linked list. If it is, then we could shrink the size of the
   heap and release memory to OS. Else, we will keep the block
   but mark it as free.      */ 

if ((char*)block + header->size == programbreak) { 
    if (head == tail) { 
        head = tail = NULL;
       } else { 
        tmp = head;             
           while (tmp) {
            if(tmp->next == tail) {
                tmp->next = NULL;
                tail = tmp;
            }
            tmp = tmp->next;
        }
    }       
/* sbrk() with a negative argument decrements the program break.
       So memory is released by the program to OS.      */


    sbrk(0 - header->size - sizeof(struct header_t)); 


    /* Note: This lock does not really assure thread
       safety, because sbrk() itself is not really
       thread safe. Suppose there occurs a foregin sbrk(N)
       after we find the program break and before we decrement
       it, then we end up realeasing the memory obtained by
       the foreign sbrk().      */      

pthread_mutex_unlock(&global_malloc_lock);
    return;
}
header->is_free = 1;
pthread_mutex_unlock(&global_malloc_lock);
}

void *malloc(size_t size)
{
    size_t total_size;
    void *block;
    struct header_t *header;
    if (!size)
        return NULL;
    pthread_mutex_lock(&global_malloc_lock);
    header = get_free_block(size);
    if (header) {
        /* Woah, found a free block to accomodate requested memory. */
        header->is_free = 0;
        pthread_mutex_unlock(&global_malloc_lock);
        return (void*)(header + 1); 
    } 
    /* We need to get memory to fit in the requested block and header 
from OS. */
    total_size = sizeof(struct header_t) + size;
    block = sbrk(total_size);
    if (block == (void*) -1) {
    pthread_mutex_unlock(&global_malloc_lock);
    return NULL;
}
header = block;
header->size = size;
header->is_free = 0;
header->next = NULL;
if (!head)
    head = header;
if (tail)
    tail->next = header;
tail = header;
pthread_mutex_unlock(&global_malloc_lock);
return (void*)(header + 1);
}

void *calloc(size_t num, size_t nsize)
{
size_t size;
void *block;
if (!num || !nsize)
    return NULL;
size = num * nsize;
/* check mul overflow */
if (nsize != size / num)
    return NULL;
block = malloc(size);
if (!block)
    return NULL;
memset(block, 0, size);
return block;
}


void *realloc(void *block, size_t size)
 {
struct header_t *header;
void *ret;
if (!block || !size)
    return malloc(size);
header = (struct header_t*)block - 1;
if (header->size >= size)
    return block;
ret = malloc(size);
if (ret) {
    /* Relocate contents to the new bigger block */
    memcpy(ret, block, header->size);
    /* Free the old memory block */
    free(block);
  }
  return ret;
 }

Answer 1

发生此问题是因为未对函数原型化[decalred]。一旦我添加了函数原型。该代码有效。

有关原型的更多信息：http://www.trytoprogram.com/c-programming/function-prototype-in-c/

Answer 2

互斥变量应该初始化，然后再将其用于应用锁定。您的global_malloc_lock未初始化。

您无法从mutex开始初始化normal variable变量。

pthread_mutex_t global_malloc_lock = 0 ;// invalid .. you may thinking since it's it declared as global it's initialized with 0 which is wrong

通过调用pthread_mutex_init()或使用PTHREAD_MUTEX_INITIALIZER ;

初始化互斥锁变量

为您的代码添加此

pthread_mutex_t global_malloc_lock = pthread_mutex_t global_malloc_lock;

自定义内存分配器 - segfault

2 个答案: