Skip to content
This repository was archived by the owner on Sep 3, 2023. It is now read-only.

Commit da7a553

Browse files
isaac-baekisaac-baek
committed
[AWIBOF-4723] Polymorphic log interface refactoring
- Add benchmark(system test) - Optimize airlog API using template - Bugfix some unit tests Run on (160 X 3700 MHz CPU s) CPU Caches: L1 Data 32 KiB (x80) L1 Instruction 32 KiB (x80) L2 Unified 1024 KiB (x80) L3 Unified 28160 KiB (x4) ----------------------------------------------------------- AIR_API/Type_Performance: 8.46ns -> 7.51ns (11% improvement) AIR_API/Type_Latency: 12.6ns -> 10.7ns (15% improvement) AIR_API/Type_Queue: 9.76ns -> 7.29ns (25% improvement) AIR_API/Type_Utilization: 7.07ns -> 5.44ns (23% improvement) AIR_API/Type_Count: 7.31ns -> 6.41ns (12% improvement) Signed-off-by: isaac.baek <isaac.baek@samsung.com>
1 parent c0ab002 commit da7a553

21 files changed

+484
-186
lines changed

‎CMakeLists.txt

+2-1
Original file line numberDiff line numberDiff line change
@@ -4,12 +4,13 @@ set(CMAKE_C_COMPILER "gcc")
44

55
project(
66
AIR
7-
VERSION 0.7.0
7+
VERSION 0.7.1
88
DESCRIPTION "Analytics In Real-time"
99
LANGUAGES CXX C
1010
)
1111

1212
find_package(Threads)
13+
find_package(benchmark)
1314

1415
if(DEFINED CONFIG)
1516
message(STATUS "CONFIG is defined: ${CONFIG}")

‎src/api/Air.cpp

+5
Original file line numberDiff line numberDiff line change
@@ -30,6 +30,11 @@ air::InstanceManager* AIR<true, true>::instance_manager = nullptr;
3030
node::NodeManager* AIR<true, true>::node_manager = nullptr;
3131
collection::CollectionManager* AIR<true, true>::collection_manager = nullptr;
3232
thread_local node::NodeDataArray* AIR<true, true>::node_data_array = nullptr;
33+
collection::PerformanceWriter AIR<true, true>::perf_writer;
34+
collection::LatencyWriter AIR<true, true>::lat_writer;
35+
collection::QueueWriter AIR<true, true>::queue_writer;
36+
collection::UtilizationWriter AIR<true, true>::util_writer;
37+
collection::CountWriter AIR<true, true>::count_writer;
3338

3439
void
3540
air_request_data(transfer::node_list nodes, transfer::task_unit&& function)

‎src/api/Air.h

+92-69
Original file line numberDiff line numberDiff line change
@@ -32,6 +32,11 @@
3232
#include <unistd.h>
3333

3434
#include "src/collection/CollectionManager.h"
35+
#include "src/collection/writer/CountWriter.h"
36+
#include "src/collection/writer/LatencyWriter.h"
37+
#include "src/collection/writer/PerformanceWriter.h"
38+
#include "src/collection/writer/QueueWriter.h"
39+
#include "src/collection/writer/UtilizationWriter.h"
3540
#include "src/config/ConfigInterface.h"
3641
#include "src/data_structure/NodeManager.h"
3742
#include "src/lib/Casting.h"
@@ -51,10 +56,11 @@
5156

5257
#define airlog(node_name, filter_item, node_index, data) \
5358
AIR<cfg::GetIntValue(config::ParagraphType::DEFAULT, "AirBuild"), \
54-
cfg::GetIntValue(config::ParagraphType::NODE, "Build", \
55-
node_name)>::LogData<cfg::GetSentenceIndex(config::ParagraphType::NODE, node_name), \
56-
cfg::GetIntValue(config::ParagraphType::FILTER, "Item", \
57-
cfg::GetStrValue(config::ParagraphType::NODE, "Filter", node_name), filter_item)>(node_index, data)
59+
cfg::GetIntValue(config::ParagraphType::NODE, "Build", node_name)> \
60+
::LogData<cfg::GetSentenceIndex(config::ParagraphType::NODE, node_name), \
61+
cfg::GetIntValue(config::ParagraphType::FILTER, "Item", \
62+
cfg::GetStrValue(config::ParagraphType::NODE, "Filter", node_name), filter_item), \
63+
cfg::GetNodeType(node_name)>(node_index, data)
5864

