SYS/SYS_Align.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        SYS_Align.h ( SYS Library, C++)
 *
 * COMMENTS:    System specific methods of creating aligned data.
 *
 */

#ifndef __SYS_Align__
#define __SYS_Align__

#include "SYS_API.h"
#include <stdlib.h>

/// These definitions are system specific methods of forcing data to be
/// aligned.  Some processors require data to be aligned on 16 byte boundaries
/// for certain operations.  These macros and inline functions provide a
/// consistent approach to doing this.
///
/// Example 1:
///    class Foo {
///       SYS_ALIGN16 int       a[4];
///       int                   b;
///       SYS_ALIGN16 char      c;
///     };
/// In the struct, both the A and C members will be aligned on a 16 byte
/// boundary.  This will force the size of the class to be 48 bytes.
///
/// Example 2:
///     fpreal32 *list = SYSamalloc(4*sizeof(fpreal32));
/// This will guarantee that the list pointer is aligned on a 16 byte boundary.
///
/// Example 3:
///     fpreal32 *list = SYSamalloc(4*sizeof(fpreal32), 128);
/// This will guarantee that the list is aligned to a 128 byte boundary.

#if defined(WIN32)
    #include <malloc.h>
    #include <string.h>

    #define SYS_ALIGN16         __declspec(align(16))
    #define SYS_ALIGN(b)        __declspec(align(b))

    inline void *SYSamalloc(size_t b)
                    { return _aligned_malloc(b, 16); }
    inline void *SYSacalloc(size_t n, size_t b)
                    {
                        b *= n;
                        void *p = _aligned_malloc(b, 16);
                        memset(p, 0, b);
                        return p;
                    }
    inline void *SYSarealloc(void *p, size_t b)
                    { return _aligned_realloc(p, b, 16); }
    inline void  SYSafree(void *p)
                    { _aligned_free(p); }

    inline void *SYSamalloc(size_t b, size_t a)
                    { return _aligned_malloc(b, a); }
    inline void *SYSarealloc(void *p, size_t b, size_t a)
                    { return _aligned_realloc(p, b, a); }

#elif defined(LINUX)   
    #include <malloc.h>

    #define SYS_ALIGN16         __attribute__ ((aligned(16)))
    #define SYS_ALIGN(b)        __attribute__ ((aligned(b)))

    inline void *SYSamalloc(size_t b)           { return malloc(b); }
    inline void *SYSacalloc(size_t n, size_t b) { return calloc(n, b); }
    inline void *SYSarealloc(void *p, size_t b) { return realloc(p, b); }
    inline void  SYSafree(void *p)              { free(p); }
    inline void *SYSamalloc(size_t b, size_t a)
                    { return memalign(a, b); }
    inline void *SYSarealloc(void *p, size_t b, size_t)
                    { return SYSarealloc(p, b); }

#elif defined(MBSD)    
    #include <malloc.h>

    #define SYS_ALIGN16         __attribute__ ((aligned(16)))
    #define SYS_ALIGN(b)        __attribute__ ((aligned(b)))

    inline void *SYSamalloc(size_t b)           { return malloc(b); }
    inline void *SYSacalloc(size_t n, size_t b) { return calloc(n, b); }
    inline void *SYSarealloc(void *p, size_t b) { return realloc(p, b); }
    inline void  SYSafree(void *p)              { free(p); }
    inline void *SYSamalloc(size_t b, size_t a)
    { 
        // There's no memalign on OS X, however all memory allocations
        // are 16-bit aligned.  We'll only panic if asked for alignment
        // beyond 16-bit
        #ifdef UT_ASSERT
        UT_ASSERT(a<=16);
        #endif
        return malloc(b); 
    }
    inline void *SYSarealloc(void *p, size_t b, size_t)
                    { return SYSarealloc(p, b); }

#else
    #define SYS_ALIGN16
    #define SYS_ALIGN(b)

    inline void *SYSamalloc(size_t b)           { return malloc(b); }
    inline void *SYSacalloc(size_t n, size_t b) { return calloc(n, b); }
    inline void *SYSarealloc(void *p, size_t b) { return realloc(p, b); }
    inline void  SYSafree(void *p)              { free(p); }
    inline void *SYSamalloc(size_t b, size_t)   { return malloc(b); }
    inline void *SYSarealloc(void *p, size_t b, size_t)
                    { return SYSarealloc(p, b); }
#endif

#endif

---