Max 5 API Reference

jit.memory.c

/* 
    jit.memory.c

    Copyright 2001-2005 - Cycling '74
    Joshua Kit Clayton jkc@cycling74.com
    
*/

#include "jit.common.h"
#include "jit.cpost.h"
#include "ext_obex.h"

#ifdef WIN_VERSION
//temporary windows memory crap.
#define NewPtr          malloc
#define DisposePtr      free
#define jit_cpost       post

#ifdef USE_HANDLE_MANIA
#define MANIA_SIZE      10000
long _handle_mania_init=0;
char *_handle_mania[MANIA_SIZE];
#endif

#endif //WIN_VERSION

#define JIT_MEM_GETBYTES    0
#define JIT_MEM_NEWPTR      1

long _jit_memreg=0;
t_hashtab *_jit_memreg_hash=NULL;

/**
 *  @defgroup memorymod Memory Module
    @ingroup jitter
 */


typedef struct _jit_memreg_entry
{
    void    *p;
    long    size;
    long    pool;
} t_jit_memreg_entry;

void jit_memory_register(void *p, long size, long pool);
void jit_memory_register(void *p, long size, long pool)
{
    t_jit_memreg_entry *me=NULL;
    
    if (!_jit_memreg_hash)
        _jit_memreg_hash = hashtab_new(997);
    
    if (!p)
        jit_cpost("jit_memory_register ptr=%x size=%d pool=%d (NULL)",p,size,pool);
    else 
    {
        hashtab_lookup(_jit_memreg_hash,(t_symbol *)p,(t_object **)&me);
        if (me) {
            if (_jit_memreg>1) {
                jit_cpost("jit_memory_register ptr=%x size=%d pool=%d (REDUNDANT MEMORY)",p,size,pool);
                jit_cpost("could be memory leak of harmless mismatch of jit_getbytes(), with max freebytes()");
            }
            hashtab_chuckkey(_jit_memreg_hash,(t_symbol *)p);
            sysmem_freeptr(me);
        }
        me = (t_jit_memreg_entry *)sysmem_newptr(sizeof(t_jit_memreg_entry));
        me->p = p;
        me->size = size;
        me->pool = pool;
        hashtab_store(_jit_memreg_hash,(t_symbol *)p,(t_object *)me);
    }   
}

void jit_memory_unregister(void *p, long size, long pool);
void jit_memory_unregister(void *p, long size, long pool)
{
    t_jit_memreg_entry *me=NULL;
    
    if (!_jit_memreg_hash)
        _jit_memreg_hash = hashtab_new(997);
    
    if (!p)
        jit_cpost("jit_memory_unregister ptr=%x size=%d pool=%d (NULL)",p,size,pool);
    else
    {
        hashtab_lookup(_jit_memreg_hash,(t_symbol *)p,(t_object **)&me);
        if (!me)
            jit_cpost("jit_memory_unregister ptr=%x size=%d pool=%d (NO REGISTERED ENTRY)",p,size,pool);
        else 
        {
            hashtab_chuckkey(_jit_memreg_hash,(t_symbol *)p);
            if (me->pool!=pool)     
                jit_cpost("jit_memory_unregister ptr=%x size=%d pool=%d (MISMATCHED POOL)",p,size,pool);
            if ((pool==JIT_MEM_GETBYTES)&&(me->size!=size))     
                jit_cpost("jit_memory_unregister ptr=%x size=%d pool=%d (MISMATCHED SIZE)",p,size,pool);

            sysmem_freeptr(me);
        }
    }   
}

/**
 * Allocates a pointer to memory.
 *
 * Depending on the size requested, jit_getbytes will allocate from either the
 * faster memory pool or the system memory pool. 
 * 
 * @warning It is important to avoid mixing memory pools, and therefore to
 *          match calls to jit_getbytes and jit_freebytes.
 *
 * @ingroup memorymod 
 *
 * @param   size    size in bytes to allocate
 * 
 * @return  pointer to memory
 *
 */
void *jit_getbytes(long size)
{
    void *rv;
    
    rv = sysmem_newptr(size);

    if (_jit_memreg)
        jit_memory_register(rv,size,JIT_MEM_GETBYTES);
    return rv;

} 

/**
 * Frees a pointer to memory.
 *
 * Depending on the size of the pointer, jit_freebytes will free from either the
 * faster memory pool or the system memory pool. 
 * 
 * @warning It is important to avoid mixing memory pools, and therefore to
 *          match calls to jit_getbytes and jit_freebytes.
 *
 * @ingroup memorymod 
 *
 * @param   ptr     pointer to memory
 * @param   size    size in bytes allocated
 *
 */
void jit_freebytes(void *ptr,long size)
{
    if (_jit_memreg)
        jit_memory_unregister(ptr,size,JIT_MEM_GETBYTES);

    sysmem_freeptr(ptr);
} 

