_Z29continuation_handler_void_ptrIN14EventProcessor10ThreadInitE5EventEM12ContinuationFiiPvEMT_FiiPT0_E: 72| 1|{ 73| 1| auto fp2 = reinterpret_cast(fp); 74| | 75| | // We keep this a static_cast for added static type analysis from the 76| | // compiler. If a compiler warning is generated for the following line of 77| | // code of the type "-Werror=shift-negative-value", then this may be an issue 78| | // with multiple inheritance of the C templated type. Make sure that for type 79| | // C the Continuation parent is listed first (either directly or indirectly 80| | // via the inheritance tree) before any other parent in the multiple class 81| | // hierarchy of C. 82| 1| return static_cast(fp2); 83| 1|} _ZN12ContinuationC2EP10ProxyMutex: 277| 3|inline Continuation::Continuation(ProxyMutex *amutex) : mutex(amutex) 278| 3|{ 279| | // Pick up the control flags from the creating thread 280| 3| this->control_flags.set_flags(get_cont_flags().get_flags()); 281| 3|} _Z29continuation_handler_void_ptrI25ThreadAffinityInitializer5EventEM12ContinuationFiiPvEMT_FiiPT0_E: 72| 1|{ 73| 1| auto fp2 = reinterpret_cast(fp); 74| | 75| | // We keep this a static_cast for added static type analysis from the 76| | // compiler. If a compiler warning is generated for the following line of 77| | // code of the type "-Werror=shift-negative-value", then this may be an issue 78| | // with multiple inheritance of the C templated type. Make sure that for type 79| | // C the Continuation parent is listed first (either directly or indirectly 80| | // via the inheritance tree) before any other parent in the multiple class 81| | // hierarchy of C. 82| 1| return static_cast(fp2); 83| 1|} UnixEventProcessor.cc:_Z29continuation_handler_void_ptrIN12_GLOBAL__N_116ThreadInitByFuncE5EventEM12ContinuationFiiPvEMT_FiiPT0_E: 72| 1|{ 73| 1| auto fp2 = reinterpret_cast(fp); 74| | 75| | // We keep this a static_cast for added static type analysis from the 76| | // compiler. If a compiler warning is generated for the following line of 77| | // code of the type "-Werror=shift-negative-value", then this may be an issue 78| | // with multiple inheritance of the C templated type. Make sure that for type 79| | // C the Continuation parent is listed first (either directly or indirectly 80| | // via the inheritance tree) before any other parent in the multiple class 81| | // hierarchy of C. 82| 1| return static_cast(fp2); 83| 1|} _ZN14EventProcessor10ThreadInitC2EPS_: 385| 1| explicit ThreadInit(EventProcessor *evp) : _evp(evp) { SET_HANDLER(&self::init); } ------------------ | | 253| 1|#define SET_HANDLER(_h) (handler = continuation_handler_void_ptr(_h)) ------------------ _Zor17HdrTokenInfoFlagsS_: 62| 34|{ 63| 34| return static_cast(static_cast(a) | static_cast(b)); 64| 34|} _ZN17FreelistAllocatorC2Ev: 89| 15| FreelistAllocator() { fl = nullptr; } _ZN17FreelistAllocatorC2EPKcjjjb: 101| 9| { 102| 9| ink_freelist_init(&fl, name, element_size, chunk_size, alignment, use_hugepages); 103| 9| } _ZN14ClassAllocatorI9MIOBufferLb0E17FreelistAllocatorEC2EPKcjj: 370| 1| : BaseAllocator(name, static_cast(RND16(sizeof(C))), chunk_size, static_cast(RND16(alignment))) ------------------ | | 49| 1|#define RND16(_x) (((_x) + 15) & ~15) ------------------ : BaseAllocator(name, static_cast(RND16(sizeof(C))), chunk_size, static_cast(RND16(alignment))) ------------------ | | 49| 1|#define RND16(_x) (((_x) + 15) & ~15) ------------------ 371| 1| { 372| 1| } _ZN14ClassAllocatorI12IOBufferDataLb0E17FreelistAllocatorEC2EPKcjj: 370| 1| : BaseAllocator(name, static_cast(RND16(sizeof(C))), chunk_size, static_cast(RND16(alignment))) ------------------ | | 49| 1|#define RND16(_x) (((_x) + 15) & ~15) ------------------ : BaseAllocator(name, static_cast(RND16(sizeof(C))), chunk_size, static_cast(RND16(alignment))) ------------------ | | 49| 1|#define RND16(_x) (((_x) + 15) & ~15) ------------------ 371| 1| { 372| 1| } _ZN14ClassAllocatorI13IOBufferBlockLb0E17FreelistAllocatorEC2EPKcjj: 370| 1| : BaseAllocator(name, static_cast(RND16(sizeof(C))), chunk_size, static_cast(RND16(alignment))) ------------------ | | 49| 1|#define RND16(_x) (((_x) + 15) & ~15) ------------------ : BaseAllocator(name, static_cast(RND16(sizeof(C))), chunk_size, static_cast(RND16(alignment))) ------------------ | | 49| 1|#define RND16(_x) (((_x) + 15) & ~15) ------------------ 371| 1| { 372| 1| } _ZN14ClassAllocatorI10ProxyMutexLb0E17FreelistAllocatorEC2EPKcjj: 370| 1| : BaseAllocator(name, static_cast(RND16(sizeof(C))), chunk_size, static_cast(RND16(alignment))) ------------------ | | 49| 1|#define RND16(_x) (((_x) + 15) & ~15) ------------------ : BaseAllocator(name, static_cast(RND16(sizeof(C))), chunk_size, static_cast(RND16(alignment))) ------------------ | | 49| 1|#define RND16(_x) (((_x) + 15) & ~15) ------------------ 371| 1| { 372| 1| } _ZN14ClassAllocatorI12HTTPCacheAltLb0E17FreelistAllocatorEC2EPKcjj: 370| 1| : BaseAllocator(name, static_cast(RND16(sizeof(C))), chunk_size, static_cast(RND16(alignment))) ------------------ | | 49| 1|#define RND16(_x) (((_x) + 15) & ~15) ------------------ : BaseAllocator(name, static_cast(RND16(sizeof(C))), chunk_size, static_cast(RND16(alignment))) ------------------ | | 49| 1|#define RND16(_x) (((_x) + 15) & ~15) ------------------ 371| 1| { 372| 1| } _ZN14ClassAllocatorI5EventLb0E17FreelistAllocatorEC2EPKcjj: 370| 1| : BaseAllocator(name, static_cast(RND16(sizeof(C))), chunk_size, static_cast(RND16(alignment))) ------------------ | | 49| 1|#define RND16(_x) (((_x) + 15) & ~15) ------------------ : BaseAllocator(name, static_cast(RND16(sizeof(C))), chunk_size, static_cast(RND16(alignment))) ------------------ | | 49| 1|#define RND16(_x) (((_x) + 15) & ~15) ------------------ 371| 1| { 372| 1| } _ZN9ContFlagsC2Ev: 44| 4| ContFlags() {} _ZN9ContFlags9set_flagsEj: 49| 3| { 50| 3| raw_flags = new_flags; 51| 3| } _ZNK9ContFlags9get_flagsEv: 61| 3| { 62| 3| return raw_flags; 63| 3| } _ZN5QueueI5EventNS0_9Link_linkEEC2Ev: 567| 8| Queue() : tail(nullptr) {} _ZN3DLLI5EventNS0_9Link_linkEEC2Ev: 264| 8| DLL() : head(nullptr) {} _ZN4LinkI12ContinuationEC2Ev: 103| 3| Link() : prev(nullptr) {} _ZN5SLinkI12ContinuationEC2Ev: 69| 3| SLink() : next(nullptr){}; _ZN3PtrI10ProxyMutexEC2EPS0_: 207| 3|template inline Ptr::Ptr(T *ptr /* = 0 */) : m_ptr(ptr) 208| 3|{ 209| 3| if (m_ptr) { ------------------ | Branch (209:7): [True: 0, False: 3] ------------------ 210| 0| m_ptr->refcount_inc(); 211| 0| } 212| 3|} _ZN10c_str_viewC2Ev: 650| 162| c_str_view() : c_str_view(nullptr, 0) {} _ZN10c_str_viewC2EPKcm: 652| 162| : c_str_view{ 653| 162| std::string_view{data, length} 654| 162| } 655| 162| { 656| 162| } _ZN10c_str_viewC2ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 657| 162| explicit c_str_view(std::string_view sv) : sv_{sv} 658| 162| { 659| 162| ink_assert(sv_.data() == nullptr ? sv_.length() == 0 : sv_.data()[sv_.length()] == '\0'); ------------------ | | 45| 324|#define ink_assert(EX) (void)(EX) | | ------------------ | | | Branch (45:31): [True: 162, False: 0] | | ------------------ ------------------ 660| 162| } ink_queue.cc:_ZL12ats_pagesizev: 112| 18|{ 113| 18| static size_t page_size; 114| | 115| 18| if (page_size) { ------------------ | Branch (115:7): [True: 17, False: 1] ------------------ 116| 17| return page_size; 117| 17| } 118| | 119| 1|#if defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE) 120| 1| long ret = sysconf(_SC_PAGESIZE); 121| 1| page_size = static_cast((ret > -1) ? ret : 8192); ------------------ | Branch (121:35): [True: 1, False: 0] ------------------ 122| |#elif defined(HAVE_GETPAGESIZE) 123| | page_size = (size_t)getpagesize(); 124| |#else 125| | page_size = static_cast(8192); 126| |#endif 127| | 128| 1| return page_size; 129| 18|} _Z8ink_zeroI12_InkFreeListEvRT_: 213| 9|{ 214| 9| memset(static_cast(&t), 0, sizeof(t)); 215| 9|} _Z8ink_zeroIA4096_P7EThreadEvRT_: 213| 2|{ 214| 2| memset(static_cast(&t), 0, sizeof(t)); 215| 2|} _ZN6DbgCtlC2EPKc: 64| 20| DbgCtl(char const *tag) : _ptr{_new_reference(tag)} {} _ZNK6DbgCtl2onEv: 104| 27| { 105| 27| auto m{_config_mode.load(std::memory_order_relaxed)}; 106| 27| if (!m) { ------------------ | Branch (106:9): [True: 27, False: 0] ------------------ 107| 27| return false; 108| 27| } 109| 0| if (!_ptr->second) { ------------------ | Branch (109:9): [True: 0, False: 0] ------------------ 110| 0| return false; 111| 0| } 112| 0| if (m & 1) { ------------------ | Branch (112:9): [True: 0, False: 0] ------------------ 113| 0| return true; 114| 0| } 115| 0| return (2 == m) && (_override_global_on()); ------------------ | Branch (115:12): [True: 0, False: 0] | Branch (115:24): [True: 0, False: 0] ------------------ 116| 0| } _ZN2ts10UnitParserC2EON4swoc7_1_5_157LexiconImEEb: 91| 1| : _unit_required_p(unit_required_p), _units(std::move(units)) 92| 1|{ 93| 1| _units.set_default(value_type{0}); // Used to check for bad unit names. 94| 1|} _ZN4swoc7_1_5_157IP6AddrC2Emm: 488| 2| : _addr{ 489| 2| {msw, lsw} 490| 2| } {} _ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE4headEv: 1019| 52|IntrusiveDList::head() -> value_type * { 1020| 52| return _head; 1021| 52|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEEC2Ev: 227| 2| IntrusiveDList() = default; _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEE5clearEv: 1031| 1|IntrusiveDList::clear() -> self_type & { 1032| 1| _head = _tail = nullptr; 1033| 1| _count = 0; 1034| 1| return *this; 1035| 1|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_16IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE6Bucket7LinkageEE5clearEv: 1031| 1|IntrusiveDList::clear() -> self_type & { 1032| 1| _head = _tail = nullptr; 1033| 1| _count = 0; 1034| 1| return *this; 1035| 1|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE5clearEv: 1031| 1|IntrusiveDList::clear() -> self_type & { 1032| 1| _head = _tail = nullptr; 1033| 1| _count = 0; 1034| 1| return *this; 1035| 1|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_16IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE6Bucket7LinkageEE5clearEv: 1031| 1|IntrusiveDList::clear() -> self_type & { 1032| 1| _head = _tail = nullptr; 1033| 1| _count = 0; 1034| 1| return *this; 1035| 1|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEEC2EOS6_: 676| 1|IntrusiveDList::IntrusiveDList(self_type &&that) : _head(that._head), _tail(that._tail), _count(that._count) { 677| 1| that.clear(); 678| 1|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_16IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE6Bucket7LinkageEEC2EOSA_: 676| 1|IntrusiveDList::IntrusiveDList(self_type &&that) : _head(that._head), _tail(that._tail), _count(that._count) { 677| 1| that.clear(); 678| 1|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEEC2EOS6_: 676| 1|IntrusiveDList::IntrusiveDList(self_type &&that) : _head(that._head), _tail(that._tail), _count(that._count) { 677| 1| that.clear(); 678| 1|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_16IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE6Bucket7LinkageEEC2EOSA_: 676| 1|IntrusiveDList::IntrusiveDList(self_type &&that) : _head(that._head), _tail(that._tail), _count(that._count) { 677| 1| that.clear(); 678| 1|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEE3endEv: 989| 48|IntrusiveDList::end() -> iterator { 990| 48| return iterator{this, nullptr}; 991| 48|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEE8iteratorC2EPS6_PS4_: 575| 48|template IntrusiveDList::iterator::iterator(list_type *list, value_type *v) : super_type(list, v) {} _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEE14const_iteratorC2EPKS6_PKS4_: 571| 48| : _list(const_cast(list)), _v(const_cast(v)) {} _ZNK4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEE14const_iteratorneERKS7_: 704| 24|IntrusiveDList::const_iterator::operator!=(self_type const &that) const { 705| 24| return this->_v != that._v; 706| 24|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEEC2Ev: 227| 1| IntrusiveDList() = default; _ZN4swoc7_1_5_1514IntrusiveDListINS0_16IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE6Bucket7LinkageEEC2Ev: 227| 1| IntrusiveDList() = default; _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEEC2Ev: 227| 1| IntrusiveDList() = default; _ZN4swoc7_1_5_1514IntrusiveDListINS0_16IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE6Bucket7LinkageEEC2Ev: 227| 1| IntrusiveDList() = default; _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEE6appendEPS4_: 748| 12|IntrusiveDList::append(value_type *v) -> self_type & { 749| 12| L::next_ptr(v) = nullptr; 750| 12| if (nullptr != (L::prev_ptr(v) = _tail)) { ------------------ | Branch (750:7): [True: 11, False: 1] ------------------ 751| 11| L::next_ptr(_tail) = v; 752| 11| } else { 753| 1| _head = v; // transition empty -> non-empty 754| 1| } 755| 12| _tail = v; 756| 12| ++_count; 757| 12| return *this; 758| 12|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_16IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE6Bucket7LinkageEE6appendEPS8_: 748| 7|IntrusiveDList::append(value_type *v) -> self_type & { 749| 7| L::next_ptr(v) = nullptr; 750| 7| if (nullptr != (L::prev_ptr(v) = _tail)) { ------------------ | Branch (750:7): [True: 6, False: 1] ------------------ 751| 6| L::next_ptr(_tail) = v; 752| 6| } else { 753| 1| _head = v; // transition empty -> non-empty 754| 1| } 755| 7| _tail = v; 756| 7| ++_count; 757| 7| return *this; 758| 7|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEE13insert_beforeEPS4_S7_: 819| 17|IntrusiveDList::insert_before(value_type *target, value_type *v) -> self_type & { 820| 17| if (target) { ------------------ | Branch (820:7): [True: 12, False: 5] ------------------ 821| 12| if (nullptr != (L::prev_ptr(v) = L::prev_ptr(target))) { ------------------ | Branch (821:9): [True: 12, False: 0] ------------------ 822| 12| L::next_ptr(L::prev_ptr(v)) = v; 823| 12| } else if (target == _head) { ------------------ | Branch (823:16): [True: 0, False: 0] ------------------ 824| 0| _head = v; 825| 0| } 826| 12| L::next_ptr(v) = target; 827| 12| L::prev_ptr(target) = v; 828| | 829| 12| ++_count; 830| 12| } else { 831| 5| this->append(v); 832| 5| } 833| 17| return *this; 834| 17|} _ZNK4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEE5countEv: 965| 24|IntrusiveDList::count() const { 966| 24| return _count; 967| 24|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE3endEv: 989| 32|IntrusiveDList::end() -> iterator { 990| 32| return iterator{this, nullptr}; 991| 32|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE8iteratorC2EPS6_PS4_: 575| 48|template IntrusiveDList::iterator::iterator(list_type *list, value_type *v) : super_type(list, v) {} _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE14const_iteratorC2EPKS6_PKS4_: 571| 48| : _list(const_cast(list)), _v(const_cast(v)) {} _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE12iterator_forEPS4_: 995| 16|IntrusiveDList::iterator_for(value_type *v) -> iterator { 996| 16| return iterator{this, v}; 997| 16|} _ZNK4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE14const_iteratoreqERKS7_: 698| 24|IntrusiveDList::const_iterator::operator==(self_type const &that) const { 699| 24| return this->_v == that._v; 700| 24|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE6appendEPS4_: 748| 6|IntrusiveDList::append(value_type *v) -> self_type & { 749| 6| L::next_ptr(v) = nullptr; 750| 6| if (nullptr != (L::prev_ptr(v) = _tail)) { ------------------ | Branch (750:7): [True: 5, False: 1] ------------------ 751| 5| L::next_ptr(_tail) = v; 752| 5| } else { 753| 1| _head = v; // transition empty -> non-empty 754| 1| } 755| 6| _tail = v; 756| 6| ++_count; 757| 6| return *this; 758| 6|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_16IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE6Bucket7LinkageEE6appendEPS8_: 748| 5|IntrusiveDList::append(value_type *v) -> self_type & { 749| 5| L::next_ptr(v) = nullptr; 750| 5| if (nullptr != (L::prev_ptr(v) = _tail)) { ------------------ | Branch (750:7): [True: 4, False: 1] ------------------ 751| 4| L::next_ptr(_tail) = v; 752| 4| } else { 753| 1| _head = v; // transition empty -> non-empty 754| 1| } 755| 5| _tail = v; 756| 5| ++_count; 757| 5| return *this; 758| 5|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE13insert_beforeEPS4_S7_: 819| 3|IntrusiveDList::insert_before(value_type *target, value_type *v) -> self_type & { 820| 3| if (target) { ------------------ | Branch (820:7): [True: 2, False: 1] ------------------ 821| 2| if (nullptr != (L::prev_ptr(v) = L::prev_ptr(target))) { ------------------ | Branch (821:9): [True: 2, False: 0] ------------------ 822| 2| L::next_ptr(L::prev_ptr(v)) = v; 823| 2| } else if (target == _head) { ------------------ | Branch (823:16): [True: 0, False: 0] ------------------ 824| 0| _head = v; 825| 0| } 826| 2| L::next_ptr(v) = target; 827| 2| L::prev_ptr(target) = v; 828| | 829| 2| ++_count; 830| 2| } else { 831| 1| this->append(v); 832| 1| } 833| 3| return *this; 834| 3|} _ZNK4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE5countEv: 965| 8|IntrusiveDList::count() const { 966| 8| return _count; 967| 8|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE14const_iteratorC2EPKS5_PKS3_: 571| 191| : _list(const_cast(list)), _v(const_cast(v)) {} _ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE7prependEPS3_: 734| 1|IntrusiveDList::prepend(value_type *v) -> self_type & { 735| 1| L::prev_ptr(v) = nullptr; 736| 1| if (nullptr != (L::next_ptr(v) = _head)) { ------------------ | Branch (736:7): [True: 0, False: 1] ------------------ 737| 0| L::prev_ptr(_head) = v; 738| 1| } else { 739| 1| _tail = v; // transition empty -> non-empty 740| 1| } 741| 1| _head = v; 742| 1| ++_count; 743| 1| return *this; 744| 1|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEEC2EOS5_: 676| 2|IntrusiveDList::IntrusiveDList(self_type &&that) : _head(that._head), _tail(that._tail), _count(that._count) { 677| 2| that.clear(); 678| 2|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE5beginEv: 977| 95|IntrusiveDList::begin() -> iterator { 978| 95| return iterator{this, _head}; 979| 95|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE8iteratorC2EPS5_PS3_: 575| 191|template IntrusiveDList::iterator::iterator(list_type *list, value_type *v) : super_type(list, v) {} _ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE3endEv: 989| 96|IntrusiveDList::end() -> iterator { 990| 96| return iterator{this, nullptr}; 991| 96|} _ZNK4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE14const_iteratorneERKS6_: 704| 95|IntrusiveDList::const_iterator::operator!=(self_type const &that) const { 705| 95| return this->_v != that._v; 706| 95|} _ZNK4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE8iteratorptEv: 649| 47|IntrusiveDList::iterator::operator->() const -> value_type * { 650| 47| return super_type::_v; 651| 47|} _ZNK4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE14const_iteratoreqERKS6_: 698| 48|IntrusiveDList::const_iterator::operator==(self_type const &that) const { 699| 48| return this->_v == that._v; 700| 48|} _ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE5clearEv: 1031| 6|IntrusiveDList::clear() -> self_type & { 1032| 6| _head = _tail = nullptr; 1033| 6| _count = 0; 1034| 6| return *this; 1035| 6|} _ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEEC2EOS6_: 179| 1| IntrusiveHashMap(self_type &&that) = default; _ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEEC2EOS6_: 179| 1| IntrusiveHashMap(self_type &&that) = default; _ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE4findENSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE: 434| 24|IntrusiveHashMap::find(key_type key) -> iterator { 435| 24| Bucket *b = this->bucket_for(key); 436| 24| value_type *v = b->_v; 437| 24| value_type *limit = b->limit(); 438| 70| while (v != limit && !H::equal(key, H::key_of(v))) { ------------------ | Branch (438:10): [True: 46, False: 24] | Branch (438:10): [True: 46, False: 24] | Branch (438:24): [True: 46, False: 0] ------------------ 439| 46| v = H::next_ptr(v); 440| 46| } 441| 24| return v == limit ? _list.end() : _list.iterator_for(v); ------------------ | Branch (441:10): [True: 24, False: 0] ------------------ 442| 24|} _ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE10bucket_forENSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE: 392| 48|IntrusiveHashMap::bucket_for(key_type key) -> Bucket * { 393| 48| return &_table[H::hash_of(key) % _table.size()]; 394| 48|} _ZNK4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE6Bucket5limitEv: 331| 41|IntrusiveHashMap::Bucket::limit() const -> value_type * { 332| 41| Bucket *n{_link._next}; 333| 41| return n ? n->_v : nullptr; ------------------ | Branch (333:10): [True: 24, False: 17] ------------------ 334| 41|}; _ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEEC2Em: 384| 1|template IntrusiveHashMap::IntrusiveHashMap(size_t n) { 385| 1| if (n) { ------------------ | Branch (385:7): [True: 1, False: 0] ------------------ 386| 1| _table.resize(*std::lower_bound(PRIME.begin(), PRIME.end(), n)); 387| 1| } 388| 1|} _ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEEC2Em: 384| 1|template IntrusiveHashMap::IntrusiveHashMap(size_t n) { 385| 1| if (n) { ------------------ | Branch (385:7): [True: 1, False: 0] ------------------ 386| 1| _table.resize(*std::lower_bound(PRIME.begin(), PRIME.end(), n)); 387| 1| } 388| 1|} _ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE3endEv: 410| 24|IntrusiveHashMap::end() -> iterator { 411| 24| return _list.end(); 412| 24|} _ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE6insertEPS4_: 497| 24|IntrusiveHashMap::insert(value_type *v) { 498| 24| auto key = H::key_of(v); 499| 24| Bucket *bucket = this->bucket_for(key); 500| 24| value_type *spot = bucket->_v; 501| 24| bool mixed_p = false; // Found a different key in the bucket. 502| | 503| 24| if (nullptr == spot) { // currently empty bucket, set it and add to active list. ------------------ | Branch (503:7): [True: 7, False: 17] ------------------ 504| 7| _list.append(v); 505| 7| bucket->_v = v; 506| 7| _active_buckets.append(bucket); 507| 17| } else { 508| 17| value_type *limit = bucket->limit(); 509| | 510| | // First search the bucket to see if the key is already in it. 511| 63| while (spot != limit && !H::equal(key, H::key_of(spot))) { ------------------ | Branch (511:12): [True: 46, False: 17] | Branch (511:12): [True: 46, False: 17] | Branch (511:29): [True: 46, False: 0] ------------------ 512| 46| spot = H::next_ptr(spot); 513| 46| } 514| 17| if (spot != bucket->_v) { ------------------ | Branch (514:9): [True: 17, False: 0] ------------------ 515| 17| mixed_p = true; // found some other key, it's going to be mixed. 516| 17| } 517| 17| if (spot != limit) { ------------------ | Branch (517:9): [True: 0, False: 17] ------------------ 518| | // If an equal key was found, walk past those to insert at the upper end of the range. 519| 0| do { 520| 0| spot = H::next_ptr(spot); 521| 0| } while (spot != limit && H::equal(key, H::key_of(spot))); ------------------ | Branch (521:16): [True: 0, False: 0] | Branch (521:16): [True: 0, False: 0] | Branch (521:33): [True: 0, False: 0] ------------------ 522| 0| if (spot != limit) { // something not equal past last equivalent, it's going to be mixed. ------------------ | Branch (522:11): [True: 0, False: 0] ------------------ 523| 0| mixed_p = true; 524| 0| } 525| 0| } 526| | 527| 17| _list.insert_before(spot, v); 528| 17| if (spot == bucket->_v) { // added before the bucket start, update the start. ------------------ | Branch (528:9): [True: 0, False: 17] ------------------ 529| 0| bucket->_v = v; 530| 0| } 531| 17| bucket->_mixed_p = mixed_p; 532| 17| } 533| 24| ++bucket->_count; 534| | 535| | // auto expand if appropriate. 536| 24| if ((AVERAGE == _expansion_policy && (_list.count() / _table.size()) > _expansion_limit) || ------------------ | Branch (536:8): [True: 24, False: 0] | Branch (536:40): [True: 0, False: 24] ------------------ 537| 24| (MAXIMUM == _expansion_policy && bucket->_count > _expansion_limit && bucket->_mixed_p)) { ------------------ | Branch (537:8): [True: 0, False: 24] | Branch (537:40): [True: 0, False: 0] | Branch (537:77): [True: 0, False: 0] ------------------ 538| 0| this->expand(); 539| 0| } 540| 24|} _ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE6Bucket7Linkage8next_ptrEPS7_: 317| 13|IntrusiveHashMap::Bucket::Linkage::next_ptr(Bucket *b) -> Bucket *& { 318| 13| return b->_link._next; 319| 13|} _ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE6Bucket7Linkage8prev_ptrEPS7_: 323| 7|IntrusiveHashMap::Bucket::Linkage::prev_ptr(Bucket *b) -> Bucket *& { 324| 7| return b->_link._prev; 325| 7|} _ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE4findEm: 434| 24|IntrusiveHashMap::find(key_type key) -> iterator { 435| 24| Bucket *b = this->bucket_for(key); 436| 24| value_type *v = b->_v; 437| 24| value_type *limit = b->limit(); 438| 36| while (v != limit && !H::equal(key, H::key_of(v))) { ------------------ | Branch (438:10): [True: 28, False: 8] | Branch (438:24): [True: 12, False: 16] ------------------ 439| 12| v = H::next_ptr(v); 440| 12| } 441| 24| return v == limit ? _list.end() : _list.iterator_for(v); ------------------ | Branch (441:10): [True: 8, False: 16] ------------------ 442| 24|} _ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE10bucket_forEm: 392| 32|IntrusiveHashMap::bucket_for(key_type key) -> Bucket * { 393| 32| return &_table[H::hash_of(key) % _table.size()]; 394| 32|} _ZNK4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE6Bucket5limitEv: 331| 27|IntrusiveHashMap::Bucket::limit() const -> value_type * { 332| 27| Bucket *n{_link._next}; 333| 27| return n ? n->_v : nullptr; ------------------ | Branch (333:10): [True: 8, False: 19] ------------------ 334| 27|}; _ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE3endEv: 410| 24|IntrusiveHashMap::end() -> iterator { 411| 24| return _list.end(); 412| 24|} _ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE6insertEPS4_: 497| 8|IntrusiveHashMap::insert(value_type *v) { 498| 8| auto key = H::key_of(v); 499| 8| Bucket *bucket = this->bucket_for(key); 500| 8| value_type *spot = bucket->_v; 501| 8| bool mixed_p = false; // Found a different key in the bucket. 502| | 503| 8| if (nullptr == spot) { // currently empty bucket, set it and add to active list. ------------------ | Branch (503:7): [True: 5, False: 3] ------------------ 504| 5| _list.append(v); 505| 5| bucket->_v = v; 506| 5| _active_buckets.append(bucket); 507| 5| } else { 508| 3| value_type *limit = bucket->limit(); 509| | 510| | // First search the bucket to see if the key is already in it. 511| 7| while (spot != limit && !H::equal(key, H::key_of(spot))) { ------------------ | Branch (511:12): [True: 4, False: 3] | Branch (511:29): [True: 4, False: 0] ------------------ 512| 4| spot = H::next_ptr(spot); 513| 4| } 514| 3| if (spot != bucket->_v) { ------------------ | Branch (514:9): [True: 3, False: 0] ------------------ 515| 3| mixed_p = true; // found some other key, it's going to be mixed. 516| 3| } 517| 3| if (spot != limit) { ------------------ | Branch (517:9): [True: 0, False: 3] ------------------ 518| | // If an equal key was found, walk past those to insert at the upper end of the range. 519| 0| do { 520| 0| spot = H::next_ptr(spot); 521| 0| } while (spot != limit && H::equal(key, H::key_of(spot))); ------------------ | Branch (521:16): [True: 0, False: 0] | Branch (521:33): [True: 0, False: 0] ------------------ 522| 0| if (spot != limit) { // something not equal past last equivalent, it's going to be mixed. ------------------ | Branch (522:11): [True: 0, False: 0] ------------------ 523| 0| mixed_p = true; 524| 0| } 525| 0| } 526| | 527| 3| _list.insert_before(spot, v); 528| 3| if (spot == bucket->_v) { // added before the bucket start, update the start. ------------------ | Branch (528:9): [True: 0, False: 3] ------------------ 529| 0| bucket->_v = v; 530| 0| } 531| 3| bucket->_mixed_p = mixed_p; 532| 3| } 533| 8| ++bucket->_count; 534| | 535| | // auto expand if appropriate. 536| 8| if ((AVERAGE == _expansion_policy && (_list.count() / _table.size()) > _expansion_limit) || ------------------ | Branch (536:8): [True: 8, False: 0] | Branch (536:40): [True: 0, False: 8] ------------------ 537| 8| (MAXIMUM == _expansion_policy && bucket->_count > _expansion_limit && bucket->_mixed_p)) { ------------------ | Branch (537:8): [True: 0, False: 8] | Branch (537:40): [True: 0, False: 0] | Branch (537:77): [True: 0, False: 0] ------------------ 538| 0| this->expand(); 539| 0| } 540| 8|} _ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE6Bucket7Linkage8next_ptrEPS7_: 317| 9|IntrusiveHashMap::Bucket::Linkage::next_ptr(Bucket *b) -> Bucket *& { 318| 9| return b->_link._next; 319| 9|} _ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE6Bucket7Linkage8prev_ptrEPS7_: 323| 5|IntrusiveHashMap::Bucket::Linkage::prev_ptr(Bucket *b) -> Bucket *& { 324| 5| return b->_link._prev; 325| 5|} _ZN4swoc7_1_5_157LexiconImE11set_defaultERKNSt3__17variantIJNS3_9monostateEmNS0_8TextViewENS3_8functionIFmS6_EEENS7_IFS6_mEEEEEE: 692| 3|Lexicon::set_default(Default const &handler) -> self_type & { 693| 3| switch (handler.index()) { ------------------ | Branch (693:11): [True: 3, False: 0] ------------------ 694| 2| case 0: ------------------ | Branch (694:3): [True: 2, False: 1] ------------------ 695| 2| break; 696| 1| case 1: ------------------ | Branch (696:3): [True: 1, False: 2] ------------------ 697| 1| _value_default = std::get<1>(handler); 698| 1| break; 699| 0| case 3: ------------------ | Branch (699:3): [True: 0, False: 3] ------------------ 700| 0| _value_default = std::get<3>(handler); 701| 0| break; 702| 0| case 2: ------------------ | Branch (702:3): [True: 0, False: 3] ------------------ 703| 0| _name_default = std::get<2>(handler); 704| 0| break; 705| 0| case 4: ------------------ | Branch (705:3): [True: 0, False: 3] ------------------ 706| 0| _name_default = std::get<4>(handler); 707| 0| break; 708| 3| } 709| 3| return *this; 710| 3|} _ZN4swoc7_1_5_157LexiconImEC2EOS2_: 187| 1| Lexicon(self_type &&that) = default; _ZN4swoc7_1_5_157LexiconImE4Item11NameLinkage7hash_ofENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE: 570| 48|Lexicon::Item::NameLinkage::hash_of(std::string_view s) { 571| 48| return Hash32FNV1a().hash_immediate(transform_view_of(&::toupper, s)); 572| 48|} _ZN4swoc7_1_5_157LexiconImE4Item11NameLinkage5equalERKNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEESB_: 582| 92|Lexicon::Item::NameLinkage::equal(std::string_view const &lhs, std::string_view const &rhs) { 583| 92| return 0 == strcasecmp(lhs, rhs); 584| 92|} _ZN4swoc7_1_5_157LexiconImE4Item11NameLinkage6key_ofEPS3_: 558| 116|Lexicon::Item::NameLinkage::key_of(Item *item) { 559| 116| return item->_payload._name; 560| 116|} _ZN4swoc7_1_5_157LexiconImE4Item11NameLinkage8next_ptrEPS3_: 534| 139|Lexicon::Item::NameLinkage::next_ptr(Item *item) -> Item *& { 535| 139| return item->_name_link._next; 536| 139|} _ZN4swoc7_1_5_157LexiconImEC2ERKSt16initializer_listINS2_10DefinitionEENSt3__17variantIJNS8_9monostateEmNS0_8TextViewENS8_8functionIFmSB_EEENSC_IFSB_mEEEEEESH_: 598| 1|template Lexicon::Lexicon(with_multi items, Default handler_1, Default handler_2) { 599| 8| for (auto const &item : items) { ------------------ | Branch (599:25): [True: 8, False: 1] ------------------ 600| 8| this->define(item.value, item.names); 601| 8| } 602| | 603| 2| for (auto &&h : {handler_1, handler_2}) { ------------------ | Branch (603:17): [True: 2, False: 1] ------------------ 604| 2| this->set_default(h); 605| 2| } 606| 1|} _ZN4swoc7_1_5_157LexiconImE6defineEmRKSt16initializer_listINS0_8TextViewEE: 652| 8|Lexicon::define(E value, const std::initializer_list &names) -> self_type & { 653| 8| if (names.size() < 1) { ------------------ | Branch (653:7): [True: 0, False: 8] ------------------ 654| 0| throw std::invalid_argument("A defined value must have at least a primary name"); 655| 0| } 656| 24| for (auto const &name : names) { ------------------ | Branch (656:25): [True: 24, False: 8] ------------------ 657| 24| if (_by_name.find(name) != _by_name.end()) { ------------------ | Branch (657:9): [True: 0, False: 24] ------------------ 658| 0| throw std::invalid_argument(detail::what("Duplicate name '{}' in Lexicon", name)); 659| 0| } 660| 24| auto i = _arena.make(value, this->localize(name)); 661| 24| _by_name.insert(i); 662| | // Only put primary names in the value table. 663| 24| if (_by_value.find(value) == _by_value.end()) { ------------------ | Branch (663:9): [True: 8, False: 16] ------------------ 664| 8| _by_value.insert(i); 665| 8| } 666| 24| } 667| 8| return *this; 668| 8|} _ZN4swoc7_1_5_157LexiconImE4ItemC2EmNS0_8TextViewE: 529| 24|template Lexicon::Item::Item(E value, TextView name) : _payload{value, name} {} _ZN4swoc7_1_5_156detail17lexicon_pair_typeImEC2EmNS0_8TextViewE: 52| 24| lexicon_pair_type(E value, TextView name) : _value(value), _name(name) {} _ZN4swoc7_1_5_157LexiconImE8localizeERKNS0_8TextViewE: 626| 24|Lexicon::localize(TextView const &name) { 627| 24| auto span = _arena.alloc_span(name.size()); 628| 24| memcpy(span, name); 629| 24| return {span.data(), span.size()}; 630| 24|} _ZN4swoc7_1_5_157LexiconImE4Item11NameLinkage8prev_ptrEPS3_: 540| 60|Lexicon::Item::NameLinkage::prev_ptr(Item *item) -> Item *& { 541| 60| return item->_name_link._prev; 542| 60|} _ZN4swoc7_1_5_157LexiconImE4Item12ValueLinkage7hash_ofEm: 576| 32|Lexicon::Item::ValueLinkage::hash_of(E value) { 577| 32| return Lexicon_Hash(value); 578| 32|} _ZN4swoc7_1_5_1512Lexicon_HashImEEmT_: 61| 32|Lexicon_Hash(E e) { 62| 32| static constexpr std::hash hasher; 63| 32| return hasher(e); 64| 32|} _ZN4swoc7_1_5_157LexiconImE4Item12ValueLinkage5equalEmm: 588| 32|Lexicon::Item::ValueLinkage::equal(E lhs, E rhs) { 589| 32| return lhs == rhs; 590| 32|} _ZN4swoc7_1_5_157LexiconImE4Item12ValueLinkage6key_ofEPS3_: 564| 40|Lexicon::Item::ValueLinkage::key_of(Item *item) { 565| 40| return item->_payload._value; 566| 40|} _ZN4swoc7_1_5_157LexiconImE4Item12ValueLinkage8next_ptrEPS3_: 546| 31|Lexicon::Item::ValueLinkage::next_ptr(Item *item) -> Item *& { 547| 31| return item->_value_link._next; 548| 31|} _ZN4swoc7_1_5_157LexiconImE4Item12ValueLinkage8prev_ptrEPS3_: 552| 14|Lexicon::Item::ValueLinkage::prev_ptr(Item *item) -> Item *& { 553| 14| return item->_value_link._prev; 554| 14|} _ZN4swoc7_1_5_158MemArena5Block4dataEv: 605| 96|MemArena::Block::data() { 606| 96| return reinterpret_cast(this + 1); 607| 96|} _ZNK4swoc7_1_5_158MemArena5Block9remainingEv: 631| 191|MemArena::Block::remaining() const { 632| 191| return size - allocated; 633| 191|} _ZN4swoc7_1_5_158MemArena5Block7remnantEv: 654| 48|MemArena::Block::remnant() { 655| 48| return {this->data() + allocated, this->remaining()}; 656| 48|} _ZN4swoc7_1_5_158MemArenaC2Em: 701| 1|inline MemArena::MemArena(size_t n) : _reserve_hint(n) {} _ZN4swoc7_1_5_158MemArena10alloc_spanIcEENS0_7MemSpanIT_EEm: 705| 24|MemArena::alloc_span(size_t n) { 706| 24| return this->alloc(sizeof(T) * n, alignof(T)).rebind(); 707| 24|} _ZN4swoc7_1_5_158MemArena4makeINS0_7LexiconImE4ItemEJRmNS0_8TextViewEEEEPT_DpOT0_: 711| 24|MemArena::make(Args &&...args) { 712| 24| return new (this->alloc(sizeof(T), alignof(T)).data()) T(std::forward(args)...); 713| 24|} _ZN4swoc7_1_5_158MemArena5Block7Linkage8next_ptrEPS2_: 593| 1|MemArena::Block::Linkage::next_ptr(Block *b) -> Block *& { 594| 1| return b->_link._next; 595| 1|} _ZN4swoc7_1_5_158MemArena5Block7Linkage8prev_ptrEPS2_: 598| 1|MemArena::Block::Linkage::prev_ptr(Block *b) -> Block *& { 599| 1| return b->_link._prev; 600| 1|} _ZNK4swoc7_1_5_158MemArena5Block4dataEv: 610| 47|MemArena::Block::data() const { 611| 47| return reinterpret_cast(this + 1); 612| 47|} _ZNK4swoc7_1_5_158MemArena5Block7is_fullEv: 636| 48|MemArena::Block::is_full() const { 637| 48| return this->remaining() < MIN_FREE_SPACE; 638| 48|} _ZN4swoc7_1_5_158MemArena5Block5allocEmm: 641| 48|MemArena::Block::alloc(size_t n, size_t align) { 642| 48| auto base = this->data() + allocated; 643| 48| auto pad = align_padding(base, align); 644| 48| if ((n + pad) > this->remaining()) { ------------------ | Branch (644:7): [True: 0, False: 48] ------------------ 645| 0| throw(std::invalid_argument{"MemArena::Block::alloc size is more than remaining."}); 646| 0| } 647| 48| MemSpan zret = this->remnant().prefix(n + pad); 648| 48| zret.remove_prefix(pad); 649| 48| allocated += n + pad; 650| 48| return zret; 651| 48|} _ZN4swoc7_1_5_158MemArena5BlocknwEmm: 666| 1|{ 667| 1| if (n < block_size) { ------------------ | Branch (667:7): [True: 0, False: 1] ------------------ 668| 0| throw std::invalid_argument("MemArena::Block::operator new size is less than object size."); 669| 0| } 670| | // In theory we could use ::operator new(n) but this causes a size mismatch during ::operator delete. 671| | // Easier to use malloc here and also override @c delete. 672| 1| auto b = static_cast(::malloc(n)); 673| 1| if (b == nullptr) { ------------------ | Branch (673:7): [True: 0, False: 1] ------------------ 674| 0| throw std::bad_alloc(); 675| 0| } 676| 1| return b; 677| 1|} _ZN4swoc7_1_5_158MemArena5BlockdlEPv: 685| 1|MemArena::Block::operator delete(void *ptr) noexcept { 686| 1| ::free(ptr); 687| 1|} _ZN4swoc7_1_5_158MemArena5Block13align_paddingEPKvm: 694| 95|MemArena::Block::align_padding(void const *ptr, size_t align) { 695| 95| if (auto delta = uintptr_t(ptr) & (align - 1); delta > 0) { ------------------ | Branch (695:50): [True: 44, False: 51] ------------------ 696| 44| return align - delta; 697| 44| } 698| 51| return 0; 699| 95|} _ZN4swoc7_1_5_158MemArena5BlockC2Em: 602| 1|inline MemArena::Block::Block(size_t n) noexcept : size(n) {} _ZN4swoc7_1_5_157MemSpanIcEC2EPcm: 1064| 24|template constexpr MemSpan::MemSpan(T *ptr, size_t count) : _ptr{ptr}, _count{count} {} _ZNK4swoc7_1_5_157MemSpanIcE4dataEv: 1154| 48|MemSpan::data() const { 1155| 48| return _ptr; 1156| 48|} _ZNK4swoc7_1_5_157MemSpanIcE4sizeEv: 1178| 24|MemSpan::size() const { 1179| 24| return _count; 1180| 24|} _ZN4swoc7_1_5_156memcpyERNS0_7MemSpanIcEENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE: 1002| 24|memcpy(MemSpan &span, std::string_view view) { 1003| 24| return static_cast(std::memcpy(span.data(), view.data(), std::min(view.size(), view.size()))); 1004| 24|} _ZNK4swoc7_1_5_157MemSpanIvE4dataEv: 1467| 24|MemSpan::data() const { 1468| 24| return _ptr; 1469| 24|} _ZNK4swoc7_1_5_157MemSpanIvE6rebindIcEENS1_IT_EEv: 1658| 24|MemSpan::rebind() const { 1659| 24| return {static_cast(_ptr), detail::is_span_compatible::count(_size)}; 1660| 24|} _ZN4swoc7_1_5_156detail18is_span_compatibleIvcE5countEm: 920| 24|is_span_compatible::count(size_t size) { 921| 24| if (size % sizeof(U)) { ------------------ | Branch (921:7): [True: 0, False: 24] ------------------ 922| 0| throw std::invalid_argument("MemSpan rebind where span size is not a multiple of the element size"); 923| 0| } 924| 24| return size / sizeof(U); 925| 24|} _ZN4swoc7_1_5_157MemSpanIvEC2Ev: 660| 48| constexpr MemSpan() = default; _ZN4swoc7_1_5_157MemSpanIKvEC2Ev: 400| 48| constexpr MemSpan() = default; _ZN4swoc7_1_5_157MemSpanIvEC2EPvm: 1342| 96|inline constexpr MemSpan::MemSpan(value_type *ptr, size_t n) : super_type(ptr, n) {} _ZN4swoc7_1_5_157MemSpanIKvEC2EPS2_m: 1341| 96|inline constexpr MemSpan::MemSpan(value_type *ptr, size_t n) : _ptr{const_cast(ptr)}, _size{n} {} _ZN4swoc7_1_5_156detail7ptr_addEPvm: 880| 48|ptr_add(void *ptr, size_t count) { 881| 48| return static_cast(ptr) + count; 882| 48|} _ZNK4swoc7_1_5_157MemSpanIvE6prefixEm: 1512| 48|MemSpan::prefix(size_t n) const -> self_type { 1513| 48| return {_ptr, std::min(n, _size)}; 1514| 48|} _ZN4swoc7_1_5_157MemSpanIKvE13remove_prefixEm: 1517| 48|MemSpan::remove_prefix(size_t n) -> self_type & { 1518| 48| n = std::min(_size, n); 1519| 48| _size -= n; 1520| 48| _ptr = detail::ptr_add(_ptr, n); 1521| 48| return *this; 1522| 48|} _ZN4swoc7_1_5_157MemSpanIvE13remove_prefixEm: 1525| 48|MemSpan::remove_prefix(size_t n) -> self_type & { 1526| 48| super_type::remove_prefix(n); 1527| 48| return *this; 1528| 48|} _ZN4swoc7_1_5_158round_upImEENS0_6detail22scalar_unit_round_up_tIT_EES4_: 559| 2|round_up(C n) { 560| 2| return {n}; 561| 2|} _ZNK4swoc7_1_5_156detail22scalar_unit_round_up_tImE5scaleILl16EiEET0_v: 106| 1| scale() const { 107| 1| return static_cast(_n / N + (0 != (_n % N))); 108| 1| } _ZNK4swoc7_1_5_156ScalarILl16EiNS0_3tag7genericEEcviEv: 443| 1|template constexpr Scalar::operator Counter() const { 444| 1| return _n * SCALE; 445| 1|} _ZN4swoc7_1_5_156ScalarILl16EiNS0_3tag7genericEEC2ImEENS0_6detail22scalar_unit_round_up_tIT_EE: 425| 1|constexpr Scalar::Scalar(detail::scalar_unit_round_up_t v) : _n(v.template scale()) {} _ZN4swoc7_1_5_156ScalarILl1024EiNS0_3tag7genericEEC2ImEENS0_6detail22scalar_unit_round_up_tIT_EE: 425| 1|constexpr Scalar::Scalar(detail::scalar_unit_round_up_t v) : _n(v.template scale()) {} _ZNK4swoc7_1_5_156detail22scalar_unit_round_up_tImE5scaleILl1024EiEET0_v: 106| 1| scale() const { 107| 1| return static_cast(_n / N + (0 != (_n % N))); 108| 1| } _ZNK4swoc7_1_5_156ScalarILl1024EiNS0_3tag7genericEEcviEv: 443| 1|template constexpr Scalar::operator Counter() const { 444| 1| return _n * SCALE; 445| 1|} _ZN4swoc7_1_5_158TextViewC2EPKcm: 1127| 24| : super_type(ptr, n == npos ? (ptr ? ::strlen(ptr) : 0) : n) {} ------------------ | Branch (1127:21): [True: 0, False: 24] | Branch (1127:34): [True: 0, False: 0] ------------------ _ZNK4swoc7_1_5_1513TransformViewIPDoFiiENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEcvbEv: 1907| 276|template TransformView::operator bool() const { 1908| 276| return _spot != _limit; 1909| 276|} _ZNK4swoc7_1_5_1513TransformViewIPDoFiiENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEdeEv: 1882| 228|TransformView::operator*() const -> value_type { 1883| 228| return _xf(*_spot); 1884| 228|} _ZN4swoc7_1_5_1513TransformViewIPDoFiiENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEppEv: 1888| 228|TransformView::operator++() -> self_type & { 1889| 228| ++_spot; 1890| 228| return *this; 1891| 228|} _ZN4swoc7_1_5_1517transform_view_ofIPDoFiiENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEENS0_13TransformViewIT_T0_EERKSA_RKSB_: 1933| 48|transform_view_of(X const &xf, V const &src) { 1934| 48| return TransformView(xf, src); 1935| 48|} _ZN4swoc7_1_5_1513TransformViewIPDoFiiENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEC2ERKS3_RKS8_: 1878| 48| : _xf(xf), _spot(v.begin()), _limit(v.end()) {} _ZN4swoc7_1_5_1511Hash32FNV1aC2Ev: 41| 48| Hash32FNV1a() = default; _ZN4swoc7_1_5_1511Hash32FNV1a14hash_immediateIPDoFiiENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEjRKNS0_13TransformViewIT_T0_EE: 203| 48|Hash32FNV1a::hash_immediate(swoc::TransformView const &view) -> value_type { 204| 48| return this->update(view).get(); 205| 48|} _ZN4swoc7_1_5_1511Hash32FNV1a6updateIPDoFiiENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEERS1_NS0_13TransformViewIT_T0_EE: 178| 48|Hash32FNV1a::update(TransformView view) -> self_type & { 179| 276| for (; view; ++view) { ------------------ | Branch (179:10): [True: 228, False: 48] ------------------ 180| 228| hval ^= static_cast(*view); 181| 228| hval += (hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24); 182| 228| } 183| 48| return *this; 184| 48|} _ZNK4swoc7_1_5_1511Hash32FNV1a3getEv: 197| 48|Hash32FNV1a::get() const -> value_type { 198| 48| return hval; 199| 48|} _ZN4swoc7_1_5_158MemArenaC2EOS1_: 38| 1| : _active_allocated(that._active_allocated), 39| 1| _active_reserved(that._active_reserved), 40| 1| _frozen_allocated(that._frozen_allocated), 41| 1| _frozen_reserved(that._frozen_reserved), 42| 1| _reserve_hint(that._reserve_hint), 43| 1| _frozen(std::move(that._frozen)), 44| 1| _active(std::move(that._active)), 45| 1| _static_block(that._static_block) { 46| | // Clear data in @a that to indicate all of the memory has been moved. 47| 1| that._active_allocated = that._active_reserved = 0; 48| 1| that._frozen_allocated = that._frozen_reserved = 0; 49| 1| that._reserve_hint = 0; 50| 1| that._static_block = nullptr; 51| 1|} _ZN4swoc7_1_5_158MemArena10make_blockEm: 73| 1|MemArena::make_block(size_t n) { 74| | // If there's no reservation hint, use the extent. This is transient because the hint is cleared. 75| 1| if (_reserve_hint == 0) { ------------------ | Branch (75:7): [True: 0, False: 1] ------------------ 76| 0| if (_active_reserved) { ------------------ | Branch (76:9): [True: 0, False: 0] ------------------ 77| 0| _reserve_hint = _active_reserved; 78| 0| } else if (_frozen_allocated) { // immediately after freezing - use that extent. ------------------ | Branch (78:16): [True: 0, False: 0] ------------------ 79| 0| _reserve_hint = _frozen_allocated; 80| 0| } 81| 0| } 82| 1| n = std::max(n, _reserve_hint); 83| 1| _reserve_hint = 0; // did this, clear for next time. 84| | // Add in overhead and round up to paragraph units. 85| 1| n = Paragraph{round_up(n + ALLOC_HEADER_SIZE + sizeof(Block))}; 86| | // If more than a page or withing a quarter page of a full page, 87| | // round up to page unit size and clip back to account for alloc header. 88| 1| if (n >= (Page::SCALE - QuarterPage::SCALE)) { ------------------ | Branch (88:7): [True: 0, False: 1] ------------------ 89| 0| n = Page{round_up(n)} - ALLOC_HEADER_SIZE; 90| 1| } else if (n >= QuarterPage::SCALE) { // if at least a quarter page, round up to quarter pages. ------------------ | Branch (90:14): [True: 1, False: 0] ------------------ 91| 1| n = QuarterPage{round_up(n)}; 92| 1| } 93| | 94| | // Allocate space for the Block instance and the requested memory and construct a Block at the front. 95| 1| auto free_space = n - sizeof(Block); 96| 1| _active_reserved += free_space; 97| 1| return new (n) Block(free_space); 98| 1|} _ZN4swoc7_1_5_158MemArena5allocEmm: 101| 48|MemArena::alloc(size_t n, size_t align) { 102| 48| MemSpan zret; 103| 48| this->require(n, align); 104| 48| auto block = _active.head(); 105| 48| zret = block->alloc(n, align); 106| 48| _active_allocated += n; 107| | // If this block is now full, move it to the back. 108| 48| if (block->is_full() && block != _active.tail()) { ------------------ | Branch (108:7): [True: 0, False: 48] | Branch (108:27): [True: 0, False: 0] ------------------ 109| 0| _active.erase(block); 110| 0| _active.append(block); 111| 0| } 112| 48| return zret; 113| 48|} _ZN4swoc7_1_5_158MemArena7requireEmm: 150| 48|MemArena::require(size_t n, size_t align) { 151| 48| auto spot = _active.begin(); 152| 48| Block *block{nullptr}; 153| | 154| | // Search back through the list until a full block is hit, which is a miss. 155| 48| while (spot != _active.end() && !spot->satisfies(n, align)) { ------------------ | Branch (155:10): [True: 47, False: 1] | Branch (155:10): [True: 0, False: 48] | Branch (155:35): [True: 0, False: 47] ------------------ 156| 0| if (spot->is_full()) { ------------------ | Branch (156:9): [True: 0, False: 0] ------------------ 157| 0| spot = _active.end(); 158| 0| } else { 159| 0| ++spot; 160| 0| } 161| 0| } 162| 48| if (spot == _active.end()) { // no block has enough free space ------------------ | Branch (162:7): [True: 1, False: 47] ------------------ 163| 1| block = this->make_block(n); // assuming a new block is sufficiently aligned. 164| 1| _active.prepend(block); 165| 47| } else if (spot != _active.begin()) { ------------------ | Branch (165:14): [True: 0, False: 47] ------------------ 166| | // big enough space, move to the head of the list. 167| 0| block = spot; 168| 0| _active.erase(block); 169| 0| _active.prepend(block); 170| 0| } 171| | // Invariant - the head active block has at least @a n bytes of free storage. 172| 48| return *this; 173| 48|} _ZN4swoc7_1_5_158MemArenaD2Ev: 254| 2|MemArena::~MemArena() { 255| | // Destruct in a way that makes it safe for the instance to be in one of its own memory blocks. 256| | // This means copying members that will be used during the delete. 257| 2| Block *ba = _active.head(); 258| 2| Block *bf = _frozen.head(); 259| 2| Block *sb = _static_block; 260| | 261| 2| _active.clear(); 262| 2| _frozen.clear(); 263| 2| while (bf) { ------------------ | Branch (263:10): [True: 0, False: 2] ------------------ 264| 0| Block *b = bf; 265| 0| bf = bf->_link._next; 266| 0| if (b != sb) { ------------------ | Branch (266:9): [True: 0, False: 0] ------------------ 267| 0| delete b; 268| 0| } 269| 0| } 270| 3| while (ba) { ------------------ | Branch (270:10): [True: 1, False: 2] ------------------ 271| 1| Block *b = ba; 272| 1| ba = ba->_link._next; 273| 1| if (b != sb) { ------------------ | Branch (273:9): [True: 1, False: 0] ------------------ 274| 1| delete b; 275| 1| } 276| 1| } 277| 2|} _ZNK4swoc7_1_5_158MemArena5Block9satisfiesEmm: 16| 47|MemArena::Block::satisfies(size_t n, size_t align) const { 17| 47| auto r = this->remaining(); 18| 47| return r >= (n + align_padding(this->data() + allocated, align)); 19| 47|} _Z10strcasecmpRKNSt3__117basic_string_viewIcNS_11char_traitsIcEEEES5_: 30| 92|strcasecmp(const std::string_view &lhs, const std::string_view &rhs) { 31| 92| int zret = 0; 32| 92| size_t n = rhs.size(); 33| | 34| | // Seems a bit ugly but size comparisons must be done anyway to get the @c strncasecmp args. 35| 92| if (lhs.size() < rhs.size()) { ------------------ | Branch (35:7): [True: 46, False: 46] ------------------ 36| 46| zret = 1; 37| 46| n = lhs.size(); 38| 46| } else if (lhs.size() > rhs.size()) { ------------------ | Branch (38:14): [True: 36, False: 10] ------------------ 39| 36| zret = -1; 40| 36| } else if (lhs.data() == rhs.data()) { // the same memory, obviously equal. ------------------ | Branch (40:14): [True: 0, False: 10] ------------------ 41| 0| return 0; 42| 0| } 43| | 44| 92| int r = ::strncasecmp(lhs.data(), rhs.data(), n); 45| | 46| 92| return r ? r : zret; ------------------ | Branch (46:10): [True: 84, False: 8] ------------------ 47| 92|} _ZN9ProcessorC2Ev: 54| 2|Processor::Processor() {} /* End Processor::Processor() */ _ZN14EventProcessorC2Ev: 366| 1|EventProcessor::EventProcessor() : thread_initializer(this) 367| 1|{ 368| 1| ink_zero(all_ethreads); 369| 1| ink_zero(all_dthreads); 370| 1| ink_mutex_init(&dedicated_thread_spawn_mutex); 371| | // Because ET_NET is compile time set to 0 it *must* be the first type registered. 372| 1| this->register_event_type("ET_NET"); 373| 1|} _ZN14EventProcessor19register_event_typeEPKc: 416| 1|{ 417| 1| ThreadGroupDescriptor *tg = &(thread_group[n_thread_groups++]); 418| 1| ink_release_assert(n_thread_groups <= MAX_EVENT_TYPES); // check for overflow ------------------ | | 48| 1|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__))) | | ------------------ | | | Branch (48:40): [True: 1, False: 0] | | ------------------ ------------------ 419| | 420| 1| tg->_name = name; 421| 1| return n_thread_groups - 1; 422| 1|} _ZN25ThreadAffinityInitializerC2Ev: 59| 1| ThreadAffinityInitializer() { SET_HANDLER(&self::set_affinity); } ------------------ | | 253| 1|#define SET_HANDLER(_h) (handler = continuation_handler_void_ptr(_h)) ------------------ UnixEventProcessor.cc:_ZN12_GLOBAL__N_116ThreadInitByFuncC2Ev: 160| 1| ThreadInitByFunc() { SET_HANDLER(&ThreadInitByFunc::invoke); } ------------------ | | 253| 1|#define SET_HANDLER(_h) (handler = continuation_handler_void_ptr(_h)) ------------------ _Z14get_cont_flagsv: 42| 3|{ 43| 3| return local_flags; 44| 3|} _ZN12je_mi_malloc25globalJeMiNodumpAllocatorEv: 173| 1|{ 174| 1| static auto instance = new JeMiNodumpAllocator(); 175| 1| return *instance; 176| 1|} _Z20ats_hugepage_enabledv: 61| 9|{ 62| 9|#ifdef MAP_HUGETLB 63| 9| return hugepage_enabled; 64| |#else 65| | return false; 66| |#endif 67| 9|} _Z10ats_mallocm: 52| 12|{ 53| 12| void *ptr = nullptr; 54| | 55| | /* 56| | * There's some nasty code in libts that expects 57| | * a MALLOC of a zero-sized item to work properly. Rather 58| | * than allocate any space, we simply return a nullptr to make 59| | * certain they die quickly & don't trash things. 60| | */ 61| | 62| | // Useful for tracing bad mallocs 63| | // ink_stack_trace_dump(); 64| 12| if (likely(size > 0)) { ------------------ | | 28| 12|#define likely(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (28:19): [True: 12, False: 0] | | ------------------ ------------------ 65| 12| if (unlikely((ptr = malloc(size)) == nullptr)) { ------------------ | | 31| 12|#define unlikely(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (31:21): [True: 0, False: 12] | | ------------------ ------------------ 66| 0| ink_abort("couldn't allocate %zu bytes", size); 67| 0| } 68| 12| } 69| 12| return ptr; 70| 12|} /* End ats_malloc */ _Z12ats_memalignmm: 96| 9|{ 97| 9| void *ptr; 98| | 99| 9| if (alignment <= 8) { ------------------ | Branch (99:7): [True: 3, False: 6] ------------------ 100| 3| return ats_malloc(size); 101| 3| } 102| | 103| |#if defined(openbsd) 104| | if (alignment > PAGE_SIZE) 105| | alignment = PAGE_SIZE; 106| |#endif 107| | 108| 6| int retcode = posix_memalign(&ptr, alignment, size); 109| | 110| 6| if (unlikely(retcode)) { ------------------ | | 31| 6|#define unlikely(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (31:21): [True: 0, False: 6] | | ------------------ ------------------ 111| 0| if (retcode == EINVAL) { ------------------ | Branch (111:9): [True: 0, False: 0] ------------------ 112| 0| ink_abort("couldn't allocate %zu bytes at alignment %zu - invalid alignment parameter", size, alignment); 113| 0| } else if (retcode == ENOMEM) { ------------------ | Branch (113:16): [True: 0, False: 0] ------------------ 114| 0| ink_abort("couldn't allocate %zu bytes at alignment %zu - insufficient memory", size, alignment); 115| 0| } else { 116| 0| ink_abort("couldn't allocate %zu bytes at alignment %zu - unknown error %d", size, alignment, retcode); 117| 0| } 118| 0| } 119| | 120| 6| return ptr; 121| 6|} /* End ats_memalign */ _Z14ink_mutex_initP15pthread_mutex_t: 50| 1|{ 51| 1| int error; 52| 1| static x_pthread_mutexattr_t attr; 53| | 54| 1| error = pthread_mutex_init(m, &attr.attr); 55| 1| if (unlikely(error != 0)) { ------------------ | | 31| 1|#define unlikely(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (31:21): [True: 0, False: 1] | | ------------------ ------------------ 56| 0| ink_abort("pthread_mutex_init(%p) failed: %s (%d)", m, strerror(error), error); 57| 0| } 58| 1|} _ZN21x_pthread_mutexattr_tC2Ev: 36| 1| { 37| 1| pthread_mutexattr_init(&attr); 38| |#if DEBUG 39| | pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK); 40| |#endif 41| 1| } _Z17ink_freelist_initPP12_InkFreeListPKcjjjb: 139| 9|{ 140| 9| InkFreeList *f; 141| 9| ink_freelist_list *fll; 142| | 143| | /* its safe to add to this global list because ink_freelist_init() 144| | is only called from single-threaded initialization code. */ 145| 9| f = static_cast(ats_memalign(alignment, sizeof(InkFreeList))); 146| 9| ink_zero(*f); 147| | 148| 9| fll = static_cast(ats_malloc(sizeof(ink_freelist_list))); 149| 9| fll->fl = f; 150| 9| fll->next = freelists; 151| 9| freelists = fll; 152| | 153| 9| f->name = name; 154| | /* quick test for power of 2 */ 155| 9| ink_assert(!(alignment & (alignment - 1))); ------------------ | | 45| 9|#define ink_assert(EX) (void)(EX) ------------------ 156| | // It is never useful to have alignment requirement looser than a page size 157| | // so clip it. This makes the item alignment checks in the actual allocator simpler. 158| 9| f->alignment = alignment; 159| 9| f->use_hugepages = ats_hugepage_enabled() && use_hugepages; ------------------ | Branch (159:26): [True: 0, False: 9] | Branch (159:52): [True: 0, False: 0] ------------------ 160| 9| f->hugepages_failure = 0; 161| 9| if (f->use_hugepages) { ------------------ | Branch (161:7): [True: 0, False: 9] ------------------ 162| | // for hugepages, always make the allocation alignment on a hugepage boundary 163| 0| f->alignment = ats_hugepage_size(); 164| 0| f->type_size = type_size; 165| 9| } else { 166| 9| if (f->alignment > ats_pagesize()) { ------------------ | Branch (166:9): [True: 0, False: 9] ------------------ 167| 0| f->alignment = ats_pagesize(); 168| 0| } 169| | // Make sure we align *all* the objects in the allocation, not just the first one 170| 9| f->type_size = INK_ALIGN(type_size, f->alignment); ------------------ | | 50| 9|#define INK_ALIGN(size, boundary) (((size) + ((boundary) - 1)) & ~((boundary) - 1)) ------------------ 171| 9| } 172| 9| Dbg(dbg_ctl_freelist_init, "<%s> Alignment request/actual (%" PRIu32 "/%" PRIu32 ")", name, alignment, f->alignment); ------------------ | | 173| 9| do { \ | | 174| 9| if ((CTL).on()) { \ | | ------------------ | | | Branch (174:9): [True: 0, False: 9] | | ------------------ | | 175| 0| DbgPrint((CTL), __VA_ARGS__); \ | | ------------------ | | | | 170| 0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__)) | | ------------------ | | 176| 0| } \ | | 177| 9| } while (false) | | ------------------ | | | Branch (177:12): [Folded, False: 9] | | ------------------ ------------------ 173| 9| Dbg(dbg_ctl_freelist_init, "<%s> Type Size request/actual (%" PRIu32 "/%" PRIu32 ")", name, type_size, f->type_size); ------------------ | | 173| 9| do { \ | | 174| 9| if ((CTL).on()) { \ | | ------------------ | | | Branch (174:9): [True: 0, False: 9] | | ------------------ | | 175| 0| DbgPrint((CTL), __VA_ARGS__); \ | | ------------------ | | | | 170| 0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__)) | | ------------------ | | 176| 0| } \ | | 177| 9| } while (false) | | ------------------ | | | Branch (177:12): [Folded, False: 9] | | ------------------ ------------------ 174| 9| ink_assert(f->type_size != 0); ------------------ | | 45| 9|#define ink_assert(EX) (void)(EX) ------------------ 175| 9| if (f->use_hugepages) { ------------------ | Branch (175:7): [True: 0, False: 9] ------------------ 176| 0| f->chunk_size = INK_ALIGN(chunk_size * f->type_size, ats_hugepage_size()) / f->type_size; ------------------ | | 50| 0|#define INK_ALIGN(size, boundary) (((size) + ((boundary) - 1)) & ~((boundary) - 1)) ------------------ 177| 9| } else { 178| 9| f->chunk_size = INK_ALIGN(chunk_size * f->type_size, ats_pagesize()) / f->type_size; ------------------ | | 50| 9|#define INK_ALIGN(size, boundary) (((size) + ((boundary) - 1)) & ~((boundary) - 1)) ------------------ 179| 9| } 180| 9| Dbg(dbg_ctl_freelist_init, "<%s> Chunk Size request/actual (%" PRIu32 "/%" PRIu32 ")", name, chunk_size, f->chunk_size); ------------------ | | 173| 9| do { \ | | 174| 9| if ((CTL).on()) { \ | | ------------------ | | | Branch (174:9): [True: 0, False: 9] | | ------------------ | | 175| 0| DbgPrint((CTL), __VA_ARGS__); \ | | ------------------ | | | | 170| 0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__)) | | ------------------ | | 176| 0| } \ | | 177| 9| } while (false) | | ------------------ | | | Branch (177:12): [Folded, False: 9] | | ------------------ ------------------ 181| 9| SET_FREELIST_POINTER_VERSION(f->head, FROM_PTR(0), 0); ------------------ | | 131| 9| (_x).s.pointer = _p; \ | | 132| 9| (_x).s.version = _v ------------------ 182| | 183| 9| *fl = f; 184| 9|} _ZN6DbgCtl14_new_referenceEPKc: 125| 20|{ 126| 20| DebugInterface *p = DebugInterface::get_instance(); 127| 20| debug_assert(tag != nullptr); ------------------ | | 45| 20|#define debug_assert(EX) (void)(EX) ------------------ 128| | 129| 20| _TagData *new_tag_data{nullptr}; 130| | 131| 20| { 132| 20| _RegistryAccessor ra; 133| | 134| 20| auto &d{ra.data()}; 135| | 136| 20| if (auto it = d.map.find(tag); it != d.map.end()) { ------------------ | Branch (136:36): [True: 4, False: 16] ------------------ 137| 4| return &*it; 138| 4| } 139| | 140| 16| auto sz = std::strlen(tag); 141| | 142| 16| debug_assert(sz > 0); ------------------ | | 45| 16|#define debug_assert(EX) (void)(EX) ------------------ 143| | 144| 16| char *t = new char[sz + 1]; // Never deleted (leaky singleton) - reclaimed by OS at process exit. 145| 16| std::memcpy(t, tag, sz + 1); 146| 16| _TagData new_elem{t, false}; 147| | 148| 16| auto res = d.map.insert(new_elem); 149| | 150| 16| debug_assert(res.second); ------------------ | | 45| 16|#define debug_assert(EX) (void)(EX) ------------------ 151| | 152| 16| new_tag_data = &*res.first; 153| 16| } 154| 16| new_tag_data->second = p && p->debug_tag_activated(tag); ------------------ | Branch (154:26): [True: 0, False: 16] | Branch (154:31): [True: 0, False: 0] ------------------ 155| | 156| | // It is important that debug_tag_activated() is NOT called while the ra object exists, and the registry mutex is 157| | // locked. There is a mutex in the C/C++ runtime that both dlopen() and _cxa_thread_atexit() lock while running. 158| | // Creating a _RegistryAccessor instance locks the registry mutex. If the subsequent code in this function triggers 159| | // the construction of a thread_local variable (with a non-trivial destructor), with the registry mutex locked, the 160| | // following deadlock scenario is possible: 161| | // 1. Thread 1 calls a DbgCtl constructor, which locks the registry mutex, but then is suspended. 162| | // 2. Thread 2 calls dlopen() for a plugin, locking the runtime mutex. It then executes the constructor for a 163| | // statically allocated DbgCtl object, which blocks on locking the registry mutex. 164| | // 3. Thread 1 resumes, and calls a function that causes the the construction of a thread_local variable with a 165| | // non-trivial destructor. This causes a call to _cxa_thread_atexit(), to set up a call of the variable's 166| | // destructor at thread exit. The call to _cxa_thread_atexit() will block on the runtime mutex (held by Thread 2). 167| | // So Thread 1 holds the registry mutex and is blocked waiting for the runtime mutex. And Thread 2 holds the 168| | // runtime mutex and is blocked waiting for the registry mutex. Deadlock. 169| | 170| 16| return new_tag_data; 171| 20|} _ZN14DebugInterface12get_instanceEv: 259| 20|{ 260| 20| return di_inst; 261| 20|} _ZN6DbgCtl17_RegistryAccessorC2Ev: 88| 20| { 89| 20| if (!_registry_instance) { ------------------ | Branch (89:9): [True: 1, False: 19] ------------------ 90| 1| Registry *expected{nullptr}; 91| 1| Registry *r{new Registry}; 92| 1| if (!_registry_instance.compare_exchange_strong(expected, r)) { ------------------ | Branch (92:11): [True: 0, False: 1] ------------------ 93| 0| r->_mtx.lock(); 94| 0| delete r; 95| 0| } 96| 1| } 97| 20| _registry_instance.load()->_mtx.lock(); 98| 20| _mtx_is_locked = true; 99| 20| } _ZN6DbgCtl17_RegistryAccessor8RegistryC2Ev: 77| 1| Registry() = default; _ZN6DbgCtl17_RegistryAccessor4dataEv: 113| 20| { 114| 20| return *_registry_instance; 115| 20| } _ZN6DbgCtl17_RegistryAccessorD2Ev: 102| 20| { 103| 20| if (_mtx_is_locked) { ------------------ | Branch (103:9): [True: 20, False: 0] ------------------ 104| 20| _registry_instance.load()->_mtx.unlock(); 105| 20| } 106| 20| } _ZNK6DbgCtl17_RegistryAccessor6TagCmpclEPKcS3_: 63| 143| { 64| 143| return std::strcmp(a, b) < 0; 65| 143| }