gpu_malloc.c

Go to the documentation of this file.

#include "gpu_malloc.h"


gpu_malloc_t* gpu_malloc_init(int _max_segment, size_t _unit_size)
{
    gpu_malloc_t *gdata = (gpu_malloc_t*)malloc(sizeof(gpu_malloc_t));
    void *ptr = NULL;
    segment_t *s;
    cudaError_t rc;
    int i;

    gdata->base               = NULL;
    gdata->allocated_segments = NULL;
    gdata->free_segments      = NULL;
    gdata->unit_size          = _unit_size;
    gdata->max_segment        = _max_segment+2;

    rc = (cudaError_t)cudaMalloc(&ptr, (_max_segment * gdata->unit_size));
    gdata->base = ptr;
    if ((cudaSuccess != rc) || (NULL == gdata->base)) {
        free(gdata);
        return NULL;
    }
    for(i = 0 ; i < _max_segment; i++) {
        s = (segment_t*)malloc(sizeof(segment_t));
        s->next = gdata->free_segments;
        gdata->free_segments = s;
    }
    // First and last segments are persistent. Simplifies the algorithm.
    gdata->allocated_segments = (segment_t*)malloc(sizeof(segment_t));
    gdata->allocated_segments->start_index = 0;
    gdata->allocated_segments->nb_units    = 1;
    gdata->allocated_segments->nb_free     = _max_segment;

    gdata->allocated_segments->next = (segment_t*)malloc(sizeof(segment_t));
    gdata->allocated_segments->next->start_index = _max_segment+1;
    gdata->allocated_segments->next->nb_units    = 1;
    gdata->allocated_segments->next->nb_free     = 0;
    gdata->allocated_segments->next->next        = NULL;

    return gdata;
}


int gpu_malloc_fini(gpu_malloc_t *gdata)
{
    segment_t *s;
    cudaError_t rc;

    while (NULL != gdata->allocated_segments) {
        s = gdata->allocated_segments->next;
        free(gdata->allocated_segments);
        gdata->allocated_segments = s;
    }
    while( NULL != gdata->free_segments ) {
        s = gdata->free_segments->next;
        free(gdata->free_segments);
        gdata->free_segments = s;
    }
    rc = (cudaError_t)cudaFree(gdata->base);
    if (cudaSuccess != rc)
        return -1;
    gdata->max_segment = 0;
    gdata->unit_size = 0;
    gdata->base = NULL;
    return 0;
}


void* gpu_malloc(gpu_malloc_t *gdata, size_t size)
{
    int nb_units = size/gdata->unit_size;
    if (size % gdata->unit_size != 0)
        nb_units++;

    segment_t *s, *n;
    for(s = gdata->allocated_segments; s->next != NULL; s = s->next) {
        if ( s->nb_free > nb_units ) {
            if (nb_units <= 0)
                return NULL;

            n = gdata->free_segments;
            gdata->free_segments = gdata->free_segments->next;

            n->start_index = s->start_index + s->nb_units;
            n->nb_units = nb_units;
            n->nb_free = s->nb_free - n->nb_units;
            n->next = s->next;
            s->nb_free = 0;
            s->next = n;
            return (void*)(gdata->base + (n->start_index * gdata->unit_size));
        }
    }
    return NULL;
}


int gpu_free(gpu_malloc_t *gdata, void *add)
{
    segment_t *s, *p;
    int tid;

    p   = gdata->allocated_segments;
    tid = ((char*)add - gdata->base) / gdata->unit_size;

    for (s = gdata->allocated_segments->next; s->next != NULL; s = s->next) {
        if (s->start_index == tid) {
            p->next = s->next;
            p->nb_free += s->nb_units + s->nb_free;

            s->next = gdata->free_segments;
            gdata->free_segments = s;

            return 0;
        }
        p = s;
    }
    return -1;
}