5965
// Primary template
6066
template<bool AirBuild, bool NodeBuild>
@@ -66,14 +72,10 @@ class AIR
6672
static void Deactivate(void);
6773
static void Finalize(void);
6874

69-
template<int32_t node_id, int32_t filter_index>
75+
template<int32_t node_id, int32_t filter_index, air::ProcessorType node_type,
76+
air::ProcessorType enable = air::ProcessorType::PROCESSORTYPE_NULL>
7077
static void LogData(uint64_t node_index, uint64_t value);
7178
static void LogData(uint32_t node_id, uint32_t filter_index, uint64_t node_index, uint64_t value);
72-
73-
static air::InstanceManager* instance_manager;
74-
static node::NodeManager* node_manager;
75-
static collection::CollectionManager* collection_manager;
76-
static thread_local node::NodeDataArray* node_data_array;
7779
};
7880

7981
// AIR build : true && Node build : true
@@ -116,29 +118,59 @@ class AIR<true, true>
116118
collection_manager = instance_manager->GetCollectionManager();
117119
}
118120

119-
template<int32_t node_id, int32_t filter_index>
121+
template<int32_t node_id, int32_t filter_index, air::ProcessorType node_type,
122+
typename std::enable_if<air::ProcessorType::PERFORMANCE == node_type, air::ProcessorType>::type = node_type>
120123
static void
121124
LogData(uint64_t node_index, uint64_t value)
122125
{
123126
static_assert(-1 != node_id, "Invalid Node");
124127
static_assert(-1 != filter_index, "Invalid Filter Item");
125128

126-
if ((nullptr == collection_manager) ||
127-
(false == collection_manager->IsLog(node_id)))
128-
{
129-
return;
130-
}
129+
perf_writer.LogData(_GetData(node_id, filter_index, node_index), value);
130+
}
131131

132-
if (nullptr != node_data_array)
133-
{
134-
collection_manager->LogData(node_id, filter_index, node_data_array, node_index, value);
135-
}
136-
else if (nullptr != node_manager)
137-
{
138-
uint32_t tid = syscall(SYS_gettid);
139-
node_data_array = node_manager->GetNodeDataArray(tid);
140-
node_manager->SetNodeDataArrayName(tid);
141-
}
132+
template<int32_t node_id, int32_t filter_index, air::ProcessorType node_type,
133+
typename std::enable_if<air::ProcessorType::LATENCY == node_type, air::ProcessorType>::type = node_type>
134+
static void
135+
LogData(uint64_t node_index, uint64_t value)
136+
{
137+
static_assert(-1 != node_id, "Invalid Node");
138+
static_assert(-1 != filter_index, "Invalid Filter Item");
139+
140+
lat_writer.LogData(_GetData(node_id, filter_index, node_index), value);
141+
}
142+
143+
template<int32_t node_id, int32_t filter_index, air::ProcessorType node_type,
144+
typename std::enable_if<air::ProcessorType::QUEUE == node_type, air::ProcessorType>::type = node_type>
145+
static void
146+
LogData(uint64_t node_index, uint64_t value)
147+
{
148+
static_assert(-1 != node_id, "Invalid Node");
149+
static_assert(-1 != filter_index, "Invalid Filter Item");
150+
151+
queue_writer.LogData(_GetData(node_id, filter_index, node_index), value);
152+
}
153+
154+
template<int32_t node_id, int32_t filter_index, air::ProcessorType node_type,
155+
typename std::enable_if<air::ProcessorType::UTILIZATION == node_type, air::ProcessorType>::type = node_type>
156+
static void
157+
LogData(uint64_t node_index, uint64_t value)
158+
{
159+
static_assert(-1 != node_id, "Invalid Node");
160+
static_assert(-1 != filter_index, "Invalid Filter Item");
161+
162+
util_writer.LogData(_GetData(node_id, filter_index, node_index), value);
163+
}
164+
165+
template<int32_t node_id, int32_t filter_index, air::ProcessorType node_type,
166+
typename std::enable_if<air::ProcessorType::COUNT == node_type, air::ProcessorType>::type = node_type>
167+
static void
168+
LogData(uint64_t node_index, uint64_t value)
169+
{
170+
static_assert(-1 != node_id, "Invalid Node");
171+
static_assert(-1 != filter_index, "Invalid Filter Item");
172+
173+
count_writer.LogData(_GetData(node_id, filter_index, node_index), value);
142174
}
143175

144176
static void
@@ -162,53 +194,49 @@ class AIR<true, true>
162194
}
163195
}
164196

