Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

183 lines
5.0KB

  1. /*
  2. * High-level, real-time safe, templated, C++ doubly-linked list
  3. * Copyright (C) 2013-2014 Filipe Coelho <falktx@falktx.com>
  4. *
  5. * This program is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU General Public License as
  7. * published by the Free Software Foundation; either version 2 of
  8. * the License, or any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. * For a full copy of the GNU General Public License see the doc/GPL.txt file.
  16. */
  17. #ifndef RT_LINKED_LIST_HPP_INCLUDED
  18. #define RT_LINKED_LIST_HPP_INCLUDED
  19. #include "LinkedList.hpp"
  20. extern "C" {
  21. #include "rtmempool/rtmempool.h"
  22. }
  23. // -----------------------------------------------------------------------
  24. // Realtime safe linkedlist
  25. template<typename T>
  26. class RtLinkedList : public AbstractLinkedList<T>
  27. {
  28. public:
  29. // -------------------------------------------------------------------
  30. // RtMemPool C++ class
  31. class Pool
  32. {
  33. public:
  34. Pool(const size_t minPreallocated, const size_t maxPreallocated) noexcept
  35. : fHandle(nullptr),
  36. kDataSize(sizeof(typename AbstractLinkedList<T>::Data))
  37. {
  38. resize(minPreallocated, maxPreallocated);
  39. }
  40. ~Pool() noexcept
  41. {
  42. if (fHandle != nullptr)
  43. {
  44. rtsafe_memory_pool_destroy(fHandle);
  45. fHandle = nullptr;
  46. }
  47. }
  48. void* allocate_atomic() const noexcept
  49. {
  50. return rtsafe_memory_pool_allocate_atomic(fHandle);
  51. }
  52. void* allocate_sleepy() const noexcept
  53. {
  54. return rtsafe_memory_pool_allocate_sleepy(fHandle);
  55. }
  56. void deallocate(void* const dataPtr) const noexcept
  57. {
  58. rtsafe_memory_pool_deallocate(fHandle, dataPtr);
  59. }
  60. void resize(const size_t minPreallocated, const size_t maxPreallocated) noexcept
  61. {
  62. if (fHandle != nullptr)
  63. {
  64. rtsafe_memory_pool_destroy(fHandle);
  65. fHandle = nullptr;
  66. }
  67. rtsafe_memory_pool_create(&fHandle, nullptr, kDataSize, minPreallocated, maxPreallocated);
  68. CARLA_SAFE_ASSERT(fHandle != nullptr);
  69. }
  70. bool operator==(const Pool& pool) const noexcept
  71. {
  72. return (fHandle == pool.fHandle && kDataSize == pool.kDataSize);
  73. }
  74. bool operator!=(const Pool& pool) const noexcept
  75. {
  76. return (fHandle != pool.fHandle || kDataSize != pool.kDataSize);
  77. }
  78. private:
  79. mutable RtMemPool_Handle fHandle;
  80. const size_t kDataSize;
  81. CARLA_PREVENT_HEAP_ALLOCATION
  82. CARLA_DECLARE_NON_COPY_CLASS(Pool)
  83. };
  84. // -------------------------------------------------------------------
  85. // Now the actual rt-linkedlist code
  86. RtLinkedList(Pool& memPool) noexcept
  87. : fMemPool(memPool) {}
  88. bool append_sleepy(const T& value) noexcept
  89. {
  90. return _add_sleepy(value, true);
  91. }
  92. bool insert_sleepy(const T& value) noexcept
  93. {
  94. return _add_sleepy(value, false);
  95. }
  96. void resize(const size_t minPreallocated, const size_t maxPreallocated) noexcept
  97. {
  98. this->clear();
  99. fMemPool.resize(minPreallocated, maxPreallocated);
  100. }
  101. void spliceAppendTo(RtLinkedList<T>& list) noexcept
  102. {
  103. CARLA_SAFE_ASSERT_RETURN(fMemPool == list.fMemPool,);
  104. AbstractLinkedList<T>::spliceAppendTo(list);
  105. }
  106. void spliceInsertInto(RtLinkedList<T>& list) noexcept
  107. {
  108. CARLA_SAFE_ASSERT_RETURN(fMemPool == list.fMemPool,);
  109. AbstractLinkedList<T>::spliceInsertInto(list);
  110. }
  111. protected:
  112. typename AbstractLinkedList<T>::Data* _allocate() noexcept override
  113. {
  114. return (typename AbstractLinkedList<T>::Data*)fMemPool.allocate_atomic();
  115. }
  116. typename AbstractLinkedList<T>::Data* _allocate_sleepy() noexcept
  117. {
  118. return (typename AbstractLinkedList<T>::Data*)fMemPool.allocate_sleepy();
  119. }
  120. void _deallocate(typename AbstractLinkedList<T>::Data* const dataPtr) noexcept override
  121. {
  122. CARLA_SAFE_ASSERT_RETURN(dataPtr != nullptr,);
  123. fMemPool.deallocate(dataPtr);
  124. }
  125. private:
  126. Pool& fMemPool;
  127. bool _add_sleepy(const T& value, const bool inTail) noexcept
  128. {
  129. if (typename AbstractLinkedList<T>::Data* const data = _allocate_sleepy())
  130. {
  131. this->_createData(data, value);
  132. if (inTail)
  133. this->__list_add(data->siblings, this->fQueue.prev, &(this->fQueue));
  134. else
  135. this->__list_add(data->siblings, &(this->fQueue), this->fQueue.next);
  136. return true;
  137. }
  138. return false;
  139. }
  140. CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION
  141. CARLA_DECLARE_NON_COPY_CLASS(RtLinkedList)
  142. };
  143. // -----------------------------------------------------------------------
  144. #endif // RT_LINKED_LIST_HPP_INCLUDED