vector aligné

vector aligné - C++ - Programmation

Marsh Posté le 23-11-2010 à 10:48:12    

Tout est dans le titre, comment je peux faire un vector aligné sur 16 octets?

Reply

Marsh Posté le 23-11-2010 à 10:48:12   

Reply

Marsh Posté le 24-11-2010 à 09:33:07    

on passe par un allcoator custom. Mais premiere etape: savori aligner de la memoire ;0
Allons y :
 
Allocation bas niveau alignée
Sous pas mal de systeme, y a une fonction tte faites. Sinon, on va faire du pointeur stashing
 

Code :
  1. #if ( (defined _GNU_SOURCE) \
  2.       || ((defined _XOPEN_SOURCE) && (_XOPEN_SOURCE >= 600)) \
  3.       ) \
  4.      && (defined _POSIX_ADVISORY_INFO) && (_POSIX_ADVISORY_INFO > 0)
  5. #include <cstdlib>
  6. #include <cstring>
  7. #define SUPPORT_POSIX_MEMALIGN
  8. #endif
  10. void* allocate( std::size_t nbytes )
  11. {
  12.     void *result;
  13.     BOOST_STATIC_CONSTANT(std::size_t, align = 16 );
  15. #if defined(SUPPORT_POSIX_MEMALIGN)
  16.     //////////////////////////////////////////////////////////////////////////////
  17.     // POSIX systems use posix_memalign
  18.     //////////////////////////////////////////////////////////////////////////////
  19.     if(posix_memalign(&result, align, nbytes))
  20.     {
  21.       throw std::bad_alloc();
  22.       result = 0;
  23.     }
  24. #elif defined (_MSC_VER)
  25.     //////////////////////////////////////////////////////////////////////////////
  26.     // MSVC systems use _aligned_malloc
  27.     //////////////////////////////////////////////////////////////////////////////
  28.     if( !(result = _aligned_malloc(nbytes, align) ) )
  29.     {
  30.       throw std::bad_alloc();
  31.       result = 0;
  32.     }
  33. #else
  34.     //////////////////////////////////////////////////////////////////////////////
  35.     // Other systems do the funky pointer stashing
  36.     //////////////////////////////////////////////////////////////////////////////
  37.     void *base;
  38.     BOOST_STATIC_CONSTANT(std::size_t, fix = ~(std::size_t(align-1)));
  39.     if( !(base = ::malloc(nbytes+align+sizeof(void*))) )
  40.     {
  41.       throw std::bad_alloc();
  42.       result = 0;
  43.     }
  44.     else
  45.     {
  46.       std::size_t ref = reinterpret_cast<std::size_t>(base)+sizeof(void*);
  47.       std::size_t stashed = (ref & fix) + align;
  48.       result = reinterpret_cast<void*>(stashed);
  49.       reinterpret_cast<void**>(result)[-1] = base;
  50.     }
  51. #endif
  53.     return result;
  54. }
  56. void deallocate( void* ptr, std::size_t )
  57.   {
  58. #if defined(SUPPORT_POSIX_MEMALIGN)
  59.     //////////////////////////////////////////////////////////////////////////////
  60.     // POSIX systems use free
  61.     //////////////////////////////////////////////////////////////////////////////
  62.     if(ptr) ::free(ptr);
  63. #elif (defined _MSC_VER)
  64.     //////////////////////////////////////////////////////////////////////////////
  65.     // MSVC systems use _aligned_free
  66.     //////////////////////////////////////////////////////////////////////////////
  67.     if(ptr)_aligned_free(ptr);
  68. #else
  69.     //////////////////////////////////////////////////////////////////////////////
  70.     // Other systems do the funky pointer stashing
  71.     //////////////////////////////////////////////////////////////////////////////
  72.     if(ptr) ::free( reinterpret_cast<void**>(ptr)[- 1] );
  73. #endif
  74.   }


 
Allocator custom

Code :
  1. template<class T> struct aligned_allocator
  2.   {
  3.     ////////////////////////////////////////////////////////////////////////////
  4.     // Internal typedefs
  5.     ////////////////////////////////////////////////////////////////////////////
  6.     typedef T value_type;
  7.     typedef T* pointer;
  8.     typedef T const* const_pointer;
  9.     typedef T& reference;
  10.     typedef T const& const_reference;
  11.     typedef std::size_t size_type;
  12.     typedef std::ptrdiff_t difference_type;
  14.     template<class U> struct rebind { typedef aligned_allocator<U> other; };
  16.     ////////////////////////////////////////////////////////////////////////////
  17.     // Ctor/dtor
  18.     ////////////////////////////////////////////////////////////////////////////
  19.                       aligned_allocator() {}
  20.     template<class U> allocator(aligned_allocator<U> const& ) {}
  21.                      ~aligned_allocator() {}
  23.     aligned_allocator& operator=(aligned_allocator const& ) { return *this; }
  25.     ////////////////////////////////////////////////////////////////////////////
  26.     // Address handling
  27.     ////////////////////////////////////////////////////////////////////////////
  28.     pointer address(reference r) { return &r; }
  29.     const_pointer address(const_reference r) { return &r; }
  31.     ////////////////////////////////////////////////////////////////////////////
  32.     // Size handling
  33.     ////////////////////////////////////////////////////////////////////////////
  34.     size_type max_size() const { return size_type(~0); }
  36.     ////////////////////////////////////////////////////////////////////////////
  37.     // Object lifetime handling
  38.     ////////////////////////////////////////////////////////////////////////////
  39.     void construct(pointer p, const T& t)
  40.     {
  41.       p = new (p) value_type(t);
  42.     }
  44.     void destroy(pointer p) { p->~value_type(); }
  46.     ////////////////////////////////////////////////////////////////////////////
  47.     // Memory handling
  48.     ////////////////////////////////////////////////////////////////////////////
  49.     pointer allocate( size_type c, const void* = 0 ) const
  50.     {
  51.       void* ptr = allocate(c*sizeof(value_type));
  52.       return reinterpret_cast<pointer>(ptr);
  53.     }
  55.     void deallocate (pointer p, size_type s) const
  56.     {
  57.       deallocate(p,s*sizeof(value_type));
  58.     }
  59.   };


 
Utilisation

Code :
  1. std::vector<float, aligned_allocator<float> > v(10);


 
Et voila :)
 
Note, l'alignement n'a de sens que sur des puissance de 2.
L'exercice est laissée au lecteur de rendre le aligned_allcoator template sur la valeur de l'alignement.
Sinon, tout est la : https://github.com/metascale/nt2 dans le module nt2::memory

Reply

Marsh Posté le 01-12-2010 à 20:58:21    

   pointer allocate( size_type c, const void* = 0 ) const
    {
      void* ptr = allocate(c*sizeof(value_type));
      return reinterpret_cast<pointer>(ptr);
    }
 
c pas récursif ça ?


---------------
.
Reply

Marsh Posté le 01-12-2010 à 21:10:39    

et sinon dans quel cas peut avoir besoin d'être aligné sur 16 bytes?


Message édité par Glock 17Pro le 01-12-2010 à 21:15:16

---------------
.
Reply

Marsh Posté le 01-12-2010 à 21:44:18    

avoir de la mémoire compatible avec des extensions SIMD comme Altivec et SSE.
 
Sinon, il faut bien entendu mettre un nt2::allcoate dans ton bout de code effectivement.

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed