|
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