hmbdc
simplify-high-performance-messaging-programming
LockFreeBufferT.hpp
1 #include "hmbdc/Copyright.hpp"
2 #pragma once
3 
4 #include "hmbdc/pattern/LockFreeBufferMisc.hpp"
5 #include "hmbdc/os/Allocators.hpp"
6 
7 #include "hmbdc/Config.hpp"
8 
9 #include <utility>
10 #include <stdexcept>
11 #include <vector>
12 #include <limits>
13 #include <cstddef>
14 
15 namespace hmbdc { namespace pattern {
16 
17 template <uint16_t MAX_PARALLE_CONSUMER>
19  using Sequence = HMBDC_SEQ_TYPE;
21  using value_type = void *;
23  enum {
24  max_parallel_consumer = MAX_PARALLE_CONSUMER
25  };
26 
27  template <typename Allocator = os::DefaultAllocator>
28  LockFreeBufferT(size_t, uint32_t, Allocator& allocator = os::DefaultAllocator::instance);
29 
30  ~LockFreeBufferT();
31  size_t capacity() const;
32  size_t maxItemSize() const;
33 
34  void put(void const*, size_t sizeHint = 0);
35  template <typename T> void put(T const& item) {put(&item, sizeof(T));}
36  template <typename T> void putSome(T const& item) {put(&item, std::min(sizeof(item), maxItemSize()));}
37 
38  bool tryPut(void const*, size_t sizeHint = 0);
39  template <typename T> bool tryPut(T const& item) {return tryPut(&item, sizeof(T));}
40 
41  void killPut(void const*, size_t sizeHint = 0);
42 
43  template <typename T> void killPut(T const& item) {killPut(&item, sizeof(T));}
44 
45  template <typename T, typename ...Args>
46  void putInPlace(Args&&... args) {
47  auto s = claim();
48  new (*s) T(std::forward<Args>(args)...);
49  commit(s);
50  }
51 
52  template <typename T, typename ...Args>
53  bool tryPutInPlace(Args&&... args) {
54  auto s = tryClaim();
55  if (!s) return false;
56  new (*s) T(std::forward<Args>(args)...);
57  commit(s);
58  return true;
59  }
60 
61  bool isFull() const;
62  Sequence readSeq(uint16_t PARALLEL_CONSUMER_INDEX) const;
63  iterator claim();
64  iterator tryClaim();
65  iterator claim(size_t);
66  iterator tryClaim(size_t);
67  iterator killClaim();
68  iterator killClaim(size_t);
69  void commit(iterator);
70  void commit(iterator, size_t);
71  void markDead(uint16_t);
72 
73  template <typename T>
74  T take(uint16_t PARALLEL_CONSUMER_INDEX) {
75  T res;
76  take(PARALLEL_CONSUMER_INDEX, &res, sizeof(res));
77  return res;
78  }
79 
80  void take(uint16_t PARALLEL_CONSUMER_INDEX, void *, size_t = 0);
81  void takeReentrant(uint16_t PARALLEL_CONSUMER_INDEX, void *, size_t = 0);
82  iterator peek(uint16_t PARALLEL_CONSUMER_INDEX) const;
83  size_t peek(uint16_t PARALLEL_CONSUMER_INDEX, iterator&, iterator&
84  , size_t maxPeekSize = std::numeric_limits<size_t>::max()) const;
85  void waste(uint16_t PARALLEL_CONSUMER_INDEX, size_t);
86  void wasteAfterPeek(uint16_t PARALLEL_CONSUMER_INDEX, size_t);
87  Sequence catchUpWith(uint16_t PARALLEL_CONSUMER_INDEX, uint16_t);
88  void catchUpTo(uint16_t PARALLEL_CONSUMER_INDEX, Sequence);
89 
90  size_t remainingSize(uint16_t PARALLEL_CONSUMER_INDEX) const;
91  size_t remainingSize() const;
92  size_t parallelConsumerAlive() const;
93  void reset(uint16_t PARALLEL_CONSUMER_INDEX);
94 
95  static
96  size_t footprint(size_t, uint32_t);
97  uint64_t purge();
98 
99  std::vector<uint16_t>
100  unusedConsumerIndexes() const;
101 
102  uint16_t
103  takeUnusedConsumer();
104 
105 private:
106  std::ptrdiff_t impl_;
107  bool allocateFromHeap_;
108 };
109 
110 }} // end namespace hmbdc::pattern
111 
Definition: LockFreeBufferMisc.hpp:23
Definition: LockFreeBufferT.hpp:18
Definition: Base.hpp:12
Definition: LockFreeBufferMisc.hpp:74