0.9.8.10
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
StatsTable.cc
Go to the documentation of this file.
1 
21 #include "Common/Compat.h"
22 #include "Common/Logger.h"
23 #include "Common/Serialization.h"
24 
25 #include "StatsTable.h"
26 
27 using namespace Hypertable;
28 
29 namespace {
30  enum Group {
31  MAIN_GROUP = 0
32  };
33 }
34 
35 StatsTable::StatsTable() : StatsSerializable(TABLE, 1) {
36  clear();
37  group_ids[0] = MAIN_GROUP;
38 }
39 
40 
41 void StatsTable::clear() {
42  table_id = "";
43  range_count = 0;
44  scanner_count = 0;
45  cell_count = 0;
46  file_count = 0;
47  scans = 0;
48  cells_scanned = 0;
49  cells_returned = 0;
50  bytes_scanned = 0;
51  bytes_returned = 0;
52  updates = 0;
53  cells_written = 0;
54  bytes_written = 0;
55  disk_bytes_read = 0;
56  disk_used = 0;
57  key_bytes = 0;
58  value_bytes = 0;
59  compression_ratio = 0.0;
60  memory_used = 0;
61  memory_allocated = 0;
62  shadow_cache_memory = 0;
63  block_index_memory = 0;
64  bloom_filter_memory = 0;
65  bloom_filter_accesses = 0;
66  bloom_filter_maybes = 0;
67 }
68 
69 size_t StatsTable::encoded_length_group(int group) const {
70 
71  if (group == MAIN_GROUP) {
72  return Serialization::encoded_length_vstr(table_id) + \
73  Serialization::encoded_length_vi32(range_count) + \
74  Serialization::encoded_length_vi32(scanner_count) + \
75  Serialization::encoded_length_vi64(cell_count) + \
76  Serialization::encoded_length_vi64(file_count) + \
77  Serialization::encoded_length_vi64(scans) + \
78  Serialization::encoded_length_vi64(cells_scanned) + \
79  Serialization::encoded_length_vi64(cells_returned) + \
80  Serialization::encoded_length_vi64(bytes_scanned) + \
81  Serialization::encoded_length_vi64(bytes_returned) + \
82  Serialization::encoded_length_vi64(updates) + \
83  Serialization::encoded_length_vi64(cells_written) + \
84  Serialization::encoded_length_vi64(bytes_written) + \
85  Serialization::encoded_length_vi64(disk_bytes_read) + \
86  Serialization::encoded_length_vi64(disk_used) + \
87  Serialization::encoded_length_vi64(key_bytes) + \
88  Serialization::encoded_length_vi64(value_bytes) + \
89  Serialization::encoded_length_double() + \
90  Serialization::encoded_length_vi64(memory_used) + \
91  Serialization::encoded_length_vi64(memory_allocated) + \
92  Serialization::encoded_length_vi64(shadow_cache_memory) + \
93  Serialization::encoded_length_vi64(block_index_memory) + \
94  Serialization::encoded_length_vi64(bloom_filter_memory) + \
95  Serialization::encoded_length_vi64(bloom_filter_accesses) + \
96  Serialization::encoded_length_vi64(bloom_filter_maybes);
97  }
98  else
99  HT_FATALF("Invalid group number (%d)", group);
100  return 0;
101 }
102 
103 void StatsTable::encode_group(int group, uint8_t **bufp) const {
104  if (group == MAIN_GROUP) {
105  Serialization::encode_vstr(bufp, table_id);
106  Serialization::encode_vi32(bufp, range_count);
107  Serialization::encode_vi32(bufp, scanner_count);
108  Serialization::encode_vi64(bufp, cell_count);
109  Serialization::encode_vi64(bufp, file_count);
110  Serialization::encode_vi64(bufp, scans);
111  Serialization::encode_vi64(bufp, cells_scanned);
112  Serialization::encode_vi64(bufp, cells_returned);
113  Serialization::encode_vi64(bufp, bytes_scanned);
114  Serialization::encode_vi64(bufp, bytes_returned);
115  Serialization::encode_vi64(bufp, updates);
116  Serialization::encode_vi64(bufp, cells_written);
117  Serialization::encode_vi64(bufp, bytes_written);
118  Serialization::encode_vi64(bufp, disk_bytes_read);
119  Serialization::encode_vi64(bufp, disk_used);
120  Serialization::encode_vi64(bufp, key_bytes);
121  Serialization::encode_vi64(bufp, value_bytes);
122  Serialization::encode_double(bufp, compression_ratio);
123  Serialization::encode_vi64(bufp, memory_used);
124  Serialization::encode_vi64(bufp, memory_allocated);
125  Serialization::encode_vi64(bufp, shadow_cache_memory);
126  Serialization::encode_vi64(bufp, block_index_memory);
127  Serialization::encode_vi64(bufp, bloom_filter_memory);
128  Serialization::encode_vi64(bufp, bloom_filter_accesses);
129  Serialization::encode_vi64(bufp, bloom_filter_maybes);
130  }
131  else
132  HT_FATALF("Invalid group number (%d)", group);
133 }
134 
135 void StatsTable::decode_group(int group, uint16_t len, const uint8_t **bufp, size_t *remainp) {
136  if (group == MAIN_GROUP) {
137  table_id = Serialization::decode_vstr(bufp, remainp);
138  range_count = Serialization::decode_vi32(bufp, remainp);
139  scanner_count = Serialization::decode_vi32(bufp, remainp);
140  cell_count = Serialization::decode_vi64(bufp, remainp);
141  file_count = Serialization::decode_vi64(bufp, remainp);
142  scans = Serialization::decode_vi64(bufp, remainp);
143  cells_scanned = Serialization::decode_vi64(bufp, remainp);
144  cells_returned = Serialization::decode_vi64(bufp, remainp);
145  bytes_scanned = Serialization::decode_vi64(bufp, remainp);
146  bytes_returned = Serialization::decode_vi64(bufp, remainp);
147  updates = Serialization::decode_vi64(bufp, remainp);
148  cells_written = Serialization::decode_vi64(bufp, remainp);
149  bytes_written = Serialization::decode_vi64(bufp, remainp);
150  disk_bytes_read = Serialization::decode_vi64(bufp, remainp);
151  disk_used = Serialization::decode_vi64(bufp, remainp);
152  key_bytes = Serialization::decode_vi64(bufp, remainp);
153  value_bytes = Serialization::decode_vi64(bufp, remainp);
154  compression_ratio = Serialization::decode_double(bufp, remainp);
155  memory_used = Serialization::decode_vi64(bufp, remainp);
156  memory_allocated = Serialization::decode_vi64(bufp, remainp);
157  shadow_cache_memory = Serialization::decode_vi64(bufp, remainp);
158  block_index_memory = Serialization::decode_vi64(bufp, remainp);
159  bloom_filter_memory = Serialization::decode_vi64(bufp, remainp);
160  bloom_filter_accesses = Serialization::decode_vi64(bufp, remainp);
161  bloom_filter_maybes = Serialization::decode_vi64(bufp, remainp);
162  }
163  else
164  HT_FATALF("Invalid group number (%d)", group);
165 }
166 
167 bool StatsTable::operator==(const StatsTable &other) const {
168  if (*((StatsSerializable *)this) != *((StatsSerializable *)&other))
169  return false;
170  if (table_id == other.table_id &&
171  range_count == other.range_count &&
172  scanner_count == other.scanner_count &&
173  cell_count == other.cell_count &&
174  file_count == other.file_count &&
175  scans == other.scans &&
176  cells_scanned == other.cells_scanned &&
177  cells_returned == other.cells_returned &&
178  bytes_scanned == other.bytes_scanned &&
179  bytes_returned == other.bytes_returned &&
180  updates == other.updates &&
181  cells_written == other.cells_written &&
182  bytes_written == other.bytes_written &&
183  disk_bytes_read == other.disk_bytes_read &&
184  disk_used == other.disk_used &&
185  key_bytes == other.key_bytes &&
186  value_bytes == other.value_bytes &&
187  Serialization::equal(compression_ratio, other.compression_ratio) &&
188  memory_used == other.memory_used &&
189  memory_allocated == other.memory_allocated &&
190  shadow_cache_memory == other.shadow_cache_memory &&
191  block_index_memory == other.block_index_memory &&
192  bloom_filter_memory == other.bloom_filter_memory &&
193  bloom_filter_accesses == other.bloom_filter_accesses &&
194  bloom_filter_maybes == other.bloom_filter_maybes)
195  return true;
196  return false;
197 }
Hypertable::StatsSerializable
Abstract base class for managing serialized statistics.
Definition: StatsSerializable.h:47
Hypertable::Serialization::decode_vstr
char * decode_vstr(const uint8_t **bufp, size_t *remainp)
Decode a vstr (vint64, data, null).
Definition: Serialization.h:487
Hypertable::StatsTable::encode_group
virtual void encode_group(int group, uint8_t **bufp) const
Abstruct function to serialize a group into a memory buffer.
Definition: StatsTable.cc:103
Hypertable::Serialization::encoded_length_double
int encoded_length_double()
Length of an encoded double (16 bytes)
Definition: Serialization.h:589
Hypertable::StatsTable::block_index_memory
uint64_t block_index_memory
Definition: StatsTable.h:91
Hypertable::StatsTable::disk_bytes_read
uint64_t disk_bytes_read
Definition: StatsTable.h:83
Hypertable::StatsTable::memory_allocated
uint64_t memory_allocated
Definition: StatsTable.h:89
Hypertable::StatsTable::decode_group
virtual void decode_group(int group, uint16_t len, const uint8_t **bufp, size_t *remainp)
Abstruct function to deserialize a group from a memory buffer.
Definition: StatsTable.cc:135
Hypertable::StatsTable::bloom_filter_memory
uint64_t bloom_filter_memory
Definition: StatsTable.h:92
Hypertable::Serialization::encoded_length_vstr
size_t encoded_length_vstr(size_t len)
Computes the encoded length of vstr (vint64, data, null)
Definition: Serialization.h:420
Hypertable::Serialization::encoded_length_vi32
int encoded_length_vi32(uint32_t val)
Length of a variable length encoded 32-bit integer (up to 5 bytes)
Definition: Serialization.h:175
Hypertable::Serialization::encode_vi64
void encode_vi64(uint8_t **bufp, uint64_t val)
Encode a integer (up to 64-bit) in variable length encoding.
Definition: Serialization.h:205
StatsTable.h
Group
Group
Definition: StatsSystem.cc:38
Logger.h
Logging routines and macros.
Compat.h
Compatibility Macros for C/C++.
Hypertable::StatsTable::table_id
std::string table_id
Definition: StatsTable.h:70
Serialization.h
Functions to serialize/deserialize primitives to/from a memory buffer.
Hypertable::StatsTable::shadow_cache_memory
uint64_t shadow_cache_memory
Definition: StatsTable.h:90
Hypertable::Serialization::encode_vstr
void encode_vstr(uint8_t **bufp, const void *buf, size_t len)
Encode a buffer as variable length string (vint64, data, null)
Definition: Serialization.h:453
Hypertable
Hypertable definitions
Definition: ApplicationHandler.h:36
HT_FATALF
#define HT_FATALF(msg,...)
Definition: Logger.h:343
Hypertable::Serialization::decode_vi64
uint64_t decode_vi64(const uint8_t **bufp, size_t *remainp)
Decode a variable length encoded integer up to 64-bit.
Definition: Serialization.h:228
Hypertable::Serialization::encode_vi32
void encode_vi32(uint8_t **bufp, uint32_t val)
Encode a integer (up to 32-bit) in variable length encoding.
Definition: Serialization.h:195
Hypertable::Serialization::decode_double
double decode_double(const uint8_t **bufp, size_t *remainp)
Decodes a double as 64-bit left-of-decimal, followed by 64-bit right-of-decimal, both in little-endia...
Definition: Serialization.h:577
Hypertable::Serialization::equal
bool equal(double a, double b)
Compare doubles that may have been serialized and unserialized.
Definition: Serialization.h:602
Hypertable::StatsTable::operator==
bool operator==(const StatsTable &other) const
Definition: StatsTable.cc:167
Hypertable::StatsSerializable::group_ids
uint8_t group_ids[32]
The actual group IDs.
Definition: StatsSerializable.h:119
Hypertable::StatsTable::bloom_filter_maybes
uint64_t bloom_filter_maybes
Definition: StatsTable.h:94
Hypertable::StatsTable::bloom_filter_accesses
uint64_t bloom_filter_accesses
Definition: StatsTable.h:93
Hypertable::StatsTable::encoded_length_group
virtual size_t encoded_length_group(int group) const
Abstruct function returning the serialized length of a group.
Definition: StatsTable.cc:69
Hypertable::Serialization::decode_vi32
uint32_t decode_vi32(const uint8_t **bufp, size_t *remainp)
Decode a variable length encoded integer up to 32-bit.
Definition: Serialization.h:216
Hypertable::Serialization::encode_double
void encode_double(uint8_t **bufp, double val)
Encodes a double with 18 decimal digits of precision as 64-bit left-of-decimal, followed by 64-bit ri...
Definition: Serialization.h:562
Hypertable::Serialization::encoded_length_vi64
int encoded_length_vi64(uint64_t val)
Length of a variable length encoded 64-bit integer (up to 9 bytes)
Definition: Serialization.h:185
Generated on Tue Dec 22 2015 18:43:13 for Hypertable by   doxygen 1.8.8