/* Copyright (c) 2009 The Khronos Group Inc.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and/or associated documentation files (the

 * "Materials"), to deal in the Materials without restriction, including

 * without limitation the rights to use, copy, modify, merge, publish,

 * distribute, sublicense, and/or sell copies of the Materials, and to

 * permit persons to whom the Materials are furnished to do so, subject to

 * the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Materials.

 *

 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

 * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

 */

#ifdef __cplusplus

extern "C"

{

#endif

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#include <pthread.h>

#include "owfmemory.h"

#include "owfdebug.h"

#define MAGIK   0x05EAF00D

#define FENCE1  0xFACED00D

#define FENCE2  0xFACE50FF

#define OFFSET(x,y) ((OWFuint32)&(((x*) 0x1000)->y) - 0x1000)

typedef struct BLOCK_ {

    OWFint                      magik;

    struct BLOCK_*              next;

    const char*                 file;

    OWFint                      line;

    OWFuint32                   size;

    OWFuint32                   nInts;

    OWFint                      memory[2];

} BLOCK;

#ifdef DEBUG

static void

OWF_Memory_Shutdown(void);

#endif

static void

OWF_Memory_LockUnlockManagedBlocks(OWFboolean lock)

{

#ifndef DEBUG

    (void) lock;

#endif

#ifdef DEBUG

    /* cannot use OWF_MUTEX because it uses managed memory */

    static pthread_mutex_t mem_mutex = PTHREAD_MUTEX_INITIALIZER;

    if (lock)

    {

        pthread_mutex_lock(&mem_mutex);

    }

    else

    {

        pthread_mutex_unlock(&mem_mutex);

    }

#endif

}

static void

OWF_Memory_LockManagedBlocks()

{

    OWF_Memory_LockUnlockManagedBlocks(OWF_TRUE);

}

static void

OWF_Memory_UnlockManagedBlocks()

{

    OWF_Memory_LockUnlockManagedBlocks(OWF_FALSE);

}

OWF_API_CALL BLOCK*

OWF_Memory_GetSetManagedBlocks(BLOCK* b, OWFboolean set)

{

#ifdef DEBUG

    static BLOCK* managed_blocks = NULL;

    static OWFboolean initialized = OWF_FALSE;

    if (!initialized) {

        /* add exit handler (leak report) */

        atexit(OWF_Memory_Shutdown);

        initialized = OWF_TRUE;

    }

    if (set)

    {

        managed_blocks = b;

        return b;

    }

    else

    {

        return managed_blocks;

    }

#else

    if (set)

    {

        b = b; /* dummy code */

    }

    return NULL;

#endif

}

static BLOCK*

OWF_Memory_GetManagedBlocks()

{

    return OWF_Memory_GetSetManagedBlocks(NULL, OWF_FALSE);

}

static void

OWF_Memory_SetManagedBlocks(BLOCK* b)

{

    OWF_Memory_GetSetManagedBlocks(b, OWF_TRUE);

}

OWF_API_CALL void*

OWF_Memory_Alloc(const char* file, OWFint line, OWFuint32 size)

{

#define INT_SIZE sizeof(OWFint)

    BLOCK* block = NULL;

    /* size rounded to nearest sizeof(int)*n + 2*sizeof(int) for fences */

    OWFuint32 nInts = 2 + (((size + INT_SIZE-1) &~ (INT_SIZE-1)) >> 2);

    OWFuint32 realSize = nInts * INT_SIZE + sizeof(BLOCK);

    if (realSize > size) /* not int overflow */

    {

        block = (BLOCK*) malloc(realSize);

    }

    if (!block)

    {

        DPRINT(("Couldn't alloc %u bytes\n", size));

        return NULL;

    }

    /* populate block header */

    memset(block, 0, realSize);

    block->magik = MAGIK;

    block->file = file;

    block->line = line;

    block->size = size;

    block->nInts = nInts;

    block->memory[0] = FENCE1;

    block->memory[nInts-1] = FENCE2;

    OWF_Memory_LockManagedBlocks();

    {

        /* insert to list at position 0 */

        block->next = (BLOCK*) OWF_Memory_GetManagedBlocks();

        OWF_Memory_SetManagedBlocks(block);

    }

    OWF_Memory_UnlockManagedBlocks();

    return &block->memory[1];

}

OWF_API_CALL void

OWF_Memory_Free(void* ptr)

{

    BLOCK* block        = NULL;

    if (!ptr) {

        return;

    }

    /* POINTER ARITHMETIC HAZARD */

    block = (BLOCK*) ((OWFuint32) ptr - (OWFuint32) OFFSET(BLOCK,memory[1]));

    if (!block)

    {

        DPRINT(("Sanity check failed. Ptr was zero....\n"));

        return;

    }

    OWF_Memory_LockManagedBlocks();

    {

        BLOCK* temp             = NULL;

        BLOCK* prev             = NULL;

        OWFboolean stillExists  = OWF_FALSE;

        temp = OWF_Memory_GetManagedBlocks();

        while (temp)

        {

            /* the block is on the list? */

            if (temp == block && ptr == &temp->memory[1])

            {

                stillExists = OWF_TRUE;

                break;

            }

            prev = temp;

            temp = temp->next;

        }

        if (stillExists == OWF_TRUE)

        {

            if (MAGIK != temp->magik)

            {

                DPRINT(("Possibly corrupt or invalid block, addr = %p\n", ptr));

            }

            if (block->memory[0] != (OWFint)FENCE1)

            {

                DPRINT(("Block's start fence corrupted, addr = %p\n", ptr));

            }

            if (block->memory[block->nInts-1] != (OWFint)FENCE2)

            {

                DPRINT(("Block's end fence corrupted, addr = %p\n", ptr));

            }

            /* valid block, unlink & free it */

            if (prev)

            {

                prev->next = temp->next;

            }

            else

            {

                OWF_Memory_SetManagedBlocks(temp->next);

            }

            free(block);

        }

        else

        {

            /* possibly already freed, strangled pointer. complain. */

            DPRINT(("Block possibly freed already! (block = %p, addr = %p)\n",

                    (void*) block, ptr));

        }

    }

    OWF_Memory_UnlockManagedBlocks();

}

OWF_API_CALL void

OWF_Memory_BlockDump()

{

    BLOCK* block = OWF_Memory_GetManagedBlocks();

    /* managed blocks locked when this is executed */

    while (block)

        {

        BLOCK* next = (BLOCK*) block->next;

        if (MAGIK == block->magik)

            {

            DPRINT(("Block: %p\nFile: %s(%d)\nSize: %u bytes\n",

                            (void*) &block->memory[1],

                            block->file,

                            block->line,

                            block->size));

            }

        else

            {

            DPRINT(("Possibly corrupt or invalid block (addr = %p)\n",

                                (void*) block));

            }

        block = next;

        }

}

#ifdef DEBUG

static void

OWF_Memory_Shutdown()

{

    BLOCK* block = NULL;

    OWF_Memory_LockManagedBlocks();

    {

        if (OWF_Memory_GetManagedBlocks())

        {

            DPRINT(("======================================================================\n"));DPRINT(("MEMORY LEAK REPORT\n"));DPRINT(("======================================================================\n"));

            OWF_Memory_BlockDump();

            block = OWF_Memory_GetManagedBlocks();

            while (block)

            {

                BLOCK* next = (BLOCK*) block->next;

                if (MAGIK == block->magik)

                {

                    free(block);

                }

                block = next;

            }

            OWF_Memory_SetManagedBlocks(NULL);

        }

    }

    OWF_Memory_UnlockManagedBlocks();

}

#endif

#ifdef __cplusplus

}

#endif