197+
protected:
198+
static lib::Data*
199+
_GetData(int32_t node_id, int32_t filter_index, uint64_t node_index)
200+
{
201+
if ((nullptr == collection_manager) ||
202+
(false == collection_manager->IsLog(node_id)))
203+
{
204+
return nullptr;
205+
}
206+
if (nullptr != node_data_array)
207+
{
208+
node::NodeData* node_data = node_data_array->node[node_id];
209+
if (nullptr == node_data)
210+
{
211+
return nullptr;
212+
}
213+
return node_data->GetUserDataByNodeIndex(node_index, filter_index);
214+
}
215+
else if (nullptr != node_manager)
216+
{
217+
uint32_t tid = syscall(SYS_gettid);
218+
node_data_array = node_manager->GetNodeDataArray(tid);
219+
node_manager->SetNodeDataArrayName(tid);
220+
}
221+
return nullptr;
222+
}
165223
static air::InstanceManager* instance_manager;
166224
static node::NodeManager* node_manager;
167225
static collection::CollectionManager* collection_manager;
168226
static thread_local node::NodeDataArray* node_data_array;
227+
static collection::PerformanceWriter perf_writer;
228+
static collection::LatencyWriter lat_writer;
229+
static collection::QueueWriter queue_writer;
230+
static collection::UtilizationWriter util_writer;
231+
static collection::CountWriter count_writer;
169232
};
170233

171-
// AIR build : false && Node build : true
234+
// AIR build : true && Node build : false
172235
template<>
173236
class AIR<true, false>
174237
{
175238
public:
176-
static void
177-
Initialize(uint32_t cpu_num = 0)
178-
{
179-
instance_manager = new air::InstanceManager();
180-
instance_manager->Initialize(cpu_num);
181-
node_manager = instance_manager->GetNodeManager();
182-
collection_manager = instance_manager->GetCollectionManager();
183-
}
184-
static void
185-
Activate(void)
186-
{
187-
if (nullptr != instance_manager)
188-
{
189-
instance_manager->Activate();
190-
}
191-
}
192-
static void
193-
Deactivate(void)
194-
{
195-
if (nullptr != instance_manager)
196-
{
197-
instance_manager->Deactivate();
198-
}
199-
}
200-
static void
201-
Finalize(void)
202-
{
203-
if (nullptr != instance_manager)
204-
{
205-
instance_manager->Finalize();
206-
delete instance_manager;
207-
instance_manager = nullptr;
208-
}
209-
}
210-
211-
template<int32_t node_id, int32_t filter_index>
239+
template<int32_t node_id, int32_t filter_index, air::ProcessorType type>
212240
static void
213241
LogData(uint64_t node_index, uint64_t value)
214242
{
@@ -217,11 +245,6 @@ class AIR<true, false>
217245
LogData(uint32_t node_id, uint32_t filter_index, uint64_t node_index, uint64_t value)
218246
{
219247
}
220-
221-
static air::InstanceManager* instance_manager;
222-
static node::NodeManager* node_manager;
223-
static collection::CollectionManager* collection_manager;
224-
static thread_local node::NodeDataArray* node_data_array;
225248
};
226249

227250
// AIR build : false
@@ -245,7 +268,7 @@ class AIR<false, NodeBuild>
245268
Finalize(void)
246269
{
247270
}
248-
template<int32_t node_id, int32_t filter_index>
271+
template<int32_t node_id, int32_t filter_index, air::ProcessorType type>
249272
static void
250273
LogData(uint64_t node_index, uint64_t value)
251274
{

‎src/api/Air_c.cpp

+39
Original file line numberDiff line numberDiff line change
@@ -23,3 +23,42 @@
2323
*/
2424

2525
#include "src/api/Air_c.h"
26+
#include "src/api/Air.h"
27+
28+
extern "C"
29+
void AIR_INITIALIZE(uint32_t cpu_num)
30+
{
31+
air_initialize(cpu_num);
32+
}
33+
34+
extern "C"
35+
void AIR_ACTIVATE(void)
36+
{
37+
air_activate();
38+
}
39+
40+
extern "C"
41+
void AIR_DEACTIVATE(void)
42+
{
43+
air_deactivate();
44+
}
45+
46+
extern "C"
47+
void AIR_FINALIZE(void)
48+
{
49+
air_finalize();
50+
}
51+
52+
extern "C"
53+
void AIRLOG(uint32_t node_id, uint32_t filter_item, uint64_t node_index, uint64_t value)
54+
{
55+
AIR<cfg::GetIntValue(config::ParagraphType::DEFAULT, "AirBuild"), true>::
56+
LogData(node_id, filter_item, node_index, value);
57+
}
58+
59+
extern "C"
60+
void AIRLOG_DUMMY(uint32_t node_id, uint32_t filter_item, uint64_t node_index, uint64_t value)
61+
{
62+
AIR<cfg::GetIntValue(config::ParagraphType::DEFAULT, "AirBuild"), false>::
63+
LogData(node_id, filter_item, node_index, value);
64+
}

‎src/collection/writer/CountWriter.h

+6-2
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,10 @@ class CountWriter : public Writer
4242
inline void
4343
LogData(lib::Data* data, uint64_t value) override
4444
{
45+
if (nullptr == data)
46+
{
47+
return;
48+
}
4549
lib::CountData* count_data = static_cast<lib::CountData*>(data);
4650
count_data->access = true;
4751

@@ -63,8 +67,8 @@ class CountWriter : public Writer
6367
}
6468

6569
private:
66-
const uint64_t MAX_INT64_VALUE{9223372036854775807};
67-
const uint64_t NEGATIVE_ONE{0xffffffffffffffff};
70+
const uint64_t MAX_INT64_VALUE {9223372036854775807};
71+
const uint64_t NEGATIVE_ONE {0xffffffffffffffff};
6872
};
6973

7074
} // namespace collection