/**
 * Allocates a memory handle.
 *
 * Handles are relocatable sections of memory which should be locked
 * before dereferencing, and unlocked when not in use so that they may 
 * be relocated as necessary.
 *
 * @warning It is important to avoid mixing memory pools, and therefore to
 *          match calls to jit_handle_new and jit_handle_free.
 *
 * @ingroup memorymod 
 *
 * @param   size    size in bytes to allocate
 * 
 * @return  memory handle
 *
 */
 void **jit_handle_new(long size)
{
#ifdef USE_HANDLE_MANIA
    long i;

    if (!_handle_mania_init) {
        _handle_mania_init=1;
        for (i=0;i<MANIA_SIZE;i++) _handle_mania[i]=0;
    }

    for (i=0;i<MANIA_SIZE;i++) {
        if (_handle_mania[i]==0)
            goto gotit;
    }
    return (void **)NULL;

gotit:
    if (_handle_mania[i]=malloc(size))
        return (void **)&(_handle_mania[i]);
    else 
        return (void **)NULL;

#else
    return (void **)sysmem_newhandle(size); 
#endif
} 

/**
 * Frees a memory handle.
 *
 * @warning It is important to avoid mixing memory pools, and therefore to
 *          match calls to jit_handle_new and jit_handle_free.
 *
 * @ingroup memorymod 
 *
 * @param   handle  memory handle
 * 
 */
void jit_handle_free(void **handle)
{
#ifdef USE_HANDLE_MANIA
    if (handle&&*handle) {
        free(*handle);
        *handle=NULL;
    }       
#else   
    sysmem_freehandle((char **)handle); 
#endif
}

/**
 * Retrieves a memory handle's size in bytes.
 *
 * @ingroup memorymod 
 *
 * @param   handle  memory handle
 * 
 * @return  size in bytes
 * 
 */
long jit_handle_size_get(void **handle)
{
#ifdef USE_HANDLE_MANIA
    if (handle&&*handle) {
        return _msize(*handle);
    } else {
        return 0;
    }
#else   
    return sysmem_handlesize((char **)handle);
#endif
} 

/**
 * Sets a memory handle's size in bytes.
 *
 * @ingroup memorymod 
 *
 * @param   handle  memory handle
 * @param   size    new size in bytes
 * 
 * @return  t_jit_err error code.
 * 
 */
t_jit_err jit_handle_size_set(void **handle, long size)
{
#ifdef USE_HANDLE_MANIA
    if (handle&&*handle) {
        if (*handle=realloc(*handle,size))
            return JIT_ERR_NONE;
        else
            return JIT_ERR_GENERIC;
    } else {
        return JIT_ERR_GENERIC;
    }
#else   
    return sysmem_resizehandle((char **)handle, size);
#endif
} 

/**
 * Sets a memory handle's lock state.
 *
 * @ingroup memorymod 
 *
 * @param   handle  memory handle
 * @param   lock    state (1=locked, 0=unlocked)
 * 
 * @return  lock state.
 * 
 */
long jit_handle_lock(void **handle, long lock)
{
#ifdef USE_HANDLE_MANIA
    return !lock;
#else
    return sysmem_lockhandle((char **)handle, lock);
#endif
} 

/**
 * Copy bytes from source to destination pointer.
 *
 * @ingroup memorymod 
 *
 * @param   dest    destination pointer
 * @param   src     source pointer
 * @param   bytes   byte count to copy
 * 
 */
void jit_copy_bytes(void *dest, const void *src, long bytes)
{
    BlockMoveData(src, dest, bytes);
}

/**
 * Reports free memory.
 *
 * @warning Obsolete. OS 9 only.
 *
 * @ingroup memorymod 
 *
 * @return  free bytes
 * 
 */
long jit_freemem(void)
{
    return FreeMem();
}

/**
 * Allocates a pointer to memory.
 *
 * Always allocates from the the system memory pool. 
 * 
 * @warning It is important to avoid mixing memory pools, and therefore to
 *          match calls to jit_newptr and jit_disposeptr.
 *
 * @ingroup memorymod 
 *
 * @param   size    size in bytes to allocate
 * 
 * @return  pointer to memory
 *
 */
char *jit_newptr(long size)
{
    char *rv = sysmem_newptr(size);

    if (_jit_memreg)
        jit_memory_register(rv,size,JIT_MEM_NEWPTR);

    return rv;
}

/**
 * Frees a pointer to memory.
 *
 * @warning It is important to avoid mixing memory pools, and therefore to
 *          match calls to jit_newptr and jit_disposeptr.
 *
 * @ingroup memorymod 
 *
 * @param   ptr     pointer to memory
 *
 */
void jit_disposeptr(char *ptr)
{
    if (_jit_memreg)
        jit_memory_unregister((void *)ptr,0,JIT_MEM_NEWPTR);

    sysmem_freeptr(ptr);
}

Copyright © 2008, Cycling '74