コード例 #1
0
ファイル: stat.c プロジェクト: matthiaskrgr/gmqcc
/*
 * A basic header of information wrapper allocator. Simply stores
 * information as a header, returns the memory + 1 past it, can be
 * retrieved again with - 1. Where type is stat_mem_block_t*.
 */
void *stat_mem_allocate(size_t size, size_t line, const char *file) {
    stat_mem_block_t *info = (stat_mem_block_t*)malloc(sizeof(stat_mem_block_t) + size);
    void             *data = (void*)(info + 1);

    if(GMQCC_UNLIKELY(!info))
        return NULL;

    info->line = line;
    info->size = size;
    info->file = file;
    info->prev = NULL;
    info->next = stat_mem_block_root;

    /* likely since it only happens once */
    if (GMQCC_LIKELY(stat_mem_block_root != NULL)) {
        VALGRIND_MAKE_MEM_DEFINED(stat_mem_block_root, sizeof(stat_mem_block_t));
        stat_mem_block_root->prev = info;
        VALGRIND_MAKE_MEM_NOACCESS(stat_mem_block_root, sizeof(stat_mem_block_t));
    }

    stat_mem_block_root       = info;
    stat_mem_allocated       += size;
    stat_mem_high            += size;
    stat_mem_allocated_total ++;

    if (stat_mem_high > stat_mem_peak)
        stat_mem_peak = stat_mem_high;

    VALGRIND_MALLOCLIKE_BLOCK(data, size, sizeof(stat_mem_block_t), 0);
    return data;
}
コード例 #2
0
ファイル: stat.c プロジェクト: CurrentResident/gmqcc
/*
 * A basic header of information wrapper allocator. Simply stores
 * information as a header, returns the memory + 1 past it, can be
 * retrieved again with - 1. Where type is stat_mem_block_t*.
 */
void *stat_mem_allocate(size_t size, size_t line, const char *file, const char *expr) {
    stat_mem_block_t *info = (stat_mem_block_t*)malloc(size + IDENT_MEM_TOP);
    void             *data = (void *)((char*)info + IDENT_MEM_TOP);

    if(GMQCC_UNLIKELY(!info))
        return NULL;

    info->line = line;
    info->size = size;
    info->file = file;
    info->expr = expr;
    info->prev = NULL;
    info->next = stat_mem_block_root;
    
    /* Write identifier */
    memcpy(info + 1, IDENT_MEM, IDENT_SIZE);

    /* likely since it only happens once */
    if (GMQCC_LIKELY(stat_mem_block_root != NULL)) {
        VALGRIND_MAKE_MEM_DEFINED(stat_mem_block_root, IDENT_MEM_TOP);
        stat_mem_block_root->prev = info;
        VALGRIND_MAKE_MEM_NOACCESS(stat_mem_block_root, IDENT_MEM_TOP);
    }

    stat_mem_block_root       = info;
    stat_mem_allocated       += size;
    stat_mem_high            += size;
    stat_mem_allocated_total ++;

    if (stat_mem_high > stat_mem_peak)
        stat_mem_peak = stat_mem_high;

    VALGRIND_MALLOCLIKE_BLOCK(data, size, IDENT_MEM_TOP, 0);
    return data;
}
コード例 #3
0
ファイル: stat.c プロジェクト: matthiaskrgr/gmqcc
void *stat_mem_reallocate(void *ptr, size_t size, size_t line, const char *file) {
    stat_mem_block_t *oldinfo = NULL;
    stat_mem_block_t *newinfo;

    if (GMQCC_UNLIKELY(!ptr))
        return stat_mem_allocate(size, line, file);

    /* stay consistent with glibc */
    if (GMQCC_UNLIKELY(!size)) {
        stat_mem_deallocate(ptr);
        return NULL;
    }

    oldinfo = ((stat_mem_block_t*)ptr - 1);
    newinfo = ((stat_mem_block_t*)malloc(sizeof(stat_mem_block_t) + size));

    if (GMQCC_UNLIKELY(!newinfo)) {
        stat_mem_deallocate(ptr);
        return NULL;
    }

    VALGRIND_MALLOCLIKE_BLOCK(newinfo + 1, size, sizeof(stat_mem_block_t), 0);

    /* we need access to the old info redzone */
    VALGRIND_MAKE_MEM_DEFINED(oldinfo, sizeof(stat_mem_block_t));

    memcpy(newinfo+1, oldinfo+1, oldinfo->size);

    if (oldinfo->prev) {
        /* just need access for a short period */
        VALGRIND_MAKE_MEM_DEFINED(oldinfo->prev, sizeof(stat_mem_block_t));
        oldinfo->prev->next = oldinfo->next;
        /* don't need access anymore */
        VALGRIND_MAKE_MEM_NOACCESS(oldinfo->prev, sizeof(stat_mem_block_t));
    }

    if (oldinfo->next) {
        /* just need access for a short period */
        VALGRIND_MAKE_MEM_DEFINED(oldinfo->next, sizeof(stat_mem_block_t));
        oldinfo->next->prev = oldinfo->prev;
        /* don't need access anymore */
        VALGRIND_MAKE_MEM_NOACCESS(oldinfo->next, sizeof(stat_mem_block_t));
    }

    /* move ahead */
    if (oldinfo == stat_mem_block_root)
        stat_mem_block_root = oldinfo->next;

    /* we need access to the redzone for the newinfo block */
    VALGRIND_MAKE_MEM_DEFINED(newinfo, sizeof(stat_mem_block_t));

    newinfo->line = line;
    newinfo->size = size;
    newinfo->file = file;
    newinfo->prev = NULL;
    newinfo->next = stat_mem_block_root;

    /*
     * likely since the only time there is no root is when it's
     * being initialized first.
     */
    if (GMQCC_LIKELY(stat_mem_block_root != NULL)) {
        /* we need access to the root */
        VALGRIND_MAKE_MEM_DEFINED(stat_mem_block_root, sizeof(stat_mem_block_t));
        stat_mem_block_root->prev = newinfo;
        /* kill access */
        VALGRIND_MAKE_MEM_NOACCESS(stat_mem_block_root, sizeof(stat_mem_block_t));
    }

    stat_mem_block_root = newinfo;
    stat_mem_allocated -= oldinfo->size;
    stat_mem_high      -= oldinfo->size;
    stat_mem_allocated += newinfo->size;
    stat_mem_high      += newinfo->size;

    /*
     * we're finished with the redzones, lets kill the access
     * to them.
     */
    VALGRIND_MAKE_MEM_NOACCESS(newinfo, sizeof(stat_mem_block_t));
    VALGRIND_MAKE_MEM_NOACCESS(oldinfo, sizeof(stat_mem_block_t));

    if (stat_mem_high > stat_mem_peak)
        stat_mem_peak = stat_mem_high;

    free(oldinfo);
    VALGRIND_FREELIKE_BLOCK(ptr, sizeof(stat_mem_block_t));
    return newinfo + 1;
}