‎src/collection/writer/LatencyWriter.h

+4
Original file line numberDiff line numberDiff line change
@@ -41,6 +41,10 @@ class LatencyWriter : public Writer
4141
inline void
4242
LogData(lib::Data* data, uint64_t key) override
4343
{
44+
if (nullptr == data)
45+
{
46+
return;
47+
}
4448
lib::LatencyData* lat_data = static_cast<lib::LatencyData*>(data);
4549

4650
lat_data->access = true;

‎src/collection/writer/PerformanceWriter.h

+4
Original file line numberDiff line numberDiff line change
@@ -39,6 +39,10 @@ class PerformanceWriter : public Writer
3939
inline void
4040
LogData(lib::Data* data, uint64_t io_size) override
4141
{
42+
if (nullptr == data)
43+
{
44+
return;
45+
}
4246
lib::PerformanceData* perf_data = static_cast<lib::PerformanceData*>(data);
4347
perf_data->access = true;
4448

‎src/collection/writer/QueueWriter.h

+11-7
Original file line numberDiff line numberDiff line change
@@ -46,6 +46,10 @@ class QueueWriter : public Writer
4646
inline void
4747
LogData(lib::Data* data, uint64_t q_depth) override
4848
{
49+
if (nullptr == data)
50+
{
51+
return;
52+
}
4953
lib::QueueData* queue_data = static_cast<lib::QueueData*>(data);
5054
if (false == IsSampling(queue_data))
5155
{
@@ -77,7 +81,7 @@ class QueueWriter : public Writer
7781
inline bool
7882
IsSampling(lib::QueueData* queue_data)
7983
{
80-
bool result{false};
84+
bool result {false};
8185
if (sampling_rate != queue_data->sampling_rate)
8286
{
8387
queue_data->sampling_rate = sampling_rate;
@@ -102,7 +106,7 @@ class QueueWriter : public Writer
102106
}
103107
else
104108
{
105-
uint32_t rand_uint = std::uniform_int_distribution<uint32_t>{
109+
uint32_t rand_uint = std::uniform_int_distribution<uint32_t> {
106110
0, sampling_rate}(queue_data->mersenne);
107111
float rand_float = rand_uint * 0.8;
108112
queue_data->logging_point = rand_float + (sampling_rate * 0.1);
@@ -119,12 +123,12 @@ class QueueWriter : public Writer
119123

120124
private:
121125
void _UpdateRand(void);
122-
static const uint32_t PADDING{10};
123-
static const uint32_t DEFAULT_RATIO{1000}; // tmp. 1000
124-
static const uint32_t MIN_RATIO{1};
125-
static const uint32_t MAX_RATIO{10000};
126+
static const uint32_t PADDING {10};
127+
static const uint32_t DEFAULT_RATIO {1000}; // tmp. 1000
128+
static const uint32_t MIN_RATIO {1};
129+
static const uint32_t MAX_RATIO {10000};
126130

127-
uint32_t sampling_rate{DEFAULT_RATIO};
131+
uint32_t sampling_rate {DEFAULT_RATIO};
128132
std::random_device rand;
129133
std::mt19937 mersenne;
130134
};

0 commit comments

Comments
 (0)