42 } |
42 } |
43 typedef typename Operation::Type Type; |
43 typedef typename Operation::Type Type; |
44 bool process(Type* t = NULL) { |
44 bool process(Type* t = NULL) { |
45 return _next == NULL ? _op->process(t) : _op->process(t) && _next->process(t); |
45 return _next == NULL ? _op->process(t) : _op->process(t) && _next->process(t); |
46 } |
46 } |
47 size_t processed() const { |
47 size_t elements() const { |
48 return _next == NULL ? _op->processed() : _op->processed() + _next->processed(); |
48 return _next == NULL ? _op->elements() : _op->elements() + _next->elements(); |
|
49 } |
|
50 size_t size() const { |
|
51 return _next == NULL ? _op->size() : _op->size() + _next->size(); |
49 } |
52 } |
50 }; |
53 }; |
51 |
54 |
52 template <typename T> |
55 template <typename T> |
53 class UnBufferedWriteToChunk { |
56 class UnBufferedWriteToChunk { |
54 private: |
57 private: |
55 JfrChunkWriter& _writer; |
58 JfrChunkWriter& _writer; |
56 size_t _processed; |
59 size_t _elements; |
|
60 size_t _size; |
57 public: |
61 public: |
58 typedef T Type; |
62 typedef T Type; |
59 UnBufferedWriteToChunk(JfrChunkWriter& writer) : _writer(writer), _processed(0) {} |
63 UnBufferedWriteToChunk(JfrChunkWriter& writer) : _writer(writer), _elements(0), _size(0) {} |
60 bool write(Type* t, const u1* data, size_t size); |
64 bool write(Type* t, const u1* data, size_t size); |
61 size_t processed() { return _processed; } |
65 size_t elements() const { return _elements; } |
|
66 size_t size() const { return _size; } |
62 }; |
67 }; |
63 |
68 |
64 template <typename T> |
69 template <typename T> |
65 class DefaultDiscarder { |
70 class DefaultDiscarder { |
66 private: |
71 private: |
67 size_t _processed; |
72 size_t _elements; |
|
73 size_t _size; |
68 public: |
74 public: |
69 typedef T Type; |
75 typedef T Type; |
70 DefaultDiscarder() : _processed() {} |
76 DefaultDiscarder() : _elements(0), _size(0) {} |
71 bool discard(Type* t, const u1* data, size_t size); |
77 bool discard(Type* t, const u1* data, size_t size); |
72 size_t processed() const { return _processed; } |
78 size_t elements() const { return _elements; } |
|
79 size_t size() const { return _size; } |
73 }; |
80 }; |
74 |
81 |
75 template <typename Operation> |
82 template <typename Operation> |
76 class ConcurrentWriteOp { |
83 class ConcurrentWriteOp { |
77 private: |
84 private: |
78 Operation& _operation; |
85 Operation& _operation; |
79 public: |
86 public: |
80 typedef typename Operation::Type Type; |
87 typedef typename Operation::Type Type; |
81 ConcurrentWriteOp(Operation& operation) : _operation(operation) {} |
88 ConcurrentWriteOp(Operation& operation) : _operation(operation) {} |
82 bool process(Type* t); |
89 bool process(Type* t); |
83 size_t processed() const { return _operation.processed(); } |
90 size_t elements() const { return _operation.elements(); } |
|
91 size_t size() const { return _operation.size(); } |
84 }; |
92 }; |
85 |
93 |
86 template <typename Operation> |
94 template <typename Operation> |
87 class ConcurrentWriteOpExcludeRetired : private ConcurrentWriteOp<Operation> { |
95 class ConcurrentWriteOpExcludeRetired : private ConcurrentWriteOp<Operation> { |
88 public: |
96 public: |
89 typedef typename Operation::Type Type; |
97 typedef typename Operation::Type Type; |
90 ConcurrentWriteOpExcludeRetired(Operation& operation) : ConcurrentWriteOp<Operation>(operation) {} |
98 ConcurrentWriteOpExcludeRetired(Operation& operation) : ConcurrentWriteOp<Operation>(operation) {} |
91 bool process(Type* t); |
99 bool process(Type* t); |
92 size_t processed() const { return ConcurrentWriteOp<Operation>::processed(); } |
100 size_t elements() const { return ConcurrentWriteOp<Operation>::elements();} |
|
101 size_t size() const { return ConcurrentWriteOp<Operation>::size(); } |
93 }; |
102 }; |
94 |
|
95 |
103 |
96 template <typename Operation> |
104 template <typename Operation> |
97 class MutexedWriteOp { |
105 class MutexedWriteOp { |
98 private: |
106 private: |
99 Operation& _operation; |
107 Operation& _operation; |
100 public: |
108 public: |
101 typedef typename Operation::Type Type; |
109 typedef typename Operation::Type Type; |
102 MutexedWriteOp(Operation& operation) : _operation(operation) {} |
110 MutexedWriteOp(Operation& operation) : _operation(operation) {} |
103 bool process(Type* t); |
111 bool process(Type* t); |
104 size_t processed() const { return _operation.processed(); } |
112 size_t elements() const { return _operation.elements(); } |
|
113 size_t size() const { return _operation.size(); } |
|
114 }; |
|
115 |
|
116 template <typename Operation> |
|
117 class ExclusiveOp : public MutexedWriteOp<Operation> { |
|
118 public: |
|
119 typedef typename Operation::Type Type; |
|
120 ExclusiveOp(Operation& operation) : MutexedWriteOp<Operation>(operation) {} |
|
121 bool process(Type* t); |
|
122 size_t size() const { return MutexedWriteOp<Operation>::size(); } |
105 }; |
123 }; |
106 |
124 |
107 enum jfr_operation_mode { |
125 enum jfr_operation_mode { |
108 mutexed = 1, |
126 mutexed = 1, |
109 concurrent |
127 concurrent |