|
6 | 6 |
|
7 | 7 | #pragma once
|
8 | 8 |
|
9 |
| -#include "common/Attribute.h" |
10 | 9 | #include "common/Entry.h"
|
11 | 10 |
|
12 | 11 | #include <algorithm>
|
13 |
| -#include <map> |
14 |
| -#include <vector> |
15 | 12 |
|
16 | 13 | namespace cali
|
17 | 14 | {
|
18 | 15 |
|
19 | 16 | class CaliperMetadataAccessInterface;
|
20 | 17 |
|
21 |
| -// Snapshots are fixed-size, stack-allocated objects that can be used in |
22 |
| -// a signal handler |
23 |
| - |
24 |
| -/// \brief Snapshot record representation. |
| 18 | +/// \brief Non-owning read-only view for snapshot record |
| 19 | +class SnapshotView |
| 20 | +{ |
| 21 | + const Entry* m_data; |
| 22 | + size_t m_len; |
25 | 23 |
|
26 |
| -class SnapshotRecord |
27 |
| -{ |
28 | 24 | public:
|
29 | 25 |
|
30 |
| - struct Data { |
31 |
| - const cali::Node* const* node_entries; |
32 |
| - const cali_id_t* immediate_attr; |
33 |
| - const cali::Variant* immediate_data; |
34 |
| - }; |
35 |
| - |
36 |
| - struct Sizes { |
37 |
| - std::size_t n_nodes; |
38 |
| - std::size_t n_immediate; |
39 |
| - }; |
40 |
| - |
41 |
| - template<std::size_t N> |
42 |
| - struct FixedSnapshotRecord { |
43 |
| - cali::Node* node_array[N]; |
44 |
| - cali_id_t attr_array[N]; |
45 |
| - cali::Variant data_array[N]; |
46 |
| - |
47 |
| - FixedSnapshotRecord() { |
48 |
| - std::fill_n(node_array, N, nullptr); |
49 |
| - std::fill_n(attr_array, N, CALI_INV_ID); |
50 |
| - std::fill_n(data_array, N, cali::Variant()); |
| 26 | + SnapshotView() |
| 27 | + : m_data { nullptr }, m_len { 0 } |
| 28 | + { } |
| 29 | + SnapshotView(size_t len, const Entry* data) |
| 30 | + : m_data { data }, m_len { len } |
| 31 | + { } |
| 32 | + |
| 33 | + using iterator = Entry*; |
| 34 | + using const_iterator = const Entry*; |
| 35 | + |
| 36 | + const_iterator begin() const { return m_data; } |
| 37 | + const_iterator end() const { return m_data+m_len; } |
| 38 | + |
| 39 | + size_t size() const { return m_len; } |
| 40 | + const Entry* data() const { return m_data; } |
| 41 | + bool empty() const { return m_len == 0; } |
| 42 | + |
| 43 | + Entry get(const Attribute& attr) const { |
| 44 | + for (const Entry& e : *this) { |
| 45 | + Entry ret = e.get(attr); |
| 46 | + if (!ret.empty()) |
| 47 | + return ret; |
51 | 48 | }
|
52 |
| - }; |
53 |
| - |
54 |
| - SnapshotRecord() |
55 |
| - : m_node_array { 0 }, |
56 |
| - m_attr_array { 0 }, |
57 |
| - m_data_array { 0 }, |
58 |
| - m_sizes { 0, 0 }, |
59 |
| - m_capacity { 0, 0 } |
60 |
| - { } |
61 |
| - |
62 |
| - template<std::size_t N> |
63 |
| - SnapshotRecord(FixedSnapshotRecord<N>& list) |
64 |
| - : m_node_array { list.node_array }, |
65 |
| - m_attr_array { list.attr_array }, |
66 |
| - m_data_array { list.data_array }, |
67 |
| - m_sizes { 0, 0 }, |
68 |
| - m_capacity { N, N } |
69 |
| - { } |
70 |
| - |
71 |
| - SnapshotRecord(size_t n_nodes, cali::Node **nodes, size_t n, cali_id_t* attr, Variant* data) |
72 |
| - : m_node_array { nodes }, |
73 |
| - m_attr_array { attr }, |
74 |
| - m_data_array { data }, |
75 |
| - m_sizes { n_nodes, n }, |
76 |
| - m_capacity { n_nodes, n } |
77 |
| - { } |
78 |
| - |
79 |
| - SnapshotRecord(size_t n, cali_id_t* attr, Variant* data) |
80 |
| - : m_node_array { 0 }, |
81 |
| - m_attr_array { attr }, |
82 |
| - m_data_array { data }, |
83 |
| - m_sizes { 0, n }, |
84 |
| - m_capacity { 0, n } |
85 |
| - { } |
86 |
| - |
87 |
| - void append(const SnapshotRecord& list); |
88 |
| - void append(size_t n, const cali_id_t*, const cali::Variant*); |
89 |
| - void append(size_t n, cali::Node* const*, size_t m, const cali_id_t*, const cali::Variant*); |
90 |
| - |
91 |
| - void append(cali::Node* node) { |
92 |
| - if (m_sizes.n_nodes < m_capacity.n_nodes) |
93 |
| - m_node_array[m_sizes.n_nodes++] = node; |
| 49 | + |
| 50 | + return Entry(); |
94 | 51 | }
|
95 |
| - |
96 |
| - void append(cali_id_t attr, const cali::Variant& data) { |
97 |
| - if (m_sizes.n_immediate < m_capacity.n_immediate) { |
98 |
| - m_attr_array[m_sizes.n_immediate] = attr; |
99 |
| - m_data_array[m_sizes.n_immediate] = data; |
100 |
| - ++m_sizes.n_immediate; |
101 |
| - } |
| 52 | +}; |
| 53 | + |
| 54 | +/// \brief Non-owning writable view for snapshot record |
| 55 | +class SnapshotBuilder |
| 56 | +{ |
| 57 | + Entry* m_data; |
| 58 | + size_t m_capacity; |
| 59 | + size_t m_len; |
| 60 | + size_t m_skipped; |
| 61 | + |
| 62 | +public: |
| 63 | + |
| 64 | + SnapshotBuilder() |
| 65 | + : m_data { nullptr}, m_capacity { 0 }, m_len { 0 }, m_skipped { 0 } |
| 66 | + { } |
| 67 | + SnapshotBuilder(size_t capacity, Entry* data) |
| 68 | + : m_data { data }, m_capacity { capacity }, m_len { 0 }, m_skipped { 0 } |
| 69 | + { } |
| 70 | + |
| 71 | + SnapshotBuilder(SnapshotBuilder&&) = default; |
| 72 | + SnapshotBuilder(const SnapshotBuilder&) = delete; |
| 73 | + |
| 74 | + SnapshotBuilder& operator = (SnapshotBuilder&&) = default; |
| 75 | + SnapshotBuilder& operator = (const SnapshotBuilder&) = delete; |
| 76 | + |
| 77 | + size_t capacity() const { return m_capacity; } |
| 78 | + size_t size() const { return m_len; } |
| 79 | + size_t skipped() const { return m_skipped; } |
| 80 | + |
| 81 | + void append(const Entry& e) { |
| 82 | + if (m_len < m_capacity) |
| 83 | + m_data[m_len++] = e; |
| 84 | + else |
| 85 | + ++m_skipped; |
102 | 86 | }
|
103 | 87 |
|
104 |
| - void append(const cali::Attribute& attr, const cali::Variant& data) { |
105 |
| - append(attr.id(), data); |
| 88 | + void append(size_t n, const Entry* entries) { |
| 89 | + size_t num_copied = std::min(n, m_capacity - m_len); |
| 90 | + std::copy_n(entries, num_copied, m_data+m_len); |
| 91 | + m_len += num_copied; |
| 92 | + m_skipped += n-num_copied; |
106 | 93 | }
|
107 | 94 |
|
108 |
| - Sizes capacity() const { |
109 |
| - return { m_capacity.n_nodes - m_sizes.n_nodes, |
110 |
| - m_capacity.n_immediate - m_sizes.n_immediate }; |
| 95 | + void append(const Attribute& attr, const Variant& val) { |
| 96 | + append(Entry(attr, val)); |
111 | 97 | }
|
112 | 98 |
|
113 |
| - Sizes size() const { |
114 |
| - return m_sizes; |
| 99 | + void append(SnapshotView view) { |
| 100 | + append(view.size(), view.data()); |
115 | 101 | }
|
116 |
| - |
117 |
| - Data data() const { |
118 |
| - Data addr = { m_node_array, m_attr_array, m_data_array }; |
119 |
| - return addr; |
120 |
| - } |
121 |
| - |
122 |
| - std::size_t num_nodes() const { return m_sizes.n_nodes; } |
123 |
| - std::size_t num_immediate() const { return m_sizes.n_immediate; } |
124 |
| - |
125 |
| - Entry get(const Attribute&) const; |
126 |
| - |
127 |
| - std::vector<Entry> |
128 |
| - to_entrylist() const; |
129 |
| - |
130 |
| -private: |
131 |
| - |
132 |
| - cali::Node** m_node_array; |
133 |
| - cali_id_t* m_attr_array; |
134 |
| - cali::Variant* m_data_array; |
135 |
| - |
136 |
| - Sizes m_sizes; |
137 |
| - Sizes m_capacity; |
138 | 102 |
|
| 103 | + SnapshotView view() const { |
| 104 | + return SnapshotView { m_len, m_data }; |
| 105 | + } |
| 106 | +}; |
| 107 | + |
| 108 | +/// \brief A fixed-size snapshot record |
| 109 | +template <std::size_t N> |
| 110 | +class FixedSizeSnapshotRecord |
| 111 | +{ |
| 112 | + Entry m_data[N]; |
| 113 | + SnapshotBuilder m_builder; |
| 114 | + |
| 115 | +public: |
| 116 | + |
| 117 | + FixedSizeSnapshotRecord() |
| 118 | + : m_builder { N, m_data } |
| 119 | + { } |
| 120 | + |
| 121 | + SnapshotBuilder& builder() { return m_builder; } |
| 122 | + SnapshotView view() const { return m_builder.view(); } |
| 123 | + |
| 124 | + void reset() { |
| 125 | + m_builder = SnapshotBuilder(N, m_data); |
| 126 | + } |
139 | 127 | };
|
140 | 128 |
|
141 |
| -} |
| 129 | +} // namespace cali |
0 commit comments