Line data    Source code

       1             : /*
       2             :  *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
       3             :  *
       4             :  *  Use of this source code is governed by a BSD-style license
       5             :  *  that can be found in the LICENSE file in the root of the source
       6             :  *  tree. An additional intellectual property rights grant can be found
       7             :  *  in the file PATENTS.  All contributing project authors may
       8             :  *  be found in the AUTHORS file in the root of the source tree.
       9             :  */
      10             : 
      11             : #ifndef WEBRTC_SYSTEM_WRAPPERS_INCLUDE_ALIGNED_MALLOC_H_
      12             : #define WEBRTC_SYSTEM_WRAPPERS_INCLUDE_ALIGNED_MALLOC_H_
      13             : 
      14             : // The functions declared here
      15             : // 1) Allocates block of aligned memory.
      16             : // 2) Re-calculates a pointer such that it is aligned to a higher or equal
      17             : //    address.
      18             : // Note: alignment must be a power of two. The alignment is in bytes.
      19             : 
      20             : #include <stddef.h>
      21             : 
      22             : namespace webrtc {
      23             : 
      24             : // Returns a pointer to the first boundry of |alignment| bytes following the
      25             : // address of |ptr|.
      26             : // Note that there is no guarantee that the memory in question is available.
      27             : // |ptr| has no requirements other than it can't be NULL.
      28             : void* GetRightAlign(const void* ptr, size_t alignment);
      29             : 
      30             : // Allocates memory of |size| bytes aligned on an |alignment| boundry.
      31             : // The return value is a pointer to the memory. Note that the memory must
      32             : // be de-allocated using AlignedFree.
      33             : void* AlignedMalloc(size_t size, size_t alignment);
      34             : // De-allocates memory created using the AlignedMalloc() API.
      35             : void AlignedFree(void* mem_block);
      36             : 
      37             : // Templated versions to facilitate usage of aligned malloc without casting
      38             : // to and from void*.
      39             : template<typename T>
      40             : T* GetRightAlign(const T* ptr, size_t alignment) {
      41             :   return reinterpret_cast<T*>(GetRightAlign(reinterpret_cast<const void*>(ptr),
      42             :                                             alignment));
      43             : }
      44             : template<typename T>
      45             : T* AlignedMalloc(size_t size, size_t alignment) {
      46             :   return reinterpret_cast<T*>(AlignedMalloc(size, alignment));
      47             : }
      48             : 
      49             : // Deleter for use with unique_ptr. E.g., use as
      50             : //   std::unique_ptr<Foo, AlignedFreeDeleter> foo;
      51             : struct AlignedFreeDeleter {
      52           0 :   inline void operator()(void* ptr) const {
      53           0 :     AlignedFree(ptr);
      54           0 :   }
      55             : };
      56             : 
      57             : }  // namespace webrtc
      58             : 
      59             : #endif // WEBRTC_SYSTEM_WRAPPERS_INCLUDE_ALIGNED_MALLOC_H_