alloc.h 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164
  1. // Copyright 2009-2021 Intel Corporation
  2. // SPDX-License-Identifier: Apache-2.0
  3. #pragma once
  4. #include "platform.h"
  5. #include <vector>
  6. #include <set>
  7. namespace embree
  8. {
  9. #define ALIGNED_STRUCT_(align) \
  10. void* operator new(size_t size) { return alignedMalloc(size,align); } \
  11. void operator delete(void* ptr) { alignedFree(ptr); } \
  12. void* operator new[](size_t size) { return alignedMalloc(size,align); } \
  13. void operator delete[](void* ptr) { alignedFree(ptr); }
  14. #define ALIGNED_CLASS_(align) \
  15. public: \
  16. ALIGNED_STRUCT_(align) \
  17. private:
  18. /*! aligned allocation */
  19. void* alignedMalloc(size_t size, size_t align);
  20. void alignedFree(void* ptr);
  21. /*! allocator that performs aligned allocations */
  22. template<typename T, size_t alignment>
  23. struct aligned_allocator
  24. {
  25. typedef T value_type;
  26. typedef T* pointer;
  27. typedef const T* const_pointer;
  28. typedef T& reference;
  29. typedef const T& const_reference;
  30. typedef std::size_t size_type;
  31. typedef std::ptrdiff_t difference_type;
  32. __forceinline pointer allocate( size_type n ) {
  33. return (pointer) alignedMalloc(n*sizeof(value_type),alignment);
  34. }
  35. __forceinline void deallocate( pointer p, size_type n ) {
  36. return alignedFree(p);
  37. }
  38. __forceinline void construct( pointer p, const_reference val ) {
  39. new (p) T(val);
  40. }
  41. __forceinline void destroy( pointer p ) {
  42. p->~T();
  43. }
  44. };
  45. /*! allocates pages directly from OS */
  46. bool win_enable_selockmemoryprivilege(bool verbose);
  47. bool os_init(bool hugepages, bool verbose);
  48. void* os_malloc (size_t bytes, bool& hugepages);
  49. size_t os_shrink (void* ptr, size_t bytesNew, size_t bytesOld, bool hugepages);
  50. void os_free (void* ptr, size_t bytes, bool hugepages);
  51. void os_advise (void* ptr, size_t bytes);
  52. /*! allocator that performs OS allocations */
  53. template<typename T>
  54. struct os_allocator
  55. {
  56. typedef T value_type;
  57. typedef T* pointer;
  58. typedef const T* const_pointer;
  59. typedef T& reference;
  60. typedef const T& const_reference;
  61. typedef std::size_t size_type;
  62. typedef std::ptrdiff_t difference_type;
  63. __forceinline os_allocator ()
  64. : hugepages(false) {}
  65. __forceinline pointer allocate( size_type n ) {
  66. return (pointer) os_malloc(n*sizeof(value_type),hugepages);
  67. }
  68. __forceinline void deallocate( pointer p, size_type n ) {
  69. return os_free(p,n*sizeof(value_type),hugepages);
  70. }
  71. __forceinline void construct( pointer p, const_reference val ) {
  72. new (p) T(val);
  73. }
  74. __forceinline void destroy( pointer p ) {
  75. p->~T();
  76. }
  77. bool hugepages;
  78. };
  79. /*! allocator for IDs */
  80. template<typename T, size_t max_id>
  81. struct IDPool
  82. {
  83. typedef T value_type;
  84. IDPool ()
  85. : nextID(0) {}
  86. T allocate()
  87. {
  88. /* return ID from list */
  89. if (!IDs.empty())
  90. {
  91. T id = *IDs.begin();
  92. IDs.erase(IDs.begin());
  93. return id;
  94. }
  95. /* allocate new ID */
  96. else
  97. {
  98. if (size_t(nextID)+1 > max_id)
  99. return -1;
  100. return nextID++;
  101. }
  102. }
  103. /* adds an ID provided by the user */
  104. bool add(T id)
  105. {
  106. if (id > max_id)
  107. return false;
  108. /* check if ID should be in IDs set */
  109. if (id < nextID) {
  110. auto p = IDs.find(id);
  111. if (p == IDs.end()) return false;
  112. IDs.erase(p);
  113. return true;
  114. }
  115. /* otherwise increase ID set */
  116. else
  117. {
  118. for (T i=nextID; i<id; i++) {
  119. IDs.insert(i);
  120. }
  121. nextID = id+1;
  122. return true;
  123. }
  124. }
  125. void deallocate( T id )
  126. {
  127. assert(id < nextID);
  128. MAYBE_UNUSED auto done = IDs.insert(id).second;
  129. assert(done);
  130. }
  131. private:
  132. std::set<T> IDs; //!< stores deallocated IDs to be reused
  133. T nextID; //!< next ID to use when IDs vector is empty
  134. };
  135. }