Line data    Source code

       1             : // **************************************************************************
       2             : // * This file is property of and copyright by the ALICE HLT Project        *
       3             : // * All rights reserved.                                                   *
       4             : // *                                                                        *
       5             : // * Primary Authors:                                                       *
       6             : // *     Copyright 2009       Matthias Kretz <kretz@kde.org>                *
       7             : // *                                                                        *
       8             : // * Permission to use, copy, modify and distribute this software and its   *
       9             : // * documentation strictly for non-commercial purposes is hereby granted   *
      10             : // * without fee, provided that the above copyright notice appears in all   *
      11             : // * copies and that both the copyright notice and this permission notice   *
      12             : // * appear in the supporting documentation. The authors make no claims     *
      13             : // * about the suitability of this software for any purpose. It is          *
      14             : // * provided "as is" without express or implied warranty.                  *
      15             : // **************************************************************************
      16             : 
      17             : #ifndef MEMORYASSIGNMENTHELPERS_H
      18             : #define MEMORYASSIGNMENTHELPERS_H
      19             : 
      20             : #ifndef assert
      21             : #include <assert.h>
      22             : #endif //!assert
      23             : 
      24             : template<unsigned int X>
      25             : GPUhd() static inline void AlignTo( char *&mem )
      26             : {
      27             :   STATIC_ASSERT( ( X & ( X - 1 ) ) == 0, X_needs_to_be_a_multiple_of_2 );
      28           0 :   const int offset = reinterpret_cast<unsigned long long>( mem ) & ( X - 1 );
      29           0 :   if ( offset > 0 ) {
      30           0 :     mem += ( X - offset );
      31           0 :   }
      32             :   //assert( ( reinterpret_cast<unsigned long>( mem ) & ( X - 1 ) ) == 0 );
      33           0 : }
      34             : 
      35             : template<unsigned int X>
      36             : GPUhd() static inline unsigned int NextMultipleOf( unsigned int value )
      37             : {
      38             :   STATIC_ASSERT( ( X & ( X - 1 ) ) == 0, X_needs_to_be_a_multiple_of_2 );
      39           0 :   const int offset = value & ( X - 1 );
      40           0 :   if ( offset > 0 ) {
      41           0 :     return value + X - offset;
      42             :   }
      43           0 :   return value;
      44           0 : }
      45             : 
      46             : template<typename T, unsigned int Alignment> static T *AssignMemory( char *&mem, unsigned int size )
      47             : {
      48             :   STATIC_ASSERT( ( Alignment & ( Alignment - 1 ) ) == 0, Alignment_needs_to_be_a_multiple_of_2 );
      49             :   AlignTo<Alignment> ( mem );
      50             :   T *r = reinterpret_cast<T *>( mem );
      51             :   mem += size * sizeof( T );
      52             :   return r;
      53             : }
      54             : 
      55             : template<typename T, unsigned int Alignment> static inline T *AssignMemory( char *&mem, unsigned int stride, unsigned int count )
      56             : {
      57             :   assert( 0 == ( stride & ( Alignment - 1 ) ) );
      58             :   return AssignMemory<T, Alignment>( mem, stride * count );
      59             : }
      60             : 
      61             : template<typename T, unsigned int Alignment> GPUhd() static T *_assignMemory( char *&mem, unsigned int size )
      62             : {
      63             :   STATIC_ASSERT( ( Alignment & ( Alignment - 1 ) ) == 0, Alignment_needs_to_be_a_multiple_of_2 );
      64           0 :   AlignTo<Alignment < sizeof( HLTCA_GPU_ROWALIGNMENT ) ? sizeof( HLTCA_GPU_ROWALIGNMENT ) : Alignment>( mem );
      65           0 :   T *r = reinterpret_cast<T *>( mem );
      66           0 :   mem += size * sizeof( T );
      67           0 :   return r;
      68             : }
      69             : 
      70             : template<typename T> GPUhd() static inline void AssignMemory( T *&dst, char *&mem, int count )
      71             : {
      72           0 :         dst = _assignMemory < T, ( sizeof( T ) & ( sizeof( T ) - 1 ) ) == 0 && sizeof( T ) <= 16 ? sizeof( T ) : sizeof( void * ) > ( mem, count );
      73           0 : }
      74             : 
      75             : #endif // MEMORYASSIGNMENTHELPERS_H