Skip to content

Commit ffd9259

Browse files
PhilippGrulichPhilippGrulich
committed
first commit
1 parent 850c5b7 commit ffd9259

File tree

8 files changed

+236
-90
lines changed

8 files changed

+236
-90
lines changed

‎CMakeLists.txt

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
cmake_minimum_required(VERSION 3.22.1)
22

33
option(USE_SOURCE_LOCATION_TRACKING "Use Feature X" ON)
4+
option(ENABLE_TRACING "Use Feature X" ON)
45

56
project(nautilus_lib)
67

‎nautilus-api/CMakeLists.txt

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,9 @@ get_source(nautilus-api NES_COMMON_SOURCE_FILES)
77
# Add Library
88
add_library(nautilus-api OBJECT ${NES_COMMON_SOURCE_FILES}
99
include/Interface/DataTypes/Val.hpp
10-
include/Interface/DataTypes/ValPtr.hpp)
10+
include/Interface/DataTypes/ValPtr.hpp
11+
include/traceing.hpp
12+
src/tracing.cpp)
1113
target_link_libraries(nautilus-api PUBLIC nautilus-jit nautilus-common nautilus_fmt)
1214
target_include_directories(nautilus-api PUBLIC
1315
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>

‎nautilus-api/include/Interface/DataTypes/Val.hpp

Lines changed: 125 additions & 85 deletions
Original file line numberDiff line numberDiff line change
@@ -8,8 +8,16 @@
88
#include <common/CastUtils.hpp>
99
#include <common/config.hpp>
1010

11+
#ifdef ENABLE_TRACING
12+
13+
#include <traceing.hpp>
14+
15+
#endif
16+
1117
#ifdef USE_SOURCE_LOCATION_TRACKING
18+
1219
#include <common/source_location.hpp>
20+
1321
#endif
1422

1523

@@ -19,7 +27,6 @@ namespace nautilus {
1927
};
2028

2129

22-
2330
template<class T>
2431
concept is_base_type = std::is_base_of<base_value, T>::value;
2532

@@ -118,17 +125,28 @@ namespace nautilus {
118125

119126
#ifdef USE_SOURCE_LOCATION_TRACKING
120127

128+
121129
inline val<ValueType>(ValueType value, const std::source_location loc = std::source_location::current())
122-
: value(value), loc(loc) {};
130+
: value(value), loc(loc) {
131+
132+
std::cout << loc.file_name() << std::endl;
133+
};
134+
123135

124136
inline val<ValueType>(const val<ValueType> &other,
125137
const std::source_location loc = std::source_location::current())
126138
: value(other.value), loc(loc) {};
127139
#else
140+
128141
inline val<ValueType>(ValueType value) : value(value) {};
142+
129143
inline val<ValueType>(const val<ValueType> &other) : value(other.value) {};
130144
#endif
131145

146+
#ifdef ENABLE_TRACING
147+
148+
inline val<ValueType>(tracing::TraceState *tc) : state(tc) {};
149+
#endif
132150

133151
val<ValueType> &operator=(const val<ValueType> &other) {
134152
this->value = other.value;
@@ -143,6 +161,7 @@ namespace nautilus {
143161
}
144162

145163
operator bool() const {
164+
// traceBool(state);
146165
// cast
147166
return value;
148167
}
@@ -182,6 +201,11 @@ namespace nautilus {
182201
const std::source_location loc;
183202
#endif
184203

204+
#ifdef ENABLE_TRACING
205+
tracing::TraceState *state;
206+
#endif
207+
208+
185209
private:
186210
friend class val_ptr<ValueType *>;
187211

@@ -256,6 +280,7 @@ namespace nautilus {
256280
return val<Type>(value);
257281
};
258282

283+
259284
template<is_fundamental LeftType, is_fundamental RightType>
260285
auto cast_value(val<LeftType> &value) {
261286
typedef typename std::common_type<LeftType, RightType>::type commonType;
@@ -267,175 +292,190 @@ namespace nautilus {
267292
};
268293

269294
namespace details {
295+
296+
#ifdef ENABLE_TRACING
297+
#define TRAC_BINARY_OP(OP) \
298+
if (tracing::inTracer()) {\
299+
auto tc = traceBinaryOp<tracing::OP, commonType>(lValue.state, rValue.state);\
300+
return val<commonType>(tc);\
301+
}
302+
#else
303+
#define TRAC_OP(OP)
304+
#endif
305+
306+
#ifdef ENABLE_TRACING
307+
#define TRAC_LOGICAL_BINARY_OP(OP) \
308+
if (tracing::inTracer()) {\
309+
auto tc = traceBinaryOp<tracing::OP, commonType>(lValue.state, rValue.state);\
310+
return val<bool>(tc);\
311+
}
312+
#else
313+
#define TRAC_LOGICAL_BINARY_OP(OP)
314+
#endif
315+
270316
template<is_fundamental LHS, is_fundamental RHS>
271317
COMMON_RETURN_TYPE add(val<LHS> &left, val<RHS> &right) {
272-
#ifdef USE_SOURCE_LOCATION_TRACKING
273-
std::cout << left.loc.file_name() << std::endl;
274-
#endif
275318
typedef typename std::common_type<LHS, RHS>::type commonType;
276319
auto lValue = cast_value<LHS, commonType>(left);
277320
auto rValue = cast_value<RHS, commonType>(right);
321+
322+
TRAC_BINARY_OP(ADD)
278323
return lValue.value + rValue.value;
279324
}
280325

281326
template<is_fundamental LHS, is_fundamental RHS>
282327
COMMON_RETURN_TYPE inline sub(val<LHS> &left, val<RHS> &right) {
283-
#ifdef USE_SOURCE_LOCATION_TRACKING
284-
std::cout << left.loc.file_name() << std::endl;
285-
#endif
286-
auto lValue = cast_value<LHS, RHS>(left);
287-
auto rValue = cast_value<RHS, LHS>(right);
328+
typedef typename std::common_type<LHS, RHS>::type commonType;
329+
auto lValue = cast_value<LHS, commonType>(left);
330+
auto rValue = cast_value<RHS, commonType>(right);
331+
TRAC_BINARY_OP(SUB)
288332
return lValue.value - rValue.value;
289333
}
290334

291335
template<is_fundamental LHS, is_fundamental RHS>
292336
COMMON_RETURN_TYPE mul(val<LHS> &left, val<RHS> &right) {
293-
#ifdef USE_SOURCE_LOCATION_TRACKING
294-
std::cout << left.loc.file_name() << std::endl;
295-
#endif
296-
auto lValue = cast_value<LHS, RHS>(left);
297-
auto rValue = cast_value<RHS, LHS>(right);
337+
typedef typename std::common_type<LHS, RHS>::type commonType;
338+
auto lValue = cast_value<LHS, commonType>(left);
339+
auto rValue = cast_value<RHS, commonType>(right);
340+
TRAC_BINARY_OP(MUL)
298341
return lValue.value * rValue.value;
299342
}
300343

301344
template<is_fundamental LHS, is_fundamental RHS>
302345
COMMON_RETURN_TYPE inline div(val<LHS> &left, val<RHS> &right) {
303-
#ifdef USE_SOURCE_LOCATION_TRACKING
304-
std::cout << left.loc.file_name() << std::endl;
305-
#endif
306-
auto lValue = cast_value<LHS, RHS>(left);
307-
auto rValue = cast_value<RHS, LHS>(right);
346+
typedef typename std::common_type<LHS, RHS>::type commonType;
347+
auto lValue = cast_value<LHS, commonType>(left);
348+
auto rValue = cast_value<RHS, commonType>(right);
349+
TRAC_BINARY_OP(DIV)
308350
return lValue.value / rValue.value;
309351
}
310352

311353
template<is_fundamental LHS, is_fundamental RHS>
312354
val<bool> inline eq(val<LHS> &left, val<RHS> &right) {
313-
#ifdef USE_SOURCE_LOCATION_TRACKING
314-
std::cout << left.loc.file_name() << std::endl;
315-
#endif
316-
auto lValue = cast_value<LHS, RHS>(left);
317-
auto rValue = cast_value<RHS, LHS>(right);
355+
typedef typename std::common_type<LHS, RHS>::type commonType;
356+
auto lValue = cast_value<LHS, commonType>(left);
357+
auto rValue = cast_value<RHS, commonType>(right);
358+
TRAC_LOGICAL_BINARY_OP(EQ)
318359
return lValue.value == rValue.value;
319360
}
320361

321362
template<is_fundamental LHS, is_fundamental RHS>
322363
val<bool> inline neq(val<LHS> &left, val<RHS> &right) {
323-
#ifdef USE_SOURCE_LOCATION_TRACKING
324-
std::cout << left.loc.file_name() << std::endl;
325-
#endif
326-
auto lValue = cast_value<LHS, RHS>(left);
327-
auto rValue = cast_value<RHS, LHS>(right);
364+
typedef typename std::common_type<LHS, RHS>::type commonType;
365+
auto lValue = cast_value<LHS, commonType>(left);
366+
auto rValue = cast_value<RHS, commonType>(right);
367+
TRAC_LOGICAL_BINARY_OP(NEQ)
328368
return lValue.value != rValue.value;
329369
}
330370

331371
template<is_fundamental LHS, is_fundamental RHS>
332372
val<bool> inline lt(val<LHS> &left, val<RHS> &right) {
333-
#ifdef USE_SOURCE_LOCATION_TRACKING
334-
std::cout << left.loc.file_name() << std::endl;
335-
#endif
336-
auto lValue = cast_value<LHS, RHS>(left);
337-
auto rValue = cast_value<RHS, LHS>(right);
373+
typedef typename std::common_type<LHS, RHS>::type commonType;
374+
auto lValue = cast_value<LHS, commonType>(left);
375+
auto rValue = cast_value<RHS, commonType>(right);
376+
TRAC_LOGICAL_BINARY_OP(LT)
338377
return lValue.value < rValue.value;
339378
}
340379

341380
template<is_fundamental LHS, is_fundamental RHS>
342381
val<bool> inline lte(val<LHS> &left, val<RHS> &right) {
343-
#ifdef USE_SOURCE_LOCATION_TRACKING
344-
std::cout << left.loc.file_name() << std::endl;
345-
#endif
346-
auto lValue = cast_value<LHS, RHS>(left);
347-
auto rValue = cast_value<RHS, LHS>(right);
382+
typedef typename std::common_type<LHS, RHS>::type commonType;
383+
auto lValue = cast_value<LHS, commonType>(left);
384+
auto rValue = cast_value<RHS, commonType>(right);
385+
TRAC_LOGICAL_BINARY_OP(LTE)
348386
return lValue.value <= rValue.value;
349387
}
350388

351389
template<is_fundamental LHS, is_fundamental RHS>
352390
val<bool> inline gt(val<LHS> &left, val<RHS> &right) {
353-
#ifdef USE_SOURCE_LOCATION_TRACKING
354-
std::cout << left.loc.file_name() << std::endl;
355-
#endif
356-
auto lValue = cast_value<LHS, RHS>(left);
357-
auto rValue = cast_value<RHS, LHS>(right);
391+
typedef typename std::common_type<LHS, RHS>::type commonType;
392+
auto lValue = cast_value<LHS, commonType>(left);
393+
auto rValue = cast_value<RHS, commonType>(right);
394+
TRAC_LOGICAL_BINARY_OP(GT)
358395
return lValue.value > rValue.value;
359396
}
360397

361398
template<is_fundamental LHS, is_fundamental RHS>
362399
val<bool> inline gte(val<LHS> &left, val<RHS> &right) {
363-
#ifdef USE_SOURCE_LOCATION_TRACKING
364-
std::cout << left.loc.file_name() << std::endl;
365-
#endif
366-
auto lValue = cast_value<LHS, RHS>(left);
367-
auto rValue = cast_value<RHS, LHS>(right);
400+
typedef typename std::common_type<LHS, RHS>::type commonType;
401+
auto lValue = cast_value<LHS, commonType>(left);
402+
auto rValue = cast_value<RHS, commonType>(right);
403+
TRAC_LOGICAL_BINARY_OP(GTE)
368404
return lValue.value >= rValue.value;
369405
}
370406

371407
val<bool> inline lOr(val<bool> &left, val<bool> &right) {
372-
#ifdef USE_SOURCE_LOCATION_TRACKING
373-
std::cout << left.loc.file_name() << std::endl;
374-
#endif
408+
if (tracing::inTracer()) {
409+
auto tc = traceBinaryOp<tracing::OR, bool>(left.state, right.state);
410+
return {tc};
411+
}
375412
return left.value || right.value;
376413
}
377414

378415
val<bool> inline lAnd(val<bool> &left, val<bool> &right) {
379-
#ifdef USE_SOURCE_LOCATION_TRACKING
380-
std::cout << left.loc.file_name() << std::endl;
381-
#endif
416+
if (tracing::inTracer()) {
417+
auto tc = traceBinaryOp<tracing::AND, bool>(left.state, right.state);
418+
return {tc};
419+
}
382420
return left.value && right.value;
383421
}
384422

385423
val<bool> inline lNot(val<bool> &val) {
386-
#ifdef USE_SOURCE_LOCATION_TRACKING
387-
std::cout << val.loc.file_name() << std::endl;
388-
#endif
424+
if (tracing::inTracer()) {
425+
auto tc = traceUnaryOp<tracing::NOT, bool>(val.state);
426+
return {tc};
427+
}
389428
return !val.value;
390429
}
391430

392431
template<is_integral LHS, is_integral RHS>
393432
auto inline shr(val<LHS> &left, val<RHS> &right) {
394-
#ifdef USE_SOURCE_LOCATION_TRACKING
395-
std::cout << left.loc.file_name() << std::endl;
396-
#endif
397-
auto lValue = cast_value<LHS, RHS>(left);
398-
auto rValue = cast_value<RHS, LHS>(right);
399-
return make_value(lValue.value >> rValue.value);
433+
typedef decltype(left.value >> right.value) resultType;
434+
auto lValue = cast_value<LHS, resultType>(left);
435+
auto rValue = cast_value<RHS, resultType>(right);
436+
if (tracing::inTracer()) {
437+
auto tc = traceBinaryOp<tracing::RSH, resultType>(lValue.state, rValue.state);
438+
return val<resultType>(tc);
439+
}
440+
return make_value(left.value >> right.value);
400441
}
401442

402443
template<is_integral LHS, is_integral RHS>
403444
auto inline shl(val<LHS> &left, val<RHS> &right) {
404-
#ifdef USE_SOURCE_LOCATION_TRACKING
405-
std::cout << left.loc.file_name() << std::endl;
406-
#endif
407-
auto lValue = cast_value<LHS, RHS>(left);
408-
auto rValue = cast_value<RHS, LHS>(right);
445+
typedef decltype(left.value << right.value) resultType;
446+
auto lValue = cast_value<LHS, resultType>(left);
447+
auto rValue = cast_value<RHS, resultType>(right);
448+
if (tracing::inTracer()) {
449+
auto tc = traceBinaryOp<tracing::LSH, resultType>(lValue.state, rValue.state);
450+
return val<resultType>(tc);
451+
}
409452
return make_value(lValue.value << rValue.value);
410453
}
411454

412455
template<is_fundamental LHS, is_fundamental RHS>
413456
COMMON_RETURN_TYPE inline mod(val<LHS> &left, val<RHS> &right) {
414-
#ifdef USE_SOURCE_LOCATION_TRACKING
415-
std::cout << left.loc.file_name() << std::endl;
416-
#endif
417-
auto lValue = cast_value<LHS, RHS>(left);
418-
auto rValue = cast_value<RHS, LHS>(right);
457+
typedef typename std::common_type<LHS, RHS>::type commonType;
458+
auto lValue = cast_value<LHS, commonType>(left);
459+
auto rValue = cast_value<RHS, commonType>(right);
460+
TRAC_BINARY_OP(MOD)
419461
return lValue.value % rValue.value;
420462
}
421463

422464
template<is_fundamental LHS, is_fundamental RHS>
423465
COMMON_RETURN_TYPE inline bAnd(val<LHS> &left, val<RHS> &right) {
424-
#ifdef USE_SOURCE_LOCATION_TRACKING
425-
std::cout << left.loc.file_name() << std::endl;
426-
#endif
427-
auto lValue = cast_value<LHS, RHS>(left);
428-
auto rValue = cast_value<RHS, LHS>(right);
466+
typedef typename std::common_type<LHS, RHS>::type commonType;
467+
auto lValue = cast_value<LHS, commonType>(left);
468+
auto rValue = cast_value<RHS, commonType>(right);
469+
TRAC_BINARY_OP(BAND)
429470
return lValue.value & rValue.value;
430471
}
431472

432473
template<is_fundamental LHS, is_fundamental RHS>
433474
COMMON_RETURN_TYPE inline bOr(val<LHS> &left, val<RHS> &right) {
434-
#ifdef USE_SOURCE_LOCATION_TRACKING
435-
std::cout << left.loc.file_name() << std::endl;
436-
#endif
437-
auto lValue = cast_value<LHS, RHS>(left);
438-
auto rValue = cast_value<RHS, LHS>(right);
475+
typedef typename std::common_type<LHS, RHS>::type commonType;
476+
auto lValue = cast_value<LHS, commonType>(left);
477+
auto rValue = cast_value<RHS, commonType>(right);
478+
TRAC_BINARY_OP(BOR)
439479
return lValue.value | rValue.value;
440480
}
441481

0 commit comments

Comments
 (0)