LLVMFuzzerTestOneInput: 24| 300|{ 25| 300| constexpr auto var_count = 8; 26| 300| constexpr auto bits = 3; 27| | 28| 300| using vector_t = immer::flex_vector; 29| 300| using size_t = std::uint8_t; 30| | 31| 300| auto vars = std::array{}; 32| | 33| 300| auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; }; 34| 300| auto is_valid_var_neq = [](auto other) { 35| 300| return [=](auto idx) { 36| 300| return idx >= 0 && idx < var_count && idx != other; 37| 300| }; 38| 300| }; 39| 300| auto is_valid_index = [](auto& v) { 40| 300| return [&](auto idx) { return idx >= 0 && idx < v.size(); }; 41| 300| }; 42| 300| auto is_valid_size = [](auto& v) { 43| 300| return [&](auto idx) { return idx >= 0 && idx <= v.size(); }; 44| 300| }; 45| 300| auto can_concat = [](auto&& v1, auto&& v2) { 46| 300| return v1.size() + v2.size() < vector_t::max_size(); 47| 300| }; 48| 300| auto can_compare = [](auto&& v) { 49| | // avoid comparing vectors that are too big, and hence, slow to compare 50| 300| return v.size() < (1 << 15); 51| 300| }; 52| 300| return fuzzer_input{data, size}.run([&](auto& in) { 53| 300| enum ops 54| 300| { 55| 300| op_push_back, 56| 300| op_update, 57| 300| op_take, 58| 300| op_drop, 59| 300| op_concat, 60| 300| op_push_back_move, 61| 300| op_update_move, 62| 300| op_take_move, 63| 300| op_drop_move, 64| 300| op_concat_move_l, 65| 300| op_concat_move_r, 66| 300| op_concat_move_lr, 67| 300| op_insert, 68| 300| op_erase, 69| 300| op_compare, 70| 300| }; 71| 300| auto src = read(in, is_valid_var); 72| 300| auto dst = read(in, is_valid_var); 73| 300| switch (read(in)) { 74| 300| case op_push_back: { 75| 300| vars[dst] = vars[src].push_back(42); 76| 300| break; 77| 300| } 78| 300| case op_update: { 79| 300| auto idx = read(in, is_valid_index(vars[src])); 80| 300| vars[dst] = vars[src].update(idx, [](auto x) { return x + 1; }); 81| 300| break; 82| 300| } 83| 300| case op_take: { 84| 300| auto idx = read(in, is_valid_size(vars[src])); 85| 300| vars[dst] = vars[src].take(idx); 86| 300| break; 87| 300| } 88| 300| case op_drop: { 89| 300| auto idx = read(in, is_valid_size(vars[src])); 90| 300| vars[dst] = vars[src].drop(idx); 91| 300| break; 92| 300| } 93| 300| case op_concat: { 94| 300| auto src2 = read(in, is_valid_var); 95| 300| if (can_concat(vars[src], vars[src2])) 96| 300| vars[dst] = vars[src] + vars[src2]; 97| 300| break; 98| 300| } 99| 300| case op_push_back_move: { 100| 300| vars[dst] = std::move(vars[src]).push_back(21); 101| 300| break; 102| 300| } 103| 300| case op_update_move: { 104| 300| auto idx = read(in, is_valid_index(vars[src])); 105| 300| vars[dst] = 106| 300| std::move(vars[src]).update(idx, [](auto x) { return x + 1; }); 107| 300| break; 108| 300| } 109| 300| case op_take_move: { 110| 300| auto idx = read(in, is_valid_size(vars[src])); 111| 300| vars[dst] = std::move(vars[src]).take(idx); 112| 300| break; 113| 300| } 114| 300| case op_drop_move: { 115| 300| auto idx = read(in, is_valid_size(vars[src])); 116| 300| vars[dst] = std::move(vars[src]).drop(idx); 117| 300| break; 118| 300| } 119| 300| case op_concat_move_l: { 120| 300| auto src2 = read(in, is_valid_var_neq(src)); 121| 300| if (can_concat(vars[src], vars[src2])) 122| 300| vars[dst] = std::move(vars[src]) + vars[src2]; 123| 300| break; 124| 300| } 125| 300| case op_concat_move_r: { 126| 300| auto src2 = read(in, is_valid_var_neq(src)); 127| 300| if (can_concat(vars[src], vars[src2])) 128| 300| vars[dst] = vars[src] + std::move(vars[src2]); 129| 300| break; 130| 300| } 131| 300| case op_concat_move_lr: { 132| 300| auto src2 = read(in, is_valid_var_neq(src)); 133| 300| if (can_concat(vars[src], vars[src2])) 134| 300| vars[dst] = std::move(vars[src]) + std::move(vars[src2]); 135| 300| break; 136| 300| } 137| 300| case op_compare: { 138| 300| using std::swap; 139| 300| if (can_compare(vars[src]) && vars[src] == vars[dst]) 140| 300| swap(vars[src], vars[dst]); 141| 300| break; 142| 300| } 143| 300| case op_erase: { 144| 300| auto idx = read(in, is_valid_index(vars[src])); 145| 300| vars[dst] = vars[src].erase(idx); 146| 300| break; 147| 300| } 148| 300| case op_insert: { 149| 300| auto idx = read(in, is_valid_size(vars[src])); 150| 300| vars[dst] = vars[src].insert(idx, immer::box{42}); 151| 300| break; 152| 300| } 153| 300| default: 154| 300| break; 155| 300| }; 156| 300| return true; 157| 300| }); 158| 300|} flex-vector-st.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_: 52| 1.67M| return fuzzer_input{data, size}.run([&](auto& in) { 53| 1.67M| enum ops 54| 1.67M| { 55| 1.67M| op_push_back, 56| 1.67M| op_update, 57| 1.67M| op_take, 58| 1.67M| op_drop, 59| 1.67M| op_concat, 60| 1.67M| op_push_back_move, 61| 1.67M| op_update_move, 62| 1.67M| op_take_move, 63| 1.67M| op_drop_move, 64| 1.67M| op_concat_move_l, 65| 1.67M| op_concat_move_r, 66| 1.67M| op_concat_move_lr, 67| 1.67M| op_insert, 68| 1.67M| op_erase, 69| 1.67M| op_compare, 70| 1.67M| }; 71| 1.67M| auto src = read(in, is_valid_var); 72| 1.67M| auto dst = read(in, is_valid_var); 73| 1.67M| switch (read(in)) { 74| 153k| case op_push_back: { ------------------ | Branch (74:9): [True: 153k, False: 1.51M] ------------------ 75| 153k| vars[dst] = vars[src].push_back(42); 76| 153k| break; 77| 0| } 78| 330k| case op_update: { ------------------ | Branch (78:9): [True: 330k, False: 1.34M] ------------------ 79| 330k| auto idx = read(in, is_valid_index(vars[src])); 80| 330k| vars[dst] = vars[src].update(idx, [](auto x) { return x + 1; }); 81| 330k| break; 82| 0| } 83| 561| case op_take: { ------------------ | Branch (83:9): [True: 561, False: 1.67M] ------------------ 84| 561| auto idx = read(in, is_valid_size(vars[src])); 85| 561| vars[dst] = vars[src].take(idx); 86| 561| break; 87| 0| } 88| 254| case op_drop: { ------------------ | Branch (88:9): [True: 254, False: 1.67M] ------------------ 89| 254| auto idx = read(in, is_valid_size(vars[src])); 90| 254| vars[dst] = vars[src].drop(idx); 91| 254| break; 92| 0| } 93| 490k| case op_concat: { ------------------ | Branch (93:9): [True: 490k, False: 1.18M] ------------------ 94| 490k| auto src2 = read(in, is_valid_var); 95| 490k| if (can_concat(vars[src], vars[src2])) ------------------ | Branch (95:17): [True: 475k, False: 14.5k] ------------------ 96| 475k| vars[dst] = vars[src] + vars[src2]; 97| 490k| break; 98| 0| } 99| 1.36k| case op_push_back_move: { ------------------ | Branch (99:9): [True: 1.36k, False: 1.67M] ------------------ 100| 1.36k| vars[dst] = std::move(vars[src]).push_back(21); 101| 1.36k| break; 102| 0| } 103| 4.30k| case op_update_move: { ------------------ | Branch (103:9): [True: 4.30k, False: 1.66M] ------------------ 104| 4.30k| auto idx = read(in, is_valid_index(vars[src])); 105| 4.30k| vars[dst] = 106| 4.30k| std::move(vars[src]).update(idx, [](auto x) { return x + 1; }); 107| 4.30k| break; 108| 0| } 109| 8.20k| case op_take_move: { ------------------ | Branch (109:9): [True: 8.20k, False: 1.66M] ------------------ 110| 8.20k| auto idx = read(in, is_valid_size(vars[src])); 111| 8.20k| vars[dst] = std::move(vars[src]).take(idx); 112| 8.20k| break; 113| 0| } 114| 25.0k| case op_drop_move: { ------------------ | Branch (114:9): [True: 25.0k, False: 1.64M] ------------------ 115| 25.0k| auto idx = read(in, is_valid_size(vars[src])); 116| 25.0k| vars[dst] = std::move(vars[src]).drop(idx); 117| 25.0k| break; 118| 0| } 119| 395k| case op_concat_move_l: { ------------------ | Branch (119:9): [True: 395k, False: 1.27M] ------------------ 120| 395k| auto src2 = read(in, is_valid_var_neq(src)); 121| 395k| if (can_concat(vars[src], vars[src2])) ------------------ | Branch (121:17): [True: 339k, False: 56.2k] ------------------ 122| 339k| vars[dst] = std::move(vars[src]) + vars[src2]; 123| 395k| break; 124| 0| } 125| 200| case op_concat_move_r: { ------------------ | Branch (125:9): [True: 200, False: 1.67M] ------------------ 126| 200| auto src2 = read(in, is_valid_var_neq(src)); 127| 200| if (can_concat(vars[src], vars[src2])) ------------------ | Branch (127:17): [True: 185, False: 15] ------------------ 128| 185| vars[dst] = vars[src] + std::move(vars[src2]); 129| 200| break; 130| 0| } 131| 243k| case op_concat_move_lr: { ------------------ | Branch (131:9): [True: 243k, False: 1.42M] ------------------ 132| 243k| auto src2 = read(in, is_valid_var_neq(src)); 133| 243k| if (can_concat(vars[src], vars[src2])) ------------------ | Branch (133:17): [True: 231k, False: 12.5k] ------------------ 134| 231k| vars[dst] = std::move(vars[src]) + std::move(vars[src2]); 135| 243k| break; 136| 0| } 137| 2.51k| case op_compare: { ------------------ | Branch (137:9): [True: 2.51k, False: 1.66M] ------------------ 138| 2.51k| using std::swap; 139| 2.51k| if (can_compare(vars[src]) && vars[src] == vars[dst]) ------------------ | Branch (139:17): [True: 1.68k, False: 826] | Branch (139:43): [True: 459, False: 1.22k] ------------------ 140| 459| swap(vars[src], vars[dst]); 141| 2.51k| break; 142| 0| } 143| 378| case op_erase: { ------------------ | Branch (143:9): [True: 378, False: 1.67M] ------------------ 144| 378| auto idx = read(in, is_valid_index(vars[src])); 145| 378| vars[dst] = vars[src].erase(idx); 146| 378| break; 147| 0| } 148| 1.19k| case op_insert: { ------------------ | Branch (148:9): [True: 1.19k, False: 1.67M] ------------------ 149| 1.19k| auto idx = read(in, is_valid_size(vars[src])); 150| 1.19k| vars[dst] = vars[src].insert(idx, immer::box{42}); 151| 1.19k| break; 152| 0| } 153| 14.1k| default: ------------------ | Branch (153:9): [True: 14.1k, False: 1.65M] ------------------ 154| 14.1k| break; 155| 1.67M| }; 156| 1.67M| return true; 157| 1.67M| }); flex-vector-st.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clIcEEDaT_: 33| 4.07M| auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; }; ------------------ | Branch (33:48): [True: 3.94M, False: 130k] | Branch (33:60): [True: 3.83M, False: 113k] ------------------ flex-vector-st.cpp:_ZZZ22LLVMFuzzerTestOneInputENK3$_2clIN5immer11flex_vectorIiNS1_13memory_policyINS1_11heap_policyINS1_8cpp_heapEEENS1_22unsafe_refcount_policyENS1_14no_lock_policyENS1_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEDaRT_ENKUlSC_E_clIhEEDaSC_: 40| 475k| return [&](auto idx) { return idx >= 0 && idx < v.size(); }; ------------------ | Branch (40:39): [True: 475k, False: 0] | Branch (40:51): [True: 335k, False: 139k] ------------------ flex-vector-st.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clIN5immer11flex_vectorIiNS1_13memory_policyINS1_11heap_policyINS1_8cpp_heapEEENS1_22unsafe_refcount_policyENS1_14no_lock_policyENS1_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEDaRT_: 39| 335k| auto is_valid_index = [](auto& v) { 40| 335k| return [&](auto idx) { return idx >= 0 && idx < v.size(); }; 41| 335k| }; flex-vector-st.cpp:_ZZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_ENKUlS2_E_clIiEEDaS2_: 80| 330k| vars[dst] = vars[src].update(idx, [](auto x) { return x + 1; }); flex-vector-st.cpp:_ZZZ22LLVMFuzzerTestOneInputENK3$_3clIN5immer11flex_vectorIiNS1_13memory_policyINS1_11heap_policyINS1_8cpp_heapEEENS1_22unsafe_refcount_policyENS1_14no_lock_policyENS1_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEDaRT_ENKUlSC_E_clIhEEDaSC_: 43| 38.9k| return [&](auto idx) { return idx >= 0 && idx <= v.size(); }; ------------------ | Branch (43:39): [True: 38.9k, False: 0] | Branch (43:51): [True: 35.2k, False: 3.75k] ------------------ flex-vector-st.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clIN5immer11flex_vectorIiNS1_13memory_policyINS1_11heap_policyINS1_8cpp_heapEEENS1_22unsafe_refcount_policyENS1_14no_lock_policyENS1_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEDaRT_: 42| 35.2k| auto is_valid_size = [](auto& v) { 43| 35.2k| return [&](auto idx) { return idx >= 0 && idx <= v.size(); }; 44| 35.2k| }; flex-vector-st.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clIRN5immer11flex_vectorIiNS1_13memory_policyINS1_11heap_policyINS1_8cpp_heapEEENS1_22unsafe_refcount_policyENS1_14no_lock_policyENS1_20no_transience_policyELb0ELb1EEELj3ELj3EEESC_EEDaOT_OT0_: 45| 1.12M| auto can_concat = [](auto&& v1, auto&& v2) { 46| 1.12M| return v1.size() + v2.size() < vector_t::max_size(); 47| 1.12M| }; flex-vector-st.cpp:_ZZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_ENKUlS2_E0_clIiEEDaS2_: 106| 4.29k| std::move(vars[src]).update(idx, [](auto x) { return x + 1; }); flex-vector-st.cpp:_ZZZ22LLVMFuzzerTestOneInputENK3$_1clIcEEDaT_ENKUlS1_E_clIcEEDaS1_: 35| 703k| return [=](auto idx) { 36| 703k| return idx >= 0 && idx < var_count && idx != other; ------------------ | Branch (36:20): [True: 683k, False: 19.6k] | Branch (36:32): [True: 665k, False: 17.7k] | Branch (36:51): [True: 639k, False: 26.8k] ------------------ 37| 703k| }; flex-vector-st.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_1clIcEEDaT_: 34| 639k| auto is_valid_var_neq = [](auto other) { 35| 639k| return [=](auto idx) { 36| 639k| return idx >= 0 && idx < var_count && idx != other; 37| 639k| }; 38| 639k| }; flex-vector-st.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_5clIRN5immer11flex_vectorIiNS1_13memory_policyINS1_11heap_policyINS1_8cpp_heapEEENS1_22unsafe_refcount_policyENS1_14no_lock_policyENS1_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEDaOT_: 48| 2.51k| auto can_compare = [](auto&& v) { 49| | // avoid comparing vectors that are too big, and hence, slow to compare 50| 2.51k| return v.size() < (1 << 15); 51| 2.51k| }; flex-vector-st.cpp:_ZN12fuzzer_input3runIZ22LLVMFuzzerTestOneInputE3$_6EEiT_: 50| 300| { 51| 300| if (size_ > fuzzer_input_max_size) ------------------ | Branch (51:13): [True: 5, False: 295] ------------------ 52| 5| return 0; 53| 295| try { 54| 1.67M| while (step(*this)) ------------------ | Branch (54:20): [True: 1.67M, False: 295] ------------------ 55| 1.67M| continue; 56| 295| } catch (const no_more_input&) {}; 57| 295| return 0; 58| 295| } flex-vector-st.cpp:_Z4readIcZ22LLVMFuzzerTestOneInputE3$_0ET_R12fuzzer_inputT0_: 69| 3.83M|{ 70| 3.83M| auto x = read(fz); 71| 4.07M| while (!cond(x)) ------------------ | Branch (71:12): [True: 243k, False: 3.83M] ------------------ 72| 243k| x = read(fz); 73| 3.83M| return x; 74| 3.83M|} _Z4readIcERKT_R12fuzzer_input: 63| 6.45M|{ 64| 6.45M| return *reinterpret_cast(fz.next(sizeof(T), alignof(T))); 65| 6.45M|} _ZN12fuzzer_input4nextEmm: 40| 6.96M| { 41| 6.96M| auto& p = const_cast(reinterpret_cast(data_)); 42| 6.96M| auto r = std::align(align, size, p, size_); 43| 6.96M| if (r == nullptr) ------------------ | Branch (43:13): [True: 295, False: 6.96M] ------------------ 44| 295| throw no_more_input{}; 45| 6.96M| return next(size); 46| 6.96M| } _ZN12fuzzer_input4nextEm: 30| 6.96M| { 31| 6.96M| if (size_ < size) ------------------ | Branch (31:13): [True: 0, False: 6.96M] ------------------ 32| 0| throw no_more_input{}; 33| 6.96M| auto r = data_; 34| 6.96M| data_ += size; 35| 6.96M| size_ -= size; 36| 6.96M| return r; 37| 6.96M| } flex-vector-st.cpp:_Z4readIhZZ22LLVMFuzzerTestOneInputENK3$_2clIN5immer11flex_vectorIiNS2_13memory_policyINS2_11heap_policyINS2_8cpp_heapEEENS2_22unsafe_refcount_policyENS2_14no_lock_policyENS2_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEDaRT_EUlSD_E_ESD_R12fuzzer_inputT0_: 69| 335k|{ 70| 335k| auto x = read(fz); 71| 475k| while (!cond(x)) ------------------ | Branch (71:12): [True: 139k, False: 335k] ------------------ 72| 139k| x = read(fz); 73| 335k| return x; 74| 335k|} _Z4readIhERKT_R12fuzzer_input: 63| 514k|{ 64| 514k| return *reinterpret_cast(fz.next(sizeof(T), alignof(T))); 65| 514k|} flex-vector-st.cpp:_Z4readIhZZ22LLVMFuzzerTestOneInputENK3$_3clIN5immer11flex_vectorIiNS2_13memory_policyINS2_11heap_policyINS2_8cpp_heapEEENS2_22unsafe_refcount_policyENS2_14no_lock_policyENS2_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEDaRT_EUlSD_E_ESD_R12fuzzer_inputT0_: 69| 35.2k|{ 70| 35.2k| auto x = read(fz); 71| 38.9k| while (!cond(x)) ------------------ | Branch (71:12): [True: 3.75k, False: 35.2k] ------------------ 72| 3.75k| x = read(fz); 73| 35.2k| return x; 74| 35.2k|} flex-vector-st.cpp:_Z4readIcZZ22LLVMFuzzerTestOneInputENK3$_1clIcEEDaT_EUlS2_E_ES2_R12fuzzer_inputT0_: 69| 639k|{ 70| 639k| auto x = read(fz); 71| 703k| while (!cond(x)) ------------------ | Branch (71:12): [True: 64.2k, False: 639k] ------------------ 72| 64.2k| x = read(fz); 73| 639k| return x; 74| 639k|} _ZN5immer3boxIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEEC2IivEEOT_: 81| 1.19k| {} _ZN5immer3boxIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6holderC2IJiEEEDpOT_: 48| 1.19k| {} _ZNK5immer3boxIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEEcvRKiEv: 128| 1.19k| operator const T&() const { return get(); } _ZNK5immer3boxIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE3getEv: 125| 1.19k| IMMER_NODISCARD const T& get() const { return impl_->value; } _ZN5immer3boxIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEED2Ev: 117| 1.19k| { 118| 1.19k| if (impl_ && impl_->dec()) { ------------------ | Branch (118:13): [True: 1.19k, False: 0] | Branch (118:22): [True: 1.19k, False: 0] ------------------ 119| 1.19k| impl_->~holder(); 120| 1.19k| heap::deallocate(sizeof(holder), impl_); 121| 1.19k| } 122| 1.19k| } _ZN5immer6detail3csl3getINS_22unsafe_refcount_policyEEEDcRKNS1_10member_twoINS0_4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEES3_NS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11impl_data_tENS1_6memberIS3_NS1_7inheritINSC_5applyISA_E4type5owneeEvE4typeEE4typeEE4typeE: 170| 262M| { 171| 262M| return x.get_(type_t{}); 172| 262M| } _ZNK5immer6detail3csl10member_twoINS0_4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11impl_data_tENS1_6memberIS9_NS1_7inheritINSB_5applyIS8_E4type5owneeEvE4typeEE4typeEE4type4get_IS9_EEDcNS1_6type_tIT_EE: 184| 262M| { 185| 262M| return n.get_(t); 186| 262M| } _ZNK5immer6detail3csl6memberINS_22unsafe_refcount_policyENS1_7inheritINS_20no_transience_policy5applyINS_11heap_policyINS_8cpp_heapEEEE4type5owneeEvE4typeEE4type4get_ENS1_6type_tIS3_EE: 128| 280M| const T& get_(type_t) const { return d; } _ZN5immer6detail3csl3getINS_22unsafe_refcount_policyEEEDcRKNS1_10member_twoINS0_4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEES3_NS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE14relaxed_data_tENS1_6memberIS3_NS1_7inheritINSC_5applyISA_E4type5owneeEvE4typeEE4typeEE4typeE: 170| 18.7M| { 171| 18.7M| return x.get_(type_t{}); 172| 18.7M| } _ZNK5immer6detail3csl10member_twoINS0_4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE14relaxed_data_tENS1_6memberIS9_NS1_7inheritINSB_5applyIS8_E4type5owneeEvE4typeEE4typeEE4type4get_IS9_EEDcNS1_6type_tIT_EE: 184| 18.7M| { 185| 18.7M| return n.get_(t); 186| 18.7M| } _ZN5immer6detail3csl3getINS_20no_transience_policy5applyINS_11heap_policyINS_8cpp_heapEEEE4type5owneeEEEDcRNS1_10member_twoINS0_4rbts4nodeIiNS_13memory_policyIS7_NS_22unsafe_refcount_policyENS_14no_lock_policyES3_Lb0ELb1EEELj3ELj3EE14relaxed_data_tENS1_6memberISF_NS1_7inheritISA_vE4typeEE4typeEE4typeE: 165| 18.4M| { 166| 18.4M| return x.get_(type_t{}); 167| 18.4M| } _ZN5immer6detail3csl10member_twoINS0_4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE14relaxed_data_tENS1_6memberIS9_NS1_7inheritINSB_5applyIS8_E4type5owneeEvE4typeEE4typeEE4type4get_ISK_EEDcNS1_6type_tIT_EE: 179| 18.4M| { 180| 18.4M| return n.get_(t); 181| 18.4M| } _ZN5immer6detail3csl7inheritINS_20no_transience_policy5applyINS_11heap_policyINS_8cpp_heapEEEE4type5owneeEvE4type4get_ENS1_6type_tISA_EE: 102| 39.8M| T& get_(type_t) { return *this; } _ZN5immer6detail3csl3getINS_20no_transience_policy5applyINS_11heap_policyINS_8cpp_heapEEEE4type5owneeEEEDcRNS1_10member_twoINS0_4rbts4nodeIiNS_13memory_policyIS7_NS_22unsafe_refcount_policyENS_14no_lock_policyES3_Lb0ELb1EEELj3ELj3EE11impl_data_tENS1_6memberISF_NS1_7inheritISA_vE4typeEE4typeEE4typeE: 165| 21.4M| { 166| 21.4M| return x.get_(type_t{}); 167| 21.4M| } _ZN5immer6detail3csl10member_twoINS0_4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11impl_data_tENS1_6memberIS9_NS1_7inheritINSB_5applyIS8_E4type5owneeEvE4typeEE4typeEE4type4get_ISK_EEDcNS1_6type_tIT_EE: 179| 21.4M| { 180| 21.4M| return n.get_(t); 181| 21.4M| } _ZN5immer6detail3csl3getINS_20no_transience_policy5applyINS_11heap_policyINS_8cpp_heapEEEE4type5owneeEEEDcRKNS1_10member_twoINS0_4rbts4nodeIiNS_13memory_policyIS7_NS_22unsafe_refcount_policyENS_14no_lock_policyES3_Lb0ELb1EEELj3ELj3EE11impl_data_tENS1_6memberISF_NS1_7inheritISA_vE4typeEE4typeEE4typeE: 170| 65.5k| { 171| 65.5k| return x.get_(type_t{}); 172| 65.5k| } _ZNK5immer6detail3csl10member_twoINS0_4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11impl_data_tENS1_6memberIS9_NS1_7inheritINSB_5applyIS8_E4type5owneeEvE4typeEE4typeEE4type4get_ISK_EEDcNS1_6type_tIT_EE: 184| 65.5k| { 185| 65.5k| return n.get_(t); 186| 65.5k| } _ZNK5immer6detail3csl7inheritINS_20no_transience_policy5applyINS_11heap_policyINS_8cpp_heapEEEE4type5owneeEvE4type4get_ENS1_6type_tISA_EE: 103| 65.5k| const T& get_(type_t) const { return *this; } _ZNK5immer6detail15iterator_facadeINS0_4rbts16rrbtree_iteratorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENSt3__126random_access_iterator_tagEiRKilPSF_EdeEv: 112| 3.42M| ReferenceT operator*() const { return access_t::dereference(derived()); } _ZN5immer6detail20iterator_core_access11dereferenceIRKNS0_4rbts16rrbtree_iteratorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEDcOT_: 22| 3.42M| { 23| 3.42M| return x.dereference(); 24| 3.42M| } _ZNK5immer6detail15iterator_facadeINS0_4rbts16rrbtree_iteratorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENSt3__126random_access_iterator_tagEiRKilPSF_E7derivedEv: 99| 3.42M| { 100| 3.42M| static_assert(std::is_base_of::value, 101| 3.42M| "must pass a derived thing"); 102| 3.42M| return *static_cast(this); 103| 3.42M| } _ZN5immer6detail15iterator_facadeINS0_4rbts16rrbtree_iteratorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENSt3__126random_access_iterator_tagEiRKilPSF_EpLEl: 156| 2.94k| { 157| 2.94k| access_t::advance(derived(), n); 158| 2.94k| return derived(); 159| 2.94k| } _ZN5immer6detail20iterator_core_access7advanceIRNS0_4rbts16rrbtree_iteratorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEElEEDcOT_T0_: 46| 2.94k| { 47| 2.94k| return x.advance(d); 48| 2.94k| } _ZN5immer6detail15iterator_facadeINS0_4rbts16rrbtree_iteratorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENSt3__126random_access_iterator_tagEiRKilPSF_E7derivedEv: 105| 6.05M| { 106| 6.05M| static_assert(std::is_base_of::value, 107| 6.05M| "must pass a derived thing"); 108| 6.05M| return *static_cast(this); 109| 6.05M| } _ZN5immer6detail15iterator_facadeINS0_4rbts16rrbtree_iteratorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENSt3__126random_access_iterator_tagEiRKilPSF_EppEv: 130| 3.02M| { 131| 3.02M| access_t::increment(derived()); 132| 3.02M| return derived(); 133| 3.02M| } _ZN5immer6detail20iterator_core_access9incrementIRNS0_4rbts16rrbtree_iteratorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEDcOT_: 28| 3.02M| { 29| 3.02M| return x.increment(); 30| 3.02M| } _ZNK5immer6detail15iterator_facadeINS0_4rbts16rrbtree_iteratorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENSt3__126random_access_iterator_tagEiRKilPSF_EplEl: 167| 2.44k| { 168| 2.44k| static_assert(is_random_access, ""); 169| 2.44k| auto tmp = derived(); 170| 2.44k| return tmp += n; 171| 2.44k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE17make_inner_n_intoEPvmj: 203| 1.31M| { 204| 1.31M| assert(n <= branches); 205| 0| assert(size >= sizeof_inner_n(n)); 206| 0| auto p = new (buffer) node_t; 207| 1.31M| p->impl.d.data.inner.relaxed = nullptr; 208| 1.31M|#if IMMER_TAGGED_NODE 209| 1.31M| p->impl.d.kind = node_t::kind_t::inner; 210| 1.31M|#endif 211| 1.31M| return p; 212| 1.31M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE14sizeof_inner_nEj: 135| 5.28M| { 136| 5.28M| return keep_headroom ? max_sizeof_inner : sizeof_packed_inner_n(n); ------------------ | Branch (136:16): [Folded - Ignored] ------------------ 137| 5.28M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE3incEv: 946| 61.1M| { 947| 61.1M| refs(this).inc(); 948| 61.1M| return this; 949| 61.1M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE4refsEPKSB_: 193| 262M| { 194| 262M| return auto_const_cast(get(x->impl)); 195| 262M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE16make_leaf_n_intoEPvmj: 320| 1.06M| { 321| 1.06M| assert(n <= branches); 322| 0| assert(size >= sizeof_leaf_n(n)); 323| 0| auto p = new (buffer) node_t; 324| 1.06M|#if IMMER_TAGGED_NODE 325| 1.06M| p->impl.d.kind = node_t::kind_t::leaf; 326| 1.06M|#endif 327| 1.06M| return p; 328| 1.06M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE13sizeof_leaf_nEj: 150| 4.52M| { 151| 4.52M| return keep_headroom ? max_sizeof_leaf : sizeof_packed_leaf_n(n); ------------------ | Branch (151:16): [Folded - Ignored] ------------------ 152| 4.52M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE7relaxedEv: 162| 359M| { 163| 359M| IMMER_ASSERT_TAGGED(kind() == kind_t::inner); ------------------ | | 60| 359M|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 164| 0| return impl.d.data.inner.relaxed; 165| 359M| } _ZNK5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE4kindEv: 158| 554M| kind_t kind() const { return impl.d.kind; } _ZNK5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE3decEv: 957| 140M| bool dec() const { return refs(this).dec(); } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE5innerEv: 174| 157M| { 175| 157M| IMMER_ASSERT_TAGGED(kind() == kind_t::inner); ------------------ | | 60| 157M|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 176| 0| return reinterpret_cast(&impl.d.data.inner.buffer); 177| 157M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE14delete_inner_rEPSB_j: 822| 18.3M| { 823| 18.3M| IMMER_ASSERT_TAGGED(p->kind() == kind_t::inner); ------------------ | | 60| 18.3M|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 824| 0| auto r = p->relaxed(); 825| 18.3M| assert(r); 826| 0| static_if([&](auto) { 827| 18.3M| if (node_t::refs(r).dec()) 828| 18.3M| heap::deallocate(node_t::ownee(r).owned() 829| 18.3M| ? node_t::max_sizeof_relaxed 830| 18.3M| : node_t::sizeof_relaxed_n(n), 831| 18.3M| r); 832| 18.3M| }); 833| 18.3M| heap::deallocate(ownee(p).owned() ? node_t::max_sizeof_inner_r ------------------ | Branch (833:26): [True: 0, False: 18.3M] ------------------ 834| 18.3M| : node_t::sizeof_inner_r_n(n), 835| 18.3M| p); 836| 18.3M| } _ZZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE14delete_inner_rEPSB_jENKUlT_E_clINS0_7empty_tEEEDaSD_: 826| 18.3M| static_if([&](auto) { 827| 18.3M| if (node_t::refs(r).dec()) ------------------ | Branch (827:17): [True: 18.2M, False: 102k] ------------------ 828| 18.2M| heap::deallocate(node_t::ownee(r).owned() ------------------ | Branch (828:34): [True: 0, False: 18.2M] ------------------ 829| 18.2M| ? node_t::max_sizeof_relaxed 830| 18.2M| : node_t::sizeof_relaxed_n(n), 831| 18.2M| r); 832| 18.3M| }); _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE4refsEPKNS0_3csl10member_twoINSB_14relaxed_data_tENSC_6memberIS7_NSC_7inheritINS9_5applyIS6_E4type5owneeEvE4typeEE4typeEE4typeE: 186| 18.7M| { 187| 18.7M| return auto_const_cast(get(*x)); 188| 18.7M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE5owneeEPNS0_3csl10member_twoINSB_14relaxed_data_tENSC_6memberIS7_NSC_7inheritINS9_5applyIS6_E4type5owneeEvE4typeEE4typeEE4typeE: 190| 18.4M| static ownee_t& ownee(relaxed_t* x) { return get(*x); } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE16sizeof_relaxed_nEj: 145| 36.3M| { 146| 36.3M| return keep_headroom ? max_sizeof_relaxed : sizeof_packed_relaxed_n(n); ------------------ | Branch (146:16): [Folded - Ignored] ------------------ 147| 36.3M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE5owneeEPSB_: 200| 21.4M| static ownee_t& ownee(node_t* x) { return get(x->impl); } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE16sizeof_inner_r_nEj: 140| 36.5M| { 141| 36.5M| return keep_headroom ? max_sizeof_inner_r : sizeof_packed_inner_r_n(n); ------------------ | Branch (141:16): [Folded - Ignored] ------------------ 142| 36.5M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11delete_leafEPSB_j: 851| 1.31M| { 852| 1.31M| IMMER_ASSERT_TAGGED(p->kind() == kind_t::leaf); ------------------ | | 60| 1.31M|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 853| 0| detail::destroy_n(p->leaf(), n); 854| 1.31M| heap::deallocate(ownee(p).owned() ? node_t::max_sizeof_leaf ------------------ | Branch (854:26): [True: 0, False: 1.31M] ------------------ 855| 1.31M| : node_t::sizeof_leaf_n(n), 856| 1.31M| p); 857| 1.31M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE4leafEv: 180| 8.27M| { 181| 8.27M| IMMER_ASSERT_TAGGED(kind() == kind_t::leaf); ------------------ | | 60| 8.27M|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 182| 0| return reinterpret_cast(&impl.d.data.leaf.buffer); 183| 8.27M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE12delete_innerEPSB_j: 798| 1.35M| { 799| 1.35M| IMMER_ASSERT_TAGGED(p->kind() == kind_t::inner); ------------------ | | 60| 1.35M|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 800| 0| assert(!p->relaxed()); 801| 1.35M| heap::deallocate(ownee(p).owned() ? node_t::max_sizeof_inner ------------------ | Branch (801:26): [True: 0, False: 1.35M] ------------------ 802| 1.35M| : node_t::sizeof_inner_n(n), 803| 1.35M| p); 804| 1.35M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE17copy_leaf_emplaceIiEEPSB_SD_jOT_: 784| 133k| { 785| 133k| auto dst = copy_leaf_n(n + 1, src, n); 786| 133k| IMMER_TRY { ------------------ | | 41| 133k|#define IMMER_TRY try ------------------ 787| 133k| new (dst->leaf() + n) T{std::forward(x)}; 788| 133k| } 789| 133k| IMMER_CATCH (...) { 790| 0| detail::destroy_n(dst->leaf(), n); 791| 0| heap::deallocate(node_t::sizeof_leaf_n(n + 1), dst); 792| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 793| 0| } 794| 0| return dst; 795| 133k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11copy_leaf_nEjPSB_j: 686| 133k| { 687| 133k| assert(allocn >= n); 688| 133k| IMMER_ASSERT_TAGGED(src->kind() == kind_t::leaf); ------------------ | | 60| 133k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 689| 0| auto dst = make_leaf_n(allocn); 690| 133k| IMMER_TRY { ------------------ | | 41| 133k|#define IMMER_TRY try ------------------ 691| 133k| detail::uninitialized_copy( 692| 133k| src->leaf(), src->leaf() + n, dst->leaf()); 693| 133k| } 694| 133k| IMMER_CATCH (...) { 695| 0| heap::deallocate(node_t::sizeof_leaf_n(allocn), dst); 696| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 697| 0| } 698| 0| return dst; 699| 133k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11make_leaf_nEj: 331| 1.06M| { 332| 1.06M| assert(n <= branches); 333| 0| auto m = heap::allocate(sizeof_leaf_n(n)); 334| 1.06M| return make_leaf_n_into(m, sizeof_leaf_n(n), n); 335| 1.06M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11make_leaf_nIiEEPSB_jOT_: 460| 19.5k| { 461| 19.5k| assert(n >= 1); 462| 0| auto p = make_leaf_n(n); 463| 19.5k| IMMER_TRY { ------------------ | | 41| 19.5k|#define IMMER_TRY try ------------------ 464| 19.5k| new (p->leaf()) T{std::forward(x)}; 465| 19.5k| } 466| 19.5k| IMMER_CATCH (...) { 467| 0| heap::deallocate(node_t::sizeof_leaf_n(n), p); 468| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 469| 0| } 470| 0| return p; 471| 19.5k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE13do_copy_innerEPSB_SC_j: 548| 1.20M| { 549| 1.20M| IMMER_ASSERT_TAGGED(dst->kind() == kind_t::inner); ------------------ | | 60| 1.20M|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 550| 1.20M| IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); ------------------ | | 60| 1.20M|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 551| 0| auto p = src->inner(); 552| 1.20M| inc_nodes(p, n); 553| 1.20M| std::copy(p, p + n, dst->inner()); 554| 1.20M| return dst; 555| 1.20M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE9inc_nodesEPPSB_j: 960| 16.5M| { 961| 75.1M| for (auto i = p, e = i + n; i != e; ++i) ------------------ | Branch (961:37): [True: 58.6M, False: 16.5M] ------------------ 962| 58.6M| refs(*i).inc(); 963| 16.5M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE14copy_inner_r_nEjPSB_j: 578| 341k| { 579| 341k| assert(allocn >= n); 580| 341k| IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); ------------------ | | 60| 341k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 581| 0| auto dst = make_inner_r_n(allocn); 582| 341k| return do_copy_inner_r(dst, src, n); 583| 341k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE15do_copy_inner_rEPSB_SC_j: 600| 348k| { 601| 348k| IMMER_ASSERT_TAGGED(dst->kind() == kind_t::inner); ------------------ | | 60| 348k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 602| 348k| IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); ------------------ | | 60| 348k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 603| 0| auto src_r = src->relaxed(); 604| 348k| auto dst_r = dst->relaxed(); 605| 348k| inc_nodes(src->inner(), n); 606| 348k| std::copy(src->inner(), src->inner() + n, dst->inner()); 607| 348k| std::copy(src_r->d.sizes, src_r->d.sizes + n, dst_r->d.sizes); 608| 348k| dst_r->d.count = n; 609| 348k| return dst; 610| 348k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE14make_inner_r_nEj: 233| 18.1M| { 234| 18.1M| assert(n <= branches); 235| 0| auto mp = heap::allocate(sizeof_inner_r_n(n)); 236| 18.1M| auto mr = static_cast(nullptr); 237| 18.1M| if (embed_relaxed) { ------------------ | Branch (237:13): [Folded - Ignored] ------------------ 238| 0| mr = reinterpret_cast(mp) + sizeof_inner_n(n); 239| 18.1M| } else { 240| 18.1M| IMMER_TRY { ------------------ | | 41| 18.1M|#define IMMER_TRY try ------------------ 241| 18.1M| mr = heap::allocate(sizeof_relaxed_n(n), norefs_tag{}); 242| 18.1M| } 243| 18.1M| IMMER_CATCH (...) { 244| 0| heap::deallocate(sizeof_inner_r_n(n), mp); 245| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 246| 0| } 247| 18.1M| } 248| 18.1M| auto p = new (mp) node_t; 249| 18.1M| auto r = new (mr) relaxed_t; 250| 18.1M| r->d.count = 0; 251| 18.1M| p->impl.d.data.inner.relaxed = r; 252| 18.1M|#if IMMER_TAGGED_NODE 253| 18.1M| p->impl.d.kind = node_t::kind_t::inner; 254| 18.1M|#endif 255| 18.1M| return p; 256| 18.1M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE9make_pathEjPSB_: 488| 359k| { 489| 359k| IMMER_ASSERT_TAGGED(node->kind() == kind_t::leaf); ------------------ | | 60| 359k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 490| 359k| if (shift == endshift) ------------------ | Branch (490:13): [True: 311k, False: 47.9k] ------------------ 491| 311k| return node; 492| 47.9k| else { 493| 47.9k| auto n = node_t::make_inner_n(1); 494| 47.9k| IMMER_TRY { ------------------ | | 41| 47.9k|#define IMMER_TRY try ------------------ 495| 47.9k| n->inner()[0] = make_path(shift - B, node); 496| 47.9k| } 497| 47.9k| IMMER_CATCH (...) { 498| 0| heap::deallocate(node_t::sizeof_inner_n(1), n); 499| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 500| 0| } 501| 47.9k| return n; 502| 47.9k| } 503| 359k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE12make_inner_nEj: 214| 1.31M| { 215| 1.31M| assert(n <= branches); 216| 0| auto m = heap::allocate(sizeof_inner_n(n)); 217| 1.31M| return make_inner_n_into(m, sizeof_inner_n(n), n); 218| 1.31M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE9copy_leafEPSB_j: 656| 331k| { 657| 331k| IMMER_ASSERT_TAGGED(src->kind() == kind_t::leaf); ------------------ | | 60| 331k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 658| 0| auto dst = make_leaf_n(n); 659| 331k| IMMER_TRY { ------------------ | | 41| 331k|#define IMMER_TRY try ------------------ 660| 331k| detail::uninitialized_copy( 661| 331k| src->leaf(), src->leaf() + n, dst->leaf()); 662| 331k| } 663| 331k| IMMER_CATCH (...) { 664| 0| heap::deallocate(node_t::sizeof_leaf_n(n), dst); 665| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 666| 0| } 667| 0| return dst; 668| 331k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE15make_inner_sr_nEjPNS0_3csl10member_twoINSB_14relaxed_data_tENSC_6memberIS7_NSC_7inheritINS9_5applyIS6_E4type5owneeEvE4typeEE4typeEE4typeE: 259| 105k| { 260| 105k| return static_if( 261| 105k| [&](auto) { return node_t::make_inner_r_n(n); }, 262| 105k| [&](auto) { 263| 105k| auto p = 264| 105k| new (heap::allocate(node_t::sizeof_inner_r_n(n))) node_t; 265| 105k| assert(r->d.count >= n); 266| 105k| node_t::refs(r).inc(); 267| 105k| p->impl.d.data.inner.relaxed = r; 268| 105k|#if IMMER_TAGGED_NODE 269| 105k| p->impl.d.kind = node_t::kind_t::inner; 270| 105k|#endif 271| 105k| return p; 272| 105k| }); 273| 105k| } _ZZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE15make_inner_sr_nEjPNS0_3csl10member_twoINSB_14relaxed_data_tENSC_6memberIS7_NSC_7inheritINS9_5applyIS6_E4type5owneeEvE4typeEE4typeEE4typeEENKUlT_E0_clINS0_7empty_tEEEDaSS_: 262| 105k| [&](auto) { 263| 105k| auto p = 264| 105k| new (heap::allocate(node_t::sizeof_inner_r_n(n))) node_t; 265| 105k| assert(r->d.count >= n); 266| 0| node_t::refs(r).inc(); 267| 105k| p->impl.d.data.inner.relaxed = r; 268| 105k|#if IMMER_TAGGED_NODE 269| 105k| p->impl.d.kind = node_t::kind_t::inner; 270| 105k|#endif 271| 105k| return p; 272| 105k| }); _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE24do_copy_inner_replace_srEPSB_SC_jjSC_: 642| 105k| { 643| 105k| if (embed_relaxed) ------------------ | Branch (643:13): [Folded - Ignored] ------------------ 644| 0| return do_copy_inner_replace_r(dst, src, n, offset, child); 645| 105k| else { 646| 105k| auto p = src->inner(); 647| 105k| inc_nodes(p, offset); 648| 105k| inc_nodes(p + offset + 1, n - offset - 1); 649| 105k| std::copy(p, p + n, dst->inner()); 650| 105k| dst->inner()[offset] = child; 651| 105k| return dst; 652| 105k| } 653| 105k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE21do_copy_inner_replaceEPSB_SC_jjSC_: 559| 62.4k| { 560| 62.4k| IMMER_ASSERT_TAGGED(dst->kind() == kind_t::inner); ------------------ | | 60| 62.4k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 561| 62.4k| IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); ------------------ | | 60| 62.4k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 562| 0| auto p = src->inner(); 563| 62.4k| inc_nodes(p, offset); 564| 62.4k| inc_nodes(p + offset + 1, n - offset - 1); 565| 62.4k| std::copy(p, p + n, dst->inner()); 566| 62.4k| dst->inner()[offset] = child; 567| 62.4k| return dst; 568| 62.4k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE12copy_inner_nEjPSB_j: 533| 509| { 534| 509| assert(allocn >= n); 535| 509| IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); ------------------ | | 60| 509|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 536| 0| auto dst = make_inner_n(allocn); 537| 509| return do_copy_inner(dst, src, n); 538| 509| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE12copy_inner_rEPSB_j: 571| 468| { 572| 468| IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); ------------------ | | 60| 468|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 573| 0| auto dst = make_inner_r_n(n); 574| 468| return do_copy_inner_r(dst, src, n); 575| 468| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE13compute_shiftEv: 967| 2.76M| { 968| 2.76M| if (kind() == kind_t::leaf) ------------------ | Branch (968:13): [True: 182k, False: 2.58M] ------------------ 969| 182k| return endshift; 970| 2.58M| else 971| 2.58M| return B + inner()[0]->compute_shift(); 972| 2.76M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE5checkEjm: 976| 182k| { 977| |#if IMMER_DEBUG_DEEP_CHECK 978| | assert(size > 0); 979| | if (shift == endshift) { 980| | IMMER_ASSERT_TAGGED(kind() == kind_t::leaf); 981| | assert(size <= branches); 982| | } else if (auto r = relaxed()) { 983| | auto count = r->d.count; 984| | assert(count > 0); 985| | assert(count <= branches); 986| | if (r->d.sizes[count - 1] != size) { 987| | IMMER_TRACE_F("check"); 988| | IMMER_TRACE_E(r->d.sizes[count - 1]); 989| | IMMER_TRACE_E(size); 990| | } 991| | assert(r->d.sizes[count - 1] == size); 992| | for (auto i = 1u; i < count; ++i) 993| | assert(r->d.sizes[i - 1] < r->d.sizes[i]); 994| | auto last_size = size_t{}; 995| | for (auto i = 0u; i < count; ++i) { 996| | assert(inner()[i]->check(shift - B, r->d.sizes[i] - last_size)); 997| | last_size = r->d.sizes[i]; 998| | } 999| | } else { 1000| | assert(size <= branches << shift); 1001| | auto count = 1002| | (size >> shift) + (size - ((size >> shift) << shift) > 0); 1003| | assert(count <= branches); 1004| | if (count) { 1005| | for (auto i = 1u; i < count - 1; ++i) 1006| | assert(inner()[i]->check(shift - B, 1 << shift)); 1007| | assert(inner()[count - 1]->check( 1008| | shift - B, size - ((count - 1) << shift))); 1009| | } 1010| | } 1011| |#endif // IMMER_DEBUG_DEEP_CHECK 1012| 182k| return true; 1013| 182k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE9copy_leafEPSB_jj: 768| 265k| { 769| 265k| IMMER_ASSERT_TAGGED(src->kind() == kind_t::leaf); ------------------ | | 60| 265k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 770| 0| auto dst = make_leaf_n(last - idx); 771| 265k| IMMER_TRY { ------------------ | | 41| 265k|#define IMMER_TRY try ------------------ 772| 265k| detail::uninitialized_copy( 773| 265k| src->leaf() + idx, src->leaf() + last, dst->leaf()); 774| 265k| } 775| 265k| IMMER_CATCH (...) { 776| 0| heap::deallocate(node_t::sizeof_leaf_n(last - idx), dst); 777| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 778| 0| } 779| 0| return dst; 780| 265k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE9copy_leafEPSB_jSC_j: 702| 266k| { 703| 266k| IMMER_ASSERT_TAGGED(src1->kind() == kind_t::leaf); ------------------ | | 60| 266k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 704| 266k| IMMER_ASSERT_TAGGED(src2->kind() == kind_t::leaf); ------------------ | | 60| 266k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 705| 0| auto dst = make_leaf_n(n1 + n2); 706| 266k| IMMER_TRY { ------------------ | | 41| 266k|#define IMMER_TRY try ------------------ 707| 266k| detail::uninitialized_copy( 708| 266k| src1->leaf(), src1->leaf() + n1, dst->leaf()); 709| 266k| } 710| 266k| IMMER_CATCH (...) { 711| 0| heap::deallocate(node_t::sizeof_leaf_n(n1 + n2), dst); 712| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 713| 0| } 714| 0| IMMER_TRY { ------------------ | | 41| 0|#define IMMER_TRY try ------------------ 715| 0| detail::uninitialized_copy( 716| 0| src2->leaf(), src2->leaf() + n2, dst->leaf() + n1); 717| 0| } 718| 0| IMMER_CATCH (...) { 719| 0| detail::destroy_n(dst->leaf(), n1); 720| 0| heap::deallocate(node_t::sizeof_leaf_n(n1 + n2), dst); 721| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 722| 0| } 723| 0| return dst; 724| 0| } _ZNK5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE10can_mutateENS9_5applyIS6_E4type4editE: 860| 1.68M| { 861| 1.68M| return refs(this).unique() || ownee(this).can_mutate(e); ------------------ | Branch (861:16): [True: 1.61M, False: 65.5k] | Branch (861:39): [True: 0, False: 65.5k] ------------------ 862| 1.68M| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE5owneeEPKSB_: 197| 65.5k| { 198| 65.5k| return get(x->impl); 199| 65.5k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11copy_leaf_eENS9_5applyIS6_E4type4editEPSB_j: 671| 9.57k| { 672| 9.57k| IMMER_ASSERT_TAGGED(src->kind() == kind_t::leaf); ------------------ | | 60| 9.57k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 673| 0| auto dst = make_leaf_e(e); 674| 9.57k| IMMER_TRY { ------------------ | | 41| 9.57k|#define IMMER_TRY try ------------------ 675| 9.57k| detail::uninitialized_copy( 676| 9.57k| src->leaf(), src->leaf() + n, dst->leaf()); 677| 9.57k| } 678| 9.57k| IMMER_CATCH (...) { 679| 0| heap::deallocate(node_t::max_sizeof_leaf, dst); 680| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 681| 0| } 682| 0| return dst; 683| 9.57k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11make_leaf_eENS9_5applyIS6_E4type4editE: 338| 243k| { 339| 243k| auto p = new (heap::allocate(max_sizeof_leaf)) node_t; 340| 243k| ownee(p) = e; 341| 243k|#if IMMER_TAGGED_NODE 342| 243k| p->impl.d.kind = node_t::kind_t::leaf; 343| 243k|#endif 344| 243k| return p; 345| 243k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11make_leaf_eIiEEPSB_NS9_5applyIS6_E4type4editEOT_: 475| 201| { 476| 201| auto p = make_leaf_e(e); 477| 201| IMMER_TRY { ------------------ | | 41| 201|#define IMMER_TRY try ------------------ 478| 201| new (p->leaf()) T{std::forward(x)}; 479| 201| } 480| 201| IMMER_CATCH (...) { 481| 0| heap::deallocate(node_t::max_sizeof_leaf, p); 482| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 483| 0| } 484| 0| return p; 485| 201| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE24ensure_mutable_relaxed_nENS9_5applyIS6_E4type4editEj: 920| 175k| { 921| 175k| auto src_r = relaxed(); 922| 175k| return static_if( 923| 175k| [&](auto) { return src_r; }, 924| 175k| [&](auto) { 925| 175k| if (node_t::refs(src_r).unique() || 926| 175k| node_t::ownee(src_r).can_mutate(e)) 927| 175k| return src_r; 928| 175k| else { 929| 175k| auto dst_r = 930| 175k| new (heap::allocate(max_sizeof_relaxed)) relaxed_t; 931| 175k| if (src_r) { 932| 175k| std::copy( 933| 175k| src_r->d.sizes, src_r->d.sizes + n, dst_r->d.sizes); 934| 175k| if (node_t::refs(src_r).dec()) 935| 175k| heap::deallocate(node_t::sizeof_inner_r_n(n), 936| 175k| src_r); 937| 175k| } 938| 175k| dst_r->d.count = n; 939| 175k| node_t::ownee(dst_r) = e; 940| 175k| return impl.d.data.inner.relaxed = dst_r; 941| 175k| } 942| 175k| }); 943| 175k| } _ZZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE24ensure_mutable_relaxed_nENS9_5applyIS6_E4type4editEjENKUlT_E0_clINS0_7empty_tEEEDaSG_: 924| 175k| [&](auto) { 925| 175k| if (node_t::refs(src_r).unique() || ------------------ | Branch (925:21): [True: 171k, False: 4.36k] ------------------ 926| 175k| node_t::ownee(src_r).can_mutate(e)) ------------------ | Branch (926:21): [True: 0, False: 4.36k] ------------------ 927| 171k| return src_r; 928| 4.36k| else { 929| 4.36k| auto dst_r = 930| 4.36k| new (heap::allocate(max_sizeof_relaxed)) relaxed_t; 931| 4.36k| if (src_r) { ------------------ | Branch (931:25): [True: 4.36k, False: 0] ------------------ 932| 4.36k| std::copy( 933| 4.36k| src_r->d.sizes, src_r->d.sizes + n, dst_r->d.sizes); 934| 4.36k| if (node_t::refs(src_r).dec()) ------------------ | Branch (934:29): [True: 0, False: 4.36k] ------------------ 935| 0| heap::deallocate(node_t::sizeof_inner_r_n(n), 936| 0| src_r); 937| 4.36k| } 938| 4.36k| dst_r->d.count = n; 939| 4.36k| node_t::ownee(dst_r) = e; 940| 4.36k| return impl.d.data.inner.relaxed = dst_r; 941| 4.36k| } 942| 175k| }); _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE14copy_inner_r_eENS9_5applyIS6_E4type4editEPSB_j: 586| 6.04k| { 587| 6.04k| IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); ------------------ | | 60| 6.04k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 588| 0| auto dst = make_inner_r_e(e); 589| 6.04k| return do_copy_inner_r(dst, src, n); 590| 6.04k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE14make_inner_r_eENS9_5applyIS6_E4type4editE: 276| 128k| { 277| 128k| auto mp = heap::allocate(max_sizeof_inner_r); 278| 128k| auto mr = static_cast(nullptr); 279| 128k| if (embed_relaxed) { ------------------ | Branch (279:13): [Folded - Ignored] ------------------ 280| 0| mr = reinterpret_cast(mp) + max_sizeof_inner; 281| 128k| } else { 282| 128k| IMMER_TRY { ------------------ | | 41| 128k|#define IMMER_TRY try ------------------ 283| 128k| mr = heap::allocate(max_sizeof_relaxed, norefs_tag{}); 284| 128k| } 285| 128k| IMMER_CATCH (...) { 286| 0| heap::deallocate(max_sizeof_inner_r, mp); 287| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 288| 0| } 289| 128k| } 290| 128k| auto p = new (mp) node_t; 291| 128k| auto r = new (mr) relaxed_t; 292| 128k| ownee(p) = e; 293| 128k| static_if([&](auto) { node_t::ownee(r) = e; }); 294| 128k| r->d.count = 0; 295| 128k| p->impl.d.data.inner.relaxed = r; 296| 128k|#if IMMER_TAGGED_NODE 297| 128k| p->impl.d.kind = node_t::kind_t::inner; 298| 128k|#endif 299| 128k| return p; 300| 128k| } _ZZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE14make_inner_r_eENS9_5applyIS6_E4type4editEENKUlT_E_clINS0_7empty_tEEEDaSG_: 293| 128k| static_if([&](auto) { node_t::ownee(r) = e; }); _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11make_path_eENS9_5applyIS6_E4type4editEjPSB_: 506| 303k| { 507| 303k| IMMER_ASSERT_TAGGED(node->kind() == kind_t::leaf); ------------------ | | 60| 303k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 508| 303k| if (shift == endshift) ------------------ | Branch (508:13): [True: 265k, False: 37.9k] ------------------ 509| 265k| return node; 510| 37.9k| else { 511| 37.9k| auto n = node_t::make_inner_e(e); 512| 37.9k| IMMER_TRY { ------------------ | | 41| 37.9k|#define IMMER_TRY try ------------------ 513| 37.9k| n->inner()[0] = make_path_e(e, shift - B, node); 514| 37.9k| } 515| 37.9k| IMMER_CATCH (...) { 516| 0| heap::deallocate(node_t::max_sizeof_inner, n); 517| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 518| 0| } 519| 37.9k| return n; 520| 37.9k| } 521| 303k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE12make_inner_eENS9_5applyIS6_E4type4editE: 221| 43.4k| { 222| 43.4k| auto m = heap::allocate(max_sizeof_inner); 223| 43.4k| auto p = new (m) node_t; 224| 43.4k| ownee(p) = e; 225| 43.4k| p->impl.d.data.inner.relaxed = nullptr; 226| 43.4k|#if IMMER_TAGGED_NODE 227| 43.4k| p->impl.d.kind = node_t::kind_t::inner; 228| 43.4k|#endif 229| 43.4k| return p; 230| 43.4k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE12copy_inner_eENS9_5applyIS6_E4type4editEPSB_j: 541| 4.17k| { 542| 4.17k| IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); ------------------ | | 60| 4.17k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 543| 0| auto dst = make_inner_e(e); 544| 4.17k| return do_copy_inner(dst, src, n); 545| 4.17k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE15copy_inner_sr_eENS9_5applyIS6_E4type4editEPSB_j: 593| 7.67k| { 594| 7.67k| IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); ------------------ | | 60| 7.67k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 595| 0| auto dst = make_inner_sr_e(e, src->relaxed()); 596| 7.67k| return do_copy_inner_sr(dst, src, n); 597| 7.67k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE15make_inner_sr_eENS9_5applyIS6_E4type4editEPNS0_3csl10member_twoINSB_14relaxed_data_tENSG_6memberIS7_NSG_7inheritINSE_5owneeEvE4typeEE4typeEE4typeE: 303| 7.67k| { 304| 7.67k| return static_if( 305| 7.67k| [&](auto) { return node_t::make_inner_r_e(e); }, 306| 7.67k| [&](auto) { 307| 7.67k| auto p = 308| 7.67k| new (heap::allocate(node_t::max_sizeof_inner_r)) node_t; 309| 7.67k| node_t::refs(r).inc(); 310| 7.67k| p->impl.d.data.inner.relaxed = r; 311| 7.67k| node_t::ownee(p) = e; 312| 7.67k|#if IMMER_TAGGED_NODE 313| 7.67k| p->impl.d.kind = node_t::kind_t::inner; 314| 7.67k|#endif 315| 7.67k| return p; 316| 7.67k| }); 317| 7.67k| } _ZZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE15make_inner_sr_eENS9_5applyIS6_E4type4editEPNS0_3csl10member_twoINSB_14relaxed_data_tENSG_6memberIS7_NSG_7inheritINSE_5owneeEvE4typeEE4typeEE4typeEENKUlT_E0_clINS0_7empty_tEEEDaST_: 306| 7.67k| [&](auto) { 307| 7.67k| auto p = 308| 7.67k| new (heap::allocate(node_t::max_sizeof_inner_r)) node_t; 309| 7.67k| node_t::refs(r).inc(); 310| 7.67k| p->impl.d.data.inner.relaxed = r; 311| 7.67k| node_t::ownee(p) = e; 312| 7.67k|#if IMMER_TAGGED_NODE 313| 7.67k| p->impl.d.kind = node_t::kind_t::inner; 314| 7.67k|#endif 315| 7.67k| return p; 316| 7.67k| }); _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE16do_copy_inner_srEPSB_SC_j: 630| 7.67k| { 631| 7.67k| if (embed_relaxed) ------------------ | Branch (631:13): [Folded - Ignored] ------------------ 632| 0| return do_copy_inner_r(dst, src, n); 633| 7.67k| else { 634| 7.67k| inc_nodes(src->inner(), n); 635| 7.67k| std::copy(src->inner(), src->inner() + n, dst->inner()); 636| 7.67k| return dst; 637| 7.67k| } 638| 7.67k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11copy_leaf_eENS9_5applyIS6_E4type4editEPSB_jj: 753| 234k| { 754| 234k| IMMER_ASSERT_TAGGED(src->kind() == kind_t::leaf); ------------------ | | 60| 234k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 755| 0| auto dst = make_leaf_e(e); 756| 234k| IMMER_TRY { ------------------ | | 41| 234k|#define IMMER_TRY try ------------------ 757| 234k| detail::uninitialized_copy( 758| 234k| src->leaf() + idx, src->leaf() + last, dst->leaf()); 759| 234k| } 760| 234k| IMMER_CATCH (...) { 761| 0| heap::deallocate(max_sizeof_leaf, dst); 762| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 763| 0| } 764| 0| return dst; 765| 234k| } _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE22ensure_mutable_relaxedENS9_5applyIS6_E4type4editE: 867| 91.2k| { 868| 91.2k| auto src_r = relaxed(); 869| 91.2k| return static_if( 870| 91.2k| [&](auto) { return src_r; }, 871| 91.2k| [&](auto) { 872| 91.2k| if (node_t::refs(src_r).unique() || 873| 91.2k| node_t::ownee(src_r).can_mutate(e)) 874| 91.2k| return src_r; 875| 91.2k| else { 876| 91.2k| auto dst_r = impl.d.data.inner.relaxed = 877| 91.2k| new (heap::allocate(max_sizeof_relaxed)) relaxed_t; 878| 91.2k| if (src_r) { 879| 91.2k| auto n = dst_r->d.count = src_r->d.count; 880| 91.2k| std::copy( 881| 91.2k| src_r->d.sizes, src_r->d.sizes + n, dst_r->d.sizes); 882| 91.2k| if (node_t::refs(src_r).dec()) 883| 91.2k| heap::deallocate(node_t::sizeof_inner_r_n(n), 884| 91.2k| src_r); 885| 91.2k| } 886| 91.2k| node_t::ownee(dst_r) = e; 887| 91.2k| return dst_r; 888| 91.2k| } 889| 91.2k| }); 890| 91.2k| } _ZZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE22ensure_mutable_relaxedENS9_5applyIS6_E4type4editEENKUlT_E0_clINS0_7empty_tEEEDaSG_: 871| 91.2k| [&](auto) { 872| 91.2k| if (node_t::refs(src_r).unique() || ------------------ | Branch (872:21): [True: 85.6k, False: 5.66k] ------------------ 873| 91.2k| node_t::ownee(src_r).can_mutate(e)) ------------------ | Branch (873:21): [True: 0, False: 5.66k] ------------------ 874| 85.6k| return src_r; 875| 5.66k| else { 876| 5.66k| auto dst_r = impl.d.data.inner.relaxed = 877| 5.66k| new (heap::allocate(max_sizeof_relaxed)) relaxed_t; 878| 5.66k| if (src_r) { ------------------ | Branch (878:25): [True: 5.66k, False: 0] ------------------ 879| 5.66k| auto n = dst_r->d.count = src_r->d.count; 880| 5.66k| std::copy( 881| 5.66k| src_r->d.sizes, src_r->d.sizes + n, dst_r->d.sizes); 882| 5.66k| if (node_t::refs(src_r).dec()) ------------------ | Branch (882:29): [True: 0, False: 5.66k] ------------------ 883| 0| heap::deallocate(node_t::sizeof_inner_r_n(n), 884| 0| src_r); 885| 5.66k| } 886| 5.66k| node_t::ownee(dst_r) = e; 887| 5.66k| return dst_r; 888| 5.66k| } 889| 91.2k| }); _ZN5immer6detail4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11copy_leaf_eENS9_5applyIS6_E4type4editEPSB_jSG_j: 728| 9| { 729| 9| IMMER_ASSERT_TAGGED(src1->kind() == kind_t::leaf); ------------------ | | 60| 9|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 730| 9| IMMER_ASSERT_TAGGED(src2->kind() == kind_t::leaf); ------------------ | | 60| 9|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 731| 0| auto dst = make_leaf_e(e); 732| 9| IMMER_TRY { ------------------ | | 41| 9|#define IMMER_TRY try ------------------ 733| 9| detail::uninitialized_copy( 734| 9| src1->leaf(), src1->leaf() + n1, dst->leaf()); 735| 9| } 736| 9| IMMER_CATCH (...) { 737| 0| heap::deallocate(max_sizeof_leaf, dst); 738| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 739| 0| } 740| 0| IMMER_TRY { ------------------ | | 41| 0|#define IMMER_TRY try ------------------ 741| 0| detail::uninitialized_copy( 742| 0| src2->leaf(), src2->leaf() + n2, dst->leaf() + n1); 743| 0| } 744| 0| IMMER_CATCH (...) { 745| 0| detail::destroy_n(dst->leaf(), n1); 746| 0| heap::deallocate(max_sizeof_leaf, dst); 747| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 748| 0| } 749| 0| return dst; 750| 0| } _ZN5immer6detail4rbts11dec_visitor13visit_relaxedIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEvOT_: 522| 97.1M| { 523| 97.1M| using node_t = node_type; 524| 97.1M| auto node = p.node(); 525| 97.1M| if (node->dec()) { ------------------ | Branch (525:13): [True: 18.3M, False: 78.8M] ------------------ 526| 18.3M| p.each(this_t{}); 527| 18.3M| node_t::delete_inner_r(node, p.count()); 528| 18.3M| } 529| 97.1M| } _ZN5immer6detail4rbts11dec_visitor13visit_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEvOT_: 533| 7.22M| { 534| 7.22M| using node_t = node_type; 535| 7.22M| auto node = p.node(); 536| 7.22M| if (node->dec()) { ------------------ | Branch (536:13): [True: 375k, False: 6.84M] ------------------ 537| 375k| p.each(this_t{}); 538| 375k| node_t::delete_inner(node, p.count()); 539| 375k| } 540| 7.22M| } _ZN5immer6detail4rbts11dec_visitor10visit_leafIRNS1_13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEvOT_: 544| 1.41M| { 545| 1.41M| using node_t = node_type; 546| 1.41M| auto node = p.node(); 547| 1.41M| if (node->dec()) { ------------------ | Branch (547:13): [True: 498k, False: 914k] ------------------ 548| 498k| node_t::delete_leaf(node, p.count()); 549| 498k| } 550| 1.41M| } _ZN5immer6detail4rbts11dec_visitor10visit_leafIRNS1_8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEvOT_: 544| 338k| { 545| 338k| using node_t = node_type; 546| 338k| auto node = p.node(); 547| 338k| if (node->dec()) { ------------------ | Branch (547:13): [True: 49.0k, False: 289k] ------------------ 548| 49.0k| node_t::delete_leaf(node, p.count()); 549| 49.0k| } 550| 338k| } _ZN5immer6detail4rbts11dec_visitor13visit_regularIRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEvOT_: 533| 3.13M| { 534| 3.13M| using node_t = node_type; 535| 3.13M| auto node = p.node(); 536| 3.13M| if (node->dec()) { ------------------ | Branch (536:13): [True: 77.5k, False: 3.05M] ------------------ 537| 77.5k| p.each(this_t{}); 538| 77.5k| node_t::delete_inner(node, p.count()); 539| 77.5k| } 540| 3.13M| } _ZN5immer6detail4rbts11dec_visitor13visit_regularIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEvOT_: 533| 937k| { 534| 937k| using node_t = node_type; 535| 937k| auto node = p.node(); 536| 937k| if (node->dec()) { ------------------ | Branch (536:13): [True: 900k, False: 37.5k] ------------------ 537| 900k| p.each(this_t{}); 538| 900k| node_t::delete_inner(node, p.count()); 539| 900k| } 540| 937k| } _ZN5immer6detail4rbts11dec_visitor13visit_regularIRNS1_17empty_regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEvOT_: 533| 1.20M| { 534| 1.20M| using node_t = node_type; 535| 1.20M| auto node = p.node(); 536| 1.20M| if (node->dec()) { ------------------ | Branch (536:13): [True: 0, False: 1.20M] ------------------ 537| 0| p.each(this_t{}); 538| 0| node_t::delete_inner(node, p.count()); 539| 0| } 540| 1.20M| } _ZN5immer6detail4rbts11dec_visitor10visit_leafIRNS1_12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEvOT_: 544| 28.3M| { 545| 28.3M| using node_t = node_type; 546| 28.3M| auto node = p.node(); 547| 28.3M| if (node->dec()) { ------------------ | Branch (547:13): [True: 765k, False: 27.5M] ------------------ 548| 765k| node_t::delete_leaf(node, p.count()); 549| 765k| } 550| 28.3M| } _ZN5immer6detail4rbts11dec_visitor10visit_leafIRNS1_14empty_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEvOT_: 544| 969k| { 545| 969k| using node_t = node_type; 546| 969k| auto node = p.node(); 547| 969k| if (node->dec()) { ------------------ | Branch (547:13): [True: 0, False: 969k] ------------------ 548| 0| node_t::delete_leaf(node, p.count()); 549| 0| } 550| 969k| } _ZN5immer6detail4rbts17push_tail_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13visit_relaxedIRNS1_11relaxed_posISC_EEEEPSC_OT_SI_j: 790| 341k| { 791| 341k| auto level = pos.shift(); 792| 341k| auto idx = pos.count() - 1; 793| 341k| auto children = pos.size(idx); 794| 341k| auto new_idx = 795| 341k| children == size_t{1} << level || level == BL ? idx + 1 : idx; ------------------ | Branch (795:13): [True: 3.62k, False: 338k] | Branch (795:47): [True: 81, False: 338k] ------------------ 796| 341k| auto new_child = static_cast(nullptr); 797| 341k| if (new_idx >= branches) ------------------ | Branch (797:13): [True: 822, False: 341k] ------------------ 798| 822| return nullptr; 799| 341k| else if (idx == new_idx) { ------------------ | Branch (799:18): [True: 338k, False: 2.88k] ------------------ 800| 338k| new_child = pos.last_oh_csh(this_t{}, idx, children, tail, ts); 801| 338k| if (!new_child) { ------------------ | Branch (801:17): [True: 1.01k, False: 337k] ------------------ 802| 1.01k| if (++new_idx < branches) ------------------ | Branch (802:21): [True: 784, False: 232] ------------------ 803| 784| new_child = node_t::make_path(level - B, tail); 804| 232| else 805| 232| return nullptr; 806| 1.01k| } 807| 338k| } else 808| 2.88k| new_child = node_t::make_path(level - B, tail); 809| 340k| IMMER_TRY { ------------------ | | 41| 340k|#define IMMER_TRY try ------------------ 810| 340k| auto count = new_idx + 1; 811| 340k| auto new_parent = 812| 340k| node_t::copy_inner_r_n(count, pos.node(), new_idx); 813| 340k| auto new_relaxed = new_parent->relaxed(); 814| 340k| new_parent->inner()[new_idx] = new_child; 815| 340k| new_relaxed->d.sizes[new_idx] = pos.size() + ts; 816| 340k| new_relaxed->d.count = count; 817| 340k| assert(new_relaxed->d.sizes[new_idx]); 818| 0| return new_parent; 819| 340k| } 820| 340k| IMMER_CATCH (...) { 821| 0| auto shift = pos.shift(); 822| 0| auto size = new_idx == idx ? children + ts : ts; ------------------ | Branch (822:26): [True: 0, False: 0] ------------------ 823| 0| if (shift > BL) { ------------------ | Branch (823:17): [True: 0, False: 0] ------------------ 824| 0| tail->inc(); 825| 0| dec_inner(new_child, shift - B, size); 826| 0| } 827| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 828| 0| } 829| 340k| } _ZN5immer6detail4rbts17push_tail_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13visit_regularIRNS1_15regular_sub_posISC_EEJRjEEEPSC_OT_SJ_DpOT0_: 833| 51.1k| { 834| 51.1k| assert((pos.size() & mask) == 0); 835| 0| auto idx = pos.index(pos.size() - 1); 836| 51.1k| auto new_idx = pos.index(pos.size() + branches - 1); 837| 51.1k| auto count = new_idx + 1; 838| 51.1k| auto new_parent = node_t::make_inner_n(count); 839| 51.1k| IMMER_TRY { ------------------ | | 41| 51.1k|#define IMMER_TRY try ------------------ 840| 51.1k| new_parent->inner()[new_idx] = 841| 51.1k| idx == new_idx ? pos.last_oh(this_t{}, idx, tail) ------------------ | Branch (841:17): [True: 46.7k, False: 4.34k] ------------------ 842| | /* otherwise */ 843| 51.1k| : node_t::make_path(pos.shift() - B, tail); 844| 51.1k| } 845| 51.1k| IMMER_CATCH (...) { 846| 0| node_t::delete_inner(new_parent, count); 847| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 848| 0| } 849| 51.1k| return node_t::do_copy_inner(new_parent, pos.node(), new_idx); 850| 51.1k| } _ZN5immer6detail4rbts17push_tail_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13visit_regularIRNS1_11regular_posISC_EEJEEEPSC_OT_SI_DpOT0_: 833| 893k| { 834| 893k| assert((pos.size() & mask) == 0); 835| 0| auto idx = pos.index(pos.size() - 1); 836| 893k| auto new_idx = pos.index(pos.size() + branches - 1); 837| 893k| auto count = new_idx + 1; 838| 893k| auto new_parent = node_t::make_inner_n(count); 839| 893k| IMMER_TRY { ------------------ | | 41| 893k|#define IMMER_TRY try ------------------ 840| 893k| new_parent->inner()[new_idx] = 841| 893k| idx == new_idx ? pos.last_oh(this_t{}, idx, tail) ------------------ | Branch (841:17): [True: 594k, False: 299k] ------------------ 842| | /* otherwise */ 843| 893k| : node_t::make_path(pos.shift() - B, tail); 844| 893k| } 845| 893k| IMMER_CATCH (...) { 846| 0| node_t::delete_inner(new_parent, count); 847| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 848| 0| } 849| 893k| return node_t::do_copy_inner(new_parent, pos.node(), new_idx); 850| 893k| } _ZN5immer6detail4rbts9dec_innerINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEvPT_jm: 561| 40|{ 562| 40| visit_maybe_relaxed_sub(node, shift, size, dec_visitor()); 563| 40|} _ZN5immer6detail4rbts17push_tail_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13visit_regularIRNS1_15regular_sub_posISC_EEJEEEPSC_OT_SI_DpOT0_: 833| 254k| { 834| 254k| assert((pos.size() & mask) == 0); 835| 0| auto idx = pos.index(pos.size() - 1); 836| 254k| auto new_idx = pos.index(pos.size() + branches - 1); 837| 254k| auto count = new_idx + 1; 838| 254k| auto new_parent = node_t::make_inner_n(count); 839| 254k| IMMER_TRY { ------------------ | | 41| 254k|#define IMMER_TRY try ------------------ 840| 254k| new_parent->inner()[new_idx] = 841| 254k| idx == new_idx ? pos.last_oh(this_t{}, idx, tail) ------------------ | Branch (841:17): [True: 252k, False: 1.98k] ------------------ 842| | /* otherwise */ 843| 254k| : node_t::make_path(pos.shift() - B, tail); 844| 254k| } 845| 254k| IMMER_CATCH (...) { 846| 0| node_t::delete_inner(new_parent, count); 847| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 848| 0| } 849| 254k| return node_t::do_copy_inner(new_parent, pos.node(), new_idx); 850| 254k| } flex-vector-st.cpp:_ZN5immer6detail4rbts14update_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_leafIRNS1_12leaf_sub_posISC_EERZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSL_E_EEPSC_OSL_mOT0_: 501| 269k| { 502| 269k| auto offset = pos.index(idx); 503| 269k| auto node = node_t::copy_leaf(pos.node(), pos.count()); 504| 269k| IMMER_TRY { ------------------ | | 41| 269k|#define IMMER_TRY try ------------------ 505| 269k| node->leaf()[offset] = 506| 269k| std::forward(fn)(std::move(node->leaf()[offset])); 507| 269k| return node; 508| 269k| } 509| 269k| IMMER_CATCH (...) { 510| 0| node_t::delete_leaf(node, pos.count()); 511| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 512| 0| } 513| 269k| } flex-vector-st.cpp:_ZN5immer6detail4rbts14update_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13visit_relaxedIRNS1_11relaxed_posISC_EERZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSL_E_EEPSC_OSL_mOT0_: 465| 105k| { 466| 105k| auto offset = pos.index(idx); 467| 105k| auto count = pos.count(); 468| 105k| auto node = node_t::make_inner_sr_n(count, pos.relaxed()); 469| 105k| IMMER_TRY { ------------------ | | 41| 105k|#define IMMER_TRY try ------------------ 470| 105k| auto child = pos.towards_oh(this_t{}, idx, offset, fn); 471| 105k| node_t::do_copy_inner_replace_sr( 472| 105k| node, pos.node(), count, offset, child); 473| 105k| return node; 474| 105k| } 475| 105k| IMMER_CATCH (...) { 476| 0| node_t::delete_inner_r(node, count); 477| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 478| 0| } 479| 105k| } flex-vector-st.cpp:_ZN5immer6detail4rbts14update_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13visit_regularIRNS1_15regular_sub_posISC_EERZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSL_E_EEPSC_OSL_mOT0_: 483| 61.9k| { 484| 61.9k| auto offset = pos.index(idx); 485| 61.9k| auto count = pos.count(); 486| 61.9k| auto node = node_t::make_inner_n(count); 487| 61.9k| IMMER_TRY { ------------------ | | 41| 61.9k|#define IMMER_TRY try ------------------ 488| 61.9k| auto child = pos.towards_oh_ch(this_t{}, idx, offset, count, fn); 489| 61.9k| node_t::do_copy_inner_replace( 490| 61.9k| node, pos.node(), count, offset, child); 491| 61.9k| return node; 492| 61.9k| } 493| 61.9k| IMMER_CATCH (...) { 494| 0| node_t::delete_inner(node, count); 495| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 496| 0| } 497| 61.9k| } flex-vector-st.cpp:_ZN5immer6detail4rbts14update_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_leafIRNS1_13full_leaf_posISC_EERZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSL_E_EEPSC_OSL_mOT0_: 501| 17.6k| { 502| 17.6k| auto offset = pos.index(idx); 503| 17.6k| auto node = node_t::copy_leaf(pos.node(), pos.count()); 504| 17.6k| IMMER_TRY { ------------------ | | 41| 17.6k|#define IMMER_TRY try ------------------ 505| 17.6k| node->leaf()[offset] = 506| 17.6k| std::forward(fn)(std::move(node->leaf()[offset])); 507| 17.6k| return node; 508| 17.6k| } 509| 17.6k| IMMER_CATCH (...) { 510| 0| node_t::delete_leaf(node, pos.count()); 511| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 512| 0| } 513| 17.6k| } flex-vector-st.cpp:_ZN5immer6detail4rbts14update_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13visit_regularIRNS1_8full_posISC_EERZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSL_E_EEPSC_OSL_mOT0_: 483| 469| { 484| 469| auto offset = pos.index(idx); 485| 469| auto count = pos.count(); 486| 469| auto node = node_t::make_inner_n(count); 487| 469| IMMER_TRY { ------------------ | | 41| 469|#define IMMER_TRY try ------------------ 488| 469| auto child = pos.towards_oh_ch(this_t{}, idx, offset, count, fn); 489| 469| node_t::do_copy_inner_replace( 490| 469| node, pos.node(), count, offset, child); 491| 469| return node; 492| 469| } 493| 469| IMMER_CATCH (...) { 494| 0| node_t::delete_inner(node, count); 495| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 496| 0| } 497| 469| } flex-vector-st.cpp:_ZN5immer6detail4rbts14update_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_leafIRNS1_8leaf_posISC_EERZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSL_E_EEPSC_OSL_mOT0_: 501| 44.3k| { 502| 44.3k| auto offset = pos.index(idx); 503| 44.3k| auto node = node_t::copy_leaf(pos.node(), pos.count()); 504| 44.3k| IMMER_TRY { ------------------ | | 41| 44.3k|#define IMMER_TRY try ------------------ 505| 44.3k| node->leaf()[offset] = 506| 44.3k| std::forward(fn)(std::move(node->leaf()[offset])); 507| 44.3k| return node; 508| 44.3k| } 509| 44.3k| IMMER_CATCH (...) { 510| 0| node_t::delete_leaf(node, pos.count()); 511| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 512| 0| } 513| 44.3k| } _ZN5immer6detail4rbts19slice_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EE13visit_relaxedIRNS1_11relaxed_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_m: 1095| 4.95k| { 1096| 4.95k| auto idx = pos.index(last); 1097| 4.95k| if (Collapse && idx == 0) { ------------------ | Branch (1097:13): [Folded - Ignored] | Branch (1097:25): [True: 4.29k, False: 667] ------------------ 1098| 4.29k| return pos.towards_oh(this_t{}, last, idx); 1099| 4.29k| } else { 1100| 667| using std::get; 1101| 667| auto subs = pos.towards_oh(no_collapse_t{}, last, idx); 1102| 667| auto next = get<1>(subs); 1103| 667| auto ts = get<2>(subs); 1104| 667| auto tail = get<3>(subs); 1105| 667| IMMER_TRY { ------------------ | | 41| 667|#define IMMER_TRY try ------------------ 1106| 667| if (next) { ------------------ | Branch (1106:21): [True: 537, False: 130] ------------------ 1107| 537| auto count = idx + 1; 1108| 537| auto newn = node_t::copy_inner_r_n(count, pos.node(), idx); 1109| 537| auto newr = newn->relaxed(); 1110| 537| newn->inner()[idx] = next; 1111| 537| newr->d.sizes[idx] = last + 1 - ts; 1112| 537| newr->d.count = count; 1113| 537| assert(newr->d.sizes[idx]); 1114| 0| return std::make_tuple(pos.shift(), newn, ts, tail); 1115| 537| } else if (idx == 0) { ------------------ | Branch (1115:28): [True: 0, False: 130] ------------------ 1116| 0| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1117| 130| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1117:28): [Folded - Ignored] | Branch (1117:40): [True: 19, False: 111] | Branch (1117:52): [True: 12, False: 7] ------------------ 1118| 12| auto newn = pos.node()->inner()[0]; 1119| 12| return std::make_tuple( 1120| 12| pos.shift() - B, newn->inc(), ts, tail); 1121| 118| } else { 1122| 118| auto newn = node_t::copy_inner_r(pos.node(), idx); 1123| 118| return std::make_tuple(pos.shift(), newn, ts, tail); 1124| 118| } 1125| 667| } 1126| 667| IMMER_CATCH (...) { 1127| 0| assert(!next || pos.shift() > BL); 1128| 0| if (next) ------------------ | Branch (1128:21): [True: 0, False: 0] ------------------ 1129| 0| dec_inner(next, 1130| 0| pos.shift() - B, 1131| 0| last + 1 - ts - pos.size_before(idx)); 1132| 0| if (tail) ------------------ | Branch (1132:21): [True: 0, False: 0] ------------------ 1133| 0| dec_leaf(tail, ts); 1134| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1135| 0| } 1136| 667| } 1137| 4.95k| } _ZN5immer6detail4rbts19slice_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EE10visit_leafIRNS1_12leaf_sub_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_m: 1180| 241| { 1181| 241| auto old_tail_size = pos.count(); 1182| 241| auto new_tail_size = pos.index(last) + 1; 1183| 241| auto new_tail = new_tail_size == old_tail_size ------------------ | Branch (1183:30): [True: 75, False: 166] ------------------ 1184| 241| ? pos.node()->inc() 1185| 241| : node_t::copy_leaf(pos.node(), new_tail_size); 1186| 241| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1187| 241| } _ZN5immer6detail4rbts19slice_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EE10visit_leafIRNS1_12leaf_sub_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_m: 1180| 457| { 1181| 457| auto old_tail_size = pos.count(); 1182| 457| auto new_tail_size = pos.index(last) + 1; 1183| 457| auto new_tail = new_tail_size == old_tail_size ------------------ | Branch (1183:30): [True: 57, False: 400] ------------------ 1184| 457| ? pos.node()->inc() 1185| 457| : node_t::copy_leaf(pos.node(), new_tail_size); 1186| 457| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1187| 457| } _ZN5immer6detail4rbts19slice_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EE13visit_relaxedIRNS1_11relaxed_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_m: 1095| 559| { 1096| 559| auto idx = pos.index(last); 1097| 559| if (Collapse && idx == 0) { ------------------ | Branch (1097:13): [Folded - Ignored] | Branch (1097:25): [True: 0, False: 0] ------------------ 1098| 0| return pos.towards_oh(this_t{}, last, idx); 1099| 559| } else { 1100| 559| using std::get; 1101| 559| auto subs = pos.towards_oh(no_collapse_t{}, last, idx); 1102| 559| auto next = get<1>(subs); 1103| 559| auto ts = get<2>(subs); 1104| 559| auto tail = get<3>(subs); 1105| 559| IMMER_TRY { ------------------ | | 41| 559|#define IMMER_TRY try ------------------ 1106| 559| if (next) { ------------------ | Branch (1106:21): [True: 164, False: 395] ------------------ 1107| 164| auto count = idx + 1; 1108| 164| auto newn = node_t::copy_inner_r_n(count, pos.node(), idx); 1109| 164| auto newr = newn->relaxed(); 1110| 164| newn->inner()[idx] = next; 1111| 164| newr->d.sizes[idx] = last + 1 - ts; 1112| 164| newr->d.count = count; 1113| 164| assert(newr->d.sizes[idx]); 1114| 0| return std::make_tuple(pos.shift(), newn, ts, tail); 1115| 395| } else if (idx == 0) { ------------------ | Branch (1115:28): [True: 45, False: 350] ------------------ 1116| 45| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1117| 350| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1117:28): [Folded - Ignored] | Branch (1117:40): [True: 0, False: 0] | Branch (1117:52): [True: 0, False: 0] ------------------ 1118| 0| auto newn = pos.node()->inner()[0]; 1119| 0| return std::make_tuple( 1120| 0| pos.shift() - B, newn->inc(), ts, tail); 1121| 350| } else { 1122| 350| auto newn = node_t::copy_inner_r(pos.node(), idx); 1123| 350| return std::make_tuple(pos.shift(), newn, ts, tail); 1124| 350| } 1125| 559| } 1126| 559| IMMER_CATCH (...) { 1127| 0| assert(!next || pos.shift() > BL); 1128| 0| if (next) ------------------ | Branch (1128:21): [True: 0, False: 0] ------------------ 1129| 0| dec_inner(next, 1130| 0| pos.shift() - B, 1131| 0| last + 1 - ts - pos.size_before(idx)); 1132| 0| if (tail) ------------------ | Branch (1132:21): [True: 0, False: 0] ------------------ 1133| 0| dec_leaf(tail, ts); 1134| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1135| 0| } 1136| 559| } 1137| 559| } _ZN5immer6detail4rbts19slice_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EE13visit_regularIRNS1_15regular_sub_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_m: 1141| 210| { 1142| 210| auto idx = pos.index(last); 1143| 210| if (Collapse && idx == 0) { ------------------ | Branch (1143:13): [Folded - Ignored] | Branch (1143:25): [True: 0, False: 0] ------------------ 1144| 0| return pos.towards_oh(this_t{}, last, idx); 1145| 210| } else { 1146| 210| using std::get; 1147| 210| auto subs = pos.towards_oh(no_collapse_t{}, last, idx); 1148| 210| auto next = get<1>(subs); 1149| 210| auto ts = get<2>(subs); 1150| 210| auto tail = get<3>(subs); 1151| 210| IMMER_TRY { ------------------ | | 41| 210|#define IMMER_TRY try ------------------ 1152| 210| if (next) { ------------------ | Branch (1152:21): [True: 123, False: 87] ------------------ 1153| 123| auto newn = node_t::copy_inner_n(idx + 1, pos.node(), idx); 1154| 123| newn->inner()[idx] = next; 1155| 123| return std::make_tuple(pos.shift(), newn, ts, tail); 1156| 123| } else if (idx == 0) { ------------------ | Branch (1156:28): [True: 23, False: 64] ------------------ 1157| 23| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1158| 64| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1158:28): [Folded - Ignored] | Branch (1158:40): [True: 0, False: 0] | Branch (1158:52): [True: 0, False: 0] ------------------ 1159| 0| auto newn = pos.node()->inner()[0]; 1160| 0| return std::make_tuple( 1161| 0| pos.shift() - B, newn->inc(), ts, tail); 1162| 64| } else { 1163| 64| auto newn = node_t::copy_inner_n(idx, pos.node(), idx); 1164| 64| return std::make_tuple(pos.shift(), newn, ts, tail); 1165| 64| } 1166| 210| } 1167| 210| IMMER_CATCH (...) { 1168| 0| assert(!next || pos.shift() > BL); 1169| 0| assert(tail); 1170| 0| if (next) ------------------ | Branch (1170:21): [True: 0, False: 0] ------------------ 1171| 0| dec_regular(next, pos.shift() - B, last + 1 - ts); 1172| 0| dec_leaf(tail, ts); 1173| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1174| 0| } 1175| 210| } 1176| 210| } _ZN5immer6detail4rbts19slice_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EE10visit_leafIRNS1_13full_leaf_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_m: 1180| 240| { 1181| 240| auto old_tail_size = pos.count(); 1182| 240| auto new_tail_size = pos.index(last) + 1; 1183| 240| auto new_tail = new_tail_size == old_tail_size ------------------ | Branch (1183:30): [True: 18, False: 222] ------------------ 1184| 240| ? pos.node()->inc() 1185| 240| : node_t::copy_leaf(pos.node(), new_tail_size); 1186| 240| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1187| 240| } _ZN5immer6detail4rbts19slice_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EE13visit_regularIRNS1_8full_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_m: 1141| 176| { 1142| 176| auto idx = pos.index(last); 1143| 176| if (Collapse && idx == 0) { ------------------ | Branch (1143:13): [Folded - Ignored] | Branch (1143:25): [True: 0, False: 0] ------------------ 1144| 0| return pos.towards_oh(this_t{}, last, idx); 1145| 176| } else { 1146| 176| using std::get; 1147| 176| auto subs = pos.towards_oh(no_collapse_t{}, last, idx); 1148| 176| auto next = get<1>(subs); 1149| 176| auto ts = get<2>(subs); 1150| 176| auto tail = get<3>(subs); 1151| 176| IMMER_TRY { ------------------ | | 41| 176|#define IMMER_TRY try ------------------ 1152| 176| if (next) { ------------------ | Branch (1152:21): [True: 26, False: 150] ------------------ 1153| 26| auto newn = node_t::copy_inner_n(idx + 1, pos.node(), idx); 1154| 26| newn->inner()[idx] = next; 1155| 26| return std::make_tuple(pos.shift(), newn, ts, tail); 1156| 150| } else if (idx == 0) { ------------------ | Branch (1156:28): [True: 6, False: 144] ------------------ 1157| 6| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1158| 144| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1158:28): [Folded - Ignored] | Branch (1158:40): [True: 0, False: 0] | Branch (1158:52): [True: 0, False: 0] ------------------ 1159| 0| auto newn = pos.node()->inner()[0]; 1160| 0| return std::make_tuple( 1161| 0| pos.shift() - B, newn->inc(), ts, tail); 1162| 144| } else { 1163| 144| auto newn = node_t::copy_inner_n(idx, pos.node(), idx); 1164| 144| return std::make_tuple(pos.shift(), newn, ts, tail); 1165| 144| } 1166| 176| } 1167| 176| IMMER_CATCH (...) { 1168| 0| assert(!next || pos.shift() > BL); 1169| 0| assert(tail); 1170| 0| if (next) ------------------ | Branch (1170:21): [True: 0, False: 0] ------------------ 1171| 0| dec_regular(next, pos.shift() - B, last + 1 - ts); 1172| 0| dec_leaf(tail, ts); 1173| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1174| 0| } 1175| 176| } 1176| 176| } _ZN5immer6detail4rbts19slice_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EE10visit_leafIRNS1_8leaf_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_m: 1180| 15| { 1181| 15| auto old_tail_size = pos.count(); 1182| 15| auto new_tail_size = pos.index(last) + 1; 1183| 15| auto new_tail = new_tail_size == old_tail_size ------------------ | Branch (1183:30): [True: 9, False: 6] ------------------ 1184| 15| ? pos.node()->inc() 1185| 15| : node_t::copy_leaf(pos.node(), new_tail_size); 1186| 15| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1187| 15| } _ZN5immer6detail4rbts19slice_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EE13visit_regularIRNS1_11regular_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_m: 1141| 113| { 1142| 113| auto idx = pos.index(last); 1143| 113| if (Collapse && idx == 0) { ------------------ | Branch (1143:13): [Folded - Ignored] | Branch (1143:25): [True: 0, False: 0] ------------------ 1144| 0| return pos.towards_oh(this_t{}, last, idx); 1145| 113| } else { 1146| 113| using std::get; 1147| 113| auto subs = pos.towards_oh(no_collapse_t{}, last, idx); 1148| 113| auto next = get<1>(subs); 1149| 113| auto ts = get<2>(subs); 1150| 113| auto tail = get<3>(subs); 1151| 113| IMMER_TRY { ------------------ | | 41| 113|#define IMMER_TRY try ------------------ 1152| 113| if (next) { ------------------ | Branch (1152:21): [True: 113, False: 0] ------------------ 1153| 113| auto newn = node_t::copy_inner_n(idx + 1, pos.node(), idx); 1154| 113| newn->inner()[idx] = next; 1155| 113| return std::make_tuple(pos.shift(), newn, ts, tail); 1156| 113| } else if (idx == 0) { ------------------ | Branch (1156:28): [True: 0, False: 0] ------------------ 1157| 0| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1158| 0| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1158:28): [Folded - Ignored] | Branch (1158:40): [True: 0, False: 0] | Branch (1158:52): [True: 0, False: 0] ------------------ 1159| 0| auto newn = pos.node()->inner()[0]; 1160| 0| return std::make_tuple( 1161| 0| pos.shift() - B, newn->inc(), ts, tail); 1162| 0| } else { 1163| 0| auto newn = node_t::copy_inner_n(idx, pos.node(), idx); 1164| 0| return std::make_tuple(pos.shift(), newn, ts, tail); 1165| 0| } 1166| 113| } 1167| 113| IMMER_CATCH (...) { 1168| 0| assert(!next || pos.shift() > BL); 1169| 0| assert(tail); 1170| 0| if (next) ------------------ | Branch (1170:21): [True: 0, False: 0] ------------------ 1171| 0| dec_regular(next, pos.shift() - B, last + 1 - ts); 1172| 0| dec_leaf(tail, ts); 1173| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1174| 0| } 1175| 113| } 1176| 113| } _ZN5immer6detail4rbts8dec_leafINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEvPT_j: 555| 8.71k|{ 556| 8.71k| make_leaf_sub_pos(node, n).visit(dec_visitor{}); 557| 8.71k|} _ZN5immer6detail4rbts19slice_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EE13visit_regularIRNS1_15regular_sub_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_m: 1141| 86| { 1142| 86| auto idx = pos.index(last); 1143| 86| if (Collapse && idx == 0) { ------------------ | Branch (1143:13): [Folded - Ignored] | Branch (1143:25): [True: 67, False: 19] ------------------ 1144| 67| return pos.towards_oh(this_t{}, last, idx); 1145| 67| } else { 1146| 19| using std::get; 1147| 19| auto subs = pos.towards_oh(no_collapse_t{}, last, idx); 1148| 19| auto next = get<1>(subs); 1149| 19| auto ts = get<2>(subs); 1150| 19| auto tail = get<3>(subs); 1151| 19| IMMER_TRY { ------------------ | | 41| 19|#define IMMER_TRY try ------------------ 1152| 19| if (next) { ------------------ | Branch (1152:21): [True: 0, False: 19] ------------------ 1153| 0| auto newn = node_t::copy_inner_n(idx + 1, pos.node(), idx); 1154| 0| newn->inner()[idx] = next; 1155| 0| return std::make_tuple(pos.shift(), newn, ts, tail); 1156| 19| } else if (idx == 0) { ------------------ | Branch (1156:28): [True: 0, False: 19] ------------------ 1157| 0| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1158| 19| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1158:28): [Folded - Ignored] | Branch (1158:40): [True: 15, False: 4] | Branch (1158:52): [True: 1, False: 14] ------------------ 1159| 1| auto newn = pos.node()->inner()[0]; 1160| 1| return std::make_tuple( 1161| 1| pos.shift() - B, newn->inc(), ts, tail); 1162| 18| } else { 1163| 18| auto newn = node_t::copy_inner_n(idx, pos.node(), idx); 1164| 18| return std::make_tuple(pos.shift(), newn, ts, tail); 1165| 18| } 1166| 19| } 1167| 19| IMMER_CATCH (...) { 1168| 0| assert(!next || pos.shift() > BL); 1169| 0| assert(tail); 1170| 0| if (next) ------------------ | Branch (1170:21): [True: 0, False: 0] ------------------ 1171| 0| dec_regular(next, pos.shift() - B, last + 1 - ts); 1172| 0| dec_leaf(tail, ts); 1173| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1174| 0| } 1175| 19| } 1176| 86| } _ZN5immer6detail4rbts19slice_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EE10visit_leafIRNS1_13full_leaf_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_m: 1180| 39| { 1181| 39| auto old_tail_size = pos.count(); 1182| 39| auto new_tail_size = pos.index(last) + 1; 1183| 39| auto new_tail = new_tail_size == old_tail_size ------------------ | Branch (1183:30): [True: 0, False: 39] ------------------ 1184| 39| ? pos.node()->inc() 1185| 39| : node_t::copy_leaf(pos.node(), new_tail_size); 1186| 39| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1187| 39| } _ZN5immer6detail4rbts19slice_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EE13visit_regularIRNS1_8full_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_m: 1141| 142| { 1142| 142| auto idx = pos.index(last); 1143| 142| if (Collapse && idx == 0) { ------------------ | Branch (1143:13): [Folded - Ignored] | Branch (1143:25): [True: 116, False: 26] ------------------ 1144| 116| return pos.towards_oh(this_t{}, last, idx); 1145| 116| } else { 1146| 26| using std::get; 1147| 26| auto subs = pos.towards_oh(no_collapse_t{}, last, idx); 1148| 26| auto next = get<1>(subs); 1149| 26| auto ts = get<2>(subs); 1150| 26| auto tail = get<3>(subs); 1151| 26| IMMER_TRY { ------------------ | | 41| 26|#define IMMER_TRY try ------------------ 1152| 26| if (next) { ------------------ | Branch (1152:21): [True: 21, False: 5] ------------------ 1153| 21| auto newn = node_t::copy_inner_n(idx + 1, pos.node(), idx); 1154| 21| newn->inner()[idx] = next; 1155| 21| return std::make_tuple(pos.shift(), newn, ts, tail); 1156| 21| } else if (idx == 0) { ------------------ | Branch (1156:28): [True: 0, False: 5] ------------------ 1157| 0| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1158| 5| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1158:28): [Folded - Ignored] | Branch (1158:40): [True: 5, False: 0] | Branch (1158:52): [True: 5, False: 0] ------------------ 1159| 5| auto newn = pos.node()->inner()[0]; 1160| 5| return std::make_tuple( 1161| 5| pos.shift() - B, newn->inc(), ts, tail); 1162| 5| } else { 1163| 0| auto newn = node_t::copy_inner_n(idx, pos.node(), idx); 1164| 0| return std::make_tuple(pos.shift(), newn, ts, tail); 1165| 0| } 1166| 26| } 1167| 26| IMMER_CATCH (...) { 1168| 0| assert(!next || pos.shift() > BL); 1169| 0| assert(tail); 1170| 0| if (next) ------------------ | Branch (1170:21): [True: 0, False: 0] ------------------ 1171| 0| dec_regular(next, pos.shift() - B, last + 1 - ts); 1172| 0| dec_leaf(tail, ts); 1173| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1174| 0| } 1175| 26| } 1176| 142| } _ZN5immer6detail4rbts19slice_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EE10visit_leafIRNS1_8leaf_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_m: 1180| 2| { 1181| 2| auto old_tail_size = pos.count(); 1182| 2| auto new_tail_size = pos.index(last) + 1; 1183| 2| auto new_tail = new_tail_size == old_tail_size ------------------ | Branch (1183:30): [True: 0, False: 2] ------------------ 1184| 2| ? pos.node()->inc() 1185| 2| : node_t::copy_leaf(pos.node(), new_tail_size); 1186| 2| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1187| 2| } _ZN5immer6detail4rbts18slice_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EE11visit_innerIRNS1_11relaxed_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_m: 1413| 1.11k| { 1414| 1.11k| auto idx = pos.subindex(first); 1415| 1.11k| auto count = pos.count(); 1416| 1.11k| auto left_size = pos.size_before(idx); 1417| 1.11k| auto child_size = pos.size_sbh(idx, left_size); 1418| 1.11k| auto dropped_size = first; 1419| 1.11k| auto child_dropped_size = dropped_size - left_size; 1420| 1.11k| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1420:13): [Folded - Ignored] | Branch (1420:25): [True: 1.10k, False: 11] | Branch (1420:45): [True: 136, False: 971] ------------------ 1421| 136| return pos.towards_sub_oh(this_t{}, first, idx); 1422| 982| } else { 1423| 982| using std::get; 1424| 982| auto n = pos.node(); 1425| 982| auto newc = count - idx; 1426| 982| auto newn = node_t::make_inner_r_n(newc); 1427| 982| IMMER_TRY { ------------------ | | 41| 982|#define IMMER_TRY try ------------------ 1428| 982| auto subs = pos.towards_sub_oh(no_collapse_t{}, first, idx); 1429| 982| auto newr = newn->relaxed(); 1430| 982| newr->d.count = count - idx; 1431| 982| newr->d.sizes[0] = child_size - child_dropped_size; 1432| 982| assert(newr->d.sizes[0]); 1433| 0| pos.copy_sizes(idx + 1, 1434| 982| newr->d.count - 1, 1435| 982| newr->d.sizes[0], 1436| 982| newr->d.sizes + 1); 1437| 982| assert(newr->d.sizes[newr->d.count - 1] == 1438| 982| pos.size() - dropped_size); 1439| 0| newn->inner()[0] = get<1>(subs); 1440| 982| std::copy(n->inner() + idx + 1, 1441| 982| n->inner() + count, 1442| 982| newn->inner() + 1); 1443| 982| node_t::inc_nodes(newn->inner() + 1, newr->d.count - 1); 1444| 982| return std::make_tuple(pos.shift(), newn); 1445| 982| } 1446| 982| IMMER_CATCH (...) { 1447| 0| node_t::delete_inner_r(newn, newc); 1448| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1449| 0| } 1450| 982| } 1451| 1.11k| } _ZN5immer6detail4rbts18slice_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EE10visit_leafIRNS1_12leaf_sub_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_m: 1455| 851| { 1456| 851| auto n = node_t::copy_leaf(pos.node(), pos.index(first), pos.count()); 1457| 851| return std::make_tuple(0, n); 1458| 851| } _ZN5immer6detail4rbts18slice_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EE11visit_innerIRNS1_11relaxed_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_m: 1413| 6.00k| { 1414| 6.00k| auto idx = pos.subindex(first); 1415| 6.00k| auto count = pos.count(); 1416| 6.00k| auto left_size = pos.size_before(idx); 1417| 6.00k| auto child_size = pos.size_sbh(idx, left_size); 1418| 6.00k| auto dropped_size = first; 1419| 6.00k| auto child_dropped_size = dropped_size - left_size; 1420| 6.00k| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1420:13): [Folded - Ignored] | Branch (1420:25): [True: 0, False: 0] | Branch (1420:45): [True: 0, False: 0] ------------------ 1421| 0| return pos.towards_sub_oh(this_t{}, first, idx); 1422| 6.00k| } else { 1423| 6.00k| using std::get; 1424| 6.00k| auto n = pos.node(); 1425| 6.00k| auto newc = count - idx; 1426| 6.00k| auto newn = node_t::make_inner_r_n(newc); 1427| 6.00k| IMMER_TRY { ------------------ | | 41| 6.00k|#define IMMER_TRY try ------------------ 1428| 6.00k| auto subs = pos.towards_sub_oh(no_collapse_t{}, first, idx); 1429| 6.00k| auto newr = newn->relaxed(); 1430| 6.00k| newr->d.count = count - idx; 1431| 6.00k| newr->d.sizes[0] = child_size - child_dropped_size; 1432| 6.00k| assert(newr->d.sizes[0]); 1433| 0| pos.copy_sizes(idx + 1, 1434| 6.00k| newr->d.count - 1, 1435| 6.00k| newr->d.sizes[0], 1436| 6.00k| newr->d.sizes + 1); 1437| 6.00k| assert(newr->d.sizes[newr->d.count - 1] == 1438| 6.00k| pos.size() - dropped_size); 1439| 0| newn->inner()[0] = get<1>(subs); 1440| 6.00k| std::copy(n->inner() + idx + 1, 1441| 6.00k| n->inner() + count, 1442| 6.00k| newn->inner() + 1); 1443| 6.00k| node_t::inc_nodes(newn->inner() + 1, newr->d.count - 1); 1444| 6.00k| return std::make_tuple(pos.shift(), newn); 1445| 6.00k| } 1446| 6.00k| IMMER_CATCH (...) { 1447| 0| node_t::delete_inner_r(newn, newc); 1448| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1449| 0| } 1450| 6.00k| } 1451| 6.00k| } _ZN5immer6detail4rbts18slice_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EE11visit_innerIRNS1_15regular_sub_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_m: 1413| 131| { 1414| 131| auto idx = pos.subindex(first); 1415| 131| auto count = pos.count(); 1416| 131| auto left_size = pos.size_before(idx); 1417| 131| auto child_size = pos.size_sbh(idx, left_size); 1418| 131| auto dropped_size = first; 1419| 131| auto child_dropped_size = dropped_size - left_size; 1420| 131| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1420:13): [Folded - Ignored] | Branch (1420:25): [True: 0, False: 0] | Branch (1420:45): [True: 0, False: 0] ------------------ 1421| 0| return pos.towards_sub_oh(this_t{}, first, idx); 1422| 131| } else { 1423| 131| using std::get; 1424| 131| auto n = pos.node(); 1425| 131| auto newc = count - idx; 1426| 131| auto newn = node_t::make_inner_r_n(newc); 1427| 131| IMMER_TRY { ------------------ | | 41| 131|#define IMMER_TRY try ------------------ 1428| 131| auto subs = pos.towards_sub_oh(no_collapse_t{}, first, idx); 1429| 131| auto newr = newn->relaxed(); 1430| 131| newr->d.count = count - idx; 1431| 131| newr->d.sizes[0] = child_size - child_dropped_size; 1432| 131| assert(newr->d.sizes[0]); 1433| 0| pos.copy_sizes(idx + 1, 1434| 131| newr->d.count - 1, 1435| 131| newr->d.sizes[0], 1436| 131| newr->d.sizes + 1); 1437| 131| assert(newr->d.sizes[newr->d.count - 1] == 1438| 131| pos.size() - dropped_size); 1439| 0| newn->inner()[0] = get<1>(subs); 1440| 131| std::copy(n->inner() + idx + 1, 1441| 131| n->inner() + count, 1442| 131| newn->inner() + 1); 1443| 131| node_t::inc_nodes(newn->inner() + 1, newr->d.count - 1); 1444| 131| return std::make_tuple(pos.shift(), newn); 1445| 131| } 1446| 131| IMMER_CATCH (...) { 1447| 0| node_t::delete_inner_r(newn, newc); 1448| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1449| 0| } 1450| 131| } 1451| 131| } _ZN5immer6detail4rbts18slice_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EE10visit_leafIRNS1_13full_leaf_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_m: 1455| 318| { 1456| 318| auto n = node_t::copy_leaf(pos.node(), pos.index(first), pos.count()); 1457| 318| return std::make_tuple(0, n); 1458| 318| } _ZN5immer6detail4rbts18slice_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EE11visit_innerIRNS1_8full_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_m: 1413| 342| { 1414| 342| auto idx = pos.subindex(first); 1415| 342| auto count = pos.count(); 1416| 342| auto left_size = pos.size_before(idx); 1417| 342| auto child_size = pos.size_sbh(idx, left_size); 1418| 342| auto dropped_size = first; 1419| 342| auto child_dropped_size = dropped_size - left_size; 1420| 342| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1420:13): [Folded - Ignored] | Branch (1420:25): [True: 0, False: 0] | Branch (1420:45): [True: 0, False: 0] ------------------ 1421| 0| return pos.towards_sub_oh(this_t{}, first, idx); 1422| 342| } else { 1423| 342| using std::get; 1424| 342| auto n = pos.node(); 1425| 342| auto newc = count - idx; 1426| 342| auto newn = node_t::make_inner_r_n(newc); 1427| 342| IMMER_TRY { ------------------ | | 41| 342|#define IMMER_TRY try ------------------ 1428| 342| auto subs = pos.towards_sub_oh(no_collapse_t{}, first, idx); 1429| 342| auto newr = newn->relaxed(); 1430| 342| newr->d.count = count - idx; 1431| 342| newr->d.sizes[0] = child_size - child_dropped_size; 1432| 342| assert(newr->d.sizes[0]); 1433| 0| pos.copy_sizes(idx + 1, 1434| 342| newr->d.count - 1, 1435| 342| newr->d.sizes[0], 1436| 342| newr->d.sizes + 1); 1437| 342| assert(newr->d.sizes[newr->d.count - 1] == 1438| 342| pos.size() - dropped_size); 1439| 0| newn->inner()[0] = get<1>(subs); 1440| 342| std::copy(n->inner() + idx + 1, 1441| 342| n->inner() + count, 1442| 342| newn->inner() + 1); 1443| 342| node_t::inc_nodes(newn->inner() + 1, newr->d.count - 1); 1444| 342| return std::make_tuple(pos.shift(), newn); 1445| 342| } 1446| 342| IMMER_CATCH (...) { 1447| 0| node_t::delete_inner_r(newn, newc); 1448| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1449| 0| } 1450| 342| } 1451| 342| } _ZN5immer6detail4rbts18slice_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EE11visit_innerIRNS1_15regular_sub_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_m: 1413| 191| { 1414| 191| auto idx = pos.subindex(first); 1415| 191| auto count = pos.count(); 1416| 191| auto left_size = pos.size_before(idx); 1417| 191| auto child_size = pos.size_sbh(idx, left_size); 1418| 191| auto dropped_size = first; 1419| 191| auto child_dropped_size = dropped_size - left_size; 1420| 191| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1420:13): [Folded - Ignored] | Branch (1420:25): [True: 177, False: 14] | Branch (1420:45): [True: 113, False: 64] ------------------ 1421| 113| return pos.towards_sub_oh(this_t{}, first, idx); 1422| 113| } else { 1423| 78| using std::get; 1424| 78| auto n = pos.node(); 1425| 78| auto newc = count - idx; 1426| 78| auto newn = node_t::make_inner_r_n(newc); 1427| 78| IMMER_TRY { ------------------ | | 41| 78|#define IMMER_TRY try ------------------ 1428| 78| auto subs = pos.towards_sub_oh(no_collapse_t{}, first, idx); 1429| 78| auto newr = newn->relaxed(); 1430| 78| newr->d.count = count - idx; 1431| 78| newr->d.sizes[0] = child_size - child_dropped_size; 1432| 78| assert(newr->d.sizes[0]); 1433| 0| pos.copy_sizes(idx + 1, 1434| 78| newr->d.count - 1, 1435| 78| newr->d.sizes[0], 1436| 78| newr->d.sizes + 1); 1437| 78| assert(newr->d.sizes[newr->d.count - 1] == 1438| 78| pos.size() - dropped_size); 1439| 0| newn->inner()[0] = get<1>(subs); 1440| 78| std::copy(n->inner() + idx + 1, 1441| 78| n->inner() + count, 1442| 78| newn->inner() + 1); 1443| 78| node_t::inc_nodes(newn->inner() + 1, newr->d.count - 1); 1444| 78| return std::make_tuple(pos.shift(), newn); 1445| 78| } 1446| 78| IMMER_CATCH (...) { 1447| 0| node_t::delete_inner_r(newn, newc); 1448| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1449| 0| } 1450| 78| } 1451| 191| } _ZN5immer6detail4rbts18slice_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EE11visit_innerIRNS1_8full_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_m: 1413| 109| { 1414| 109| auto idx = pos.subindex(first); 1415| 109| auto count = pos.count(); 1416| 109| auto left_size = pos.size_before(idx); 1417| 109| auto child_size = pos.size_sbh(idx, left_size); 1418| 109| auto dropped_size = first; 1419| 109| auto child_dropped_size = dropped_size - left_size; 1420| 109| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1420:13): [Folded - Ignored] | Branch (1420:25): [True: 109, False: 0] | Branch (1420:45): [True: 0, False: 109] ------------------ 1421| 0| return pos.towards_sub_oh(this_t{}, first, idx); 1422| 109| } else { 1423| 109| using std::get; 1424| 109| auto n = pos.node(); 1425| 109| auto newc = count - idx; 1426| 109| auto newn = node_t::make_inner_r_n(newc); 1427| 109| IMMER_TRY { ------------------ | | 41| 109|#define IMMER_TRY try ------------------ 1428| 109| auto subs = pos.towards_sub_oh(no_collapse_t{}, first, idx); 1429| 109| auto newr = newn->relaxed(); 1430| 109| newr->d.count = count - idx; 1431| 109| newr->d.sizes[0] = child_size - child_dropped_size; 1432| 109| assert(newr->d.sizes[0]); 1433| 0| pos.copy_sizes(idx + 1, 1434| 109| newr->d.count - 1, 1435| 109| newr->d.sizes[0], 1436| 109| newr->d.sizes + 1); 1437| 109| assert(newr->d.sizes[newr->d.count - 1] == 1438| 109| pos.size() - dropped_size); 1439| 0| newn->inner()[0] = get<1>(subs); 1440| 109| std::copy(n->inner() + idx + 1, 1441| 109| n->inner() + count, 1442| 109| newn->inner() + 1); 1443| 109| node_t::inc_nodes(newn->inner() + 1, newr->d.count - 1); 1444| 109| return std::make_tuple(pos.shift(), newn); 1445| 109| } 1446| 109| IMMER_CATCH (...) { 1447| 0| node_t::delete_inner_r(newn, newc); 1448| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1449| 0| } 1450| 109| } 1451| 109| } _ZN5immer6detail4rbts12concat_treesINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_11relaxed_posIT_EEPSE_jSG_jm: 1996| 1.12k|{ 1997| 1.12k| return make_singleton_regular_sub_pos(ltail, ltcount) 1998| 1.12k| .visit(concat_trees_left_visitor{}, 1999| 1.12k| empty_leaf_pos{}, 2000| 1.12k| rroot, 2001| 1.12k| rshift, 2002| 1.12k| rsize) 2003| 1.12k| .realize(); 2004| 1.12k|} _ZN5immer6detail4rbts25concat_trees_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_nodeIRNS1_25singleton_regular_sub_posISC_EENS1_14empty_leaf_posISC_EEJRPSC_RjRmEEENS1_17concat_center_posISC_EEOT_OT0_DpOT1_: 1966| 1.12k| { 1967| 1.12k| return visit_maybe_relaxed_sub( 1968| 1.12k| args..., concat_trees_right_visitor{}, lpos, tpos); 1969| 1.12k| } _ZN5immer6detail4rbts26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_nodeIRNS1_11relaxed_posISC_EERNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1953| 1.05k| { 1954| 1.05k| return concat_inners(lpos, tpos, rpos); 1955| 1.05k| } _ZN5immer6detail4rbts13concat_innersINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EERNS1_11relaxed_posISC_EEEENS1_17concat_center_posIT_EEOT0_OT1_OT2_: 1867| 10.5k|{ 1868| 10.5k| auto lshift = lpos.shift(); 1869| 10.5k| auto rshift = rpos.shift(); 1870| 10.5k| if (lshift > rshift) { ------------------ | Branch (1870:9): [True: 0, False: 10.5k] ------------------ 1871| 0| auto cpos = lpos.last_sub(concat_left_visitor{}, tpos, rpos); 1872| 0| return concat_rebalance(lpos, cpos, null_sub_pos{}); 1873| 10.5k| } else if (lshift < rshift) { ------------------ | Branch (1873:16): [True: 9.58k, False: 925] ------------------ 1874| 9.58k| auto cpos = rpos.first_sub(concat_right_visitor{}, lpos, tpos); 1875| 9.58k| return concat_rebalance(null_sub_pos{}, cpos, rpos); 1876| 9.58k| } else { 1877| 925| assert(lshift == rshift); 1878| 0| assert(Node::bits_leaf == 0u || lshift > 0); 1879| 0| auto cpos = lpos.last_sub(concat_both_visitor{}, tpos, rpos); 1880| 925| return concat_rebalance(lpos, cpos, rpos); 1881| 925| } 1882| 10.5k|} _ZN5immer6detail4rbts17concat_center_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8each_subINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEvT_DpOT0_: 1508| 6.53M| { 1509| 6.53M| if (shift_ == BL) { ------------------ | Branch (1509:13): [True: 483k, False: 6.05M] ------------------ 1510| 483k| auto s = size_t{}; 1511| 1.93M| for (auto i = count_t{0}; i < count_; ++i) { ------------------ | Branch (1511:39): [True: 1.44M, False: 483k] ------------------ 1512| 1.44M| make_leaf_sub_pos(nodes_[i], sizes_[i] - s).visit(v, args...); 1513| 1.44M| s = sizes_[i]; 1514| 1.44M| } 1515| 6.05M| } else { 1516| 16.2M| for (auto i = count_t{0}; i < count_; ++i) ------------------ | Branch (1516:39): [True: 10.2M, False: 6.05M] ------------------ 1517| 10.2M| make_relaxed_pos(nodes_[i], shift_ - B, nodes_[i]->relaxed()) 1518| 10.2M| .visit(v, args...); 1519| 6.05M| } 1520| 6.53M| } _ZN5immer6detail4rbts34concat_rebalance_plan_fill_visitor10visit_nodeIRNS1_12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_21concat_rebalance_planILj3ELj3EEEEEvOT_RT0_: 1728| 5.28M| { 1729| 5.28M| auto count = p.count(); 1730| 5.28M| assert(plan.n < Plan::max_children); 1731| 0| plan.counts[plan.n++] = count; 1732| 5.28M| plan.total += count; 1733| 5.28M| } _ZN5immer6detail4rbts34concat_rebalance_plan_fill_visitor10visit_nodeIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_21concat_rebalance_planILj3ELj3EEEEEvOT_RT0_: 1728| 58.7M| { 1729| 58.7M| auto count = p.count(); 1730| 58.7M| assert(plan.n < Plan::max_children); 1731| 0| plan.counts[plan.n++] = count; 1732| 58.7M| plan.total += count; 1733| 58.7M| } _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE7shuffleEj: 1757| 6.53M| { 1758| | // gcc seems to not really understand this code... :( 1759| 6.53M|#if !defined(_MSC_VER) 1760| 6.53M|#pragma GCC diagnostic push 1761| 6.53M|#pragma GCC diagnostic ignored "-Warray-bounds" 1762| 6.53M|#endif 1763| 6.53M| constexpr count_t rrb_extras = 2; 1764| 6.53M| constexpr count_t rrb_invariant = 1; 1765| 6.53M| const auto bits = shift == BL ? BL : B; ------------------ | Branch (1765:43): [True: 483k, False: 6.05M] ------------------ 1766| 6.53M| const auto branches = count_t{1} << bits; 1767| 6.53M| const auto optimal = ((total - 1) >> bits) + 1; 1768| 6.53M| count_t i = 0; 1769| 8.47M| while (n >= optimal + rrb_extras) { ------------------ | Branch (1769:16): [True: 1.94M, False: 6.53M] ------------------ 1770| | // skip ok nodes 1771| 4.35M| while (counts[i] > branches - rrb_invariant) ------------------ | Branch (1771:20): [True: 2.41M, False: 1.94M] ------------------ 1772| 2.41M| i++; 1773| 1.94M| assert(i < n); 1774| | // short node, redistribute 1775| 0| auto remaining = counts[i]; 1776| 7.52M| do { 1777| 7.52M| auto next = counts[i + 1]; 1778| 7.52M| auto count = std::min(remaining + next, branches); 1779| 7.52M| counts[i] = count; 1780| 7.52M| assert(counts[i]); 1781| 0| remaining += next - count; 1782| 7.52M| ++i; 1783| 7.52M| } while (remaining > 0); ------------------ | Branch (1783:22): [True: 5.58M, False: 1.94M] ------------------ 1784| | // remove node 1785| 0| std::move(counts + i + 1, counts + n, counts + i); 1786| 1.94M| --n; 1787| 1.94M| --i; 1788| 1.94M| } 1789| 6.53M|#if !defined(_MSC_VER) 1790| 6.53M|#pragma GCC diagnostic pop 1791| 6.53M|#endif 1792| 6.53M| } _ZNK5immer6detail4rbts17concat_center_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5shiftEv: 1477| 13.0M| auto shift() const { return shift_; } _ZN5immer6detail4rbts13concat_mergerINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEC2EjPjj: 1577| 6.53M| {} _ZN5immer6detail4rbts17concat_center_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEC2EjPSC_m: 1484| 6.53M| {} _ZN5immer6detail4rbts17concat_center_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8each_subINS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEvT_DpOT0_: 1508| 6.53M| { 1509| 6.53M| if (shift_ == BL) { ------------------ | Branch (1509:13): [True: 483k, False: 6.05M] ------------------ 1510| 483k| auto s = size_t{}; 1511| 1.93M| for (auto i = count_t{0}; i < count_; ++i) { ------------------ | Branch (1511:39): [True: 1.44M, False: 483k] ------------------ 1512| 1.44M| make_leaf_sub_pos(nodes_[i], sizes_[i] - s).visit(v, args...); 1513| 1.44M| s = sizes_[i]; 1514| 1.44M| } 1515| 6.05M| } else { 1516| 16.2M| for (auto i = count_t{0}; i < count_; ++i) ------------------ | Branch (1516:39): [True: 10.2M, False: 6.05M] ------------------ 1517| 10.2M| make_relaxed_pos(nodes_[i], shift_ - B, nodes_[i]->relaxed()) 1518| 10.2M| .visit(v, args...); 1519| 6.05M| } 1520| 6.53M| } _ZN5immer6detail4rbts21concat_merger_visitor10visit_leafIRNS1_12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_13concat_mergerISE_EEEEvOT_RT0_: 1716| 5.28M| { 1717| 5.28M| merger.merge_leaf(p); 1718| 5.28M| } _ZN5immer6detail4rbts13concat_mergerINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10merge_leafIRNS1_12leaf_sub_posISC_EEEEvOT_: 1609| 5.28M| { 1610| 5.28M| auto from = p.node(); 1611| 5.28M| auto from_size = p.size(); 1612| 5.28M| auto from_count = p.count(); 1613| 5.28M| assert(from_size); 1614| 5.28M| if (!to_ && *curr_ == from_count) { ------------------ | Branch (1614:13): [True: 5.22M, False: 53.1k] | Branch (1614:21): [True: 5.20M, False: 22.0k] ------------------ 1615| 5.20M| add_child(from, from_size); 1616| 5.20M| from->inc(); 1617| 5.20M| } else { 1618| 75.2k| auto from_offset = count_t{}; 1619| 75.2k| auto from_data = from->leaf(); 1620| 104k| do { 1621| 104k| if (!to_) { ------------------ | Branch (1621:21): [True: 51.2k, False: 53.1k] ------------------ 1622| 51.2k| to_ = node_t::make_leaf_n(*curr_); 1623| 51.2k| to_offset_ = 0; 1624| 51.2k| } 1625| 104k| auto data = to_->leaf(); 1626| 104k| auto to_copy = 1627| 104k| std::min(from_count - from_offset, *curr_ - to_offset_); 1628| 104k| detail::uninitialized_copy(from_data + from_offset, 1629| 104k| from_data + from_offset + to_copy, 1630| 104k| data + to_offset_); 1631| 104k| to_offset_ += to_copy; 1632| 104k| from_offset += to_copy; 1633| 104k| if (*curr_ == to_offset_) { ------------------ | Branch (1633:21): [True: 51.2k, False: 53.1k] ------------------ 1634| 51.2k| add_child(to_, to_offset_); 1635| 51.2k| to_ = nullptr; 1636| 51.2k| } 1637| 104k| } while (from_offset != from_count); ------------------ | Branch (1637:22): [True: 29.2k, False: 75.2k] ------------------ 1638| 75.2k| } 1639| 5.28M| } _ZN5immer6detail4rbts13concat_mergerINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9add_childEPSC_m: 1584| 63.7M| { 1585| 63.7M| assert(size); 1586| 0| ++curr_; 1587| 63.7M| auto parent = result_.nodes_[result_.count_ - 1]; 1588| 63.7M| auto relaxed = parent->relaxed(); 1589| 63.7M| if (relaxed->d.count == branches) { ------------------ | Branch (1589:13): [True: 4.19M, False: 59.5M] ------------------ 1590| 4.19M| assert(result_.count_ < result_t::max_children); 1591| 0| n_ -= branches; 1592| 4.19M| parent = node_t::make_inner_r_n(std::min(n_, branches)); 1593| 4.19M| relaxed = parent->relaxed(); 1594| 4.19M| result_.nodes_[result_.count_] = parent; 1595| 4.19M| result_.sizes_[result_.count_] = result_.sizes_[result_.count_ - 1]; 1596| 4.19M| assert(result_.sizes_[result_.count_]); 1597| 0| ++result_.count_; 1598| 4.19M| } 1599| 0| auto idx = relaxed->d.count++; 1600| 63.7M| result_.sizes_[result_.count_ - 1] += size; 1601| 63.7M| assert(result_.sizes_[result_.count_ - 1]); 1602| 63.7M| relaxed->d.sizes[idx] = size + (idx ? relaxed->d.sizes[idx - 1] : 0); ------------------ | Branch (1602:41): [True: 52.9M, False: 10.7M] ------------------ 1603| 63.7M| assert(relaxed->d.sizes[idx]); 1604| 0| parent->inner()[idx] = p; 1605| 63.7M| }; _ZN5immer6detail4rbts21concat_merger_visitor11visit_innerIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_13concat_mergerISE_EEEEvOT_RT0_: 1710| 58.7M| { 1711| 58.7M| merger.merge_inner(p); 1712| 58.7M| } _ZN5immer6detail4rbts13concat_mergerINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11merge_innerIRNS1_11relaxed_posISC_EEEEvOT_: 1643| 58.7M| { 1644| 58.7M| auto from = p.node(); 1645| 58.7M| auto from_size = p.size(); 1646| 58.7M| auto from_count = p.count(); 1647| 58.7M| assert(from_size); 1648| 58.7M| if (!to_ && *curr_ == from_count) { ------------------ | Branch (1648:13): [True: 51.5M, False: 7.22M] | Branch (1648:21): [True: 50.0M, False: 1.48M] ------------------ 1649| 50.0M| add_child(from, from_size); 1650| 50.0M| from->inc(); 1651| 50.0M| } else { 1652| 8.70M| auto from_offset = count_t{}; 1653| 8.70M| auto from_data = from->inner(); 1654| 14.0M| do { 1655| 14.0M| if (!to_) { ------------------ | Branch (1655:21): [True: 6.78M, False: 7.22M] ------------------ 1656| 6.78M| to_ = node_t::make_inner_r_n(*curr_); 1657| 6.78M| to_offset_ = 0; 1658| 6.78M| to_size_ = 0; 1659| 6.78M| } 1660| 14.0M| auto data = to_->inner(); 1661| 14.0M| auto to_copy = 1662| 14.0M| std::min(from_count - from_offset, *curr_ - to_offset_); 1663| 14.0M| std::copy(from_data + from_offset, 1664| 14.0M| from_data + from_offset + to_copy, 1665| 14.0M| data + to_offset_); 1666| 14.0M| node_t::inc_nodes(from_data + from_offset, to_copy); 1667| 14.0M| auto sizes = to_->relaxed()->d.sizes; 1668| 14.0M| p.copy_sizes( 1669| 14.0M| from_offset, to_copy, to_size_, sizes + to_offset_); 1670| 14.0M| to_offset_ += to_copy; 1671| 14.0M| from_offset += to_copy; 1672| 14.0M| to_size_ = sizes[to_offset_ - 1]; 1673| 14.0M| assert(to_size_); 1674| 14.0M| if (*curr_ == to_offset_) { ------------------ | Branch (1674:21): [True: 6.78M, False: 7.22M] ------------------ 1675| 6.78M| to_->relaxed()->d.count = to_offset_; 1676| 6.78M| add_child(to_, to_size_); 1677| 6.78M| to_ = nullptr; 1678| 6.78M| } 1679| 14.0M| } while (from_offset != from_count); ------------------ | Branch (1679:22): [True: 5.30M, False: 8.70M] ------------------ 1680| 8.70M| } 1681| 58.7M| } _ZNK5immer6detail4rbts13concat_mergerINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE6finishEv: 1684| 6.53M| { 1685| 6.53M| assert(!to_); 1686| 0| return result_; 1687| 6.53M| } _ZN5immer6detail4rbts17concat_center_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8each_subINS1_11dec_visitorEJEEEvT_DpOT0_: 1508| 6.53M| { 1509| 6.53M| if (shift_ == BL) { ------------------ | Branch (1509:13): [True: 483k, False: 6.05M] ------------------ 1510| 483k| auto s = size_t{}; 1511| 1.93M| for (auto i = count_t{0}; i < count_; ++i) { ------------------ | Branch (1511:39): [True: 1.44M, False: 483k] ------------------ 1512| 1.44M| make_leaf_sub_pos(nodes_[i], sizes_[i] - s).visit(v, args...); 1513| 1.44M| s = sizes_[i]; 1514| 1.44M| } 1515| 6.05M| } else { 1516| 16.2M| for (auto i = count_t{0}; i < count_; ++i) ------------------ | Branch (1516:39): [True: 10.2M, False: 6.05M] ------------------ 1517| 10.2M| make_relaxed_pos(nodes_[i], shift_ - B, nodes_[i]->relaxed()) 1518| 10.2M| .visit(v, args...); 1519| 6.05M| } 1520| 6.53M| } _ZN5immer6detail4rbts17concat_center_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEC2EjPSC_mSE_mSE_m: 1504| 482k| {} _ZN5immer6detail4rbts17concat_center_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEC2EjPSC_mSE_m: 1491| 1.12k| {} _ZN5immer6detail4rbts20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_11relaxed_posISC_EERNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1912| 9.45k| { 1913| 9.45k| return concat_inners(lpos, tpos, rpos); 1914| 9.45k| } _ZN5immer6detail4rbts20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_15regular_sub_posISC_EERNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1912| 129| { 1913| 129| return concat_inners(lpos, tpos, rpos); 1914| 129| } _ZN5immer6detail4rbts13concat_innersINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EERNS1_15regular_sub_posISC_EEEENS1_17concat_center_posIT_EEOT0_OT1_OT2_: 1867| 202|{ 1868| 202| auto lshift = lpos.shift(); 1869| 202| auto rshift = rpos.shift(); 1870| 202| if (lshift > rshift) { ------------------ | Branch (1870:9): [True: 0, False: 202] ------------------ 1871| 0| auto cpos = lpos.last_sub(concat_left_visitor{}, tpos, rpos); 1872| 0| return concat_rebalance(lpos, cpos, null_sub_pos{}); 1873| 202| } else if (lshift < rshift) { ------------------ | Branch (1873:16): [True: 26, False: 176] ------------------ 1874| 26| auto cpos = rpos.first_sub(concat_right_visitor{}, lpos, tpos); 1875| 26| return concat_rebalance(null_sub_pos{}, cpos, rpos); 1876| 176| } else { 1877| 176| assert(lshift == rshift); 1878| 0| assert(Node::bits_leaf == 0u || lshift > 0); 1879| 0| auto cpos = lpos.last_sub(concat_both_visitor{}, tpos, rpos); 1880| 176| return concat_rebalance(lpos, cpos, rpos); 1881| 176| } 1882| 202|} _ZN5immer6detail4rbts20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_8full_posISC_EERNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1912| 81| { 1913| 81| return concat_inners(lpos, tpos, rpos); 1914| 81| } _ZN5immer6detail4rbts13concat_innersINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EERNS1_8full_posISC_EEEENS1_17concat_center_posIT_EEOT0_OT1_OT2_: 1867| 81|{ 1868| 81| auto lshift = lpos.shift(); 1869| 81| auto rshift = rpos.shift(); 1870| 81| if (lshift > rshift) { ------------------ | Branch (1870:9): [True: 0, False: 81] ------------------ 1871| 0| auto cpos = lpos.last_sub(concat_left_visitor{}, tpos, rpos); 1872| 0| return concat_rebalance(lpos, cpos, null_sub_pos{}); 1873| 81| } else if (lshift < rshift) { ------------------ | Branch (1873:16): [True: 55, False: 26] ------------------ 1874| 55| auto cpos = rpos.first_sub(concat_right_visitor{}, lpos, tpos); 1875| 55| return concat_rebalance(null_sub_pos{}, cpos, rpos); 1876| 55| } else { 1877| 26| assert(lshift == rshift); 1878| 0| assert(Node::bits_leaf == 0u || lshift > 0); 1879| 0| auto cpos = lpos.last_sub(concat_both_visitor{}, tpos, rpos); 1880| 26| return concat_rebalance(lpos, cpos, rpos); 1881| 26| } 1882| 81|} _ZN5immer6detail4rbts16concat_rebalanceINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_12null_sub_posERNS1_17concat_center_posISC_EERNS1_8full_posISC_EEEENSE_IT_EEOT0_OT1_OT2_: 1818| 62|{ 1819| 62| auto plan = concat_rebalance_plan{}; 1820| 62| plan.fill(lpos, cpos, rpos); 1821| 62| plan.shuffle(cpos.shift()); 1822| 62| IMMER_TRY { ------------------ | | 41| 62|#define IMMER_TRY try ------------------ 1823| 62| return plan.merge(lpos, cpos, rpos); 1824| 62| } 1825| 62| IMMER_CATCH (...) { 1826| 0| cpos.each_sub(dec_visitor{}); 1827| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1828| 0| } 1829| 62|} _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE4fillIRNS1_12null_sub_posERNS1_17concat_center_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_8full_posISH_EEEEvOT_OT0_OT1_: 1747| 62| { 1748| 62| assert(n == 0u); 1749| 0| assert(total == 0u); 1750| 0| using visitor_t = concat_rebalance_plan_fill_visitor; 1751| 62| lpos.each_left_sub(visitor_t{}, *this); 1752| 62| cpos.each_sub(visitor_t{}, *this); 1753| 62| rpos.each_right_sub(visitor_t{}, *this); 1754| 62| } _ZN5immer6detail4rbts34concat_rebalance_plan_fill_visitor10visit_nodeIRNS1_13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_21concat_rebalance_planILj3ELj3EEEEEvOT_RT0_: 1728| 582k| { 1729| 582k| auto count = p.count(); 1730| 582k| assert(plan.n < Plan::max_children); 1731| 0| plan.counts[plan.n++] = count; 1732| 582k| plan.total += count; 1733| 582k| } _ZN5immer6detail4rbts34concat_rebalance_plan_fill_visitor10visit_nodeIRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_21concat_rebalance_planILj3ELj3EEEEEvOT_RT0_: 1728| 264k| { 1729| 264k| auto count = p.count(); 1730| 264k| assert(plan.n < Plan::max_children); 1731| 0| plan.counts[plan.n++] = count; 1732| 264k| plan.total += count; 1733| 264k| } _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE5mergeIRNS1_12null_sub_posERNS1_17concat_center_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_8full_posISH_EEEENS7_INSt3__15decayIT0_E4type6node_tEEEOT_OSP_OT1_: 1797| 62| { 1798| 62| using node_t = node_type; 1799| 62| using merger_t = concat_merger; 1800| 62| using visitor_t = concat_merger_visitor; 1801| 62| auto merger = merger_t{cpos.shift(), counts, n}; 1802| 62| IMMER_TRY { ------------------ | | 41| 62|#define IMMER_TRY try ------------------ 1803| 62| lpos.each_left_sub(visitor_t{}, merger); 1804| 62| cpos.each_sub(visitor_t{}, merger); 1805| 62| rpos.each_right_sub(visitor_t{}, merger); 1806| 62| cpos.each_sub(dec_visitor{}); 1807| 62| return merger.finish(); 1808| 62| } 1809| 62| IMMER_CATCH (...) { 1810| 0| merger.abort(); 1811| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1812| 0| } 1813| 62| } _ZN5immer6detail4rbts21concat_merger_visitor10visit_leafIRNS1_13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_13concat_mergerISE_EEEEvOT_RT0_: 1716| 582k| { 1717| 582k| merger.merge_leaf(p); 1718| 582k| } _ZN5immer6detail4rbts13concat_mergerINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10merge_leafIRNS1_13full_leaf_posISC_EEEEvOT_: 1609| 582k| { 1610| 582k| auto from = p.node(); 1611| 582k| auto from_size = p.size(); 1612| 582k| auto from_count = p.count(); 1613| 582k| assert(from_size); 1614| 582k| if (!to_ && *curr_ == from_count) { ------------------ | Branch (1614:13): [True: 582k, False: 0] | Branch (1614:21): [True: 582k, False: 0] ------------------ 1615| 582k| add_child(from, from_size); 1616| 582k| from->inc(); 1617| 582k| } else { 1618| 0| auto from_offset = count_t{}; 1619| 0| auto from_data = from->leaf(); 1620| 0| do { 1621| 0| if (!to_) { ------------------ | Branch (1621:21): [True: 0, False: 0] ------------------ 1622| 0| to_ = node_t::make_leaf_n(*curr_); 1623| 0| to_offset_ = 0; 1624| 0| } 1625| 0| auto data = to_->leaf(); 1626| 0| auto to_copy = 1627| 0| std::min(from_count - from_offset, *curr_ - to_offset_); 1628| 0| detail::uninitialized_copy(from_data + from_offset, 1629| 0| from_data + from_offset + to_copy, 1630| 0| data + to_offset_); 1631| 0| to_offset_ += to_copy; 1632| 0| from_offset += to_copy; 1633| 0| if (*curr_ == to_offset_) { ------------------ | Branch (1633:21): [True: 0, False: 0] ------------------ 1634| 0| add_child(to_, to_offset_); 1635| 0| to_ = nullptr; 1636| 0| } 1637| 0| } while (from_offset != from_count); ------------------ | Branch (1637:22): [True: 0, False: 0] ------------------ 1638| 0| } 1639| 582k| } _ZN5immer6detail4rbts21concat_merger_visitor11visit_innerIRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_13concat_mergerISE_EEEEvOT_RT0_: 1710| 264k| { 1711| 264k| merger.merge_inner(p); 1712| 264k| } _ZN5immer6detail4rbts13concat_mergerINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11merge_innerIRNS1_8full_posISC_EEEEvOT_: 1643| 264k| { 1644| 264k| auto from = p.node(); 1645| 264k| auto from_size = p.size(); 1646| 264k| auto from_count = p.count(); 1647| 264k| assert(from_size); 1648| 264k| if (!to_ && *curr_ == from_count) { ------------------ | Branch (1648:13): [True: 264k, False: 0] | Branch (1648:21): [True: 264k, False: 0] ------------------ 1649| 264k| add_child(from, from_size); 1650| 264k| from->inc(); 1651| 264k| } else { 1652| 0| auto from_offset = count_t{}; 1653| 0| auto from_data = from->inner(); 1654| 0| do { 1655| 0| if (!to_) { ------------------ | Branch (1655:21): [True: 0, False: 0] ------------------ 1656| 0| to_ = node_t::make_inner_r_n(*curr_); 1657| 0| to_offset_ = 0; 1658| 0| to_size_ = 0; 1659| 0| } 1660| 0| auto data = to_->inner(); 1661| 0| auto to_copy = 1662| 0| std::min(from_count - from_offset, *curr_ - to_offset_); 1663| 0| std::copy(from_data + from_offset, 1664| 0| from_data + from_offset + to_copy, 1665| 0| data + to_offset_); 1666| 0| node_t::inc_nodes(from_data + from_offset, to_copy); 1667| 0| auto sizes = to_->relaxed()->d.sizes; 1668| 0| p.copy_sizes( 1669| 0| from_offset, to_copy, to_size_, sizes + to_offset_); 1670| 0| to_offset_ += to_copy; 1671| 0| from_offset += to_copy; 1672| 0| to_size_ = sizes[to_offset_ - 1]; 1673| 0| assert(to_size_); 1674| 0| if (*curr_ == to_offset_) { ------------------ | Branch (1674:21): [True: 0, False: 0] ------------------ 1675| 0| to_->relaxed()->d.count = to_offset_; 1676| 0| add_child(to_, to_size_); 1677| 0| to_ = nullptr; 1678| 0| } 1679| 0| } while (from_offset != from_count); ------------------ | Branch (1679:22): [True: 0, False: 0] ------------------ 1680| 0| } 1681| 264k| } _ZN5immer6detail4rbts19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_leafIRNS1_12leaf_sub_posISC_EERNS1_14empty_leaf_posISC_EERNS1_8full_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1939| 26| { 1940| 26| return rpos.first_sub_leaf(concat_right_visitor{}, lpos, tpos); 1941| 26| } _ZN5immer6detail4rbts20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_leafIRNS1_13full_leaf_posISC_EERNS1_12leaf_sub_posISC_EERNS1_14empty_leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1919| 202| { 1920| 202| return concat_leafs(lpos, tpos, rpos); 1921| 202| } _ZN5immer6detail4rbts12concat_leafsINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_12leaf_sub_posISC_EERNS1_14empty_leaf_posISC_EERNS1_13full_leaf_posISC_EEEENS1_17concat_center_posIT_EEOT0_OT1_OT2_: 1833| 202|{ 1834| 202| static_assert(Node::bits >= 2, ""); 1835| 202| assert(lpos.shift() == tpos.shift()); 1836| 0| assert(lpos.shift() == rpos.shift()); 1837| 0| assert(lpos.shift() == 0); 1838| 202| if (tpos.count() > 0) ------------------ | Branch (1838:9): [True: 0, False: 202] ------------------ 1839| 0| return { 1840| 0| Node::bits_leaf, 1841| 0| lpos.node()->inc(), 1842| 0| lpos.count(), 1843| 0| tpos.node()->inc(), 1844| 0| tpos.count(), 1845| 0| rpos.node()->inc(), 1846| 0| rpos.count(), 1847| 0| }; 1848| 202| else 1849| 202| return { 1850| 202| Node::bits_leaf, 1851| 202| lpos.node()->inc(), 1852| 202| lpos.count(), 1853| 202| rpos.node()->inc(), 1854| 202| rpos.count(), 1855| 202| }; 1856| 202|} _ZN5immer6detail4rbts16concat_rebalanceINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_25singleton_regular_sub_posISC_EERNS1_17concat_center_posISC_EERNS1_8full_posISC_EEEENSG_IT_EEOT0_OT1_OT2_: 1818| 26|{ 1819| 26| auto plan = concat_rebalance_plan{}; 1820| 26| plan.fill(lpos, cpos, rpos); 1821| 26| plan.shuffle(cpos.shift()); 1822| 26| IMMER_TRY { ------------------ | | 41| 26|#define IMMER_TRY try ------------------ 1823| 26| return plan.merge(lpos, cpos, rpos); 1824| 26| } 1825| 26| IMMER_CATCH (...) { 1826| 0| cpos.each_sub(dec_visitor{}); 1827| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1828| 0| } 1829| 26|} _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE4fillIRNS1_25singleton_regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_8full_posISF_EEEEvOT_OT0_OT1_: 1747| 26| { 1748| 26| assert(n == 0u); 1749| 0| assert(total == 0u); 1750| 0| using visitor_t = concat_rebalance_plan_fill_visitor; 1751| 26| lpos.each_left_sub(visitor_t{}, *this); 1752| 26| cpos.each_sub(visitor_t{}, *this); 1753| 26| rpos.each_right_sub(visitor_t{}, *this); 1754| 26| } _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE5mergeIRNS1_25singleton_regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_8full_posISF_EEEENSI_INSt3__15decayIT0_E4type6node_tEEEOT_OSQ_OT1_: 1797| 26| { 1798| 26| using node_t = node_type; 1799| 26| using merger_t = concat_merger; 1800| 26| using visitor_t = concat_merger_visitor; 1801| 26| auto merger = merger_t{cpos.shift(), counts, n}; 1802| 26| IMMER_TRY { ------------------ | | 41| 26|#define IMMER_TRY try ------------------ 1803| 26| lpos.each_left_sub(visitor_t{}, merger); 1804| 26| cpos.each_sub(visitor_t{}, merger); 1805| 26| rpos.each_right_sub(visitor_t{}, merger); 1806| 26| cpos.each_sub(dec_visitor{}); 1807| 26| return merger.finish(); 1808| 26| } 1809| 26| IMMER_CATCH (...) { 1810| 0| merger.abort(); 1811| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1812| 0| } 1813| 26| } _ZN5immer6detail4rbts16concat_rebalanceINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_12null_sub_posERNS1_17concat_center_posISC_EERNS1_15regular_sub_posISC_EEEENSE_IT_EEOT0_OT1_OT2_: 1818| 70|{ 1819| 70| auto plan = concat_rebalance_plan{}; 1820| 70| plan.fill(lpos, cpos, rpos); 1821| 70| plan.shuffle(cpos.shift()); 1822| 70| IMMER_TRY { ------------------ | | 41| 70|#define IMMER_TRY try ------------------ 1823| 70| return plan.merge(lpos, cpos, rpos); 1824| 70| } 1825| 70| IMMER_CATCH (...) { 1826| 0| cpos.each_sub(dec_visitor{}); 1827| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1828| 0| } 1829| 70|} _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE4fillIRNS1_12null_sub_posERNS1_17concat_center_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_15regular_sub_posISH_EEEEvOT_OT0_OT1_: 1747| 70| { 1748| 70| assert(n == 0u); 1749| 0| assert(total == 0u); 1750| 0| using visitor_t = concat_rebalance_plan_fill_visitor; 1751| 70| lpos.each_left_sub(visitor_t{}, *this); 1752| 70| cpos.each_sub(visitor_t{}, *this); 1753| 70| rpos.each_right_sub(visitor_t{}, *this); 1754| 70| } _ZN5immer6detail4rbts34concat_rebalance_plan_fill_visitor10visit_nodeIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_21concat_rebalance_planILj3ELj3EEEEEvOT_RT0_: 1728| 768k| { 1729| 768k| auto count = p.count(); 1730| 768k| assert(plan.n < Plan::max_children); 1731| 0| plan.counts[plan.n++] = count; 1732| 768k| plan.total += count; 1733| 768k| } _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE5mergeIRNS1_12null_sub_posERNS1_17concat_center_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_15regular_sub_posISH_EEEENS7_INSt3__15decayIT0_E4type6node_tEEEOT_OSP_OT1_: 1797| 70| { 1798| 70| using node_t = node_type; 1799| 70| using merger_t = concat_merger; 1800| 70| using visitor_t = concat_merger_visitor; 1801| 70| auto merger = merger_t{cpos.shift(), counts, n}; 1802| 70| IMMER_TRY { ------------------ | | 41| 70|#define IMMER_TRY try ------------------ 1803| 70| lpos.each_left_sub(visitor_t{}, merger); 1804| 70| cpos.each_sub(visitor_t{}, merger); 1805| 70| rpos.each_right_sub(visitor_t{}, merger); 1806| 70| cpos.each_sub(dec_visitor{}); 1807| 70| return merger.finish(); 1808| 70| } 1809| 70| IMMER_CATCH (...) { 1810| 0| merger.abort(); 1811| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1812| 0| } 1813| 70| } _ZN5immer6detail4rbts21concat_merger_visitor11visit_innerIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_13concat_mergerISE_EEEEvOT_RT0_: 1710| 768k| { 1711| 768k| merger.merge_inner(p); 1712| 768k| } _ZN5immer6detail4rbts13concat_mergerINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11merge_innerIRNS1_15regular_sub_posISC_EEEEvOT_: 1643| 768k| { 1644| 768k| auto from = p.node(); 1645| 768k| auto from_size = p.size(); 1646| 768k| auto from_count = p.count(); 1647| 768k| assert(from_size); 1648| 768k| if (!to_ && *curr_ == from_count) { ------------------ | Branch (1648:13): [True: 520k, False: 247k] | Branch (1648:21): [True: 520k, False: 0] ------------------ 1649| 520k| add_child(from, from_size); 1650| 520k| from->inc(); 1651| 520k| } else { 1652| 247k| auto from_offset = count_t{}; 1653| 247k| auto from_data = from->inner(); 1654| 495k| do { 1655| 495k| if (!to_) { ------------------ | Branch (1655:21): [True: 247k, False: 247k] ------------------ 1656| 247k| to_ = node_t::make_inner_r_n(*curr_); 1657| 247k| to_offset_ = 0; 1658| 247k| to_size_ = 0; 1659| 247k| } 1660| 495k| auto data = to_->inner(); 1661| 495k| auto to_copy = 1662| 495k| std::min(from_count - from_offset, *curr_ - to_offset_); 1663| 495k| std::copy(from_data + from_offset, 1664| 495k| from_data + from_offset + to_copy, 1665| 495k| data + to_offset_); 1666| 495k| node_t::inc_nodes(from_data + from_offset, to_copy); 1667| 495k| auto sizes = to_->relaxed()->d.sizes; 1668| 495k| p.copy_sizes( 1669| 495k| from_offset, to_copy, to_size_, sizes + to_offset_); 1670| 495k| to_offset_ += to_copy; 1671| 495k| from_offset += to_copy; 1672| 495k| to_size_ = sizes[to_offset_ - 1]; 1673| 495k| assert(to_size_); 1674| 495k| if (*curr_ == to_offset_) { ------------------ | Branch (1674:21): [True: 247k, False: 247k] ------------------ 1675| 247k| to_->relaxed()->d.count = to_offset_; 1676| 247k| add_child(to_, to_size_); 1677| 247k| to_ = nullptr; 1678| 247k| } 1679| 495k| } while (from_offset != from_count); ------------------ | Branch (1679:22): [True: 247k, False: 247k] ------------------ 1680| 247k| } 1681| 768k| } _ZN5immer6detail4rbts19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_leafIRNS1_12leaf_sub_posISC_EERNS1_14empty_leaf_posISC_EERNS1_15regular_sub_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1939| 176| { 1940| 176| return rpos.first_sub_leaf(concat_right_visitor{}, lpos, tpos); 1941| 176| } _ZN5immer6detail4rbts20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_leafIRNS1_12leaf_sub_posISC_EESH_RNS1_14empty_leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1919| 925| { 1920| 925| return concat_leafs(lpos, tpos, rpos); 1921| 925| } _ZN5immer6detail4rbts12concat_leafsINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_12leaf_sub_posISC_EERNS1_14empty_leaf_posISC_EESF_EENS1_17concat_center_posIT_EEOT0_OT1_OT2_: 1833| 925|{ 1834| 925| static_assert(Node::bits >= 2, ""); 1835| 925| assert(lpos.shift() == tpos.shift()); 1836| 0| assert(lpos.shift() == rpos.shift()); 1837| 0| assert(lpos.shift() == 0); 1838| 925| if (tpos.count() > 0) ------------------ | Branch (1838:9): [True: 0, False: 925] ------------------ 1839| 0| return { 1840| 0| Node::bits_leaf, 1841| 0| lpos.node()->inc(), 1842| 0| lpos.count(), 1843| 0| tpos.node()->inc(), 1844| 0| tpos.count(), 1845| 0| rpos.node()->inc(), 1846| 0| rpos.count(), 1847| 0| }; 1848| 925| else 1849| 925| return { 1850| 925| Node::bits_leaf, 1851| 925| lpos.node()->inc(), 1852| 925| lpos.count(), 1853| 925| rpos.node()->inc(), 1854| 925| rpos.count(), 1855| 925| }; 1856| 925|} _ZN5immer6detail4rbts16concat_rebalanceINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_25singleton_regular_sub_posISC_EERNS1_17concat_center_posISC_EERNS1_15regular_sub_posISC_EEEENSG_IT_EEOT0_OT1_OT2_: 1818| 176|{ 1819| 176| auto plan = concat_rebalance_plan{}; 1820| 176| plan.fill(lpos, cpos, rpos); 1821| 176| plan.shuffle(cpos.shift()); 1822| 176| IMMER_TRY { ------------------ | | 41| 176|#define IMMER_TRY try ------------------ 1823| 176| return plan.merge(lpos, cpos, rpos); 1824| 176| } 1825| 176| IMMER_CATCH (...) { 1826| 0| cpos.each_sub(dec_visitor{}); 1827| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1828| 0| } 1829| 176|} _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE4fillIRNS1_25singleton_regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_15regular_sub_posISF_EEEEvOT_OT0_OT1_: 1747| 176| { 1748| 176| assert(n == 0u); 1749| 0| assert(total == 0u); 1750| 0| using visitor_t = concat_rebalance_plan_fill_visitor; 1751| 176| lpos.each_left_sub(visitor_t{}, *this); 1752| 176| cpos.each_sub(visitor_t{}, *this); 1753| 176| rpos.each_right_sub(visitor_t{}, *this); 1754| 176| } _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE5mergeIRNS1_25singleton_regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_15regular_sub_posISF_EEEENSI_INSt3__15decayIT0_E4type6node_tEEEOT_OSQ_OT1_: 1797| 176| { 1798| 176| using node_t = node_type; 1799| 176| using merger_t = concat_merger; 1800| 176| using visitor_t = concat_merger_visitor; 1801| 176| auto merger = merger_t{cpos.shift(), counts, n}; 1802| 176| IMMER_TRY { ------------------ | | 41| 176|#define IMMER_TRY try ------------------ 1803| 176| lpos.each_left_sub(visitor_t{}, merger); 1804| 176| cpos.each_sub(visitor_t{}, merger); 1805| 176| rpos.each_right_sub(visitor_t{}, merger); 1806| 176| cpos.each_sub(dec_visitor{}); 1807| 176| return merger.finish(); 1808| 176| } 1809| 176| IMMER_CATCH (...) { 1810| 0| merger.abort(); 1811| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1812| 0| } 1813| 176| } _ZN5immer6detail4rbts16concat_rebalanceINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_12null_sub_posERNS1_17concat_center_posISC_EERNS1_11relaxed_posISC_EEEENSE_IT_EEOT0_OT1_OT2_: 1818| 27.8k|{ 1819| 27.8k| auto plan = concat_rebalance_plan{}; 1820| 27.8k| plan.fill(lpos, cpos, rpos); 1821| 27.8k| plan.shuffle(cpos.shift()); 1822| 27.8k| IMMER_TRY { ------------------ | | 41| 27.8k|#define IMMER_TRY try ------------------ 1823| 27.8k| return plan.merge(lpos, cpos, rpos); 1824| 27.8k| } 1825| 27.8k| IMMER_CATCH (...) { 1826| 0| cpos.each_sub(dec_visitor{}); 1827| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1828| 0| } 1829| 27.8k|} _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE4fillIRNS1_12null_sub_posERNS1_17concat_center_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_11relaxed_posISH_EEEEvOT_OT0_OT1_: 1747| 27.8k| { 1748| 27.8k| assert(n == 0u); 1749| 0| assert(total == 0u); 1750| 0| using visitor_t = concat_rebalance_plan_fill_visitor; 1751| 27.8k| lpos.each_left_sub(visitor_t{}, *this); 1752| 27.8k| cpos.each_sub(visitor_t{}, *this); 1753| 27.8k| rpos.each_right_sub(visitor_t{}, *this); 1754| 27.8k| } _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE5mergeIRNS1_12null_sub_posERNS1_17concat_center_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_11relaxed_posISH_EEEENS7_INSt3__15decayIT0_E4type6node_tEEEOT_OSP_OT1_: 1797| 27.8k| { 1798| 27.8k| using node_t = node_type; 1799| 27.8k| using merger_t = concat_merger; 1800| 27.8k| using visitor_t = concat_merger_visitor; 1801| 27.8k| auto merger = merger_t{cpos.shift(), counts, n}; 1802| 27.8k| IMMER_TRY { ------------------ | | 41| 27.8k|#define IMMER_TRY try ------------------ 1803| 27.8k| lpos.each_left_sub(visitor_t{}, merger); 1804| 27.8k| cpos.each_sub(visitor_t{}, merger); 1805| 27.8k| rpos.each_right_sub(visitor_t{}, merger); 1806| 27.8k| cpos.each_sub(dec_visitor{}); 1807| 27.8k| return merger.finish(); 1808| 27.8k| } 1809| 27.8k| IMMER_CATCH (...) { 1810| 0| merger.abort(); 1811| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1812| 0| } 1813| 27.8k| } _ZN5immer6detail4rbts19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_leafIRNS1_12leaf_sub_posISC_EERNS1_14empty_leaf_posISC_EERNS1_11relaxed_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1939| 925| { 1940| 925| return rpos.first_sub_leaf(concat_right_visitor{}, lpos, tpos); 1941| 925| } _ZN5immer6detail4rbts16concat_rebalanceINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_25singleton_regular_sub_posISC_EERNS1_17concat_center_posISC_EERNS1_11relaxed_posISC_EEEENSG_IT_EEOT0_OT1_OT2_: 1818| 925|{ 1819| 925| auto plan = concat_rebalance_plan{}; 1820| 925| plan.fill(lpos, cpos, rpos); 1821| 925| plan.shuffle(cpos.shift()); 1822| 925| IMMER_TRY { ------------------ | | 41| 925|#define IMMER_TRY try ------------------ 1823| 925| return plan.merge(lpos, cpos, rpos); 1824| 925| } 1825| 925| IMMER_CATCH (...) { 1826| 0| cpos.each_sub(dec_visitor{}); 1827| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1828| 0| } 1829| 925|} _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE4fillIRNS1_25singleton_regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_11relaxed_posISF_EEEEvOT_OT0_OT1_: 1747| 925| { 1748| 925| assert(n == 0u); 1749| 0| assert(total == 0u); 1750| 0| using visitor_t = concat_rebalance_plan_fill_visitor; 1751| 925| lpos.each_left_sub(visitor_t{}, *this); 1752| 925| cpos.each_sub(visitor_t{}, *this); 1753| 925| rpos.each_right_sub(visitor_t{}, *this); 1754| 925| } _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE5mergeIRNS1_25singleton_regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_11relaxed_posISF_EEEENSI_INSt3__15decayIT0_E4type6node_tEEEOT_OSQ_OT1_: 1797| 925| { 1798| 925| using node_t = node_type; 1799| 925| using merger_t = concat_merger; 1800| 925| using visitor_t = concat_merger_visitor; 1801| 925| auto merger = merger_t{cpos.shift(), counts, n}; 1802| 925| IMMER_TRY { ------------------ | | 41| 925|#define IMMER_TRY try ------------------ 1803| 925| lpos.each_left_sub(visitor_t{}, merger); 1804| 925| cpos.each_sub(visitor_t{}, merger); 1805| 925| rpos.each_right_sub(visitor_t{}, merger); 1806| 925| cpos.each_sub(dec_visitor{}); 1807| 925| return merger.finish(); 1808| 925| } 1809| 925| IMMER_CATCH (...) { 1810| 0| merger.abort(); 1811| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1812| 0| } 1813| 925| } _ZN5immer6detail4rbts26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_nodeIRNS1_15regular_sub_posISC_EERNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1953| 73| { 1954| 73| return concat_inners(lpos, tpos, rpos); 1955| 73| } _ZNO5immer6detail4rbts17concat_center_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7realizeEv: 1523| 483k| { 1524| 483k| if (count_ > 1) { ------------------ | Branch (1524:13): [True: 7.81k, False: 475k] ------------------ 1525| 7.81k| IMMER_TRY { ------------------ | | 41| 7.81k|#define IMMER_TRY try ------------------ 1526| 7.81k| auto result = node_t::make_inner_r_n(count_); 1527| 7.81k| auto r = result->relaxed(); 1528| 7.81k| r->d.count = count_; 1529| 7.81k| std::copy(nodes_, nodes_ + count_, result->inner()); 1530| 7.81k| std::copy(sizes_, sizes_ + count_, r->d.sizes); 1531| 7.81k| return {result, shift_, r}; 1532| 7.81k| } 1533| 7.81k| IMMER_CATCH (...) { 1534| 0| each_sub(dec_visitor{}); 1535| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1536| 0| } 1537| 475k| } else { 1538| 475k| assert(shift_ >= B + BL); 1539| 0| return {nodes_[0], shift_ - B, nodes_[0]->relaxed()}; 1540| 475k| } 1541| 483k| } _ZN5immer6detail4rbts12concat_treesINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_11relaxed_posIT_EEPSE_jmSG_jSG_jm: 1981| 482k|{ 1982| 482k| return visit_maybe_relaxed_sub(lroot, 1983| 482k| lshift, 1984| 482k| lsize, 1985| 482k| concat_trees_left_visitor{}, 1986| 482k| make_leaf_pos(ltail, ltcount), 1987| 482k| rroot, 1988| 482k| rshift, 1989| 482k| rsize) 1990| 482k| .realize(); 1991| 482k|} _ZN5immer6detail4rbts25concat_trees_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_nodeIRNS1_11relaxed_posISC_EENS1_8leaf_posISC_EEJRPSC_RjRmEEENS1_17concat_center_posISC_EEOT_OT0_DpOT1_: 1966| 480k| { 1967| 480k| return visit_maybe_relaxed_sub( 1968| 480k| args..., concat_trees_right_visitor{}, lpos, tpos); 1969| 480k| } _ZN5immer6detail4rbts26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_nodeIRNS1_11relaxed_posISC_EESH_RNS1_8leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1953| 475k| { 1954| 475k| return concat_inners(lpos, tpos, rpos); 1955| 475k| } _ZN5immer6detail4rbts13concat_innersINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EESF_EENS1_17concat_center_posIT_EEOT0_OT1_OT2_: 1867| 5.88M|{ 1868| 5.88M| auto lshift = lpos.shift(); 1869| 5.88M| auto rshift = rpos.shift(); 1870| 5.88M| if (lshift > rshift) { ------------------ | Branch (1870:9): [True: 1.44M, False: 4.44M] ------------------ 1871| 1.44M| auto cpos = lpos.last_sub(concat_left_visitor{}, tpos, rpos); 1872| 1.44M| return concat_rebalance(lpos, cpos, null_sub_pos{}); 1873| 4.44M| } else if (lshift < rshift) { ------------------ | Branch (1873:16): [True: 16.7k, False: 4.42M] ------------------ 1874| 16.7k| auto cpos = rpos.first_sub(concat_right_visitor{}, lpos, tpos); 1875| 16.7k| return concat_rebalance(null_sub_pos{}, cpos, rpos); 1876| 4.42M| } else { 1877| 4.42M| assert(lshift == rshift); 1878| 0| assert(Node::bits_leaf == 0u || lshift > 0); 1879| 0| auto cpos = lpos.last_sub(concat_both_visitor{}, tpos, rpos); 1880| 4.42M| return concat_rebalance(lpos, cpos, rpos); 1881| 4.42M| } 1882| 5.88M|} _ZN5immer6detail4rbts19concat_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EESH_EENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1892| 1.44M| { 1893| 1.44M| return concat_inners(lpos, tpos, rpos); 1894| 1.44M| } _ZN5immer6detail4rbts19concat_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EERNS1_11relaxed_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1892| 299| { 1893| 299| return concat_inners(lpos, tpos, rpos); 1894| 299| } _ZN5immer6detail4rbts13concat_innersINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EERNS1_11relaxed_posISC_EEEENS1_17concat_center_posIT_EEOT0_OT1_OT2_: 1867| 588k|{ 1868| 588k| auto lshift = lpos.shift(); 1869| 588k| auto rshift = rpos.shift(); 1870| 588k| if (lshift > rshift) { ------------------ | Branch (1870:9): [True: 146, False: 588k] ------------------ 1871| 146| auto cpos = lpos.last_sub(concat_left_visitor{}, tpos, rpos); 1872| 146| return concat_rebalance(lpos, cpos, null_sub_pos{}); 1873| 588k| } else if (lshift < rshift) { ------------------ | Branch (1873:16): [True: 1.60k, False: 586k] ------------------ 1874| 1.60k| auto cpos = rpos.first_sub(concat_right_visitor{}, lpos, tpos); 1875| 1.60k| return concat_rebalance(null_sub_pos{}, cpos, rpos); 1876| 586k| } else { 1877| 586k| assert(lshift == rshift); 1878| 0| assert(Node::bits_leaf == 0u || lshift > 0); 1879| 0| auto cpos = lpos.last_sub(concat_both_visitor{}, tpos, rpos); 1880| 586k| return concat_rebalance(lpos, cpos, rpos); 1881| 586k| } 1882| 588k|} _ZN5immer6detail4rbts16concat_rebalanceINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_15regular_sub_posISC_EERNS1_17concat_center_posISC_EENS1_12null_sub_posEEENSG_IT_EEOT0_OT1_OT2_: 1818| 329|{ 1819| 329| auto plan = concat_rebalance_plan{}; 1820| 329| plan.fill(lpos, cpos, rpos); 1821| 329| plan.shuffle(cpos.shift()); 1822| 329| IMMER_TRY { ------------------ | | 41| 329|#define IMMER_TRY try ------------------ 1823| 329| return plan.merge(lpos, cpos, rpos); 1824| 329| } 1825| 329| IMMER_CATCH (...) { 1826| 0| cpos.each_sub(dec_visitor{}); 1827| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1828| 0| } 1829| 329|} _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE4fillIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_12null_sub_posEEEvOT_OT0_OT1_: 1747| 329| { 1748| 329| assert(n == 0u); 1749| 0| assert(total == 0u); 1750| 0| using visitor_t = concat_rebalance_plan_fill_visitor; 1751| 329| lpos.each_left_sub(visitor_t{}, *this); 1752| 329| cpos.each_sub(visitor_t{}, *this); 1753| 329| rpos.each_right_sub(visitor_t{}, *this); 1754| 329| } _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE5mergeIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_12null_sub_posEEENSI_INSt3__15decayIT0_E4type6node_tEEEOT_OSP_OT1_: 1797| 329| { 1798| 329| using node_t = node_type; 1799| 329| using merger_t = concat_merger; 1800| 329| using visitor_t = concat_merger_visitor; 1801| 329| auto merger = merger_t{cpos.shift(), counts, n}; 1802| 329| IMMER_TRY { ------------------ | | 41| 329|#define IMMER_TRY try ------------------ 1803| 329| lpos.each_left_sub(visitor_t{}, merger); 1804| 329| cpos.each_sub(visitor_t{}, merger); 1805| 329| rpos.each_right_sub(visitor_t{}, merger); 1806| 329| cpos.each_sub(dec_visitor{}); 1807| 329| return merger.finish(); 1808| 329| } 1809| 329| IMMER_CATCH (...) { 1810| 0| merger.abort(); 1811| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1812| 0| } 1813| 329| } _ZN5immer6detail4rbts20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_11relaxed_posISC_EERNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1912| 587k| { 1913| 587k| return concat_inners(lpos, tpos, rpos); 1914| 587k| } _ZN5immer6detail4rbts20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_15regular_sub_posISC_EESH_RNS1_8leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1912| 19.0k| { 1913| 19.0k| return concat_inners(lpos, tpos, rpos); 1914| 19.0k| } _ZN5immer6detail4rbts13concat_innersINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EESF_EENS1_17concat_center_posIT_EEOT0_OT1_OT2_: 1867| 20.5k|{ 1868| 20.5k| auto lshift = lpos.shift(); 1869| 20.5k| auto rshift = rpos.shift(); 1870| 20.5k| if (lshift > rshift) { ------------------ | Branch (1870:9): [True: 183, False: 20.3k] ------------------ 1871| 183| auto cpos = lpos.last_sub(concat_left_visitor{}, tpos, rpos); 1872| 183| return concat_rebalance(lpos, cpos, null_sub_pos{}); 1873| 20.3k| } else if (lshift < rshift) { ------------------ | Branch (1873:16): [True: 37, False: 20.3k] ------------------ 1874| 37| auto cpos = rpos.first_sub(concat_right_visitor{}, lpos, tpos); 1875| 37| return concat_rebalance(null_sub_pos{}, cpos, rpos); 1876| 20.3k| } else { 1877| 20.3k| assert(lshift == rshift); 1878| 0| assert(Node::bits_leaf == 0u || lshift > 0); 1879| 0| auto cpos = lpos.last_sub(concat_both_visitor{}, tpos, rpos); 1880| 20.3k| return concat_rebalance(lpos, cpos, rpos); 1881| 20.3k| } 1882| 20.5k|} _ZN5immer6detail4rbts19concat_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EESH_EENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1892| 259| { 1893| 259| return concat_inners(lpos, tpos, rpos); 1894| 259| } _ZN5immer6detail4rbts20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_8full_posISC_EERNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1912| 7.83k| { 1913| 7.83k| return concat_inners(lpos, tpos, rpos); 1914| 7.83k| } _ZN5immer6detail4rbts13concat_innersINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EERNS1_8full_posISC_EEEENS1_17concat_center_posIT_EEOT0_OT1_OT2_: 1867| 7.83k|{ 1868| 7.83k| auto lshift = lpos.shift(); 1869| 7.83k| auto rshift = rpos.shift(); 1870| 7.83k| if (lshift > rshift) { ------------------ | Branch (1870:9): [True: 0, False: 7.83k] ------------------ 1871| 0| auto cpos = lpos.last_sub(concat_left_visitor{}, tpos, rpos); 1872| 0| return concat_rebalance(lpos, cpos, null_sub_pos{}); 1873| 7.83k| } else if (lshift < rshift) { ------------------ | Branch (1873:16): [True: 6, False: 7.83k] ------------------ 1874| 6| auto cpos = rpos.first_sub(concat_right_visitor{}, lpos, tpos); 1875| 6| return concat_rebalance(null_sub_pos{}, cpos, rpos); 1876| 7.83k| } else { 1877| 7.83k| assert(lshift == rshift); 1878| 0| assert(Node::bits_leaf == 0u || lshift > 0); 1879| 0| auto cpos = lpos.last_sub(concat_both_visitor{}, tpos, rpos); 1880| 7.83k| return concat_rebalance(lpos, cpos, rpos); 1881| 7.83k| } 1882| 7.83k|} _ZN5immer6detail4rbts19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_leafIRNS1_12leaf_sub_posISC_EERNS1_8leaf_posISC_EERNS1_8full_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1939| 4.09k| { 1940| 4.09k| return rpos.first_sub_leaf(concat_right_visitor{}, lpos, tpos); 1941| 4.09k| } _ZN5immer6detail4rbts20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_leafIRNS1_13full_leaf_posISC_EERNS1_12leaf_sub_posISC_EERNS1_8leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1919| 29.5k| { 1920| 29.5k| return concat_leafs(lpos, tpos, rpos); 1921| 29.5k| } _ZN5immer6detail4rbts12concat_leafsINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_12leaf_sub_posISC_EERNS1_8leaf_posISC_EERNS1_13full_leaf_posISC_EEEENS1_17concat_center_posIT_EEOT0_OT1_OT2_: 1833| 29.5k|{ 1834| 29.5k| static_assert(Node::bits >= 2, ""); 1835| 29.5k| assert(lpos.shift() == tpos.shift()); 1836| 0| assert(lpos.shift() == rpos.shift()); 1837| 0| assert(lpos.shift() == 0); 1838| 29.5k| if (tpos.count() > 0) ------------------ | Branch (1838:9): [True: 29.5k, False: 0] ------------------ 1839| 29.5k| return { 1840| 29.5k| Node::bits_leaf, 1841| 29.5k| lpos.node()->inc(), 1842| 29.5k| lpos.count(), 1843| 29.5k| tpos.node()->inc(), 1844| 29.5k| tpos.count(), 1845| 29.5k| rpos.node()->inc(), 1846| 29.5k| rpos.count(), 1847| 29.5k| }; 1848| 0| else 1849| 0| return { 1850| 0| Node::bits_leaf, 1851| 0| lpos.node()->inc(), 1852| 0| lpos.count(), 1853| 0| rpos.node()->inc(), 1854| 0| rpos.count(), 1855| 0| }; 1856| 29.5k|} _ZN5immer6detail4rbts19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EERNS1_8full_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1932| 3.77k| { 1933| 3.77k| return rpos.first_sub(concat_right_visitor{}, lpos, tpos); 1934| 3.77k| } _ZN5immer6detail4rbts16concat_rebalanceINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_15regular_sub_posISC_EERNS1_17concat_center_posISC_EERNS1_8full_posISC_EEEENSG_IT_EEOT0_OT1_OT2_: 1818| 7.83k|{ 1819| 7.83k| auto plan = concat_rebalance_plan{}; 1820| 7.83k| plan.fill(lpos, cpos, rpos); 1821| 7.83k| plan.shuffle(cpos.shift()); 1822| 7.83k| IMMER_TRY { ------------------ | | 41| 7.83k|#define IMMER_TRY try ------------------ 1823| 7.83k| return plan.merge(lpos, cpos, rpos); 1824| 7.83k| } 1825| 7.83k| IMMER_CATCH (...) { 1826| 0| cpos.each_sub(dec_visitor{}); 1827| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1828| 0| } 1829| 7.83k|} _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE4fillIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_8full_posISF_EEEEvOT_OT0_OT1_: 1747| 7.83k| { 1748| 7.83k| assert(n == 0u); 1749| 0| assert(total == 0u); 1750| 0| using visitor_t = concat_rebalance_plan_fill_visitor; 1751| 7.83k| lpos.each_left_sub(visitor_t{}, *this); 1752| 7.83k| cpos.each_sub(visitor_t{}, *this); 1753| 7.83k| rpos.each_right_sub(visitor_t{}, *this); 1754| 7.83k| } _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE5mergeIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_8full_posISF_EEEENSI_INSt3__15decayIT0_E4type6node_tEEEOT_OSQ_OT1_: 1797| 7.83k| { 1798| 7.83k| using node_t = node_type; 1799| 7.83k| using merger_t = concat_merger; 1800| 7.83k| using visitor_t = concat_merger_visitor; 1801| 7.83k| auto merger = merger_t{cpos.shift(), counts, n}; 1802| 7.83k| IMMER_TRY { ------------------ | | 41| 7.83k|#define IMMER_TRY try ------------------ 1803| 7.83k| lpos.each_left_sub(visitor_t{}, merger); 1804| 7.83k| cpos.each_sub(visitor_t{}, merger); 1805| 7.83k| rpos.each_right_sub(visitor_t{}, merger); 1806| 7.83k| cpos.each_sub(dec_visitor{}); 1807| 7.83k| return merger.finish(); 1808| 7.83k| } 1809| 7.83k| IMMER_CATCH (...) { 1810| 0| merger.abort(); 1811| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1812| 0| } 1813| 7.83k| } _ZN5immer6detail4rbts19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_leafIRNS1_12leaf_sub_posISC_EERNS1_8leaf_posISC_EERNS1_15regular_sub_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1939| 25.4k| { 1940| 25.4k| return rpos.first_sub_leaf(concat_right_visitor{}, lpos, tpos); 1941| 25.4k| } _ZN5immer6detail4rbts20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_leafIRNS1_12leaf_sub_posISC_EESH_RNS1_8leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1919| 452k| { 1920| 452k| return concat_leafs(lpos, tpos, rpos); 1921| 452k| } _ZN5immer6detail4rbts12concat_leafsINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_12leaf_sub_posISC_EERNS1_8leaf_posISC_EESF_EENS1_17concat_center_posIT_EEOT0_OT1_OT2_: 1833| 452k|{ 1834| 452k| static_assert(Node::bits >= 2, ""); 1835| 452k| assert(lpos.shift() == tpos.shift()); 1836| 0| assert(lpos.shift() == rpos.shift()); 1837| 0| assert(lpos.shift() == 0); 1838| 452k| if (tpos.count() > 0) ------------------ | Branch (1838:9): [True: 452k, False: 0] ------------------ 1839| 452k| return { 1840| 452k| Node::bits_leaf, 1841| 452k| lpos.node()->inc(), 1842| 452k| lpos.count(), 1843| 452k| tpos.node()->inc(), 1844| 452k| tpos.count(), 1845| 452k| rpos.node()->inc(), 1846| 452k| rpos.count(), 1847| 452k| }; 1848| 0| else 1849| 0| return { 1850| 0| Node::bits_leaf, 1851| 0| lpos.node()->inc(), 1852| 0| lpos.count(), 1853| 0| rpos.node()->inc(), 1854| 0| rpos.count(), 1855| 0| }; 1856| 452k|} _ZN5immer6detail4rbts19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EESH_EENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1932| 4.02k| { 1933| 4.02k| return rpos.first_sub(concat_right_visitor{}, lpos, tpos); 1934| 4.02k| } _ZN5immer6detail4rbts16concat_rebalanceINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_15regular_sub_posISC_EERNS1_17concat_center_posISC_EESF_EENSG_IT_EEOT0_OT1_OT2_: 1818| 20.3k|{ 1819| 20.3k| auto plan = concat_rebalance_plan{}; 1820| 20.3k| plan.fill(lpos, cpos, rpos); 1821| 20.3k| plan.shuffle(cpos.shift()); 1822| 20.3k| IMMER_TRY { ------------------ | | 41| 20.3k|#define IMMER_TRY try ------------------ 1823| 20.3k| return plan.merge(lpos, cpos, rpos); 1824| 20.3k| } 1825| 20.3k| IMMER_CATCH (...) { 1826| 0| cpos.each_sub(dec_visitor{}); 1827| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1828| 0| } 1829| 20.3k|} _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE4fillIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EESH_EEvOT_OT0_OT1_: 1747| 20.3k| { 1748| 20.3k| assert(n == 0u); 1749| 0| assert(total == 0u); 1750| 0| using visitor_t = concat_rebalance_plan_fill_visitor; 1751| 20.3k| lpos.each_left_sub(visitor_t{}, *this); 1752| 20.3k| cpos.each_sub(visitor_t{}, *this); 1753| 20.3k| rpos.each_right_sub(visitor_t{}, *this); 1754| 20.3k| } _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE5mergeIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EESH_EENSI_INSt3__15decayIT0_E4type6node_tEEEOT_OSN_OT1_: 1797| 20.3k| { 1798| 20.3k| using node_t = node_type; 1799| 20.3k| using merger_t = concat_merger; 1800| 20.3k| using visitor_t = concat_merger_visitor; 1801| 20.3k| auto merger = merger_t{cpos.shift(), counts, n}; 1802| 20.3k| IMMER_TRY { ------------------ | | 41| 20.3k|#define IMMER_TRY try ------------------ 1803| 20.3k| lpos.each_left_sub(visitor_t{}, merger); 1804| 20.3k| cpos.each_sub(visitor_t{}, merger); 1805| 20.3k| rpos.each_right_sub(visitor_t{}, merger); 1806| 20.3k| cpos.each_sub(dec_visitor{}); 1807| 20.3k| return merger.finish(); 1808| 20.3k| } 1809| 20.3k| IMMER_CATCH (...) { 1810| 0| merger.abort(); 1811| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1812| 0| } 1813| 20.3k| } _ZN5immer6detail4rbts19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_leafIRNS1_12leaf_sub_posISC_EERNS1_8leaf_posISC_EERNS1_11relaxed_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1939| 452k| { 1940| 452k| return rpos.first_sub_leaf(concat_right_visitor{}, lpos, tpos); 1941| 452k| } _ZN5immer6detail4rbts19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EERNS1_11relaxed_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1932| 604k| { 1933| 604k| return rpos.first_sub(concat_right_visitor{}, lpos, tpos); 1934| 604k| } _ZN5immer6detail4rbts16concat_rebalanceINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_15regular_sub_posISC_EERNS1_17concat_center_posISC_EERNS1_11relaxed_posISC_EEEENSG_IT_EEOT0_OT1_OT2_: 1818| 586k|{ 1819| 586k| auto plan = concat_rebalance_plan{}; 1820| 586k| plan.fill(lpos, cpos, rpos); 1821| 586k| plan.shuffle(cpos.shift()); 1822| 586k| IMMER_TRY { ------------------ | | 41| 586k|#define IMMER_TRY try ------------------ 1823| 586k| return plan.merge(lpos, cpos, rpos); 1824| 586k| } 1825| 586k| IMMER_CATCH (...) { 1826| 0| cpos.each_sub(dec_visitor{}); 1827| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1828| 0| } 1829| 586k|} _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE4fillIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_11relaxed_posISF_EEEEvOT_OT0_OT1_: 1747| 586k| { 1748| 586k| assert(n == 0u); 1749| 0| assert(total == 0u); 1750| 0| using visitor_t = concat_rebalance_plan_fill_visitor; 1751| 586k| lpos.each_left_sub(visitor_t{}, *this); 1752| 586k| cpos.each_sub(visitor_t{}, *this); 1753| 586k| rpos.each_right_sub(visitor_t{}, *this); 1754| 586k| } _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE5mergeIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_11relaxed_posISF_EEEENSI_INSt3__15decayIT0_E4type6node_tEEEOT_OSQ_OT1_: 1797| 586k| { 1798| 586k| using node_t = node_type; 1799| 586k| using merger_t = concat_merger; 1800| 586k| using visitor_t = concat_merger_visitor; 1801| 586k| auto merger = merger_t{cpos.shift(), counts, n}; 1802| 586k| IMMER_TRY { ------------------ | | 41| 586k|#define IMMER_TRY try ------------------ 1803| 586k| lpos.each_left_sub(visitor_t{}, merger); 1804| 586k| cpos.each_sub(visitor_t{}, merger); 1805| 586k| rpos.each_right_sub(visitor_t{}, merger); 1806| 586k| cpos.each_sub(dec_visitor{}); 1807| 586k| return merger.finish(); 1808| 586k| } 1809| 586k| IMMER_CATCH (...) { 1810| 0| merger.abort(); 1811| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1812| 0| } 1813| 586k| } _ZN5immer6detail4rbts16concat_rebalanceINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_11relaxed_posISC_EERNS1_17concat_center_posISC_EENS1_12null_sub_posEEENSG_IT_EEOT0_OT1_OT2_: 1818| 1.45M|{ 1819| 1.45M| auto plan = concat_rebalance_plan{}; 1820| 1.45M| plan.fill(lpos, cpos, rpos); 1821| 1.45M| plan.shuffle(cpos.shift()); 1822| 1.45M| IMMER_TRY { ------------------ | | 41| 1.45M|#define IMMER_TRY try ------------------ 1823| 1.45M| return plan.merge(lpos, cpos, rpos); 1824| 1.45M| } 1825| 1.45M| IMMER_CATCH (...) { 1826| 0| cpos.each_sub(dec_visitor{}); 1827| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1828| 0| } 1829| 1.45M|} _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE4fillIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_12null_sub_posEEEvOT_OT0_OT1_: 1747| 1.45M| { 1748| 1.45M| assert(n == 0u); 1749| 0| assert(total == 0u); 1750| 0| using visitor_t = concat_rebalance_plan_fill_visitor; 1751| 1.45M| lpos.each_left_sub(visitor_t{}, *this); 1752| 1.45M| cpos.each_sub(visitor_t{}, *this); 1753| 1.45M| rpos.each_right_sub(visitor_t{}, *this); 1754| 1.45M| } _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE5mergeIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_12null_sub_posEEENSI_INSt3__15decayIT0_E4type6node_tEEEOT_OSP_OT1_: 1797| 1.45M| { 1798| 1.45M| using node_t = node_type; 1799| 1.45M| using merger_t = concat_merger; 1800| 1.45M| using visitor_t = concat_merger_visitor; 1801| 1.45M| auto merger = merger_t{cpos.shift(), counts, n}; 1802| 1.45M| IMMER_TRY { ------------------ | | 41| 1.45M|#define IMMER_TRY try ------------------ 1803| 1.45M| lpos.each_left_sub(visitor_t{}, merger); 1804| 1.45M| cpos.each_sub(visitor_t{}, merger); 1805| 1.45M| rpos.each_right_sub(visitor_t{}, merger); 1806| 1.45M| cpos.each_sub(dec_visitor{}); 1807| 1.45M| return merger.finish(); 1808| 1.45M| } 1809| 1.45M| IMMER_CATCH (...) { 1810| 0| merger.abort(); 1811| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1812| 0| } 1813| 1.45M| } _ZN5immer6detail4rbts20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_11relaxed_posISC_EESH_RNS1_8leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1912| 3.96M| { 1913| 3.96M| return concat_inners(lpos, tpos, rpos); 1914| 3.96M| } _ZN5immer6detail4rbts20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_15regular_sub_posISC_EERNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1912| 4.58k| { 1913| 4.58k| return concat_inners(lpos, tpos, rpos); 1914| 4.58k| } _ZN5immer6detail4rbts13concat_innersINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EERNS1_15regular_sub_posISC_EEEENS1_17concat_center_posIT_EEOT0_OT1_OT2_: 1867| 22.1k|{ 1868| 22.1k| auto lshift = lpos.shift(); 1869| 22.1k| auto rshift = rpos.shift(); 1870| 22.1k| if (lshift > rshift) { ------------------ | Branch (1870:9): [True: 13.0k, False: 9.14k] ------------------ 1871| 13.0k| auto cpos = lpos.last_sub(concat_left_visitor{}, tpos, rpos); 1872| 13.0k| return concat_rebalance(lpos, cpos, null_sub_pos{}); 1873| 13.0k| } else if (lshift < rshift) { ------------------ | Branch (1873:16): [True: 7, False: 9.13k] ------------------ 1874| 7| auto cpos = rpos.first_sub(concat_right_visitor{}, lpos, tpos); 1875| 7| return concat_rebalance(null_sub_pos{}, cpos, rpos); 1876| 9.13k| } else { 1877| 9.13k| assert(lshift == rshift); 1878| 0| assert(Node::bits_leaf == 0u || lshift > 0); 1879| 0| auto cpos = lpos.last_sub(concat_both_visitor{}, tpos, rpos); 1880| 9.13k| return concat_rebalance(lpos, cpos, rpos); 1881| 9.13k| } 1882| 22.1k|} _ZN5immer6detail4rbts19concat_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EERNS1_15regular_sub_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1892| 12.9k| { 1893| 12.9k| return concat_inners(lpos, tpos, rpos); 1894| 12.9k| } _ZN5immer6detail4rbts20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_8full_posISC_EERNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1912| 35| { 1913| 35| return concat_inners(lpos, tpos, rpos); 1914| 35| } _ZN5immer6detail4rbts13concat_innersINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EERNS1_8full_posISC_EEEENS1_17concat_center_posIT_EEOT0_OT1_OT2_: 1867| 35|{ 1868| 35| auto lshift = lpos.shift(); 1869| 35| auto rshift = rpos.shift(); 1870| 35| if (lshift > rshift) { ------------------ | Branch (1870:9): [True: 0, False: 35] ------------------ 1871| 0| auto cpos = lpos.last_sub(concat_left_visitor{}, tpos, rpos); 1872| 0| return concat_rebalance(lpos, cpos, null_sub_pos{}); 1873| 35| } else if (lshift < rshift) { ------------------ | Branch (1873:16): [True: 1, False: 34] ------------------ 1874| 1| auto cpos = rpos.first_sub(concat_right_visitor{}, lpos, tpos); 1875| 1| return concat_rebalance(null_sub_pos{}, cpos, rpos); 1876| 34| } else { 1877| 34| assert(lshift == rshift); 1878| 0| assert(Node::bits_leaf == 0u || lshift > 0); 1879| 0| auto cpos = lpos.last_sub(concat_both_visitor{}, tpos, rpos); 1880| 34| return concat_rebalance(lpos, cpos, rpos); 1881| 34| } 1882| 35|} _ZN5immer6detail4rbts19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EERNS1_8full_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1932| 2| { 1933| 2| return rpos.first_sub(concat_right_visitor{}, lpos, tpos); 1934| 2| } _ZN5immer6detail4rbts16concat_rebalanceINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_11relaxed_posISC_EERNS1_17concat_center_posISC_EERNS1_8full_posISC_EEEENSG_IT_EEOT0_OT1_OT2_: 1818| 34|{ 1819| 34| auto plan = concat_rebalance_plan{}; 1820| 34| plan.fill(lpos, cpos, rpos); 1821| 34| plan.shuffle(cpos.shift()); 1822| 34| IMMER_TRY { ------------------ | | 41| 34|#define IMMER_TRY try ------------------ 1823| 34| return plan.merge(lpos, cpos, rpos); 1824| 34| } 1825| 34| IMMER_CATCH (...) { 1826| 0| cpos.each_sub(dec_visitor{}); 1827| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1828| 0| } 1829| 34|} _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE4fillIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_8full_posISF_EEEEvOT_OT0_OT1_: 1747| 34| { 1748| 34| assert(n == 0u); 1749| 0| assert(total == 0u); 1750| 0| using visitor_t = concat_rebalance_plan_fill_visitor; 1751| 34| lpos.each_left_sub(visitor_t{}, *this); 1752| 34| cpos.each_sub(visitor_t{}, *this); 1753| 34| rpos.each_right_sub(visitor_t{}, *this); 1754| 34| } _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE5mergeIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_8full_posISF_EEEENSI_INSt3__15decayIT0_E4type6node_tEEEOT_OSQ_OT1_: 1797| 34| { 1798| 34| using node_t = node_type; 1799| 34| using merger_t = concat_merger; 1800| 34| using visitor_t = concat_merger_visitor; 1801| 34| auto merger = merger_t{cpos.shift(), counts, n}; 1802| 34| IMMER_TRY { ------------------ | | 41| 34|#define IMMER_TRY try ------------------ 1803| 34| lpos.each_left_sub(visitor_t{}, merger); 1804| 34| cpos.each_sub(visitor_t{}, merger); 1805| 34| rpos.each_right_sub(visitor_t{}, merger); 1806| 34| cpos.each_sub(dec_visitor{}); 1807| 34| return merger.finish(); 1808| 34| } 1809| 34| IMMER_CATCH (...) { 1810| 0| merger.abort(); 1811| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1812| 0| } 1813| 34| } _ZN5immer6detail4rbts19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EERNS1_15regular_sub_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1932| 25| { 1933| 25| return rpos.first_sub(concat_right_visitor{}, lpos, tpos); 1934| 25| } _ZN5immer6detail4rbts16concat_rebalanceINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_11relaxed_posISC_EERNS1_17concat_center_posISC_EERNS1_15regular_sub_posISC_EEEENSG_IT_EEOT0_OT1_OT2_: 1818| 9.13k|{ 1819| 9.13k| auto plan = concat_rebalance_plan{}; 1820| 9.13k| plan.fill(lpos, cpos, rpos); 1821| 9.13k| plan.shuffle(cpos.shift()); 1822| 9.13k| IMMER_TRY { ------------------ | | 41| 9.13k|#define IMMER_TRY try ------------------ 1823| 9.13k| return plan.merge(lpos, cpos, rpos); 1824| 9.13k| } 1825| 9.13k| IMMER_CATCH (...) { 1826| 0| cpos.each_sub(dec_visitor{}); 1827| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1828| 0| } 1829| 9.13k|} _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE4fillIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_15regular_sub_posISF_EEEEvOT_OT0_OT1_: 1747| 9.13k| { 1748| 9.13k| assert(n == 0u); 1749| 0| assert(total == 0u); 1750| 0| using visitor_t = concat_rebalance_plan_fill_visitor; 1751| 9.13k| lpos.each_left_sub(visitor_t{}, *this); 1752| 9.13k| cpos.each_sub(visitor_t{}, *this); 1753| 9.13k| rpos.each_right_sub(visitor_t{}, *this); 1754| 9.13k| } _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE5mergeIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EERNS1_15regular_sub_posISF_EEEENSI_INSt3__15decayIT0_E4type6node_tEEEOT_OSQ_OT1_: 1797| 9.13k| { 1798| 9.13k| using node_t = node_type; 1799| 9.13k| using merger_t = concat_merger; 1800| 9.13k| using visitor_t = concat_merger_visitor; 1801| 9.13k| auto merger = merger_t{cpos.shift(), counts, n}; 1802| 9.13k| IMMER_TRY { ------------------ | | 41| 9.13k|#define IMMER_TRY try ------------------ 1803| 9.13k| lpos.each_left_sub(visitor_t{}, merger); 1804| 9.13k| cpos.each_sub(visitor_t{}, merger); 1805| 9.13k| rpos.each_right_sub(visitor_t{}, merger); 1806| 9.13k| cpos.each_sub(dec_visitor{}); 1807| 9.13k| return merger.finish(); 1808| 9.13k| } 1809| 9.13k| IMMER_CATCH (...) { 1810| 0| merger.abort(); 1811| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1812| 0| } 1813| 9.13k| } _ZN5immer6detail4rbts19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11visit_innerIRNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EESH_EENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1932| 3.95M| { 1933| 3.95M| return rpos.first_sub(concat_right_visitor{}, lpos, tpos); 1934| 3.95M| } _ZN5immer6detail4rbts16concat_rebalanceINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERNS1_11relaxed_posISC_EERNS1_17concat_center_posISC_EESF_EENSG_IT_EEOT0_OT1_OT2_: 1818| 4.42M|{ 1819| 4.42M| auto plan = concat_rebalance_plan{}; 1820| 4.42M| plan.fill(lpos, cpos, rpos); 1821| 4.42M| plan.shuffle(cpos.shift()); 1822| 4.42M| IMMER_TRY { ------------------ | | 41| 4.42M|#define IMMER_TRY try ------------------ 1823| 4.42M| return plan.merge(lpos, cpos, rpos); 1824| 4.42M| } 1825| 4.42M| IMMER_CATCH (...) { 1826| 0| cpos.each_sub(dec_visitor{}); 1827| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1828| 0| } 1829| 4.42M|} _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE4fillIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EESH_EEvOT_OT0_OT1_: 1747| 4.42M| { 1748| 4.42M| assert(n == 0u); 1749| 0| assert(total == 0u); 1750| 0| using visitor_t = concat_rebalance_plan_fill_visitor; 1751| 4.42M| lpos.each_left_sub(visitor_t{}, *this); 1752| 4.42M| cpos.each_sub(visitor_t{}, *this); 1753| 4.42M| rpos.each_right_sub(visitor_t{}, *this); 1754| 4.42M| } _ZN5immer6detail4rbts21concat_rebalance_planILj3ELj3EE5mergeIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_17concat_center_posISF_EESH_EENSI_INSt3__15decayIT0_E4type6node_tEEEOT_OSN_OT1_: 1797| 4.42M| { 1798| 4.42M| using node_t = node_type; 1799| 4.42M| using merger_t = concat_merger; 1800| 4.42M| using visitor_t = concat_merger_visitor; 1801| 4.42M| auto merger = merger_t{cpos.shift(), counts, n}; 1802| 4.42M| IMMER_TRY { ------------------ | | 41| 4.42M|#define IMMER_TRY try ------------------ 1803| 4.42M| lpos.each_left_sub(visitor_t{}, merger); 1804| 4.42M| cpos.each_sub(visitor_t{}, merger); 1805| 4.42M| rpos.each_right_sub(visitor_t{}, merger); 1806| 4.42M| cpos.each_sub(dec_visitor{}); 1807| 4.42M| return merger.finish(); 1808| 4.42M| } 1809| 4.42M| IMMER_CATCH (...) { 1810| 0| merger.abort(); 1811| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1812| 0| } 1813| 4.42M| } _ZN5immer6detail4rbts26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_nodeIRNS1_15regular_sub_posISC_EERNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1953| 4.63k| { 1954| 4.63k| return concat_inners(lpos, tpos, rpos); 1955| 4.63k| } _ZN5immer6detail4rbts25concat_trees_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_nodeIRNS1_15regular_sub_posISC_EENS1_8leaf_posISC_EEJRPSC_RjRmEEENS1_17concat_center_posISC_EEOT_OT0_DpOT1_: 1966| 1.82k| { 1967| 1.82k| return visit_maybe_relaxed_sub( 1968| 1.82k| args..., concat_trees_right_visitor{}, lpos, tpos); 1969| 1.82k| } _ZN5immer6detail4rbts26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_nodeIRNS1_11relaxed_posISC_EERNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1953| 579| { 1954| 579| return concat_inners(lpos, tpos, rpos); 1955| 579| } _ZN5immer6detail4rbts26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_nodeIRNS1_15regular_sub_posISC_EESH_RNS1_8leaf_posISC_EEEENS1_17concat_center_posISC_EEOT_OT0_OT1_: 1953| 1.24k| { 1954| 1.24k| return concat_inners(lpos, tpos, rpos); 1955| 1.24k| } _ZN5immer6detail4rbts21push_tail_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EE13visit_relaxedIRNS1_11relaxed_posISC_EEEEPSC_OT_NSA_5applyIS7_E4type4editESI_j: 679| 170k| { 680| 170k| auto node = pos.node(); 681| 170k| auto level = pos.shift(); 682| 170k| auto idx = pos.count() - 1; 683| 170k| auto children = pos.size(idx); 684| 170k| auto new_idx = 685| 170k| children == size_t{1} << level || level == BL ? idx + 1 : idx; ------------------ | Branch (685:13): [True: 675, False: 170k] | Branch (685:47): [True: 5, False: 170k] ------------------ 686| 170k| auto new_child = static_cast(nullptr); 687| 170k| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (687:26): [Folded - Ignored] | Branch (687:38): [True: 170k, False: 57] ------------------ 688| | 689| 170k| if (new_idx >= branches) ------------------ | Branch (689:13): [True: 125, False: 170k] ------------------ 690| 125| return nullptr; 691| 170k| else if (idx == new_idx) { ------------------ | Branch (691:18): [True: 170k, False: 555] ------------------ 692| 170k| new_child = 693| 170k| mutate ? pos.last_oh_csh(this_t{}, idx, children, e, tail, ts) ------------------ | Branch (693:17): [True: 170k, False: 45] ------------------ 694| 170k| : pos.last_oh_csh( 695| 45| this_no_mut_t{}, idx, children, e, tail, ts); 696| 170k| if (!new_child) { ------------------ | Branch (696:17): [True: 240, False: 170k] ------------------ 697| 240| if (++new_idx < branches) ------------------ | Branch (697:21): [True: 33, False: 207] ------------------ 698| 33| new_child = node_t::make_path_e(e, level - B, tail); 699| 207| else 700| 207| return nullptr; 701| 240| } 702| 170k| } else 703| 555| new_child = node_t::make_path_e(e, level - B, tail); 704| | 705| 170k| if (mutate) { ------------------ | Branch (705:13): [True: 170k, False: 57] ------------------ 706| 170k| auto count = new_idx + 1; 707| 170k| auto relaxed = node->ensure_mutable_relaxed_n(e, new_idx); 708| 170k| node->inner()[new_idx] = new_child; 709| 170k| relaxed->d.sizes[new_idx] = pos.size() + ts; 710| 170k| relaxed->d.count = count; 711| 170k| assert(relaxed->d.sizes[new_idx]); 712| 0| return node; 713| 170k| } else { 714| 57| IMMER_TRY { ------------------ | | 41| 57|#define IMMER_TRY try ------------------ 715| 57| auto count = new_idx + 1; 716| 57| auto new_node = node_t::copy_inner_r_e(e, pos.node(), new_idx); 717| 57| auto relaxed = new_node->relaxed(); 718| 57| new_node->inner()[new_idx] = new_child; 719| 57| relaxed->d.sizes[new_idx] = pos.size() + ts; 720| 57| relaxed->d.count = count; 721| 57| assert(relaxed->d.sizes[new_idx]); 722| 57| if (Mutating) ------------------ | Branch (722:21): [Folded - Ignored] ------------------ 723| 57| pos.visit(dec_visitor{}); 724| 57| return new_node; 725| 57| } 726| 57| IMMER_CATCH (...) { 727| 0| auto shift = pos.shift(); 728| 0| auto size = new_idx == idx ? children + ts : ts; ------------------ | Branch (728:30): [True: 0, False: 0] ------------------ 729| 0| if (shift > BL) { ------------------ | Branch (729:21): [True: 0, False: 0] ------------------ 730| 0| tail->inc(); 731| 0| dec_inner(new_child, shift - B, size); 732| 0| } 733| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 734| 0| } 735| 57| } 736| 170k| } _ZN5immer6detail4rbts21push_tail_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EE13visit_regularIRNS1_15regular_sub_posISC_EEJRjEEEPSC_OT_NSA_5applyIS7_E4type4editESJ_DpOT0_: 740| 127k| { 741| 127k| assert((pos.size() & mask) == 0); 742| 0| auto node = pos.node(); 743| 127k| auto idx = pos.index(pos.size() - 1); 744| 127k| auto new_idx = pos.index(pos.size() + branches - 1); 745| 127k| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (745:24): [Folded - Ignored] | Branch (745:36): [True: 127k, False: 11] ------------------ 746| 127k| if (mutate) { ------------------ | Branch (746:13): [True: 127k, False: 11] ------------------ 747| 127k| node->inner()[new_idx] = 748| 127k| idx == new_idx ? pos.last_oh(this_t{}, idx, e, tail) ------------------ | Branch (748:17): [True: 126k, False: 1.57k] ------------------ 749| | /* otherwise */ 750| 127k| : node_t::make_path_e(e, pos.shift() - B, tail); 751| 127k| return node; 752| 127k| } else { 753| 11| auto new_parent = node_t::make_inner_e(e); 754| 11| IMMER_TRY { ------------------ | | 41| 11|#define IMMER_TRY try ------------------ 755| 11| new_parent->inner()[new_idx] = 756| 11| idx == new_idx ------------------ | Branch (756:21): [True: 5, False: 6] ------------------ 757| 11| ? pos.last_oh(this_no_mut_t{}, idx, e, tail) 758| | /* otherwise */ 759| 11| : node_t::make_path_e(e, pos.shift() - B, tail); 760| 11| node_t::do_copy_inner(new_parent, node, new_idx); 761| 11| if (Mutating) ------------------ | Branch (761:21): [Folded - Ignored] ------------------ 762| 11| pos.visit(dec_visitor{}); 763| 11| return new_parent; 764| 11| } 765| 11| IMMER_CATCH (...) { 766| 0| node_t::delete_inner_e(new_parent); 767| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 768| 0| } 769| 11| } 770| 127k| } _ZN5immer6detail4rbts21push_tail_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EE13visit_regularIRNS1_11regular_posISC_EEJEEEPSC_OT_NSA_5applyIS7_E4type4editESI_DpOT0_: 740| 816k| { 741| 816k| assert((pos.size() & mask) == 0); 742| 0| auto node = pos.node(); 743| 816k| auto idx = pos.index(pos.size() - 1); 744| 816k| auto new_idx = pos.index(pos.size() + branches - 1); 745| 816k| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (745:24): [Folded - Ignored] | Branch (745:36): [True: 816k, False: 0] ------------------ 746| 816k| if (mutate) { ------------------ | Branch (746:13): [True: 816k, False: 0] ------------------ 747| 816k| node->inner()[new_idx] = 748| 816k| idx == new_idx ? pos.last_oh(this_t{}, idx, e, tail) ------------------ | Branch (748:17): [True: 554k, False: 261k] ------------------ 749| | /* otherwise */ 750| 816k| : node_t::make_path_e(e, pos.shift() - B, tail); 751| 816k| return node; 752| 816k| } else { 753| 0| auto new_parent = node_t::make_inner_e(e); 754| 0| IMMER_TRY { ------------------ | | 41| 0|#define IMMER_TRY try ------------------ 755| 0| new_parent->inner()[new_idx] = 756| 0| idx == new_idx ------------------ | Branch (756:21): [True: 0, False: 0] ------------------ 757| 0| ? pos.last_oh(this_no_mut_t{}, idx, e, tail) 758| | /* otherwise */ 759| 0| : node_t::make_path_e(e, pos.shift() - B, tail); 760| 0| node_t::do_copy_inner(new_parent, node, new_idx); 761| 0| if (Mutating) ------------------ | Branch (761:21): [Folded - Ignored] ------------------ 762| 0| pos.visit(dec_visitor{}); 763| 0| return new_parent; 764| 0| } 765| 0| IMMER_CATCH (...) { 766| 0| node_t::delete_inner_e(new_parent); 767| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 768| 0| } 769| 0| } 770| 816k| } _ZN5immer6detail4rbts21push_tail_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EE13visit_regularIRNS1_11regular_posISC_EEJEEEPSC_OT_NSA_5applyIS7_E4type4editESI_DpOT0_: 740| 795| { 741| 795| assert((pos.size() & mask) == 0); 742| 0| auto node = pos.node(); 743| 795| auto idx = pos.index(pos.size() - 1); 744| 795| auto new_idx = pos.index(pos.size() + branches - 1); 745| 795| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (745:24): [Folded - Ignored] | Branch (745:36): [True: 0, False: 0] ------------------ 746| 795| if (mutate) { ------------------ | Branch (746:13): [True: 0, False: 795] ------------------ 747| 0| node->inner()[new_idx] = 748| 0| idx == new_idx ? pos.last_oh(this_t{}, idx, e, tail) ------------------ | Branch (748:17): [True: 0, False: 0] ------------------ 749| | /* otherwise */ 750| 0| : node_t::make_path_e(e, pos.shift() - B, tail); 751| 0| return node; 752| 795| } else { 753| 795| auto new_parent = node_t::make_inner_e(e); 754| 795| IMMER_TRY { ------------------ | | 41| 795|#define IMMER_TRY try ------------------ 755| 795| new_parent->inner()[new_idx] = 756| 795| idx == new_idx ------------------ | Branch (756:21): [True: 532, False: 263] ------------------ 757| 795| ? pos.last_oh(this_no_mut_t{}, idx, e, tail) 758| | /* otherwise */ 759| 795| : node_t::make_path_e(e, pos.shift() - B, tail); 760| 795| node_t::do_copy_inner(new_parent, node, new_idx); 761| 795| if (Mutating) ------------------ | Branch (761:21): [Folded - Ignored] ------------------ 762| 0| pos.visit(dec_visitor{}); 763| 795| return new_parent; 764| 795| } 765| 795| IMMER_CATCH (...) { 766| 0| node_t::delete_inner_e(new_parent); 767| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 768| 0| } 769| 795| } 770| 795| } _ZN5immer6detail4rbts21push_tail_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EE13visit_relaxedIRNS1_11relaxed_posISC_EEEEPSC_OT_NSA_5applyIS7_E4type4editESI_j: 679| 97| { 680| 97| auto node = pos.node(); 681| 97| auto level = pos.shift(); 682| 97| auto idx = pos.count() - 1; 683| 97| auto children = pos.size(idx); 684| 97| auto new_idx = 685| 97| children == size_t{1} << level || level == BL ? idx + 1 : idx; ------------------ | Branch (685:13): [True: 22, False: 75] | Branch (685:47): [True: 0, False: 75] ------------------ 686| 97| auto new_child = static_cast(nullptr); 687| 97| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (687:26): [Folded - Ignored] | Branch (687:38): [True: 0, False: 0] ------------------ 688| | 689| 97| if (new_idx >= branches) ------------------ | Branch (689:13): [True: 4, False: 93] ------------------ 690| 4| return nullptr; 691| 93| else if (idx == new_idx) { ------------------ | Branch (691:18): [True: 75, False: 18] ------------------ 692| 75| new_child = 693| 75| mutate ? pos.last_oh_csh(this_t{}, idx, children, e, tail, ts) ------------------ | Branch (693:17): [True: 0, False: 75] ------------------ 694| 75| : pos.last_oh_csh( 695| 75| this_no_mut_t{}, idx, children, e, tail, ts); 696| 75| if (!new_child) { ------------------ | Branch (696:17): [True: 2, False: 73] ------------------ 697| 2| if (++new_idx < branches) ------------------ | Branch (697:21): [True: 2, False: 0] ------------------ 698| 2| new_child = node_t::make_path_e(e, level - B, tail); 699| 0| else 700| 0| return nullptr; 701| 2| } 702| 75| } else 703| 18| new_child = node_t::make_path_e(e, level - B, tail); 704| | 705| 93| if (mutate) { ------------------ | Branch (705:13): [True: 0, False: 93] ------------------ 706| 0| auto count = new_idx + 1; 707| 0| auto relaxed = node->ensure_mutable_relaxed_n(e, new_idx); 708| 0| node->inner()[new_idx] = new_child; 709| 0| relaxed->d.sizes[new_idx] = pos.size() + ts; 710| 0| relaxed->d.count = count; 711| 0| assert(relaxed->d.sizes[new_idx]); 712| 0| return node; 713| 93| } else { 714| 93| IMMER_TRY { ------------------ | | 41| 93|#define IMMER_TRY try ------------------ 715| 93| auto count = new_idx + 1; 716| 93| auto new_node = node_t::copy_inner_r_e(e, pos.node(), new_idx); 717| 93| auto relaxed = new_node->relaxed(); 718| 93| new_node->inner()[new_idx] = new_child; 719| 93| relaxed->d.sizes[new_idx] = pos.size() + ts; 720| 93| relaxed->d.count = count; 721| 93| assert(relaxed->d.sizes[new_idx]); 722| 93| if (Mutating) ------------------ | Branch (722:21): [Folded - Ignored] ------------------ 723| 0| pos.visit(dec_visitor{}); 724| 93| return new_node; 725| 93| } 726| 93| IMMER_CATCH (...) { 727| 0| auto shift = pos.shift(); 728| 0| auto size = new_idx == idx ? children + ts : ts; ------------------ | Branch (728:30): [True: 0, False: 0] ------------------ 729| 0| if (shift > BL) { ------------------ | Branch (729:21): [True: 0, False: 0] ------------------ 730| 0| tail->inc(); 731| 0| dec_inner(new_child, shift - B, size); 732| 0| } 733| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 734| 0| } 735| 93| } 736| 93| } _ZN5immer6detail4rbts21push_tail_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EE13visit_regularIRNS1_15regular_sub_posISC_EEJRjEEEPSC_OT_NSA_5applyIS7_E4type4editESJ_DpOT0_: 740| 23| { 741| 23| assert((pos.size() & mask) == 0); 742| 0| auto node = pos.node(); 743| 23| auto idx = pos.index(pos.size() - 1); 744| 23| auto new_idx = pos.index(pos.size() + branches - 1); 745| 23| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (745:24): [Folded - Ignored] | Branch (745:36): [True: 0, False: 0] ------------------ 746| 23| if (mutate) { ------------------ | Branch (746:13): [True: 0, False: 23] ------------------ 747| 0| node->inner()[new_idx] = 748| 0| idx == new_idx ? pos.last_oh(this_t{}, idx, e, tail) ------------------ | Branch (748:17): [True: 0, False: 0] ------------------ 749| | /* otherwise */ 750| 0| : node_t::make_path_e(e, pos.shift() - B, tail); 751| 0| return node; 752| 23| } else { 753| 23| auto new_parent = node_t::make_inner_e(e); 754| 23| IMMER_TRY { ------------------ | | 41| 23|#define IMMER_TRY try ------------------ 755| 23| new_parent->inner()[new_idx] = 756| 23| idx == new_idx ------------------ | Branch (756:21): [True: 9, False: 14] ------------------ 757| 23| ? pos.last_oh(this_no_mut_t{}, idx, e, tail) 758| | /* otherwise */ 759| 23| : node_t::make_path_e(e, pos.shift() - B, tail); 760| 23| node_t::do_copy_inner(new_parent, node, new_idx); 761| 23| if (Mutating) ------------------ | Branch (761:21): [Folded - Ignored] ------------------ 762| 0| pos.visit(dec_visitor{}); 763| 23| return new_parent; 764| 23| } 765| 23| IMMER_CATCH (...) { 766| 0| node_t::delete_inner_e(new_parent); 767| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 768| 0| } 769| 23| } 770| 23| } _ZN5immer6detail4rbts21push_tail_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EE13visit_regularIRNS1_15regular_sub_posISC_EEJEEEPSC_OT_NSA_5applyIS7_E4type4editESI_DpOT0_: 740| 136k| { 741| 136k| assert((pos.size() & mask) == 0); 742| 0| auto node = pos.node(); 743| 136k| auto idx = pos.index(pos.size() - 1); 744| 136k| auto new_idx = pos.index(pos.size() + branches - 1); 745| 136k| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (745:24): [Folded - Ignored] | Branch (745:36): [True: 136k, False: 297] ------------------ 746| 136k| if (mutate) { ------------------ | Branch (746:13): [True: 136k, False: 297] ------------------ 747| 136k| node->inner()[new_idx] = 748| 136k| idx == new_idx ? pos.last_oh(this_t{}, idx, e, tail) ------------------ | Branch (748:17): [True: 135k, False: 1.26k] ------------------ 749| | /* otherwise */ 750| 136k| : node_t::make_path_e(e, pos.shift() - B, tail); 751| 136k| return node; 752| 136k| } else { 753| 297| auto new_parent = node_t::make_inner_e(e); 754| 297| IMMER_TRY { ------------------ | | 41| 297|#define IMMER_TRY try ------------------ 755| 297| new_parent->inner()[new_idx] = 756| 297| idx == new_idx ------------------ | Branch (756:21): [True: 249, False: 48] ------------------ 757| 297| ? pos.last_oh(this_no_mut_t{}, idx, e, tail) 758| | /* otherwise */ 759| 297| : node_t::make_path_e(e, pos.shift() - B, tail); 760| 297| node_t::do_copy_inner(new_parent, node, new_idx); 761| 297| if (Mutating) ------------------ | Branch (761:21): [Folded - Ignored] ------------------ 762| 297| pos.visit(dec_visitor{}); 763| 297| return new_parent; 764| 297| } 765| 297| IMMER_CATCH (...) { 766| 0| node_t::delete_inner_e(new_parent); 767| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 768| 0| } 769| 297| } 770| 136k| } _ZN5immer6detail4rbts17dec_empty_regularINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEvPT_: 579| 91|{ 580| 91| make_empty_regular_pos(node).visit(dec_visitor()); 581| 91|} _ZN5immer6detail4rbts15get_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13visit_relaxedIRNS1_11relaxed_posISC_EEEERiOT_mNSA_5applyIS7_E4type4editEPPSC_: 594| 16.4k| { 595| 16.4k| auto offset = pos.index(idx); 596| 16.4k| auto count = pos.count(); 597| 16.4k| auto node = pos.node(); 598| 16.4k| if (node->can_mutate(e)) { ------------------ | Branch (598:13): [True: 8.78k, False: 7.67k] ------------------ 599| 8.78k| return pos.towards_oh( 600| 8.78k| this_t{}, idx, offset, e, &node->inner()[offset]); 601| 8.78k| } else { 602| 7.67k| auto new_node = node_t::copy_inner_sr_e(e, node, count); 603| 7.67k| IMMER_TRY { ------------------ | | 41| 7.67k|#define IMMER_TRY try ------------------ 604| 7.67k| auto& res = pos.towards_oh( 605| 7.67k| this_t{}, idx, offset, e, &new_node->inner()[offset]); 606| 7.67k| pos.visit(dec_visitor{}); 607| 7.67k| *location = new_node; 608| 7.67k| return res; 609| 7.67k| } 610| 7.67k| IMMER_CATCH (...) { 611| 0| dec_relaxed(new_node, pos.shift()); 612| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 613| 0| } 614| 7.67k| } 615| 16.4k| } _ZN5immer6detail4rbts15get_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_leafIRNS1_12leaf_sub_posISC_EEEERiOT_mNSA_5applyIS7_E4type4editEPPSC_: 651| 2.06k| { 652| 2.06k| assert(pos.node() == *location); 653| 0| auto node = pos.node(); 654| 2.06k| if (node->can_mutate(e)) { ------------------ | Branch (654:13): [True: 380, False: 1.68k] ------------------ 655| 380| return node->leaf()[pos.index(idx)]; 656| 1.68k| } else { 657| 1.68k| auto new_node = node_t::copy_leaf_e(e, pos.node(), pos.count()); 658| 1.68k| pos.visit(dec_visitor{}); 659| 1.68k| *location = new_node; 660| 1.68k| return new_node->leaf()[pos.index(idx)]; 661| 1.68k| } 662| 2.06k| } _ZN5immer6detail4rbts15get_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13visit_regularIRNS1_15regular_sub_posISC_EEEERiOT_mNSA_5applyIS7_E4type4editEPPSC_: 620| 2.07k| { 621| 2.07k| assert(pos.node() == *location); 622| 0| auto offset = pos.index(idx); 623| 2.07k| auto count = pos.count(); 624| 2.07k| auto node = pos.node(); 625| 2.07k| if (node->can_mutate(e)) { ------------------ | Branch (625:13): [True: 704, False: 1.37k] ------------------ 626| 704| return pos.towards_oh_ch( 627| 704| this_t{}, idx, offset, count, e, &node->inner()[offset]); 628| 1.37k| } else { 629| 1.37k| auto new_node = node_t::copy_inner_e(e, node, count); 630| 1.37k| IMMER_TRY { ------------------ | | 41| 1.37k|#define IMMER_TRY try ------------------ 631| 1.37k| auto& res = pos.towards_oh_ch(this_t{}, 632| 1.37k| idx, 633| 1.37k| offset, 634| 1.37k| count, 635| 1.37k| e, 636| 1.37k| &new_node->inner()[offset]); 637| 1.37k| pos.visit(dec_visitor{}); 638| 1.37k| *location = new_node; 639| 1.37k| return res; 640| 1.37k| } 641| 1.37k| IMMER_CATCH (...) { 642| 0| dec_regular(new_node, pos.shift(), pos.size()); 643| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 644| 0| } 645| 1.37k| } 646| 2.07k| } _ZN5immer6detail4rbts15get_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_leafIRNS1_13full_leaf_posISC_EEEERiOT_mNSA_5applyIS7_E4type4editEPPSC_: 651| 1.85k| { 652| 1.85k| assert(pos.node() == *location); 653| 0| auto node = pos.node(); 654| 1.85k| if (node->can_mutate(e)) { ------------------ | Branch (654:13): [True: 235, False: 1.61k] ------------------ 655| 235| return node->leaf()[pos.index(idx)]; 656| 1.61k| } else { 657| 1.61k| auto new_node = node_t::copy_leaf_e(e, pos.node(), pos.count()); 658| 1.61k| pos.visit(dec_visitor{}); 659| 1.61k| *location = new_node; 660| 1.61k| return new_node->leaf()[pos.index(idx)]; 661| 1.61k| } 662| 1.85k| } _ZN5immer6detail4rbts15get_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13visit_regularIRNS1_8full_posISC_EEEERiOT_mNSA_5applyIS7_E4type4editEPPSC_: 620| 685| { 621| 685| assert(pos.node() == *location); 622| 0| auto offset = pos.index(idx); 623| 685| auto count = pos.count(); 624| 685| auto node = pos.node(); 625| 685| if (node->can_mutate(e)) { ------------------ | Branch (625:13): [True: 192, False: 493] ------------------ 626| 192| return pos.towards_oh_ch( 627| 192| this_t{}, idx, offset, count, e, &node->inner()[offset]); 628| 493| } else { 629| 493| auto new_node = node_t::copy_inner_e(e, node, count); 630| 493| IMMER_TRY { ------------------ | | 41| 493|#define IMMER_TRY try ------------------ 631| 493| auto& res = pos.towards_oh_ch(this_t{}, 632| 493| idx, 633| 493| offset, 634| 493| count, 635| 493| e, 636| 493| &new_node->inner()[offset]); 637| 493| pos.visit(dec_visitor{}); 638| 493| *location = new_node; 639| 493| return res; 640| 493| } 641| 493| IMMER_CATCH (...) { 642| 0| dec_regular(new_node, pos.shift(), pos.size()); 643| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 644| 0| } 645| 493| } 646| 685| } _ZN5immer6detail4rbts15get_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10visit_leafIRNS1_8leaf_posISC_EEEERiOT_mNSA_5applyIS7_E4type4editEPPSC_: 651| 224| { 652| 224| assert(pos.node() == *location); 653| 0| auto node = pos.node(); 654| 224| if (node->can_mutate(e)) { ------------------ | Branch (654:13): [True: 116, False: 108] ------------------ 655| 116| return node->leaf()[pos.index(idx)]; 656| 116| } else { 657| 108| auto new_node = node_t::copy_leaf_e(e, pos.node(), pos.count()); 658| 108| pos.visit(dec_visitor{}); 659| 108| *location = new_node; 660| 108| return new_node->leaf()[pos.index(idx)]; 661| 108| } 662| 224| } _ZN5immer6detail4rbts15get_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13visit_regularIRNS1_11regular_posISC_EEEERiOT_mNSA_5applyIS7_E4type4editEPPSC_: 620| 74| { 621| 74| assert(pos.node() == *location); 622| 0| auto offset = pos.index(idx); 623| 74| auto count = pos.count(); 624| 74| auto node = pos.node(); 625| 74| if (node->can_mutate(e)) { ------------------ | Branch (625:13): [True: 14, False: 60] ------------------ 626| 14| return pos.towards_oh_ch( 627| 14| this_t{}, idx, offset, count, e, &node->inner()[offset]); 628| 60| } else { 629| 60| auto new_node = node_t::copy_inner_e(e, node, count); 630| 60| IMMER_TRY { ------------------ | | 41| 60|#define IMMER_TRY try ------------------ 631| 60| auto& res = pos.towards_oh_ch(this_t{}, 632| 60| idx, 633| 60| offset, 634| 60| count, 635| 60| e, 636| 60| &new_node->inner()[offset]); 637| 60| pos.visit(dec_visitor{}); 638| 60| *location = new_node; 639| 60| return res; 640| 60| } 641| 60| IMMER_CATCH (...) { 642| 0| dec_regular(new_node, pos.shift(), pos.size()); 643| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 644| 0| } 645| 60| } 646| 74| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb1EE13visit_relaxedIRNS1_11relaxed_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 912| 40.8k| { 913| 40.8k| auto idx = pos.index(last); 914| 40.8k| auto node = pos.node(); 915| 40.8k| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (915:23): [Folded - Ignored] | Branch (915:35): [True: 37.6k, False: 3.15k] ------------------ 916| 40.8k| if (Collapse && idx == 0) { ------------------ | Branch (916:13): [Folded - Ignored] | Branch (916:25): [True: 35.5k, False: 5.29k] ------------------ 917| 35.5k| auto res = mutate ? pos.towards_oh(this_t{}, last, idx, e) ------------------ | Branch (917:24): [True: 33.7k, False: 1.80k] ------------------ 918| 35.5k| : pos.towards_oh(no_mut_t{}, last, idx, e); 919| 35.5k| if (Mutating) ------------------ | Branch (919:17): [Folded - Ignored] ------------------ 920| 35.5k| pos.visit(dec_right_visitor{}, count_t{1}); 921| 35.5k| return res; 922| 35.5k| } else { 923| 5.29k| using std::get; 924| 5.29k| auto subs = 925| 5.29k| mutate ? pos.towards_oh(no_collapse_t{}, last, idx, e) ------------------ | Branch (925:17): [True: 3.94k, False: 1.35k] ------------------ 926| 5.29k| : pos.towards_oh(no_collapse_no_mut_t{}, last, idx, e); 927| 5.29k| auto next = get<1>(subs); 928| 5.29k| auto ts = get<2>(subs); 929| 5.29k| auto tail = get<3>(subs); 930| 5.29k| IMMER_TRY { ------------------ | | 41| 5.29k|#define IMMER_TRY try ------------------ 931| 5.29k| if (next) { ------------------ | Branch (931:21): [True: 3.31k, False: 1.98k] ------------------ 932| 3.31k| if (mutate) { ------------------ | Branch (932:25): [True: 2.39k, False: 920] ------------------ 933| 2.39k| auto nodr = node->ensure_mutable_relaxed_n(e, idx); 934| 2.39k| pos.each_right(dec_visitor{}, idx + 1); 935| 2.39k| node->inner()[idx] = next; 936| 2.39k| nodr->d.sizes[idx] = last + 1 - ts; 937| 2.39k| nodr->d.count = idx + 1; 938| 2.39k| assert(nodr->d.sizes[idx]); 939| 0| return std::make_tuple(pos.shift(), node, ts, tail); 940| 2.39k| } else { 941| 920| auto newn = node_t::copy_inner_r_e(e, node, idx); 942| 920| auto newr = newn->relaxed(); 943| 920| newn->inner()[idx] = next; 944| 920| newr->d.sizes[idx] = last + 1 - ts; 945| 920| newr->d.count = idx + 1; 946| 920| assert(newr->d.sizes[idx]); 947| 920| if (Mutating) ------------------ | Branch (947:29): [Folded - Ignored] ------------------ 948| 920| pos.visit(dec_visitor{}); 949| 920| return std::make_tuple(pos.shift(), newn, ts, tail); 950| 920| } 951| 3.31k| } else if (idx == 0) { ------------------ | Branch (951:28): [True: 0, False: 1.98k] ------------------ 952| 0| if (Mutating) ------------------ | Branch (952:25): [Folded - Ignored] ------------------ 953| 0| pos.visit(dec_right_visitor{}, count_t{1}); 954| 0| return std::make_tuple(pos.shift(), nullptr, ts, tail); 955| 1.98k| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (955:28): [Folded - Ignored] | Branch (955:40): [True: 1.74k, False: 242] | Branch (955:52): [True: 1.53k, False: 206] ------------------ 956| 1.53k| auto newn = pos.node()->inner()[0]; 957| 1.53k| if (!mutate) ------------------ | Branch (957:25): [True: 338, False: 1.20k] ------------------ 958| 338| newn->inc(); 959| 1.53k| if (Mutating) ------------------ | Branch (959:25): [Folded - Ignored] ------------------ 960| 1.53k| pos.visit(dec_right_visitor{}, count_t{2}); 961| 1.53k| return std::make_tuple(pos.shift() - B, newn, ts, tail); 962| 1.53k| } else { 963| 448| if (mutate) { ------------------ | Branch (963:25): [True: 349, False: 99] ------------------ 964| 349| pos.each_right(dec_visitor{}, idx + 1); 965| 349| node->ensure_mutable_relaxed_n(e, idx)->d.count = idx; 966| 349| return std::make_tuple(pos.shift(), node, ts, tail); 967| 349| } else { 968| 99| auto newn = node_t::copy_inner_r_e(e, node, idx); 969| 99| if (Mutating) ------------------ | Branch (969:29): [Folded - Ignored] ------------------ 970| 99| pos.visit(dec_visitor{}); 971| 99| return std::make_tuple(pos.shift(), newn, ts, tail); 972| 99| } 973| 448| } 974| 5.29k| } 975| 5.29k| IMMER_CATCH (...) { 976| 0| assert(!mutate); 977| 0| assert(!next || pos.shift() > BL); 978| 0| if (next) ------------------ | Branch (978:21): [True: 0, False: 0] ------------------ 979| 0| dec_inner(next, 980| 0| pos.shift() - B, 981| 0| last + 1 - ts - pos.size_before(idx)); 982| 0| dec_leaf(tail, ts); 983| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 984| 0| } 985| 5.29k| } 986| 40.8k| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb1EE10visit_leafIRNS1_12leaf_sub_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 1058| 75| { 1059| 75| auto old_tail_size = pos.count(); 1060| 75| auto new_tail_size = pos.index(last) + 1; 1061| 75| auto node = pos.node(); 1062| 75| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (1062:30): [Folded - Ignored] | Branch (1062:42): [True: 36, False: 39] ------------------ 1063| 75| if (new_tail_size == old_tail_size) { ------------------ | Branch (1063:13): [True: 4, False: 71] ------------------ 1064| 4| if (!Mutating) ------------------ | Branch (1064:17): [Folded - Ignored] ------------------ 1065| 0| node->inc(); 1066| 4| return std::make_tuple(0, nullptr, new_tail_size, node); 1067| 71| } else if (mutate) { ------------------ | Branch (1067:20): [True: 33, False: 38] ------------------ 1068| 33| detail::destroy_n(node->leaf() + new_tail_size, 1069| 33| old_tail_size - new_tail_size); 1070| 33| return std::make_tuple(0, nullptr, new_tail_size, node); 1071| 38| } else { 1072| 38| auto new_tail = node_t::copy_leaf_e(e, node, new_tail_size); 1073| 38| if (Mutating) ------------------ | Branch (1073:17): [Folded - Ignored] ------------------ 1074| 38| pos.visit(dec_visitor{}); 1075| 38| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1076| 38| } 1077| 75| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb0EE10visit_leafIRNS1_12leaf_sub_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 1058| 374| { 1059| 374| auto old_tail_size = pos.count(); 1060| 374| auto new_tail_size = pos.index(last) + 1; 1061| 374| auto node = pos.node(); 1062| 374| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (1062:30): [Folded - Ignored] | Branch (1062:42): [True: 0, False: 0] ------------------ 1063| 374| if (new_tail_size == old_tail_size) { ------------------ | Branch (1063:13): [True: 134, False: 240] ------------------ 1064| 134| if (!Mutating) ------------------ | Branch (1064:17): [Folded - Ignored] ------------------ 1065| 134| node->inc(); 1066| 134| return std::make_tuple(0, nullptr, new_tail_size, node); 1067| 240| } else if (mutate) { ------------------ | Branch (1067:20): [True: 0, False: 240] ------------------ 1068| 0| detail::destroy_n(node->leaf() + new_tail_size, 1069| 0| old_tail_size - new_tail_size); 1070| 0| return std::make_tuple(0, nullptr, new_tail_size, node); 1071| 240| } else { 1072| 240| auto new_tail = node_t::copy_leaf_e(e, node, new_tail_size); 1073| 240| if (Mutating) ------------------ | Branch (1073:17): [Folded - Ignored] ------------------ 1074| 0| pos.visit(dec_visitor{}); 1075| 240| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1076| 240| } 1077| 374| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb0EE13visit_relaxedIRNS1_11relaxed_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 912| 10.1k| { 913| 10.1k| auto idx = pos.index(last); 914| 10.1k| auto node = pos.node(); 915| 10.1k| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (915:23): [Folded - Ignored] | Branch (915:35): [True: 0, False: 0] ------------------ 916| 10.1k| if (Collapse && idx == 0) { ------------------ | Branch (916:13): [Folded - Ignored] | Branch (916:25): [True: 8.76k, False: 1.34k] ------------------ 917| 8.76k| auto res = mutate ? pos.towards_oh(this_t{}, last, idx, e) ------------------ | Branch (917:24): [True: 0, False: 8.76k] ------------------ 918| 8.76k| : pos.towards_oh(no_mut_t{}, last, idx, e); 919| 8.76k| if (Mutating) ------------------ | Branch (919:17): [Folded - Ignored] ------------------ 920| 0| pos.visit(dec_right_visitor{}, count_t{1}); 921| 8.76k| return res; 922| 8.76k| } else { 923| 1.34k| using std::get; 924| 1.34k| auto subs = 925| 1.34k| mutate ? pos.towards_oh(no_collapse_t{}, last, idx, e) ------------------ | Branch (925:17): [True: 0, False: 1.34k] ------------------ 926| 1.34k| : pos.towards_oh(no_collapse_no_mut_t{}, last, idx, e); 927| 1.34k| auto next = get<1>(subs); 928| 1.34k| auto ts = get<2>(subs); 929| 1.34k| auto tail = get<3>(subs); 930| 1.34k| IMMER_TRY { ------------------ | | 41| 1.34k|#define IMMER_TRY try ------------------ 931| 1.34k| if (next) { ------------------ | Branch (931:21): [True: 894, False: 446] ------------------ 932| 894| if (mutate) { ------------------ | Branch (932:25): [True: 0, False: 894] ------------------ 933| 0| auto nodr = node->ensure_mutable_relaxed_n(e, idx); 934| 0| pos.each_right(dec_visitor{}, idx + 1); 935| 0| node->inner()[idx] = next; 936| 0| nodr->d.sizes[idx] = last + 1 - ts; 937| 0| nodr->d.count = idx + 1; 938| 0| assert(nodr->d.sizes[idx]); 939| 0| return std::make_tuple(pos.shift(), node, ts, tail); 940| 894| } else { 941| 894| auto newn = node_t::copy_inner_r_e(e, node, idx); 942| 894| auto newr = newn->relaxed(); 943| 894| newn->inner()[idx] = next; 944| 894| newr->d.sizes[idx] = last + 1 - ts; 945| 894| newr->d.count = idx + 1; 946| 894| assert(newr->d.sizes[idx]); 947| 894| if (Mutating) ------------------ | Branch (947:29): [Folded - Ignored] ------------------ 948| 0| pos.visit(dec_visitor{}); 949| 894| return std::make_tuple(pos.shift(), newn, ts, tail); 950| 894| } 951| 894| } else if (idx == 0) { ------------------ | Branch (951:28): [True: 0, False: 446] ------------------ 952| 0| if (Mutating) ------------------ | Branch (952:25): [Folded - Ignored] ------------------ 953| 0| pos.visit(dec_right_visitor{}, count_t{1}); 954| 0| return std::make_tuple(pos.shift(), nullptr, ts, tail); 955| 446| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (955:28): [Folded - Ignored] | Branch (955:40): [True: 282, False: 164] | Branch (955:52): [True: 237, False: 45] ------------------ 956| 237| auto newn = pos.node()->inner()[0]; 957| 237| if (!mutate) ------------------ | Branch (957:25): [True: 237, False: 0] ------------------ 958| 237| newn->inc(); 959| 237| if (Mutating) ------------------ | Branch (959:25): [Folded - Ignored] ------------------ 960| 0| pos.visit(dec_right_visitor{}, count_t{2}); 961| 237| return std::make_tuple(pos.shift() - B, newn, ts, tail); 962| 237| } else { 963| 209| if (mutate) { ------------------ | Branch (963:25): [True: 0, False: 209] ------------------ 964| 0| pos.each_right(dec_visitor{}, idx + 1); 965| 0| node->ensure_mutable_relaxed_n(e, idx)->d.count = idx; 966| 0| return std::make_tuple(pos.shift(), node, ts, tail); 967| 209| } else { 968| 209| auto newn = node_t::copy_inner_r_e(e, node, idx); 969| 209| if (Mutating) ------------------ | Branch (969:29): [Folded - Ignored] ------------------ 970| 0| pos.visit(dec_visitor{}); 971| 209| return std::make_tuple(pos.shift(), newn, ts, tail); 972| 209| } 973| 209| } 974| 1.34k| } 975| 1.34k| IMMER_CATCH (...) { 976| 0| assert(!mutate); 977| 0| assert(!next || pos.shift() > BL); 978| 0| if (next) ------------------ | Branch (978:21): [True: 0, False: 0] ------------------ 979| 0| dec_inner(next, 980| 0| pos.shift() - B, 981| 0| last + 1 - ts - pos.size_before(idx)); 982| 0| dec_leaf(tail, ts); 983| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 984| 0| } 985| 1.34k| } 986| 10.1k| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb0EE13visit_regularIRNS1_15regular_sub_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 990| 87| { 991| 87| auto idx = pos.index(last); 992| 87| auto node = pos.node(); 993| 87| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (993:23): [Folded - Ignored] | Branch (993:35): [True: 0, False: 0] ------------------ 994| 87| if (Collapse && idx == 0) { ------------------ | Branch (994:13): [Folded - Ignored] | Branch (994:25): [True: 67, False: 20] ------------------ 995| 67| auto res = mutate ? pos.towards_oh(this_t{}, last, idx, e) ------------------ | Branch (995:24): [True: 0, False: 67] ------------------ 996| 67| : pos.towards_oh(no_mut_t{}, last, idx, e); 997| 67| if (Mutating) ------------------ | Branch (997:17): [Folded - Ignored] ------------------ 998| 0| pos.visit(dec_right_visitor{}, count_t{1}); 999| 67| return res; 1000| 67| } else { 1001| 20| using std::get; 1002| 20| auto subs = 1003| 20| mutate ? pos.towards_oh(no_collapse_t{}, last, idx, e) ------------------ | Branch (1003:17): [True: 0, False: 20] ------------------ 1004| 20| : pos.towards_oh(no_collapse_no_mut_t{}, last, idx, e); 1005| 20| auto next = get<1>(subs); 1006| 20| auto ts = get<2>(subs); 1007| 20| auto tail = get<3>(subs); 1008| 20| IMMER_TRY { ------------------ | | 41| 20|#define IMMER_TRY try ------------------ 1009| 20| if (next) { ------------------ | Branch (1009:21): [True: 0, False: 20] ------------------ 1010| 0| if (mutate) { ------------------ | Branch (1010:25): [True: 0, False: 0] ------------------ 1011| 0| node->inner()[idx] = next; 1012| 0| pos.each_right(dec_visitor{}, idx + 1); 1013| 0| return std::make_tuple(pos.shift(), node, ts, tail); 1014| 0| } else { 1015| 0| auto newn = node_t::copy_inner_e(e, node, idx); 1016| 0| newn->inner()[idx] = next; 1017| 0| if (Mutating) ------------------ | Branch (1017:29): [Folded - Ignored] ------------------ 1018| 0| pos.visit(dec_visitor{}); 1019| 0| return std::make_tuple(pos.shift(), newn, ts, tail); 1020| 0| } 1021| 20| } else if (idx == 0) { ------------------ | Branch (1021:28): [True: 0, False: 20] ------------------ 1022| 0| if (Mutating) ------------------ | Branch (1022:25): [Folded - Ignored] ------------------ 1023| 0| pos.visit(dec_right_visitor{}, count_t{1}); 1024| 0| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1025| 20| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1025:28): [Folded - Ignored] | Branch (1025:40): [True: 0, False: 20] | Branch (1025:52): [True: 0, False: 0] ------------------ 1026| 0| auto newn = pos.node()->inner()[0]; 1027| 0| if (!mutate) ------------------ | Branch (1027:25): [True: 0, False: 0] ------------------ 1028| 0| newn->inc(); 1029| 0| if (Mutating) ------------------ | Branch (1029:25): [Folded - Ignored] ------------------ 1030| 0| pos.visit(dec_right_visitor{}, count_t{2}); 1031| 0| return std::make_tuple(pos.shift() - B, newn, ts, tail); 1032| 20| } else { 1033| 20| if (mutate) { ------------------ | Branch (1033:25): [True: 0, False: 20] ------------------ 1034| 0| pos.each_right(dec_visitor{}, idx + 1); 1035| 0| return std::make_tuple(pos.shift(), node, ts, tail); 1036| 20| } else { 1037| 20| auto newn = node_t::copy_inner_e(e, node, idx); 1038| 20| if (Mutating) ------------------ | Branch (1038:29): [Folded - Ignored] ------------------ 1039| 0| pos.visit(dec_visitor{}); 1040| 20| return std::make_tuple(pos.shift(), newn, ts, tail); 1041| 20| } 1042| 20| } 1043| 20| } 1044| 20| IMMER_CATCH (...) { 1045| 0| assert(!mutate); 1046| 0| assert(!next || pos.shift() > BL); 1047| 0| assert(tail); 1048| 0| if (next) ------------------ | Branch (1048:21): [True: 0, False: 0] ------------------ 1049| 0| dec_regular(next, pos.shift() - B, last + 1 - ts); 1050| 0| dec_leaf(tail, ts); 1051| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1052| 0| } 1053| 20| } 1054| 87| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb0EE10visit_leafIRNS1_13full_leaf_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 1058| 151| { 1059| 151| auto old_tail_size = pos.count(); 1060| 151| auto new_tail_size = pos.index(last) + 1; 1061| 151| auto node = pos.node(); 1062| 151| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (1062:30): [Folded - Ignored] | Branch (1062:42): [True: 0, False: 0] ------------------ 1063| 151| if (new_tail_size == old_tail_size) { ------------------ | Branch (1063:13): [True: 0, False: 151] ------------------ 1064| 0| if (!Mutating) ------------------ | Branch (1064:17): [Folded - Ignored] ------------------ 1065| 0| node->inc(); 1066| 0| return std::make_tuple(0, nullptr, new_tail_size, node); 1067| 151| } else if (mutate) { ------------------ | Branch (1067:20): [True: 0, False: 151] ------------------ 1068| 0| detail::destroy_n(node->leaf() + new_tail_size, 1069| 0| old_tail_size - new_tail_size); 1070| 0| return std::make_tuple(0, nullptr, new_tail_size, node); 1071| 151| } else { 1072| 151| auto new_tail = node_t::copy_leaf_e(e, node, new_tail_size); 1073| 151| if (Mutating) ------------------ | Branch (1073:17): [Folded - Ignored] ------------------ 1074| 0| pos.visit(dec_visitor{}); 1075| 151| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1076| 151| } 1077| 151| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb0EE13visit_regularIRNS1_8full_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 990| 69| { 991| 69| auto idx = pos.index(last); 992| 69| auto node = pos.node(); 993| 69| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (993:23): [Folded - Ignored] | Branch (993:35): [True: 0, False: 0] ------------------ 994| 69| if (Collapse && idx == 0) { ------------------ | Branch (994:13): [Folded - Ignored] | Branch (994:25): [True: 44, False: 25] ------------------ 995| 44| auto res = mutate ? pos.towards_oh(this_t{}, last, idx, e) ------------------ | Branch (995:24): [True: 0, False: 44] ------------------ 996| 44| : pos.towards_oh(no_mut_t{}, last, idx, e); 997| 44| if (Mutating) ------------------ | Branch (997:17): [Folded - Ignored] ------------------ 998| 0| pos.visit(dec_right_visitor{}, count_t{1}); 999| 44| return res; 1000| 44| } else { 1001| 25| using std::get; 1002| 25| auto subs = 1003| 25| mutate ? pos.towards_oh(no_collapse_t{}, last, idx, e) ------------------ | Branch (1003:17): [True: 0, False: 25] ------------------ 1004| 25| : pos.towards_oh(no_collapse_no_mut_t{}, last, idx, e); 1005| 25| auto next = get<1>(subs); 1006| 25| auto ts = get<2>(subs); 1007| 25| auto tail = get<3>(subs); 1008| 25| IMMER_TRY { ------------------ | | 41| 25|#define IMMER_TRY try ------------------ 1009| 25| if (next) { ------------------ | Branch (1009:21): [True: 1, False: 24] ------------------ 1010| 1| if (mutate) { ------------------ | Branch (1010:25): [True: 0, False: 1] ------------------ 1011| 0| node->inner()[idx] = next; 1012| 0| pos.each_right(dec_visitor{}, idx + 1); 1013| 0| return std::make_tuple(pos.shift(), node, ts, tail); 1014| 1| } else { 1015| 1| auto newn = node_t::copy_inner_e(e, node, idx); 1016| 1| newn->inner()[idx] = next; 1017| 1| if (Mutating) ------------------ | Branch (1017:29): [Folded - Ignored] ------------------ 1018| 0| pos.visit(dec_visitor{}); 1019| 1| return std::make_tuple(pos.shift(), newn, ts, tail); 1020| 1| } 1021| 24| } else if (idx == 0) { ------------------ | Branch (1021:28): [True: 0, False: 24] ------------------ 1022| 0| if (Mutating) ------------------ | Branch (1022:25): [Folded - Ignored] ------------------ 1023| 0| pos.visit(dec_right_visitor{}, count_t{1}); 1024| 0| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1025| 24| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1025:28): [Folded - Ignored] | Branch (1025:40): [True: 10, False: 14] | Branch (1025:52): [True: 1, False: 9] ------------------ 1026| 1| auto newn = pos.node()->inner()[0]; 1027| 1| if (!mutate) ------------------ | Branch (1027:25): [True: 1, False: 0] ------------------ 1028| 1| newn->inc(); 1029| 1| if (Mutating) ------------------ | Branch (1029:25): [Folded - Ignored] ------------------ 1030| 0| pos.visit(dec_right_visitor{}, count_t{2}); 1031| 1| return std::make_tuple(pos.shift() - B, newn, ts, tail); 1032| 23| } else { 1033| 23| if (mutate) { ------------------ | Branch (1033:25): [True: 0, False: 23] ------------------ 1034| 0| pos.each_right(dec_visitor{}, idx + 1); 1035| 0| return std::make_tuple(pos.shift(), node, ts, tail); 1036| 23| } else { 1037| 23| auto newn = node_t::copy_inner_e(e, node, idx); 1038| 23| if (Mutating) ------------------ | Branch (1038:29): [Folded - Ignored] ------------------ 1039| 0| pos.visit(dec_visitor{}); 1040| 23| return std::make_tuple(pos.shift(), newn, ts, tail); 1041| 23| } 1042| 23| } 1043| 25| } 1044| 25| IMMER_CATCH (...) { 1045| 0| assert(!mutate); 1046| 0| assert(!next || pos.shift() > BL); 1047| 0| assert(tail); 1048| 0| if (next) ------------------ | Branch (1048:21): [True: 0, False: 0] ------------------ 1049| 0| dec_regular(next, pos.shift() - B, last + 1 - ts); 1050| 0| dec_leaf(tail, ts); 1051| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1052| 0| } 1053| 25| } 1054| 69| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb1EE10visit_leafIRNS1_13full_leaf_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 1058| 17| { 1059| 17| auto old_tail_size = pos.count(); 1060| 17| auto new_tail_size = pos.index(last) + 1; 1061| 17| auto node = pos.node(); 1062| 17| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (1062:30): [Folded - Ignored] | Branch (1062:42): [True: 4, False: 13] ------------------ 1063| 17| if (new_tail_size == old_tail_size) { ------------------ | Branch (1063:13): [True: 1, False: 16] ------------------ 1064| 1| if (!Mutating) ------------------ | Branch (1064:17): [Folded - Ignored] ------------------ 1065| 0| node->inc(); 1066| 1| return std::make_tuple(0, nullptr, new_tail_size, node); 1067| 16| } else if (mutate) { ------------------ | Branch (1067:20): [True: 3, False: 13] ------------------ 1068| 3| detail::destroy_n(node->leaf() + new_tail_size, 1069| 3| old_tail_size - new_tail_size); 1070| 3| return std::make_tuple(0, nullptr, new_tail_size, node); 1071| 13| } else { 1072| 13| auto new_tail = node_t::copy_leaf_e(e, node, new_tail_size); 1073| 13| if (Mutating) ------------------ | Branch (1073:17): [Folded - Ignored] ------------------ 1074| 13| pos.visit(dec_visitor{}); 1075| 13| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1076| 13| } 1077| 17| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb1EE13visit_regularIRNS1_8full_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 990| 113| { 991| 113| auto idx = pos.index(last); 992| 113| auto node = pos.node(); 993| 113| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (993:23): [Folded - Ignored] | Branch (993:35): [True: 0, False: 113] ------------------ 994| 113| if (Collapse && idx == 0) { ------------------ | Branch (994:13): [Folded - Ignored] | Branch (994:25): [True: 0, False: 0] ------------------ 995| 0| auto res = mutate ? pos.towards_oh(this_t{}, last, idx, e) ------------------ | Branch (995:24): [True: 0, False: 0] ------------------ 996| 0| : pos.towards_oh(no_mut_t{}, last, idx, e); 997| 0| if (Mutating) ------------------ | Branch (997:17): [Folded - Ignored] ------------------ 998| 0| pos.visit(dec_right_visitor{}, count_t{1}); 999| 0| return res; 1000| 113| } else { 1001| 113| using std::get; 1002| 113| auto subs = 1003| 113| mutate ? pos.towards_oh(no_collapse_t{}, last, idx, e) ------------------ | Branch (1003:17): [True: 0, False: 113] ------------------ 1004| 113| : pos.towards_oh(no_collapse_no_mut_t{}, last, idx, e); 1005| 113| auto next = get<1>(subs); 1006| 113| auto ts = get<2>(subs); 1007| 113| auto tail = get<3>(subs); 1008| 113| IMMER_TRY { ------------------ | | 41| 113|#define IMMER_TRY try ------------------ 1009| 113| if (next) { ------------------ | Branch (1009:21): [True: 77, False: 36] ------------------ 1010| 77| if (mutate) { ------------------ | Branch (1010:25): [True: 0, False: 77] ------------------ 1011| 0| node->inner()[idx] = next; 1012| 0| pos.each_right(dec_visitor{}, idx + 1); 1013| 0| return std::make_tuple(pos.shift(), node, ts, tail); 1014| 77| } else { 1015| 77| auto newn = node_t::copy_inner_e(e, node, idx); 1016| 77| newn->inner()[idx] = next; 1017| 77| if (Mutating) ------------------ | Branch (1017:29): [Folded - Ignored] ------------------ 1018| 77| pos.visit(dec_visitor{}); 1019| 77| return std::make_tuple(pos.shift(), newn, ts, tail); 1020| 77| } 1021| 77| } else if (idx == 0) { ------------------ | Branch (1021:28): [True: 13, False: 23] ------------------ 1022| 13| if (Mutating) ------------------ | Branch (1022:25): [Folded - Ignored] ------------------ 1023| 13| pos.visit(dec_right_visitor{}, count_t{1}); 1024| 13| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1025| 23| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1025:28): [Folded - Ignored] | Branch (1025:40): [True: 0, False: 0] | Branch (1025:52): [True: 0, False: 0] ------------------ 1026| 0| auto newn = pos.node()->inner()[0]; 1027| 0| if (!mutate) ------------------ | Branch (1027:25): [True: 0, False: 0] ------------------ 1028| 0| newn->inc(); 1029| 0| if (Mutating) ------------------ | Branch (1029:25): [Folded - Ignored] ------------------ 1030| 0| pos.visit(dec_right_visitor{}, count_t{2}); 1031| 0| return std::make_tuple(pos.shift() - B, newn, ts, tail); 1032| 23| } else { 1033| 23| if (mutate) { ------------------ | Branch (1033:25): [True: 0, False: 23] ------------------ 1034| 0| pos.each_right(dec_visitor{}, idx + 1); 1035| 0| return std::make_tuple(pos.shift(), node, ts, tail); 1036| 23| } else { 1037| 23| auto newn = node_t::copy_inner_e(e, node, idx); 1038| 23| if (Mutating) ------------------ | Branch (1038:29): [Folded - Ignored] ------------------ 1039| 23| pos.visit(dec_visitor{}); 1040| 23| return std::make_tuple(pos.shift(), newn, ts, tail); 1041| 23| } 1042| 23| } 1043| 113| } 1044| 113| IMMER_CATCH (...) { 1045| 0| assert(!mutate); 1046| 0| assert(!next || pos.shift() > BL); 1047| 0| assert(tail); 1048| 0| if (next) ------------------ | Branch (1048:21): [True: 0, False: 0] ------------------ 1049| 0| dec_regular(next, pos.shift() - B, last + 1 - ts); 1050| 0| dec_leaf(tail, ts); 1051| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1052| 0| } 1053| 113| } 1054| 113| } _ZN5immer6detail4rbts17dec_right_visitor13visit_regularIRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEvOT_j: 877| 69| { 878| 69| using node_t = node_type; 879| 69| auto node = p.node(); 880| 69| if (node->dec()) { ------------------ | Branch (880:13): [True: 52, False: 17] ------------------ 881| 52| p.each_right(dec_t{}, idx); 882| 52| node_t::delete_inner(node, p.count()); 883| 52| } 884| 69| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb0EE10visit_leafIRNS1_13full_leaf_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 1058| 1.61k| { 1059| 1.61k| auto old_tail_size = pos.count(); 1060| 1.61k| auto new_tail_size = pos.index(last) + 1; 1061| 1.61k| auto node = pos.node(); 1062| 1.61k| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (1062:30): [Folded - Ignored] | Branch (1062:42): [True: 0, False: 0] ------------------ 1063| 1.61k| if (new_tail_size == old_tail_size) { ------------------ | Branch (1063:13): [True: 461, False: 1.15k] ------------------ 1064| 461| if (!Mutating) ------------------ | Branch (1064:17): [Folded - Ignored] ------------------ 1065| 461| node->inc(); 1066| 461| return std::make_tuple(0, nullptr, new_tail_size, node); 1067| 1.15k| } else if (mutate) { ------------------ | Branch (1067:20): [True: 0, False: 1.15k] ------------------ 1068| 0| detail::destroy_n(node->leaf() + new_tail_size, 1069| 0| old_tail_size - new_tail_size); 1070| 0| return std::make_tuple(0, nullptr, new_tail_size, node); 1071| 1.15k| } else { 1072| 1.15k| auto new_tail = node_t::copy_leaf_e(e, node, new_tail_size); 1073| 1.15k| if (Mutating) ------------------ | Branch (1073:17): [Folded - Ignored] ------------------ 1074| 0| pos.visit(dec_visitor{}); 1075| 1.15k| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1076| 1.15k| } 1077| 1.61k| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb0EE13visit_regularIRNS1_8full_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 990| 1.09k| { 991| 1.09k| auto idx = pos.index(last); 992| 1.09k| auto node = pos.node(); 993| 1.09k| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (993:23): [Folded - Ignored] | Branch (993:35): [True: 0, False: 0] ------------------ 994| 1.09k| if (Collapse && idx == 0) { ------------------ | Branch (994:13): [Folded - Ignored] | Branch (994:25): [True: 0, False: 0] ------------------ 995| 0| auto res = mutate ? pos.towards_oh(this_t{}, last, idx, e) ------------------ | Branch (995:24): [True: 0, False: 0] ------------------ 996| 0| : pos.towards_oh(no_mut_t{}, last, idx, e); 997| 0| if (Mutating) ------------------ | Branch (997:17): [Folded - Ignored] ------------------ 998| 0| pos.visit(dec_right_visitor{}, count_t{1}); 999| 0| return res; 1000| 1.09k| } else { 1001| 1.09k| using std::get; 1002| 1.09k| auto subs = 1003| 1.09k| mutate ? pos.towards_oh(no_collapse_t{}, last, idx, e) ------------------ | Branch (1003:17): [True: 0, False: 1.09k] ------------------ 1004| 1.09k| : pos.towards_oh(no_collapse_no_mut_t{}, last, idx, e); 1005| 1.09k| auto next = get<1>(subs); 1006| 1.09k| auto ts = get<2>(subs); 1007| 1.09k| auto tail = get<3>(subs); 1008| 1.09k| IMMER_TRY { ------------------ | | 41| 1.09k|#define IMMER_TRY try ------------------ 1009| 1.09k| if (next) { ------------------ | Branch (1009:21): [True: 297, False: 796] ------------------ 1010| 297| if (mutate) { ------------------ | Branch (1010:25): [True: 0, False: 297] ------------------ 1011| 0| node->inner()[idx] = next; 1012| 0| pos.each_right(dec_visitor{}, idx + 1); 1013| 0| return std::make_tuple(pos.shift(), node, ts, tail); 1014| 297| } else { 1015| 297| auto newn = node_t::copy_inner_e(e, node, idx); 1016| 297| newn->inner()[idx] = next; 1017| 297| if (Mutating) ------------------ | Branch (1017:29): [Folded - Ignored] ------------------ 1018| 0| pos.visit(dec_visitor{}); 1019| 297| return std::make_tuple(pos.shift(), newn, ts, tail); 1020| 297| } 1021| 796| } else if (idx == 0) { ------------------ | Branch (1021:28): [True: 168, False: 628] ------------------ 1022| 168| if (Mutating) ------------------ | Branch (1022:25): [Folded - Ignored] ------------------ 1023| 0| pos.visit(dec_right_visitor{}, count_t{1}); 1024| 168| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1025| 628| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1025:28): [Folded - Ignored] | Branch (1025:40): [True: 0, False: 0] | Branch (1025:52): [True: 0, False: 0] ------------------ 1026| 0| auto newn = pos.node()->inner()[0]; 1027| 0| if (!mutate) ------------------ | Branch (1027:25): [True: 0, False: 0] ------------------ 1028| 0| newn->inc(); 1029| 0| if (Mutating) ------------------ | Branch (1029:25): [Folded - Ignored] ------------------ 1030| 0| pos.visit(dec_right_visitor{}, count_t{2}); 1031| 0| return std::make_tuple(pos.shift() - B, newn, ts, tail); 1032| 628| } else { 1033| 628| if (mutate) { ------------------ | Branch (1033:25): [True: 0, False: 628] ------------------ 1034| 0| pos.each_right(dec_visitor{}, idx + 1); 1035| 0| return std::make_tuple(pos.shift(), node, ts, tail); 1036| 628| } else { 1037| 628| auto newn = node_t::copy_inner_e(e, node, idx); 1038| 628| if (Mutating) ------------------ | Branch (1038:29): [Folded - Ignored] ------------------ 1039| 0| pos.visit(dec_visitor{}); 1040| 628| return std::make_tuple(pos.shift(), newn, ts, tail); 1041| 628| } 1042| 628| } 1043| 1.09k| } 1044| 1.09k| IMMER_CATCH (...) { 1045| 0| assert(!mutate); 1046| 0| assert(!next || pos.shift() > BL); 1047| 0| assert(tail); 1048| 0| if (next) ------------------ | Branch (1048:21): [True: 0, False: 0] ------------------ 1049| 0| dec_regular(next, pos.shift() - B, last + 1 - ts); 1050| 0| dec_leaf(tail, ts); 1051| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1052| 0| } 1053| 1.09k| } 1054| 1.09k| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb0EE10visit_leafIRNS1_8leaf_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 1058| 77| { 1059| 77| auto old_tail_size = pos.count(); 1060| 77| auto new_tail_size = pos.index(last) + 1; 1061| 77| auto node = pos.node(); 1062| 77| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (1062:30): [Folded - Ignored] | Branch (1062:42): [True: 0, False: 0] ------------------ 1063| 77| if (new_tail_size == old_tail_size) { ------------------ | Branch (1063:13): [True: 0, False: 77] ------------------ 1064| 0| if (!Mutating) ------------------ | Branch (1064:17): [Folded - Ignored] ------------------ 1065| 0| node->inc(); 1066| 0| return std::make_tuple(0, nullptr, new_tail_size, node); 1067| 77| } else if (mutate) { ------------------ | Branch (1067:20): [True: 0, False: 77] ------------------ 1068| 0| detail::destroy_n(node->leaf() + new_tail_size, 1069| 0| old_tail_size - new_tail_size); 1070| 0| return std::make_tuple(0, nullptr, new_tail_size, node); 1071| 77| } else { 1072| 77| auto new_tail = node_t::copy_leaf_e(e, node, new_tail_size); 1073| 77| if (Mutating) ------------------ | Branch (1073:17): [Folded - Ignored] ------------------ 1074| 0| pos.visit(dec_visitor{}); 1075| 77| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1076| 77| } 1077| 77| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb1EE10visit_leafIRNS1_8leaf_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 1058| 26| { 1059| 26| auto old_tail_size = pos.count(); 1060| 26| auto new_tail_size = pos.index(last) + 1; 1061| 26| auto node = pos.node(); 1062| 26| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (1062:30): [Folded - Ignored] | Branch (1062:42): [True: 14, False: 12] ------------------ 1063| 26| if (new_tail_size == old_tail_size) { ------------------ | Branch (1063:13): [True: 0, False: 26] ------------------ 1064| 0| if (!Mutating) ------------------ | Branch (1064:17): [Folded - Ignored] ------------------ 1065| 0| node->inc(); 1066| 0| return std::make_tuple(0, nullptr, new_tail_size, node); 1067| 26| } else if (mutate) { ------------------ | Branch (1067:20): [True: 14, False: 12] ------------------ 1068| 14| detail::destroy_n(node->leaf() + new_tail_size, 1069| 14| old_tail_size - new_tail_size); 1070| 14| return std::make_tuple(0, nullptr, new_tail_size, node); 1071| 14| } else { 1072| 12| auto new_tail = node_t::copy_leaf_e(e, node, new_tail_size); 1073| 12| if (Mutating) ------------------ | Branch (1073:17): [Folded - Ignored] ------------------ 1074| 12| pos.visit(dec_visitor{}); 1075| 12| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1076| 12| } 1077| 26| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb1EE13visit_regularIRNS1_11regular_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 990| 53| { 991| 53| auto idx = pos.index(last); 992| 53| auto node = pos.node(); 993| 53| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (993:23): [Folded - Ignored] | Branch (993:35): [True: 28, False: 25] ------------------ 994| 53| if (Collapse && idx == 0) { ------------------ | Branch (994:13): [Folded - Ignored] | Branch (994:25): [True: 0, False: 0] ------------------ 995| 0| auto res = mutate ? pos.towards_oh(this_t{}, last, idx, e) ------------------ | Branch (995:24): [True: 0, False: 0] ------------------ 996| 0| : pos.towards_oh(no_mut_t{}, last, idx, e); 997| 0| if (Mutating) ------------------ | Branch (997:17): [Folded - Ignored] ------------------ 998| 0| pos.visit(dec_right_visitor{}, count_t{1}); 999| 0| return res; 1000| 53| } else { 1001| 53| using std::get; 1002| 53| auto subs = 1003| 53| mutate ? pos.towards_oh(no_collapse_t{}, last, idx, e) ------------------ | Branch (1003:17): [True: 28, False: 25] ------------------ 1004| 53| : pos.towards_oh(no_collapse_no_mut_t{}, last, idx, e); 1005| 53| auto next = get<1>(subs); 1006| 53| auto ts = get<2>(subs); 1007| 53| auto tail = get<3>(subs); 1008| 53| IMMER_TRY { ------------------ | | 41| 53|#define IMMER_TRY try ------------------ 1009| 53| if (next) { ------------------ | Branch (1009:21): [True: 29, False: 24] ------------------ 1010| 29| if (mutate) { ------------------ | Branch (1010:25): [True: 9, False: 20] ------------------ 1011| 9| node->inner()[idx] = next; 1012| 9| pos.each_right(dec_visitor{}, idx + 1); 1013| 9| return std::make_tuple(pos.shift(), node, ts, tail); 1014| 20| } else { 1015| 20| auto newn = node_t::copy_inner_e(e, node, idx); 1016| 20| newn->inner()[idx] = next; 1017| 20| if (Mutating) ------------------ | Branch (1017:29): [Folded - Ignored] ------------------ 1018| 20| pos.visit(dec_visitor{}); 1019| 20| return std::make_tuple(pos.shift(), newn, ts, tail); 1020| 20| } 1021| 29| } else if (idx == 0) { ------------------ | Branch (1021:28): [True: 19, False: 5] ------------------ 1022| 19| if (Mutating) ------------------ | Branch (1022:25): [Folded - Ignored] ------------------ 1023| 19| pos.visit(dec_right_visitor{}, count_t{1}); 1024| 19| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1025| 19| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1025:28): [Folded - Ignored] | Branch (1025:40): [True: 0, False: 0] | Branch (1025:52): [True: 0, False: 0] ------------------ 1026| 0| auto newn = pos.node()->inner()[0]; 1027| 0| if (!mutate) ------------------ | Branch (1027:25): [True: 0, False: 0] ------------------ 1028| 0| newn->inc(); 1029| 0| if (Mutating) ------------------ | Branch (1029:25): [Folded - Ignored] ------------------ 1030| 0| pos.visit(dec_right_visitor{}, count_t{2}); 1031| 0| return std::make_tuple(pos.shift() - B, newn, ts, tail); 1032| 5| } else { 1033| 5| if (mutate) { ------------------ | Branch (1033:25): [True: 2, False: 3] ------------------ 1034| 2| pos.each_right(dec_visitor{}, idx + 1); 1035| 2| return std::make_tuple(pos.shift(), node, ts, tail); 1036| 3| } else { 1037| 3| auto newn = node_t::copy_inner_e(e, node, idx); 1038| 3| if (Mutating) ------------------ | Branch (1038:29): [Folded - Ignored] ------------------ 1039| 3| pos.visit(dec_visitor{}); 1040| 3| return std::make_tuple(pos.shift(), newn, ts, tail); 1041| 3| } 1042| 5| } 1043| 53| } 1044| 53| IMMER_CATCH (...) { 1045| 0| assert(!mutate); 1046| 0| assert(!next || pos.shift() > BL); 1047| 0| assert(tail); 1048| 0| if (next) ------------------ | Branch (1048:21): [True: 0, False: 0] ------------------ 1049| 0| dec_regular(next, pos.shift() - B, last + 1 - ts); 1050| 0| dec_leaf(tail, ts); 1051| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1052| 0| } 1053| 53| } 1054| 53| } _ZN5immer6detail4rbts17dec_right_visitor13visit_regularIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEvOT_j: 877| 19| { 878| 19| using node_t = node_type; 879| 19| auto node = p.node(); 880| 19| if (node->dec()) { ------------------ | Branch (880:13): [True: 17, False: 2] ------------------ 881| 17| p.each_right(dec_t{}, idx); 882| 17| node_t::delete_inner(node, p.count()); 883| 17| } 884| 19| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb0EE10visit_leafIRNS1_8leaf_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 1058| 91| { 1059| 91| auto old_tail_size = pos.count(); 1060| 91| auto new_tail_size = pos.index(last) + 1; 1061| 91| auto node = pos.node(); 1062| 91| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (1062:30): [Folded - Ignored] | Branch (1062:42): [True: 0, False: 0] ------------------ 1063| 91| if (new_tail_size == old_tail_size) { ------------------ | Branch (1063:13): [True: 24, False: 67] ------------------ 1064| 24| if (!Mutating) ------------------ | Branch (1064:17): [Folded - Ignored] ------------------ 1065| 24| node->inc(); 1066| 24| return std::make_tuple(0, nullptr, new_tail_size, node); 1067| 67| } else if (mutate) { ------------------ | Branch (1067:20): [True: 0, False: 67] ------------------ 1068| 0| detail::destroy_n(node->leaf() + new_tail_size, 1069| 0| old_tail_size - new_tail_size); 1070| 0| return std::make_tuple(0, nullptr, new_tail_size, node); 1071| 67| } else { 1072| 67| auto new_tail = node_t::copy_leaf_e(e, node, new_tail_size); 1073| 67| if (Mutating) ------------------ | Branch (1073:17): [Folded - Ignored] ------------------ 1074| 0| pos.visit(dec_visitor{}); 1075| 67| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1076| 67| } 1077| 91| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb0EE13visit_regularIRNS1_11regular_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 990| 259| { 991| 259| auto idx = pos.index(last); 992| 259| auto node = pos.node(); 993| 259| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (993:23): [Folded - Ignored] | Branch (993:35): [True: 0, False: 0] ------------------ 994| 259| if (Collapse && idx == 0) { ------------------ | Branch (994:13): [Folded - Ignored] | Branch (994:25): [True: 0, False: 0] ------------------ 995| 0| auto res = mutate ? pos.towards_oh(this_t{}, last, idx, e) ------------------ | Branch (995:24): [True: 0, False: 0] ------------------ 996| 0| : pos.towards_oh(no_mut_t{}, last, idx, e); 997| 0| if (Mutating) ------------------ | Branch (997:17): [Folded - Ignored] ------------------ 998| 0| pos.visit(dec_right_visitor{}, count_t{1}); 999| 0| return res; 1000| 259| } else { 1001| 259| using std::get; 1002| 259| auto subs = 1003| 259| mutate ? pos.towards_oh(no_collapse_t{}, last, idx, e) ------------------ | Branch (1003:17): [True: 0, False: 259] ------------------ 1004| 259| : pos.towards_oh(no_collapse_no_mut_t{}, last, idx, e); 1005| 259| auto next = get<1>(subs); 1006| 259| auto ts = get<2>(subs); 1007| 259| auto tail = get<3>(subs); 1008| 259| IMMER_TRY { ------------------ | | 41| 259|#define IMMER_TRY try ------------------ 1009| 259| if (next) { ------------------ | Branch (1009:21): [True: 188, False: 71] ------------------ 1010| 188| if (mutate) { ------------------ | Branch (1010:25): [True: 0, False: 188] ------------------ 1011| 0| node->inner()[idx] = next; 1012| 0| pos.each_right(dec_visitor{}, idx + 1); 1013| 0| return std::make_tuple(pos.shift(), node, ts, tail); 1014| 188| } else { 1015| 188| auto newn = node_t::copy_inner_e(e, node, idx); 1016| 188| newn->inner()[idx] = next; 1017| 188| if (Mutating) ------------------ | Branch (1017:29): [Folded - Ignored] ------------------ 1018| 0| pos.visit(dec_visitor{}); 1019| 188| return std::make_tuple(pos.shift(), newn, ts, tail); 1020| 188| } 1021| 188| } else if (idx == 0) { ------------------ | Branch (1021:28): [True: 45, False: 26] ------------------ 1022| 45| if (Mutating) ------------------ | Branch (1022:25): [Folded - Ignored] ------------------ 1023| 0| pos.visit(dec_right_visitor{}, count_t{1}); 1024| 45| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1025| 45| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1025:28): [Folded - Ignored] | Branch (1025:40): [True: 0, False: 0] | Branch (1025:52): [True: 0, False: 0] ------------------ 1026| 0| auto newn = pos.node()->inner()[0]; 1027| 0| if (!mutate) ------------------ | Branch (1027:25): [True: 0, False: 0] ------------------ 1028| 0| newn->inc(); 1029| 0| if (Mutating) ------------------ | Branch (1029:25): [Folded - Ignored] ------------------ 1030| 0| pos.visit(dec_right_visitor{}, count_t{2}); 1031| 0| return std::make_tuple(pos.shift() - B, newn, ts, tail); 1032| 26| } else { 1033| 26| if (mutate) { ------------------ | Branch (1033:25): [True: 0, False: 26] ------------------ 1034| 0| pos.each_right(dec_visitor{}, idx + 1); 1035| 0| return std::make_tuple(pos.shift(), node, ts, tail); 1036| 26| } else { 1037| 26| auto newn = node_t::copy_inner_e(e, node, idx); 1038| 26| if (Mutating) ------------------ | Branch (1038:29): [Folded - Ignored] ------------------ 1039| 0| pos.visit(dec_visitor{}); 1040| 26| return std::make_tuple(pos.shift(), newn, ts, tail); 1041| 26| } 1042| 26| } 1043| 259| } 1044| 259| IMMER_CATCH (...) { 1045| 0| assert(!mutate); 1046| 0| assert(!next || pos.shift() > BL); 1047| 0| assert(tail); 1048| 0| if (next) ------------------ | Branch (1048:21): [True: 0, False: 0] ------------------ 1049| 0| dec_regular(next, pos.shift() - B, last + 1 - ts); 1050| 0| dec_leaf(tail, ts); 1051| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1052| 0| } 1053| 259| } 1054| 259| } _ZN5immer6detail4rbts17dec_right_visitor13visit_relaxedIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEvOT_j: 866| 38.2k| { 867| 38.2k| using node_t = node_type; 868| 38.2k| auto node = p.node(); 869| 38.2k| if (node->dec()) { ------------------ | Branch (869:13): [True: 35.4k, False: 2.73k] ------------------ 870| 35.4k| p.each_right(dec_t{}, idx); 871| 35.4k| node_t::delete_inner_r(node, p.count()); 872| 35.4k| } 873| 38.2k| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb1EE10visit_leafIRNS1_12leaf_sub_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 1058| 1.85k| { 1059| 1.85k| auto old_tail_size = pos.count(); 1060| 1.85k| auto new_tail_size = pos.index(last) + 1; 1061| 1.85k| auto node = pos.node(); 1062| 1.85k| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (1062:30): [Folded - Ignored] | Branch (1062:42): [True: 14, False: 1.84k] ------------------ 1063| 1.85k| if (new_tail_size == old_tail_size) { ------------------ | Branch (1063:13): [True: 764, False: 1.09k] ------------------ 1064| 764| if (!Mutating) ------------------ | Branch (1064:17): [Folded - Ignored] ------------------ 1065| 0| node->inc(); 1066| 764| return std::make_tuple(0, nullptr, new_tail_size, node); 1067| 1.09k| } else if (mutate) { ------------------ | Branch (1067:20): [True: 11, False: 1.08k] ------------------ 1068| 11| detail::destroy_n(node->leaf() + new_tail_size, 1069| 11| old_tail_size - new_tail_size); 1070| 11| return std::make_tuple(0, nullptr, new_tail_size, node); 1071| 1.08k| } else { 1072| 1.08k| auto new_tail = node_t::copy_leaf_e(e, node, new_tail_size); 1073| 1.08k| if (Mutating) ------------------ | Branch (1073:17): [Folded - Ignored] ------------------ 1074| 1.08k| pos.visit(dec_visitor{}); 1075| 1.08k| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1076| 1.08k| } 1077| 1.85k| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb1EE13visit_relaxedIRNS1_11relaxed_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 912| 4.29k| { 913| 4.29k| auto idx = pos.index(last); 914| 4.29k| auto node = pos.node(); 915| 4.29k| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (915:23): [Folded - Ignored] | Branch (915:35): [True: 2.61k, False: 1.67k] ------------------ 916| 4.29k| if (Collapse && idx == 0) { ------------------ | Branch (916:13): [Folded - Ignored] | Branch (916:25): [True: 0, False: 0] ------------------ 917| 0| auto res = mutate ? pos.towards_oh(this_t{}, last, idx, e) ------------------ | Branch (917:24): [True: 0, False: 0] ------------------ 918| 0| : pos.towards_oh(no_mut_t{}, last, idx, e); 919| 0| if (Mutating) ------------------ | Branch (919:17): [Folded - Ignored] ------------------ 920| 0| pos.visit(dec_right_visitor{}, count_t{1}); 921| 0| return res; 922| 4.29k| } else { 923| 4.29k| using std::get; 924| 4.29k| auto subs = 925| 4.29k| mutate ? pos.towards_oh(no_collapse_t{}, last, idx, e) ------------------ | Branch (925:17): [True: 2.61k, False: 1.67k] ------------------ 926| 4.29k| : pos.towards_oh(no_collapse_no_mut_t{}, last, idx, e); 927| 4.29k| auto next = get<1>(subs); 928| 4.29k| auto ts = get<2>(subs); 929| 4.29k| auto tail = get<3>(subs); 930| 4.29k| IMMER_TRY { ------------------ | | 41| 4.29k|#define IMMER_TRY try ------------------ 931| 4.29k| if (next) { ------------------ | Branch (931:21): [True: 2.08k, False: 2.20k] ------------------ 932| 2.08k| if (mutate) { ------------------ | Branch (932:25): [True: 1.04k, False: 1.04k] ------------------ 933| 1.04k| auto nodr = node->ensure_mutable_relaxed_n(e, idx); 934| 1.04k| pos.each_right(dec_visitor{}, idx + 1); 935| 1.04k| node->inner()[idx] = next; 936| 1.04k| nodr->d.sizes[idx] = last + 1 - ts; 937| 1.04k| nodr->d.count = idx + 1; 938| 1.04k| assert(nodr->d.sizes[idx]); 939| 0| return std::make_tuple(pos.shift(), node, ts, tail); 940| 1.04k| } else { 941| 1.04k| auto newn = node_t::copy_inner_r_e(e, node, idx); 942| 1.04k| auto newr = newn->relaxed(); 943| 1.04k| newn->inner()[idx] = next; 944| 1.04k| newr->d.sizes[idx] = last + 1 - ts; 945| 1.04k| newr->d.count = idx + 1; 946| 1.04k| assert(newr->d.sizes[idx]); 947| 1.04k| if (Mutating) ------------------ | Branch (947:29): [Folded - Ignored] ------------------ 948| 1.04k| pos.visit(dec_visitor{}); 949| 1.04k| return std::make_tuple(pos.shift(), newn, ts, tail); 950| 1.04k| } 951| 2.20k| } else if (idx == 0) { ------------------ | Branch (951:28): [True: 1.13k, False: 1.07k] ------------------ 952| 1.13k| if (Mutating) ------------------ | Branch (952:25): [Folded - Ignored] ------------------ 953| 1.13k| pos.visit(dec_right_visitor{}, count_t{1}); 954| 1.13k| return std::make_tuple(pos.shift(), nullptr, ts, tail); 955| 1.13k| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (955:28): [Folded - Ignored] | Branch (955:40): [True: 0, False: 0] | Branch (955:52): [True: 0, False: 0] ------------------ 956| 0| auto newn = pos.node()->inner()[0]; 957| 0| if (!mutate) ------------------ | Branch (957:25): [True: 0, False: 0] ------------------ 958| 0| newn->inc(); 959| 0| if (Mutating) ------------------ | Branch (959:25): [Folded - Ignored] ------------------ 960| 0| pos.visit(dec_right_visitor{}, count_t{2}); 961| 0| return std::make_tuple(pos.shift() - B, newn, ts, tail); 962| 1.07k| } else { 963| 1.07k| if (mutate) { ------------------ | Branch (963:25): [True: 1.03k, False: 40] ------------------ 964| 1.03k| pos.each_right(dec_visitor{}, idx + 1); 965| 1.03k| node->ensure_mutable_relaxed_n(e, idx)->d.count = idx; 966| 1.03k| return std::make_tuple(pos.shift(), node, ts, tail); 967| 1.03k| } else { 968| 40| auto newn = node_t::copy_inner_r_e(e, node, idx); 969| 40| if (Mutating) ------------------ | Branch (969:29): [Folded - Ignored] ------------------ 970| 40| pos.visit(dec_visitor{}); 971| 40| return std::make_tuple(pos.shift(), newn, ts, tail); 972| 40| } 973| 1.07k| } 974| 4.29k| } 975| 4.29k| IMMER_CATCH (...) { 976| 0| assert(!mutate); 977| 0| assert(!next || pos.shift() > BL); 978| 0| if (next) ------------------ | Branch (978:21): [True: 0, False: 0] ------------------ 979| 0| dec_inner(next, 980| 0| pos.shift() - B, 981| 0| last + 1 - ts - pos.size_before(idx)); 982| 0| dec_leaf(tail, ts); 983| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 984| 0| } 985| 4.29k| } 986| 4.29k| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb1EE13visit_regularIRNS1_15regular_sub_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 990| 406| { 991| 406| auto idx = pos.index(last); 992| 406| auto node = pos.node(); 993| 406| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (993:23): [Folded - Ignored] | Branch (993:35): [True: 119, False: 287] ------------------ 994| 406| if (Collapse && idx == 0) { ------------------ | Branch (994:13): [Folded - Ignored] | Branch (994:25): [True: 0, False: 0] ------------------ 995| 0| auto res = mutate ? pos.towards_oh(this_t{}, last, idx, e) ------------------ | Branch (995:24): [True: 0, False: 0] ------------------ 996| 0| : pos.towards_oh(no_mut_t{}, last, idx, e); 997| 0| if (Mutating) ------------------ | Branch (997:17): [Folded - Ignored] ------------------ 998| 0| pos.visit(dec_right_visitor{}, count_t{1}); 999| 0| return res; 1000| 406| } else { 1001| 406| using std::get; 1002| 406| auto subs = 1003| 406| mutate ? pos.towards_oh(no_collapse_t{}, last, idx, e) ------------------ | Branch (1003:17): [True: 119, False: 287] ------------------ 1004| 406| : pos.towards_oh(no_collapse_no_mut_t{}, last, idx, e); 1005| 406| auto next = get<1>(subs); 1006| 406| auto ts = get<2>(subs); 1007| 406| auto tail = get<3>(subs); 1008| 406| IMMER_TRY { ------------------ | | 41| 406|#define IMMER_TRY try ------------------ 1009| 406| if (next) { ------------------ | Branch (1009:21): [True: 182, False: 224] ------------------ 1010| 182| if (mutate) { ------------------ | Branch (1010:25): [True: 104, False: 78] ------------------ 1011| 104| node->inner()[idx] = next; 1012| 104| pos.each_right(dec_visitor{}, idx + 1); 1013| 104| return std::make_tuple(pos.shift(), node, ts, tail); 1014| 104| } else { 1015| 78| auto newn = node_t::copy_inner_e(e, node, idx); 1016| 78| newn->inner()[idx] = next; 1017| 78| if (Mutating) ------------------ | Branch (1017:29): [Folded - Ignored] ------------------ 1018| 78| pos.visit(dec_visitor{}); 1019| 78| return std::make_tuple(pos.shift(), newn, ts, tail); 1020| 78| } 1021| 224| } else if (idx == 0) { ------------------ | Branch (1021:28): [True: 134, False: 90] ------------------ 1022| 134| if (Mutating) ------------------ | Branch (1022:25): [Folded - Ignored] ------------------ 1023| 134| pos.visit(dec_right_visitor{}, count_t{1}); 1024| 134| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1025| 134| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1025:28): [Folded - Ignored] | Branch (1025:40): [True: 0, False: 0] | Branch (1025:52): [True: 0, False: 0] ------------------ 1026| 0| auto newn = pos.node()->inner()[0]; 1027| 0| if (!mutate) ------------------ | Branch (1027:25): [True: 0, False: 0] ------------------ 1028| 0| newn->inc(); 1029| 0| if (Mutating) ------------------ | Branch (1029:25): [Folded - Ignored] ------------------ 1030| 0| pos.visit(dec_right_visitor{}, count_t{2}); 1031| 0| return std::make_tuple(pos.shift() - B, newn, ts, tail); 1032| 90| } else { 1033| 90| if (mutate) { ------------------ | Branch (1033:25): [True: 1, False: 89] ------------------ 1034| 1| pos.each_right(dec_visitor{}, idx + 1); 1035| 1| return std::make_tuple(pos.shift(), node, ts, tail); 1036| 89| } else { 1037| 89| auto newn = node_t::copy_inner_e(e, node, idx); 1038| 89| if (Mutating) ------------------ | Branch (1038:29): [Folded - Ignored] ------------------ 1039| 89| pos.visit(dec_visitor{}); 1040| 89| return std::make_tuple(pos.shift(), newn, ts, tail); 1041| 89| } 1042| 90| } 1043| 406| } 1044| 406| IMMER_CATCH (...) { 1045| 0| assert(!mutate); 1046| 0| assert(!next || pos.shift() > BL); 1047| 0| assert(tail); 1048| 0| if (next) ------------------ | Branch (1048:21): [True: 0, False: 0] ------------------ 1049| 0| dec_regular(next, pos.shift() - B, last + 1 - ts); 1050| 0| dec_leaf(tail, ts); 1051| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1052| 0| } 1053| 406| } 1054| 406| } _ZN5immer6detail4rbts17dec_right_visitor13visit_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEvOT_j: 877| 495| { 878| 495| using node_t = node_type; 879| 495| auto node = p.node(); 880| 495| if (node->dec()) { ------------------ | Branch (880:13): [True: 155, False: 340] ------------------ 881| 155| p.each_right(dec_t{}, idx); 882| 155| node_t::delete_inner(node, p.count()); 883| 155| } 884| 495| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb0EE10visit_leafIRNS1_12leaf_sub_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 1058| 3.18k| { 1059| 3.18k| auto old_tail_size = pos.count(); 1060| 3.18k| auto new_tail_size = pos.index(last) + 1; 1061| 3.18k| auto node = pos.node(); 1062| 3.18k| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (1062:30): [Folded - Ignored] | Branch (1062:42): [True: 0, False: 0] ------------------ 1063| 3.18k| if (new_tail_size == old_tail_size) { ------------------ | Branch (1063:13): [True: 1.06k, False: 2.12k] ------------------ 1064| 1.06k| if (!Mutating) ------------------ | Branch (1064:17): [Folded - Ignored] ------------------ 1065| 1.06k| node->inc(); 1066| 1.06k| return std::make_tuple(0, nullptr, new_tail_size, node); 1067| 2.12k| } else if (mutate) { ------------------ | Branch (1067:20): [True: 0, False: 2.12k] ------------------ 1068| 0| detail::destroy_n(node->leaf() + new_tail_size, 1069| 0| old_tail_size - new_tail_size); 1070| 0| return std::make_tuple(0, nullptr, new_tail_size, node); 1071| 2.12k| } else { 1072| 2.12k| auto new_tail = node_t::copy_leaf_e(e, node, new_tail_size); 1073| 2.12k| if (Mutating) ------------------ | Branch (1073:17): [Folded - Ignored] ------------------ 1074| 0| pos.visit(dec_visitor{}); 1075| 2.12k| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1076| 2.12k| } 1077| 3.18k| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb0EE13visit_relaxedIRNS1_11relaxed_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 912| 3.06k| { 913| 3.06k| auto idx = pos.index(last); 914| 3.06k| auto node = pos.node(); 915| 3.06k| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (915:23): [Folded - Ignored] | Branch (915:35): [True: 0, False: 0] ------------------ 916| 3.06k| if (Collapse && idx == 0) { ------------------ | Branch (916:13): [Folded - Ignored] | Branch (916:25): [True: 0, False: 0] ------------------ 917| 0| auto res = mutate ? pos.towards_oh(this_t{}, last, idx, e) ------------------ | Branch (917:24): [True: 0, False: 0] ------------------ 918| 0| : pos.towards_oh(no_mut_t{}, last, idx, e); 919| 0| if (Mutating) ------------------ | Branch (919:17): [Folded - Ignored] ------------------ 920| 0| pos.visit(dec_right_visitor{}, count_t{1}); 921| 0| return res; 922| 3.06k| } else { 923| 3.06k| using std::get; 924| 3.06k| auto subs = 925| 3.06k| mutate ? pos.towards_oh(no_collapse_t{}, last, idx, e) ------------------ | Branch (925:17): [True: 0, False: 3.06k] ------------------ 926| 3.06k| : pos.towards_oh(no_collapse_no_mut_t{}, last, idx, e); 927| 3.06k| auto next = get<1>(subs); 928| 3.06k| auto ts = get<2>(subs); 929| 3.06k| auto tail = get<3>(subs); 930| 3.06k| IMMER_TRY { ------------------ | | 41| 3.06k|#define IMMER_TRY try ------------------ 931| 3.06k| if (next) { ------------------ | Branch (931:21): [True: 590, False: 2.47k] ------------------ 932| 590| if (mutate) { ------------------ | Branch (932:25): [True: 0, False: 590] ------------------ 933| 0| auto nodr = node->ensure_mutable_relaxed_n(e, idx); 934| 0| pos.each_right(dec_visitor{}, idx + 1); 935| 0| node->inner()[idx] = next; 936| 0| nodr->d.sizes[idx] = last + 1 - ts; 937| 0| nodr->d.count = idx + 1; 938| 0| assert(nodr->d.sizes[idx]); 939| 0| return std::make_tuple(pos.shift(), node, ts, tail); 940| 590| } else { 941| 590| auto newn = node_t::copy_inner_r_e(e, node, idx); 942| 590| auto newr = newn->relaxed(); 943| 590| newn->inner()[idx] = next; 944| 590| newr->d.sizes[idx] = last + 1 - ts; 945| 590| newr->d.count = idx + 1; 946| 590| assert(newr->d.sizes[idx]); 947| 590| if (Mutating) ------------------ | Branch (947:29): [Folded - Ignored] ------------------ 948| 0| pos.visit(dec_visitor{}); 949| 590| return std::make_tuple(pos.shift(), newn, ts, tail); 950| 590| } 951| 2.47k| } else if (idx == 0) { ------------------ | Branch (951:28): [True: 379, False: 2.10k] ------------------ 952| 379| if (Mutating) ------------------ | Branch (952:25): [Folded - Ignored] ------------------ 953| 0| pos.visit(dec_right_visitor{}, count_t{1}); 954| 379| return std::make_tuple(pos.shift(), nullptr, ts, tail); 955| 2.10k| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (955:28): [Folded - Ignored] | Branch (955:40): [True: 0, False: 0] | Branch (955:52): [True: 0, False: 0] ------------------ 956| 0| auto newn = pos.node()->inner()[0]; 957| 0| if (!mutate) ------------------ | Branch (957:25): [True: 0, False: 0] ------------------ 958| 0| newn->inc(); 959| 0| if (Mutating) ------------------ | Branch (959:25): [Folded - Ignored] ------------------ 960| 0| pos.visit(dec_right_visitor{}, count_t{2}); 961| 0| return std::make_tuple(pos.shift() - B, newn, ts, tail); 962| 2.10k| } else { 963| 2.10k| if (mutate) { ------------------ | Branch (963:25): [True: 0, False: 2.10k] ------------------ 964| 0| pos.each_right(dec_visitor{}, idx + 1); 965| 0| node->ensure_mutable_relaxed_n(e, idx)->d.count = idx; 966| 0| return std::make_tuple(pos.shift(), node, ts, tail); 967| 2.10k| } else { 968| 2.10k| auto newn = node_t::copy_inner_r_e(e, node, idx); 969| 2.10k| if (Mutating) ------------------ | Branch (969:29): [Folded - Ignored] ------------------ 970| 0| pos.visit(dec_visitor{}); 971| 2.10k| return std::make_tuple(pos.shift(), newn, ts, tail); 972| 2.10k| } 973| 2.10k| } 974| 3.06k| } 975| 3.06k| IMMER_CATCH (...) { 976| 0| assert(!mutate); 977| 0| assert(!next || pos.shift() > BL); 978| 0| if (next) ------------------ | Branch (978:21): [True: 0, False: 0] ------------------ 979| 0| dec_inner(next, 980| 0| pos.shift() - B, 981| 0| last + 1 - ts - pos.size_before(idx)); 982| 0| dec_leaf(tail, ts); 983| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 984| 0| } 985| 3.06k| } 986| 3.06k| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb0EE13visit_regularIRNS1_15regular_sub_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 990| 1.18k| { 991| 1.18k| auto idx = pos.index(last); 992| 1.18k| auto node = pos.node(); 993| 1.18k| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (993:23): [Folded - Ignored] | Branch (993:35): [True: 0, False: 0] ------------------ 994| 1.18k| if (Collapse && idx == 0) { ------------------ | Branch (994:13): [Folded - Ignored] | Branch (994:25): [True: 0, False: 0] ------------------ 995| 0| auto res = mutate ? pos.towards_oh(this_t{}, last, idx, e) ------------------ | Branch (995:24): [True: 0, False: 0] ------------------ 996| 0| : pos.towards_oh(no_mut_t{}, last, idx, e); 997| 0| if (Mutating) ------------------ | Branch (997:17): [Folded - Ignored] ------------------ 998| 0| pos.visit(dec_right_visitor{}, count_t{1}); 999| 0| return res; 1000| 1.18k| } else { 1001| 1.18k| using std::get; 1002| 1.18k| auto subs = 1003| 1.18k| mutate ? pos.towards_oh(no_collapse_t{}, last, idx, e) ------------------ | Branch (1003:17): [True: 0, False: 1.18k] ------------------ 1004| 1.18k| : pos.towards_oh(no_collapse_no_mut_t{}, last, idx, e); 1005| 1.18k| auto next = get<1>(subs); 1006| 1.18k| auto ts = get<2>(subs); 1007| 1.18k| auto tail = get<3>(subs); 1008| 1.18k| IMMER_TRY { ------------------ | | 41| 1.18k|#define IMMER_TRY try ------------------ 1009| 1.18k| if (next) { ------------------ | Branch (1009:21): [True: 472, False: 715] ------------------ 1010| 472| if (mutate) { ------------------ | Branch (1010:25): [True: 0, False: 472] ------------------ 1011| 0| node->inner()[idx] = next; 1012| 0| pos.each_right(dec_visitor{}, idx + 1); 1013| 0| return std::make_tuple(pos.shift(), node, ts, tail); 1014| 472| } else { 1015| 472| auto newn = node_t::copy_inner_e(e, node, idx); 1016| 472| newn->inner()[idx] = next; 1017| 472| if (Mutating) ------------------ | Branch (1017:29): [Folded - Ignored] ------------------ 1018| 0| pos.visit(dec_visitor{}); 1019| 472| return std::make_tuple(pos.shift(), newn, ts, tail); 1020| 472| } 1021| 715| } else if (idx == 0) { ------------------ | Branch (1021:28): [True: 427, False: 288] ------------------ 1022| 427| if (Mutating) ------------------ | Branch (1022:25): [Folded - Ignored] ------------------ 1023| 0| pos.visit(dec_right_visitor{}, count_t{1}); 1024| 427| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1025| 427| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1025:28): [Folded - Ignored] | Branch (1025:40): [True: 0, False: 0] | Branch (1025:52): [True: 0, False: 0] ------------------ 1026| 0| auto newn = pos.node()->inner()[0]; 1027| 0| if (!mutate) ------------------ | Branch (1027:25): [True: 0, False: 0] ------------------ 1028| 0| newn->inc(); 1029| 0| if (Mutating) ------------------ | Branch (1029:25): [Folded - Ignored] ------------------ 1030| 0| pos.visit(dec_right_visitor{}, count_t{2}); 1031| 0| return std::make_tuple(pos.shift() - B, newn, ts, tail); 1032| 288| } else { 1033| 288| if (mutate) { ------------------ | Branch (1033:25): [True: 0, False: 288] ------------------ 1034| 0| pos.each_right(dec_visitor{}, idx + 1); 1035| 0| return std::make_tuple(pos.shift(), node, ts, tail); 1036| 288| } else { 1037| 288| auto newn = node_t::copy_inner_e(e, node, idx); 1038| 288| if (Mutating) ------------------ | Branch (1038:29): [Folded - Ignored] ------------------ 1039| 0| pos.visit(dec_visitor{}); 1040| 288| return std::make_tuple(pos.shift(), newn, ts, tail); 1041| 288| } 1042| 288| } 1043| 1.18k| } 1044| 1.18k| IMMER_CATCH (...) { 1045| 0| assert(!mutate); 1046| 0| assert(!next || pos.shift() > BL); 1047| 0| assert(tail); 1048| 0| if (next) ------------------ | Branch (1048:21): [True: 0, False: 0] ------------------ 1049| 0| dec_regular(next, pos.shift() - B, last + 1 - ts); 1050| 0| dec_leaf(tail, ts); 1051| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1052| 0| } 1053| 1.18k| } 1054| 1.18k| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb1EE13visit_regularIRNS1_15regular_sub_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 990| 396| { 991| 396| auto idx = pos.index(last); 992| 396| auto node = pos.node(); 993| 396| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (993:23): [Folded - Ignored] | Branch (993:35): [True: 162, False: 234] ------------------ 994| 396| if (Collapse && idx == 0) { ------------------ | Branch (994:13): [Folded - Ignored] | Branch (994:25): [True: 305, False: 91] ------------------ 995| 305| auto res = mutate ? pos.towards_oh(this_t{}, last, idx, e) ------------------ | Branch (995:24): [True: 123, False: 182] ------------------ 996| 305| : pos.towards_oh(no_mut_t{}, last, idx, e); 997| 305| if (Mutating) ------------------ | Branch (997:17): [Folded - Ignored] ------------------ 998| 305| pos.visit(dec_right_visitor{}, count_t{1}); 999| 305| return res; 1000| 305| } else { 1001| 91| using std::get; 1002| 91| auto subs = 1003| 91| mutate ? pos.towards_oh(no_collapse_t{}, last, idx, e) ------------------ | Branch (1003:17): [True: 39, False: 52] ------------------ 1004| 91| : pos.towards_oh(no_collapse_no_mut_t{}, last, idx, e); 1005| 91| auto next = get<1>(subs); 1006| 91| auto ts = get<2>(subs); 1007| 91| auto tail = get<3>(subs); 1008| 91| IMMER_TRY { ------------------ | | 41| 91|#define IMMER_TRY try ------------------ 1009| 91| if (next) { ------------------ | Branch (1009:21): [True: 11, False: 80] ------------------ 1010| 11| if (mutate) { ------------------ | Branch (1010:25): [True: 5, False: 6] ------------------ 1011| 5| node->inner()[idx] = next; 1012| 5| pos.each_right(dec_visitor{}, idx + 1); 1013| 5| return std::make_tuple(pos.shift(), node, ts, tail); 1014| 6| } else { 1015| 6| auto newn = node_t::copy_inner_e(e, node, idx); 1016| 6| newn->inner()[idx] = next; 1017| 6| if (Mutating) ------------------ | Branch (1017:29): [Folded - Ignored] ------------------ 1018| 6| pos.visit(dec_visitor{}); 1019| 6| return std::make_tuple(pos.shift(), newn, ts, tail); 1020| 6| } 1021| 80| } else if (idx == 0) { ------------------ | Branch (1021:28): [True: 0, False: 80] ------------------ 1022| 0| if (Mutating) ------------------ | Branch (1022:25): [Folded - Ignored] ------------------ 1023| 0| pos.visit(dec_right_visitor{}, count_t{1}); 1024| 0| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1025| 80| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1025:28): [Folded - Ignored] | Branch (1025:40): [True: 69, False: 11] | Branch (1025:52): [True: 56, False: 13] ------------------ 1026| 56| auto newn = pos.node()->inner()[0]; 1027| 56| if (!mutate) ------------------ | Branch (1027:25): [True: 38, False: 18] ------------------ 1028| 38| newn->inc(); 1029| 56| if (Mutating) ------------------ | Branch (1029:25): [Folded - Ignored] ------------------ 1030| 56| pos.visit(dec_right_visitor{}, count_t{2}); 1031| 56| return std::make_tuple(pos.shift() - B, newn, ts, tail); 1032| 56| } else { 1033| 24| if (mutate) { ------------------ | Branch (1033:25): [True: 16, False: 8] ------------------ 1034| 16| pos.each_right(dec_visitor{}, idx + 1); 1035| 16| return std::make_tuple(pos.shift(), node, ts, tail); 1036| 16| } else { 1037| 8| auto newn = node_t::copy_inner_e(e, node, idx); 1038| 8| if (Mutating) ------------------ | Branch (1038:29): [Folded - Ignored] ------------------ 1039| 8| pos.visit(dec_visitor{}); 1040| 8| return std::make_tuple(pos.shift(), newn, ts, tail); 1041| 8| } 1042| 24| } 1043| 91| } 1044| 91| IMMER_CATCH (...) { 1045| 0| assert(!mutate); 1046| 0| assert(!next || pos.shift() > BL); 1047| 0| assert(tail); 1048| 0| if (next) ------------------ | Branch (1048:21): [True: 0, False: 0] ------------------ 1049| 0| dec_regular(next, pos.shift() - B, last + 1 - ts); 1050| 0| dec_leaf(tail, ts); 1051| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1052| 0| } 1053| 91| } 1054| 396| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb1EE10visit_leafIRNS1_13full_leaf_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 1058| 49| { 1059| 49| auto old_tail_size = pos.count(); 1060| 49| auto new_tail_size = pos.index(last) + 1; 1061| 49| auto node = pos.node(); 1062| 49| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (1062:30): [Folded - Ignored] | Branch (1062:42): [True: 17, False: 32] ------------------ 1063| 49| if (new_tail_size == old_tail_size) { ------------------ | Branch (1063:13): [True: 0, False: 49] ------------------ 1064| 0| if (!Mutating) ------------------ | Branch (1064:17): [Folded - Ignored] ------------------ 1065| 0| node->inc(); 1066| 0| return std::make_tuple(0, nullptr, new_tail_size, node); 1067| 49| } else if (mutate) { ------------------ | Branch (1067:20): [True: 17, False: 32] ------------------ 1068| 17| detail::destroy_n(node->leaf() + new_tail_size, 1069| 17| old_tail_size - new_tail_size); 1070| 17| return std::make_tuple(0, nullptr, new_tail_size, node); 1071| 32| } else { 1072| 32| auto new_tail = node_t::copy_leaf_e(e, node, new_tail_size); 1073| 32| if (Mutating) ------------------ | Branch (1073:17): [Folded - Ignored] ------------------ 1074| 32| pos.visit(dec_visitor{}); 1075| 32| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1076| 32| } 1077| 49| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb1EE13visit_regularIRNS1_8full_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 990| 80| { 991| 80| auto idx = pos.index(last); 992| 80| auto node = pos.node(); 993| 80| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (993:23): [Folded - Ignored] | Branch (993:35): [True: 75, False: 5] ------------------ 994| 80| if (Collapse && idx == 0) { ------------------ | Branch (994:13): [Folded - Ignored] | Branch (994:25): [True: 56, False: 24] ------------------ 995| 56| auto res = mutate ? pos.towards_oh(this_t{}, last, idx, e) ------------------ | Branch (995:24): [True: 52, False: 4] ------------------ 996| 56| : pos.towards_oh(no_mut_t{}, last, idx, e); 997| 56| if (Mutating) ------------------ | Branch (997:17): [Folded - Ignored] ------------------ 998| 56| pos.visit(dec_right_visitor{}, count_t{1}); 999| 56| return res; 1000| 56| } else { 1001| 24| using std::get; 1002| 24| auto subs = 1003| 24| mutate ? pos.towards_oh(no_collapse_t{}, last, idx, e) ------------------ | Branch (1003:17): [True: 23, False: 1] ------------------ 1004| 24| : pos.towards_oh(no_collapse_no_mut_t{}, last, idx, e); 1005| 24| auto next = get<1>(subs); 1006| 24| auto ts = get<2>(subs); 1007| 24| auto tail = get<3>(subs); 1008| 24| IMMER_TRY { ------------------ | | 41| 24|#define IMMER_TRY try ------------------ 1009| 24| if (next) { ------------------ | Branch (1009:21): [True: 16, False: 8] ------------------ 1010| 16| if (mutate) { ------------------ | Branch (1010:25): [True: 16, False: 0] ------------------ 1011| 16| node->inner()[idx] = next; 1012| 16| pos.each_right(dec_visitor{}, idx + 1); 1013| 16| return std::make_tuple(pos.shift(), node, ts, tail); 1014| 16| } else { 1015| 0| auto newn = node_t::copy_inner_e(e, node, idx); 1016| 0| newn->inner()[idx] = next; 1017| 0| if (Mutating) ------------------ | Branch (1017:29): [Folded - Ignored] ------------------ 1018| 0| pos.visit(dec_visitor{}); 1019| 0| return std::make_tuple(pos.shift(), newn, ts, tail); 1020| 0| } 1021| 16| } else if (idx == 0) { ------------------ | Branch (1021:28): [True: 0, False: 8] ------------------ 1022| 0| if (Mutating) ------------------ | Branch (1022:25): [Folded - Ignored] ------------------ 1023| 0| pos.visit(dec_right_visitor{}, count_t{1}); 1024| 0| return std::make_tuple(pos.shift(), nullptr, ts, tail); 1025| 8| } else if (Collapse && idx == 1 && pos.shift() > BL) { ------------------ | Branch (1025:28): [Folded - Ignored] | Branch (1025:40): [True: 3, False: 5] | Branch (1025:52): [True: 0, False: 3] ------------------ 1026| 0| auto newn = pos.node()->inner()[0]; 1027| 0| if (!mutate) ------------------ | Branch (1027:25): [True: 0, False: 0] ------------------ 1028| 0| newn->inc(); 1029| 0| if (Mutating) ------------------ | Branch (1029:25): [Folded - Ignored] ------------------ 1030| 0| pos.visit(dec_right_visitor{}, count_t{2}); 1031| 0| return std::make_tuple(pos.shift() - B, newn, ts, tail); 1032| 8| } else { 1033| 8| if (mutate) { ------------------ | Branch (1033:25): [True: 7, False: 1] ------------------ 1034| 7| pos.each_right(dec_visitor{}, idx + 1); 1035| 7| return std::make_tuple(pos.shift(), node, ts, tail); 1036| 7| } else { 1037| 1| auto newn = node_t::copy_inner_e(e, node, idx); 1038| 1| if (Mutating) ------------------ | Branch (1038:29): [Folded - Ignored] ------------------ 1039| 1| pos.visit(dec_visitor{}); 1040| 1| return std::make_tuple(pos.shift(), newn, ts, tail); 1041| 1| } 1042| 8| } 1043| 24| } 1044| 24| IMMER_CATCH (...) { 1045| 0| assert(!mutate); 1046| 0| assert(!next || pos.shift() > BL); 1047| 0| assert(tail); 1048| 0| if (next) ------------------ | Branch (1048:21): [True: 0, False: 0] ------------------ 1049| 0| dec_regular(next, pos.shift() - B, last + 1 - ts); 1050| 0| dec_leaf(tail, ts); 1051| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1052| 0| } 1053| 24| } 1054| 80| } _ZN5immer6detail4rbts23slice_right_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb1EE10visit_leafIRNS1_8leaf_posISC_EEEENSt3__15tupleIJjPSC_jSK_EEEOT_mNSA_5applyIS7_E4type4editE: 1058| 46| { 1059| 46| auto old_tail_size = pos.count(); 1060| 46| auto new_tail_size = pos.index(last) + 1; 1061| 46| auto node = pos.node(); 1062| 46| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (1062:30): [Folded - Ignored] | Branch (1062:42): [True: 22, False: 24] ------------------ 1063| 46| if (new_tail_size == old_tail_size) { ------------------ | Branch (1063:13): [True: 0, False: 46] ------------------ 1064| 0| if (!Mutating) ------------------ | Branch (1064:17): [Folded - Ignored] ------------------ 1065| 0| node->inc(); 1066| 0| return std::make_tuple(0, nullptr, new_tail_size, node); 1067| 46| } else if (mutate) { ------------------ | Branch (1067:20): [True: 22, False: 24] ------------------ 1068| 22| detail::destroy_n(node->leaf() + new_tail_size, 1069| 22| old_tail_size - new_tail_size); 1070| 22| return std::make_tuple(0, nullptr, new_tail_size, node); 1071| 24| } else { 1072| 24| auto new_tail = node_t::copy_leaf_e(e, node, new_tail_size); 1073| 24| if (Mutating) ------------------ | Branch (1073:17): [Folded - Ignored] ------------------ 1074| 24| pos.visit(dec_visitor{}); 1075| 24| return std::make_tuple(0, nullptr, new_tail_size, new_tail); 1076| 24| } 1077| 46| } _ZN5immer6detail4rbts22slice_left_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb1EE10visit_leafIRNS1_12leaf_sub_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_mNSA_5applyIS7_E4type4editE: 1376| 153| { 1377| 153| auto node = pos.node(); 1378| 153| auto idx = pos.index(first); 1379| 153| auto count = pos.count(); 1380| 153| auto mutate = Mutating && ------------------ | Branch (1380:23): [Folded - Ignored] ------------------ 1381| 153| std::is_nothrow_move_constructible::value && ------------------ | Branch (1381:23): [Folded - Ignored] ------------------ 1382| 153| node->can_mutate(e); ------------------ | Branch (1382:23): [True: 145, False: 8] ------------------ 1383| 153| if (mutate) { ------------------ | Branch (1383:13): [True: 145, False: 8] ------------------ 1384| 145| auto data = node->leaf(); 1385| 145| auto newcount = count - idx; 1386| 145| std::move(data + idx, data + count, data); 1387| 145| detail::destroy_n(data + newcount, idx); 1388| 145| return std::make_tuple(0, node); 1389| 145| } else { 1390| 8| auto newn = node_t::copy_leaf_e(e, node, idx, count); 1391| 8| if (Mutating) ------------------ | Branch (1391:17): [Folded - Ignored] ------------------ 1392| 8| pos.visit(dec_visitor{}); 1393| 8| return std::make_tuple(0, newn); 1394| 8| } 1395| 153| } _ZN5immer6detail4rbts22slice_left_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb1EE13visit_relaxedIRNS1_11relaxed_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_mNSA_5applyIS7_E4type4editE: 1245| 24.4k| { 1246| 24.4k| auto idx = pos.subindex(first); 1247| 24.4k| auto count = pos.count(); 1248| 24.4k| auto node = pos.node(); 1249| 24.4k| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (1249:35): [Folded - Ignored] | Branch (1249:47): [True: 14.3k, False: 10.1k] ------------------ 1250| 24.4k| auto left_size = pos.size_before(idx); 1251| 24.4k| auto child_size = pos.size_sbh(idx, left_size); 1252| 24.4k| auto dropped_size = first; 1253| 24.4k| auto child_dropped_size = dropped_size - left_size; 1254| 24.4k| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1254:13): [Folded - Ignored] | Branch (1254:25): [True: 24.4k, False: 77] | Branch (1254:45): [True: 85, False: 24.3k] ------------------ 1255| 85| auto r = mutate ? pos.towards_sub_oh(this_t{}, first, idx, e) ------------------ | Branch (1255:22): [True: 53, False: 32] ------------------ 1256| 85| : pos.towards_sub_oh(no_mut_t{}, first, idx, e); 1257| 85| if (mutate) ------------------ | Branch (1257:17): [True: 53, False: 32] ------------------ 1258| 53| pos.visit(dec_left_visitor{}, idx); 1259| 32| else if (Mutating) ------------------ | Branch (1259:22): [Folded - Ignored] ------------------ 1260| 32| pos.visit(dec_visitor{}); 1261| 85| return r; 1262| 24.3k| } else { 1263| 24.3k| using std::get; 1264| 24.3k| auto newn = mutate ? (node->ensure_mutable_relaxed(e), node) ------------------ | Branch (1264:29): [True: 14.2k, False: 10.0k] ------------------ 1265| 24.3k| : node_t::make_inner_r_e(e); 1266| 24.3k| auto newr = newn->relaxed(); 1267| 24.3k| auto newcount = count - idx; 1268| 24.3k| auto new_child_size = child_size - child_dropped_size; 1269| 24.3k| IMMER_TRY { ------------------ | | 41| 24.3k|#define IMMER_TRY try ------------------ 1270| 24.3k| auto subs = 1271| 24.3k| mutate ? pos.towards_sub_oh(no_collapse_t{}, first, idx, e) ------------------ | Branch (1271:21): [True: 14.2k, False: 10.0k] ------------------ 1272| 24.3k| : pos.towards_sub_oh( 1273| 10.0k| no_collapse_no_mut_t{}, first, idx, e); 1274| 24.3k| if (mutate) ------------------ | Branch (1274:21): [True: 14.2k, False: 10.0k] ------------------ 1275| 14.2k| pos.each_left(dec_visitor{}, idx); 1276| 24.3k| pos.copy_sizes( 1277| 24.3k| idx + 1, newcount - 1, new_child_size, newr->d.sizes + 1); 1278| 24.3k| std::copy(node->inner() + idx + 1, 1279| 24.3k| node->inner() + count, 1280| 24.3k| newn->inner() + 1); 1281| 24.3k| newn->inner()[0] = get<1>(subs); 1282| 24.3k| newr->d.sizes[0] = new_child_size; 1283| 24.3k| newr->d.count = newcount; 1284| 24.3k| assert(new_child_size); 1285| 24.3k| if (!mutate) { ------------------ | Branch (1285:21): [True: 10.0k, False: 14.2k] ------------------ 1286| 10.0k| node_t::inc_nodes(newn->inner() + 1, newcount - 1); 1287| 10.0k| if (Mutating) ------------------ | Branch (1287:25): [Folded - Ignored] ------------------ 1288| 10.0k| pos.visit(dec_visitor{}); 1289| 10.0k| } 1290| 24.3k| return std::make_tuple(pos.shift(), newn); 1291| 24.3k| } 1292| 24.3k| IMMER_CATCH (...) { 1293| 0| if (!mutate) ------------------ | Branch (1293:21): [True: 0, False: 0] ------------------ 1294| 0| node_t::delete_inner_r_e(newn); 1295| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1296| 0| } 1297| 24.3k| } 1298| 24.4k| } _ZN5immer6detail4rbts22slice_left_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb0EE13visit_relaxedIRNS1_11relaxed_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_mNSA_5applyIS7_E4type4editE: 1245| 14| { 1246| 14| auto idx = pos.subindex(first); 1247| 14| auto count = pos.count(); 1248| 14| auto node = pos.node(); 1249| 14| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (1249:35): [Folded - Ignored] | Branch (1249:47): [True: 0, False: 0] ------------------ 1250| 14| auto left_size = pos.size_before(idx); 1251| 14| auto child_size = pos.size_sbh(idx, left_size); 1252| 14| auto dropped_size = first; 1253| 14| auto child_dropped_size = dropped_size - left_size; 1254| 14| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1254:13): [Folded - Ignored] | Branch (1254:25): [True: 0, False: 14] | Branch (1254:45): [True: 0, False: 0] ------------------ 1255| 0| auto r = mutate ? pos.towards_sub_oh(this_t{}, first, idx, e) ------------------ | Branch (1255:22): [True: 0, False: 0] ------------------ 1256| 0| : pos.towards_sub_oh(no_mut_t{}, first, idx, e); 1257| 0| if (mutate) ------------------ | Branch (1257:17): [True: 0, False: 0] ------------------ 1258| 0| pos.visit(dec_left_visitor{}, idx); 1259| 0| else if (Mutating) ------------------ | Branch (1259:22): [Folded - Ignored] ------------------ 1260| 0| pos.visit(dec_visitor{}); 1261| 0| return r; 1262| 14| } else { 1263| 14| using std::get; 1264| 14| auto newn = mutate ? (node->ensure_mutable_relaxed(e), node) ------------------ | Branch (1264:29): [True: 0, False: 14] ------------------ 1265| 14| : node_t::make_inner_r_e(e); 1266| 14| auto newr = newn->relaxed(); 1267| 14| auto newcount = count - idx; 1268| 14| auto new_child_size = child_size - child_dropped_size; 1269| 14| IMMER_TRY { ------------------ | | 41| 14|#define IMMER_TRY try ------------------ 1270| 14| auto subs = 1271| 14| mutate ? pos.towards_sub_oh(no_collapse_t{}, first, idx, e) ------------------ | Branch (1271:21): [True: 0, False: 14] ------------------ 1272| 14| : pos.towards_sub_oh( 1273| 14| no_collapse_no_mut_t{}, first, idx, e); 1274| 14| if (mutate) ------------------ | Branch (1274:21): [True: 0, False: 14] ------------------ 1275| 0| pos.each_left(dec_visitor{}, idx); 1276| 14| pos.copy_sizes( 1277| 14| idx + 1, newcount - 1, new_child_size, newr->d.sizes + 1); 1278| 14| std::copy(node->inner() + idx + 1, 1279| 14| node->inner() + count, 1280| 14| newn->inner() + 1); 1281| 14| newn->inner()[0] = get<1>(subs); 1282| 14| newr->d.sizes[0] = new_child_size; 1283| 14| newr->d.count = newcount; 1284| 14| assert(new_child_size); 1285| 14| if (!mutate) { ------------------ | Branch (1285:21): [True: 14, False: 0] ------------------ 1286| 14| node_t::inc_nodes(newn->inner() + 1, newcount - 1); 1287| 14| if (Mutating) ------------------ | Branch (1287:25): [Folded - Ignored] ------------------ 1288| 0| pos.visit(dec_visitor{}); 1289| 14| } 1290| 14| return std::make_tuple(pos.shift(), newn); 1291| 14| } 1292| 14| IMMER_CATCH (...) { 1293| 0| if (!mutate) ------------------ | Branch (1293:21): [True: 0, False: 0] ------------------ 1294| 0| node_t::delete_inner_r_e(newn); 1295| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1296| 0| } 1297| 14| } 1298| 14| } _ZN5immer6detail4rbts22slice_left_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb0EE13visit_regularIRNS1_15regular_sub_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_mNSA_5applyIS7_E4type4editE: 1302| 23| { 1303| 23| auto idx = pos.subindex(first); 1304| 23| auto count = pos.count(); 1305| 23| auto node = pos.node(); 1306| 23| auto mutate = Mutating ------------------ | Branch (1306:23): [Folded - Ignored] ------------------ 1307| | // this is more restrictive than actually needed because 1308| | // it causes the algorithm to also avoid mutating the leaf 1309| | // in place 1310| 23| && !node_t::embed_relaxed && node->can_mutate(e); ------------------ | Branch (1310:26): [Folded - Ignored] | Branch (1310:52): [True: 0, False: 0] ------------------ 1311| 23| auto left_size = pos.size_before(idx); 1312| 23| auto child_size = pos.size_sbh(idx, left_size); 1313| 23| auto dropped_size = first; 1314| 23| auto child_dropped_size = dropped_size - left_size; 1315| 23| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1315:13): [Folded - Ignored] | Branch (1315:25): [True: 23, False: 0] | Branch (1315:45): [True: 3, False: 20] ------------------ 1316| 3| auto r = mutate ? pos.towards_sub_oh(this_t{}, first, idx, e) ------------------ | Branch (1316:22): [True: 0, False: 3] ------------------ 1317| 3| : pos.towards_sub_oh(no_mut_t{}, first, idx, e); 1318| 3| if (mutate) ------------------ | Branch (1318:17): [True: 0, False: 3] ------------------ 1319| 0| pos.visit(dec_left_visitor{}, idx); 1320| 3| else if (Mutating) ------------------ | Branch (1320:22): [Folded - Ignored] ------------------ 1321| 0| pos.visit(dec_visitor{}); 1322| 3| return r; 1323| 20| } else { 1324| 20| using std::get; 1325| | // if possible, we convert the node to a relaxed one simply by 1326| | // allocating a `relaxed_t` size table for it... maybe some of this 1327| | // magic should be moved as a `node<...>` static method... 1328| 20| auto newcount = count - idx; 1329| 20| auto newn = 1330| 20| mutate ? (node->impl.d.data.inner.relaxed = new ( ------------------ | Branch (1330:17): [True: 0, False: 20] ------------------ 1331| 0| node_t::heap::allocate(node_t::max_sizeof_relaxed, 1332| 0| norefs_tag{})) relaxed_t, 1333| 0| node) 1334| 20| : node_t::make_inner_r_e(e); 1335| 20| auto newr = newn->relaxed(); 1336| 20| IMMER_TRY { ------------------ | | 41| 20|#define IMMER_TRY try ------------------ 1337| 20| auto subs = 1338| 20| mutate ? pos.towards_sub_oh(no_collapse_t{}, first, idx, e) ------------------ | Branch (1338:21): [True: 0, False: 20] ------------------ 1339| 20| : pos.towards_sub_oh( 1340| 20| no_collapse_no_mut_t{}, first, idx, e); 1341| 20| if (mutate) ------------------ | Branch (1341:21): [True: 0, False: 20] ------------------ 1342| 0| pos.each_left(dec_visitor{}, idx); 1343| 20| newr->d.sizes[0] = child_size - child_dropped_size; 1344| 20| assert(newr->d.sizes[0]); 1345| 0| pos.copy_sizes( 1346| 20| idx + 1, newcount - 1, newr->d.sizes[0], newr->d.sizes + 1); 1347| 20| newr->d.count = newcount; 1348| 20| newn->inner()[0] = get<1>(subs); 1349| 20| std::copy(node->inner() + idx + 1, 1350| 20| node->inner() + count, 1351| 20| newn->inner() + 1); 1352| 20| if (!mutate) { ------------------ | Branch (1352:21): [True: 20, False: 0] ------------------ 1353| 20| node_t::inc_nodes(newn->inner() + 1, newcount - 1); 1354| 20| if (Mutating) ------------------ | Branch (1354:25): [Folded - Ignored] ------------------ 1355| 0| pos.visit(dec_visitor{}); 1356| 20| } 1357| 20| return std::make_tuple(pos.shift(), newn); 1358| 20| } 1359| 20| IMMER_CATCH (...) { 1360| 0| if (!mutate) ------------------ | Branch (1360:21): [True: 0, False: 0] ------------------ 1361| 0| node_t::delete_inner_r_e(newn); 1362| 0| else { 1363| | // restore the regular node that we were 1364| | // attempting to relax... 1365| 0| node_t::heap::deallocate(node_t::max_sizeof_relaxed, 1366| 0| node->impl.d.data.inner.relaxed); 1367| 0| node->impl.d.data.inner.relaxed = nullptr; 1368| 0| } 1369| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1370| 0| } 1371| 20| } 1372| 23| } _ZN5immer6detail4rbts22slice_left_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb1EE10visit_leafIRNS1_13full_leaf_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_mNSA_5applyIS7_E4type4editE: 1376| 64| { 1377| 64| auto node = pos.node(); 1378| 64| auto idx = pos.index(first); 1379| 64| auto count = pos.count(); 1380| 64| auto mutate = Mutating && ------------------ | Branch (1380:23): [Folded - Ignored] ------------------ 1381| 64| std::is_nothrow_move_constructible::value && ------------------ | Branch (1381:23): [Folded - Ignored] ------------------ 1382| 64| node->can_mutate(e); ------------------ | Branch (1382:23): [True: 17, False: 47] ------------------ 1383| 64| if (mutate) { ------------------ | Branch (1383:13): [True: 17, False: 47] ------------------ 1384| 17| auto data = node->leaf(); 1385| 17| auto newcount = count - idx; 1386| 17| std::move(data + idx, data + count, data); 1387| 17| detail::destroy_n(data + newcount, idx); 1388| 17| return std::make_tuple(0, node); 1389| 47| } else { 1390| 47| auto newn = node_t::copy_leaf_e(e, node, idx, count); 1391| 47| if (Mutating) ------------------ | Branch (1391:17): [Folded - Ignored] ------------------ 1392| 47| pos.visit(dec_visitor{}); 1393| 47| return std::make_tuple(0, newn); 1394| 47| } 1395| 64| } _ZN5immer6detail4rbts22slice_left_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb1EE13visit_regularIRNS1_8full_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_mNSA_5applyIS7_E4type4editE: 1302| 52| { 1303| 52| auto idx = pos.subindex(first); 1304| 52| auto count = pos.count(); 1305| 52| auto node = pos.node(); 1306| 52| auto mutate = Mutating ------------------ | Branch (1306:23): [Folded - Ignored] ------------------ 1307| | // this is more restrictive than actually needed because 1308| | // it causes the algorithm to also avoid mutating the leaf 1309| | // in place 1310| 52| && !node_t::embed_relaxed && node->can_mutate(e); ------------------ | Branch (1310:26): [Folded - Ignored] | Branch (1310:52): [True: 35, False: 17] ------------------ 1311| 52| auto left_size = pos.size_before(idx); 1312| 52| auto child_size = pos.size_sbh(idx, left_size); 1313| 52| auto dropped_size = first; 1314| 52| auto child_dropped_size = dropped_size - left_size; 1315| 52| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1315:13): [Folded - Ignored] | Branch (1315:25): [True: 0, False: 0] | Branch (1315:45): [True: 0, False: 0] ------------------ 1316| 0| auto r = mutate ? pos.towards_sub_oh(this_t{}, first, idx, e) ------------------ | Branch (1316:22): [True: 0, False: 0] ------------------ 1317| 0| : pos.towards_sub_oh(no_mut_t{}, first, idx, e); 1318| 0| if (mutate) ------------------ | Branch (1318:17): [True: 0, False: 0] ------------------ 1319| 0| pos.visit(dec_left_visitor{}, idx); 1320| 0| else if (Mutating) ------------------ | Branch (1320:22): [Folded - Ignored] ------------------ 1321| 0| pos.visit(dec_visitor{}); 1322| 0| return r; 1323| 52| } else { 1324| 52| using std::get; 1325| | // if possible, we convert the node to a relaxed one simply by 1326| | // allocating a `relaxed_t` size table for it... maybe some of this 1327| | // magic should be moved as a `node<...>` static method... 1328| 52| auto newcount = count - idx; 1329| 52| auto newn = 1330| 52| mutate ? (node->impl.d.data.inner.relaxed = new ( ------------------ | Branch (1330:17): [True: 35, False: 17] ------------------ 1331| 35| node_t::heap::allocate(node_t::max_sizeof_relaxed, 1332| 35| norefs_tag{})) relaxed_t, 1333| 35| node) 1334| 52| : node_t::make_inner_r_e(e); 1335| 52| auto newr = newn->relaxed(); 1336| 52| IMMER_TRY { ------------------ | | 41| 52|#define IMMER_TRY try ------------------ 1337| 52| auto subs = 1338| 52| mutate ? pos.towards_sub_oh(no_collapse_t{}, first, idx, e) ------------------ | Branch (1338:21): [True: 35, False: 17] ------------------ 1339| 52| : pos.towards_sub_oh( 1340| 17| no_collapse_no_mut_t{}, first, idx, e); 1341| 52| if (mutate) ------------------ | Branch (1341:21): [True: 35, False: 17] ------------------ 1342| 35| pos.each_left(dec_visitor{}, idx); 1343| 52| newr->d.sizes[0] = child_size - child_dropped_size; 1344| 52| assert(newr->d.sizes[0]); 1345| 0| pos.copy_sizes( 1346| 52| idx + 1, newcount - 1, newr->d.sizes[0], newr->d.sizes + 1); 1347| 52| newr->d.count = newcount; 1348| 52| newn->inner()[0] = get<1>(subs); 1349| 52| std::copy(node->inner() + idx + 1, 1350| 52| node->inner() + count, 1351| 52| newn->inner() + 1); 1352| 52| if (!mutate) { ------------------ | Branch (1352:21): [True: 17, False: 35] ------------------ 1353| 17| node_t::inc_nodes(newn->inner() + 1, newcount - 1); 1354| 17| if (Mutating) ------------------ | Branch (1354:25): [Folded - Ignored] ------------------ 1355| 17| pos.visit(dec_visitor{}); 1356| 17| } 1357| 52| return std::make_tuple(pos.shift(), newn); 1358| 52| } 1359| 52| IMMER_CATCH (...) { 1360| 0| if (!mutate) ------------------ | Branch (1360:21): [True: 0, False: 0] ------------------ 1361| 0| node_t::delete_inner_r_e(newn); 1362| 0| else { 1363| | // restore the regular node that we were 1364| | // attempting to relax... 1365| 0| node_t::heap::deallocate(node_t::max_sizeof_relaxed, 1366| 0| node->impl.d.data.inner.relaxed); 1367| 0| node->impl.d.data.inner.relaxed = nullptr; 1368| 0| } 1369| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1370| 0| } 1371| 52| } 1372| 52| } _ZN5immer6detail4rbts22slice_left_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb0EE10visit_leafIRNS1_13full_leaf_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_mNSA_5applyIS7_E4type4editE: 1376| 2.56k| { 1377| 2.56k| auto node = pos.node(); 1378| 2.56k| auto idx = pos.index(first); 1379| 2.56k| auto count = pos.count(); 1380| 2.56k| auto mutate = Mutating && ------------------ | Branch (1380:23): [Folded - Ignored] ------------------ 1381| 2.56k| std::is_nothrow_move_constructible::value && ------------------ | Branch (1381:23): [Folded - Ignored] ------------------ 1382| 2.56k| node->can_mutate(e); ------------------ | Branch (1382:23): [True: 0, False: 0] ------------------ 1383| 2.56k| if (mutate) { ------------------ | Branch (1383:13): [True: 0, False: 2.56k] ------------------ 1384| 0| auto data = node->leaf(); 1385| 0| auto newcount = count - idx; 1386| 0| std::move(data + idx, data + count, data); 1387| 0| detail::destroy_n(data + newcount, idx); 1388| 0| return std::make_tuple(0, node); 1389| 2.56k| } else { 1390| 2.56k| auto newn = node_t::copy_leaf_e(e, node, idx, count); 1391| 2.56k| if (Mutating) ------------------ | Branch (1391:17): [Folded - Ignored] ------------------ 1392| 0| pos.visit(dec_visitor{}); 1393| 2.56k| return std::make_tuple(0, newn); 1394| 2.56k| } 1395| 2.56k| } _ZN5immer6detail4rbts22slice_left_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb0EE13visit_regularIRNS1_8full_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_mNSA_5applyIS7_E4type4editE: 1302| 327| { 1303| 327| auto idx = pos.subindex(first); 1304| 327| auto count = pos.count(); 1305| 327| auto node = pos.node(); 1306| 327| auto mutate = Mutating ------------------ | Branch (1306:23): [Folded - Ignored] ------------------ 1307| | // this is more restrictive than actually needed because 1308| | // it causes the algorithm to also avoid mutating the leaf 1309| | // in place 1310| 327| && !node_t::embed_relaxed && node->can_mutate(e); ------------------ | Branch (1310:26): [Folded - Ignored] | Branch (1310:52): [True: 0, False: 0] ------------------ 1311| 327| auto left_size = pos.size_before(idx); 1312| 327| auto child_size = pos.size_sbh(idx, left_size); 1313| 327| auto dropped_size = first; 1314| 327| auto child_dropped_size = dropped_size - left_size; 1315| 327| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1315:13): [Folded - Ignored] | Branch (1315:25): [True: 0, False: 0] | Branch (1315:45): [True: 0, False: 0] ------------------ 1316| 0| auto r = mutate ? pos.towards_sub_oh(this_t{}, first, idx, e) ------------------ | Branch (1316:22): [True: 0, False: 0] ------------------ 1317| 0| : pos.towards_sub_oh(no_mut_t{}, first, idx, e); 1318| 0| if (mutate) ------------------ | Branch (1318:17): [True: 0, False: 0] ------------------ 1319| 0| pos.visit(dec_left_visitor{}, idx); 1320| 0| else if (Mutating) ------------------ | Branch (1320:22): [Folded - Ignored] ------------------ 1321| 0| pos.visit(dec_visitor{}); 1322| 0| return r; 1323| 327| } else { 1324| 327| using std::get; 1325| | // if possible, we convert the node to a relaxed one simply by 1326| | // allocating a `relaxed_t` size table for it... maybe some of this 1327| | // magic should be moved as a `node<...>` static method... 1328| 327| auto newcount = count - idx; 1329| 327| auto newn = 1330| 327| mutate ? (node->impl.d.data.inner.relaxed = new ( ------------------ | Branch (1330:17): [True: 0, False: 327] ------------------ 1331| 0| node_t::heap::allocate(node_t::max_sizeof_relaxed, 1332| 0| norefs_tag{})) relaxed_t, 1333| 0| node) 1334| 327| : node_t::make_inner_r_e(e); 1335| 327| auto newr = newn->relaxed(); 1336| 327| IMMER_TRY { ------------------ | | 41| 327|#define IMMER_TRY try ------------------ 1337| 327| auto subs = 1338| 327| mutate ? pos.towards_sub_oh(no_collapse_t{}, first, idx, e) ------------------ | Branch (1338:21): [True: 0, False: 327] ------------------ 1339| 327| : pos.towards_sub_oh( 1340| 327| no_collapse_no_mut_t{}, first, idx, e); 1341| 327| if (mutate) ------------------ | Branch (1341:21): [True: 0, False: 327] ------------------ 1342| 0| pos.each_left(dec_visitor{}, idx); 1343| 327| newr->d.sizes[0] = child_size - child_dropped_size; 1344| 327| assert(newr->d.sizes[0]); 1345| 0| pos.copy_sizes( 1346| 327| idx + 1, newcount - 1, newr->d.sizes[0], newr->d.sizes + 1); 1347| 327| newr->d.count = newcount; 1348| 327| newn->inner()[0] = get<1>(subs); 1349| 327| std::copy(node->inner() + idx + 1, 1350| 327| node->inner() + count, 1351| 327| newn->inner() + 1); 1352| 327| if (!mutate) { ------------------ | Branch (1352:21): [True: 327, False: 0] ------------------ 1353| 327| node_t::inc_nodes(newn->inner() + 1, newcount - 1); 1354| 327| if (Mutating) ------------------ | Branch (1354:25): [Folded - Ignored] ------------------ 1355| 0| pos.visit(dec_visitor{}); 1356| 327| } 1357| 327| return std::make_tuple(pos.shift(), newn); 1358| 327| } 1359| 327| IMMER_CATCH (...) { 1360| 0| if (!mutate) ------------------ | Branch (1360:21): [True: 0, False: 0] ------------------ 1361| 0| node_t::delete_inner_r_e(newn); 1362| 0| else { 1363| | // restore the regular node that we were 1364| | // attempting to relax... 1365| 0| node_t::heap::deallocate(node_t::max_sizeof_relaxed, 1366| 0| node->impl.d.data.inner.relaxed); 1367| 0| node->impl.d.data.inner.relaxed = nullptr; 1368| 0| } 1369| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1370| 0| } 1371| 327| } 1372| 327| } _ZN5immer6detail4rbts16dec_left_visitor13visit_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEvOT_j: 1208| 47| { 1209| 47| using node_t = node_type; 1210| 47| auto node = p.node(); 1211| 47| if (node->dec()) { ------------------ | Branch (1211:13): [True: 47, False: 0] ------------------ 1212| 47| p.each_left(dec_t{}, idx); 1213| 47| node_t::delete_inner(node, p.count()); 1214| 47| } 1215| 47| } _ZN5immer6detail4rbts22slice_left_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb1EE10visit_leafIRNS1_12leaf_sub_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_mNSA_5applyIS7_E4type4editE: 1376| 443| { 1377| 443| auto node = pos.node(); 1378| 443| auto idx = pos.index(first); 1379| 443| auto count = pos.count(); 1380| 443| auto mutate = Mutating && ------------------ | Branch (1380:23): [Folded - Ignored] ------------------ 1381| 443| std::is_nothrow_move_constructible::value && ------------------ | Branch (1381:23): [Folded - Ignored] ------------------ 1382| 443| node->can_mutate(e); ------------------ | Branch (1382:23): [True: 248, False: 195] ------------------ 1383| 443| if (mutate) { ------------------ | Branch (1383:13): [True: 248, False: 195] ------------------ 1384| 248| auto data = node->leaf(); 1385| 248| auto newcount = count - idx; 1386| 248| std::move(data + idx, data + count, data); 1387| 248| detail::destroy_n(data + newcount, idx); 1388| 248| return std::make_tuple(0, node); 1389| 248| } else { 1390| 195| auto newn = node_t::copy_leaf_e(e, node, idx, count); 1391| 195| if (Mutating) ------------------ | Branch (1391:17): [Folded - Ignored] ------------------ 1392| 195| pos.visit(dec_visitor{}); 1393| 195| return std::make_tuple(0, newn); 1394| 195| } 1395| 443| } _ZN5immer6detail4rbts22slice_left_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb1EE13visit_regularIRNS1_15regular_sub_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_mNSA_5applyIS7_E4type4editE: 1302| 614| { 1303| 614| auto idx = pos.subindex(first); 1304| 614| auto count = pos.count(); 1305| 614| auto node = pos.node(); 1306| 614| auto mutate = Mutating ------------------ | Branch (1306:23): [Folded - Ignored] ------------------ 1307| | // this is more restrictive than actually needed because 1308| | // it causes the algorithm to also avoid mutating the leaf 1309| | // in place 1310| 614| && !node_t::embed_relaxed && node->can_mutate(e); ------------------ | Branch (1310:26): [Folded - Ignored] | Branch (1310:52): [True: 14, False: 600] ------------------ 1311| 614| auto left_size = pos.size_before(idx); 1312| 614| auto child_size = pos.size_sbh(idx, left_size); 1313| 614| auto dropped_size = first; 1314| 614| auto child_dropped_size = dropped_size - left_size; 1315| 614| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1315:13): [Folded - Ignored] | Branch (1315:25): [True: 0, False: 0] | Branch (1315:45): [True: 0, False: 0] ------------------ 1316| 0| auto r = mutate ? pos.towards_sub_oh(this_t{}, first, idx, e) ------------------ | Branch (1316:22): [True: 0, False: 0] ------------------ 1317| 0| : pos.towards_sub_oh(no_mut_t{}, first, idx, e); 1318| 0| if (mutate) ------------------ | Branch (1318:17): [True: 0, False: 0] ------------------ 1319| 0| pos.visit(dec_left_visitor{}, idx); 1320| 0| else if (Mutating) ------------------ | Branch (1320:22): [Folded - Ignored] ------------------ 1321| 0| pos.visit(dec_visitor{}); 1322| 0| return r; 1323| 614| } else { 1324| 614| using std::get; 1325| | // if possible, we convert the node to a relaxed one simply by 1326| | // allocating a `relaxed_t` size table for it... maybe some of this 1327| | // magic should be moved as a `node<...>` static method... 1328| 614| auto newcount = count - idx; 1329| 614| auto newn = 1330| 614| mutate ? (node->impl.d.data.inner.relaxed = new ( ------------------ | Branch (1330:17): [True: 14, False: 600] ------------------ 1331| 14| node_t::heap::allocate(node_t::max_sizeof_relaxed, 1332| 14| norefs_tag{})) relaxed_t, 1333| 14| node) 1334| 614| : node_t::make_inner_r_e(e); 1335| 614| auto newr = newn->relaxed(); 1336| 614| IMMER_TRY { ------------------ | | 41| 614|#define IMMER_TRY try ------------------ 1337| 614| auto subs = 1338| 614| mutate ? pos.towards_sub_oh(no_collapse_t{}, first, idx, e) ------------------ | Branch (1338:21): [True: 14, False: 600] ------------------ 1339| 614| : pos.towards_sub_oh( 1340| 600| no_collapse_no_mut_t{}, first, idx, e); 1341| 614| if (mutate) ------------------ | Branch (1341:21): [True: 14, False: 600] ------------------ 1342| 14| pos.each_left(dec_visitor{}, idx); 1343| 614| newr->d.sizes[0] = child_size - child_dropped_size; 1344| 614| assert(newr->d.sizes[0]); 1345| 0| pos.copy_sizes( 1346| 614| idx + 1, newcount - 1, newr->d.sizes[0], newr->d.sizes + 1); 1347| 614| newr->d.count = newcount; 1348| 614| newn->inner()[0] = get<1>(subs); 1349| 614| std::copy(node->inner() + idx + 1, 1350| 614| node->inner() + count, 1351| 614| newn->inner() + 1); 1352| 614| if (!mutate) { ------------------ | Branch (1352:21): [True: 600, False: 14] ------------------ 1353| 600| node_t::inc_nodes(newn->inner() + 1, newcount - 1); 1354| 600| if (Mutating) ------------------ | Branch (1354:25): [Folded - Ignored] ------------------ 1355| 600| pos.visit(dec_visitor{}); 1356| 600| } 1357| 614| return std::make_tuple(pos.shift(), newn); 1358| 614| } 1359| 614| IMMER_CATCH (...) { 1360| 0| if (!mutate) ------------------ | Branch (1360:21): [True: 0, False: 0] ------------------ 1361| 0| node_t::delete_inner_r_e(newn); 1362| 0| else { 1363| | // restore the regular node that we were 1364| | // attempting to relax... 1365| 0| node_t::heap::deallocate(node_t::max_sizeof_relaxed, 1366| 0| node->impl.d.data.inner.relaxed); 1367| 0| node->impl.d.data.inner.relaxed = nullptr; 1368| 0| } 1369| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1370| 0| } 1371| 614| } 1372| 614| } _ZN5immer6detail4rbts22slice_left_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb0EE10visit_leafIRNS1_12leaf_sub_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_mNSA_5applyIS7_E4type4editE: 1376| 21.5k| { 1377| 21.5k| auto node = pos.node(); 1378| 21.5k| auto idx = pos.index(first); 1379| 21.5k| auto count = pos.count(); 1380| 21.5k| auto mutate = Mutating && ------------------ | Branch (1380:23): [Folded - Ignored] ------------------ 1381| 21.5k| std::is_nothrow_move_constructible::value && ------------------ | Branch (1381:23): [Folded - Ignored] ------------------ 1382| 21.5k| node->can_mutate(e); ------------------ | Branch (1382:23): [True: 0, False: 0] ------------------ 1383| 21.5k| if (mutate) { ------------------ | Branch (1383:13): [True: 0, False: 21.5k] ------------------ 1384| 0| auto data = node->leaf(); 1385| 0| auto newcount = count - idx; 1386| 0| std::move(data + idx, data + count, data); 1387| 0| detail::destroy_n(data + newcount, idx); 1388| 0| return std::make_tuple(0, node); 1389| 21.5k| } else { 1390| 21.5k| auto newn = node_t::copy_leaf_e(e, node, idx, count); 1391| 21.5k| if (Mutating) ------------------ | Branch (1391:17): [Folded - Ignored] ------------------ 1392| 0| pos.visit(dec_visitor{}); 1393| 21.5k| return std::make_tuple(0, newn); 1394| 21.5k| } 1395| 21.5k| } _ZN5immer6detail4rbts22slice_left_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb0EE13visit_regularIRNS1_15regular_sub_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_mNSA_5applyIS7_E4type4editE: 1302| 1.84k| { 1303| 1.84k| auto idx = pos.subindex(first); 1304| 1.84k| auto count = pos.count(); 1305| 1.84k| auto node = pos.node(); 1306| 1.84k| auto mutate = Mutating ------------------ | Branch (1306:23): [Folded - Ignored] ------------------ 1307| | // this is more restrictive than actually needed because 1308| | // it causes the algorithm to also avoid mutating the leaf 1309| | // in place 1310| 1.84k| && !node_t::embed_relaxed && node->can_mutate(e); ------------------ | Branch (1310:26): [Folded - Ignored] | Branch (1310:52): [True: 0, False: 0] ------------------ 1311| 1.84k| auto left_size = pos.size_before(idx); 1312| 1.84k| auto child_size = pos.size_sbh(idx, left_size); 1313| 1.84k| auto dropped_size = first; 1314| 1.84k| auto child_dropped_size = dropped_size - left_size; 1315| 1.84k| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1315:13): [Folded - Ignored] | Branch (1315:25): [True: 0, False: 0] | Branch (1315:45): [True: 0, False: 0] ------------------ 1316| 0| auto r = mutate ? pos.towards_sub_oh(this_t{}, first, idx, e) ------------------ | Branch (1316:22): [True: 0, False: 0] ------------------ 1317| 0| : pos.towards_sub_oh(no_mut_t{}, first, idx, e); 1318| 0| if (mutate) ------------------ | Branch (1318:17): [True: 0, False: 0] ------------------ 1319| 0| pos.visit(dec_left_visitor{}, idx); 1320| 0| else if (Mutating) ------------------ | Branch (1320:22): [Folded - Ignored] ------------------ 1321| 0| pos.visit(dec_visitor{}); 1322| 0| return r; 1323| 1.84k| } else { 1324| 1.84k| using std::get; 1325| | // if possible, we convert the node to a relaxed one simply by 1326| | // allocating a `relaxed_t` size table for it... maybe some of this 1327| | // magic should be moved as a `node<...>` static method... 1328| 1.84k| auto newcount = count - idx; 1329| 1.84k| auto newn = 1330| 1.84k| mutate ? (node->impl.d.data.inner.relaxed = new ( ------------------ | Branch (1330:17): [True: 0, False: 1.84k] ------------------ 1331| 0| node_t::heap::allocate(node_t::max_sizeof_relaxed, 1332| 0| norefs_tag{})) relaxed_t, 1333| 0| node) 1334| 1.84k| : node_t::make_inner_r_e(e); 1335| 1.84k| auto newr = newn->relaxed(); 1336| 1.84k| IMMER_TRY { ------------------ | | 41| 1.84k|#define IMMER_TRY try ------------------ 1337| 1.84k| auto subs = 1338| 1.84k| mutate ? pos.towards_sub_oh(no_collapse_t{}, first, idx, e) ------------------ | Branch (1338:21): [True: 0, False: 1.84k] ------------------ 1339| 1.84k| : pos.towards_sub_oh( 1340| 1.84k| no_collapse_no_mut_t{}, first, idx, e); 1341| 1.84k| if (mutate) ------------------ | Branch (1341:21): [True: 0, False: 1.84k] ------------------ 1342| 0| pos.each_left(dec_visitor{}, idx); 1343| 1.84k| newr->d.sizes[0] = child_size - child_dropped_size; 1344| 1.84k| assert(newr->d.sizes[0]); 1345| 0| pos.copy_sizes( 1346| 1.84k| idx + 1, newcount - 1, newr->d.sizes[0], newr->d.sizes + 1); 1347| 1.84k| newr->d.count = newcount; 1348| 1.84k| newn->inner()[0] = get<1>(subs); 1349| 1.84k| std::copy(node->inner() + idx + 1, 1350| 1.84k| node->inner() + count, 1351| 1.84k| newn->inner() + 1); 1352| 1.84k| if (!mutate) { ------------------ | Branch (1352:21): [True: 1.84k, False: 0] ------------------ 1353| 1.84k| node_t::inc_nodes(newn->inner() + 1, newcount - 1); 1354| 1.84k| if (Mutating) ------------------ | Branch (1354:25): [Folded - Ignored] ------------------ 1355| 0| pos.visit(dec_visitor{}); 1356| 1.84k| } 1357| 1.84k| return std::make_tuple(pos.shift(), newn); 1358| 1.84k| } 1359| 1.84k| IMMER_CATCH (...) { 1360| 0| if (!mutate) ------------------ | Branch (1360:21): [True: 0, False: 0] ------------------ 1361| 0| node_t::delete_inner_r_e(newn); 1362| 0| else { 1363| | // restore the regular node that we were 1364| | // attempting to relax... 1365| 0| node_t::heap::deallocate(node_t::max_sizeof_relaxed, 1366| 0| node->impl.d.data.inner.relaxed); 1367| 0| node->impl.d.data.inner.relaxed = nullptr; 1368| 0| } 1369| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1370| 0| } 1371| 1.84k| } 1372| 1.84k| } _ZN5immer6detail4rbts16dec_left_visitor13visit_relaxedIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEvOT_j: 1197| 53| { 1198| 53| using node_t = node_type; 1199| 53| auto node = p.node(); 1200| 53| if (node->dec()) { ------------------ | Branch (1200:13): [True: 53, False: 0] ------------------ 1201| 53| p.each_left(dec_t{}, idx); 1202| 53| node_t::delete_inner_r(node, p.count()); 1203| 53| } 1204| 53| } _ZN5immer6detail4rbts22slice_left_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb1EE13visit_relaxedIRNS1_11relaxed_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_mNSA_5applyIS7_E4type4editE: 1245| 90.2k| { 1246| 90.2k| auto idx = pos.subindex(first); 1247| 90.2k| auto count = pos.count(); 1248| 90.2k| auto node = pos.node(); 1249| 90.2k| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (1249:35): [Folded - Ignored] | Branch (1249:47): [True: 76.9k, False: 13.2k] ------------------ 1250| 90.2k| auto left_size = pos.size_before(idx); 1251| 90.2k| auto child_size = pos.size_sbh(idx, left_size); 1252| 90.2k| auto dropped_size = first; 1253| 90.2k| auto child_dropped_size = dropped_size - left_size; 1254| 90.2k| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1254:13): [Folded - Ignored] | Branch (1254:25): [True: 0, False: 0] | Branch (1254:45): [True: 0, False: 0] ------------------ 1255| 0| auto r = mutate ? pos.towards_sub_oh(this_t{}, first, idx, e) ------------------ | Branch (1255:22): [True: 0, False: 0] ------------------ 1256| 0| : pos.towards_sub_oh(no_mut_t{}, first, idx, e); 1257| 0| if (mutate) ------------------ | Branch (1257:17): [True: 0, False: 0] ------------------ 1258| 0| pos.visit(dec_left_visitor{}, idx); 1259| 0| else if (Mutating) ------------------ | Branch (1259:22): [Folded - Ignored] ------------------ 1260| 0| pos.visit(dec_visitor{}); 1261| 0| return r; 1262| 90.2k| } else { 1263| 90.2k| using std::get; 1264| 90.2k| auto newn = mutate ? (node->ensure_mutable_relaxed(e), node) ------------------ | Branch (1264:29): [True: 76.9k, False: 13.2k] ------------------ 1265| 90.2k| : node_t::make_inner_r_e(e); 1266| 90.2k| auto newr = newn->relaxed(); 1267| 90.2k| auto newcount = count - idx; 1268| 90.2k| auto new_child_size = child_size - child_dropped_size; 1269| 90.2k| IMMER_TRY { ------------------ | | 41| 90.2k|#define IMMER_TRY try ------------------ 1270| 90.2k| auto subs = 1271| 90.2k| mutate ? pos.towards_sub_oh(no_collapse_t{}, first, idx, e) ------------------ | Branch (1271:21): [True: 76.9k, False: 13.2k] ------------------ 1272| 90.2k| : pos.towards_sub_oh( 1273| 13.2k| no_collapse_no_mut_t{}, first, idx, e); 1274| 90.2k| if (mutate) ------------------ | Branch (1274:21): [True: 76.9k, False: 13.2k] ------------------ 1275| 76.9k| pos.each_left(dec_visitor{}, idx); 1276| 90.2k| pos.copy_sizes( 1277| 90.2k| idx + 1, newcount - 1, new_child_size, newr->d.sizes + 1); 1278| 90.2k| std::copy(node->inner() + idx + 1, 1279| 90.2k| node->inner() + count, 1280| 90.2k| newn->inner() + 1); 1281| 90.2k| newn->inner()[0] = get<1>(subs); 1282| 90.2k| newr->d.sizes[0] = new_child_size; 1283| 90.2k| newr->d.count = newcount; 1284| 90.2k| assert(new_child_size); 1285| 90.2k| if (!mutate) { ------------------ | Branch (1285:21): [True: 13.2k, False: 76.9k] ------------------ 1286| 13.2k| node_t::inc_nodes(newn->inner() + 1, newcount - 1); 1287| 13.2k| if (Mutating) ------------------ | Branch (1287:25): [Folded - Ignored] ------------------ 1288| 13.2k| pos.visit(dec_visitor{}); 1289| 13.2k| } 1290| 90.2k| return std::make_tuple(pos.shift(), newn); 1291| 90.2k| } 1292| 90.2k| IMMER_CATCH (...) { 1293| 0| if (!mutate) ------------------ | Branch (1293:21): [True: 0, False: 0] ------------------ 1294| 0| node_t::delete_inner_r_e(newn); 1295| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1296| 0| } 1297| 90.2k| } 1298| 90.2k| } _ZN5immer6detail4rbts22slice_left_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0ELb0EE13visit_relaxedIRNS1_11relaxed_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_mNSA_5applyIS7_E4type4editE: 1245| 95.8k| { 1246| 95.8k| auto idx = pos.subindex(first); 1247| 95.8k| auto count = pos.count(); 1248| 95.8k| auto node = pos.node(); 1249| 95.8k| auto mutate = Mutating && node->can_mutate(e); ------------------ | Branch (1249:35): [Folded - Ignored] | Branch (1249:47): [True: 0, False: 0] ------------------ 1250| 95.8k| auto left_size = pos.size_before(idx); 1251| 95.8k| auto child_size = pos.size_sbh(idx, left_size); 1252| 95.8k| auto dropped_size = first; 1253| 95.8k| auto child_dropped_size = dropped_size - left_size; 1254| 95.8k| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1254:13): [Folded - Ignored] | Branch (1254:25): [True: 0, False: 0] | Branch (1254:45): [True: 0, False: 0] ------------------ 1255| 0| auto r = mutate ? pos.towards_sub_oh(this_t{}, first, idx, e) ------------------ | Branch (1255:22): [True: 0, False: 0] ------------------ 1256| 0| : pos.towards_sub_oh(no_mut_t{}, first, idx, e); 1257| 0| if (mutate) ------------------ | Branch (1257:17): [True: 0, False: 0] ------------------ 1258| 0| pos.visit(dec_left_visitor{}, idx); 1259| 0| else if (Mutating) ------------------ | Branch (1259:22): [Folded - Ignored] ------------------ 1260| 0| pos.visit(dec_visitor{}); 1261| 0| return r; 1262| 95.8k| } else { 1263| 95.8k| using std::get; 1264| 95.8k| auto newn = mutate ? (node->ensure_mutable_relaxed(e), node) ------------------ | Branch (1264:29): [True: 0, False: 95.8k] ------------------ 1265| 95.8k| : node_t::make_inner_r_e(e); 1266| 95.8k| auto newr = newn->relaxed(); 1267| 95.8k| auto newcount = count - idx; 1268| 95.8k| auto new_child_size = child_size - child_dropped_size; 1269| 95.8k| IMMER_TRY { ------------------ | | 41| 95.8k|#define IMMER_TRY try ------------------ 1270| 95.8k| auto subs = 1271| 95.8k| mutate ? pos.towards_sub_oh(no_collapse_t{}, first, idx, e) ------------------ | Branch (1271:21): [True: 0, False: 95.8k] ------------------ 1272| 95.8k| : pos.towards_sub_oh( 1273| 95.8k| no_collapse_no_mut_t{}, first, idx, e); 1274| 95.8k| if (mutate) ------------------ | Branch (1274:21): [True: 0, False: 95.8k] ------------------ 1275| 0| pos.each_left(dec_visitor{}, idx); 1276| 95.8k| pos.copy_sizes( 1277| 95.8k| idx + 1, newcount - 1, new_child_size, newr->d.sizes + 1); 1278| 95.8k| std::copy(node->inner() + idx + 1, 1279| 95.8k| node->inner() + count, 1280| 95.8k| newn->inner() + 1); 1281| 95.8k| newn->inner()[0] = get<1>(subs); 1282| 95.8k| newr->d.sizes[0] = new_child_size; 1283| 95.8k| newr->d.count = newcount; 1284| 95.8k| assert(new_child_size); 1285| 95.8k| if (!mutate) { ------------------ | Branch (1285:21): [True: 95.8k, False: 0] ------------------ 1286| 95.8k| node_t::inc_nodes(newn->inner() + 1, newcount - 1); 1287| 95.8k| if (Mutating) ------------------ | Branch (1287:25): [Folded - Ignored] ------------------ 1288| 0| pos.visit(dec_visitor{}); 1289| 95.8k| } 1290| 95.8k| return std::make_tuple(pos.shift(), newn); 1291| 95.8k| } 1292| 95.8k| IMMER_CATCH (...) { 1293| 0| if (!mutate) ------------------ | Branch (1293:21): [True: 0, False: 0] ------------------ 1294| 0| node_t::delete_inner_r_e(newn); 1295| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1296| 0| } 1297| 95.8k| } 1298| 95.8k| } _ZN5immer6detail4rbts22slice_left_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb1EE13visit_regularIRNS1_15regular_sub_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_mNSA_5applyIS7_E4type4editE: 1302| 186| { 1303| 186| auto idx = pos.subindex(first); 1304| 186| auto count = pos.count(); 1305| 186| auto node = pos.node(); 1306| 186| auto mutate = Mutating ------------------ | Branch (1306:23): [Folded - Ignored] ------------------ 1307| | // this is more restrictive than actually needed because 1308| | // it causes the algorithm to also avoid mutating the leaf 1309| | // in place 1310| 186| && !node_t::embed_relaxed && node->can_mutate(e); ------------------ | Branch (1310:26): [Folded - Ignored] | Branch (1310:52): [True: 114, False: 72] ------------------ 1311| 186| auto left_size = pos.size_before(idx); 1312| 186| auto child_size = pos.size_sbh(idx, left_size); 1313| 186| auto dropped_size = first; 1314| 186| auto child_dropped_size = dropped_size - left_size; 1315| 186| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1315:13): [Folded - Ignored] | Branch (1315:25): [True: 99, False: 87] | Branch (1315:45): [True: 49, False: 50] ------------------ 1316| 49| auto r = mutate ? pos.towards_sub_oh(this_t{}, first, idx, e) ------------------ | Branch (1316:22): [True: 47, False: 2] ------------------ 1317| 49| : pos.towards_sub_oh(no_mut_t{}, first, idx, e); 1318| 49| if (mutate) ------------------ | Branch (1318:17): [True: 47, False: 2] ------------------ 1319| 47| pos.visit(dec_left_visitor{}, idx); 1320| 2| else if (Mutating) ------------------ | Branch (1320:22): [Folded - Ignored] ------------------ 1321| 2| pos.visit(dec_visitor{}); 1322| 49| return r; 1323| 137| } else { 1324| 137| using std::get; 1325| | // if possible, we convert the node to a relaxed one simply by 1326| | // allocating a `relaxed_t` size table for it... maybe some of this 1327| | // magic should be moved as a `node<...>` static method... 1328| 137| auto newcount = count - idx; 1329| 137| auto newn = 1330| 137| mutate ? (node->impl.d.data.inner.relaxed = new ( ------------------ | Branch (1330:17): [True: 67, False: 70] ------------------ 1331| 67| node_t::heap::allocate(node_t::max_sizeof_relaxed, 1332| 67| norefs_tag{})) relaxed_t, 1333| 67| node) 1334| 137| : node_t::make_inner_r_e(e); 1335| 137| auto newr = newn->relaxed(); 1336| 137| IMMER_TRY { ------------------ | | 41| 137|#define IMMER_TRY try ------------------ 1337| 137| auto subs = 1338| 137| mutate ? pos.towards_sub_oh(no_collapse_t{}, first, idx, e) ------------------ | Branch (1338:21): [True: 67, False: 70] ------------------ 1339| 137| : pos.towards_sub_oh( 1340| 70| no_collapse_no_mut_t{}, first, idx, e); 1341| 137| if (mutate) ------------------ | Branch (1341:21): [True: 67, False: 70] ------------------ 1342| 67| pos.each_left(dec_visitor{}, idx); 1343| 137| newr->d.sizes[0] = child_size - child_dropped_size; 1344| 137| assert(newr->d.sizes[0]); 1345| 0| pos.copy_sizes( 1346| 137| idx + 1, newcount - 1, newr->d.sizes[0], newr->d.sizes + 1); 1347| 137| newr->d.count = newcount; 1348| 137| newn->inner()[0] = get<1>(subs); 1349| 137| std::copy(node->inner() + idx + 1, 1350| 137| node->inner() + count, 1351| 137| newn->inner() + 1); 1352| 137| if (!mutate) { ------------------ | Branch (1352:21): [True: 70, False: 67] ------------------ 1353| 70| node_t::inc_nodes(newn->inner() + 1, newcount - 1); 1354| 70| if (Mutating) ------------------ | Branch (1354:25): [Folded - Ignored] ------------------ 1355| 70| pos.visit(dec_visitor{}); 1356| 70| } 1357| 137| return std::make_tuple(pos.shift(), newn); 1358| 137| } 1359| 137| IMMER_CATCH (...) { 1360| 0| if (!mutate) ------------------ | Branch (1360:21): [True: 0, False: 0] ------------------ 1361| 0| node_t::delete_inner_r_e(newn); 1362| 0| else { 1363| | // restore the regular node that we were 1364| | // attempting to relax... 1365| 0| node_t::heap::deallocate(node_t::max_sizeof_relaxed, 1366| 0| node->impl.d.data.inner.relaxed); 1367| 0| node->impl.d.data.inner.relaxed = nullptr; 1368| 0| } 1369| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1370| 0| } 1371| 137| } 1372| 186| } _ZN5immer6detail4rbts22slice_left_mut_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1ELb1EE13visit_regularIRNS1_8full_posISC_EEEENSt3__15tupleIJjPSC_EEEOT_mNSA_5applyIS7_E4type4editE: 1302| 8| { 1303| 8| auto idx = pos.subindex(first); 1304| 8| auto count = pos.count(); 1305| 8| auto node = pos.node(); 1306| 8| auto mutate = Mutating ------------------ | Branch (1306:23): [Folded - Ignored] ------------------ 1307| | // this is more restrictive than actually needed because 1308| | // it causes the algorithm to also avoid mutating the leaf 1309| | // in place 1310| 8| && !node_t::embed_relaxed && node->can_mutate(e); ------------------ | Branch (1310:26): [Folded - Ignored] | Branch (1310:52): [True: 0, False: 8] ------------------ 1311| 8| auto left_size = pos.size_before(idx); 1312| 8| auto child_size = pos.size_sbh(idx, left_size); 1313| 8| auto dropped_size = first; 1314| 8| auto child_dropped_size = dropped_size - left_size; 1315| 8| if (Collapse && pos.shift() > BL && idx == pos.count() - 1) { ------------------ | Branch (1315:13): [Folded - Ignored] | Branch (1315:25): [True: 8, False: 0] | Branch (1315:45): [True: 0, False: 8] ------------------ 1316| 0| auto r = mutate ? pos.towards_sub_oh(this_t{}, first, idx, e) ------------------ | Branch (1316:22): [True: 0, False: 0] ------------------ 1317| 0| : pos.towards_sub_oh(no_mut_t{}, first, idx, e); 1318| 0| if (mutate) ------------------ | Branch (1318:17): [True: 0, False: 0] ------------------ 1319| 0| pos.visit(dec_left_visitor{}, idx); 1320| 0| else if (Mutating) ------------------ | Branch (1320:22): [Folded - Ignored] ------------------ 1321| 0| pos.visit(dec_visitor{}); 1322| 0| return r; 1323| 8| } else { 1324| 8| using std::get; 1325| | // if possible, we convert the node to a relaxed one simply by 1326| | // allocating a `relaxed_t` size table for it... maybe some of this 1327| | // magic should be moved as a `node<...>` static method... 1328| 8| auto newcount = count - idx; 1329| 8| auto newn = 1330| 8| mutate ? (node->impl.d.data.inner.relaxed = new ( ------------------ | Branch (1330:17): [True: 0, False: 8] ------------------ 1331| 0| node_t::heap::allocate(node_t::max_sizeof_relaxed, 1332| 0| norefs_tag{})) relaxed_t, 1333| 0| node) 1334| 8| : node_t::make_inner_r_e(e); 1335| 8| auto newr = newn->relaxed(); 1336| 8| IMMER_TRY { ------------------ | | 41| 8|#define IMMER_TRY try ------------------ 1337| 8| auto subs = 1338| 8| mutate ? pos.towards_sub_oh(no_collapse_t{}, first, idx, e) ------------------ | Branch (1338:21): [True: 0, False: 8] ------------------ 1339| 8| : pos.towards_sub_oh( 1340| 8| no_collapse_no_mut_t{}, first, idx, e); 1341| 8| if (mutate) ------------------ | Branch (1341:21): [True: 0, False: 8] ------------------ 1342| 0| pos.each_left(dec_visitor{}, idx); 1343| 8| newr->d.sizes[0] = child_size - child_dropped_size; 1344| 8| assert(newr->d.sizes[0]); 1345| 0| pos.copy_sizes( 1346| 8| idx + 1, newcount - 1, newr->d.sizes[0], newr->d.sizes + 1); 1347| 8| newr->d.count = newcount; 1348| 8| newn->inner()[0] = get<1>(subs); 1349| 8| std::copy(node->inner() + idx + 1, 1350| 8| node->inner() + count, 1351| 8| newn->inner() + 1); 1352| 8| if (!mutate) { ------------------ | Branch (1352:21): [True: 8, False: 0] ------------------ 1353| 8| node_t::inc_nodes(newn->inner() + 1, newcount - 1); 1354| 8| if (Mutating) ------------------ | Branch (1354:25): [Folded - Ignored] ------------------ 1355| 8| pos.visit(dec_visitor{}); 1356| 8| } 1357| 8| return std::make_tuple(pos.shift(), newn); 1358| 8| } 1359| 8| IMMER_CATCH (...) { 1360| 0| if (!mutate) ------------------ | Branch (1360:21): [True: 0, False: 0] ------------------ 1361| 0| node_t::delete_inner_r_e(newn); 1362| 0| else { 1363| | // restore the regular node that we were 1364| | // attempting to relax... 1365| 0| node_t::heap::deallocate(node_t::max_sizeof_relaxed, 1366| 0| node->impl.d.data.inner.relaxed); 1367| 0| node->impl.d.data.inner.relaxed = nullptr; 1368| 0| } 1369| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1370| 0| } 1371| 8| } 1372| 8| } _ZN5immer6detail4rbts14equals_visitor3rrb10visit_nodeIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_16rrbtree_iteratorIiSE_Lj3ELj3EEESF_EEbOT_OT0_PT1_jm: 348| 439| { 349| 439| assert(shiftl <= posr.shift()); 350| 439| return shiftl == posr.shift() ------------------ | Branch (350:20): [True: 437, False: 2] ------------------ 351| 439| ? visit_maybe_relaxed_sub(rootl, 352| 437| shiftl, 353| 437| sizel, 354| 437| this_t{}, 355| 437| posr, 356| 437| first, 357| 437| size_t{}) 358| 439| : posr.first_sub_inner( 359| 2| rrb{}, first, rootl, shiftl, sizel); 360| 439| } _ZN5immer6detail4rbts14equals_visitor13visit_relaxedIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEESG_RNS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEEbOT_OT0_OT1_m: 381| 1.51k| { 382| 1.51k| auto nl = posl.node(); 383| 1.51k| auto nr = posr.node(); 384| 1.51k| if (nl == nr) ------------------ | Branch (384:13): [True: 459, False: 1.05k] ------------------ 385| 459| return true; 386| 1.05k| auto cl = posl.count(); 387| 1.05k| auto cr = posr.count(); 388| 1.05k| assert(cr > 0); 389| 0| auto sbr = size_t{}; 390| 1.05k| auto i = count_t{}; 391| 1.05k| auto j = count_t{}; 392| 3.87k| for (; i < cl; ++i) { ------------------ | Branch (392:16): [True: 3.39k, False: 476] ------------------ 393| 3.39k| auto sbl = posl.size_before(i); 394| 5.70k| for (; j + 1 < cr && (sbr = posr.size_before(j)) < sbl; ++j) ------------------ | Branch (394:20): [True: 5.02k, False: 687] | Branch (394:34): [True: 2.31k, False: 2.71k] ------------------ 395| 2.31k| ; 396| 3.39k| auto res = 397| 3.39k| sbl == sbr ------------------ | Branch (397:17): [True: 1.84k, False: 1.55k] ------------------ 398| 3.39k| ? posr.nth_sub(j, this_aux_t{}, i, posl, first, idx + sbl) 399| 3.39k| : posl.nth_sub(i, 400| 1.55k| for_each_chunk_p_visitor{}, 401| 1.55k| this_t::equal_chunk_p(first + (idx + sbl))); 402| 3.39k| if (!res) ------------------ | Branch (402:17): [True: 582, False: 2.81k] ------------------ 403| 582| return false; 404| 3.39k| } 405| 476| return true; 406| 1.05k| } _ZN5immer6detail4rbts14equals_visitor10this_aux_t10visit_leafIRNS1_12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_11relaxed_posISF_EERNS1_16rrbtree_iteratorIiSE_Lj3ELj3EEEEEbOT_jOT0_OT1_m: 335| 667| { 336| 667| return posl.nth_sub_leaf(i, this_t{}, posr, first, idx); 337| 667| } _ZN5immer6detail4rbts14equals_visitor10visit_leafIRNS1_12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEESG_RNS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEEbOT_OT0_OT1_m: 426| 676| { 427| 676| if (posl.node() == posr.node()) ------------------ | Branch (427:13): [True: 399, False: 277] ------------------ 428| 399| return true; 429| 277| auto cl = posl.count(); 430| 277| auto cr = posr.count(); 431| 277| auto mp = std::min(cl, cr); 432| 277| return std::equal(posl.node()->leaf(), ------------------ | Branch (432:16): [True: 208, False: 69] ------------------ 433| 277| posl.node()->leaf() + mp, 434| 277| posr.node()->leaf()) && 435| 277| std::equal(posl.node()->leaf() + mp, ------------------ | Branch (435:16): [True: 208, False: 0] ------------------ 436| 208| posl.node()->leaf() + posl.count(), 437| 208| first + (idx + mp)); 438| 676| } _ZN5immer6detail4rbts14equals_visitor10this_aux_t11visit_innerIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEESH_RNS1_16rrbtree_iteratorIiSE_Lj3ELj3EEEEEbOT_jOT0_OT1_m: 328| 1.14k| { 329| 1.14k| return posl.nth_sub(i, this_t{}, posr, first, idx); 330| 1.14k| } _ZN5immer6detail4rbts14equals_visitor13visit_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_11relaxed_posISE_EERNS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEENSt3__19enable_ifIX12is_relaxed_vIT0_EEbE4typeEOT_OSP_OT1_m: 411| 68| { 412| 68| return this_t::visit_relaxed(posl, posr, first, idx); 413| 68| } _ZN5immer6detail4rbts14equals_visitor13visit_relaxedIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_11relaxed_posISE_EERNS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEEbOT_OT0_OT1_m: 381| 68| { 382| 68| auto nl = posl.node(); 383| 68| auto nr = posr.node(); 384| 68| if (nl == nr) ------------------ | Branch (384:13): [True: 0, False: 68] ------------------ 385| 0| return true; 386| 68| auto cl = posl.count(); 387| 68| auto cr = posr.count(); 388| 68| assert(cr > 0); 389| 0| auto sbr = size_t{}; 390| 68| auto i = count_t{}; 391| 68| auto j = count_t{}; 392| 323| for (; i < cl; ++i) { ------------------ | Branch (392:16): [True: 303, False: 20] ------------------ 393| 303| auto sbl = posl.size_before(i); 394| 548| for (; j + 1 < cr && (sbr = posr.size_before(j)) < sbl; ++j) ------------------ | Branch (394:20): [True: 490, False: 58] | Branch (394:34): [True: 245, False: 245] ------------------ 395| 245| ; 396| 303| auto res = 397| 303| sbl == sbr ------------------ | Branch (397:17): [True: 130, False: 173] ------------------ 398| 303| ? posr.nth_sub(j, this_aux_t{}, i, posl, first, idx + sbl) 399| 303| : posl.nth_sub(i, 400| 173| for_each_chunk_p_visitor{}, 401| 173| this_t::equal_chunk_p(first + (idx + sbl))); 402| 303| if (!res) ------------------ | Branch (402:17): [True: 48, False: 255] ------------------ 403| 48| return false; 404| 303| } 405| 20| return true; 406| 68| } _ZN5immer6detail4rbts14equals_visitor10this_aux_t10visit_leafIRNS1_12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_15regular_sub_posISF_EERNS1_16rrbtree_iteratorIiSE_Lj3ELj3EEEEEbOT_jOT0_OT1_m: 335| 110| { 336| 110| return posl.nth_sub_leaf(i, this_t{}, posr, first, idx); 337| 110| } _ZN5immer6detail4rbts14equals_visitor10visit_leafIRNS1_13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_12leaf_sub_posISE_EERNS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEEbOT_OT0_OT1_m: 426| 193| { 427| 193| if (posl.node() == posr.node()) ------------------ | Branch (427:13): [True: 137, False: 56] ------------------ 428| 137| return true; 429| 56| auto cl = posl.count(); 430| 56| auto cr = posr.count(); 431| 56| auto mp = std::min(cl, cr); 432| 56| return std::equal(posl.node()->leaf(), ------------------ | Branch (432:16): [True: 35, False: 21] ------------------ 433| 56| posl.node()->leaf() + mp, 434| 56| posr.node()->leaf()) && 435| 56| std::equal(posl.node()->leaf() + mp, ------------------ | Branch (435:16): [True: 31, False: 4] ------------------ 436| 35| posl.node()->leaf() + posl.count(), 437| 35| first + (idx + mp)); 438| 193| } _ZN5immer6detail4rbts14equals_visitor10this_aux_t11visit_innerIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_15regular_sub_posISF_EERNS1_16rrbtree_iteratorIiSE_Lj3ELj3EEEEEbOT_jOT0_OT1_m: 328| 20| { 329| 20| return posl.nth_sub(i, this_t{}, posr, first, idx); 330| 20| } _ZN5immer6detail4rbts14equals_visitor13visit_regularIRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_11relaxed_posISE_EERNS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEENSt3__19enable_ifIX12is_relaxed_vIT0_EEbE4typeEOT_OSP_OT1_m: 411| 60| { 412| 60| return this_t::visit_relaxed(posl, posr, first, idx); 413| 60| } _ZN5immer6detail4rbts14equals_visitor13visit_relaxedIRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_11relaxed_posISE_EERNS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEEbOT_OT0_OT1_m: 381| 60| { 382| 60| auto nl = posl.node(); 383| 60| auto nr = posr.node(); 384| 60| if (nl == nr) ------------------ | Branch (384:13): [True: 0, False: 60] ------------------ 385| 0| return true; 386| 60| auto cl = posl.count(); 387| 60| auto cr = posr.count(); 388| 60| assert(cr > 0); 389| 0| auto sbr = size_t{}; 390| 60| auto i = count_t{}; 391| 60| auto j = count_t{}; 392| 516| for (; i < cl; ++i) { ------------------ | Branch (392:16): [True: 459, False: 57] ------------------ 393| 459| auto sbl = posl.size_before(i); 394| 858| for (; j + 1 < cr && (sbr = posr.size_before(j)) < sbl; ++j) ------------------ | Branch (394:20): [True: 735, False: 123] | Branch (394:34): [True: 399, False: 336] ------------------ 395| 399| ; 396| 459| auto res = 397| 459| sbl == sbr ------------------ | Branch (397:17): [True: 148, False: 311] ------------------ 398| 459| ? posr.nth_sub(j, this_aux_t{}, i, posl, first, idx + sbl) 399| 459| : posl.nth_sub(i, 400| 311| for_each_chunk_p_visitor{}, 401| 311| this_t::equal_chunk_p(first + (idx + sbl))); 402| 459| if (!res) ------------------ | Branch (402:17): [True: 3, False: 456] ------------------ 403| 3| return false; 404| 459| } 405| 57| return true; 406| 60| } _ZN5immer6detail4rbts14equals_visitor10this_aux_t10visit_leafIRNS1_12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_8full_posISF_EERNS1_16rrbtree_iteratorIiSE_Lj3ELj3EEEEEbOT_jOT0_OT1_m: 335| 92| { 336| 92| return posl.nth_sub_leaf(i, this_t{}, posr, first, idx); 337| 92| } _ZN5immer6detail4rbts14equals_visitor10this_aux_t11visit_innerIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_8full_posISF_EERNS1_16rrbtree_iteratorIiSE_Lj3ELj3EEEEEbOT_jOT0_OT1_m: 328| 40| { 329| 40| return posl.nth_sub(i, this_t{}, posr, first, idx); 330| 40| } _ZN5immer6detail4rbts14equals_visitor10this_aux_t11visit_innerIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_8full_posISF_EERNS1_16rrbtree_iteratorIiSE_Lj3ELj3EEEEEbOT_jOT0_OT1_m: 328| 16| { 329| 16| return posl.nth_sub(i, this_t{}, posr, first, idx); 330| 16| } _ZN5immer6detail4rbts14equals_visitor13visit_regularIRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_15regular_sub_posISE_EERNS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEENSt3__19enable_ifIXnt12is_relaxed_vIT0_EEbE4typeEOT_OSP_OT1_m: 418| 16| { 419| 16| return posl.count() >= posr.count() ------------------ | Branch (419:16): [True: 16, False: 0] ------------------ 420| 16| ? this_t::visit_regular(posl, posr.node()) 421| 16| : this_t::visit_regular(posr, posl.node()); 422| 16| } _ZN5immer6detail4rbts14equals_visitor13visit_regularIRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEESE_EEbOT_PT0_: 442| 122| { 443| 122| auto node = pos.node(); 444| 122| return node == other || pos.each_pred_zip(this_t{}, other); ------------------ | Branch (444:16): [True: 103, False: 19] | Branch (444:33): [True: 17, False: 2] ------------------ 445| 122| } _ZN5immer6detail4rbts14equals_visitor10visit_leafIRNS1_13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEESE_EEbOT_PT0_: 449| 540| { 450| 540| auto node = pos.node(); 451| 540| return node == other || std::equal(node->leaf(), ------------------ | Branch (451:16): [True: 378, False: 162] | Branch (451:33): [True: 120, False: 42] ------------------ 452| 162| node->leaf() + pos.count(), 453| 162| other->leaf()); 454| 540| } _ZN5immer6detail4rbts14equals_visitor13visit_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEESE_EEbOT_PT0_: 442| 262| { 443| 262| auto node = pos.node(); 444| 262| return node == other || pos.each_pred_zip(this_t{}, other); ------------------ | Branch (444:16): [True: 64, False: 198] | Branch (444:33): [True: 96, False: 102] ------------------ 445| 262| } _ZN5immer6detail4rbts14equals_visitor10visit_leafIRNS1_8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEESE_EEbOT_PT0_: 449| 156| { 450| 156| auto node = pos.node(); 451| 156| return node == other || std::equal(node->leaf(), ------------------ | Branch (451:16): [True: 16, False: 140] | Branch (451:33): [True: 80, False: 60] ------------------ 452| 140| node->leaf() + pos.count(), 453| 140| other->leaf()); 454| 156| } _ZN5immer6detail4rbts14equals_visitor13visit_regularIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEESE_EEbOT_PT0_: 442| 64| { 443| 64| auto node = pos.node(); 444| 64| return node == other || pos.each_pred_zip(this_t{}, other); ------------------ | Branch (444:16): [True: 0, False: 64] | Branch (444:33): [True: 17, False: 47] ------------------ 445| 64| } _ZN5immer6detail4rbts24for_each_chunk_p_visitor10visit_leafIRNS1_13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEEDaOT_EUlSL_T0_E_EEbSM_OSN_: 111| 257k| { 112| 257k| auto data = as_const(pos.node()->leaf()); 113| 257k| return fn(data, data + pos.count()); 114| 257k| } _ZZN5immer6detail4rbts14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEDaOT_ENUlSE_T0_E_clIPKiSK_EEDaSE_SG_: 366| 395k| return [iter](auto f, auto e) mutable { 367| 395k| if (f == &*iter) { ------------------ | Branch (367:17): [True: 497, False: 395k] ------------------ 368| 497| iter += e - f; 369| 497| return true; 370| 497| } 371| 3.41M| for (; f != e; ++f, ++iter) ------------------ | Branch (371:20): [True: 3.02M, False: 395k] ------------------ 372| 3.02M| if (*f != *iter) ------------------ | Branch (372:21): [True: 160, False: 3.02M] ------------------ 373| 160| return false; 374| 395k| return true; 375| 395k| }; _ZN5immer6detail4rbts18region_for_visitorIiE11visit_innerIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEENSt3__15tupleIJPimmEEEOT_m: 52| 1.06M| { 53| 1.06M| return pos.towards(this_t{}, idx); 54| 1.06M| } _ZN5immer6detail4rbts18region_for_visitorIiE10visit_leafIRNS1_12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEENSt3__15tupleIJPimmEEEOT_m: 58| 139k| { 59| 139k| return std::make_tuple(pos.node()->leaf(), pos.index(idx), pos.count()); 60| 139k| } _ZN5immer6detail4rbts18region_for_visitorIiE11visit_innerIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEENSt3__15tupleIJPimmEEEOT_m: 52| 258k| { 53| 258k| return pos.towards(this_t{}, idx); 54| 258k| } _ZN5immer6detail4rbts18region_for_visitorIiE10visit_leafIRNS1_13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEENSt3__15tupleIJPimmEEEOT_m: 58| 257k| { 59| 257k| return std::make_tuple(pos.node()->leaf(), pos.index(idx), pos.count()); 60| 257k| } _ZN5immer6detail4rbts18region_for_visitorIiE11visit_innerIRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEENSt3__15tupleIJPimmEEEOT_m: 52| 615k| { 53| 615k| return pos.towards(this_t{}, idx); 54| 615k| } _ZN5immer6detail4rbts18region_for_visitorIiE10visit_leafIRNS1_8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEENSt3__15tupleIJPimmEEEOT_m: 58| 1.46k| { 59| 1.46k| return std::make_tuple(pos.node()->leaf(), pos.index(idx), pos.count()); 60| 1.46k| } _ZN5immer6detail4rbts18region_for_visitorIiE11visit_innerIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEENSt3__15tupleIJPimmEEEOT_m: 52| 25.6k| { 53| 25.6k| return pos.towards(this_t{}, idx); 54| 25.6k| } _ZN5immer6detail4rbts24for_each_chunk_p_visitor11visit_innerIRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEEDaOT_EUlSL_T0_E_EEbSM_OSN_: 105| 36.1k| { 106| 36.1k| return pos.each_pred(this_t{}, fn); 107| 36.1k| } _ZN5immer6detail4rbts14equals_visitor13visit_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEESG_RNS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEENSt3__19enable_ifIXnt12is_relaxed_vIT0_EEbE4typeEOT_OSM_OT1_m: 418| 259| { 419| 259| return posl.count() >= posr.count() ------------------ | Branch (419:16): [True: 259, False: 0] ------------------ 420| 259| ? this_t::visit_regular(posl, posr.node()) 421| 259| : this_t::visit_regular(posr, posl.node()); 422| 259| } _ZN5immer6detail4rbts24for_each_chunk_p_visitor10visit_leafIRNS1_12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEEDaOT_EUlSL_T0_E_EEbSM_OSN_: 111| 137k| { 112| 137k| auto data = as_const(pos.node()->leaf()); 113| 137k| return fn(data, data + pos.count()); 114| 137k| } _ZN5immer6detail4rbts24for_each_chunk_p_visitor11visit_innerIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEEDaOT_EUlSL_T0_E_EEbSM_OSN_: 105| 557| { 106| 557| return pos.each_pred(this_t{}, fn); 107| 557| } _ZN5immer6detail4rbts24for_each_chunk_p_visitor10visit_leafIRNS1_8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEEDaOT_EUlSL_T0_E_EEbSM_OSN_: 111| 478| { 112| 478| auto data = as_const(pos.node()->leaf()); 113| 478| return fn(data, data + pos.count()); 114| 478| } _ZN5immer6detail4rbts24for_each_chunk_p_visitor11visit_innerIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEEDaOT_EUlSL_T0_E_EEbSM_OSN_: 105| 291| { 106| 291| return pos.each_pred(this_t{}, fn); 107| 291| } _ZN5immer6detail4rbts14equals_visitor10this_aux_t11visit_innerIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_11relaxed_posISF_EERNS1_16rrbtree_iteratorIiSE_Lj3ELj3EEEEEbOT_jOT0_OT1_m: 328| 33| { 329| 33| return posl.nth_sub(i, this_t{}, posr, first, idx); 330| 33| } _ZN5immer6detail4rbts14equals_visitor13visit_relaxedIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_15regular_sub_posISE_EERNS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEEbOT_OT0_OT1_m: 381| 30| { 382| 30| auto nl = posl.node(); 383| 30| auto nr = posr.node(); 384| 30| if (nl == nr) ------------------ | Branch (384:13): [True: 0, False: 30] ------------------ 385| 0| return true; 386| 30| auto cl = posl.count(); 387| 30| auto cr = posr.count(); 388| 30| assert(cr > 0); 389| 0| auto sbr = size_t{}; 390| 30| auto i = count_t{}; 391| 30| auto j = count_t{}; 392| 108| for (; i < cl; ++i) { ------------------ | Branch (392:16): [True: 98, False: 10] ------------------ 393| 98| auto sbl = posl.size_before(i); 394| 165| for (; j + 1 < cr && (sbr = posr.size_before(j)) < sbl; ++j) ------------------ | Branch (394:20): [True: 149, False: 16] | Branch (394:34): [True: 67, False: 82] ------------------ 395| 67| ; 396| 98| auto res = 397| 98| sbl == sbr ------------------ | Branch (397:17): [True: 48, False: 50] ------------------ 398| 98| ? posr.nth_sub(j, this_aux_t{}, i, posl, first, idx + sbl) 399| 98| : posl.nth_sub(i, 400| 50| for_each_chunk_p_visitor{}, 401| 50| this_t::equal_chunk_p(first + (idx + sbl))); 402| 98| if (!res) ------------------ | Branch (402:17): [True: 20, False: 78] ------------------ 403| 20| return false; 404| 98| } 405| 10| return true; 406| 30| } _ZN5immer6detail4rbts14equals_visitor10this_aux_t10visit_leafIRNS1_13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_11relaxed_posISF_EERNS1_16rrbtree_iteratorIiSE_Lj3ELj3EEEEEbOT_jOT0_OT1_m: 335| 70| { 336| 70| return posl.nth_sub_leaf(i, this_t{}, posr, first, idx); 337| 70| } _ZN5immer6detail4rbts14equals_visitor10visit_leafIRNS1_12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_13full_leaf_posISE_EERNS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEEbOT_OT0_OT1_m: 426| 70| { 427| 70| if (posl.node() == posr.node()) ------------------ | Branch (427:13): [True: 49, False: 21] ------------------ 428| 49| return true; 429| 21| auto cl = posl.count(); 430| 21| auto cr = posr.count(); 431| 21| auto mp = std::min(cl, cr); 432| 21| return std::equal(posl.node()->leaf(), ------------------ | Branch (432:16): [True: 7, False: 14] ------------------ 433| 21| posl.node()->leaf() + mp, 434| 21| posr.node()->leaf()) && 435| 21| std::equal(posl.node()->leaf() + mp, ------------------ | Branch (435:16): [True: 7, False: 0] ------------------ 436| 7| posl.node()->leaf() + posl.count(), 437| 7| first + (idx + mp)); 438| 70| } _ZN5immer6detail4rbts14equals_visitor10this_aux_t11visit_innerIRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_11relaxed_posISF_EERNS1_16rrbtree_iteratorIiSE_Lj3ELj3EEEEEbOT_jOT0_OT1_m: 328| 18| { 329| 18| return posl.nth_sub(i, this_t{}, posr, first, idx); 330| 18| } _ZN5immer6detail4rbts14equals_visitor13visit_relaxedIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_8full_posISE_EERNS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEEbOT_OT0_OT1_m: 381| 15| { 382| 15| auto nl = posl.node(); 383| 15| auto nr = posr.node(); 384| 15| if (nl == nr) ------------------ | Branch (384:13): [True: 0, False: 15] ------------------ 385| 0| return true; 386| 15| auto cl = posl.count(); 387| 15| auto cr = posr.count(); 388| 15| assert(cr > 0); 389| 0| auto sbr = size_t{}; 390| 15| auto i = count_t{}; 391| 15| auto j = count_t{}; 392| 135| for (; i < cl; ++i) { ------------------ | Branch (392:16): [True: 120, False: 15] ------------------ 393| 120| auto sbl = posl.size_before(i); 394| 222| for (; j + 1 < cr && (sbr = posr.size_before(j)) < sbl; ++j) ------------------ | Branch (394:20): [True: 210, False: 12] | Branch (394:34): [True: 102, False: 108] ------------------ 395| 102| ; 396| 120| auto res = 397| 120| sbl == sbr ------------------ | Branch (397:17): [True: 46, False: 74] ------------------ 398| 120| ? posr.nth_sub(j, this_aux_t{}, i, posl, first, idx + sbl) 399| 120| : posl.nth_sub(i, 400| 74| for_each_chunk_p_visitor{}, 401| 74| this_t::equal_chunk_p(first + (idx + sbl))); 402| 120| if (!res) ------------------ | Branch (402:17): [True: 0, False: 120] ------------------ 403| 0| return false; 404| 120| } 405| 15| return true; 406| 15| } _ZN5immer6detail4rbts14equals_visitor13visit_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_8full_posISE_EERNS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEENSt3__19enable_ifIXnt12is_relaxed_vIT0_EEbE4typeEOT_OSP_OT1_m: 418| 3| { 419| 3| return posl.count() >= posr.count() ------------------ | Branch (419:16): [True: 3, False: 0] ------------------ 420| 3| ? this_t::visit_regular(posl, posr.node()) 421| 3| : this_t::visit_regular(posr, posl.node()); 422| 3| } _ZN5immer6detail4rbts24for_each_chunk_p_visitor11visit_innerIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSD_Lj3ELj3EEEEEDaOT_EUlSL_T0_E_EEbSM_OSN_: 105| 21.8k| { 106| 21.8k| return pos.each_pred(this_t{}, fn); 107| 21.8k| } _ZN5immer6detail4rbts14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEDaOT_: 365| 2.16k| { 366| 2.16k| return [iter](auto f, auto e) mutable { 367| 2.16k| if (f == &*iter) { 368| 2.16k| iter += e - f; 369| 2.16k| return true; 370| 2.16k| } 371| 2.16k| for (; f != e; ++f, ++iter) 372| 2.16k| if (*f != *iter) 373| 2.16k| return false; 374| 2.16k| return true; 375| 2.16k| }; 376| 2.16k| } _ZN5immer6detail4rbts14equals_visitor3rrb10visit_nodeIRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_16rrbtree_iteratorIiSE_Lj3ELj3EEESF_EEbOT_OT0_PT1_jm: 348| 2| { 349| 2| assert(shiftl <= posr.shift()); 350| 2| return shiftl == posr.shift() ------------------ | Branch (350:20): [True: 2, False: 0] ------------------ 351| 2| ? visit_maybe_relaxed_sub(rootl, 352| 2| shiftl, 353| 2| sizel, 354| 2| this_t{}, 355| 2| posr, 356| 2| first, 357| 2| size_t{}) 358| 2| : posr.first_sub_inner( 359| 0| rrb{}, first, rootl, shiftl, sizel); 360| 2| } _ZN5immer6detail4rbts14equals_visitor3rrb10visit_nodeIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_16rrbtree_iteratorIiSE_Lj3ELj3EEESF_EEbOT_OT0_PT1_jm: 348| 256| { 349| 256| assert(shiftl <= posr.shift()); 350| 256| return shiftl == posr.shift() ------------------ | Branch (350:20): [True: 256, False: 0] ------------------ 351| 256| ? visit_maybe_relaxed_sub(rootl, 352| 256| shiftl, 353| 256| sizel, 354| 256| this_t{}, 355| 256| posr, 356| 256| first, 357| 256| size_t{}) 358| 256| : posr.first_sub_inner( 359| 0| rrb{}, first, rootl, shiftl, sizel); 360| 256| } _ZN5immer6detail4rbts14equals_visitor10visit_leafIRNS1_12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEESE_EEbOT_PT0_: 449| 424| { 450| 424| auto node = pos.node(); 451| 424| return node == other || std::equal(node->leaf(), ------------------ | Branch (451:16): [True: 252, False: 172] | Branch (451:33): [True: 137, False: 35] ------------------ 452| 172| node->leaf() + pos.count(), 453| 172| other->leaf()); 454| 424| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_11dec_visitorEJEEEDcPT_jmT0_DpOT1_: 1830| 94.1M|{ 1831| 94.1M| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 94.1M| if (relaxed) { ------------------ | Branch (1833:9): [True: 86.8M, False: 7.22M] ------------------ 1834| 86.8M| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 86.8M| .visit(v, std::forward(args)...); 1837| 86.8M| } else { 1838| 7.22M| return make_regular_sub_pos(node, shift, size) 1839| 7.22M| .visit(v, std::forward(args)...); 1840| 7.22M| } 1841| 94.1M|} _ZN5immer6detail4rbts16make_relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_11relaxed_posIT_EEPSE_jPNSE_9relaxed_tE: 1820| 227M|{ 1821| 227M| assert(node); 1822| 0| assert(relaxed); 1823| 0| assert(shift >= NodeT::bits_leaf); 1824| 0| return {node, shift, relaxed}; 1825| 227M|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_11dec_visitorEJEEEDcT_DpOT0_: 1805| 97.1M| { 1806| 97.1M| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 97.1M| } _ZNK5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4nodeEv: 1423| 157M| node_t* node() const { return node_; } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4eachINS1_11dec_visitorEJEEEvT_DpOT0_: 1468| 18.3M| { 1469| 18.3M| each_left(v, relaxed_->d.count, args...); 1470| 18.3M| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9each_leftINS1_11dec_visitorEJEEEvT_jDpOT0_: 1615| 18.4M| { 1616| 18.4M| auto p = node_->inner(); 1617| 18.4M| auto s = size_t{}; 1618| 18.4M| if (shift_ == BL) { ------------------ | Branch (1618:13): [True: 3.61M, False: 14.8M] ------------------ 1619| 29.2M| for (auto i = count_t{0}; i < n; ++i) { ------------------ | Branch (1619:39): [True: 25.6M, False: 3.61M] ------------------ 1620| 25.6M| IMMER_PREFETCH(p + i + 1); 1621| 25.6M| make_leaf_sub_pos(p[i], relaxed_->d.sizes[i] - s) 1622| 25.6M| .visit(v, args...); 1623| 25.6M| s = relaxed_->d.sizes[i]; 1624| 25.6M| assert(s); 1625| 25.6M| } 1626| 14.8M| } else { 1627| 14.8M| auto ss = shift_ - B; 1628| 107M| for (auto i = count_t{0}; i < n; ++i) { ------------------ | Branch (1628:39): [True: 92.8M, False: 14.8M] ------------------ 1629| 92.8M| visit_maybe_relaxed_sub( 1630| 92.8M| p[i], ss, relaxed_->d.sizes[i] - s, v, args...); 1631| 92.8M| s = relaxed_->d.sizes[i]; 1632| 92.8M| assert(s); 1633| 92.8M| } 1634| 14.8M| } 1635| 18.4M| } _ZNK5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5countEv: 1422| 137M| count_t count() const { return relaxed_->d.count; } _ZN5immer6detail4rbts20make_regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_15regular_sub_posIT_EEPSE_jm: 1036| 10.3M|{ 1037| 10.3M| assert(node); 1038| 0| assert(shift >= NodeT::bits_leaf); 1039| 0| assert(size > 0); 1040| 0| assert(size <= (branches << shift)); 1041| 0| return {node, shift, size}; 1042| 10.3M|} _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_11dec_visitorEJEEEDcT_DpOT0_: 1028| 7.22M| { 1029| 7.22M| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 7.22M| } _ZNK5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4nodeEv: 777| 11.2M| node_t* node() const { return node_; } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4eachINS1_11dec_visitorEJEEEvT_DpOT0_: 817| 375k| { 818| 375k| return each_regular(*this, v, args...); 819| 375k| } _ZN5immer6detail4rbts12each_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_11dec_visitorEJEEEvOT_T0_DpOT1_: 341| 375k|{ 342| 375k| constexpr auto B = bits; 343| 375k| constexpr auto BL = bits_leaf; 344| 375k| auto n = p.node()->inner(); 345| 375k| auto last = p.count() - 1; 346| 375k| auto e = n + last; 347| 375k| if (p.shift() == BL) { ------------------ | Branch (347:9): [True: 71.0k, False: 304k] ------------------ 348| 126k| for (; n != e; ++n) { ------------------ | Branch (348:16): [True: 55.8k, False: 71.0k] ------------------ 349| 55.8k| IMMER_PREFETCH(n + 1); 350| 55.8k| make_full_leaf_pos(*n).visit(v, args...); 351| 55.8k| } 352| 71.0k| make_leaf_pos(*n, p.size()).visit(v, args...); 353| 304k| } else { 354| 304k| auto ss = p.shift() - B; 355| 1.21M| for (; n != e; ++n) ------------------ | Branch (355:16): [True: 913k, False: 304k] ------------------ 356| 913k| make_full_pos(*n, ss).visit(v, args...); 357| 304k| make_regular_pos(*n, ss, p.size()).visit(v, args...); 358| 304k| } 359| 375k|} _ZNK5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5shiftEv: 779| 5.11M| shift_t shift() const { return shift_; } _ZN5immer6detail4rbts18make_full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_13full_leaf_posIT_EEPSE_: 212| 3.14M|{ 213| 3.14M| assert(node); 214| 0| return {node}; 215| 3.14M|} _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_11dec_visitorEJEEEDcT_DpOT0_: 205| 1.41M| { 206| 1.41M| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 1.41M| } _ZNK5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4nodeEv: 197| 2.56M| node_t* node() const { return node_; } _ZNK5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5countEv: 196| 2.23M| count_t count() const { return branches; } _ZN5immer6detail4rbts13make_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_8leaf_posIT_EEPSE_m: 118| 867k|{ 119| 867k| assert(node); 120| 0| assert(size > 0); 121| 0| return {node, size}; 122| 867k|} _ZNK5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4sizeEv: 778| 3.48M| size_t size() const { return size_; } _ZN5immer6detail4rbts8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_11dec_visitorEJEEEDcT_DpOT0_: 111| 338k| { 112| 338k| return Visitor::visit_leaf(*this, std::forward(args)...); 113| 338k| } _ZNK5immer6detail4rbts8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4nodeEv: 103| 867k| node_t* node() const { return node_; } _ZNK5immer6detail4rbts8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5countEv: 102| 1.05M| count_t count() const { return index(size_ - 1) + 1; } _ZNK5immer6detail4rbts8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5indexEm: 106| 1.10M| count_t index(size_t idx) const { return idx & mask; } _ZN5immer6detail4rbts13make_full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_8full_posIT_EEPSE_j: 1404| 4.32M|{ 1405| 4.32M| assert(node); 1406| 0| assert(shift >= NodeT::bits_leaf); 1407| 0| return {node, shift}; 1408| 4.32M|} _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_11dec_visitorEJEEEDcT_DpOT0_: 1397| 3.13M| { 1398| 3.13M| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 3.13M| } _ZNK5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4nodeEv: 1151| 3.40M| node_t* node() const { return node_; } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4eachINS1_11dec_visitorEJEEEvT_DpOT0_: 1177| 77.5k| { 1178| 77.5k| auto p = node_->inner(); 1179| 77.5k| auto e = p + branches; 1180| 77.5k| if (shift_ == BL) { ------------------ | Branch (1180:13): [True: 68.8k, False: 8.62k] ------------------ 1181| 620k| for (; p != e; ++p) { ------------------ | Branch (1181:20): [True: 551k, False: 68.8k] ------------------ 1182| 551k| IMMER_PREFETCH(p + 1); 1183| 551k| make_full_leaf_pos(*p).visit(v, args...); 1184| 551k| } 1185| 68.8k| } else { 1186| 8.62k| auto ss = shift_ - B; 1187| 77.5k| for (; p != e; ++p) ------------------ | Branch (1187:20): [True: 68.9k, False: 8.62k] ------------------ 1188| 68.9k| make_full_pos(*p, ss).visit(v, args...); 1189| 8.62k| } 1190| 77.5k| } _ZNK5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5countEv: 1150| 609k| count_t count() const { return branches; } _ZN5immer6detail4rbts16make_regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_11regular_posIT_EEPSE_jm: 688| 2.67M|{ 689| 2.67M| assert(node); 690| 0| assert(shift >= NodeT::bits_leaf); 691| 0| assert(size > 0); 692| 0| return {node, shift, size}; 693| 2.67M|} _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_11dec_visitorEJEEEDcT_DpOT0_: 334| 937k| { 335| 937k| return Visitor::visit_regular(*this, std::forward(args)...); 336| 937k| } _ZNK5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4nodeEv: 229| 4.72M| node_t* node() const { return node_; } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4eachINS1_11dec_visitorEJEEEvT_DpOT0_: 241| 900k| { 242| 900k| return each_regular(*this, v, args...); 243| 900k| } _ZN5immer6detail4rbts12each_regularIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_11dec_visitorEJEEEvOT_T0_DpOT1_: 341| 900k|{ 342| 900k| constexpr auto B = bits; 343| 900k| constexpr auto BL = bits_leaf; 344| 900k| auto n = p.node()->inner(); 345| 900k| auto last = p.count() - 1; 346| 900k| auto e = n + last; 347| 900k| if (p.shift() == BL) { ------------------ | Branch (347:9): [True: 267k, False: 633k] ------------------ 348| 1.07M| for (; n != e; ++n) { ------------------ | Branch (348:16): [True: 804k, False: 267k] ------------------ 349| 804k| IMMER_PREFETCH(n + 1); 350| 804k| make_full_leaf_pos(*n).visit(v, args...); 351| 804k| } 352| 267k| make_leaf_pos(*n, p.size()).visit(v, args...); 353| 633k| } else { 354| 633k| auto ss = p.shift() - B; 355| 2.78M| for (; n != e; ++n) ------------------ | Branch (355:16): [True: 2.15M, False: 633k] ------------------ 356| 2.15M| make_full_pos(*n, ss).visit(v, args...); 357| 633k| make_regular_pos(*n, ss, p.size()).visit(v, args...); 358| 633k| } 359| 900k|} _ZNK5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5shiftEv: 231| 4.44M| shift_t shift() const { return shift_; } _ZNK5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4sizeEv: 230| 7.18M| size_t size() const { return size_; } _ZNK5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5countEv: 228| 3.00M| count_t count() const { return index(size_ - 1) + 1; } _ZNK5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5indexEm: 232| 6.47M| count_t index(size_t idx) const { return (idx >> shift_) & mask; } _ZNK5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5countEv: 776| 6.75M| count_t count() const { return subindex(size_ - 1) + 1; } _ZNK5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8subindexEm: 781| 7.25M| count_t subindex(size_t idx) const { return idx >> shift_; } _ZN5immer6detail4rbts22make_empty_regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_17empty_regular_posIT_EEPSE_: 63| 1.20M|{ 64| 1.20M| return {node}; 65| 1.20M|} _ZN5immer6detail4rbts17empty_regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_11dec_visitorEJEEEDcT_DpOT0_: 56| 1.20M| { 57| 1.20M| return Visitor::visit_regular(*this, std::forward(args)...); 58| 1.20M| } _ZNK5immer6detail4rbts17empty_regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4nodeEv: 41| 1.20M| node_t* node() const { return node_; } _ZN5immer6detail4rbts17make_leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_12leaf_sub_posIT_EEPSE_j: 150| 40.4M|{ 151| 40.4M| assert(node); 152| 0| assert(count <= branches); 153| 0| return {node, count}; 154| 40.4M|} _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_11dec_visitorEJEEEDcT_DpOT0_: 143| 28.3M| { 144| 28.3M| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 28.3M| } _ZNK5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4nodeEv: 135| 35.1M| node_t* node() const { return node_; } _ZNK5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5countEv: 134| 12.8M| count_t count() const { return count_; } _ZN5immer6detail4rbts19make_empty_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_14empty_leaf_posIT_EEPSE_: 87| 969k|{ 88| 969k| assert(node); 89| 0| return {node}; 90| 969k|} _ZN5immer6detail4rbts14empty_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_11dec_visitorEJEEEDcT_DpOT0_: 80| 969k| { 81| 969k| return Visitor::visit_leaf(*this, std::forward(args)...); 82| 969k| } _ZNK5immer6detail4rbts14empty_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4nodeEv: 74| 969k| node_t* node() const { return node_; } _ZNK5immer6detail4rbts14empty_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5countEv: 73| 1.12k| count_t count() const { return 0; } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_17push_tail_visitorISC_EEJRPSC_RjEEEDcT_DpOT0_: 1805| 341k| { 1806| 341k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 341k| } _ZNK5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5shiftEv: 1425| 13.6M| shift_t shift() const { return shift_; } _ZNK5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4sizeEj: 1435| 6.91M| { 1436| 6.91M| return size_sbh(offset, size_before(offset)); 1437| 6.91M| } _ZNK5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8size_sbhEjm: 1440| 7.13M| { 1441| 7.13M| assert(size_before_hint == size_before(offset)); 1442| 0| return relaxed_->d.sizes[offset] - size_before_hint; 1443| 7.13M| } _ZNK5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11size_beforeEj: 1430| 28.5M| { 1431| 28.5M| return offset ? relaxed_->d.sizes[offset - 1] : 0; ------------------ | Branch (1431:16): [True: 17.6M, False: 10.8M] ------------------ 1432| 28.5M| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11last_oh_cshINS1_17push_tail_visitorISC_EEJRPSC_RjEEEDcT_jmDpOT0_: 1729| 338k| { 1730| 338k| assert(offset_hint == count() - 1); 1731| 0| assert(child_size_hint == size(offset_hint)); 1732| 0| auto child = node_->inner()[offset_hint]; 1733| 338k| auto is_leaf = shift_ == BL; 1734| 338k| return is_leaf ------------------ | Branch (1734:16): [True: 0, False: 338k] ------------------ 1735| 338k| ? make_leaf_sub_pos(child, child_size_hint).visit(v, args...) 1736| 338k| : visit_maybe_relaxed_sub( 1737| 338k| child, shift_ - B, child_size_hint, v, args...); 1738| 338k| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_17push_tail_visitorISC_EEJRPSC_RjEEEDcPT_jmT0_DpOT1_: 1830| 338k|{ 1831| 338k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 338k| if (relaxed) { ------------------ | Branch (1833:9): [True: 287k, False: 51.1k] ------------------ 1834| 287k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 287k| .visit(v, std::forward(args)...); 1837| 287k| } else { 1838| 51.1k| return make_regular_sub_pos(node, shift, size) 1839| 51.1k| .visit(v, std::forward(args)...); 1840| 51.1k| } 1841| 338k|} _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_17push_tail_visitorISC_EEJRPSC_RjEEEDcT_DpOT0_: 1028| 51.1k| { 1029| 51.1k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 51.1k| } _ZNK5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5indexEm: 780| 1.79M| count_t index(size_t idx) const { return (idx >> shift_) & mask; } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7last_ohINS1_17push_tail_visitorISC_EEJRPSC_EEEDcT_jDpOT0_: 944| 299k| { 945| 299k| return last_oh_regular(*this, v, offset_hint, args...); 946| 299k| } _ZN5immer6detail4rbts15last_oh_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_17push_tail_visitorISD_EEJRPSD_EEEDcOT_T0_jDpOT1_: 675| 299k|{ 676| 299k| assert(offset_hint == p.count() - 1); 677| 0| constexpr auto B = bits; 678| 299k| constexpr auto BL = bits_leaf; 679| 299k| auto child = p.node()->inner()[offset_hint]; 680| 299k| auto is_leaf = p.shift() == BL; 681| 299k| return is_leaf ? make_leaf_pos(child, p.size()).visit(v, args...) ------------------ | Branch (681:12): [True: 0, False: 299k] ------------------ 682| 299k| : make_regular_pos(child, p.shift() - B, p.size()) 683| 299k| .visit(v, args...); 684| 299k|} _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_17push_tail_visitorISC_EEJRPSC_EEEDcT_DpOT0_: 334| 893k| { 335| 893k| return Visitor::visit_regular(*this, std::forward(args)...); 336| 893k| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7last_ohINS1_17push_tail_visitorISC_EEJRPSC_EEEDcT_jDpOT0_: 328| 594k| { 329| 594k| return last_oh_regular(*this, v, offset_hint, args...); 330| 594k| } _ZN5immer6detail4rbts15last_oh_regularIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_17push_tail_visitorISD_EEJRPSD_EEEDcOT_T0_jDpOT1_: 675| 594k|{ 676| 594k| assert(offset_hint == p.count() - 1); 677| 0| constexpr auto B = bits; 678| 594k| constexpr auto BL = bits_leaf; 679| 594k| auto child = p.node()->inner()[offset_hint]; 680| 594k| auto is_leaf = p.shift() == BL; 681| 594k| return is_leaf ? make_leaf_pos(child, p.size()).visit(v, args...) ------------------ | Branch (681:12): [True: 0, False: 594k] ------------------ 682| 594k| : make_regular_pos(child, p.shift() - B, p.size()) 683| 594k| .visit(v, args...); 684| 594k|} _ZNK5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4sizeEv: 1424| 59.2M| size_t size() const { return relaxed_->d.sizes[relaxed_->d.count - 1]; } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_17push_tail_visitorISC_EEJRPSC_EEEDcT_DpOT0_: 1028| 254k| { 1029| 254k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 254k| } flex-vector-st.cpp:_ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14update_visitorISC_EEJmRZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSK_E_EEEDcSK_DpOT0_: 143| 251k| { 144| 251k| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 251k| } _ZNK5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5indexEm: 138| 439k| count_t index(size_t idx) const { return idx & mask; } flex-vector-st.cpp:_ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_14update_visitorISC_EEJRmRZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSJ_E_EEEDcPSJ_jmT0_DpOT1_: 1830| 166k|{ 1831| 166k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 166k| if (relaxed) { ------------------ | Branch (1833:9): [True: 105k, False: 61.9k] ------------------ 1834| 105k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 105k| .visit(v, std::forward(args)...); 1837| 105k| } else { 1838| 61.9k| return make_regular_sub_pos(node, shift, size) 1839| 61.9k| .visit(v, std::forward(args)...); 1840| 61.9k| } 1841| 166k|} flex-vector-st.cpp:_ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14update_visitorISC_EEJRmRZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSL_E_EEEDcSL_DpOT0_: 1805| 105k| { 1806| 105k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 105k| } _ZNK5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5indexEm: 1446| 4.39M| { 1447| 4.39M| auto offset = idx >> shift_; 1448| 7.05M| while (relaxed_->d.sizes[offset] <= idx) ------------------ | Branch (1448:16): [True: 2.65M, False: 4.39M] ------------------ 1449| 2.65M| ++offset; 1450| 4.39M| return offset; 1451| 4.39M| } _ZNK5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7relaxedEv: 1427| 105k| relaxed_t* relaxed() const { return relaxed_; } flex-vector-st.cpp:_ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_14update_visitorISC_EEJRZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSK_E_EEEDcSK_mjDpOT0_: 1678| 105k| { 1679| 105k| assert(offset_hint == index(idx)); 1680| 105k| auto left_size = offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0; ------------------ | Branch (1680:26): [True: 10.4k, False: 94.5k] ------------------ 1681| 105k| return towards_oh_sbh(v, idx, offset_hint, left_size, args...); 1682| 105k| } flex-vector-st.cpp:_ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_oh_sbhINS1_14update_visitorISC_EEJRZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSK_E_EEEDcSK_mjmDpOT0_: 1690| 105k| { 1691| 105k| return towards_sub_oh_sbh(v, idx, offset_hint, left_size_hint, args...); 1692| 105k| } flex-vector-st.cpp:_ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE18towards_sub_oh_sbhINS1_14update_visitorISC_EEJRZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSK_E_EEEDcSK_mjmDpOT0_: 1709| 105k| { 1710| 105k| assert(offset_hint == index(idx)); 1711| 0| assert(left_size_hint == 1712| 105k| (offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0)); 1713| 0| auto child = node_->inner()[offset_hint]; 1714| 105k| auto is_leaf = shift_ == BL; 1715| 105k| auto next_size = relaxed_->d.sizes[offset_hint] - left_size_hint; 1716| 105k| auto next_idx = idx - left_size_hint; 1717| 105k| return is_leaf ------------------ | Branch (1717:16): [True: 17.1k, False: 87.8k] ------------------ 1718| 105k| ? make_leaf_sub_pos(child, next_size) 1719| 17.1k| .visit(v, next_idx, args...) 1720| 105k| : visit_maybe_relaxed_sub( 1721| 87.8k| child, shift_ - B, next_size, v, next_idx, args...); 1722| 105k| } flex-vector-st.cpp:_ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14update_visitorISC_EEJRmRZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSL_E_EEEDcSL_DpOT0_: 143| 17.1k| { 144| 17.1k| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 17.1k| } flex-vector-st.cpp:_ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14update_visitorISC_EEJRmRZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSL_E_EEEDcSL_DpOT0_: 1028| 61.9k| { 1029| 61.9k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 61.9k| } flex-vector-st.cpp:_ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13towards_oh_chINS1_14update_visitorISC_EEJRZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSK_E_EEEDcSK_mjjDpOT0_: 930| 61.9k| { 931| 61.9k| return towards_oh_ch_regular( 932| 61.9k| *this, v, idx, offset_hint, count(), args...); 933| 61.9k| } flex-vector-st.cpp:_ZN5immer6detail4rbts21towards_oh_ch_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_14update_visitorISD_EEJRZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSL_E_EEEDcOSL_T0_mjjDpOT1_: 630| 61.9k|{ 631| 61.9k| constexpr auto B = bits; 632| 61.9k| constexpr auto BL = bits_leaf; 633| 61.9k| assert(offset_hint == p.index(idx)); 634| 0| assert(count_hint == p.count()); 635| 0| auto is_leaf = p.shift() == BL; 636| 61.9k| auto child = p.node()->inner()[offset_hint]; 637| 61.9k| auto is_full = offset_hint + 1 != count_hint; 638| 61.9k| return is_full ------------------ | Branch (638:12): [True: 17.6k, False: 44.3k] ------------------ 639| 61.9k| ? (is_leaf ? make_full_leaf_pos(child).visit(v, idx, args...) ------------------ | Branch (639:19): [True: 17.3k, False: 235] ------------------ 640| 17.6k| : make_full_pos(child, p.shift() - B) 641| 235| .visit(v, idx, args...)) 642| 61.9k| : (is_leaf ------------------ | Branch (642:19): [True: 44.3k, False: 0] ------------------ 643| 44.3k| ? make_leaf_pos(child, p.size()).visit(v, idx, args...) 644| 44.3k| : make_regular_pos(child, p.shift() - B, p.size()) 645| 0| .visit(v, idx, args...)); 646| 61.9k|} flex-vector-st.cpp:_ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14update_visitorISC_EEJRmRZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSL_E_EEEDcSL_DpOT0_: 205| 17.6k| { 206| 17.6k| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 17.6k| } _ZNK5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5indexEm: 200| 281k| count_t index(size_t idx) const { return idx & mask; } flex-vector-st.cpp:_ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14update_visitorISC_EEJRmRZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSL_E_EEEDcSL_DpOT0_: 1397| 469| { 1398| 469| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 469| } _ZNK5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5indexEm: 1154| 1.23M| count_t index(size_t idx) const { return (idx >> shift_) & mask; } flex-vector-st.cpp:_ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13towards_oh_chINS1_14update_visitorISC_EEJRZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSK_E_EEEDcSK_mjjDpOT0_: 1321| 469| { 1322| 469| return towards_oh(v, idx, offset_hint, args...); 1323| 469| } flex-vector-st.cpp:_ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_14update_visitorISC_EEJRZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSK_E_EEEDcSK_mjDpOT0_: 1328| 469| { 1329| 469| assert(offset_hint == index(idx)); 1330| 0| auto is_leaf = shift_ == BL; 1331| 469| auto child = node_->inner()[offset_hint]; 1332| 469| return is_leaf ------------------ | Branch (1332:16): [True: 235, False: 234] ------------------ 1333| 469| ? make_full_leaf_pos(child).visit(v, idx, args...) 1334| 469| : make_full_pos(child, shift_ - B).visit(v, idx, args...); 1335| 469| } flex-vector-st.cpp:_ZN5immer6detail4rbts8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14update_visitorISC_EEJRmRZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSL_E_EEEDcSL_DpOT0_: 111| 44.3k| { 112| 44.3k| return Visitor::visit_leaf(*this, std::forward(args)...); 113| 44.3k| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_19slice_right_visitorISC_Lb1EEEJRmEEEDcPT_jmT0_DpOT1_: 1830| 5.04k|{ 1831| 5.04k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 5.04k| if (relaxed) { ------------------ | Branch (1833:9): [True: 4.95k, False: 86] ------------------ 1834| 4.95k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 4.95k| .visit(v, std::forward(args)...); 1837| 4.95k| } else { 1838| 86| return make_regular_sub_pos(node, shift, size) 1839| 86| .visit(v, std::forward(args)...); 1840| 86| } 1841| 5.04k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19slice_right_visitorISC_Lb1EEEJRmEEEDcT_DpOT0_: 1805| 4.95k| { 1806| 4.95k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 4.95k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_19slice_right_visitorISC_Lb1EEEJEEEDcT_mjDpOT0_: 1678| 4.29k| { 1679| 4.29k| assert(offset_hint == index(idx)); 1680| 4.29k| auto left_size = offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0; ------------------ | Branch (1680:26): [True: 0, False: 4.29k] ------------------ 1681| 4.29k| return towards_oh_sbh(v, idx, offset_hint, left_size, args...); 1682| 4.29k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_oh_sbhINS1_19slice_right_visitorISC_Lb1EEEJEEEDcT_mjmDpOT0_: 1690| 4.29k| { 1691| 4.29k| return towards_sub_oh_sbh(v, idx, offset_hint, left_size_hint, args...); 1692| 4.29k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE18towards_sub_oh_sbhINS1_19slice_right_visitorISC_Lb1EEEJEEEDcT_mjmDpOT0_: 1709| 4.29k| { 1710| 4.29k| assert(offset_hint == index(idx)); 1711| 0| assert(left_size_hint == 1712| 4.29k| (offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0)); 1713| 0| auto child = node_->inner()[offset_hint]; 1714| 4.29k| auto is_leaf = shift_ == BL; 1715| 4.29k| auto next_size = relaxed_->d.sizes[offset_hint] - left_size_hint; 1716| 4.29k| auto next_idx = idx - left_size_hint; 1717| 4.29k| return is_leaf ------------------ | Branch (1717:16): [True: 241, False: 4.05k] ------------------ 1718| 4.29k| ? make_leaf_sub_pos(child, next_size) 1719| 241| .visit(v, next_idx, args...) 1720| 4.29k| : visit_maybe_relaxed_sub( 1721| 4.05k| child, shift_ - B, next_size, v, next_idx, args...); 1722| 4.29k| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19slice_right_visitorISC_Lb1EEEJRmEEEDcT_DpOT0_: 143| 241| { 144| 241| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 241| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_19slice_right_visitorISC_Lb0EEEJEEEDcT_mjDpOT0_: 1678| 1.22k| { 1679| 1.22k| assert(offset_hint == index(idx)); 1680| 1.22k| auto left_size = offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0; ------------------ | Branch (1680:26): [True: 1.12k, False: 102] ------------------ 1681| 1.22k| return towards_oh_sbh(v, idx, offset_hint, left_size, args...); 1682| 1.22k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_oh_sbhINS1_19slice_right_visitorISC_Lb0EEEJEEEDcT_mjmDpOT0_: 1690| 1.22k| { 1691| 1.22k| return towards_sub_oh_sbh(v, idx, offset_hint, left_size_hint, args...); 1692| 1.22k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE18towards_sub_oh_sbhINS1_19slice_right_visitorISC_Lb0EEEJEEEDcT_mjmDpOT0_: 1709| 1.22k| { 1710| 1.22k| assert(offset_hint == index(idx)); 1711| 0| assert(left_size_hint == 1712| 1.22k| (offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0)); 1713| 0| auto child = node_->inner()[offset_hint]; 1714| 1.22k| auto is_leaf = shift_ == BL; 1715| 1.22k| auto next_size = relaxed_->d.sizes[offset_hint] - left_size_hint; 1716| 1.22k| auto next_idx = idx - left_size_hint; 1717| 1.22k| return is_leaf ------------------ | Branch (1717:16): [True: 457, False: 769] ------------------ 1718| 1.22k| ? make_leaf_sub_pos(child, next_size) 1719| 457| .visit(v, next_idx, args...) 1720| 1.22k| : visit_maybe_relaxed_sub( 1721| 769| child, shift_ - B, next_size, v, next_idx, args...); 1722| 1.22k| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19slice_right_visitorISC_Lb0EEEJRmEEEDcT_DpOT0_: 143| 457| { 144| 457| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 457| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_19slice_right_visitorISC_Lb0EEEJRmEEEDcPT_jmT0_DpOT1_: 1830| 769|{ 1831| 769| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 769| if (relaxed) { ------------------ | Branch (1833:9): [True: 559, False: 210] ------------------ 1834| 559| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 559| .visit(v, std::forward(args)...); 1837| 559| } else { 1838| 210| return make_regular_sub_pos(node, shift, size) 1839| 210| .visit(v, std::forward(args)...); 1840| 210| } 1841| 769|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19slice_right_visitorISC_Lb0EEEJRmEEEDcT_DpOT0_: 1805| 559| { 1806| 559| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 559| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19slice_right_visitorISC_Lb0EEEJRmEEEDcT_DpOT0_: 1028| 210| { 1029| 210| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 210| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_19slice_right_visitorISC_Lb0EEEJEEEDcT_mjDpOT0_: 919| 229| { 920| 229| return towards_oh_ch_regular( 921| 229| *this, v, idx, offset_hint, count(), args...); 922| 229| } _ZN5immer6detail4rbts21towards_oh_ch_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_19slice_right_visitorISD_Lb0EEEJEEEDcOT_T0_mjjDpOT1_: 630| 229|{ 631| 229| constexpr auto B = bits; 632| 229| constexpr auto BL = bits_leaf; 633| 229| assert(offset_hint == p.index(idx)); 634| 0| assert(count_hint == p.count()); 635| 0| auto is_leaf = p.shift() == BL; 636| 229| auto child = p.node()->inner()[offset_hint]; 637| 229| auto is_full = offset_hint + 1 != count_hint; 638| 229| return is_full ------------------ | Branch (638:12): [True: 101, False: 128] ------------------ 639| 229| ? (is_leaf ? make_full_leaf_pos(child).visit(v, idx, args...) ------------------ | Branch (639:19): [True: 90, False: 11] ------------------ 640| 101| : make_full_pos(child, p.shift() - B) 641| 11| .visit(v, idx, args...)) 642| 229| : (is_leaf ------------------ | Branch (642:19): [True: 15, False: 113] ------------------ 643| 128| ? make_leaf_pos(child, p.size()).visit(v, idx, args...) 644| 128| : make_regular_pos(child, p.shift() - B, p.size()) 645| 113| .visit(v, idx, args...)); 646| 229|} _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19slice_right_visitorISC_Lb0EEEJRmEEEDcT_DpOT0_: 205| 240| { 206| 240| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 240| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19slice_right_visitorISC_Lb0EEEJRmEEEDcT_DpOT0_: 1397| 176| { 1398| 176| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 176| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_19slice_right_visitorISC_Lb0EEEJEEEDcT_mjDpOT0_: 1328| 202| { 1329| 202| assert(offset_hint == index(idx)); 1330| 0| auto is_leaf = shift_ == BL; 1331| 202| auto child = node_->inner()[offset_hint]; 1332| 202| return is_leaf ------------------ | Branch (1332:16): [True: 150, False: 52] ------------------ 1333| 202| ? make_full_leaf_pos(child).visit(v, idx, args...) 1334| 202| : make_full_pos(child, shift_ - B).visit(v, idx, args...); 1335| 202| } _ZNK5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5shiftEv: 1153| 10.3k| shift_t shift() const { return shift_; } _ZN5immer6detail4rbts8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19slice_right_visitorISC_Lb0EEEJRmEEEDcT_DpOT0_: 111| 15| { 112| 15| return Visitor::visit_leaf(*this, std::forward(args)...); 113| 15| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19slice_right_visitorISC_Lb0EEEJRmEEEDcT_DpOT0_: 334| 113| { 335| 113| return Visitor::visit_regular(*this, std::forward(args)...); 336| 113| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_19slice_right_visitorISC_Lb0EEEJEEEDcT_mjDpOT0_: 303| 113| { 304| 113| return towards_oh_ch_regular( 305| 113| *this, v, idx, offset_hint, count(), args...); 306| 113| } _ZN5immer6detail4rbts21towards_oh_ch_regularIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_19slice_right_visitorISD_Lb0EEEJEEEDcOT_T0_mjjDpOT1_: 630| 113|{ 631| 113| constexpr auto B = bits; 632| 113| constexpr auto BL = bits_leaf; 633| 113| assert(offset_hint == p.index(idx)); 634| 0| assert(count_hint == p.count()); 635| 0| auto is_leaf = p.shift() == BL; 636| 113| auto child = p.node()->inner()[offset_hint]; 637| 113| auto is_full = offset_hint + 1 != count_hint; 638| 113| return is_full ------------------ | Branch (638:12): [True: 113, False: 0] ------------------ 639| 113| ? (is_leaf ? make_full_leaf_pos(child).visit(v, idx, args...) ------------------ | Branch (639:19): [True: 0, False: 113] ------------------ 640| 113| : make_full_pos(child, p.shift() - B) 641| 113| .visit(v, idx, args...)) 642| 113| : (is_leaf ------------------ | Branch (642:19): [True: 0, False: 0] ------------------ 643| 0| ? make_leaf_pos(child, p.size()).visit(v, idx, args...) 644| 0| : make_regular_pos(child, p.shift() - B, p.size()) 645| 0| .visit(v, idx, args...)); 646| 113|} _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19slice_right_visitorISC_Lb1EEEJRmEEEDcT_DpOT0_: 1028| 86| { 1029| 86| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 86| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_19slice_right_visitorISC_Lb1EEEJEEEDcT_mjDpOT0_: 919| 67| { 920| 67| return towards_oh_ch_regular( 921| 67| *this, v, idx, offset_hint, count(), args...); 922| 67| } _ZN5immer6detail4rbts21towards_oh_ch_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_19slice_right_visitorISD_Lb1EEEJEEEDcOT_T0_mjjDpOT1_: 630| 67|{ 631| 67| constexpr auto B = bits; 632| 67| constexpr auto BL = bits_leaf; 633| 67| assert(offset_hint == p.index(idx)); 634| 0| assert(count_hint == p.count()); 635| 0| auto is_leaf = p.shift() == BL; 636| 67| auto child = p.node()->inner()[offset_hint]; 637| 67| auto is_full = offset_hint + 1 != count_hint; 638| 67| return is_full ------------------ | Branch (638:12): [True: 65, False: 2] ------------------ 639| 67| ? (is_leaf ? make_full_leaf_pos(child).visit(v, idx, args...) ------------------ | Branch (639:19): [True: 10, False: 55] ------------------ 640| 65| : make_full_pos(child, p.shift() - B) 641| 55| .visit(v, idx, args...)) 642| 67| : (is_leaf ------------------ | Branch (642:19): [True: 2, False: 0] ------------------ 643| 2| ? make_leaf_pos(child, p.size()).visit(v, idx, args...) 644| 2| : make_regular_pos(child, p.shift() - B, p.size()) 645| 0| .visit(v, idx, args...)); 646| 67|} _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19slice_right_visitorISC_Lb1EEEJRmEEEDcT_DpOT0_: 205| 39| { 206| 39| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 39| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19slice_right_visitorISC_Lb1EEEJRmEEEDcT_DpOT0_: 1397| 142| { 1398| 142| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 142| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_19slice_right_visitorISC_Lb1EEEJEEEDcT_mjDpOT0_: 1328| 116| { 1329| 116| assert(offset_hint == index(idx)); 1330| 0| auto is_leaf = shift_ == BL; 1331| 116| auto child = node_->inner()[offset_hint]; 1332| 116| return is_leaf ------------------ | Branch (1332:16): [True: 29, False: 87] ------------------ 1333| 116| ? make_full_leaf_pos(child).visit(v, idx, args...) 1334| 116| : make_full_pos(child, shift_ - B).visit(v, idx, args...); 1335| 116| } _ZN5immer6detail4rbts8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19slice_right_visitorISC_Lb1EEEJRmEEEDcT_DpOT0_: 111| 2| { 112| 2| return Visitor::visit_leaf(*this, std::forward(args)...); 113| 2| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_18slice_left_visitorISC_Lb1EEEJRmEEEDcPT_jmT0_DpOT1_: 1830| 1.30k|{ 1831| 1.30k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 1.30k| if (relaxed) { ------------------ | Branch (1833:9): [True: 1.11k, False: 187] ------------------ 1834| 1.11k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 1.11k| .visit(v, std::forward(args)...); 1837| 1.11k| } else { 1838| 187| return make_regular_sub_pos(node, shift, size) 1839| 187| .visit(v, std::forward(args)...); 1840| 187| } 1841| 1.30k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_18slice_left_visitorISC_Lb1EEEJRmEEEDcT_DpOT0_: 1805| 1.11k| { 1806| 1.11k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 1.11k| } _ZNK5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8subindexEm: 1426| 1.27M| count_t subindex(size_t idx) const { return index(idx); } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_sub_ohINS1_18slice_left_visitorISC_Lb1EEEJEEEDcT_mjDpOT0_: 1697| 136| { 1698| 136| assert(offset_hint == index(idx)); 1699| 136| auto left_size = offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0; ------------------ | Branch (1699:26): [True: 136, False: 0] ------------------ 1700| 136| return towards_sub_oh_sbh(v, idx, offset_hint, left_size, args...); 1701| 136| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE18towards_sub_oh_sbhINS1_18slice_left_visitorISC_Lb1EEEJEEEDcT_mjmDpOT0_: 1709| 136| { 1710| 136| assert(offset_hint == index(idx)); 1711| 0| assert(left_size_hint == 1712| 136| (offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0)); 1713| 0| auto child = node_->inner()[offset_hint]; 1714| 136| auto is_leaf = shift_ == BL; 1715| 136| auto next_size = relaxed_->d.sizes[offset_hint] - left_size_hint; 1716| 136| auto next_idx = idx - left_size_hint; 1717| 136| return is_leaf ------------------ | Branch (1717:16): [True: 0, False: 136] ------------------ 1718| 136| ? make_leaf_sub_pos(child, next_size) 1719| 0| .visit(v, next_idx, args...) 1720| 136| : visit_maybe_relaxed_sub( 1721| 136| child, shift_ - B, next_size, v, next_idx, args...); 1722| 136| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_sub_ohINS1_18slice_left_visitorISC_Lb0EEEJEEEDcT_mjDpOT0_: 1697| 6.98k| { 1698| 6.98k| assert(offset_hint == index(idx)); 1699| 6.98k| auto left_size = offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0; ------------------ | Branch (1699:26): [True: 1.17k, False: 5.80k] ------------------ 1700| 6.98k| return towards_sub_oh_sbh(v, idx, offset_hint, left_size, args...); 1701| 6.98k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE18towards_sub_oh_sbhINS1_18slice_left_visitorISC_Lb0EEEJEEEDcT_mjmDpOT0_: 1709| 6.98k| { 1710| 6.98k| assert(offset_hint == index(idx)); 1711| 0| assert(left_size_hint == 1712| 6.98k| (offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0)); 1713| 0| auto child = node_->inner()[offset_hint]; 1714| 6.98k| auto is_leaf = shift_ == BL; 1715| 6.98k| auto next_size = relaxed_->d.sizes[offset_hint] - left_size_hint; 1716| 6.98k| auto next_idx = idx - left_size_hint; 1717| 6.98k| return is_leaf ------------------ | Branch (1717:16): [True: 851, False: 6.13k] ------------------ 1718| 6.98k| ? make_leaf_sub_pos(child, next_size) 1719| 851| .visit(v, next_idx, args...) 1720| 6.98k| : visit_maybe_relaxed_sub( 1721| 6.13k| child, shift_ - B, next_size, v, next_idx, args...); 1722| 6.98k| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_18slice_left_visitorISC_Lb0EEEJRmEEEDcT_DpOT0_: 143| 851| { 144| 851| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 851| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_18slice_left_visitorISC_Lb0EEEJRmEEEDcPT_jmT0_DpOT1_: 1830| 6.13k|{ 1831| 6.13k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 6.13k| if (relaxed) { ------------------ | Branch (1833:9): [True: 6.00k, False: 131] ------------------ 1834| 6.00k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 6.00k| .visit(v, std::forward(args)...); 1837| 6.00k| } else { 1838| 131| return make_regular_sub_pos(node, shift, size) 1839| 131| .visit(v, std::forward(args)...); 1840| 131| } 1841| 6.13k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_18slice_left_visitorISC_Lb0EEEJRmEEEDcT_DpOT0_: 1805| 6.00k| { 1806| 6.00k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 6.00k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_18slice_left_visitorISC_Lb0EEEJRmEEEDcT_DpOT0_: 1028| 131| { 1029| 131| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 131| } _ZNK5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11size_beforeEj: 783| 256k| { 784| 256k| return size_t{offset} << shift_; 785| 256k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8size_sbhEjm: 795| 2.99k| { 796| 2.99k| assert(size_before_hint == size_before(offset)); 797| 2.99k| return offset == subindex(size_ - 1) ? size_ - size_before_hint ------------------ | Branch (797:16): [True: 542, False: 2.45k] ------------------ 798| 2.99k| : size_t{1} << shift_; 799| 2.99k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_sub_ohINS1_18slice_left_visitorISC_Lb0EEEJEEEDcT_mjDpOT0_: 938| 209| { 939| 209| return towards_sub_oh_regular(*this, v, idx, offset_hint, args...); 940| 209| } _ZN5immer6detail4rbts22towards_sub_oh_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_18slice_left_visitorISD_Lb0EEEJEEEDcOT_T0_mjDpOT1_: 651| 209|{ 652| 209| constexpr auto B = bits; 653| 209| constexpr auto BL = bits_leaf; 654| 209| assert(offset_hint == p.index(idx)); 655| 0| auto is_leaf = p.shift() == BL; 656| 209| auto child = p.node()->inner()[offset_hint]; 657| 209| auto lsize = offset_hint << p.shift(); 658| 209| auto size = p.this_size(); 659| 209| auto is_full = (size - lsize) >= (size_t{1} << p.shift()); 660| 209| return is_full ------------------ | Branch (660:12): [True: 209, False: 0] ------------------ 661| 209| ? (is_leaf ------------------ | Branch (661:19): [True: 131, False: 78] ------------------ 662| 209| ? make_full_leaf_pos(child).visit(v, idx - lsize, args...) 663| 209| : make_full_pos(child, p.shift() - B) 664| 78| .visit(v, idx - lsize, args...)) 665| 209| : (is_leaf ------------------ | Branch (665:19): [True: 0, False: 0] ------------------ 666| 0| ? make_leaf_sub_pos(child, size - lsize) 667| 0| .visit(v, idx - lsize, args...) 668| 0| : make_regular_sub_pos(child, p.shift() - B, size - lsize) 669| 0| .visit(v, idx - lsize, args...)); 670| 209|} _ZNK5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9this_sizeEv: 786| 2.99k| size_t this_size() const { return size_; } _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_18slice_left_visitorISC_Lb0EEEJmEEEDcT_DpOT0_: 205| 318| { 206| 318| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 318| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_18slice_left_visitorISC_Lb0EEEJmEEEDcT_DpOT0_: 1397| 342| { 1398| 342| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 342| } _ZNK5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8subindexEm: 1155| 838| count_t subindex(size_t idx) const { return idx >> shift_; } _ZNK5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11size_beforeEj: 1162| 1.50k| { 1163| 1.50k| return size_t{offset} << shift_; 1164| 1.50k| } _ZNK5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8size_sbhEjm: 1158| 838| { 1159| 838| return size_t{1} << shift_; 1160| 838| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_sub_ohINS1_18slice_left_visitorISC_Lb0EEEJEEEDcT_mjDpOT0_: 1340| 451| { 1341| 451| assert(offset_hint == index(idx)); 1342| 0| auto is_leaf = shift_ == BL; 1343| 451| auto child = node_->inner()[offset_hint]; 1344| 451| auto lsize = size_t{offset_hint} << shift_; 1345| 451| return is_leaf ------------------ | Branch (1345:16): [True: 187, False: 264] ------------------ 1346| 451| ? make_full_leaf_pos(child).visit(v, idx - lsize, args...) 1347| 451| : make_full_pos(child, shift_ - B) 1348| 264| .visit(v, idx - lsize, args...); 1349| 451| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10copy_sizesEjjmPm: 1167| 838| { 1168| 838| auto e = sizes + n; 1169| 5.16k| for (; sizes != e; ++sizes) { ------------------ | Branch (1169:16): [True: 4.32k, False: 838] ------------------ 1170| 4.32k| init = *sizes = init + (size_t{1} << shift_); 1171| 4.32k| assert(init); 1172| 4.32k| } 1173| 838| } _ZNK5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4sizeEv: 1152| 264k| size_t size() const { return branches << shift_; } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10copy_sizesEjjmPm: 802| 498k| { 803| 498k| if (n) { ------------------ | Branch (803:13): [True: 497k, False: 377] ------------------ 804| 497k| auto last = offset + n - 1; 805| 497k| auto e = sizes + n - 1; 806| 1.99M| for (; sizes != e; ++sizes) { ------------------ | Branch (806:20): [True: 1.49M, False: 497k] ------------------ 807| 1.49M| init = *sizes = init + (size_t{1} << shift_); 808| 1.49M| assert(init); 809| 1.49M| } 810| 497k| *sizes = init + size(last); 811| 497k| assert(*sizes); 812| 497k| } 813| 498k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4sizeEj: 789| 498k| { 790| 498k| return offset == subindex(size_ - 1) ? size_ - size_before(offset) ------------------ | Branch (790:16): [True: 250k, False: 247k] ------------------ 791| 498k| : size_t{1} << shift_; 792| 498k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10copy_sizesEjjmPm: 1454| 14.2M| { 1455| 14.2M| auto e = sizes + n; 1456| 14.2M| auto prev = size_before(offset); 1457| 14.2M| auto these = relaxed_->d.sizes + offset; 1458| 65.3M| for (; sizes != e; ++sizes, ++these) { ------------------ | Branch (1458:16): [True: 51.0M, False: 14.2M] ------------------ 1459| 51.0M| auto this_size = *these; 1460| 51.0M| init = *sizes = init + (this_size - prev); 1461| 51.0M| assert(init); 1462| 0| prev = this_size; 1463| 51.0M| } 1464| 14.2M| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_18slice_left_visitorISC_Lb1EEEJRmEEEDcT_DpOT0_: 1028| 187| { 1029| 187| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 187| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_sub_ohINS1_18slice_left_visitorISC_Lb1EEEJEEEDcT_mjDpOT0_: 938| 113| { 939| 113| return towards_sub_oh_regular(*this, v, idx, offset_hint, args...); 940| 113| } _ZN5immer6detail4rbts22towards_sub_oh_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_18slice_left_visitorISD_Lb1EEEJEEEDcOT_T0_mjDpOT1_: 651| 113|{ 652| 113| constexpr auto B = bits; 653| 113| constexpr auto BL = bits_leaf; 654| 113| assert(offset_hint == p.index(idx)); 655| 0| auto is_leaf = p.shift() == BL; 656| 113| auto child = p.node()->inner()[offset_hint]; 657| 113| auto lsize = offset_hint << p.shift(); 658| 113| auto size = p.this_size(); 659| 113| auto is_full = (size - lsize) >= (size_t{1} << p.shift()); 660| 113| return is_full ------------------ | Branch (660:12): [True: 109, False: 4] ------------------ 661| 113| ? (is_leaf ------------------ | Branch (661:19): [True: 0, False: 109] ------------------ 662| 109| ? make_full_leaf_pos(child).visit(v, idx - lsize, args...) 663| 109| : make_full_pos(child, p.shift() - B) 664| 109| .visit(v, idx - lsize, args...)) 665| 113| : (is_leaf ------------------ | Branch (665:19): [True: 0, False: 4] ------------------ 666| 4| ? make_leaf_sub_pos(child, size - lsize) 667| 0| .visit(v, idx - lsize, args...) 668| 4| : make_regular_sub_pos(child, p.shift() - B, size - lsize) 669| 4| .visit(v, idx - lsize, args...)); 670| 113|} _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_18slice_left_visitorISC_Lb1EEEJmEEEDcT_DpOT0_: 1397| 109| { 1398| 109| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 109| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_18slice_left_visitorISC_Lb1EEEJmEEEDcT_DpOT0_: 1028| 4| { 1029| 4| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 4| } _ZN5immer6detail4rbts30make_singleton_regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEDaPT_j: 758| 1.12k|{ 759| 1.12k| assert(leaf); 760| 1.12k| IMMER_ASSERT_TAGGED(leaf->kind() == NodeT::kind_t::leaf); ------------------ | | 60| 1.12k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 761| 0| assert(count > 0); 762| 0| return singleton_regular_sub_pos{leaf, count}; 763| 1.12k|} _ZN5immer6detail4rbts25singleton_regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_25concat_trees_left_visitorISC_EEJNS1_14empty_leaf_posISC_EERPSC_RjRmEEEDcT_DpOT0_: 751| 1.12k| { 752| 1.12k| return Visitor::visit_regular(*this, std::forward(args)...); 753| 1.12k| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_26concat_trees_right_visitorISC_EEJRNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EEEEEDcPT_jmT0_DpOT1_: 1830| 1.12k|{ 1831| 1.12k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 1.12k| if (relaxed) { ------------------ | Branch (1833:9): [True: 1.05k, False: 73] ------------------ 1834| 1.05k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 1.05k| .visit(v, std::forward(args)...); 1837| 1.05k| } else { 1838| 73| return make_regular_sub_pos(node, shift, size) 1839| 73| .visit(v, std::forward(args)...); 1840| 73| } 1841| 1.12k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_26concat_trees_right_visitorISC_EEJRNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EEEEEDcT_DpOT0_: 1805| 1.05k| { 1806| 1.05k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 1.05k| } _ZNK5immer6detail4rbts25singleton_regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5shiftEv: 729| 10.7k| shift_t shift() const { return BL; } _ZN5immer6detail4rbts25singleton_regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13each_left_subINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEvT_DpOT0_: 738| 1.12k| {} _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEDcT_DpOT0_: 143| 5.28M| { 144| 5.28M| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 5.28M| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEDcT_DpOT0_: 1805| 58.7M| { 1806| 58.7M| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 58.7M| } _ZN5immer6detail4rbts12null_sub_pos14each_right_subINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEvT_DpOT0_: 704| 1.45M| {} _ZN5immer6detail4rbts25singleton_regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13each_left_subINS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEvT_DpOT0_: 738| 1.12k| {} _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEDcT_DpOT0_: 143| 5.28M| { 144| 5.28M| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 5.28M| } _ZNK5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4sizeEv: 136| 5.28M| size_t size() const { return count_; } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEDcT_DpOT0_: 1805| 58.7M| { 1806| 58.7M| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 58.7M| } _ZN5immer6detail4rbts12null_sub_pos14each_right_subINS1_21concat_merger_visitorEJRNS1_13concat_mergerINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEEvT_DpOT0_: 704| 1.45M| {} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9first_subINS1_20concat_right_visitorISC_EEJRNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EEEEEDcT_DpOT0_: 1754| 9.58k| { 1755| 9.58k| auto child = node_->inner()[0]; 1756| 9.58k| auto child_size = relaxed_->d.sizes[0]; 1757| 9.58k| auto is_leaf = shift_ == BL; 1758| 9.58k| assert(child_size); 1759| 9.58k| return is_leaf ? make_leaf_sub_pos(child, child_size).visit(v, args...) ------------------ | Branch (1759:16): [True: 0, False: 9.58k] ------------------ 1760| 9.58k| : visit_maybe_relaxed_sub( 1761| 9.58k| child, shift_ - B, child_size, v, args...); 1762| 9.58k| } _ZNK5immer6detail4rbts14empty_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5shiftEv: 75| 1.12k| shift_t shift() const { return 0; } _ZNK5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5shiftEv: 137| 1.90M| shift_t shift() const { return 0; } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_20concat_right_visitorISC_EEJRNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EEEEEDcPT_jmT0_DpOT1_: 1830| 9.58k|{ 1831| 9.58k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 9.58k| if (relaxed) { ------------------ | Branch (1833:9): [True: 9.45k, False: 129] ------------------ 1834| 9.45k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 9.45k| .visit(v, std::forward(args)...); 1837| 9.45k| } else { 1838| 129| return make_regular_sub_pos(node, shift, size) 1839| 129| .visit(v, std::forward(args)...); 1840| 129| } 1841| 9.58k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_20concat_right_visitorISC_EEJRNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EEEEEDcT_DpOT0_: 1805| 9.45k| { 1806| 9.45k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 9.45k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_20concat_right_visitorISC_EEJRNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EEEEEDcT_DpOT0_: 1028| 129| { 1029| 129| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 129| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9first_subINS1_20concat_right_visitorISC_EEJRNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EEEEEDcT_DpOT0_: 962| 26| { 963| 26| auto is_leaf = shift_ == BL; 964| 26| auto child = node_->inner()[0]; 965| 26| auto is_full = size_ >= (size_t{1} << shift_); 966| 26| return is_full ------------------ | Branch (966:16): [True: 26, False: 0] ------------------ 967| 26| ? (is_leaf ------------------ | Branch (967:23): [True: 0, False: 26] ------------------ 968| 26| ? make_full_leaf_pos(child).visit(v, args...) 969| 26| : make_full_pos(child, shift_ - B).visit(v, args...)) 970| 26| : (is_leaf ------------------ | Branch (970:23): [True: 0, False: 0] ------------------ 971| 0| ? make_leaf_sub_pos(child, size_).visit(v, args...) 972| 0| : make_regular_sub_pos(child, shift_ - B, size_) 973| 0| .visit(v, args...)); 974| 26| } _ZNK5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5shiftEv: 199| 29.7k| shift_t shift() const { return 0; } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_20concat_right_visitorISC_EEJRNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EEEEEDcT_DpOT0_: 1397| 81| { 1398| 81| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 81| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9first_subINS1_20concat_right_visitorISC_EEJRNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EEEEEDcT_DpOT0_: 1353| 55| { 1354| 55| auto is_leaf = shift_ == BL; 1355| 55| auto child = node_->inner()[0]; 1356| 55| return is_leaf ? make_full_leaf_pos(child).visit(v, args...) ------------------ | Branch (1356:16): [True: 0, False: 55] ------------------ 1357| 55| : make_full_pos(child, shift_ - B).visit(v, args...); 1358| 55| } _ZN5immer6detail4rbts12null_sub_pos13each_left_subINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEvT_DpOT0_: 707| 28.0k| {} _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14each_right_subINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEvT_DpOT0_: 1296| 7.95k| { 1297| 7.95k| each_i(v, 1, branches, args...); 1298| 7.95k| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE6each_iINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEvT_jjDpOT0_: 1255| 7.95k| { 1256| 7.95k| auto p = node_->inner() + i; 1257| 7.95k| auto e = node_->inner() + n; 1258| 7.95k| if (shift_ == BL) { ------------------ | Branch (1258:13): [True: 4.11k, False: 3.83k] ------------------ 1259| 32.9k| for (; p != e; ++p) { ------------------ | Branch (1259:20): [True: 28.8k, False: 4.11k] ------------------ 1260| 28.8k| IMMER_PREFETCH(p + 1); 1261| 28.8k| make_full_leaf_pos(*p).visit(v, args...); 1262| 28.8k| } 1263| 4.11k| } else { 1264| 3.83k| auto ss = shift_ - B; 1265| 30.7k| for (; p != e; ++p) ------------------ | Branch (1265:20): [True: 26.8k, False: 3.83k] ------------------ 1266| 26.8k| make_full_pos(*p, ss).visit(v, args...); 1267| 3.83k| } 1268| 7.95k| } _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEDcT_DpOT0_: 205| 582k| { 206| 582k| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 582k| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEDcT_DpOT0_: 1397| 264k| { 1398| 264k| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 264k| } _ZN5immer6detail4rbts12null_sub_pos13each_left_subINS1_21concat_merger_visitorEJRNS1_13concat_mergerINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEEEEvT_DpOT0_: 707| 28.0k| {} _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14each_right_subINS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEvT_DpOT0_: 1296| 7.95k| { 1297| 7.95k| each_i(v, 1, branches, args...); 1298| 7.95k| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE6each_iINS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEvT_jjDpOT0_: 1255| 7.95k| { 1256| 7.95k| auto p = node_->inner() + i; 1257| 7.95k| auto e = node_->inner() + n; 1258| 7.95k| if (shift_ == BL) { ------------------ | Branch (1258:13): [True: 4.11k, False: 3.83k] ------------------ 1259| 32.9k| for (; p != e; ++p) { ------------------ | Branch (1259:20): [True: 28.8k, False: 4.11k] ------------------ 1260| 28.8k| IMMER_PREFETCH(p + 1); 1261| 28.8k| make_full_leaf_pos(*p).visit(v, args...); 1262| 28.8k| } 1263| 4.11k| } else { 1264| 3.83k| auto ss = shift_ - B; 1265| 30.7k| for (; p != e; ++p) ------------------ | Branch (1265:20): [True: 26.8k, False: 3.83k] ------------------ 1266| 26.8k| make_full_pos(*p, ss).visit(v, args...); 1267| 3.83k| } 1268| 7.95k| } _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEDcT_DpOT0_: 205| 582k| { 206| 582k| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 582k| } _ZNK5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE4sizeEv: 198| 582k| size_t size() const { return branches; } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEDcT_DpOT0_: 1397| 264k| { 1398| 264k| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 264k| } _ZN5immer6detail4rbts25singleton_regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8last_subINS1_19concat_both_visitorISC_EEJRNS1_14empty_leaf_posISC_EERNS1_8full_posISC_EEEEEDcT_DpOT0_: 745| 26| { 746| 26| return make_leaf_sub_pos(leaf_, count_).visit(v, args...); 747| 26| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19concat_both_visitorISC_EEJRNS1_14empty_leaf_posISC_EERNS1_8full_posISC_EEEEEDcT_DpOT0_: 143| 26| { 144| 26| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 26| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14first_sub_leafINS1_20concat_right_visitorISC_EEJRNS1_12leaf_sub_posISC_EERNS1_14empty_leaf_posISC_EEEEEDcT_DpOT0_: 1362| 26| { 1363| 26| assert(shift_ == BL); 1364| 0| auto child = node_->inner()[0]; 1365| 26| return make_full_leaf_pos(child).visit(v, args...); 1366| 26| } _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_20concat_right_visitorISC_EEJRNS1_12leaf_sub_posISC_EERNS1_14empty_leaf_posISC_EEEEEDcT_DpOT0_: 205| 202| { 206| 202| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 202| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14each_right_subINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEvT_DpOT0_: 898| 29.7k| { 899| 29.7k| if (count() > 1) ------------------ | Branch (899:13): [True: 25.9k, False: 3.74k] ------------------ 900| 25.9k| each_right_sub_(v, 1, args...); 901| 29.7k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE15each_right_sub_INS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEvT_jDpOT0_: 871| 25.9k| { 872| 25.9k| auto last = count() - 1; 873| 25.9k| auto lsize = size_ - (last << shift_); 874| 25.9k| auto n = node()->inner() + i; 875| 25.9k| auto e = node()->inner() + last; 876| 25.9k| if (shift() == BL) { ------------------ | Branch (876:13): [True: 21.8k, False: 4.11k] ------------------ 877| 151k| for (; n != e; ++n) { ------------------ | Branch (877:20): [True: 129k, False: 21.8k] ------------------ 878| 129k| IMMER_PREFETCH(n + 1); 879| 129k| make_full_leaf_pos(*n).visit(v, args...); 880| 129k| } 881| 21.8k| make_leaf_sub_pos(*n, lsize).visit(v, args...); 882| 21.8k| } else { 883| 4.11k| auto ss = shift_ - B; 884| 18.7k| for (; n != e; ++n) ------------------ | Branch (884:20): [True: 14.6k, False: 4.11k] ------------------ 885| 14.6k| make_full_pos(*n, ss).visit(v, args...); 886| 4.11k| make_regular_sub_pos(*n, ss, lsize).visit(v, args...); 887| 4.11k| } 888| 25.9k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEDcT_DpOT0_: 1028| 768k| { 1029| 768k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 768k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14each_right_subINS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEvT_DpOT0_: 898| 29.7k| { 899| 29.7k| if (count() > 1) ------------------ | Branch (899:13): [True: 25.9k, False: 3.74k] ------------------ 900| 25.9k| each_right_sub_(v, 1, args...); 901| 29.7k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE15each_right_sub_INS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEvT_jDpOT0_: 871| 25.9k| { 872| 25.9k| auto last = count() - 1; 873| 25.9k| auto lsize = size_ - (last << shift_); 874| 25.9k| auto n = node()->inner() + i; 875| 25.9k| auto e = node()->inner() + last; 876| 25.9k| if (shift() == BL) { ------------------ | Branch (876:13): [True: 21.8k, False: 4.11k] ------------------ 877| 151k| for (; n != e; ++n) { ------------------ | Branch (877:20): [True: 129k, False: 21.8k] ------------------ 878| 129k| IMMER_PREFETCH(n + 1); 879| 129k| make_full_leaf_pos(*n).visit(v, args...); 880| 129k| } 881| 21.8k| make_leaf_sub_pos(*n, lsize).visit(v, args...); 882| 21.8k| } else { 883| 4.11k| auto ss = shift_ - B; 884| 18.7k| for (; n != e; ++n) ------------------ | Branch (884:20): [True: 14.6k, False: 4.11k] ------------------ 885| 14.6k| make_full_pos(*n, ss).visit(v, args...); 886| 4.11k| make_regular_sub_pos(*n, ss, lsize).visit(v, args...); 887| 4.11k| } 888| 25.9k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEDcT_DpOT0_: 1028| 768k| { 1029| 768k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 768k| } _ZN5immer6detail4rbts25singleton_regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8last_subINS1_19concat_both_visitorISC_EEJRNS1_14empty_leaf_posISC_EERNS1_15regular_sub_posISC_EEEEEDcT_DpOT0_: 745| 176| { 746| 176| return make_leaf_sub_pos(leaf_, count_).visit(v, args...); 747| 176| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19concat_both_visitorISC_EEJRNS1_14empty_leaf_posISC_EERNS1_15regular_sub_posISC_EEEEEDcT_DpOT0_: 143| 176| { 144| 176| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 176| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14first_sub_leafINS1_20concat_right_visitorISC_EEJRNS1_12leaf_sub_posISC_EERNS1_14empty_leaf_posISC_EEEEEDcT_DpOT0_: 978| 176| { 979| 176| assert(shift_ == BL); 980| 0| auto child = node_->inner()[0]; 981| 176| auto is_full = size_ >= branches; 982| 176| return is_full ? make_full_leaf_pos(child).visit(v, args...) ------------------ | Branch (982:16): [True: 176, False: 0] ------------------ 983| 176| : make_leaf_sub_pos(child, size_).visit(v, args...); 984| 176| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_20concat_right_visitorISC_EEJRSD_RNS1_14empty_leaf_posISC_EEEEEDcT_DpOT0_: 143| 925| { 144| 925| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 925| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14each_right_subINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEvT_DpOT0_: 1639| 5.04M| { 1640| 5.04M| each_right(v, 1, std::forward(args)...); 1641| 5.04M| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10each_rightINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEvT_jDpOT0_: 1645| 5.04M| { 1646| 5.04M| assert(start > 0); 1647| 0| assert(start <= relaxed_->d.count); 1648| 0| auto s = relaxed_->d.sizes[start - 1]; 1649| 5.04M| auto p = node_->inner(); 1650| 5.04M| if (shift_ == BL) { ------------------ | Branch (1650:13): [True: 453k, False: 4.58M] ------------------ 1651| 2.70M| for (auto i = start; i < relaxed_->d.count; ++i) { ------------------ | Branch (1651:34): [True: 2.24M, False: 453k] ------------------ 1652| 2.24M| IMMER_PREFETCH(p + i + 1); 1653| 2.24M| make_leaf_sub_pos(p[i], relaxed_->d.sizes[i] - s) 1654| 2.24M| .visit(v, args...); 1655| 2.24M| s = relaxed_->d.sizes[i]; 1656| 2.24M| assert(s); 1657| 2.24M| } 1658| 4.58M| } else { 1659| 4.58M| auto ss = shift_ - B; 1660| 33.2M| for (auto i = start; i < relaxed_->d.count; ++i) { ------------------ | Branch (1660:34): [True: 28.7M, False: 4.58M] ------------------ 1661| 28.7M| visit_maybe_relaxed_sub( 1662| 28.7M| p[i], ss, relaxed_->d.sizes[i] - s, v, args...); 1663| 28.7M| s = relaxed_->d.sizes[i]; 1664| 28.7M| assert(s); 1665| 28.7M| } 1666| 4.58M| } 1667| 5.04M| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEDcPT_jmT0_DpOT1_: 1830| 49.2M|{ 1831| 49.2M| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 49.2M| if (relaxed) { ------------------ | Branch (1833:9): [True: 48.5M, False: 763k] ------------------ 1834| 48.5M| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 48.5M| .visit(v, std::forward(args)...); 1837| 48.5M| } else { 1838| 763k| return make_regular_sub_pos(node, shift, size) 1839| 763k| .visit(v, std::forward(args)...); 1840| 763k| } 1841| 49.2M|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14each_right_subINS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEvT_DpOT0_: 1639| 5.04M| { 1640| 5.04M| each_right(v, 1, std::forward(args)...); 1641| 5.04M| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10each_rightINS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEvT_jDpOT0_: 1645| 5.04M| { 1646| 5.04M| assert(start > 0); 1647| 0| assert(start <= relaxed_->d.count); 1648| 0| auto s = relaxed_->d.sizes[start - 1]; 1649| 5.04M| auto p = node_->inner(); 1650| 5.04M| if (shift_ == BL) { ------------------ | Branch (1650:13): [True: 453k, False: 4.58M] ------------------ 1651| 2.70M| for (auto i = start; i < relaxed_->d.count; ++i) { ------------------ | Branch (1651:34): [True: 2.24M, False: 453k] ------------------ 1652| 2.24M| IMMER_PREFETCH(p + i + 1); 1653| 2.24M| make_leaf_sub_pos(p[i], relaxed_->d.sizes[i] - s) 1654| 2.24M| .visit(v, args...); 1655| 2.24M| s = relaxed_->d.sizes[i]; 1656| 2.24M| assert(s); 1657| 2.24M| } 1658| 4.58M| } else { 1659| 4.58M| auto ss = shift_ - B; 1660| 33.2M| for (auto i = start; i < relaxed_->d.count; ++i) { ------------------ | Branch (1660:34): [True: 28.7M, False: 4.58M] ------------------ 1661| 28.7M| visit_maybe_relaxed_sub( 1662| 28.7M| p[i], ss, relaxed_->d.sizes[i] - s, v, args...); 1663| 28.7M| s = relaxed_->d.sizes[i]; 1664| 28.7M| assert(s); 1665| 28.7M| } 1666| 4.58M| } 1667| 5.04M| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEDcPT_jmT0_DpOT1_: 1830| 49.2M|{ 1831| 49.2M| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 49.2M| if (relaxed) { ------------------ | Branch (1833:9): [True: 48.5M, False: 763k] ------------------ 1834| 48.5M| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 48.5M| .visit(v, std::forward(args)...); 1837| 48.5M| } else { 1838| 763k| return make_regular_sub_pos(node, shift, size) 1839| 763k| .visit(v, std::forward(args)...); 1840| 763k| } 1841| 49.2M|} _ZN5immer6detail4rbts25singleton_regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8last_subINS1_19concat_both_visitorISC_EEJRNS1_14empty_leaf_posISC_EERNS1_11relaxed_posISC_EEEEEDcT_DpOT0_: 745| 925| { 746| 925| return make_leaf_sub_pos(leaf_, count_).visit(v, args...); 747| 925| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19concat_both_visitorISC_EEJRNS1_14empty_leaf_posISC_EERNS1_11relaxed_posISC_EEEEEDcT_DpOT0_: 143| 925| { 144| 925| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 925| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14first_sub_leafINS1_20concat_right_visitorISC_EEJRNS1_12leaf_sub_posISC_EERNS1_14empty_leaf_posISC_EEEEEDcT_DpOT0_: 1766| 925| { 1767| 925| assert(shift_ == BL); 1768| 0| auto child = node_->inner()[0]; 1769| 925| auto child_size = relaxed_->d.sizes[0]; 1770| 925| return make_leaf_sub_pos(child, child_size).visit(v, args...); 1771| 925| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_26concat_trees_right_visitorISC_EEJRNS1_25singleton_regular_sub_posISC_EERNS1_14empty_leaf_posISC_EEEEEDcT_DpOT0_: 1028| 73| { 1029| 73| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 73| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_25concat_trees_left_visitorISC_EEJNS1_8leaf_posISC_EERPSC_RjRmEEEDcPT_jmT0_DpOT1_: 1830| 482k|{ 1831| 482k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 482k| if (relaxed) { ------------------ | Branch (1833:9): [True: 480k, False: 1.82k] ------------------ 1834| 480k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 480k| .visit(v, std::forward(args)...); 1837| 480k| } else { 1838| 1.82k| return make_regular_sub_pos(node, shift, size) 1839| 1.82k| .visit(v, std::forward(args)...); 1840| 1.82k| } 1841| 482k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_25concat_trees_left_visitorISC_EEJNS1_8leaf_posISC_EERPSC_RjRmEEEDcT_DpOT0_: 1805| 480k| { 1806| 480k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 480k| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_26concat_trees_right_visitorISC_EEJRNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EEEEEDcPT_jmT0_DpOT1_: 1830| 480k|{ 1831| 480k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 480k| if (relaxed) { ------------------ | Branch (1833:9): [True: 475k, False: 4.63k] ------------------ 1834| 475k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 475k| .visit(v, std::forward(args)...); 1837| 475k| } else { 1838| 4.63k| return make_regular_sub_pos(node, shift, size) 1839| 4.63k| .visit(v, std::forward(args)...); 1840| 4.63k| } 1841| 480k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_26concat_trees_right_visitorISC_EEJRSD_RNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 1805| 475k| { 1806| 475k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 475k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8last_subINS1_19concat_left_visitorISC_EEJRNS1_8leaf_posISC_EERSD_EEEDcT_DpOT0_: 1742| 1.44M| { 1743| 1.44M| auto offset = relaxed_->d.count - 1; 1744| 1.44M| auto child = node_->inner()[offset]; 1745| 1.44M| auto child_size = size(offset); 1746| 1.44M| auto is_leaf = shift_ == BL; 1747| 1.44M| return is_leaf ? make_leaf_sub_pos(child, child_size).visit(v, args...) ------------------ | Branch (1747:16): [True: 0, False: 1.44M] ------------------ 1748| 1.44M| : visit_maybe_relaxed_sub( 1749| 1.44M| child, shift_ - B, child_size, v, args...); 1750| 1.44M| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_19concat_left_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_11relaxed_posISC_EEEEEDcPT_jmT0_DpOT1_: 1830| 1.44M|{ 1831| 1.44M| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 1.44M| if (relaxed) { ------------------ | Branch (1833:9): [True: 1.44M, False: 153] ------------------ 1834| 1.44M| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 1.44M| .visit(v, std::forward(args)...); 1837| 1.44M| } else { 1838| 153| return make_regular_sub_pos(node, shift, size) 1839| 153| .visit(v, std::forward(args)...); 1840| 153| } 1841| 1.44M|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19concat_left_visitorISC_EEJRNS1_8leaf_posISC_EERSD_EEEDcT_DpOT0_: 1805| 1.44M| { 1806| 1.44M| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 1.44M| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19concat_left_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_11relaxed_posISC_EEEEEDcT_DpOT0_: 1028| 299| { 1029| 299| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 299| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8last_subINS1_19concat_left_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_11relaxed_posISC_EEEEEDcT_DpOT0_: 950| 146| { 951| 146| auto offset = count() - 1; 952| 146| auto child = node_->inner()[offset]; 953| 146| auto is_leaf = shift_ == BL; 954| 146| auto lsize = size_ - (size_t{offset} << shift_); 955| 146| return is_leaf ? make_leaf_sub_pos(child, lsize).visit(v, args...) ------------------ | Branch (955:16): [True: 0, False: 146] ------------------ 956| 146| : make_regular_sub_pos(child, shift_ - B, lsize) 957| 146| .visit(v, args...); 958| 146| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13each_left_subINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEvT_DpOT0_: 905| 615k| { 906| 615k| each_left(v, count() - 1, args...); 907| 615k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9each_leftINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEvT_jDpOT0_: 865| 615k| { 866| 615k| return each_left_regular(*this, v, last, args...); 867| 615k| } _ZN5immer6detail4rbts17each_left_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEvOT_T0_jDpOT1_: 573| 615k|{ 574| 615k| constexpr auto B = bits; 575| 615k| constexpr auto BL = bits_leaf; 576| 615k| assert(last < p.count()); 577| 615k| if (p.shift() == BL) { ------------------ | Branch (577:9): [True: 234k, False: 380k] ------------------ 578| 234k| auto n = p.node()->inner(); 579| 234k| auto e = n + last; 580| 658k| for (; n != e; ++n) { ------------------ | Branch (580:16): [True: 423k, False: 234k] ------------------ 581| 423k| IMMER_PREFETCH(n + 1); 582| 423k| make_full_leaf_pos(*n).visit(v, args...); 583| 423k| } 584| 380k| } else { 585| 380k| auto n = p.node()->inner(); 586| 380k| auto e = n + last; 587| 380k| auto ss = p.shift() - B; 588| 603k| for (; n != e; ++n) ------------------ | Branch (588:16): [True: 222k, False: 380k] ------------------ 589| 222k| make_full_pos(*n, ss).visit(v, args...); 590| 380k| } 591| 615k|} _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13each_left_subINS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEvT_DpOT0_: 905| 615k| { 906| 615k| each_left(v, count() - 1, args...); 907| 615k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9each_leftINS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEvT_jDpOT0_: 865| 615k| { 866| 615k| return each_left_regular(*this, v, last, args...); 867| 615k| } _ZN5immer6detail4rbts17each_left_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_21concat_merger_visitorEJRNS1_13concat_mergerISD_EEEEEvOT_T0_jDpOT1_: 573| 615k|{ 574| 615k| constexpr auto B = bits; 575| 615k| constexpr auto BL = bits_leaf; 576| 615k| assert(last < p.count()); 577| 615k| if (p.shift() == BL) { ------------------ | Branch (577:9): [True: 234k, False: 380k] ------------------ 578| 234k| auto n = p.node()->inner(); 579| 234k| auto e = n + last; 580| 658k| for (; n != e; ++n) { ------------------ | Branch (580:16): [True: 423k, False: 234k] ------------------ 581| 423k| IMMER_PREFETCH(n + 1); 582| 423k| make_full_leaf_pos(*n).visit(v, args...); 583| 423k| } 584| 380k| } else { 585| 380k| auto n = p.node()->inner(); 586| 380k| auto e = n + last; 587| 380k| auto ss = p.shift() - B; 588| 603k| for (; n != e; ++n) ------------------ | Branch (588:16): [True: 222k, False: 380k] ------------------ 589| 222k| make_full_pos(*n, ss).visit(v, args...); 590| 380k| } 591| 615k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9first_subINS1_20concat_right_visitorISC_EEJRNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 1754| 606k| { 1755| 606k| auto child = node_->inner()[0]; 1756| 606k| auto child_size = relaxed_->d.sizes[0]; 1757| 606k| auto is_leaf = shift_ == BL; 1758| 606k| assert(child_size); 1759| 606k| return is_leaf ? make_leaf_sub_pos(child, child_size).visit(v, args...) ------------------ | Branch (1759:16): [True: 0, False: 606k] ------------------ 1760| 606k| : visit_maybe_relaxed_sub( 1761| 606k| child, shift_ - B, child_size, v, args...); 1762| 606k| } _ZNK5immer6detail4rbts8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5shiftEv: 105| 482k| shift_t shift() const { return 0; } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_20concat_right_visitorISC_EEJRNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EEEEEDcPT_jmT0_DpOT1_: 1830| 606k|{ 1831| 606k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 606k| if (relaxed) { ------------------ | Branch (1833:9): [True: 587k, False: 19.0k] ------------------ 1834| 587k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 587k| .visit(v, std::forward(args)...); 1837| 587k| } else { 1838| 19.0k| return make_regular_sub_pos(node, shift, size) 1839| 19.0k| .visit(v, std::forward(args)...); 1840| 19.0k| } 1841| 606k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_20concat_right_visitorISC_EEJRNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 1805| 587k| { 1806| 587k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 587k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_20concat_right_visitorISC_EEJRSD_RNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 1028| 19.0k| { 1029| 19.0k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 19.0k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8last_subINS1_19concat_left_visitorISC_EEJRNS1_8leaf_posISC_EERSD_EEEDcT_DpOT0_: 950| 183| { 951| 183| auto offset = count() - 1; 952| 183| auto child = node_->inner()[offset]; 953| 183| auto is_leaf = shift_ == BL; 954| 183| auto lsize = size_ - (size_t{offset} << shift_); 955| 183| return is_leaf ? make_leaf_sub_pos(child, lsize).visit(v, args...) ------------------ | Branch (955:16): [True: 0, False: 183] ------------------ 956| 183| : make_regular_sub_pos(child, shift_ - B, lsize) 957| 183| .visit(v, args...); 958| 183| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19concat_left_visitorISC_EEJRNS1_8leaf_posISC_EERSD_EEEDcT_DpOT0_: 1028| 259| { 1029| 259| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 259| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9first_subINS1_20concat_right_visitorISC_EEJRSD_RNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 962| 4.05k| { 963| 4.05k| auto is_leaf = shift_ == BL; 964| 4.05k| auto child = node_->inner()[0]; 965| 4.05k| auto is_full = size_ >= (size_t{1} << shift_); 966| 4.05k| return is_full ------------------ | Branch (966:16): [True: 4.05k, False: 0] ------------------ 967| 4.05k| ? (is_leaf ------------------ | Branch (967:23): [True: 0, False: 4.05k] ------------------ 968| 4.05k| ? make_full_leaf_pos(child).visit(v, args...) 969| 4.05k| : make_full_pos(child, shift_ - B).visit(v, args...)) 970| 4.05k| : (is_leaf ------------------ | Branch (970:23): [True: 0, False: 0] ------------------ 971| 0| ? make_leaf_sub_pos(child, size_).visit(v, args...) 972| 0| : make_regular_sub_pos(child, shift_ - B, size_) 973| 0| .visit(v, args...)); 974| 4.05k| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_20concat_right_visitorISC_EEJRNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 1397| 7.83k| { 1398| 7.83k| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 7.83k| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9first_subINS1_20concat_right_visitorISC_EEJRNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 1353| 3.78k| { 1354| 3.78k| auto is_leaf = shift_ == BL; 1355| 3.78k| auto child = node_->inner()[0]; 1356| 3.78k| return is_leaf ? make_full_leaf_pos(child).visit(v, args...) ------------------ | Branch (1356:16): [True: 0, False: 3.78k] ------------------ 1357| 3.78k| : make_full_pos(child, shift_ - B).visit(v, args...); 1358| 3.78k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8last_subINS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_8full_posISC_EEEEEDcT_DpOT0_: 950| 7.83k| { 951| 7.83k| auto offset = count() - 1; 952| 7.83k| auto child = node_->inner()[offset]; 953| 7.83k| auto is_leaf = shift_ == BL; 954| 7.83k| auto lsize = size_ - (size_t{offset} << shift_); 955| 7.83k| return is_leaf ? make_leaf_sub_pos(child, lsize).visit(v, args...) ------------------ | Branch (955:16): [True: 4.06k, False: 3.76k] ------------------ 956| 7.83k| : make_regular_sub_pos(child, shift_ - B, lsize) 957| 3.76k| .visit(v, args...); 958| 7.83k| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_8full_posISC_EEEEEDcT_DpOT0_: 143| 4.09k| { 144| 4.09k| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 4.09k| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14first_sub_leafINS1_20concat_right_visitorISC_EEJRNS1_12leaf_sub_posISC_EERNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 1362| 4.09k| { 1363| 4.09k| assert(shift_ == BL); 1364| 0| auto child = node_->inner()[0]; 1365| 4.09k| return make_full_leaf_pos(child).visit(v, args...); 1366| 4.09k| } _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_20concat_right_visitorISC_EEJRNS1_12leaf_sub_posISC_EERNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 205| 29.5k| { 206| 29.5k| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 29.5k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_8full_posISC_EEEEEDcT_DpOT0_: 1028| 3.77k| { 1029| 3.77k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 3.77k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8last_subINS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERSD_EEEDcT_DpOT0_: 950| 20.3k| { 951| 20.3k| auto offset = count() - 1; 952| 20.3k| auto child = node_->inner()[offset]; 953| 20.3k| auto is_leaf = shift_ == BL; 954| 20.3k| auto lsize = size_ - (size_t{offset} << shift_); 955| 20.3k| return is_leaf ? make_leaf_sub_pos(child, lsize).visit(v, args...) ------------------ | Branch (955:16): [True: 17.6k, False: 2.74k] ------------------ 956| 20.3k| : make_regular_sub_pos(child, shift_ - B, lsize) 957| 2.74k| .visit(v, args...); 958| 20.3k| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_15regular_sub_posISC_EEEEEDcT_DpOT0_: 143| 25.4k| { 144| 25.4k| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 25.4k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14first_sub_leafINS1_20concat_right_visitorISC_EEJRNS1_12leaf_sub_posISC_EERNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 978| 25.4k| { 979| 25.4k| assert(shift_ == BL); 980| 0| auto child = node_->inner()[0]; 981| 25.4k| auto is_full = size_ >= branches; 982| 25.4k| return is_full ? make_full_leaf_pos(child).visit(v, args...) ------------------ | Branch (982:16): [True: 25.4k, False: 0] ------------------ 983| 25.4k| : make_leaf_sub_pos(child, size_).visit(v, args...); 984| 25.4k| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_20concat_right_visitorISC_EEJRSD_RNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 143| 452k| { 144| 452k| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 452k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERSD_EEEDcT_DpOT0_: 1028| 4.02k| { 1029| 4.02k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 4.02k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8last_subINS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_11relaxed_posISC_EEEEEDcT_DpOT0_: 950| 586k| { 951| 586k| auto offset = count() - 1; 952| 586k| auto child = node_->inner()[offset]; 953| 586k| auto is_leaf = shift_ == BL; 954| 586k| auto lsize = size_ - (size_t{offset} << shift_); 955| 586k| return is_leaf ? make_leaf_sub_pos(child, lsize).visit(v, args...) ------------------ | Branch (955:16): [True: 213k, False: 373k] ------------------ 956| 586k| : make_regular_sub_pos(child, shift_ - B, lsize) 957| 373k| .visit(v, args...); 958| 586k| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_11relaxed_posISC_EEEEEDcT_DpOT0_: 143| 452k| { 144| 452k| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 452k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14first_sub_leafINS1_20concat_right_visitorISC_EEJRNS1_12leaf_sub_posISC_EERNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 1766| 452k| { 1767| 452k| assert(shift_ == BL); 1768| 0| auto child = node_->inner()[0]; 1769| 452k| auto child_size = relaxed_->d.sizes[0]; 1770| 452k| return make_leaf_sub_pos(child, child_size).visit(v, args...); 1771| 452k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_11relaxed_posISC_EEEEEDcT_DpOT0_: 1028| 604k| { 1029| 604k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 604k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13each_left_subINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEvT_DpOT0_: 1609| 5.89M| { 1610| 5.89M| each_left(v, relaxed_->d.count - 1, args...); 1611| 5.89M| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9each_leftINS1_34concat_rebalance_plan_fill_visitorEJRNS1_21concat_rebalance_planILj3ELj3EEEEEEvT_jDpOT0_: 1615| 5.89M| { 1616| 5.89M| auto p = node_->inner(); 1617| 5.89M| auto s = size_t{}; 1618| 5.89M| if (shift_ == BL) { ------------------ | Branch (1618:13): [True: 247k, False: 5.64M] ------------------ 1619| 1.81M| for (auto i = count_t{0}; i < n; ++i) { ------------------ | Branch (1619:39): [True: 1.56M, False: 247k] ------------------ 1620| 1.56M| IMMER_PREFETCH(p + i + 1); 1621| 1.56M| make_leaf_sub_pos(p[i], relaxed_->d.sizes[i] - s) 1622| 1.56M| .visit(v, args...); 1623| 1.56M| s = relaxed_->d.sizes[i]; 1624| 1.56M| assert(s); 1625| 1.56M| } 1626| 5.64M| } else { 1627| 5.64M| auto ss = shift_ - B; 1628| 26.2M| for (auto i = count_t{0}; i < n; ++i) { ------------------ | Branch (1628:39): [True: 20.5M, False: 5.64M] ------------------ 1629| 20.5M| visit_maybe_relaxed_sub( 1630| 20.5M| p[i], ss, relaxed_->d.sizes[i] - s, v, args...); 1631| 20.5M| s = relaxed_->d.sizes[i]; 1632| 20.5M| assert(s); 1633| 20.5M| } 1634| 5.64M| } 1635| 5.89M| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13each_left_subINS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEvT_DpOT0_: 1609| 5.89M| { 1610| 5.89M| each_left(v, relaxed_->d.count - 1, args...); 1611| 5.89M| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9each_leftINS1_21concat_merger_visitorEJRNS1_13concat_mergerISC_EEEEEvT_jDpOT0_: 1615| 5.89M| { 1616| 5.89M| auto p = node_->inner(); 1617| 5.89M| auto s = size_t{}; 1618| 5.89M| if (shift_ == BL) { ------------------ | Branch (1618:13): [True: 247k, False: 5.64M] ------------------ 1619| 1.81M| for (auto i = count_t{0}; i < n; ++i) { ------------------ | Branch (1619:39): [True: 1.56M, False: 247k] ------------------ 1620| 1.56M| IMMER_PREFETCH(p + i + 1); 1621| 1.56M| make_leaf_sub_pos(p[i], relaxed_->d.sizes[i] - s) 1622| 1.56M| .visit(v, args...); 1623| 1.56M| s = relaxed_->d.sizes[i]; 1624| 1.56M| assert(s); 1625| 1.56M| } 1626| 5.64M| } else { 1627| 5.64M| auto ss = shift_ - B; 1628| 26.2M| for (auto i = count_t{0}; i < n; ++i) { ------------------ | Branch (1628:39): [True: 20.5M, False: 5.64M] ------------------ 1629| 20.5M| visit_maybe_relaxed_sub( 1630| 20.5M| p[i], ss, relaxed_->d.sizes[i] - s, v, args...); 1631| 20.5M| s = relaxed_->d.sizes[i]; 1632| 20.5M| assert(s); 1633| 20.5M| } 1634| 5.64M| } 1635| 5.89M| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9first_subINS1_20concat_right_visitorISC_EEJRSD_RNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 1754| 3.97M| { 1755| 3.97M| auto child = node_->inner()[0]; 1756| 3.97M| auto child_size = relaxed_->d.sizes[0]; 1757| 3.97M| auto is_leaf = shift_ == BL; 1758| 3.97M| assert(child_size); 1759| 3.97M| return is_leaf ? make_leaf_sub_pos(child, child_size).visit(v, args...) ------------------ | Branch (1759:16): [True: 0, False: 3.97M] ------------------ 1760| 3.97M| : visit_maybe_relaxed_sub( 1761| 3.97M| child, shift_ - B, child_size, v, args...); 1762| 3.97M| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_20concat_right_visitorISC_EEJRNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EEEEEDcPT_jmT0_DpOT1_: 1830| 3.97M|{ 1831| 3.97M| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 3.97M| if (relaxed) { ------------------ | Branch (1833:9): [True: 3.96M, False: 4.58k] ------------------ 1834| 3.96M| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 3.96M| .visit(v, std::forward(args)...); 1837| 3.96M| } else { 1838| 4.58k| return make_regular_sub_pos(node, shift, size) 1839| 4.58k| .visit(v, std::forward(args)...); 1840| 4.58k| } 1841| 3.97M|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_20concat_right_visitorISC_EEJRSD_RNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 1805| 3.96M| { 1806| 3.96M| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 3.96M| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_20concat_right_visitorISC_EEJRNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 1028| 4.58k| { 1029| 4.58k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 4.58k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8last_subINS1_19concat_left_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_15regular_sub_posISC_EEEEEDcT_DpOT0_: 1742| 13.0k| { 1743| 13.0k| auto offset = relaxed_->d.count - 1; 1744| 13.0k| auto child = node_->inner()[offset]; 1745| 13.0k| auto child_size = size(offset); 1746| 13.0k| auto is_leaf = shift_ == BL; 1747| 13.0k| return is_leaf ? make_leaf_sub_pos(child, child_size).visit(v, args...) ------------------ | Branch (1747:16): [True: 0, False: 13.0k] ------------------ 1748| 13.0k| : visit_maybe_relaxed_sub( 1749| 13.0k| child, shift_ - B, child_size, v, args...); 1750| 13.0k| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_19concat_left_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_15regular_sub_posISC_EEEEEDcPT_jmT0_DpOT1_: 1830| 13.0k|{ 1831| 13.0k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 13.0k| if (relaxed) { ------------------ | Branch (1833:9): [True: 12.9k, False: 76] ------------------ 1834| 12.9k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 12.9k| .visit(v, std::forward(args)...); 1837| 12.9k| } else { 1838| 76| return make_regular_sub_pos(node, shift, size) 1839| 76| .visit(v, std::forward(args)...); 1840| 76| } 1841| 13.0k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19concat_left_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_15regular_sub_posISC_EEEEEDcT_DpOT0_: 1805| 12.9k| { 1806| 12.9k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 12.9k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9first_subINS1_20concat_right_visitorISC_EEJRNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 962| 32| { 963| 32| auto is_leaf = shift_ == BL; 964| 32| auto child = node_->inner()[0]; 965| 32| auto is_full = size_ >= (size_t{1} << shift_); 966| 32| return is_full ------------------ | Branch (966:16): [True: 32, False: 0] ------------------ 967| 32| ? (is_leaf ------------------ | Branch (967:23): [True: 0, False: 32] ------------------ 968| 32| ? make_full_leaf_pos(child).visit(v, args...) 969| 32| : make_full_pos(child, shift_ - B).visit(v, args...)) 970| 32| : (is_leaf ------------------ | Branch (970:23): [True: 0, False: 0] ------------------ 971| 0| ? make_leaf_sub_pos(child, size_).visit(v, args...) 972| 0| : make_regular_sub_pos(child, shift_ - B, size_) 973| 0| .visit(v, args...)); 974| 32| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_20concat_right_visitorISC_EEJRNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 1397| 35| { 1398| 35| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 35| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9first_subINS1_20concat_right_visitorISC_EEJRNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 1353| 3| { 1354| 3| auto is_leaf = shift_ == BL; 1355| 3| auto child = node_->inner()[0]; 1356| 3| return is_leaf ? make_full_leaf_pos(child).visit(v, args...) ------------------ | Branch (1356:16): [True: 0, False: 3] ------------------ 1357| 3| : make_full_pos(child, shift_ - B).visit(v, args...); 1358| 3| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8last_subINS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_8full_posISC_EEEEEDcT_DpOT0_: 1742| 34| { 1743| 34| auto offset = relaxed_->d.count - 1; 1744| 34| auto child = node_->inner()[offset]; 1745| 34| auto child_size = size(offset); 1746| 34| auto is_leaf = shift_ == BL; 1747| 34| return is_leaf ? make_leaf_sub_pos(child, child_size).visit(v, args...) ------------------ | Branch (1747:16): [True: 24, False: 10] ------------------ 1748| 34| : visit_maybe_relaxed_sub( 1749| 10| child, shift_ - B, child_size, v, args...); 1750| 34| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_8full_posISC_EEEEEDcPT_jmT0_DpOT1_: 1830| 10|{ 1831| 10| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 10| if (relaxed) { ------------------ | Branch (1833:9): [True: 2, False: 8] ------------------ 1834| 2| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 2| .visit(v, std::forward(args)...); 1837| 8| } else { 1838| 8| return make_regular_sub_pos(node, shift, size) 1839| 8| .visit(v, std::forward(args)...); 1840| 8| } 1841| 10|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_8full_posISC_EEEEEDcT_DpOT0_: 1805| 2| { 1806| 2| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 2| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8last_subINS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_15regular_sub_posISC_EEEEEDcT_DpOT0_: 1742| 9.13k| { 1743| 9.13k| auto offset = relaxed_->d.count - 1; 1744| 9.13k| auto child = node_->inner()[offset]; 1745| 9.13k| auto child_size = size(offset); 1746| 9.13k| auto is_leaf = shift_ == BL; 1747| 9.13k| return is_leaf ? make_leaf_sub_pos(child, child_size).visit(v, args...) ------------------ | Branch (1747:16): [True: 7.83k, False: 1.30k] ------------------ 1748| 9.13k| : visit_maybe_relaxed_sub( 1749| 1.30k| child, shift_ - B, child_size, v, args...); 1750| 9.13k| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_15regular_sub_posISC_EEEEEDcPT_jmT0_DpOT1_: 1830| 1.30k|{ 1831| 1.30k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 1.30k| if (relaxed) { ------------------ | Branch (1833:9): [True: 25, False: 1.27k] ------------------ 1834| 25| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 25| .visit(v, std::forward(args)...); 1837| 1.27k| } else { 1838| 1.27k| return make_regular_sub_pos(node, shift, size) 1839| 1.27k| .visit(v, std::forward(args)...); 1840| 1.27k| } 1841| 1.30k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_15regular_sub_posISC_EEEEEDcT_DpOT0_: 1805| 25| { 1806| 25| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 25| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE8last_subINS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERSD_EEEDcT_DpOT0_: 1742| 4.42M| { 1743| 4.42M| auto offset = relaxed_->d.count - 1; 1744| 4.42M| auto child = node_->inner()[offset]; 1745| 4.42M| auto child_size = size(offset); 1746| 4.42M| auto is_leaf = shift_ == BL; 1747| 4.42M| return is_leaf ? make_leaf_sub_pos(child, child_size).visit(v, args...) ------------------ | Branch (1747:16): [True: 239k, False: 4.18M] ------------------ 1748| 4.42M| : visit_maybe_relaxed_sub( 1749| 4.18M| child, shift_ - B, child_size, v, args...); 1750| 4.42M| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERNS1_11relaxed_posISC_EEEEEDcPT_jmT0_DpOT1_: 1830| 4.18M|{ 1831| 4.18M| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 4.18M| if (relaxed) { ------------------ | Branch (1833:9): [True: 3.95M, False: 231k] ------------------ 1834| 3.95M| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 3.95M| .visit(v, std::forward(args)...); 1837| 3.95M| } else { 1838| 231k| return make_regular_sub_pos(node, shift, size) 1839| 231k| .visit(v, std::forward(args)...); 1840| 231k| } 1841| 4.18M|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_19concat_both_visitorISC_EEJRNS1_8leaf_posISC_EERSD_EEEDcT_DpOT0_: 1805| 3.95M| { 1806| 3.95M| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 3.95M| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_26concat_trees_right_visitorISC_EEJRNS1_11relaxed_posISC_EERNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 1028| 4.63k| { 1029| 4.63k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 4.63k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_25concat_trees_left_visitorISC_EEJNS1_8leaf_posISC_EERPSC_RjRmEEEDcT_DpOT0_: 1028| 1.82k| { 1029| 1.82k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 1.82k| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_26concat_trees_right_visitorISC_EEJRNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EEEEEDcPT_jmT0_DpOT1_: 1830| 1.82k|{ 1831| 1.82k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 1.82k| if (relaxed) { ------------------ | Branch (1833:9): [True: 579, False: 1.24k] ------------------ 1834| 579| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 579| .visit(v, std::forward(args)...); 1837| 1.24k| } else { 1838| 1.24k| return make_regular_sub_pos(node, shift, size) 1839| 1.24k| .visit(v, std::forward(args)...); 1840| 1.24k| } 1841| 1.82k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_26concat_trees_right_visitorISC_EEJRNS1_15regular_sub_posISC_EERNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 1805| 579| { 1806| 579| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 579| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_26concat_trees_right_visitorISC_EEJRSD_RNS1_8leaf_posISC_EEEEEDcT_DpOT0_: 1028| 1.24k| { 1029| 1.24k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 1.24k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_21push_tail_mut_visitorISC_Lb1EEEJRNSA_5applyIS7_E4type4editERPSC_RjEEEDcT_DpOT0_: 1805| 170k| { 1806| 170k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 170k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11last_oh_cshINS1_21push_tail_mut_visitorISC_Lb1EEEJRNSA_5applyIS7_E4type4editERPSC_RjEEEDcT_jmDpOT0_: 1729| 170k| { 1730| 170k| assert(offset_hint == count() - 1); 1731| 0| assert(child_size_hint == size(offset_hint)); 1732| 0| auto child = node_->inner()[offset_hint]; 1733| 170k| auto is_leaf = shift_ == BL; 1734| 170k| return is_leaf ------------------ | Branch (1734:16): [True: 0, False: 170k] ------------------ 1735| 170k| ? make_leaf_sub_pos(child, child_size_hint).visit(v, args...) 1736| 170k| : visit_maybe_relaxed_sub( 1737| 170k| child, shift_ - B, child_size_hint, v, args...); 1738| 170k| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_21push_tail_mut_visitorISC_Lb1EEEJRNSA_5applyIS7_E4type4editERPSC_RjEEEDcPT_jmT0_DpOT1_: 1830| 170k|{ 1831| 170k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 170k| if (relaxed) { ------------------ | Branch (1833:9): [True: 42.2k, False: 127k] ------------------ 1834| 42.2k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 42.2k| .visit(v, std::forward(args)...); 1837| 127k| } else { 1838| 127k| return make_regular_sub_pos(node, shift, size) 1839| 127k| .visit(v, std::forward(args)...); 1840| 127k| } 1841| 170k|} _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_21push_tail_mut_visitorISC_Lb1EEEJRNSA_5applyIS7_E4type4editERPSC_RjEEEDcT_DpOT0_: 1028| 127k| { 1029| 127k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 127k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7last_ohINS1_21push_tail_mut_visitorISC_Lb1EEEJRNSA_5applyIS7_E4type4editERPSC_EEEDcT_jDpOT0_: 944| 261k| { 945| 261k| return last_oh_regular(*this, v, offset_hint, args...); 946| 261k| } _ZN5immer6detail4rbts15last_oh_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_21push_tail_mut_visitorISD_Lb1EEEJRNSB_5applyIS8_E4type4editERPSD_EEEDcOT_T0_jDpOT1_: 675| 261k|{ 676| 261k| assert(offset_hint == p.count() - 1); 677| 0| constexpr auto B = bits; 678| 261k| constexpr auto BL = bits_leaf; 679| 261k| auto child = p.node()->inner()[offset_hint]; 680| 261k| auto is_leaf = p.shift() == BL; 681| 261k| return is_leaf ? make_leaf_pos(child, p.size()).visit(v, args...) ------------------ | Branch (681:12): [True: 0, False: 261k] ------------------ 682| 261k| : make_regular_pos(child, p.shift() - B, p.size()) 683| 261k| .visit(v, args...); 684| 261k|} _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_21push_tail_mut_visitorISC_Lb1EEEJRNSA_5applyIS7_E4type4editERPSC_EEEDcT_DpOT0_: 334| 816k| { 335| 816k| return Visitor::visit_regular(*this, std::forward(args)...); 336| 816k| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7last_ohINS1_21push_tail_mut_visitorISC_Lb1EEEJRNSA_5applyIS7_E4type4editERPSC_EEEDcT_jDpOT0_: 328| 554k| { 329| 554k| return last_oh_regular(*this, v, offset_hint, args...); 330| 554k| } _ZN5immer6detail4rbts15last_oh_regularIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_21push_tail_mut_visitorISD_Lb1EEEJRNSB_5applyIS8_E4type4editERPSD_EEEDcOT_T0_jDpOT1_: 675| 554k|{ 676| 554k| assert(offset_hint == p.count() - 1); 677| 0| constexpr auto B = bits; 678| 554k| constexpr auto BL = bits_leaf; 679| 554k| auto child = p.node()->inner()[offset_hint]; 680| 554k| auto is_leaf = p.shift() == BL; 681| 554k| return is_leaf ? make_leaf_pos(child, p.size()).visit(v, args...) ------------------ | Branch (681:12): [True: 0, False: 554k] ------------------ 682| 554k| : make_regular_pos(child, p.shift() - B, p.size()) 683| 554k| .visit(v, args...); 684| 554k|} _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7last_ohINS1_21push_tail_mut_visitorISC_Lb0EEEJRNSA_5applyIS7_E4type4editERPSC_EEEDcT_jDpOT0_: 328| 532| { 329| 532| return last_oh_regular(*this, v, offset_hint, args...); 330| 532| } _ZN5immer6detail4rbts15last_oh_regularIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_21push_tail_mut_visitorISD_Lb0EEEJRNSB_5applyIS8_E4type4editERPSD_EEEDcOT_T0_jDpOT1_: 675| 532|{ 676| 532| assert(offset_hint == p.count() - 1); 677| 0| constexpr auto B = bits; 678| 532| constexpr auto BL = bits_leaf; 679| 532| auto child = p.node()->inner()[offset_hint]; 680| 532| auto is_leaf = p.shift() == BL; 681| 532| return is_leaf ? make_leaf_pos(child, p.size()).visit(v, args...) ------------------ | Branch (681:12): [True: 0, False: 532] ------------------ 682| 532| : make_regular_pos(child, p.shift() - B, p.size()) 683| 532| .visit(v, args...); 684| 532|} _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_21push_tail_mut_visitorISC_Lb0EEEJRNSA_5applyIS7_E4type4editERPSC_EEEDcT_DpOT0_: 334| 795| { 335| 795| return Visitor::visit_regular(*this, std::forward(args)...); 336| 795| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7last_ohINS1_21push_tail_mut_visitorISC_Lb0EEEJRNSA_5applyIS7_E4type4editERPSC_EEEDcT_jDpOT0_: 944| 263| { 945| 263| return last_oh_regular(*this, v, offset_hint, args...); 946| 263| } _ZN5immer6detail4rbts15last_oh_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_21push_tail_mut_visitorISD_Lb0EEEJRNSB_5applyIS8_E4type4editERPSD_EEEDcOT_T0_jDpOT1_: 675| 263|{ 676| 263| assert(offset_hint == p.count() - 1); 677| 0| constexpr auto B = bits; 678| 263| constexpr auto BL = bits_leaf; 679| 263| auto child = p.node()->inner()[offset_hint]; 680| 263| auto is_leaf = p.shift() == BL; 681| 263| return is_leaf ? make_leaf_pos(child, p.size()).visit(v, args...) ------------------ | Branch (681:12): [True: 0, False: 263] ------------------ 682| 263| : make_regular_pos(child, p.shift() - B, p.size()) 683| 263| .visit(v, args...); 684| 263|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE11last_oh_cshINS1_21push_tail_mut_visitorISC_Lb0EEEJRNSA_5applyIS7_E4type4editERPSC_RjEEEDcT_jmDpOT0_: 1729| 120| { 1730| 120| assert(offset_hint == count() - 1); 1731| 0| assert(child_size_hint == size(offset_hint)); 1732| 0| auto child = node_->inner()[offset_hint]; 1733| 120| auto is_leaf = shift_ == BL; 1734| 120| return is_leaf ------------------ | Branch (1734:16): [True: 0, False: 120] ------------------ 1735| 120| ? make_leaf_sub_pos(child, child_size_hint).visit(v, args...) 1736| 120| : visit_maybe_relaxed_sub( 1737| 120| child, shift_ - B, child_size_hint, v, args...); 1738| 120| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_21push_tail_mut_visitorISC_Lb0EEEJRNSA_5applyIS7_E4type4editERPSC_RjEEEDcPT_jmT0_DpOT1_: 1830| 120|{ 1831| 120| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 120| if (relaxed) { ------------------ | Branch (1833:9): [True: 97, False: 23] ------------------ 1834| 97| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 97| .visit(v, std::forward(args)...); 1837| 97| } else { 1838| 23| return make_regular_sub_pos(node, shift, size) 1839| 23| .visit(v, std::forward(args)...); 1840| 23| } 1841| 120|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_21push_tail_mut_visitorISC_Lb0EEEJRNSA_5applyIS7_E4type4editERPSC_RjEEEDcT_DpOT0_: 1805| 97| { 1806| 97| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 97| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_21push_tail_mut_visitorISC_Lb0EEEJRNSA_5applyIS7_E4type4editERPSC_RjEEEDcT_DpOT0_: 1028| 23| { 1029| 23| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 23| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_21push_tail_mut_visitorISC_Lb1EEEJRNSA_5applyIS7_E4type4editERPSC_EEEDcT_DpOT0_: 1028| 136k| { 1029| 136k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 136k| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_15get_mut_visitorISC_EEJRmRNSA_5applyIS7_E4type4editEPPSC_EEEDcPT_jmT0_DpOT1_: 1830| 4.14k|{ 1831| 4.14k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 4.14k| if (relaxed) { ------------------ | Branch (1833:9): [True: 3.69k, False: 450] ------------------ 1834| 3.69k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 3.69k| .visit(v, std::forward(args)...); 1837| 3.69k| } else { 1838| 450| return make_regular_sub_pos(node, shift, size) 1839| 450| .visit(v, std::forward(args)...); 1840| 450| } 1841| 4.14k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_15get_mut_visitorISC_EEJRmRNSA_5applyIS7_E4type4editEPPSC_EEEDcT_DpOT0_: 1805| 3.69k| { 1806| 3.69k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 3.69k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_15get_mut_visitorISC_EEJRNSA_5applyIS7_E4type4editEPPSC_EEEDcT_mjDpOT0_: 1678| 16.4k| { 1679| 16.4k| assert(offset_hint == index(idx)); 1680| 16.4k| auto left_size = offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0; ------------------ | Branch (1680:26): [True: 1.64k, False: 14.8k] ------------------ 1681| 16.4k| return towards_oh_sbh(v, idx, offset_hint, left_size, args...); 1682| 16.4k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_oh_sbhINS1_15get_mut_visitorISC_EEJRNSA_5applyIS7_E4type4editERPPSC_EEEDcT_mjmDpOT0_: 1690| 16.4k| { 1691| 16.4k| return towards_sub_oh_sbh(v, idx, offset_hint, left_size_hint, args...); 1692| 16.4k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE18towards_sub_oh_sbhINS1_15get_mut_visitorISC_EEJRNSA_5applyIS7_E4type4editERPPSC_EEEDcT_mjmDpOT0_: 1709| 16.4k| { 1710| 16.4k| assert(offset_hint == index(idx)); 1711| 0| assert(left_size_hint == 1712| 16.4k| (offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0)); 1713| 0| auto child = node_->inner()[offset_hint]; 1714| 16.4k| auto is_leaf = shift_ == BL; 1715| 16.4k| auto next_size = relaxed_->d.sizes[offset_hint] - left_size_hint; 1716| 16.4k| auto next_idx = idx - left_size_hint; 1717| 16.4k| return is_leaf ------------------ | Branch (1717:16): [True: 2.06k, False: 14.3k] ------------------ 1718| 16.4k| ? make_leaf_sub_pos(child, next_size) 1719| 2.06k| .visit(v, next_idx, args...) 1720| 16.4k| : visit_maybe_relaxed_sub( 1721| 14.3k| child, shift_ - B, next_size, v, next_idx, args...); 1722| 16.4k| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_15get_mut_visitorISC_EEJRmRNSA_5applyIS7_E4type4editERPPSC_EEEDcT_DpOT0_: 143| 2.06k| { 144| 2.06k| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 2.06k| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_15get_mut_visitorISC_EEJRmRNSA_5applyIS7_E4type4editERPPSC_EEEDcPT_jmT0_DpOT1_: 1830| 14.3k|{ 1831| 14.3k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 14.3k| if (relaxed) { ------------------ | Branch (1833:9): [True: 12.7k, False: 1.62k] ------------------ 1834| 12.7k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 12.7k| .visit(v, std::forward(args)...); 1837| 12.7k| } else { 1838| 1.62k| return make_regular_sub_pos(node, shift, size) 1839| 1.62k| .visit(v, std::forward(args)...); 1840| 1.62k| } 1841| 14.3k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_15get_mut_visitorISC_EEJRmRNSA_5applyIS7_E4type4editERPPSC_EEEDcT_DpOT0_: 1805| 12.7k| { 1806| 12.7k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 12.7k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_15get_mut_visitorISC_EEJRmRNSA_5applyIS7_E4type4editERPPSC_EEEDcT_DpOT0_: 1028| 1.62k| { 1029| 1.62k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 1.62k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13towards_oh_chINS1_15get_mut_visitorISC_EEJRNSA_5applyIS7_E4type4editEPPSC_EEEDcT_mjjDpOT0_: 930| 2.07k| { 931| 2.07k| return towards_oh_ch_regular( 932| 2.07k| *this, v, idx, offset_hint, count(), args...); 933| 2.07k| } _ZN5immer6detail4rbts21towards_oh_ch_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_15get_mut_visitorISD_EEJRNSB_5applyIS8_E4type4editERPPSD_EEEDcOT_T0_mjjDpOT1_: 630| 2.07k|{ 631| 2.07k| constexpr auto B = bits; 632| 2.07k| constexpr auto BL = bits_leaf; 633| 2.07k| assert(offset_hint == p.index(idx)); 634| 0| assert(count_hint == p.count()); 635| 0| auto is_leaf = p.shift() == BL; 636| 2.07k| auto child = p.node()->inner()[offset_hint]; 637| 2.07k| auto is_full = offset_hint + 1 != count_hint; 638| 2.07k| return is_full ------------------ | Branch (638:12): [True: 1.79k, False: 283] ------------------ 639| 2.07k| ? (is_leaf ? make_full_leaf_pos(child).visit(v, idx, args...) ------------------ | Branch (639:19): [True: 1.43k, False: 358] ------------------ 640| 1.79k| : make_full_pos(child, p.shift() - B) 641| 358| .visit(v, idx, args...)) 642| 2.07k| : (is_leaf ------------------ | Branch (642:19): [True: 209, False: 74] ------------------ 643| 283| ? make_leaf_pos(child, p.size()).visit(v, idx, args...) 644| 283| : make_regular_pos(child, p.shift() - B, p.size()) 645| 74| .visit(v, idx, args...)); 646| 2.07k|} _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_15get_mut_visitorISC_EEJRmRNSA_5applyIS7_E4type4editERPPSC_EEEDcT_DpOT0_: 205| 1.85k| { 206| 1.85k| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 1.85k| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_15get_mut_visitorISC_EEJRmRNSA_5applyIS7_E4type4editERPPSC_EEEDcT_DpOT0_: 1397| 685| { 1398| 685| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 685| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13towards_oh_chINS1_15get_mut_visitorISC_EEJRNSA_5applyIS7_E4type4editEPPSC_EEEDcT_mjjDpOT0_: 1321| 685| { 1322| 685| return towards_oh(v, idx, offset_hint, args...); 1323| 685| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_15get_mut_visitorISC_EEJRNSA_5applyIS7_E4type4editERPPSC_EEEDcT_mjDpOT0_: 1328| 685| { 1329| 685| assert(offset_hint == index(idx)); 1330| 0| auto is_leaf = shift_ == BL; 1331| 685| auto child = node_->inner()[offset_hint]; 1332| 685| return is_leaf ------------------ | Branch (1332:16): [True: 409, False: 276] ------------------ 1333| 685| ? make_full_leaf_pos(child).visit(v, idx, args...) 1334| 685| : make_full_pos(child, shift_ - B).visit(v, idx, args...); 1335| 685| } _ZN5immer6detail4rbts8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_15get_mut_visitorISC_EEJRmRNSA_5applyIS7_E4type4editERPPSC_EEEDcT_DpOT0_: 111| 224| { 112| 224| return Visitor::visit_leaf(*this, std::forward(args)...); 113| 224| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_15get_mut_visitorISC_EEJRmRNSA_5applyIS7_E4type4editERPPSC_EEEDcT_DpOT0_: 334| 74| { 335| 74| return Visitor::visit_regular(*this, std::forward(args)...); 336| 74| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13towards_oh_chINS1_15get_mut_visitorISC_EEJRNSA_5applyIS7_E4type4editEPPSC_EEEDcT_mjjDpOT0_: 314| 74| { 315| 74| return towards_oh_ch_regular( 316| 74| *this, v, idx, offset_hint, count(), args...); 317| 74| } _ZN5immer6detail4rbts21towards_oh_ch_regularIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_15get_mut_visitorISD_EEJRNSB_5applyIS8_E4type4editERPPSD_EEEDcOT_T0_mjjDpOT1_: 630| 74|{ 631| 74| constexpr auto B = bits; 632| 74| constexpr auto BL = bits_leaf; 633| 74| assert(offset_hint == p.index(idx)); 634| 0| assert(count_hint == p.count()); 635| 0| auto is_leaf = p.shift() == BL; 636| 74| auto child = p.node()->inner()[offset_hint]; 637| 74| auto is_full = offset_hint + 1 != count_hint; 638| 74| return is_full ------------------ | Branch (638:12): [True: 59, False: 15] ------------------ 639| 74| ? (is_leaf ? make_full_leaf_pos(child).visit(v, idx, args...) ------------------ | Branch (639:19): [True: 8, False: 51] ------------------ 640| 59| : make_full_pos(child, p.shift() - B) 641| 51| .visit(v, idx, args...)) 642| 74| : (is_leaf ------------------ | Branch (642:19): [True: 15, False: 0] ------------------ 643| 15| ? make_leaf_pos(child, p.size()).visit(v, idx, args...) 644| 15| : make_regular_pos(child, p.shift() - B, p.size()) 645| 0| .visit(v, idx, args...)); 646| 74|} _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_15get_mut_visitorISC_EEJRmRNSA_5applyIS7_E4type4editEPPSC_EEEDcT_DpOT0_: 1028| 450| { 1029| 450| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 450| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_23slice_right_mut_visitorISC_Lb1ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcPT_jmT0_DpOT1_: 1830| 41.2k|{ 1831| 41.2k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 41.2k| if (relaxed) { ------------------ | Branch (1833:9): [True: 40.8k, False: 396] ------------------ 1834| 40.8k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 40.8k| .visit(v, std::forward(args)...); 1837| 40.8k| } else { 1838| 396| return make_regular_sub_pos(node, shift, size) 1839| 396| .visit(v, std::forward(args)...); 1840| 396| } 1841| 41.2k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb1ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1805| 40.8k| { 1806| 40.8k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 40.8k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_23slice_right_mut_visitorISC_Lb1ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 1678| 33.7k| { 1679| 33.7k| assert(offset_hint == index(idx)); 1680| 33.7k| auto left_size = offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0; ------------------ | Branch (1680:26): [True: 0, False: 33.7k] ------------------ 1681| 33.7k| return towards_oh_sbh(v, idx, offset_hint, left_size, args...); 1682| 33.7k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_oh_sbhINS1_23slice_right_mut_visitorISC_Lb1ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjmDpOT0_: 1690| 33.7k| { 1691| 33.7k| return towards_sub_oh_sbh(v, idx, offset_hint, left_size_hint, args...); 1692| 33.7k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE18towards_sub_oh_sbhINS1_23slice_right_mut_visitorISC_Lb1ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjmDpOT0_: 1709| 33.7k| { 1710| 33.7k| assert(offset_hint == index(idx)); 1711| 0| assert(left_size_hint == 1712| 33.7k| (offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0)); 1713| 0| auto child = node_->inner()[offset_hint]; 1714| 33.7k| auto is_leaf = shift_ == BL; 1715| 33.7k| auto next_size = relaxed_->d.sizes[offset_hint] - left_size_hint; 1716| 33.7k| auto next_idx = idx - left_size_hint; 1717| 33.7k| return is_leaf ------------------ | Branch (1717:16): [True: 75, False: 33.6k] ------------------ 1718| 33.7k| ? make_leaf_sub_pos(child, next_size) 1719| 75| .visit(v, next_idx, args...) 1720| 33.7k| : visit_maybe_relaxed_sub( 1721| 33.6k| child, shift_ - B, next_size, v, next_idx, args...); 1722| 33.7k| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb1ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 143| 75| { 144| 75| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 75| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_23slice_right_mut_visitorISC_Lb1ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 1678| 10.5k| { 1679| 10.5k| assert(offset_hint == index(idx)); 1680| 10.5k| auto left_size = offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0; ------------------ | Branch (1680:26): [True: 0, False: 10.5k] ------------------ 1681| 10.5k| return towards_oh_sbh(v, idx, offset_hint, left_size, args...); 1682| 10.5k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_oh_sbhINS1_23slice_right_mut_visitorISC_Lb1ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjmDpOT0_: 1690| 10.5k| { 1691| 10.5k| return towards_sub_oh_sbh(v, idx, offset_hint, left_size_hint, args...); 1692| 10.5k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE18towards_sub_oh_sbhINS1_23slice_right_mut_visitorISC_Lb1ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjmDpOT0_: 1709| 10.5k| { 1710| 10.5k| assert(offset_hint == index(idx)); 1711| 0| assert(left_size_hint == 1712| 10.5k| (offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0)); 1713| 0| auto child = node_->inner()[offset_hint]; 1714| 10.5k| auto is_leaf = shift_ == BL; 1715| 10.5k| auto next_size = relaxed_->d.sizes[offset_hint] - left_size_hint; 1716| 10.5k| auto next_idx = idx - left_size_hint; 1717| 10.5k| return is_leaf ------------------ | Branch (1717:16): [True: 374, False: 10.1k] ------------------ 1718| 10.5k| ? make_leaf_sub_pos(child, next_size) 1719| 374| .visit(v, next_idx, args...) 1720| 10.5k| : visit_maybe_relaxed_sub( 1721| 10.1k| child, shift_ - B, next_size, v, next_idx, args...); 1722| 10.5k| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb1ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 143| 374| { 144| 374| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 374| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_23slice_right_mut_visitorISC_Lb1ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcPT_jmT0_DpOT1_: 1830| 10.1k|{ 1831| 10.1k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 10.1k| if (relaxed) { ------------------ | Branch (1833:9): [True: 10.1k, False: 87] ------------------ 1834| 10.1k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 10.1k| .visit(v, std::forward(args)...); 1837| 10.1k| } else { 1838| 87| return make_regular_sub_pos(node, shift, size) 1839| 87| .visit(v, std::forward(args)...); 1840| 87| } 1841| 10.1k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb1ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1805| 10.1k| { 1806| 10.1k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 10.1k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb1ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1028| 87| { 1029| 87| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 87| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_23slice_right_mut_visitorISC_Lb1ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 919| 249| { 920| 249| return towards_oh_ch_regular( 921| 249| *this, v, idx, offset_hint, count(), args...); 922| 249| } _ZN5immer6detail4rbts21towards_oh_ch_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_23slice_right_mut_visitorISD_Lb1ELb0EEEJRNSB_5applyIS8_E4type4editEEEEDcOT_T0_mjjDpOT1_: 630| 249|{ 631| 249| constexpr auto B = bits; 632| 249| constexpr auto BL = bits_leaf; 633| 249| assert(offset_hint == p.index(idx)); 634| 0| assert(count_hint == p.count()); 635| 0| auto is_leaf = p.shift() == BL; 636| 249| auto child = p.node()->inner()[offset_hint]; 637| 249| auto is_full = offset_hint + 1 != count_hint; 638| 249| return is_full ------------------ | Branch (638:12): [True: 172, False: 77] ------------------ 639| 249| ? (is_leaf ? make_full_leaf_pos(child).visit(v, idx, args...) ------------------ | Branch (639:19): [True: 130, False: 42] ------------------ 640| 172| : make_full_pos(child, p.shift() - B) 641| 42| .visit(v, idx, args...)) 642| 249| : (is_leaf ------------------ | Branch (642:19): [True: 77, False: 0] ------------------ 643| 77| ? make_leaf_pos(child, p.size()).visit(v, idx, args...) 644| 77| : make_regular_pos(child, p.shift() - B, p.size()) 645| 0| .visit(v, idx, args...)); 646| 249|} _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb1ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 205| 151| { 206| 151| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 151| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb1ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1397| 69| { 1398| 69| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 69| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_23slice_right_mut_visitorISC_Lb1ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 1328| 48| { 1329| 48| assert(offset_hint == index(idx)); 1330| 0| auto is_leaf = shift_ == BL; 1331| 48| auto child = node_->inner()[offset_hint]; 1332| 48| return is_leaf ------------------ | Branch (1332:16): [True: 21, False: 27] ------------------ 1333| 48| ? make_full_leaf_pos(child).visit(v, idx, args...) 1334| 48| : make_full_pos(child, shift_ - B).visit(v, idx, args...); 1335| 48| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_23slice_right_mut_visitorISC_Lb0ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 1328| 23| { 1329| 23| assert(offset_hint == index(idx)); 1330| 0| auto is_leaf = shift_ == BL; 1331| 23| auto child = node_->inner()[offset_hint]; 1332| 23| return is_leaf ------------------ | Branch (1332:16): [True: 7, False: 16] ------------------ 1333| 23| ? make_full_leaf_pos(child).visit(v, idx, args...) 1334| 23| : make_full_pos(child, shift_ - B).visit(v, idx, args...); 1335| 23| } _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb0ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 205| 17| { 206| 17| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 17| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb0ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1397| 113| { 1398| 113| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 113| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_17dec_right_visitorEJjEEEDcT_DpOT0_: 1397| 69| { 1398| 69| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 69| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_23slice_right_mut_visitorISC_Lb0ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 1328| 1.23k| { 1329| 1.23k| assert(offset_hint == index(idx)); 1330| 0| auto is_leaf = shift_ == BL; 1331| 1.23k| auto child = node_->inner()[offset_hint]; 1332| 1.23k| return is_leaf ------------------ | Branch (1332:16): [True: 819, False: 413] ------------------ 1333| 1.23k| ? make_full_leaf_pos(child).visit(v, idx, args...) 1334| 1.23k| : make_full_pos(child, shift_ - B).visit(v, idx, args...); 1335| 1.23k| } _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb0ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 205| 1.61k| { 206| 1.61k| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 1.61k| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb0ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1397| 1.09k| { 1398| 1.09k| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 1.09k| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10each_rightINS1_11dec_visitorEJEEEvT_jDpOT0_: 1302| 75| { 1303| 75| each_i(v, start, branches, args...); 1304| 75| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE6each_iINS1_11dec_visitorEJEEEvT_jjDpOT0_: 1255| 110| { 1256| 110| auto p = node_->inner() + i; 1257| 110| auto e = node_->inner() + n; 1258| 110| if (shift_ == BL) { ------------------ | Branch (1258:13): [True: 29, False: 81] ------------------ 1259| 141| for (; p != e; ++p) { ------------------ | Branch (1259:20): [True: 112, False: 29] ------------------ 1260| 112| IMMER_PREFETCH(p + 1); 1261| 112| make_full_leaf_pos(*p).visit(v, args...); 1262| 112| } 1263| 81| } else { 1264| 81| auto ss = shift_ - B; 1265| 488| for (; p != e; ++p) ------------------ | Branch (1265:20): [True: 407, False: 81] ------------------ 1266| 407| make_full_pos(*p, ss).visit(v, args...); 1267| 81| } 1268| 110| } _ZN5immer6detail4rbts8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb1ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 111| 77| { 112| 77| return Visitor::visit_leaf(*this, std::forward(args)...); 113| 77| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_23slice_right_mut_visitorISC_Lb0ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 303| 28| { 304| 28| return towards_oh_ch_regular( 305| 28| *this, v, idx, offset_hint, count(), args...); 306| 28| } _ZN5immer6detail4rbts21towards_oh_ch_regularIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_23slice_right_mut_visitorISD_Lb0ELb1EEEJRNSB_5applyIS8_E4type4editEEEEDcOT_T0_mjjDpOT1_: 630| 28|{ 631| 28| constexpr auto B = bits; 632| 28| constexpr auto BL = bits_leaf; 633| 28| assert(offset_hint == p.index(idx)); 634| 0| assert(count_hint == p.count()); 635| 0| auto is_leaf = p.shift() == BL; 636| 28| auto child = p.node()->inner()[offset_hint]; 637| 28| auto is_full = offset_hint + 1 != count_hint; 638| 28| return is_full ------------------ | Branch (638:12): [True: 9, False: 19] ------------------ 639| 28| ? (is_leaf ? make_full_leaf_pos(child).visit(v, idx, args...) ------------------ | Branch (639:19): [True: 2, False: 7] ------------------ 640| 9| : make_full_pos(child, p.shift() - B) 641| 7| .visit(v, idx, args...)) 642| 28| : (is_leaf ------------------ | Branch (642:19): [True: 17, False: 2] ------------------ 643| 19| ? make_leaf_pos(child, p.size()).visit(v, idx, args...) 644| 19| : make_regular_pos(child, p.shift() - B, p.size()) 645| 2| .visit(v, idx, args...)); 646| 28|} _ZN5immer6detail4rbts8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb0ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 111| 26| { 112| 26| return Visitor::visit_leaf(*this, std::forward(args)...); 113| 26| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb0ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 334| 53| { 335| 53| return Visitor::visit_regular(*this, std::forward(args)...); 336| 53| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_17dec_right_visitorEJjEEEDcT_DpOT0_: 334| 19| { 335| 19| return Visitor::visit_regular(*this, std::forward(args)...); 336| 19| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_23slice_right_mut_visitorISC_Lb0ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 303| 284| { 304| 284| return towards_oh_ch_regular( 305| 284| *this, v, idx, offset_hint, count(), args...); 306| 284| } _ZN5immer6detail4rbts21towards_oh_ch_regularIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_23slice_right_mut_visitorISD_Lb0ELb0EEEJRNSB_5applyIS8_E4type4editEEEEDcOT_T0_mjjDpOT1_: 630| 284|{ 631| 284| constexpr auto B = bits; 632| 284| constexpr auto BL = bits_leaf; 633| 284| assert(offset_hint == p.index(idx)); 634| 0| assert(count_hint == p.count()); 635| 0| auto is_leaf = p.shift() == BL; 636| 284| auto child = p.node()->inner()[offset_hint]; 637| 284| auto is_full = offset_hint + 1 != count_hint; 638| 284| return is_full ------------------ | Branch (638:12): [True: 215, False: 69] ------------------ 639| 284| ? (is_leaf ? make_full_leaf_pos(child).visit(v, idx, args...) ------------------ | Branch (639:19): [True: 11, False: 204] ------------------ 640| 215| : make_full_pos(child, p.shift() - B) 641| 204| .visit(v, idx, args...)) 642| 284| : (is_leaf ------------------ | Branch (642:19): [True: 46, False: 23] ------------------ 643| 69| ? make_leaf_pos(child, p.size()).visit(v, idx, args...) 644| 69| : make_regular_pos(child, p.shift() - B, p.size()) 645| 23| .visit(v, idx, args...)); 646| 284|} _ZN5immer6detail4rbts8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb0ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 111| 91| { 112| 91| return Visitor::visit_leaf(*this, std::forward(args)...); 113| 91| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb0ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 334| 259| { 335| 259| return Visitor::visit_regular(*this, std::forward(args)...); 336| 259| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10each_rightINS1_11dec_visitorEJEEEvT_jDpOT0_: 283| 28| { 284| 28| return each_right_regular(*this, v, start, args...); 285| 28| } _ZN5immer6detail4rbts18each_right_regularIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_11dec_visitorEJEEEvOT_T0_jDpOT1_: 595| 28|{ 596| 28| constexpr auto B = bits; 597| 28| constexpr auto BL = bits_leaf; 598| | 599| 28| if (p.shift() == BL) { ------------------ | Branch (599:9): [True: 19, False: 9] ------------------ 600| 19| auto n = p.node()->inner() + start; 601| 19| auto last = p.count() - 1; 602| 19| auto e = p.node()->inner() + last; 603| 19| if (n <= e) { ------------------ | Branch (603:13): [True: 2, False: 17] ------------------ 604| 6| for (; n != e; ++n) { ------------------ | Branch (604:20): [True: 4, False: 2] ------------------ 605| 4| IMMER_PREFETCH(n + 1); 606| 4| make_full_leaf_pos(*n).visit(v, args...); 607| 4| } 608| 2| make_leaf_pos(*n, p.size()).visit(v, args...); 609| 2| } 610| 19| } else { 611| 9| auto n = p.node()->inner() + start; 612| 9| auto last = p.count() - 1; 613| 9| auto e = p.node()->inner() + last; 614| 9| auto ss = p.shift() - B; 615| 9| if (n <= e) { ------------------ | Branch (615:13): [True: 7, False: 2] ------------------ 616| 17| for (; n != e; ++n) ------------------ | Branch (616:20): [True: 10, False: 7] ------------------ 617| 10| make_full_pos(*n, ss).visit(v, args...); 618| 7| make_regular_pos(*n, ss, p.size()).visit(v, args...); 619| 7| } 620| 9| } 621| 28|} _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_23slice_right_mut_visitorISC_Lb0ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 919| 158| { 920| 158| return towards_oh_ch_regular( 921| 158| *this, v, idx, offset_hint, count(), args...); 922| 158| } _ZN5immer6detail4rbts21towards_oh_ch_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_23slice_right_mut_visitorISD_Lb0ELb1EEEJRNSB_5applyIS8_E4type4editEEEEDcOT_T0_mjjDpOT1_: 630| 158|{ 631| 158| constexpr auto B = bits; 632| 158| constexpr auto BL = bits_leaf; 633| 158| assert(offset_hint == p.index(idx)); 634| 0| assert(count_hint == p.count()); 635| 0| auto is_leaf = p.shift() == BL; 636| 158| auto child = p.node()->inner()[offset_hint]; 637| 158| auto is_full = offset_hint + 1 != count_hint; 638| 158| return is_full ------------------ | Branch (638:12): [True: 98, False: 60] ------------------ 639| 158| ? (is_leaf ? make_full_leaf_pos(child).visit(v, idx, args...) ------------------ | Branch (639:19): [True: 8, False: 90] ------------------ 640| 98| : make_full_pos(child, p.shift() - B) 641| 90| .visit(v, idx, args...)) 642| 158| : (is_leaf ------------------ | Branch (642:19): [True: 9, False: 51] ------------------ 643| 60| ? make_leaf_pos(child, p.size()).visit(v, idx, args...) 644| 60| : make_regular_pos(child, p.shift() - B, p.size()) 645| 51| .visit(v, idx, args...)); 646| 158|} _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_23slice_right_mut_visitorISC_Lb0ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 919| 1.54k| { 920| 1.54k| return towards_oh_ch_regular( 921| 1.54k| *this, v, idx, offset_hint, count(), args...); 922| 1.54k| } _ZN5immer6detail4rbts21towards_oh_ch_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_23slice_right_mut_visitorISD_Lb0ELb0EEEJRNSB_5applyIS8_E4type4editEEEEDcOT_T0_mjjDpOT1_: 630| 1.54k|{ 631| 1.54k| constexpr auto B = bits; 632| 1.54k| constexpr auto BL = bits_leaf; 633| 1.54k| assert(offset_hint == p.index(idx)); 634| 0| assert(count_hint == p.count()); 635| 0| auto is_leaf = p.shift() == BL; 636| 1.54k| auto child = p.node()->inner()[offset_hint]; 637| 1.54k| auto is_full = offset_hint + 1 != count_hint; 638| 1.54k| return is_full ------------------ | Branch (638:12): [True: 1.26k, False: 281] ------------------ 639| 1.54k| ? (is_leaf ? make_full_leaf_pos(child).visit(v, idx, args...) ------------------ | Branch (639:19): [True: 789, False: 476] ------------------ 640| 1.26k| : make_full_pos(child, p.shift() - B) 641| 476| .visit(v, idx, args...)) 642| 1.54k| : (is_leaf ------------------ | Branch (642:19): [True: 45, False: 236] ------------------ 643| 281| ? make_leaf_pos(child, p.size()).visit(v, idx, args...) 644| 281| : make_regular_pos(child, p.shift() - B, p.size()) 645| 236| .visit(v, idx, args...)); 646| 1.54k|} _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10each_rightINS1_11dec_visitorEJEEEvT_jDpOT0_: 859| 281| { 860| 281| return each_right_regular(*this, v, start, args...); 861| 281| } _ZN5immer6detail4rbts18each_right_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_11dec_visitorEJEEEvOT_T0_jDpOT1_: 595| 281|{ 596| 281| constexpr auto B = bits; 597| 281| constexpr auto BL = bits_leaf; 598| | 599| 281| if (p.shift() == BL) { ------------------ | Branch (599:9): [True: 104, False: 177] ------------------ 600| 104| auto n = p.node()->inner() + start; 601| 104| auto last = p.count() - 1; 602| 104| auto e = p.node()->inner() + last; 603| 104| if (n <= e) { ------------------ | Branch (603:13): [True: 49, False: 55] ------------------ 604| 230| for (; n != e; ++n) { ------------------ | Branch (604:20): [True: 181, False: 49] ------------------ 605| 181| IMMER_PREFETCH(n + 1); 606| 181| make_full_leaf_pos(*n).visit(v, args...); 607| 181| } 608| 49| make_leaf_pos(*n, p.size()).visit(v, args...); 609| 49| } 610| 177| } else { 611| 177| auto n = p.node()->inner() + start; 612| 177| auto last = p.count() - 1; 613| 177| auto e = p.node()->inner() + last; 614| 177| auto ss = p.shift() - B; 615| 177| if (n <= e) { ------------------ | Branch (615:13): [True: 126, False: 51] ------------------ 616| 224| for (; n != e; ++n) ------------------ | Branch (616:20): [True: 98, False: 126] ------------------ 617| 98| make_full_pos(*n, ss).visit(v, args...); 618| 126| make_regular_pos(*n, ss, p.size()).visit(v, args...); 619| 126| } 620| 177| } 621| 281|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_17dec_right_visitorEJjEEEDcT_DpOT0_: 1805| 38.2k| { 1806| 38.2k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 38.2k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_23slice_right_mut_visitorISC_Lb0ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 1678| 6.55k| { 1679| 6.55k| assert(offset_hint == index(idx)); 1680| 6.55k| auto left_size = offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0; ------------------ | Branch (1680:26): [True: 4.97k, False: 1.57k] ------------------ 1681| 6.55k| return towards_oh_sbh(v, idx, offset_hint, left_size, args...); 1682| 6.55k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_oh_sbhINS1_23slice_right_mut_visitorISC_Lb0ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjmDpOT0_: 1690| 6.55k| { 1691| 6.55k| return towards_sub_oh_sbh(v, idx, offset_hint, left_size_hint, args...); 1692| 6.55k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE18towards_sub_oh_sbhINS1_23slice_right_mut_visitorISC_Lb0ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjmDpOT0_: 1709| 6.55k| { 1710| 6.55k| assert(offset_hint == index(idx)); 1711| 0| assert(left_size_hint == 1712| 6.55k| (offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0)); 1713| 0| auto child = node_->inner()[offset_hint]; 1714| 6.55k| auto is_leaf = shift_ == BL; 1715| 6.55k| auto next_size = relaxed_->d.sizes[offset_hint] - left_size_hint; 1716| 6.55k| auto next_idx = idx - left_size_hint; 1717| 6.55k| return is_leaf ------------------ | Branch (1717:16): [True: 1.85k, False: 4.70k] ------------------ 1718| 6.55k| ? make_leaf_sub_pos(child, next_size) 1719| 1.85k| .visit(v, next_idx, args...) 1720| 6.55k| : visit_maybe_relaxed_sub( 1721| 4.70k| child, shift_ - B, next_size, v, next_idx, args...); 1722| 6.55k| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb0ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 143| 1.85k| { 144| 1.85k| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 1.85k| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_23slice_right_mut_visitorISC_Lb0ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcPT_jmT0_DpOT1_: 1830| 4.70k|{ 1831| 4.70k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 4.70k| if (relaxed) { ------------------ | Branch (1833:9): [True: 4.29k, False: 406] ------------------ 1834| 4.29k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 4.29k| .visit(v, std::forward(args)...); 1837| 4.29k| } else { 1838| 406| return make_regular_sub_pos(node, shift, size) 1839| 406| .visit(v, std::forward(args)...); 1840| 406| } 1841| 4.70k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb0ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1805| 4.29k| { 1806| 4.29k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 4.29k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb0ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1028| 406| { 1029| 406| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 406| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_17dec_right_visitorEJjEEEDcT_DpOT0_: 1028| 495| { 1029| 495| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 495| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_23slice_right_mut_visitorISC_Lb0ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 1678| 7.44k| { 1679| 7.44k| assert(offset_hint == index(idx)); 1680| 7.44k| auto left_size = offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0; ------------------ | Branch (1680:26): [True: 4.90k, False: 2.53k] ------------------ 1681| 7.44k| return towards_oh_sbh(v, idx, offset_hint, left_size, args...); 1682| 7.44k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_oh_sbhINS1_23slice_right_mut_visitorISC_Lb0ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjmDpOT0_: 1690| 7.44k| { 1691| 7.44k| return towards_sub_oh_sbh(v, idx, offset_hint, left_size_hint, args...); 1692| 7.44k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE18towards_sub_oh_sbhINS1_23slice_right_mut_visitorISC_Lb0ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjmDpOT0_: 1709| 7.44k| { 1710| 7.44k| assert(offset_hint == index(idx)); 1711| 0| assert(left_size_hint == 1712| 7.44k| (offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0)); 1713| 0| auto child = node_->inner()[offset_hint]; 1714| 7.44k| auto is_leaf = shift_ == BL; 1715| 7.44k| auto next_size = relaxed_->d.sizes[offset_hint] - left_size_hint; 1716| 7.44k| auto next_idx = idx - left_size_hint; 1717| 7.44k| return is_leaf ------------------ | Branch (1717:16): [True: 3.18k, False: 4.25k] ------------------ 1718| 7.44k| ? make_leaf_sub_pos(child, next_size) 1719| 3.18k| .visit(v, next_idx, args...) 1720| 7.44k| : visit_maybe_relaxed_sub( 1721| 4.25k| child, shift_ - B, next_size, v, next_idx, args...); 1722| 7.44k| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb0ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 143| 3.18k| { 144| 3.18k| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 3.18k| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_23slice_right_mut_visitorISC_Lb0ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcPT_jmT0_DpOT1_: 1830| 4.25k|{ 1831| 4.25k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 4.25k| if (relaxed) { ------------------ | Branch (1833:9): [True: 3.06k, False: 1.18k] ------------------ 1834| 3.06k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 3.06k| .visit(v, std::forward(args)...); 1837| 3.06k| } else { 1838| 1.18k| return make_regular_sub_pos(node, shift, size) 1839| 1.18k| .visit(v, std::forward(args)...); 1840| 1.18k| } 1841| 4.25k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb0ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1805| 3.06k| { 1806| 3.06k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 3.06k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb0ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1028| 1.18k| { 1029| 1.18k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 1.18k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10each_rightINS1_11dec_visitorEJEEEvT_jDpOT0_: 1645| 40.3k| { 1646| 40.3k| assert(start > 0); 1647| 0| assert(start <= relaxed_->d.count); 1648| 0| auto s = relaxed_->d.sizes[start - 1]; 1649| 40.3k| auto p = node_->inner(); 1650| 40.3k| if (shift_ == BL) { ------------------ | Branch (1650:13): [True: 1.93k, False: 38.3k] ------------------ 1651| 12.3k| for (auto i = start; i < relaxed_->d.count; ++i) { ------------------ | Branch (1651:34): [True: 10.4k, False: 1.93k] ------------------ 1652| 10.4k| IMMER_PREFETCH(p + i + 1); 1653| 10.4k| make_leaf_sub_pos(p[i], relaxed_->d.sizes[i] - s) 1654| 10.4k| .visit(v, args...); 1655| 10.4k| s = relaxed_->d.sizes[i]; 1656| 10.4k| assert(s); 1657| 10.4k| } 1658| 38.3k| } else { 1659| 38.3k| auto ss = shift_ - B; 1660| 282k| for (auto i = start; i < relaxed_->d.count; ++i) { ------------------ | Branch (1660:34): [True: 244k, False: 38.3k] ------------------ 1661| 244k| visit_maybe_relaxed_sub( 1662| 244k| p[i], ss, relaxed_->d.sizes[i] - s, v, args...); 1663| 244k| s = relaxed_->d.sizes[i]; 1664| 244k| assert(s); 1665| 244k| } 1666| 38.3k| } 1667| 40.3k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb1ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1028| 396| { 1029| 396| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 396| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_23slice_right_mut_visitorISC_Lb1ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 919| 123| { 920| 123| return towards_oh_ch_regular( 921| 123| *this, v, idx, offset_hint, count(), args...); 922| 123| } _ZN5immer6detail4rbts21towards_oh_ch_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_23slice_right_mut_visitorISD_Lb1ELb1EEEJRNSB_5applyIS8_E4type4editEEEEDcOT_T0_mjjDpOT1_: 630| 123|{ 631| 123| constexpr auto B = bits; 632| 123| constexpr auto BL = bits_leaf; 633| 123| assert(offset_hint == p.index(idx)); 634| 0| assert(count_hint == p.count()); 635| 0| auto is_leaf = p.shift() == BL; 636| 123| auto child = p.node()->inner()[offset_hint]; 637| 123| auto is_full = offset_hint + 1 != count_hint; 638| 123| return is_full ------------------ | Branch (638:12): [True: 77, False: 46] ------------------ 639| 123| ? (is_leaf ? make_full_leaf_pos(child).visit(v, idx, args...) ------------------ | Branch (639:19): [True: 41, False: 36] ------------------ 640| 77| : make_full_pos(child, p.shift() - B) 641| 36| .visit(v, idx, args...)) 642| 123| : (is_leaf ------------------ | Branch (642:19): [True: 46, False: 0] ------------------ 643| 46| ? make_leaf_pos(child, p.size()).visit(v, idx, args...) 644| 46| : make_regular_pos(child, p.shift() - B, p.size()) 645| 0| .visit(v, idx, args...)); 646| 123|} _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb1ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 205| 49| { 206| 49| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 49| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb1ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1397| 80| { 1398| 80| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 80| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_23slice_right_mut_visitorISC_Lb1ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 1328| 52| { 1329| 52| assert(offset_hint == index(idx)); 1330| 0| auto is_leaf = shift_ == BL; 1331| 52| auto child = node_->inner()[offset_hint]; 1332| 52| return is_leaf ------------------ | Branch (1332:16): [True: 8, False: 44] ------------------ 1333| 52| ? make_full_leaf_pos(child).visit(v, idx, args...) 1334| 52| : make_full_pos(child, shift_ - B).visit(v, idx, args...); 1335| 52| } _ZN5immer6detail4rbts8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_23slice_right_mut_visitorISC_Lb1ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 111| 46| { 112| 46| return Visitor::visit_leaf(*this, std::forward(args)...); 113| 46| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb1ELb1EEEJmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 143| 153| { 144| 153| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 153| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_22slice_left_mut_visitorISC_Lb1ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcPT_jmT0_DpOT1_: 1830| 24.6k|{ 1831| 24.6k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 24.6k| if (relaxed) { ------------------ | Branch (1833:9): [True: 24.4k, False: 147] ------------------ 1834| 24.4k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 24.4k| .visit(v, std::forward(args)...); 1837| 24.4k| } else { 1838| 147| return make_regular_sub_pos(node, shift, size) 1839| 147| .visit(v, std::forward(args)...); 1840| 147| } 1841| 24.6k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb1ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1805| 24.4k| { 1806| 24.4k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 24.4k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_sub_ohINS1_22slice_left_mut_visitorISC_Lb1ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 1697| 53| { 1698| 53| assert(offset_hint == index(idx)); 1699| 53| auto left_size = offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0; ------------------ | Branch (1699:26): [True: 53, False: 0] ------------------ 1700| 53| return towards_sub_oh_sbh(v, idx, offset_hint, left_size, args...); 1701| 53| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE18towards_sub_oh_sbhINS1_22slice_left_mut_visitorISC_Lb1ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjmDpOT0_: 1709| 53| { 1710| 53| assert(offset_hint == index(idx)); 1711| 0| assert(left_size_hint == 1712| 53| (offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0)); 1713| 0| auto child = node_->inner()[offset_hint]; 1714| 53| auto is_leaf = shift_ == BL; 1715| 53| auto next_size = relaxed_->d.sizes[offset_hint] - left_size_hint; 1716| 53| auto next_idx = idx - left_size_hint; 1717| 53| return is_leaf ------------------ | Branch (1717:16): [True: 0, False: 53] ------------------ 1718| 53| ? make_leaf_sub_pos(child, next_size) 1719| 0| .visit(v, next_idx, args...) 1720| 53| : visit_maybe_relaxed_sub( 1721| 53| child, shift_ - B, next_size, v, next_idx, args...); 1722| 53| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_sub_ohINS1_22slice_left_mut_visitorISC_Lb1ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 1697| 32| { 1698| 32| assert(offset_hint == index(idx)); 1699| 32| auto left_size = offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0; ------------------ | Branch (1699:26): [True: 32, False: 0] ------------------ 1700| 32| return towards_sub_oh_sbh(v, idx, offset_hint, left_size, args...); 1701| 32| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE18towards_sub_oh_sbhINS1_22slice_left_mut_visitorISC_Lb1ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjmDpOT0_: 1709| 32| { 1710| 32| assert(offset_hint == index(idx)); 1711| 0| assert(left_size_hint == 1712| 32| (offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0)); 1713| 0| auto child = node_->inner()[offset_hint]; 1714| 32| auto is_leaf = shift_ == BL; 1715| 32| auto next_size = relaxed_->d.sizes[offset_hint] - left_size_hint; 1716| 32| auto next_idx = idx - left_size_hint; 1717| 32| return is_leaf ------------------ | Branch (1717:16): [True: 0, False: 32] ------------------ 1718| 32| ? make_leaf_sub_pos(child, next_size) 1719| 0| .visit(v, next_idx, args...) 1720| 32| : visit_maybe_relaxed_sub( 1721| 32| child, shift_ - B, next_size, v, next_idx, args...); 1722| 32| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_22slice_left_mut_visitorISC_Lb1ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcPT_jmT0_DpOT1_: 1830| 32|{ 1831| 32| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 32| if (relaxed) { ------------------ | Branch (1833:9): [True: 14, False: 18] ------------------ 1834| 14| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 14| .visit(v, std::forward(args)...); 1837| 18| } else { 1838| 18| return make_regular_sub_pos(node, shift, size) 1839| 18| .visit(v, std::forward(args)...); 1840| 18| } 1841| 32|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb1ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1805| 14| { 1806| 14| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 14| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb1ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1028| 18| { 1029| 18| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 18| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_sub_ohINS1_22slice_left_mut_visitorISC_Lb1ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 938| 5| { 939| 5| return towards_sub_oh_regular(*this, v, idx, offset_hint, args...); 940| 5| } _ZN5immer6detail4rbts22towards_sub_oh_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_22slice_left_mut_visitorISD_Lb1ELb0EEEJRNSB_5applyIS8_E4type4editEEEEDcOT_T0_mjDpOT1_: 651| 5|{ 652| 5| constexpr auto B = bits; 653| 5| constexpr auto BL = bits_leaf; 654| 5| assert(offset_hint == p.index(idx)); 655| 0| auto is_leaf = p.shift() == BL; 656| 5| auto child = p.node()->inner()[offset_hint]; 657| 5| auto lsize = offset_hint << p.shift(); 658| 5| auto size = p.this_size(); 659| 5| auto is_full = (size - lsize) >= (size_t{1} << p.shift()); 660| 5| return is_full ------------------ | Branch (660:12): [True: 0, False: 5] ------------------ 661| 5| ? (is_leaf ------------------ | Branch (661:19): [True: 0, False: 0] ------------------ 662| 0| ? make_full_leaf_pos(child).visit(v, idx - lsize, args...) 663| 0| : make_full_pos(child, p.shift() - B) 664| 0| .visit(v, idx - lsize, args...)) 665| 5| : (is_leaf ------------------ | Branch (665:19): [True: 0, False: 5] ------------------ 666| 5| ? make_leaf_sub_pos(child, size - lsize) 667| 0| .visit(v, idx - lsize, args...) 668| 5| : make_regular_sub_pos(child, p.shift() - B, size - lsize) 669| 5| .visit(v, idx - lsize, args...)); 670| 5|} _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_sub_ohINS1_22slice_left_mut_visitorISC_Lb0ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 1340| 35| { 1341| 35| assert(offset_hint == index(idx)); 1342| 0| auto is_leaf = shift_ == BL; 1343| 35| auto child = node_->inner()[offset_hint]; 1344| 35| auto lsize = size_t{offset_hint} << shift_; 1345| 35| return is_leaf ------------------ | Branch (1345:16): [True: 14, False: 21] ------------------ 1346| 35| ? make_full_leaf_pos(child).visit(v, idx - lsize, args...) 1347| 35| : make_full_pos(child, shift_ - B) 1348| 21| .visit(v, idx - lsize, args...); 1349| 35| } _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb0ELb1EEEJmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 205| 64| { 206| 64| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 64| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb0ELb1EEEJmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1397| 52| { 1398| 52| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 52| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_sub_ohINS1_22slice_left_mut_visitorISC_Lb0ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 1340| 352| { 1341| 352| assert(offset_hint == index(idx)); 1342| 0| auto is_leaf = shift_ == BL; 1343| 352| auto child = node_->inner()[offset_hint]; 1344| 352| auto lsize = size_t{offset_hint} << shift_; 1345| 352| return is_leaf ------------------ | Branch (1345:16): [True: 188, False: 164] ------------------ 1346| 352| ? make_full_leaf_pos(child).visit(v, idx - lsize, args...) 1347| 352| : make_full_pos(child, shift_ - B) 1348| 164| .visit(v, idx - lsize, args...); 1349| 352| } _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb0ELb0EEEJmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 205| 2.56k| { 206| 2.56k| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 2.56k| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb0ELb0EEEJmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1397| 327| { 1398| 327| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 327| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9each_leftINS1_11dec_visitorEJEEEvT_jDpOT0_: 1308| 35| { 1309| 35| each_i(v, 0, last, args...); 1310| 35| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb1ELb0EEEJmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1028| 5| { 1029| 5| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 5| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_16dec_left_visitorEJRjEEEDcT_DpOT0_: 1028| 47| { 1029| 47| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 47| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_sub_ohINS1_22slice_left_mut_visitorISC_Lb0ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 938| 81| { 939| 81| return towards_sub_oh_regular(*this, v, idx, offset_hint, args...); 940| 81| } _ZN5immer6detail4rbts22towards_sub_oh_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_22slice_left_mut_visitorISD_Lb0ELb1EEEJRNSB_5applyIS8_E4type4editEEEEDcOT_T0_mjDpOT1_: 651| 81|{ 652| 81| constexpr auto B = bits; 653| 81| constexpr auto BL = bits_leaf; 654| 81| assert(offset_hint == p.index(idx)); 655| 0| auto is_leaf = p.shift() == BL; 656| 81| auto child = p.node()->inner()[offset_hint]; 657| 81| auto lsize = offset_hint << p.shift(); 658| 81| auto size = p.this_size(); 659| 81| auto is_full = (size - lsize) >= (size_t{1} << p.shift()); 660| 81| return is_full ------------------ | Branch (660:12): [True: 81, False: 0] ------------------ 661| 81| ? (is_leaf ------------------ | Branch (661:19): [True: 50, False: 31] ------------------ 662| 81| ? make_full_leaf_pos(child).visit(v, idx - lsize, args...) 663| 81| : make_full_pos(child, p.shift() - B) 664| 31| .visit(v, idx - lsize, args...)) 665| 81| : (is_leaf ------------------ | Branch (665:19): [True: 0, False: 0] ------------------ 666| 0| ? make_leaf_sub_pos(child, size - lsize) 667| 0| .visit(v, idx - lsize, args...) 668| 0| : make_regular_sub_pos(child, p.shift() - B, size - lsize) 669| 0| .visit(v, idx - lsize, args...)); 670| 81|} _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_sub_ohINS1_22slice_left_mut_visitorISC_Lb0ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 938| 2.53k| { 939| 2.53k| return towards_sub_oh_regular(*this, v, idx, offset_hint, args...); 940| 2.53k| } _ZN5immer6detail4rbts22towards_sub_oh_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_22slice_left_mut_visitorISD_Lb0ELb0EEEJRNSB_5applyIS8_E4type4editEEEEDcOT_T0_mjDpOT1_: 651| 2.53k|{ 652| 2.53k| constexpr auto B = bits; 653| 2.53k| constexpr auto BL = bits_leaf; 654| 2.53k| assert(offset_hint == p.index(idx)); 655| 0| auto is_leaf = p.shift() == BL; 656| 2.53k| auto child = p.node()->inner()[offset_hint]; 657| 2.53k| auto lsize = offset_hint << p.shift(); 658| 2.53k| auto size = p.this_size(); 659| 2.53k| auto is_full = (size - lsize) >= (size_t{1} << p.shift()); 660| 2.53k| return is_full ------------------ | Branch (660:12): [True: 2.53k, False: 0] ------------------ 661| 2.53k| ? (is_leaf ------------------ | Branch (661:19): [True: 2.37k, False: 163] ------------------ 662| 2.53k| ? make_full_leaf_pos(child).visit(v, idx - lsize, args...) 663| 2.53k| : make_full_pos(child, p.shift() - B) 664| 163| .visit(v, idx - lsize, args...)) 665| 2.53k| : (is_leaf ------------------ | Branch (665:19): [True: 0, False: 0] ------------------ 666| 0| ? make_leaf_sub_pos(child, size - lsize) 667| 0| .visit(v, idx - lsize, args...) 668| 0| : make_regular_sub_pos(child, p.shift() - B, size - lsize) 669| 0| .visit(v, idx - lsize, args...)); 670| 2.53k|} _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9each_leftINS1_11dec_visitorEJEEEvT_jDpOT0_: 865| 128| { 866| 128| return each_left_regular(*this, v, last, args...); 867| 128| } _ZN5immer6detail4rbts17each_left_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_11dec_visitorEJEEEvOT_T0_jDpOT1_: 573| 128|{ 574| 128| constexpr auto B = bits; 575| 128| constexpr auto BL = bits_leaf; 576| 128| assert(last < p.count()); 577| 128| if (p.shift() == BL) { ------------------ | Branch (577:9): [True: 50, False: 78] ------------------ 578| 50| auto n = p.node()->inner(); 579| 50| auto e = n + last; 580| 103| for (; n != e; ++n) { ------------------ | Branch (580:16): [True: 53, False: 50] ------------------ 581| 53| IMMER_PREFETCH(n + 1); 582| 53| make_full_leaf_pos(*n).visit(v, args...); 583| 53| } 584| 78| } else { 585| 78| auto n = p.node()->inner(); 586| 78| auto e = n + last; 587| 78| auto ss = p.shift() - B; 588| 105| for (; n != e; ++n) ------------------ | Branch (588:16): [True: 27, False: 78] ------------------ 589| 27| make_full_pos(*n, ss).visit(v, args...); 590| 78| } 591| 128|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_16dec_left_visitorEJRjEEEDcT_DpOT0_: 1805| 53| { 1806| 53| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 53| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_sub_ohINS1_22slice_left_mut_visitorISC_Lb0ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 1697| 91.2k| { 1698| 91.2k| assert(offset_hint == index(idx)); 1699| 91.2k| auto left_size = offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0; ------------------ | Branch (1699:26): [True: 12.5k, False: 78.7k] ------------------ 1700| 91.2k| return towards_sub_oh_sbh(v, idx, offset_hint, left_size, args...); 1701| 91.2k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE18towards_sub_oh_sbhINS1_22slice_left_mut_visitorISC_Lb0ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjmDpOT0_: 1709| 91.2k| { 1710| 91.2k| assert(offset_hint == index(idx)); 1711| 0| assert(left_size_hint == 1712| 91.2k| (offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0)); 1713| 0| auto child = node_->inner()[offset_hint]; 1714| 91.2k| auto is_leaf = shift_ == BL; 1715| 91.2k| auto next_size = relaxed_->d.sizes[offset_hint] - left_size_hint; 1716| 91.2k| auto next_idx = idx - left_size_hint; 1717| 91.2k| return is_leaf ------------------ | Branch (1717:16): [True: 443, False: 90.8k] ------------------ 1718| 91.2k| ? make_leaf_sub_pos(child, next_size) 1719| 443| .visit(v, next_idx, args...) 1720| 91.2k| : visit_maybe_relaxed_sub( 1721| 90.8k| child, shift_ - B, next_size, v, next_idx, args...); 1722| 91.2k| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb0ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 143| 443| { 144| 443| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 443| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_22slice_left_mut_visitorISC_Lb0ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcPT_jmT0_DpOT1_: 1830| 90.8k|{ 1831| 90.8k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 90.8k| if (relaxed) { ------------------ | Branch (1833:9): [True: 90.2k, False: 614] ------------------ 1834| 90.2k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 90.2k| .visit(v, std::forward(args)...); 1837| 90.2k| } else { 1838| 614| return make_regular_sub_pos(node, shift, size) 1839| 614| .visit(v, std::forward(args)...); 1840| 614| } 1841| 90.8k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb0ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1805| 90.2k| { 1806| 90.2k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 90.2k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb0ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1028| 614| { 1029| 614| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 614| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_sub_ohINS1_22slice_left_mut_visitorISC_Lb0ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 1697| 119k| { 1698| 119k| assert(offset_hint == index(idx)); 1699| 119k| auto left_size = offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0; ------------------ | Branch (1699:26): [True: 41.7k, False: 77.4k] ------------------ 1700| 119k| return towards_sub_oh_sbh(v, idx, offset_hint, left_size, args...); 1701| 119k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE18towards_sub_oh_sbhINS1_22slice_left_mut_visitorISC_Lb0ELb0EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjmDpOT0_: 1709| 119k| { 1710| 119k| assert(offset_hint == index(idx)); 1711| 0| assert(left_size_hint == 1712| 119k| (offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0)); 1713| 0| auto child = node_->inner()[offset_hint]; 1714| 119k| auto is_leaf = shift_ == BL; 1715| 119k| auto next_size = relaxed_->d.sizes[offset_hint] - left_size_hint; 1716| 119k| auto next_idx = idx - left_size_hint; 1717| 119k| return is_leaf ------------------ | Branch (1717:16): [True: 21.5k, False: 97.7k] ------------------ 1718| 119k| ? make_leaf_sub_pos(child, next_size) 1719| 21.5k| .visit(v, next_idx, args...) 1720| 119k| : visit_maybe_relaxed_sub( 1721| 97.7k| child, shift_ - B, next_size, v, next_idx, args...); 1722| 119k| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb0ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 143| 21.5k| { 144| 21.5k| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 21.5k| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_22slice_left_mut_visitorISC_Lb0ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcPT_jmT0_DpOT1_: 1830| 97.7k|{ 1831| 97.7k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 97.7k| if (relaxed) { ------------------ | Branch (1833:9): [True: 95.8k, False: 1.84k] ------------------ 1834| 95.8k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 95.8k| .visit(v, std::forward(args)...); 1837| 95.8k| } else { 1838| 1.84k| return make_regular_sub_pos(node, shift, size) 1839| 1.84k| .visit(v, std::forward(args)...); 1840| 1.84k| } 1841| 97.7k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb0ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1805| 95.8k| { 1806| 95.8k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 95.8k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb0ELb0EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1028| 1.84k| { 1029| 1.84k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 1.84k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb1ELb1EEEJRmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1028| 147| { 1029| 147| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 147| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_sub_ohINS1_22slice_left_mut_visitorISC_Lb1ELb1EEEJRNSA_5applyIS7_E4type4editEEEEDcT_mjDpOT0_: 938| 47| { 939| 47| return towards_sub_oh_regular(*this, v, idx, offset_hint, args...); 940| 47| } _ZN5immer6detail4rbts22towards_sub_oh_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_22slice_left_mut_visitorISD_Lb1ELb1EEEJRNSB_5applyIS8_E4type4editEEEEDcOT_T0_mjDpOT1_: 651| 47|{ 652| 47| constexpr auto B = bits; 653| 47| constexpr auto BL = bits_leaf; 654| 47| assert(offset_hint == p.index(idx)); 655| 0| auto is_leaf = p.shift() == BL; 656| 47| auto child = p.node()->inner()[offset_hint]; 657| 47| auto lsize = offset_hint << p.shift(); 658| 47| auto size = p.this_size(); 659| 47| auto is_full = (size - lsize) >= (size_t{1} << p.shift()); 660| 47| return is_full ------------------ | Branch (660:12): [True: 8, False: 39] ------------------ 661| 47| ? (is_leaf ------------------ | Branch (661:19): [True: 0, False: 8] ------------------ 662| 8| ? make_full_leaf_pos(child).visit(v, idx - lsize, args...) 663| 8| : make_full_pos(child, p.shift() - B) 664| 8| .visit(v, idx - lsize, args...)) 665| 47| : (is_leaf ------------------ | Branch (665:19): [True: 0, False: 39] ------------------ 666| 39| ? make_leaf_sub_pos(child, size - lsize) 667| 0| .visit(v, idx - lsize, args...) 668| 39| : make_regular_sub_pos(child, p.shift() - B, size - lsize) 669| 39| .visit(v, idx - lsize, args...)); 670| 47|} _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb1ELb1EEEJmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1397| 8| { 1398| 8| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 8| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_22slice_left_mut_visitorISC_Lb1ELb1EEEJmRNSA_5applyIS7_E4type4editEEEEDcT_DpOT0_: 1028| 39| { 1029| 39| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 39| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_14equals_visitor3rrbEJNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERKPSC_RKjRmEEEDcPT_jmT0_DpOT1_: 1830| 695|{ 1831| 695| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 695| if (relaxed) { ------------------ | Branch (1833:9): [True: 439, False: 256] ------------------ 1834| 439| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 439| .visit(v, std::forward(args)...); 1837| 439| } else { 1838| 256| return make_regular_sub_pos(node, shift, size) 1839| 256| .visit(v, std::forward(args)...); 1840| 256| } 1841| 695|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitor3rrbEJNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERKPSC_RKjRmEEEDcT_DpOT0_: 1805| 439| { 1806| 439| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 439| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_14equals_visitorEJRNS1_11relaxed_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEmEEEDcPT_jmT0_DpOT1_: 1830| 439|{ 1831| 439| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 439| if (relaxed) { ------------------ | Branch (1833:9): [True: 402, False: 37] ------------------ 1834| 402| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 402| .visit(v, std::forward(args)...); 1837| 402| } else { 1838| 37| return make_regular_sub_pos(node, shift, size) 1839| 37| .visit(v, std::forward(args)...); 1840| 37| } 1841| 439|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRSD_RNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEmEEEDcT_DpOT0_: 1805| 402| { 1806| 402| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 402| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7nth_subINS1_14equals_visitor10this_aux_tEJRjRSD_RNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEmEEEDcjT_DpOT0_: 1785| 1.84k| { 1786| 1.84k| auto child = node_->inner()[offset]; 1787| 1.84k| auto child_size = size(offset); 1788| 1.84k| auto is_leaf = shift_ == BL; 1789| 1.84k| return is_leaf ? make_leaf_sub_pos(child, child_size).visit(v, args...) ------------------ | Branch (1789:16): [True: 661, False: 1.17k] ------------------ 1790| 1.84k| : visit_maybe_relaxed_sub( 1791| 1.17k| child, shift_ - B, child_size, v, args...); 1792| 1.84k| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitor10this_aux_tEJRjRNS1_11relaxed_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 143| 667| { 144| 667| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 667| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE12nth_sub_leafINS1_14equals_visitorEJRNS1_12leaf_sub_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcjT_DpOT0_: 1796| 667| { 1797| 667| assert(shift_ == BL); 1798| 0| auto child = node_->inner()[offset]; 1799| 667| auto child_size = size(offset); 1800| 667| return make_leaf_sub_pos(child, child_size).visit(v, args...); 1801| 667| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRSD_RNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 143| 676| { 144| 676| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 676| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_14equals_visitor10this_aux_tEJRjRNS1_11relaxed_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcPT_jmT0_DpOT1_: 1830| 1.17k|{ 1831| 1.17k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 1.17k| if (relaxed) { ------------------ | Branch (1833:9): [True: 1.14k, False: 33] ------------------ 1834| 1.14k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 1.14k| .visit(v, std::forward(args)...); 1837| 1.14k| } else { 1838| 33| return make_regular_sub_pos(node, shift, size) 1839| 33| .visit(v, std::forward(args)...); 1840| 33| } 1841| 1.17k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitor10this_aux_tEJRjRSD_RNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 1805| 1.14k| { 1806| 1.14k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 1.14k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7nth_subINS1_14equals_visitorEJRSD_RNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcjT_DpOT0_: 1785| 1.14k| { 1786| 1.14k| auto child = node_->inner()[offset]; 1787| 1.14k| auto child_size = size(offset); 1788| 1.14k| auto is_leaf = shift_ == BL; 1789| 1.14k| return is_leaf ? make_leaf_sub_pos(child, child_size).visit(v, args...) ------------------ | Branch (1789:16): [True: 0, False: 1.14k] ------------------ 1790| 1.14k| : visit_maybe_relaxed_sub( 1791| 1.14k| child, shift_ - B, child_size, v, args...); 1792| 1.14k| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_14equals_visitorEJRNS1_11relaxed_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcPT_jmT0_DpOT1_: 1830| 1.14k|{ 1831| 1.14k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 1.14k| if (relaxed) { ------------------ | Branch (1833:9): [True: 1.11k, False: 31] ------------------ 1834| 1.11k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 1.11k| .visit(v, std::forward(args)...); 1837| 1.11k| } else { 1838| 31| return make_regular_sub_pos(node, shift, size) 1839| 31| .visit(v, std::forward(args)...); 1840| 31| } 1841| 1.14k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRSD_RNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 1805| 1.11k| { 1806| 1.11k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 1.11k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRNS1_11relaxed_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 1028| 31| { 1029| 31| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 31| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7nth_subINS1_14equals_visitor10this_aux_tEJRjRNS1_15regular_sub_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEmEEEDcjT_DpOT0_: 1785| 130| { 1786| 130| auto child = node_->inner()[offset]; 1787| 130| auto child_size = size(offset); 1788| 130| auto is_leaf = shift_ == BL; 1789| 130| return is_leaf ? make_leaf_sub_pos(child, child_size).visit(v, args...) ------------------ | Branch (1789:16): [True: 110, False: 20] ------------------ 1790| 130| : visit_maybe_relaxed_sub( 1791| 20| child, shift_ - B, child_size, v, args...); 1792| 130| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitor10this_aux_tEJRjRNS1_15regular_sub_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 143| 110| { 144| 110| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 110| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE12nth_sub_leafINS1_14equals_visitorEJRNS1_12leaf_sub_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcjT_DpOT0_: 1017| 110| { 1018| 110| assert(shift_ == BL); 1019| 0| auto child = node_->inner()[idx]; 1020| 110| auto lsize = size(idx); 1021| 110| auto is_full = idx + 1 < count(); 1022| 110| return is_full ? make_full_leaf_pos(child).visit(v, args...) ------------------ | Branch (1022:16): [True: 101, False: 9] ------------------ 1023| 110| : make_leaf_sub_pos(child, lsize).visit(v, args...); 1024| 110| } _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRNS1_12leaf_sub_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 205| 193| { 206| 193| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 193| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_14equals_visitor10this_aux_tEJRjRNS1_15regular_sub_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcPT_jmT0_DpOT1_: 1830| 20|{ 1831| 20| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 20| if (relaxed) { ------------------ | Branch (1833:9): [True: 20, False: 0] ------------------ 1834| 20| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 20| .visit(v, std::forward(args)...); 1837| 20| } else { 1838| 0| return make_regular_sub_pos(node, shift, size) 1839| 0| .visit(v, std::forward(args)...); 1840| 0| } 1841| 20|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitor10this_aux_tEJRjRNS1_15regular_sub_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 1805| 20| { 1806| 20| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 20| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7nth_subINS1_14equals_visitorEJRNS1_11relaxed_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcjT_DpOT0_: 999| 20| { 1000| 20| assert(idx < count()); 1001| 0| auto is_leaf = shift_ == BL; 1002| 20| auto child = node_->inner()[idx]; 1003| 20| auto lsize = size(idx); 1004| 20| auto is_full = idx + 1 < count(); 1005| 20| return is_full ------------------ | Branch (1005:16): [True: 20, False: 0] ------------------ 1006| 20| ? (is_leaf ------------------ | Branch (1006:23): [True: 0, False: 20] ------------------ 1007| 20| ? make_full_leaf_pos(child).visit(v, args...) 1008| 20| : make_full_pos(child, shift_ - B).visit(v, args...)) 1009| 20| : (is_leaf ------------------ | Branch (1009:23): [True: 0, False: 0] ------------------ 1010| 0| ? make_leaf_sub_pos(child, lsize).visit(v, args...) 1011| 0| : make_regular_sub_pos(child, shift_ - B, lsize) 1012| 0| .visit(v, args...)); 1013| 20| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRNS1_11relaxed_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 1397| 60| { 1398| 60| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 60| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7nth_subINS1_14equals_visitor10this_aux_tEJRjRNS1_8full_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEmEEEDcjT_DpOT0_: 1785| 148| { 1786| 148| auto child = node_->inner()[offset]; 1787| 148| auto child_size = size(offset); 1788| 148| auto is_leaf = shift_ == BL; 1789| 148| return is_leaf ? make_leaf_sub_pos(child, child_size).visit(v, args...) ------------------ | Branch (1789:16): [True: 92, False: 56] ------------------ 1790| 148| : visit_maybe_relaxed_sub( 1791| 56| child, shift_ - B, child_size, v, args...); 1792| 148| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitor10this_aux_tEJRjRNS1_8full_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 143| 92| { 144| 92| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 92| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE12nth_sub_leafINS1_14equals_visitorEJRNS1_12leaf_sub_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcjT_DpOT0_: 1388| 92| { 1389| 92| assert(shift_ == BL); 1390| 0| assert(idx < count()); 1391| 0| auto child = node_->inner()[idx]; 1392| 92| return make_full_leaf_pos(child).visit(v, args...); 1393| 92| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_14equals_visitor10this_aux_tEJRjRNS1_8full_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcPT_jmT0_DpOT1_: 1830| 56|{ 1831| 56| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 56| if (relaxed) { ------------------ | Branch (1833:9): [True: 40, False: 16] ------------------ 1834| 40| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 40| .visit(v, std::forward(args)...); 1837| 40| } else { 1838| 16| return make_regular_sub_pos(node, shift, size) 1839| 16| .visit(v, std::forward(args)...); 1840| 16| } 1841| 56|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitor10this_aux_tEJRjRNS1_8full_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 1805| 40| { 1806| 40| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 40| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7nth_subINS1_14equals_visitorEJRNS1_11relaxed_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcjT_DpOT0_: 1378| 40| { 1379| 40| assert(idx < count()); 1380| 0| auto is_leaf = shift_ == BL; 1381| 40| auto child = node_->inner()[idx]; 1382| 40| return is_leaf ? make_full_leaf_pos(child).visit(v, args...) ------------------ | Branch (1382:16): [True: 0, False: 40] ------------------ 1383| 40| : make_full_pos(child, shift_ - B).visit(v, args...); 1384| 40| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitor10this_aux_tEJRjRNS1_8full_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 1028| 16| { 1029| 16| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 16| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7nth_subINS1_14equals_visitorEJRNS1_15regular_sub_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcjT_DpOT0_: 1378| 16| { 1379| 16| assert(idx < count()); 1380| 0| auto is_leaf = shift_ == BL; 1381| 16| auto child = node_->inner()[idx]; 1382| 16| return is_leaf ? make_full_leaf_pos(child).visit(v, args...) ------------------ | Branch (1382:16): [True: 0, False: 16] ------------------ 1383| 16| : make_full_pos(child, shift_ - B).visit(v, args...); 1384| 16| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRNS1_15regular_sub_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 1397| 16| { 1398| 16| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 16| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13each_pred_zipINS1_14equals_visitorEJEEEbT_PSC_DpOT0_: 1214| 19| { 1215| 19| auto p = node_->inner(); 1216| 19| auto p2 = other->inner(); 1217| 19| auto e = p + branches; 1218| 19| if (shift_ == BL) { ------------------ | Branch (1218:13): [True: 19, False: 0] ------------------ 1219| 169| for (; p != e; ++p, ++p2) { ------------------ | Branch (1219:20): [True: 152, False: 17] ------------------ 1220| 152| IMMER_PREFETCH(p + 1); 1221| 152| if (!make_full_leaf_pos(*p).visit(v, *p2, args...)) ------------------ | Branch (1221:21): [True: 2, False: 150] ------------------ 1222| 2| return false; 1223| 152| } 1224| 19| } else { 1225| 0| auto ss = shift_ - B; 1226| 0| for (; p != e; ++p, ++p2) ------------------ | Branch (1226:20): [True: 0, False: 0] ------------------ 1227| 0| if (!make_full_pos(*p, ss).visit(v, *p2, args...)) ------------------ | Branch (1227:21): [True: 0, False: 0] ------------------ 1228| 0| return false; 1229| 0| } 1230| 17| return true; 1231| 19| } _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRPSC_EEEDcT_DpOT0_: 205| 540| { 206| 540| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 540| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRPSC_EEEDcT_DpOT0_: 1397| 106| { 1398| 106| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 106| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13each_pred_zipINS1_14equals_visitorEJEEEbT_PSC_DpOT0_: 829| 198| { 830| 198| return each_pred_zip_regular(*this, v, other, args...); 831| 198| } _ZN5immer6detail4rbts21each_pred_zip_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_14equals_visitorEJEEEbOT_T0_PNSt3__15decayISH_E4type6node_tEDpOT1_: 390| 198|{ 391| 198| constexpr auto B = bits; 392| 198| constexpr auto BL = bits_leaf; 393| | 394| 198| auto n = p.node()->inner(); 395| 198| auto n2 = other->inner(); 396| 198| auto last = p.count() - 1; 397| 198| auto e = n + last; 398| 198| if (p.shift() == BL) { ------------------ | Branch (398:9): [True: 132, False: 66] ------------------ 399| 325| for (; n != e; ++n, ++n2) { ------------------ | Branch (399:16): [True: 208, False: 117] ------------------ 400| 208| IMMER_PREFETCH(n + 1); 401| 208| IMMER_PREFETCH(n2 + 1); 402| 208| if (!make_full_leaf_pos(*n).visit(v, *n2, args...)) ------------------ | Branch (402:17): [True: 15, False: 193] ------------------ 403| 15| return false; 404| 208| } 405| 117| return make_leaf_pos(*n, p.size()).visit(v, *n2, args...); 406| 132| } else { 407| 66| auto ss = p.shift() - B; 408| 170| for (; n != e; ++n, ++n2) ------------------ | Branch (408:16): [True: 106, False: 64] ------------------ 409| 106| if (!make_full_pos(*n, ss).visit(v, *n2, args...)) ------------------ | Branch (409:17): [True: 2, False: 104] ------------------ 410| 2| return false; 411| 64| return make_regular_pos(*n, ss, p.size()).visit(v, *n2, args...); 412| 66| } 413| 198|} _ZN5immer6detail4rbts8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRPSC_EEEDcT_DpOT0_: 111| 156| { 112| 156| return Visitor::visit_leaf(*this, std::forward(args)...); 113| 156| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRPSC_EEEDcT_DpOT0_: 334| 64| { 335| 64| return Visitor::visit_regular(*this, std::forward(args)...); 336| 64| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE13each_pred_zipINS1_14equals_visitorEJEEEbT_PSC_DpOT0_: 253| 64| { 254| 64| return each_pred_zip_regular(*this, v, other, args...); 255| 64| } _ZN5immer6detail4rbts21each_pred_zip_regularIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_14equals_visitorEJEEEbOT_T0_PNSt3__15decayISH_E4type6node_tEDpOT1_: 390| 64|{ 391| 64| constexpr auto B = bits; 392| 64| constexpr auto BL = bits_leaf; 393| | 394| 64| auto n = p.node()->inner(); 395| 64| auto n2 = other->inner(); 396| 64| auto last = p.count() - 1; 397| 64| auto e = n + last; 398| 64| if (p.shift() == BL) { ------------------ | Branch (398:9): [True: 64, False: 0] ------------------ 399| 219| for (; n != e; ++n, ++n2) { ------------------ | Branch (399:16): [True: 180, False: 39] ------------------ 400| 180| IMMER_PREFETCH(n + 1); 401| 180| IMMER_PREFETCH(n2 + 1); 402| 180| if (!make_full_leaf_pos(*n).visit(v, *n2, args...)) ------------------ | Branch (402:17): [True: 25, False: 155] ------------------ 403| 25| return false; 404| 180| } 405| 39| return make_leaf_pos(*n, p.size()).visit(v, *n2, args...); 406| 64| } else { 407| 0| auto ss = p.shift() - B; 408| 0| for (; n != e; ++n, ++n2) ------------------ | Branch (408:16): [True: 0, False: 0] ------------------ 409| 0| if (!make_full_pos(*n, ss).visit(v, *n2, args...)) ------------------ | Branch (409:17): [True: 0, False: 0] ------------------ 410| 0| return false; 411| 0| return make_regular_pos(*n, ss, p.size()).visit(v, *n2, args...); 412| 0| } 413| 64|} _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7nth_subINS1_24for_each_chunk_p_visitorEJZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEEEDaOT_EUlSK_T0_E_EEEDcjSK_DpOT0_: 1378| 311| { 1379| 311| assert(idx < count()); 1380| 0| auto is_leaf = shift_ == BL; 1381| 311| auto child = node_->inner()[idx]; 1382| 311| return is_leaf ? make_full_leaf_pos(child).visit(v, args...) ------------------ | Branch (1382:16): [True: 61, False: 250] ------------------ 1383| 311| : make_full_pos(child, shift_ - B).visit(v, args...); 1384| 311| } _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_24for_each_chunk_p_visitorEJRZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEEEDaOT_EUlSK_T0_E_EEEDcSK_DpOT0_: 205| 257k| { 206| 257k| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 257k| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_18region_for_visitorIiEEJRmEEEDcPT_jmT0_DpOT1_: 1830| 1.32M|{ 1831| 1.32M| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 1.32M| if (relaxed) { ------------------ | Branch (1833:9): [True: 1.06M, False: 258k] ------------------ 1834| 1.06M| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 1.06M| .visit(v, std::forward(args)...); 1837| 1.06M| } else { 1838| 258k| return make_regular_sub_pos(node, shift, size) 1839| 258k| .visit(v, std::forward(args)...); 1840| 258k| } 1841| 1.32M|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_18region_for_visitorIiEEJRmEEEDcT_DpOT0_: 1805| 1.06M| { 1806| 1.06M| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 1.06M| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7towardsINS1_18region_for_visitorIiEEJEEEDcT_mDpOT0_: 1671| 1.06M| { 1672| 1.06M| return towards_oh(v, idx, subindex(idx), args...); 1673| 1.06M| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_18region_for_visitorIiEEJEEEDcT_mjDpOT0_: 1678| 1.06M| { 1679| 1.06M| assert(offset_hint == index(idx)); 1680| 1.06M| auto left_size = offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0; ------------------ | Branch (1680:26): [True: 820k, False: 241k] ------------------ 1681| 1.06M| return towards_oh_sbh(v, idx, offset_hint, left_size, args...); 1682| 1.06M| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE14towards_oh_sbhINS1_18region_for_visitorIiEEJEEEDcT_mjmDpOT0_: 1690| 1.06M| { 1691| 1.06M| return towards_sub_oh_sbh(v, idx, offset_hint, left_size_hint, args...); 1692| 1.06M| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE18towards_sub_oh_sbhINS1_18region_for_visitorIiEEJEEEDcT_mjmDpOT0_: 1709| 1.06M| { 1710| 1.06M| assert(offset_hint == index(idx)); 1711| 0| assert(left_size_hint == 1712| 1.06M| (offset_hint ? relaxed_->d.sizes[offset_hint - 1] : 0)); 1713| 0| auto child = node_->inner()[offset_hint]; 1714| 1.06M| auto is_leaf = shift_ == BL; 1715| 1.06M| auto next_size = relaxed_->d.sizes[offset_hint] - left_size_hint; 1716| 1.06M| auto next_idx = idx - left_size_hint; 1717| 1.06M| return is_leaf ------------------ | Branch (1717:16): [True: 139k, False: 922k] ------------------ 1718| 1.06M| ? make_leaf_sub_pos(child, next_size) 1719| 139k| .visit(v, next_idx, args...) 1720| 1.06M| : visit_maybe_relaxed_sub( 1721| 922k| child, shift_ - B, next_size, v, next_idx, args...); 1722| 1.06M| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_18region_for_visitorIiEEJRmEEEDcT_DpOT0_: 143| 139k| { 144| 139k| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 139k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_18region_for_visitorIiEEJRmEEEDcT_DpOT0_: 1028| 258k| { 1029| 258k| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 258k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7towardsINS1_18region_for_visitorIiEEJEEEDcT_mDpOT0_: 911| 258k| { 912| 258k| return towards_oh_ch_regular( 913| 258k| *this, v, idx, index(idx), count(), args...); 914| 258k| } _ZN5immer6detail4rbts21towards_oh_ch_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_18region_for_visitorIiEEJEEEDcOT_T0_mjjDpOT1_: 630| 258k|{ 631| 258k| constexpr auto B = bits; 632| 258k| constexpr auto BL = bits_leaf; 633| 258k| assert(offset_hint == p.index(idx)); 634| 0| assert(count_hint == p.count()); 635| 0| auto is_leaf = p.shift() == BL; 636| 258k| auto child = p.node()->inner()[offset_hint]; 637| 258k| auto is_full = offset_hint + 1 != count_hint; 638| 258k| return is_full ------------------ | Branch (638:12): [True: 234k, False: 23.6k] ------------------ 639| 258k| ? (is_leaf ? make_full_leaf_pos(child).visit(v, idx, args...) ------------------ | Branch (639:19): [True: 3.83k, False: 231k] ------------------ 640| 234k| : make_full_pos(child, p.shift() - B) 641| 231k| .visit(v, idx, args...)) 642| 258k| : (is_leaf ------------------ | Branch (642:19): [True: 729, False: 22.9k] ------------------ 643| 23.6k| ? make_leaf_pos(child, p.size()).visit(v, idx, args...) 644| 23.6k| : make_regular_pos(child, p.shift() - B, p.size()) 645| 22.9k| .visit(v, idx, args...)); 646| 258k|} _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_18region_for_visitorIiEEJRmEEEDcT_DpOT0_: 205| 257k| { 206| 257k| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 257k| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_18region_for_visitorIiEEJRmEEEDcT_DpOT0_: 1397| 615k| { 1398| 615k| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 615k| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7towardsINS1_18region_for_visitorIiEEJEEEDcT_mDpOT0_: 1314| 615k| { 1315| 615k| return towards_oh(v, idx, index(idx), args...); 1316| 615k| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE10towards_ohINS1_18region_for_visitorIiEEJEEEDcT_mjDpOT0_: 1328| 615k| { 1329| 615k| assert(offset_hint == index(idx)); 1330| 0| auto is_leaf = shift_ == BL; 1331| 615k| auto child = node_->inner()[offset_hint]; 1332| 615k| return is_leaf ------------------ | Branch (1332:16): [True: 250k, False: 365k] ------------------ 1333| 615k| ? make_full_leaf_pos(child).visit(v, idx, args...) 1334| 615k| : make_full_pos(child, shift_ - B).visit(v, idx, args...); 1335| 615k| } _ZN5immer6detail4rbts8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_18region_for_visitorIiEEJRmEEEDcT_DpOT0_: 111| 1.46k| { 112| 1.46k| return Visitor::visit_leaf(*this, std::forward(args)...); 113| 1.46k| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_18region_for_visitorIiEEJRmEEEDcT_DpOT0_: 334| 25.6k| { 335| 25.6k| return Visitor::visit_regular(*this, std::forward(args)...); 336| 25.6k| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7towardsINS1_18region_for_visitorIiEEJEEEDcT_mDpOT0_: 295| 25.6k| { 296| 25.6k| return towards_oh_ch_regular( 297| 25.6k| *this, v, idx, index(idx), count(), args...); 298| 25.6k| } _ZN5immer6detail4rbts21towards_oh_ch_regularIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_18region_for_visitorIiEEJEEEDcOT_T0_mjjDpOT1_: 630| 25.6k|{ 631| 25.6k| constexpr auto B = bits; 632| 25.6k| constexpr auto BL = bits_leaf; 633| 25.6k| assert(offset_hint == p.index(idx)); 634| 0| assert(count_hint == p.count()); 635| 0| auto is_leaf = p.shift() == BL; 636| 25.6k| auto child = p.node()->inner()[offset_hint]; 637| 25.6k| auto is_full = offset_hint + 1 != count_hint; 638| 25.6k| return is_full ------------------ | Branch (638:12): [True: 22.2k, False: 3.46k] ------------------ 639| 25.6k| ? (is_leaf ? make_full_leaf_pos(child).visit(v, idx, args...) ------------------ | Branch (639:19): [True: 3.12k, False: 19.1k] ------------------ 640| 22.2k| : make_full_pos(child, p.shift() - B) 641| 19.1k| .visit(v, idx, args...)) 642| 25.6k| : (is_leaf ------------------ | Branch (642:19): [True: 731, False: 2.73k] ------------------ 643| 3.46k| ? make_leaf_pos(child, p.size()).visit(v, idx, args...) 644| 3.46k| : make_regular_pos(child, p.shift() - B, p.size()) 645| 2.73k| .visit(v, idx, args...)); 646| 25.6k|} _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_24for_each_chunk_p_visitorEJRZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEEEDaOT_EUlSK_T0_E_EEEDcSK_DpOT0_: 1397| 36.1k| { 1398| 36.1k| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 36.1k| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9each_predINS1_24for_each_chunk_p_visitorEJRZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEEEDaOT_EUlSK_T0_E_EEEbSK_DpOT0_: 1194| 36.1k| { 1195| 36.1k| auto p = node_->inner(); 1196| 36.1k| auto e = p + branches; 1197| 36.1k| if (shift_ == BL) { ------------------ | Branch (1197:13): [True: 31.8k, False: 4.30k] ------------------ 1198| 286k| for (; p != e; ++p) { ------------------ | Branch (1198:20): [True: 254k, False: 31.7k] ------------------ 1199| 254k| IMMER_PREFETCH(p + 1); 1200| 254k| if (!make_full_leaf_pos(*p).visit(v, args...)) ------------------ | Branch (1200:21): [True: 81, False: 254k] ------------------ 1201| 81| return false; 1202| 254k| } 1203| 31.8k| } else { 1204| 4.30k| auto ss = shift_ - B; 1205| 38.3k| for (; p != e; ++p) ------------------ | Branch (1205:20): [True: 34.1k, False: 4.19k] ------------------ 1206| 34.1k| if (!make_full_pos(*p, ss).visit(v, args...)) ------------------ | Branch (1206:21): [True: 113, False: 34.0k] ------------------ 1207| 113| return false; 1208| 4.30k| } 1209| 35.9k| return true; 1210| 36.1k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRSD_RNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 1028| 27| { 1029| 27| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 27| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7nth_subINS1_24for_each_chunk_p_visitorEJZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEEEDaOT_EUlSK_T0_E_EEEDcjSK_DpOT0_: 999| 173| { 1000| 173| assert(idx < count()); 1001| 0| auto is_leaf = shift_ == BL; 1002| 173| auto child = node_->inner()[idx]; 1003| 173| auto lsize = size(idx); 1004| 173| auto is_full = idx + 1 < count(); 1005| 173| return is_full ------------------ | Branch (1005:16): [True: 147, False: 26] ------------------ 1006| 173| ? (is_leaf ------------------ | Branch (1006:23): [True: 36, False: 111] ------------------ 1007| 147| ? make_full_leaf_pos(child).visit(v, args...) 1008| 147| : make_full_pos(child, shift_ - B).visit(v, args...)) 1009| 173| : (is_leaf ------------------ | Branch (1009:23): [True: 15, False: 11] ------------------ 1010| 26| ? make_leaf_sub_pos(child, lsize).visit(v, args...) 1011| 26| : make_regular_sub_pos(child, shift_ - B, lsize) 1012| 11| .visit(v, args...)); 1013| 173| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_24for_each_chunk_p_visitorEJRZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEEEDaOT_EUlSK_T0_E_EEEDcSK_DpOT0_: 143| 137k| { 144| 137k| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 137k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_24for_each_chunk_p_visitorEJRZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEEEDaOT_EUlSK_T0_E_EEEDcSK_DpOT0_: 1028| 557| { 1029| 557| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 557| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9each_predINS1_24for_each_chunk_p_visitorEJRZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEEEDaOT_EUlSK_T0_E_EEEbSK_DpOT0_: 823| 557| { 824| 557| return each_pred_regular(*this, v, args...); 825| 557| } _ZN5immer6detail4rbts17each_pred_regularIRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_24for_each_chunk_p_visitorEJRZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSC_Lj3ELj3EEEEEDaOT_EUlSL_T0_E_EEEbSM_SN_DpOT1_: 363| 557|{ 364| 557| constexpr auto B = bits; 365| 557| constexpr auto BL = bits_leaf; 366| 557| auto n = p.node()->inner(); 367| 557| auto last = p.count() - 1; 368| 557| auto e = n + last; 369| 557| if (p.shift() == BL) { ------------------ | Branch (369:9): [True: 339, False: 218] ------------------ 370| 2.64k| for (; n != e; ++n) { ------------------ | Branch (370:16): [True: 2.31k, False: 333] ------------------ 371| 2.31k| IMMER_PREFETCH(n + 1); 372| 2.31k| if (!make_full_leaf_pos(*n).visit(v, args...)) ------------------ | Branch (372:17): [True: 6, False: 2.31k] ------------------ 373| 6| return false; 374| 2.31k| } 375| 333| return make_leaf_pos(*n, p.size()).visit(v, args...); 376| 339| } else { 377| 218| auto ss = p.shift() - B; 378| 1.27k| for (; n != e; ++n) ------------------ | Branch (378:16): [True: 1.09k, False: 172] ------------------ 379| 1.09k| if (!make_full_pos(*n, ss).visit(v, args...)) ------------------ | Branch (379:17): [True: 46, False: 1.05k] ------------------ 380| 46| return false; 381| 172| return make_regular_pos(*n, ss, p.size()).visit(v, args...); 382| 218| } 383| 557|} _ZN5immer6detail4rbts8leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_24for_each_chunk_p_visitorEJRZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEEEDaOT_EUlSK_T0_E_EEEDcSK_DpOT0_: 111| 478| { 112| 478| return Visitor::visit_leaf(*this, std::forward(args)...); 113| 478| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_24for_each_chunk_p_visitorEJRZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEEEDaOT_EUlSK_T0_E_EEEDcSK_DpOT0_: 334| 291| { 335| 291| return Visitor::visit_regular(*this, std::forward(args)...); 336| 291| } _ZN5immer6detail4rbts11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9each_predINS1_24for_each_chunk_p_visitorEJRZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEEEDaOT_EUlSK_T0_E_EEEbSK_DpOT0_: 247| 291| { 248| 291| return each_pred_regular(*this, v, args...); 249| 291| } _ZN5immer6detail4rbts17each_pred_regularIRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_24for_each_chunk_p_visitorEJRZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSC_Lj3ELj3EEEEEDaOT_EUlSL_T0_E_EEEbSM_SN_DpOT1_: 363| 291|{ 364| 291| constexpr auto B = bits; 365| 291| constexpr auto BL = bits_leaf; 366| 291| auto n = p.node()->inner(); 367| 291| auto last = p.count() - 1; 368| 291| auto e = n + last; 369| 291| if (p.shift() == BL) { ------------------ | Branch (369:9): [True: 145, False: 146] ------------------ 370| 984| for (; n != e; ++n) { ------------------ | Branch (370:16): [True: 839, False: 145] ------------------ 371| 839| IMMER_PREFETCH(n + 1); 372| 839| if (!make_full_leaf_pos(*n).visit(v, args...)) ------------------ | Branch (372:17): [True: 0, False: 839] ------------------ 373| 0| return false; 374| 839| } 375| 145| return make_leaf_pos(*n, p.size()).visit(v, args...); 376| 146| } else { 377| 146| auto ss = p.shift() - B; 378| 676| for (; n != e; ++n) ------------------ | Branch (378:16): [True: 557, False: 119] ------------------ 379| 557| if (!make_full_pos(*n, ss).visit(v, args...)) ------------------ | Branch (379:17): [True: 27, False: 530] ------------------ 380| 27| return false; 381| 119| return make_regular_pos(*n, ss, p.size()).visit(v, args...); 382| 146| } 383| 291|} _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitor10this_aux_tEJRjRNS1_11relaxed_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 1028| 33| { 1029| 33| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 33| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7nth_subINS1_14equals_visitorEJRNS1_15regular_sub_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcjT_DpOT0_: 1785| 33| { 1786| 33| auto child = node_->inner()[offset]; 1787| 33| auto child_size = size(offset); 1788| 33| auto is_leaf = shift_ == BL; 1789| 33| return is_leaf ? make_leaf_sub_pos(child, child_size).visit(v, args...) ------------------ | Branch (1789:16): [True: 0, False: 33] ------------------ 1790| 33| : visit_maybe_relaxed_sub( 1791| 33| child, shift_ - B, child_size, v, args...); 1792| 33| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_14equals_visitorEJRNS1_15regular_sub_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcPT_jmT0_DpOT1_: 1830| 33|{ 1831| 33| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 33| if (relaxed) { ------------------ | Branch (1833:9): [True: 6, False: 27] ------------------ 1834| 6| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 6| .visit(v, std::forward(args)...); 1837| 27| } else { 1838| 27| return make_regular_sub_pos(node, shift, size) 1839| 27| .visit(v, std::forward(args)...); 1840| 27| } 1841| 33|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRNS1_15regular_sub_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 1805| 6| { 1806| 6| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 6| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7nth_subINS1_14equals_visitor10this_aux_tEJRjRNS1_11relaxed_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEmEEEDcjT_DpOT0_: 999| 48| { 1000| 48| assert(idx < count()); 1001| 0| auto is_leaf = shift_ == BL; 1002| 48| auto child = node_->inner()[idx]; 1003| 48| auto lsize = size(idx); 1004| 48| auto is_full = idx + 1 < count(); 1005| 48| return is_full ------------------ | Branch (1005:16): [True: 42, False: 6] ------------------ 1006| 48| ? (is_leaf ------------------ | Branch (1006:23): [True: 38, False: 4] ------------------ 1007| 42| ? make_full_leaf_pos(child).visit(v, args...) 1008| 42| : make_full_pos(child, shift_ - B).visit(v, args...)) 1009| 48| : (is_leaf ------------------ | Branch (1009:23): [True: 6, False: 0] ------------------ 1010| 6| ? make_leaf_sub_pos(child, lsize).visit(v, args...) 1011| 6| : make_regular_sub_pos(child, shift_ - B, lsize) 1012| 0| .visit(v, args...)); 1013| 48| } _ZN5immer6detail4rbts13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitor10this_aux_tEJRjRNS1_11relaxed_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 205| 70| { 206| 70| return Visitor::visit_leaf(*this, std::forward(args)...); 207| 70| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE12nth_sub_leafINS1_14equals_visitorEJRNS1_13full_leaf_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcjT_DpOT0_: 1796| 70| { 1797| 70| assert(shift_ == BL); 1798| 0| auto child = node_->inner()[offset]; 1799| 70| auto child_size = size(offset); 1800| 70| return make_leaf_sub_pos(child, child_size).visit(v, args...); 1801| 70| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRNS1_13full_leaf_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 143| 70| { 144| 70| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 70| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitor10this_aux_tEJRjRNS1_11relaxed_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 1397| 18| { 1398| 18| return Visitor::visit_regular(*this, std::forward(args)...); 1399| 18| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7nth_subINS1_14equals_visitorEJRNS1_8full_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcjT_DpOT0_: 1785| 18| { 1786| 18| auto child = node_->inner()[offset]; 1787| 18| auto child_size = size(offset); 1788| 18| auto is_leaf = shift_ == BL; 1789| 18| return is_leaf ? make_leaf_sub_pos(child, child_size).visit(v, args...) ------------------ | Branch (1789:16): [True: 0, False: 18] ------------------ 1790| 18| : visit_maybe_relaxed_sub( 1791| 18| child, shift_ - B, child_size, v, args...); 1792| 18| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_14equals_visitorEJRNS1_8full_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcPT_jmT0_DpOT1_: 1830| 18|{ 1831| 18| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 18| if (relaxed) { ------------------ | Branch (1833:9): [True: 15, False: 3] ------------------ 1834| 15| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 15| .visit(v, std::forward(args)...); 1837| 15| } else { 1838| 3| return make_regular_sub_pos(node, shift, size) 1839| 3| .visit(v, std::forward(args)...); 1840| 3| } 1841| 18|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRNS1_8full_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 1805| 15| { 1806| 15| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 15| } _ZN5immer6detail4rbts8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7nth_subINS1_14equals_visitor10this_aux_tEJRjRNS1_11relaxed_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEmEEEDcjT_DpOT0_: 1378| 46| { 1379| 46| assert(idx < count()); 1380| 0| auto is_leaf = shift_ == BL; 1381| 46| auto child = node_->inner()[idx]; 1382| 46| return is_leaf ? make_full_leaf_pos(child).visit(v, args...) ------------------ | Branch (1382:16): [True: 32, False: 14] ------------------ 1383| 46| : make_full_pos(child, shift_ - B).visit(v, args...); 1384| 46| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRNS1_8full_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERmEEEDcT_DpOT0_: 1028| 3| { 1029| 3| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 3| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE7nth_subINS1_24for_each_chunk_p_visitorEJZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEEEDaOT_EUlSK_T0_E_EEEDcjSK_DpOT0_: 1785| 1.68k| { 1786| 1.68k| auto child = node_->inner()[offset]; 1787| 1.68k| auto child_size = size(offset); 1788| 1.68k| auto is_leaf = shift_ == BL; 1789| 1.68k| return is_leaf ? make_leaf_sub_pos(child, child_size).visit(v, args...) ------------------ | Branch (1789:16): [True: 561, False: 1.12k] ------------------ 1790| 1.68k| : visit_maybe_relaxed_sub( 1791| 1.12k| child, shift_ - B, child_size, v, args...); 1792| 1.68k| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_24for_each_chunk_p_visitorEJRZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEEEDaOT_EUlSI_T0_E_EEEDcPSI_jmSK_DpOT1_: 1830| 22.3k|{ 1831| 22.3k| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 22.3k| if (relaxed) { ------------------ | Branch (1833:9): [True: 21.8k, False: 546] ------------------ 1834| 21.8k| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 21.8k| .visit(v, std::forward(args)...); 1837| 21.8k| } else { 1838| 546| return make_regular_sub_pos(node, shift, size) 1839| 546| .visit(v, std::forward(args)...); 1840| 546| } 1841| 22.3k|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_24for_each_chunk_p_visitorEJRZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEEEDaOT_EUlSK_T0_E_EEEDcSK_DpOT0_: 1805| 21.8k| { 1806| 21.8k| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 21.8k| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE9each_predINS1_24for_each_chunk_p_visitorEJRZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEEEDaOT_EUlSK_T0_E_EEEbSK_DpOT0_: 1474| 21.8k| { 1475| 21.8k| auto p = node_->inner(); 1476| 21.8k| auto s = size_t{}; 1477| 21.8k| auto n = count(); 1478| 21.8k| if (shift_ == BL) { ------------------ | Branch (1478:13): [True: 18.8k, False: 2.97k] ------------------ 1479| 156k| for (auto i = count_t{0}; i < n; ++i) { ------------------ | Branch (1479:39): [True: 137k, False: 18.7k] ------------------ 1480| 137k| IMMER_PREFETCH(p + i + 1); 1481| 137k| if (!make_leaf_sub_pos(p[i], relaxed_->d.sizes[i] - s) ------------------ | Branch (1481:21): [True: 56, False: 137k] ------------------ 1482| 137k| .visit(v, args...)) 1483| 56| return false; 1484| 137k| s = relaxed_->d.sizes[i]; 1485| 137k| } 1486| 18.8k| } else { 1487| 2.97k| auto ss = shift_ - B; 1488| 24.1k| for (auto i = count_t{0}; i < n; ++i) { ------------------ | Branch (1488:39): [True: 21.2k, False: 2.94k] ------------------ 1489| 21.2k| if (!visit_maybe_relaxed_sub( ------------------ | Branch (1489:21): [True: 28, False: 21.2k] ------------------ 1490| 21.2k| p[i], ss, relaxed_->d.sizes[i] - s, v, args...)) 1491| 28| return false; 1492| 21.2k| s = relaxed_->d.sizes[i]; 1493| 21.2k| } 1494| 2.97k| } 1495| 21.7k| return true; 1496| 21.8k| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRNS1_11relaxed_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEmEEEDcT_DpOT0_: 1028| 37| { 1029| 37| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 37| } _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE15first_sub_innerINS1_14equals_visitor3rrbEJRNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERPSC_RjRmEEEDcT_DpOT0_: 1775| 2| { 1776| 2| assert(shift_ > BL); 1777| 0| auto child = node_->inner()[0]; 1778| 2| auto child_size = relaxed_->d.sizes[0]; 1779| 2| return visit_maybe_relaxed_sub( 1780| 2| child, shift_ - B, child_size, v, args...); 1781| 2| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_14equals_visitor3rrbEJRNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERPSC_RjRmEEEDcPT_jmT0_DpOT1_: 1830| 2|{ 1831| 2| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 2| if (relaxed) { ------------------ | Branch (1833:9): [True: 2, False: 0] ------------------ 1834| 2| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 2| .visit(v, std::forward(args)...); 1837| 2| } else { 1838| 0| return make_regular_sub_pos(node, shift, size) 1839| 0| .visit(v, std::forward(args)...); 1840| 0| } 1841| 2|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitor3rrbEJRNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERPSC_RjRmEEEDcT_DpOT0_: 1805| 2| { 1806| 2| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 2| } _ZN5immer6detail4rbts23visit_maybe_relaxed_subINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS1_14equals_visitorEJRNS1_15regular_sub_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEmEEEDcPT_jmT0_DpOT1_: 1830| 256|{ 1831| 256| assert(node); 1832| 0| auto relaxed = node->relaxed(); 1833| 256| if (relaxed) { ------------------ | Branch (1833:9): [True: 24, False: 232] ------------------ 1834| 24| assert(size == relaxed->d.sizes[relaxed->d.count - 1]); 1835| 0| return make_relaxed_pos(node, shift, relaxed) 1836| 24| .visit(v, std::forward(args)...); 1837| 232| } else { 1838| 232| return make_regular_sub_pos(node, shift, size) 1839| 232| .visit(v, std::forward(args)...); 1840| 232| } 1841| 256|} _ZN5immer6detail4rbts11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRNS1_15regular_sub_posISC_EERNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEmEEEDcT_DpOT0_: 1805| 24| { 1806| 24| return Visitor::visit_relaxed(*this, std::forward(args)...); 1807| 24| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRSD_RNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEEmEEEDcT_DpOT0_: 1028| 232| { 1029| 232| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 232| } _ZN5immer6detail4rbts15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitor3rrbEJNS1_16rrbtree_iteratorIiSB_Lj3ELj3EEERKPSC_RKjRmEEEDcT_DpOT0_: 1028| 256| { 1029| 256| return Visitor::visit_regular(*this, std::forward(args)...); 1030| 256| } _ZN5immer6detail4rbts12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEE5visitINS1_14equals_visitorEJRKPSC_EEEDcT_DpOT0_: 143| 424| { 144| 424| return Visitor::visit_leaf(*this, std::forward(args)...); 145| 424| } _ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEC2Ev: 106| 969k| { 107| 969k| assert(check_tree()); 108| 969k| } _ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE10empty_rootEv: 51| 970k| { 52| 970k| static const auto empty_ = []{ 53| 970k| constexpr auto size = node_t::sizeof_inner_n(0); 54| 970k| static std::aligned_storage_t storage; 55| 970k| return node_t::make_inner_n_into(&storage, size, 0u); 56| 970k| }(); 57| 970k| return empty_->inc(); 58| 970k| } _ZZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE10empty_rootEvENKUlvE_clEv: 52| 1| static const auto empty_ = []{ 53| 1| constexpr auto size = node_t::sizeof_inner_n(0); 54| 1| static std::aligned_storage_t storage; 55| 1| return node_t::make_inner_n_into(&storage, size, 0u); 56| 1| }(); _ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE10empty_tailEv: 61| 969k| { 62| 969k| static const auto empty_ = []{ 63| 969k| constexpr auto size = node_t::sizeof_leaf_n(0); 64| 969k| static std::aligned_storage_t storage; 65| 969k| return node_t::make_leaf_n_into(&storage, size, 0u); 66| 969k| }(); 67| 969k| return empty_->inc(); 68| 969k| } _ZZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE10empty_tailEvENKUlvE_clEv: 62| 1| static const auto empty_ = []{ 63| 1| constexpr auto size = node_t::sizeof_leaf_n(0); 64| 1| static std::aligned_storage_t storage; 65| 1| return node_t::make_leaf_n_into(&storage, size, 0u); 66| 1| }(); _ZNK5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE10check_treeEv: 1341| 2.23M| { 1342| 2.23M| assert(shift <= sizeof(size_t) * 8 - BL); 1343| 0| assert(shift >= BL); 1344| 0| assert(tail_offset() <= size); 1345| 0| assert(tail_size() <= branches); 1346| |#if IMMER_DEBUG_DEEP_CHECK 1347| | assert(check_root()); 1348| | assert(check_tail()); 1349| |#endif 1350| 0| return true; 1351| 2.23M| } _ZNK5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11tail_offsetEv: 166| 10.8M| { 167| 10.8M| auto r = root->relaxed(); 168| 10.8M| assert(r == nullptr || r->d.count); 169| 10.8M| return r ? r->d.sizes[r->d.count - 1] ------------------ | Branch (169:16): [True: 4.99M, False: 5.89M] ------------------ 170| 10.8M| : size ? (size - 1) & ~mask ------------------ | Branch (170:18): [True: 2.98M, False: 2.91M] ------------------ 171| | /* otherwise */ 172| 5.89M| : 0; 173| 10.8M| } _ZNK5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE9tail_sizeEv: 163| 2.39M| auto tail_size() const { return size - tail_offset(); } _ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EED2Ev: 153| 2.23M| ~rrbtree() { dec(); } _ZNK5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE3decEv: 161| 2.23M| void dec() const { traverse(dec_visitor()); } _ZNK5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE8traverseINS1_11dec_visitorEJEEEvT_DpOT0_: 177| 2.23M| { 178| 2.23M| auto tail_off = tail_offset(); 179| 2.23M| auto tail_size = size - tail_off; 180| | 181| 2.23M| if (tail_off) ------------------ | Branch (181:13): [True: 1.02M, False: 1.20M] ------------------ 182| 1.02M| visit_maybe_relaxed_sub(root, shift, tail_off, v, args...); 183| 1.20M| else 184| 1.20M| make_empty_regular_pos(root).visit(v, args...); 185| | 186| 2.23M| if (tail_size) ------------------ | Branch (186:13): [True: 1.26M, False: 969k] ------------------ 187| 1.26M| make_leaf_sub_pos(tail, tail_size).visit(v, args...); 188| 969k| else 189| 969k| make_empty_leaf_pos(tail).visit(v, args...); 190| 2.23M| } _ZNK5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE9push_backEi: 469| 153k| { 470| 153k| auto ts = tail_size(); 471| 153k| if (ts < branches) { ------------------ | Branch (471:13): [True: 133k, False: 19.5k] ------------------ 472| 133k| auto new_tail = 473| 133k| node_t::copy_leaf_emplace(tail, ts, std::move(value)); 474| 133k| return {size + 1, shift, root->inc(), new_tail}; 475| 133k| } else { 476| 19.5k| using std::get; 477| 19.5k| auto new_tail = node_t::make_leaf_n(1u, std::move(value)); 478| 19.5k| auto tail_off = tail_offset(); 479| 19.5k| IMMER_TRY { ------------------ | | 41| 19.5k|#define IMMER_TRY try ------------------ 480| 19.5k| auto new_root = 481| 19.5k| push_tail(root, shift, tail_off, tail, size - tail_off); 482| 19.5k| tail->inc(); 483| 19.5k| return {size + 1, get<0>(new_root), get<1>(new_root), new_tail}; 484| 19.5k| } 485| 19.5k| IMMER_CATCH (...) { 486| 0| node_t::delete_leaf(new_tail, 1u); 487| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 488| 0| } 489| 19.5k| } 490| 153k| } _ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEC2EmjPNS1_4nodeIiSA_Lj3ELj3EEESE_: 115| 1.26M| { 116| 1.26M| assert(check_tree()); 117| 1.26M| } _ZNK5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE9push_tailEPNS1_4nodeIiSA_Lj3ELj3EEEjmSE_j: 338| 311k| { 339| 311k| if (auto r = root->relaxed()) { ------------------ | Branch (339:18): [True: 54.8k, False: 256k] ------------------ 340| 54.8k| auto new_root = 341| 54.8k| make_relaxed_pos(root, shift, r) 342| 54.8k| .visit(push_tail_visitor{}, tail, tail_size); 343| 54.8k| if (new_root) ------------------ | Branch (343:17): [True: 54.7k, False: 38] ------------------ 344| 54.7k| return std::make_tuple(shift, new_root); 345| 38| else { 346| 38| auto new_root = node_t::make_inner_r_n(2); 347| 38| IMMER_TRY { ------------------ | | 41| 38|#define IMMER_TRY try ------------------ 348| 38| auto new_path = node_t::make_path(shift, tail); 349| 38| new_root->inner()[0] = root->inc(); 350| 38| new_root->inner()[1] = new_path; 351| 38| new_root->relaxed()->d.sizes[0] = size; 352| 38| new_root->relaxed()->d.sizes[1] = size + tail_size; 353| 38| assert(size); 354| 0| assert(tail_size); 355| 0| new_root->relaxed()->d.count = 2u; 356| 38| } 357| 38| IMMER_CATCH (...) { 358| 0| node_t::delete_inner_r(new_root, 2); 359| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 360| 0| } 361| 38| return std::make_tuple(shift + B, new_root); 362| 38| } 363| 256k| } else if (size == size_t{branches} << shift) { ------------------ | Branch (363:20): [True: 295, False: 255k] ------------------ 364| 295| auto new_root = node_t::make_inner_n(2); 365| 295| IMMER_TRY { ------------------ | | 41| 295|#define IMMER_TRY try ------------------ 366| 295| auto new_path = node_t::make_path(shift, tail); 367| 295| new_root->inner()[0] = root->inc(); 368| 295| new_root->inner()[1] = new_path; 369| 295| } 370| 295| IMMER_CATCH (...) { 371| 0| node_t::delete_inner(new_root, 2); 372| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 373| 0| } 374| 295| return std::make_tuple(shift + B, new_root); 375| 255k| } else if (size) { ------------------ | Branch (375:20): [True: 254k, False: 1.55k] ------------------ 376| 254k| auto new_root = make_regular_sub_pos(root, shift, size) 377| 254k| .visit(push_tail_visitor{}, tail); 378| 254k| return std::make_tuple(shift, new_root); 379| 254k| } else { 380| 1.55k| return std::make_tuple(shift, node_t::make_path(shift, tail)); 381| 1.55k| } 382| 311k| } _ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEC2EOSB_: 127| 965k| { 128| 965k| swap(*this, other); 129| 965k| } _ZN5immer6detail4rbts4swapERNS1_7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEESC_: 145| 2.84M| { 146| 2.84M| using std::swap; 147| 2.84M| swap(x.size, y.size); 148| 2.84M| swap(x.shift, y.shift); 149| 2.84M| swap(x.root, y.root); 150| 2.84M| swap(x.tail, y.tail); 151| 2.84M| } _ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEaSEOSB_: 139| 1.87M| { 140| 1.87M| swap(*this, other); 141| 1.87M| return *this; 142| 1.87M| } flex-vector-st.cpp:_ZNK5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE6updateIZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSG_E_EESB_mOSG_: 549| 330k| { 550| 330k| auto tail_off = tail_offset(); 551| 330k| if (idx >= tail_off) { ------------------ | Branch (551:13): [True: 251k, False: 79.1k] ------------------ 552| 251k| auto tail_size = size - tail_off; 553| 251k| auto new_tail = 554| 251k| make_leaf_sub_pos(tail, tail_size) 555| 251k| .visit(update_visitor{}, idx - tail_off, fn); 556| 251k| return {size, shift, root->inc(), new_tail}; 557| 251k| } else { 558| 79.1k| auto new_root = visit_maybe_relaxed_sub( 559| 79.1k| root, shift, tail_off, update_visitor{}, idx, fn); 560| 79.1k| return {size, shift, new_root, tail->inc()}; 561| 79.1k| } 562| 330k| } _ZNK5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE4takeEm: 616| 2.13k| { 617| 2.13k| auto tail_off = tail_offset(); 618| 2.13k| if (new_size == 0) { ------------------ | Branch (618:13): [True: 1.09k, False: 1.03k] ------------------ 619| 1.09k| return {}; 620| 1.09k| } else if (new_size >= size) { ------------------ | Branch (620:20): [True: 35, False: 1.00k] ------------------ 621| 35| return *this; 622| 1.00k| } else if (new_size > tail_off) { ------------------ | Branch (622:20): [True: 10, False: 994] ------------------ 623| 10| auto new_tail = node_t::copy_leaf(tail, new_size - tail_off); 624| 10| return {new_size, shift, root->inc(), new_tail}; 625| 994| } else { 626| 994| using std::get; 627| 994| auto l = new_size - 1; 628| 994| auto v = slice_right_visitor(); 629| 994| auto r = visit_maybe_relaxed_sub(root, shift, tail_off, v, l); 630| 994| auto new_shift = get<0>(r); 631| 994| auto new_root = get<1>(r); 632| 994| auto new_tail = get<3>(r); 633| 994| if (new_root) { ------------------ | Branch (633:17): [True: 712, False: 282] ------------------ 634| 712| IMMER_ASSERT_TAGGED(new_root->compute_shift() == get<0>(r)); ------------------ | | 60| 712|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 635| 0| assert(new_root->check(new_shift, new_size - get<2>(r))); 636| 0| return {new_size, new_shift, new_root, new_tail}; 637| 712| } else { 638| 282| return {new_size, BL, empty_root(), new_tail}; 639| 282| } 640| 994| } 641| 2.13k| } _ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEC2ERKSB_: 121| 1.89k| { 122| 1.89k| inc(); 123| 1.89k| } _ZNK5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE3incEv: 156| 1.89k| { 157| 1.89k| root->inc(); 158| 1.89k| tail->inc(); 159| 1.89k| } _ZNK5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE4dropEm: 680| 1.82k| { 681| 1.82k| if (elems == 0) { ------------------ | Branch (681:13): [True: 625, False: 1.20k] ------------------ 682| 625| return *this; 683| 1.20k| } else if (elems >= size) { ------------------ | Branch (683:20): [True: 18, False: 1.18k] ------------------ 684| 18| return {}; 685| 1.18k| } else if (elems == tail_offset()) { ------------------ | Branch (685:20): [True: 3, False: 1.17k] ------------------ 686| 3| return {size - elems, BL, empty_root(), tail->inc()}; 687| 1.17k| } else if (elems > tail_offset()) { ------------------ | Branch (687:20): [True: 10, False: 1.16k] ------------------ 688| 10| auto tail_off = tail_offset(); 689| 10| auto new_tail = 690| 10| node_t::copy_leaf(tail, elems - tail_off, size - tail_off); 691| 10| return {size - elems, BL, empty_root(), new_tail}; 692| 1.16k| } else { 693| 1.16k| using std::get; 694| 1.16k| auto v = slice_left_visitor(); 695| 1.16k| auto r = 696| 1.16k| visit_maybe_relaxed_sub(root, shift, tail_offset(), v, elems); 697| 1.16k| auto new_root = get<1>(r); 698| 1.16k| auto new_shift = get<0>(r); 699| 1.16k| return {size - elems, new_shift, new_root, tail->inc()}; 700| 1.16k| } 701| 1.82k| } _ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE8max_sizeEv: 44| 1.60M| { 45| 1.60M| auto S = sizeof(size_t) * 8; 46| 1.60M| return ((size_t{1} << BL) - std::min(size_t{BL}, size_t{2})) * 47| 1.60M| ipow((size_t{1} << B) - 2, (S - BL) / B); 48| 1.60M| } _ZNK5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE6concatERKSB_: 704| 475k| { 705| 475k| assert(r.size + size <= max_size()); 706| 0| using std::get; 707| 475k| if (size == 0) ------------------ | Branch (707:13): [True: 573, False: 475k] ------------------ 708| 573| return r; 709| 475k| else if (r.size == 0) ------------------ | Branch (709:18): [True: 250, False: 474k] ------------------ 710| 250| return *this; 711| 474k| else if (r.tail_offset() == 0) { ------------------ | Branch (711:18): [True: 293k, False: 181k] ------------------ 712| | // just concat the tail, similar to push_back 713| 293k| auto tail_offst = tail_offset(); 714| 293k| auto tail_size = size - tail_offst; 715| 293k| if (tail_size == branches) { ------------------ | Branch (715:17): [True: 26.7k, False: 266k] ------------------ 716| 26.7k| auto new_root = 717| 26.7k| push_tail(root, shift, tail_offst, tail, tail_size); 718| 26.7k| tail->inc(); 719| 26.7k| return {size + r.size, 720| 26.7k| get<0>(new_root), 721| 26.7k| get<1>(new_root), 722| 26.7k| r.tail->inc()}; 723| 266k| } else if (tail_size + r.size <= branches) { ------------------ | Branch (723:24): [True: 2.08k, False: 264k] ------------------ 724| 2.08k| auto new_tail = 725| 2.08k| node_t::copy_leaf(tail, tail_size, r.tail, r.size); 726| 2.08k| return {size + r.size, shift, root->inc(), new_tail}; 727| 264k| } else { 728| 264k| auto remaining = branches - tail_size; 729| 264k| auto add_tail = 730| 264k| node_t::copy_leaf(tail, tail_size, r.tail, remaining); 731| 264k| IMMER_TRY { ------------------ | | 41| 264k|#define IMMER_TRY try ------------------ 732| 264k| auto new_tail = 733| 264k| node_t::copy_leaf(r.tail, remaining, r.size); 734| 264k| IMMER_TRY { ------------------ | | 41| 264k|#define IMMER_TRY try ------------------ 735| 264k| auto new_root = push_tail( 736| 264k| root, shift, tail_offst, add_tail, branches); 737| 264k| return {size + r.size, 738| 264k| get<0>(new_root), 739| 264k| get<1>(new_root), 740| 264k| new_tail}; 741| 264k| } 742| 264k| IMMER_CATCH (...) { 743| 0| node_t::delete_leaf(new_tail, r.size - remaining); 744| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 745| 0| } 746| 264k| } 747| 264k| IMMER_CATCH (...) { 748| 0| node_t::delete_leaf(add_tail, branches); 749| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 750| 0| } 751| 264k| } 752| 293k| } else if (tail_offset() == 0) { ------------------ | Branch (752:20): [True: 591, False: 180k] ------------------ 753| 591| auto tail_offst = tail_offset(); 754| 591| auto tail_size = size - tail_offst; 755| 591| auto concated = 756| 591| concat_trees(tail, tail_size, r.root, r.shift, r.tail_offset()); 757| 591| auto new_shift = concated.shift(); 758| 591| auto new_root = concated.node(); 759| 591| IMMER_ASSERT_TAGGED(new_shift == new_root->compute_shift()); ------------------ | | 60| 591|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 760| 0| assert(new_root->check(new_shift, size + r.tail_offset())); 761| 0| return {size + r.size, new_shift, new_root, r.tail->inc()}; 762| 180k| } else { 763| 180k| auto tail_offst = tail_offset(); 764| 180k| auto tail_size = size - tail_offst; 765| 180k| auto concated = concat_trees(root, 766| 180k| shift, 767| 180k| tail_offst, 768| 180k| tail, 769| 180k| tail_size, 770| 180k| r.root, 771| 180k| r.shift, 772| 180k| r.tail_offset()); 773| 180k| auto new_shift = concated.shift(); 774| 180k| auto new_root = concated.node(); 775| 180k| IMMER_ASSERT_TAGGED(new_shift == new_root->compute_shift()); ------------------ | | 60| 180k|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 776| 0| assert(new_root->check(new_shift, size + r.tail_offset())); 777| 0| return {size + r.size, new_shift, new_root, r.tail->inc()}; 778| 180k| } 779| 475k| } _ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE13push_back_mutENS9_5applyIS6_E4type4editEi: 447| 2.55k| { 448| 2.55k| auto ts = tail_size(); 449| 2.55k| if (ts < branches) { ------------------ | Branch (449:13): [True: 2.35k, False: 201] ------------------ 450| 2.35k| ensure_mutable_tail(e, ts); 451| 2.35k| new (&tail->leaf()[ts]) T{std::move(value)}; 452| 2.35k| } else { 453| 201| using std::get; 454| 201| auto new_tail = node_t::make_leaf_e(e, std::move(value)); 455| 201| auto tail_off = tail_offset(); 456| 201| IMMER_TRY { ------------------ | | 41| 201|#define IMMER_TRY try ------------------ 457| 201| push_tail_mut(e, tail_off, tail, ts); 458| 201| tail = new_tail; 459| 201| } 460| 201| IMMER_CATCH (...) { 461| 0| node_t::delete_leaf(new_tail, 1u); 462| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 463| 0| } 464| 201| } 465| 2.55k| ++size; 466| 2.55k| } _ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE19ensure_mutable_tailENS9_5applyIS6_E4type4editEj: 438| 215k| { 439| 215k| if (!tail->can_mutate(e)) { ------------------ | Branch (439:13): [True: 1.06k, False: 214k] ------------------ 440| 1.06k| auto new_tail = node_t::copy_leaf_e(e, tail, n); 441| 1.06k| dec_leaf(tail, n); 442| 1.06k| tail = new_tail; 443| 1.06k| } 444| 215k| } _ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE13push_tail_mutENS9_5applyIS6_E4type4editEmPNS1_4nodeIiSA_Lj3ELj3EEEj: 386| 265k| { 387| 265k| if (auto r = root->relaxed()) { ------------------ | Branch (387:18): [True: 128k, False: 136k] ------------------ 388| 128k| auto new_root = 389| 128k| make_relaxed_pos(root, shift, r) 390| 128k| .visit(push_tail_mut_visitor{}, e, tail, tail_size); 391| 128k| if (new_root) { ------------------ | Branch (391:17): [True: 128k, False: 94] ------------------ 392| 128k| root = new_root; 393| 128k| } else { 394| 94| auto new_root = node_t::make_inner_r_e(e); 395| 94| IMMER_TRY { ------------------ | | 41| 94|#define IMMER_TRY try ------------------ 396| 94| auto new_path = node_t::make_path_e(e, shift, tail); 397| 94| new_root->inner()[0] = root; 398| 94| new_root->inner()[1] = new_path; 399| 94| new_root->relaxed()->d.sizes[0] = tail_off; 400| 94| new_root->relaxed()->d.sizes[1] = tail_off + tail_size; 401| 94| assert(tail_off); 402| 0| assert(tail_size); 403| 0| new_root->relaxed()->d.count = 2u; 404| 94| root = new_root; 405| 94| shift += B; 406| 94| } 407| 94| IMMER_CATCH (...) { 408| 0| node_t::delete_inner_r_e(new_root); 409| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 410| 0| } 411| 94| } 412| 136k| } else if (tail_off == size_t{branches} << shift) { ------------------ | Branch (412:20): [True: 168, False: 136k] ------------------ 413| 168| auto new_root = node_t::make_inner_e(e); 414| 168| IMMER_TRY { ------------------ | | 41| 168|#define IMMER_TRY try ------------------ 415| 168| auto new_path = node_t::make_path_e(e, shift, tail); 416| 168| new_root->inner()[0] = root; 417| 168| new_root->inner()[1] = new_path; 418| 168| root = new_root; 419| 168| shift += B; 420| 168| } 421| 168| IMMER_CATCH (...) { 422| 0| node_t::delete_inner_e(new_root); 423| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 424| 0| } 425| 136k| } else if (tail_off) { ------------------ | Branch (425:20): [True: 136k, False: 91] ------------------ 426| 136k| auto new_root = 427| 136k| make_regular_sub_pos(root, shift, tail_off) 428| 136k| .visit(push_tail_mut_visitor{}, e, tail); 429| 136k| root = new_root; 430| 136k| } else { 431| 91| auto new_root = node_t::make_path_e(e, shift, tail); 432| 91| dec_empty_regular(root); 433| 91| root = new_root; 434| 91| } 435| 265k| } flex-vector-st.cpp:_ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE10update_mutIZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSG_E0_EEvNS9_5applyIS6_E4type4editEmOSG_: 542| 4.29k| { 543| 4.29k| auto& elem = get_mut(e, idx); 544| 4.29k| elem = std::forward(fn)(std::move(elem)); 545| 4.29k| } _ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE7get_mutENS9_5applyIS6_E4type4editEm: 508| 4.29k| { 509| 4.29k| auto tail_off = tail_offset(); 510| 4.29k| if (idx >= tail_off) { ------------------ | Branch (510:13): [True: 154, False: 4.14k] ------------------ 511| 154| ensure_mutable_tail(e, size - tail_off); 512| 154| return tail->leaf()[(idx - tail_off) & mask]; 513| 4.14k| } else { 514| 4.14k| return visit_maybe_relaxed_sub(root, 515| 4.14k| shift, 516| 4.14k| tail_off, 517| 4.14k| get_mut_visitor{}, 518| 4.14k| idx, 519| 4.14k| e, 520| 4.14k| &root); 521| 4.14k| } 522| 4.29k| } _ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE8take_mutENS9_5applyIS6_E4type4editEm: 575| 8.20k| { 576| 8.20k| auto tail_off = tail_offset(); 577| 8.20k| if (new_size == 0) { ------------------ | Branch (577:13): [True: 153, False: 8.05k] ------------------ 578| 153| *this = {}; 579| 8.05k| } else if (new_size >= size) { ------------------ | Branch (579:20): [True: 292, False: 7.76k] ------------------ 580| 292| return; 581| 7.76k| } else if (new_size > tail_off) { ------------------ | Branch (581:20): [True: 194, False: 7.57k] ------------------ 582| 194| auto ts = size - tail_off; 583| 194| auto newts = new_size - tail_off; 584| 194| if (tail->can_mutate(e)) { ------------------ | Branch (584:17): [True: 113, False: 81] ------------------ 585| 113| detail::destroy_n(tail->leaf() + newts, ts - newts); 586| 113| } else { 587| 81| auto new_tail = node_t::copy_leaf_e(e, tail, newts); 588| 81| dec_leaf(tail, ts); 589| 81| tail = new_tail; 590| 81| } 591| 194| size = new_size; 592| 194| return; 593| 7.57k| } else { 594| 7.57k| using std::get; 595| 7.57k| auto l = new_size - 1; 596| 7.57k| auto v = slice_right_mut_visitor(); 597| 7.57k| auto r = visit_maybe_relaxed_sub(root, shift, tail_off, v, l, e); 598| 7.57k| auto new_shift = get<0>(r); 599| 7.57k| auto new_root = get<1>(r); 600| 7.57k| auto new_tail = get<3>(r); 601| 7.57k| if (new_root) { ------------------ | Branch (601:17): [True: 6.79k, False: 772] ------------------ 602| 6.79k| root = new_root; 603| 6.79k| shift = new_shift; 604| 6.79k| } else { 605| 772| root = empty_root(); 606| 772| shift = BL; 607| 772| } 608| 7.57k| dec_leaf(tail, size - tail_off); 609| 7.57k| size = new_size; 610| 7.57k| tail = new_tail; 611| 7.57k| return; 612| 7.57k| } 613| 8.20k| } _ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE8drop_mutENS9_5applyIS6_E4type4editEm: 644| 25.0k| { 645| 25.0k| using std::get; 646| 25.0k| auto tail_off = tail_offset(); 647| 25.0k| if (elems == 0) { ------------------ | Branch (647:13): [True: 258, False: 24.7k] ------------------ 648| 258| return; 649| 24.7k| } else if (elems >= size) { ------------------ | Branch (649:20): [True: 3, False: 24.7k] ------------------ 650| 3| *this = {}; 651| 24.7k| } else if (elems == tail_off) { ------------------ | Branch (651:20): [True: 23, False: 24.7k] ------------------ 652| 23| dec_inner(root, shift, tail_off); 653| 23| shift = BL; 654| 23| root = empty_root(); 655| 23| size -= elems; 656| 23| return; 657| 24.7k| } else if (elems > tail_off) { ------------------ | Branch (657:20): [True: 153, False: 24.5k] ------------------ 658| 153| auto v = slice_left_mut_visitor(); 659| 153| tail = get<1>(make_leaf_sub_pos(tail, size - tail_off) 660| 153| .visit(v, elems - tail_off, e)); 661| 153| if (tail_off) { ------------------ | Branch (661:17): [True: 17, False: 136] ------------------ 662| 17| dec_inner(root, shift, tail_off); 663| 17| shift = BL; 664| 17| root = empty_root(); 665| 17| } 666| 153| size -= elems; 667| 153| return; 668| 24.5k| } else { 669| 24.5k| auto v = slice_left_mut_visitor(); 670| 24.5k| auto r = 671| 24.5k| visit_maybe_relaxed_sub(root, shift, tail_off, v, elems, e); 672| 24.5k| shift = get<0>(r); 673| 24.5k| root = get<1>(r); 674| 24.5k| size -= elems; 675| 24.5k| return; 676| 24.5k| } 677| 25.0k| } _ZN5immer6detail4rbts12concat_mut_lERNS1_7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS9_5applyIS6_E4type4editERKSB_: 785| 339k| { 786| 339k| assert(&l != &r); 787| 0| assert(r.size < (std::numeric_limits::max() - l.size)); 788| 0| using std::get; 789| 339k| if (l.size == 0) ------------------ | Branch (789:13): [True: 14, False: 339k] ------------------ 790| 14| l = r; 791| 339k| else if (r.size == 0) ------------------ | Branch (791:18): [True: 387, False: 338k] ------------------ 792| 387| return; 793| 338k| else if (r.tail_offset() == 0) { ------------------ | Branch (793:18): [True: 238k, False: 100k] ------------------ 794| | // just concat the tail, similar to push_back 795| 238k| auto tail_offst = l.tail_offset(); 796| 238k| auto tail_size = l.size - tail_offst; 797| 238k| if (tail_size == branches) { ------------------ | Branch (797:17): [True: 52.0k, False: 186k] ------------------ 798| 52.0k| l.push_tail_mut(el, tail_offst, l.tail, tail_size); 799| 52.0k| l.tail = r.tail->inc(); 800| 52.0k| l.size += r.size; 801| 52.0k| return; 802| 186k| } else if (tail_size + r.size <= branches) { ------------------ | Branch (802:24): [True: 2.65k, False: 183k] ------------------ 803| 2.65k| l.ensure_mutable_tail(el, tail_size); 804| 2.65k| detail::uninitialized_copy(r.tail->leaf(), 805| 2.65k| r.tail->leaf() + r.size, 806| 2.65k| l.tail->leaf() + tail_size); 807| 2.65k| l.size += r.size; 808| 2.65k| return; 809| 183k| } else { 810| 183k| auto remaining = branches - tail_size; 811| 183k| l.ensure_mutable_tail(el, tail_size); 812| 183k| detail::uninitialized_copy(r.tail->leaf(), 813| 183k| r.tail->leaf() + remaining, 814| 183k| l.tail->leaf() + tail_size); 815| 183k| IMMER_TRY { ------------------ | | 41| 183k|#define IMMER_TRY try ------------------ 816| 183k| auto new_tail = 817| 183k| node_t::copy_leaf_e(el, r.tail, remaining, r.size); 818| 183k| IMMER_TRY { ------------------ | | 41| 183k|#define IMMER_TRY try ------------------ 819| 183k| l.push_tail_mut(el, tail_offst, l.tail, branches); 820| 183k| l.tail = new_tail; 821| 183k| l.size += r.size; 822| 183k| return; 823| 183k| } 824| 183k| IMMER_CATCH (...) { 825| 0| node_t::delete_leaf(new_tail, r.size - remaining); 826| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 827| 0| } 828| 183k| } 829| 183k| IMMER_CATCH (...) { 830| 0| detail::destroy_n(r.tail->leaf() + tail_size, remaining); 831| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 832| 0| } 833| 183k| } 834| 238k| } else if (l.tail_offset() == 0) { ------------------ | Branch (834:20): [True: 52, False: 100k] ------------------ 835| 52| if (supports_transient_concat) { ------------------ | Branch (835:17): [Folded - Ignored] ------------------ 836| 0| auto tail_offst = l.tail_offset(); 837| 0| auto tail_size = l.size - tail_offst; 838| 0| auto concated = 839| 0| concat_trees_mut(el, 840| 0| el, 841| 0| l.tail, 842| 0| tail_size, 843| 0| MemoryPolicy::transience_t::noone, 844| 0| r.root, 845| 0| r.shift, 846| 0| r.tail_offset()); 847| 0| IMMER_ASSERT_TAGGED(concated.shift() == ------------------ | | 60| 0|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 848| 0| concated.node()->compute_shift()); 849| 0| l.size += r.size; 850| 0| l.shift = concated.shift(); 851| 0| l.root = concated.node(); 852| 0| l.tail = r.tail; 853| 0| assert(l.check_tree()); 854| 52| } else { 855| 52| auto tail_offst = l.tail_offset(); 856| 52| auto tail_size = l.size - tail_offst; 857| 52| auto concated = concat_trees( 858| 52| l.tail, tail_size, r.root, r.shift, r.tail_offset()); 859| 52| l = {l.size + r.size, 860| 52| concated.shift(), 861| 52| concated.node(), 862| 52| r.tail->inc()}; 863| 52| assert(l.check_tree()); 864| 0| return; 865| 52| } 866| 100k| } else { 867| 100k| if (supports_transient_concat) { ------------------ | Branch (867:17): [Folded - Ignored] ------------------ 868| 0| auto tail_offst = l.tail_offset(); 869| 0| auto tail_size = l.size - tail_offst; 870| 0| assert(l.check_tree()); 871| 0| assert(r.check_tree()); 872| 0| auto concated = 873| 0| concat_trees_mut(el, 874| 0| el, 875| 0| l.root, 876| 0| l.shift, 877| 0| tail_offst, 878| 0| l.tail, 879| 0| tail_size, 880| 0| MemoryPolicy::transience_t::noone, 881| 0| r.root, 882| 0| r.shift, 883| 0| r.tail_offset()); 884| 0| IMMER_ASSERT_TAGGED(concated.shift() == ------------------ | | 60| 0|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 885| 0| concated.node()->compute_shift()); 886| 0| l.size += r.size; 887| 0| l.shift = concated.shift(); 888| 0| l.root = concated.node(); 889| 0| l.tail = r.tail; 890| 0| assert(l.check_tree()); 891| 100k| } else { 892| 100k| auto tail_offst = l.tail_offset(); 893| 100k| auto tail_size = l.size - tail_offst; 894| 100k| auto concated = concat_trees(l.root, 895| 100k| l.shift, 896| 100k| tail_offst, 897| 100k| l.tail, 898| 100k| tail_size, 899| 100k| r.root, 900| 100k| r.shift, 901| 100k| r.tail_offset()); 902| 100k| l = {l.size + r.size, 903| 100k| concated.shift(), 904| 100k| concated.node(), 905| 100k| r.tail->inc()}; 906| 100k| } 907| 100k| } 908| 339k| } _ZN5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEaSERKSB_: 132| 416| { 133| 416| auto next{other}; 134| 416| swap(*this, next); 135| 416| return *this; 136| 416| } _ZN5immer6detail4rbts12concat_mut_rERKNS1_7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERSB_NS9_5applyIS6_E4type4editE: 911| 185| { 912| 185| assert(&l != &r); 913| 0| assert(r.size < (std::numeric_limits::max() - l.size)); 914| 0| using std::get; 915| 185| if (r.size == 0) ------------------ | Branch (915:13): [True: 7, False: 178] ------------------ 916| 7| r = std::move(l); 917| 178| else if (l.size == 0) ------------------ | Branch (917:18): [True: 2, False: 176] ------------------ 918| 2| return; 919| 176| else if (r.tail_offset() == 0) { ------------------ | Branch (919:18): [True: 35, False: 141] ------------------ 920| | // just concat the tail, similar to push_back 921| 35| auto tail_offst = l.tail_offset(); 922| 35| auto tail_size = l.size - tail_offst; 923| 35| if (tail_size == branches) { ------------------ | Branch (923:17): [True: 6, False: 29] ------------------ 924| | // this could be improved by making sure that the 925| | // newly created nodes as part of the `push_tail()` 926| | // are tagged with `er` 927| 6| auto res = 928| 6| l.push_tail(l.root, l.shift, tail_offst, l.tail, tail_size); 929| 6| l.tail->inc(); // note: leak if mutably concatenated 930| | // with itself, but this is forbidden 931| | // by the interface 932| 6| r = {l.size + r.size, get<0>(res), get<1>(res), r.tail->inc()}; 933| 6| return; 934| 29| } else if (tail_size + r.size <= branches) { ------------------ | Branch (934:24): [True: 20, False: 9] ------------------ 935| | // doing this in a exception way mutating way is very 936| | // tricky while potential performance gains are 937| | // minimal (we need to move every element of the right 938| | // tail anyways to make space for the left tail) 939| | // 940| | // we could however improve this by at least moving the 941| | // elements of the right tail... 942| 20| auto new_tail = 943| 20| node_t::copy_leaf(l.tail, tail_size, r.tail, r.size); 944| 20| r = {l.size + r.size, l.shift, l.root->inc(), new_tail}; 945| 20| return; 946| 20| } else { 947| | // like the immutable version 948| 9| auto remaining = branches - tail_size; 949| 9| auto add_tail = node_t::copy_leaf_e( 950| 9| er, l.tail, tail_size, r.tail, remaining); 951| 9| IMMER_TRY { ------------------ | | 41| 9|#define IMMER_TRY try ------------------ 952| 9| auto new_tail = 953| 9| node_t::copy_leaf_e(er, r.tail, remaining, r.size); 954| 9| IMMER_TRY { ------------------ | | 41| 9|#define IMMER_TRY try ------------------ 955| | // this could be improved by making sure that the 956| | // newly created nodes as part of the `push_tail()` 957| | // are tagged with `er` 958| 9| auto new_root = l.push_tail(l.root, 959| 9| l.shift, 960| 9| tail_offst, 961| 9| add_tail, 962| 9| branches); 963| 9| r = {l.size + r.size, 964| 9| get<0>(new_root), 965| 9| get<1>(new_root), 966| 9| new_tail}; 967| 9| return; 968| 9| } 969| 9| IMMER_CATCH (...) { 970| 0| node_t::delete_leaf(new_tail, r.size - remaining); 971| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 972| 0| } 973| 9| } 974| 9| IMMER_CATCH (...) { 975| 0| node_t::delete_leaf(add_tail, branches); 976| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 977| 0| } 978| 9| } 979| 141| } else if (l.tail_offset() == 0) { ------------------ | Branch (979:20): [True: 0, False: 141] ------------------ 980| 0| if (supports_transient_concat) { ------------------ | Branch (980:17): [Folded - Ignored] ------------------ 981| 0| auto tail_offst = l.tail_offset(); 982| 0| auto tail_size = l.size - tail_offst; 983| 0| auto concated = 984| 0| concat_trees_mut(er, 985| 0| MemoryPolicy::transience_t::noone, 986| 0| l.tail, 987| 0| tail_size, 988| 0| er, 989| 0| r.root, 990| 0| r.shift, 991| 0| r.tail_offset()); 992| 0| IMMER_ASSERT_TAGGED(concated.shift() == ------------------ | | 60| 0|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 993| 0| concated.node()->compute_shift()); 994| 0| r.size += l.size; 995| 0| r.shift = concated.shift(); 996| 0| r.root = concated.node(); 997| 0| assert(r.check_tree()); 998| 0| } else { 999| 0| auto tail_offst = l.tail_offset(); 1000| 0| auto tail_size = l.size - tail_offst; 1001| 0| auto concated = concat_trees( 1002| 0| l.tail, tail_size, r.root, r.shift, r.tail_offset()); 1003| 0| r = {l.size + r.size, 1004| 0| concated.shift(), 1005| 0| concated.node(), 1006| 0| r.tail->inc()}; 1007| 0| return; 1008| 0| } 1009| 141| } else { 1010| 141| if (supports_transient_concat) { ------------------ | Branch (1010:17): [Folded - Ignored] ------------------ 1011| 0| auto tail_offst = l.tail_offset(); 1012| 0| auto tail_size = l.size - tail_offst; 1013| 0| auto concated = 1014| 0| concat_trees_mut(er, 1015| 0| MemoryPolicy::transience_t::noone, 1016| 0| l.root, 1017| 0| l.shift, 1018| 0| tail_offst, 1019| 0| l.tail, 1020| 0| tail_size, 1021| 0| er, 1022| 0| r.root, 1023| 0| r.shift, 1024| 0| r.tail_offset()); 1025| 0| IMMER_ASSERT_TAGGED(concated.shift() == ------------------ | | 60| 0|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 1026| 0| concated.node()->compute_shift()); 1027| 0| r.size += l.size; 1028| 0| r.shift = concated.shift(); 1029| 0| r.root = concated.node(); 1030| 0| assert(r.check_tree()); 1031| 0| return; 1032| 141| } else { 1033| 141| auto tail_offst = l.tail_offset(); 1034| 141| auto tail_size = l.size - tail_offst; 1035| 141| auto concated = concat_trees(l.root, 1036| 141| l.shift, 1037| 141| tail_offst, 1038| 141| l.tail, 1039| 141| tail_size, 1040| 141| r.root, 1041| 141| r.shift, 1042| 141| r.tail_offset()); 1043| 141| r = {l.size + r.size, 1044| 141| concated.shift(), 1045| 141| concated.node(), 1046| 141| r.tail->inc()}; 1047| 141| return; 1048| 141| } 1049| 141| } 1050| 185| } _ZN5immer6detail4rbts15concat_mut_lr_lERNS1_7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEENS9_5applyIS6_E4type4editESC_SG_: 1053| 232k| { 1054| 232k| assert(&l != &r); 1055| 0| assert(r.size < (std::numeric_limits::max() - l.size)); 1056| 0| using std::get; 1057| 232k| if (l.size == 0) ------------------ | Branch (1057:13): [True: 395, False: 232k] ------------------ 1058| 395| l = r; 1059| 232k| else if (r.size == 0) ------------------ | Branch (1059:18): [True: 834, False: 231k] ------------------ 1060| 834| return; 1061| 231k| else if (r.tail_offset() == 0) { ------------------ | Branch (1061:18): [True: 30.3k, False: 201k] ------------------ 1062| | // just concat the tail, similar to push_back 1063| 30.3k| auto tail_offst = l.tail_offset(); 1064| 30.3k| auto tail_size = l.size - tail_offst; 1065| 30.3k| if (tail_size == branches) { ------------------ | Branch (1065:17): [True: 3.55k, False: 26.7k] ------------------ 1066| 3.55k| l.push_tail_mut(el, tail_offst, l.tail, tail_size); 1067| 3.55k| l.tail = r.tail->inc(); 1068| 3.55k| l.size += r.size; 1069| 3.55k| return; 1070| 26.7k| } else if (tail_size + r.size <= branches) { ------------------ | Branch (1070:24): [True: 300, False: 26.4k] ------------------ 1071| 300| l.ensure_mutable_tail(el, tail_size); 1072| 300| if (r.tail->can_mutate(er)) ------------------ | Branch (1072:21): [True: 280, False: 20] ------------------ 1073| 280| detail::uninitialized_move(r.tail->leaf(), 1074| 280| r.tail->leaf() + r.size, 1075| 280| l.tail->leaf() + tail_size); 1076| 20| else 1077| 20| detail::uninitialized_copy(r.tail->leaf(), 1078| 20| r.tail->leaf() + r.size, 1079| 20| l.tail->leaf() + tail_size); 1080| 300| l.size += r.size; 1081| 300| return; 1082| 26.4k| } else { 1083| 26.4k| auto remaining = branches - tail_size; 1084| 26.4k| l.ensure_mutable_tail(el, tail_size); 1085| 26.4k| if (r.tail->can_mutate(er)) ------------------ | Branch (1085:21): [True: 7.26k, False: 19.1k] ------------------ 1086| 7.26k| detail::uninitialized_move(r.tail->leaf(), 1087| 7.26k| r.tail->leaf() + remaining, 1088| 7.26k| l.tail->leaf() + tail_size); 1089| 19.1k| else 1090| 19.1k| detail::uninitialized_copy(r.tail->leaf(), 1091| 19.1k| r.tail->leaf() + remaining, 1092| 19.1k| l.tail->leaf() + tail_size); 1093| 26.4k| IMMER_TRY { ------------------ | | 41| 26.4k|#define IMMER_TRY try ------------------ 1094| 26.4k| auto new_tail = 1095| 26.4k| node_t::copy_leaf_e(el, r.tail, remaining, r.size); 1096| 26.4k| IMMER_TRY { ------------------ | | 41| 26.4k|#define IMMER_TRY try ------------------ 1097| 26.4k| l.push_tail_mut(el, tail_offst, l.tail, branches); 1098| 26.4k| l.tail = new_tail; 1099| 26.4k| l.size += r.size; 1100| 26.4k| return; 1101| 26.4k| } 1102| 26.4k| IMMER_CATCH (...) { 1103| 0| node_t::delete_leaf(new_tail, r.size - remaining); 1104| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1105| 0| } 1106| 26.4k| } 1107| 26.4k| IMMER_CATCH (...) { 1108| 0| detail::destroy_n(r.tail->leaf() + tail_size, remaining); 1109| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 1110| 0| } 1111| 26.4k| } 1112| 201k| } else if (l.tail_offset() == 0) { ------------------ | Branch (1112:20): [True: 484, False: 200k] ------------------ 1113| 484| if (supports_transient_concat) { ------------------ | Branch (1113:17): [Folded - Ignored] ------------------ 1114| 0| auto tail_offst = l.tail_offset(); 1115| 0| auto tail_size = l.size - tail_offst; 1116| 0| auto concated = concat_trees_mut(el, 1117| 0| el, 1118| 0| l.tail, 1119| 0| tail_size, 1120| 0| er, 1121| 0| r.root, 1122| 0| r.shift, 1123| 0| r.tail_offset()); 1124| 0| IMMER_ASSERT_TAGGED(concated.shift() == ------------------ | | 60| 0|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 1125| 0| concated.node()->compute_shift()); 1126| 0| l.size += r.size; 1127| 0| l.shift = concated.shift(); 1128| 0| l.root = concated.node(); 1129| 0| l.tail = r.tail; 1130| 0| assert(l.check_tree()); 1131| 0| r.hard_reset(); 1132| 0| return; 1133| 484| } else { 1134| 484| auto tail_offst = l.tail_offset(); 1135| 484| auto tail_size = l.size - tail_offst; 1136| 484| auto concated = concat_trees( 1137| 484| l.tail, tail_size, r.root, r.shift, r.tail_offset()); 1138| 484| l = {l.size + r.size, 1139| 484| concated.shift(), 1140| 484| concated.node(), 1141| 484| r.tail->inc()}; 1142| 484| return; 1143| 484| } 1144| 200k| } else { 1145| 200k| if (supports_transient_concat) { ------------------ | Branch (1145:17): [Folded - Ignored] ------------------ 1146| 0| auto tail_offst = l.tail_offset(); 1147| 0| auto tail_size = l.size - tail_offst; 1148| 0| auto concated = concat_trees_mut(el, 1149| 0| el, 1150| 0| l.root, 1151| 0| l.shift, 1152| 0| tail_offst, 1153| 0| l.tail, 1154| 0| tail_size, 1155| 0| er, 1156| 0| r.root, 1157| 0| r.shift, 1158| 0| r.tail_offset()); 1159| 0| IMMER_ASSERT_TAGGED(concated.shift() == ------------------ | | 60| 0|#define IMMER_ASSERT_TAGGED(assertion) assert(assertion) ------------------ 1160| 0| concated.node()->compute_shift()); 1161| 0| l.size += r.size; 1162| 0| l.shift = concated.shift(); 1163| 0| l.root = concated.node(); 1164| 0| l.tail = r.tail; 1165| 0| assert(l.check_tree()); 1166| 0| r.hard_reset(); 1167| 0| return; 1168| 200k| } else { 1169| 200k| auto tail_offst = l.tail_offset(); 1170| 200k| auto tail_size = l.size - tail_offst; 1171| 200k| auto concated = concat_trees(l.root, 1172| 200k| l.shift, 1173| 200k| tail_offst, 1174| 200k| l.tail, 1175| 200k| tail_size, 1176| 200k| r.root, 1177| 200k| r.shift, 1178| 200k| r.tail_offset()); 1179| 200k| l = {l.size + r.size, 1180| 200k| concated.shift(), 1181| 200k| concated.node(), 1182| 200k| r.tail->inc()}; 1183| 200k| return; 1184| 200k| } 1185| 200k| } 1186| 232k| } _ZNK5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE6equalsERKSB_: 284| 1.68k| { 285| 1.68k| using iter_t = rrbtree_iterator; 286| 1.68k| if (size != other.size) ------------------ | Branch (286:13): [True: 815, False: 873] ------------------ 287| 815| return false; 288| 873| if (size == 0) ------------------ | Branch (288:13): [True: 0, False: 873] ------------------ 289| 0| return true; 290| 873| auto tail_off = tail_offset(); 291| 873| auto tail_off_other = other.tail_offset(); 292| | // compare trees 293| 873| if (tail_off > 0 && tail_off_other > 0) { ------------------ | Branch (293:13): [True: 699, False: 174] | Branch (293:29): [True: 695, False: 4] ------------------ 294| | // other.shift != shift is a theoretical possibility for 295| | // relaxed trees that sadly we haven't managed to exercise 296| | // in tests yet... 297| 695| if (other.shift >= shift) { ------------------ | Branch (297:17): [True: 695, False: 0] ------------------ 298| 695| if (!visit_maybe_relaxed_sub(other.root, ------------------ | Branch (298:21): [True: 370, False: 325] ------------------ 299| 695| other.shift, 300| 695| tail_off_other, 301| 695| equals_visitor::rrb{}, 302| 695| iter_t{other}, 303| 695| root, 304| 695| shift, 305| 695| tail_off)) 306| 370| return false; 307| 695| } else { 308| 0| if (!visit_maybe_relaxed_sub(root, ------------------ | Branch (308:21): [True: 0, False: 0] ------------------ 309| 0| shift, 310| 0| tail_off, 311| 0| equals_visitor::rrb{}, 312| 0| iter_t{*this}, 313| 0| other.root, 314| 0| other.shift, 315| 0| tail_off_other)) 316| 0| return false; 317| 0| } 318| 695| } 319| 503| return tail_off == tail_off_other ------------------ | Branch (319:16): [True: 424, False: 79] ------------------ 320| 503| ? make_leaf_sub_pos(tail, tail_size()) 321| 424| .visit(equals_visitor{}, other.tail) 322| 503| : tail_off > tail_off_other ------------------ | Branch (322:18): [True: 50, False: 29] ------------------ 323| 79| ? std::equal(tail->leaf(), 324| 50| tail->leaf() + (size - tail_off), 325| 50| other.tail->leaf() + 326| 50| (tail_off - tail_off_other)) 327| | /* otherwise */ 328| 79| : std::equal(tail->leaf(), 329| 29| tail->leaf() + (size - tail_off), 330| 29| iter_t{other} + tail_off); 331| 873| } _ZNK5immer6detail4rbts7rrbtreeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE10region_forEm: 493| 398k| { 494| 398k| using std::get; 495| 398k| auto tail_off = tail_offset(); 496| 398k| if (idx >= tail_off) { ------------------ | Branch (496:13): [True: 74, False: 398k] ------------------ 497| 74| return std::make_tuple(tail->leaf(), tail_off, size); 498| 398k| } else { 499| 398k| auto subs = visit_maybe_relaxed_sub( 500| 398k| root, shift, tail_off, region_for_visitor(), idx); 501| 398k| auto first = idx - get<1>(subs); 502| 398k| auto end = first + get<2>(subs); 503| 398k| return std::make_tuple(get<0>(subs), first, end); 504| 398k| } 505| 398k| } _ZNK5immer6detail4rbts16rrbtree_iteratorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11dereferenceEv: 88| 3.42M| { 89| 3.42M| using std::get; 90| 3.42M| if (i_ < get<1>(curr_) || i_ >= get<2>(curr_)) ------------------ | Branch (90:13): [True: 2.31k, False: 3.41M] | Branch (90:35): [True: 395k, False: 3.02M] ------------------ 91| 398k| curr_ = v_->region_for(i_); 92| 3.42M| return get<0>(curr_)[i_ - get<1>(curr_)]; 93| 3.42M| } _ZN5immer6detail4rbts16rrbtree_iteratorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE7advanceEl: 72| 2.94k| { 73| 2.94k| using std::get; 74| 2.94k| assert(n <= 0 || i_ + static_cast(n) <= v_->size); 75| 0| assert(n >= 0 || static_cast(-n) <= i_); 76| 0| i_ += n; 77| 2.94k| } _ZN5immer6detail4rbts16rrbtree_iteratorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE9incrementEv: 58| 3.02M| { 59| 3.02M| using std::get; 60| 3.02M| assert(i_ < v_->size); 61| 0| ++i_; 62| 3.02M| } _ZN5immer6detail4rbts16rrbtree_iteratorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEC2ERKNS1_7rrbtreeIiSA_Lj3ELj3EEE: 42| 724| {} _ZN5immer6detail4rbts12visitor_baseINS1_18slice_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EEEE13visit_relaxedIJRNS1_11relaxed_posISD_EERmEEEDcDpOT_: 31| 1.11k| { 32| 1.11k| return Deriv::visit_inner(std::forward(args)...); 33| 1.11k| } _ZN5immer6detail4rbts12visitor_baseINS1_18slice_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EEEE13visit_relaxedIJRNS1_11relaxed_posISD_EERmEEEDcDpOT_: 31| 6.00k| { 32| 6.00k| return Deriv::visit_inner(std::forward(args)...); 33| 6.00k| } _ZN5immer6detail4rbts12visitor_baseINS1_18slice_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EEEE13visit_regularIJRNS1_15regular_sub_posISD_EERmEEEDcDpOT_: 37| 131| { 38| 131| return Deriv::visit_inner(std::forward(args)...); 39| 131| } _ZN5immer6detail4rbts12visitor_baseINS1_18slice_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb0EEEE13visit_regularIJRNS1_8full_posISD_EEmEEEDcDpOT_: 37| 342| { 38| 342| return Deriv::visit_inner(std::forward(args)...); 39| 342| } _ZN5immer6detail4rbts12visitor_baseINS1_18slice_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EEEE13visit_regularIJRNS1_15regular_sub_posISD_EERmEEEDcDpOT_: 37| 187| { 38| 187| return Deriv::visit_inner(std::forward(args)...); 39| 187| } _ZN5immer6detail4rbts12visitor_baseINS1_18slice_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EEEE13visit_regularIJRNS1_8full_posISD_EEmEEEDcDpOT_: 37| 109| { 38| 109| return Deriv::visit_inner(std::forward(args)...); 39| 109| } _ZN5immer6detail4rbts12visitor_baseINS1_18slice_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEELb1EEEE13visit_regularIJRNS1_15regular_sub_posISD_EEmEEEDcDpOT_: 37| 4| { 38| 4| return Deriv::visit_inner(std::forward(args)...); 39| 4| } _ZN5immer6detail4rbts12visitor_baseINS1_25concat_trees_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_regularIJRNS1_25singleton_regular_sub_posISD_EENS1_14empty_leaf_posISD_EERPSD_RjRmEEEDcDpOT_: 37| 1.12k| { 38| 1.12k| return Deriv::visit_inner(std::forward(args)...); 39| 1.12k| } _ZN5immer6detail4rbts12visitor_baseINS1_25concat_trees_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE11visit_innerIJRNS1_25singleton_regular_sub_posISD_EENS1_14empty_leaf_posISD_EERPSD_RjRmEEEDcDpOT_: 43| 1.12k| { 44| 1.12k| return Deriv::visit_node(std::forward(args)...); 45| 1.12k| } _ZN5immer6detail4rbts12visitor_baseINS1_26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_relaxedIJRNS1_11relaxed_posISD_EERNS1_25singleton_regular_sub_posISD_EERNS1_14empty_leaf_posISD_EEEEEDcDpOT_: 31| 1.05k| { 32| 1.05k| return Deriv::visit_inner(std::forward(args)...); 33| 1.05k| } _ZN5immer6detail4rbts12visitor_baseINS1_26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE11visit_innerIJRNS1_11relaxed_posISD_EERNS1_25singleton_regular_sub_posISD_EERNS1_14empty_leaf_posISD_EEEEEDcDpOT_: 43| 1.05k| { 44| 1.05k| return Deriv::visit_node(std::forward(args)...); 45| 1.05k| } _ZN5immer6detail4rbts12visitor_baseINS1_34concat_rebalance_plan_fill_visitorEE10visit_leafIJRNS1_12leaf_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_21concat_rebalance_planILj3ELj3EEEEEEDcDpOT_: 49| 5.28M| { 50| 5.28M| return Deriv::visit_node(std::forward(args)...); 51| 5.28M| } _ZN5immer6detail4rbts12visitor_baseINS1_34concat_rebalance_plan_fill_visitorEE13visit_relaxedIJRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_21concat_rebalance_planILj3ELj3EEEEEEDcDpOT_: 31| 58.7M| { 32| 58.7M| return Deriv::visit_inner(std::forward(args)...); 33| 58.7M| } _ZN5immer6detail4rbts12visitor_baseINS1_34concat_rebalance_plan_fill_visitorEE11visit_innerIJRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_21concat_rebalance_planILj3ELj3EEEEEEDcDpOT_: 43| 58.7M| { 44| 58.7M| return Deriv::visit_node(std::forward(args)...); 45| 58.7M| } _ZN5immer6detail4rbts12visitor_baseINS1_21concat_merger_visitorEE13visit_relaxedIJRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_13concat_mergerISG_EEEEEDcDpOT_: 31| 58.7M| { 32| 58.7M| return Deriv::visit_inner(std::forward(args)...); 33| 58.7M| } _ZN5immer6detail4rbts12visitor_baseINS1_20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_relaxedIJRNS1_11relaxed_posISD_EERNS1_25singleton_regular_sub_posISD_EERNS1_14empty_leaf_posISD_EEEEEDcDpOT_: 31| 9.45k| { 32| 9.45k| return Deriv::visit_inner(std::forward(args)...); 33| 9.45k| } _ZN5immer6detail4rbts12visitor_baseINS1_20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_regularIJRNS1_15regular_sub_posISD_EERNS1_25singleton_regular_sub_posISD_EERNS1_14empty_leaf_posISD_EEEEEDcDpOT_: 37| 129| { 38| 129| return Deriv::visit_inner(std::forward(args)...); 39| 129| } _ZN5immer6detail4rbts12visitor_baseINS1_20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_regularIJRNS1_8full_posISD_EERNS1_25singleton_regular_sub_posISD_EERNS1_14empty_leaf_posISD_EEEEEDcDpOT_: 37| 81| { 38| 81| return Deriv::visit_inner(std::forward(args)...); 39| 81| } _ZN5immer6detail4rbts12visitor_baseINS1_34concat_rebalance_plan_fill_visitorEE10visit_leafIJRNS1_13full_leaf_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_21concat_rebalance_planILj3ELj3EEEEEEDcDpOT_: 49| 582k| { 50| 582k| return Deriv::visit_node(std::forward(args)...); 51| 582k| } _ZN5immer6detail4rbts12visitor_baseINS1_34concat_rebalance_plan_fill_visitorEE13visit_regularIJRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_21concat_rebalance_planILj3ELj3EEEEEEDcDpOT_: 37| 264k| { 38| 264k| return Deriv::visit_inner(std::forward(args)...); 39| 264k| } _ZN5immer6detail4rbts12visitor_baseINS1_34concat_rebalance_plan_fill_visitorEE11visit_innerIJRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_21concat_rebalance_planILj3ELj3EEEEEEDcDpOT_: 43| 264k| { 44| 264k| return Deriv::visit_node(std::forward(args)...); 45| 264k| } _ZN5immer6detail4rbts12visitor_baseINS1_21concat_merger_visitorEE13visit_regularIJRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_13concat_mergerISG_EEEEEDcDpOT_: 37| 264k| { 38| 264k| return Deriv::visit_inner(std::forward(args)...); 39| 264k| } _ZN5immer6detail4rbts12visitor_baseINS1_34concat_rebalance_plan_fill_visitorEE13visit_regularIJRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_21concat_rebalance_planILj3ELj3EEEEEEDcDpOT_: 37| 768k| { 38| 768k| return Deriv::visit_inner(std::forward(args)...); 39| 768k| } _ZN5immer6detail4rbts12visitor_baseINS1_34concat_rebalance_plan_fill_visitorEE11visit_innerIJRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_21concat_rebalance_planILj3ELj3EEEEEEDcDpOT_: 43| 768k| { 44| 768k| return Deriv::visit_node(std::forward(args)...); 45| 768k| } _ZN5immer6detail4rbts12visitor_baseINS1_21concat_merger_visitorEE13visit_regularIJRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_13concat_mergerISG_EEEEEDcDpOT_: 37| 768k| { 38| 768k| return Deriv::visit_inner(std::forward(args)...); 39| 768k| } _ZN5immer6detail4rbts12visitor_baseINS1_26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_regularIJRNS1_15regular_sub_posISD_EERNS1_25singleton_regular_sub_posISD_EERNS1_14empty_leaf_posISD_EEEEEDcDpOT_: 37| 73| { 38| 73| return Deriv::visit_inner(std::forward(args)...); 39| 73| } _ZN5immer6detail4rbts12visitor_baseINS1_26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE11visit_innerIJRNS1_15regular_sub_posISD_EERNS1_25singleton_regular_sub_posISD_EERNS1_14empty_leaf_posISD_EEEEEDcDpOT_: 43| 73| { 44| 73| return Deriv::visit_node(std::forward(args)...); 45| 73| } _ZN5immer6detail4rbts12visitor_baseINS1_25concat_trees_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_relaxedIJRNS1_11relaxed_posISD_EENS1_8leaf_posISD_EERPSD_RjRmEEEDcDpOT_: 31| 480k| { 32| 480k| return Deriv::visit_inner(std::forward(args)...); 33| 480k| } _ZN5immer6detail4rbts12visitor_baseINS1_25concat_trees_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE11visit_innerIJRNS1_11relaxed_posISD_EENS1_8leaf_posISD_EERPSD_RjRmEEEDcDpOT_: 43| 480k| { 44| 480k| return Deriv::visit_node(std::forward(args)...); 45| 480k| } _ZN5immer6detail4rbts12visitor_baseINS1_26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_relaxedIJRNS1_11relaxed_posISD_EESJ_RNS1_8leaf_posISD_EEEEEDcDpOT_: 31| 475k| { 32| 475k| return Deriv::visit_inner(std::forward(args)...); 33| 475k| } _ZN5immer6detail4rbts12visitor_baseINS1_26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE11visit_innerIJRNS1_11relaxed_posISD_EESJ_RNS1_8leaf_posISD_EEEEEDcDpOT_: 43| 475k| { 44| 475k| return Deriv::visit_node(std::forward(args)...); 45| 475k| } _ZN5immer6detail4rbts12visitor_baseINS1_19concat_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_relaxedIJRNS1_11relaxed_posISD_EERNS1_8leaf_posISD_EESJ_EEEDcDpOT_: 31| 1.44M| { 32| 1.44M| return Deriv::visit_inner(std::forward(args)...); 33| 1.44M| } _ZN5immer6detail4rbts12visitor_baseINS1_19concat_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_regularIJRNS1_15regular_sub_posISD_EERNS1_8leaf_posISD_EERNS1_11relaxed_posISD_EEEEEDcDpOT_: 37| 299| { 38| 299| return Deriv::visit_inner(std::forward(args)...); 39| 299| } _ZN5immer6detail4rbts12visitor_baseINS1_20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_relaxedIJRNS1_11relaxed_posISD_EERNS1_15regular_sub_posISD_EERNS1_8leaf_posISD_EEEEEDcDpOT_: 31| 587k| { 32| 587k| return Deriv::visit_inner(std::forward(args)...); 33| 587k| } _ZN5immer6detail4rbts12visitor_baseINS1_20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_regularIJRNS1_15regular_sub_posISD_EESJ_RNS1_8leaf_posISD_EEEEEDcDpOT_: 37| 19.0k| { 38| 19.0k| return Deriv::visit_inner(std::forward(args)...); 39| 19.0k| } _ZN5immer6detail4rbts12visitor_baseINS1_19concat_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_regularIJRNS1_15regular_sub_posISD_EERNS1_8leaf_posISD_EESJ_EEEDcDpOT_: 37| 259| { 38| 259| return Deriv::visit_inner(std::forward(args)...); 39| 259| } _ZN5immer6detail4rbts12visitor_baseINS1_20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_regularIJRNS1_8full_posISD_EERNS1_15regular_sub_posISD_EERNS1_8leaf_posISD_EEEEEDcDpOT_: 37| 7.83k| { 38| 7.83k| return Deriv::visit_inner(std::forward(args)...); 39| 7.83k| } _ZN5immer6detail4rbts12visitor_baseINS1_19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_regularIJRNS1_15regular_sub_posISD_EERNS1_8leaf_posISD_EERNS1_8full_posISD_EEEEEDcDpOT_: 37| 3.77k| { 38| 3.77k| return Deriv::visit_inner(std::forward(args)...); 39| 3.77k| } _ZN5immer6detail4rbts12visitor_baseINS1_19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_regularIJRNS1_15regular_sub_posISD_EERNS1_8leaf_posISD_EESJ_EEEDcDpOT_: 37| 4.02k| { 38| 4.02k| return Deriv::visit_inner(std::forward(args)...); 39| 4.02k| } _ZN5immer6detail4rbts12visitor_baseINS1_19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_regularIJRNS1_15regular_sub_posISD_EERNS1_8leaf_posISD_EERNS1_11relaxed_posISD_EEEEEDcDpOT_: 37| 604k| { 38| 604k| return Deriv::visit_inner(std::forward(args)...); 39| 604k| } _ZN5immer6detail4rbts12visitor_baseINS1_20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_relaxedIJRNS1_11relaxed_posISD_EESJ_RNS1_8leaf_posISD_EEEEEDcDpOT_: 31| 3.96M| { 32| 3.96M| return Deriv::visit_inner(std::forward(args)...); 33| 3.96M| } _ZN5immer6detail4rbts12visitor_baseINS1_20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_regularIJRNS1_15regular_sub_posISD_EERNS1_11relaxed_posISD_EERNS1_8leaf_posISD_EEEEEDcDpOT_: 37| 4.58k| { 38| 4.58k| return Deriv::visit_inner(std::forward(args)...); 39| 4.58k| } _ZN5immer6detail4rbts12visitor_baseINS1_19concat_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_relaxedIJRNS1_11relaxed_posISD_EERNS1_8leaf_posISD_EERNS1_15regular_sub_posISD_EEEEEDcDpOT_: 31| 12.9k| { 32| 12.9k| return Deriv::visit_inner(std::forward(args)...); 33| 12.9k| } _ZN5immer6detail4rbts12visitor_baseINS1_20concat_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_regularIJRNS1_8full_posISD_EERNS1_11relaxed_posISD_EERNS1_8leaf_posISD_EEEEEDcDpOT_: 37| 35| { 38| 35| return Deriv::visit_inner(std::forward(args)...); 39| 35| } _ZN5immer6detail4rbts12visitor_baseINS1_19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_relaxedIJRNS1_11relaxed_posISD_EERNS1_8leaf_posISD_EERNS1_8full_posISD_EEEEEDcDpOT_: 31| 2| { 32| 2| return Deriv::visit_inner(std::forward(args)...); 33| 2| } _ZN5immer6detail4rbts12visitor_baseINS1_19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_relaxedIJRNS1_11relaxed_posISD_EERNS1_8leaf_posISD_EERNS1_15regular_sub_posISD_EEEEEDcDpOT_: 31| 25| { 32| 25| return Deriv::visit_inner(std::forward(args)...); 33| 25| } _ZN5immer6detail4rbts12visitor_baseINS1_19concat_both_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_relaxedIJRNS1_11relaxed_posISD_EERNS1_8leaf_posISD_EESJ_EEEDcDpOT_: 31| 3.95M| { 32| 3.95M| return Deriv::visit_inner(std::forward(args)...); 33| 3.95M| } _ZN5immer6detail4rbts12visitor_baseINS1_26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_regularIJRNS1_15regular_sub_posISD_EERNS1_11relaxed_posISD_EERNS1_8leaf_posISD_EEEEEDcDpOT_: 37| 4.63k| { 38| 4.63k| return Deriv::visit_inner(std::forward(args)...); 39| 4.63k| } _ZN5immer6detail4rbts12visitor_baseINS1_26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE11visit_innerIJRNS1_15regular_sub_posISD_EERNS1_11relaxed_posISD_EERNS1_8leaf_posISD_EEEEEDcDpOT_: 43| 4.63k| { 44| 4.63k| return Deriv::visit_node(std::forward(args)...); 45| 4.63k| } _ZN5immer6detail4rbts12visitor_baseINS1_25concat_trees_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_regularIJRNS1_15regular_sub_posISD_EENS1_8leaf_posISD_EERPSD_RjRmEEEDcDpOT_: 37| 1.82k| { 38| 1.82k| return Deriv::visit_inner(std::forward(args)...); 39| 1.82k| } _ZN5immer6detail4rbts12visitor_baseINS1_25concat_trees_left_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE11visit_innerIJRNS1_15regular_sub_posISD_EENS1_8leaf_posISD_EERPSD_RjRmEEEDcDpOT_: 43| 1.82k| { 44| 1.82k| return Deriv::visit_node(std::forward(args)...); 45| 1.82k| } _ZN5immer6detail4rbts12visitor_baseINS1_26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_relaxedIJRNS1_11relaxed_posISD_EERNS1_15regular_sub_posISD_EERNS1_8leaf_posISD_EEEEEDcDpOT_: 31| 579| { 32| 579| return Deriv::visit_inner(std::forward(args)...); 33| 579| } _ZN5immer6detail4rbts12visitor_baseINS1_26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE11visit_innerIJRNS1_11relaxed_posISD_EERNS1_15regular_sub_posISD_EERNS1_8leaf_posISD_EEEEEDcDpOT_: 43| 579| { 44| 579| return Deriv::visit_node(std::forward(args)...); 45| 579| } _ZN5immer6detail4rbts12visitor_baseINS1_26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE13visit_regularIJRNS1_15regular_sub_posISD_EESJ_RNS1_8leaf_posISD_EEEEEDcDpOT_: 37| 1.24k| { 38| 1.24k| return Deriv::visit_inner(std::forward(args)...); 39| 1.24k| } _ZN5immer6detail4rbts12visitor_baseINS1_26concat_trees_right_visitorINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEEE11visit_innerIJRNS1_15regular_sub_posISD_EESJ_RNS1_8leaf_posISD_EEEEEDcDpOT_: 43| 1.24k| { 44| 1.24k| return Deriv::visit_node(std::forward(args)...); 45| 1.24k| } _ZN5immer6detail4rbts12visitor_baseINS1_14equals_visitor3rrbEE13visit_relaxedIJRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_16rrbtree_iteratorIiSG_Lj3ELj3EEERKPSH_RKjRmEEEDcDpOT_: 31| 439| { 32| 439| return Deriv::visit_inner(std::forward(args)...); 33| 439| } _ZN5immer6detail4rbts12visitor_baseINS1_14equals_visitor3rrbEE11visit_innerIJRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_16rrbtree_iteratorIiSG_Lj3ELj3EEERKPSH_RKjRmEEEDcDpOT_: 43| 439| { 44| 439| return Deriv::visit_node(std::forward(args)...); 45| 439| } _ZN5immer6detail4rbts12visitor_baseINS1_14equals_visitor10this_aux_tEE13visit_relaxedIJRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERjSJ_RNS1_16rrbtree_iteratorIiSG_Lj3ELj3EEERmEEEDcDpOT_: 31| 1.14k| { 32| 1.14k| return Deriv::visit_inner(std::forward(args)...); 33| 1.14k| } _ZN5immer6detail4rbts12visitor_baseINS1_14equals_visitor10this_aux_tEE13visit_relaxedIJRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERjRNS1_15regular_sub_posISH_EERNS1_16rrbtree_iteratorIiSG_Lj3ELj3EEERmEEEDcDpOT_: 31| 20| { 32| 20| return Deriv::visit_inner(std::forward(args)...); 33| 20| } _ZN5immer6detail4rbts12visitor_baseINS1_14equals_visitor10this_aux_tEE13visit_relaxedIJRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERjRNS1_8full_posISH_EERNS1_16rrbtree_iteratorIiSG_Lj3ELj3EEERmEEEDcDpOT_: 31| 40| { 32| 40| return Deriv::visit_inner(std::forward(args)...); 33| 40| } _ZN5immer6detail4rbts12visitor_baseINS1_14equals_visitor10this_aux_tEE13visit_regularIJRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERjRNS1_8full_posISH_EERNS1_16rrbtree_iteratorIiSG_Lj3ELj3EEERmEEEDcDpOT_: 37| 16| { 38| 16| return Deriv::visit_inner(std::forward(args)...); 39| 16| } _ZN5immer6detail4rbts12visitor_baseINS1_18region_for_visitorIiEEE13visit_relaxedIJRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERmEEEDcDpOT_: 31| 1.06M| { 32| 1.06M| return Deriv::visit_inner(std::forward(args)...); 33| 1.06M| } _ZN5immer6detail4rbts12visitor_baseINS1_18region_for_visitorIiEEE13visit_regularIJRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERmEEEDcDpOT_: 37| 258k| { 38| 258k| return Deriv::visit_inner(std::forward(args)...); 39| 258k| } _ZN5immer6detail4rbts12visitor_baseINS1_18region_for_visitorIiEEE13visit_regularIJRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERmEEEDcDpOT_: 37| 615k| { 38| 615k| return Deriv::visit_inner(std::forward(args)...); 39| 615k| } _ZN5immer6detail4rbts12visitor_baseINS1_18region_for_visitorIiEEE13visit_regularIJRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERmEEEDcDpOT_: 37| 25.6k| { 38| 25.6k| return Deriv::visit_inner(std::forward(args)...); 39| 25.6k| } _ZN5immer6detail4rbts12visitor_baseINS1_24for_each_chunk_p_visitorEE13visit_regularIJRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSF_Lj3ELj3EEEEEDaOT_EUlSN_T0_E_EEEDcDpOT_: 37| 36.1k| { 38| 36.1k| return Deriv::visit_inner(std::forward(args)...); 39| 36.1k| } _ZN5immer6detail4rbts12visitor_baseINS1_24for_each_chunk_p_visitorEE13visit_regularIJRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSF_Lj3ELj3EEEEEDaOT_EUlSN_T0_E_EEEDcDpOT_: 37| 557| { 38| 557| return Deriv::visit_inner(std::forward(args)...); 39| 557| } _ZN5immer6detail4rbts12visitor_baseINS1_24for_each_chunk_p_visitorEE13visit_regularIJRNS1_11regular_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSF_Lj3ELj3EEEEEDaOT_EUlSN_T0_E_EEEDcDpOT_: 37| 291| { 38| 291| return Deriv::visit_inner(std::forward(args)...); 39| 291| } _ZN5immer6detail4rbts12visitor_baseINS1_14equals_visitor10this_aux_tEE13visit_regularIJRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERjRNS1_11relaxed_posISH_EERNS1_16rrbtree_iteratorIiSG_Lj3ELj3EEERmEEEDcDpOT_: 37| 33| { 38| 33| return Deriv::visit_inner(std::forward(args)...); 39| 33| } _ZN5immer6detail4rbts12visitor_baseINS1_14equals_visitor10this_aux_tEE13visit_regularIJRNS1_8full_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERjRNS1_11relaxed_posISH_EERNS1_16rrbtree_iteratorIiSG_Lj3ELj3EEERmEEEDcDpOT_: 37| 18| { 38| 18| return Deriv::visit_inner(std::forward(args)...); 39| 18| } _ZN5immer6detail4rbts12visitor_baseINS1_24for_each_chunk_p_visitorEE13visit_relaxedIJRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERZNS1_14equals_visitor13equal_chunk_pINS1_16rrbtree_iteratorIiSF_Lj3ELj3EEEEEDaOT_EUlSN_T0_E_EEEDcDpOT_: 31| 21.8k| { 32| 21.8k| return Deriv::visit_inner(std::forward(args)...); 33| 21.8k| } _ZN5immer6detail4rbts12visitor_baseINS1_14equals_visitor3rrbEE13visit_relaxedIJRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_16rrbtree_iteratorIiSG_Lj3ELj3EEERPSH_RjRmEEEDcDpOT_: 31| 2| { 32| 2| return Deriv::visit_inner(std::forward(args)...); 33| 2| } _ZN5immer6detail4rbts12visitor_baseINS1_14equals_visitor3rrbEE11visit_innerIJRNS1_11relaxed_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEERNS1_16rrbtree_iteratorIiSG_Lj3ELj3EEERPSH_RjRmEEEDcDpOT_: 43| 2| { 44| 2| return Deriv::visit_node(std::forward(args)...); 45| 2| } _ZN5immer6detail4rbts12visitor_baseINS1_14equals_visitor3rrbEE13visit_regularIJRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_16rrbtree_iteratorIiSG_Lj3ELj3EEERKPSH_RKjRmEEEDcDpOT_: 37| 256| { 38| 256| return Deriv::visit_inner(std::forward(args)...); 39| 256| } _ZN5immer6detail4rbts12visitor_baseINS1_14equals_visitor3rrbEE11visit_innerIJRNS1_15regular_sub_posINS1_4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEEENS1_16rrbtree_iteratorIiSG_Lj3ELj3EEERKPSH_RKjRmEEEDcDpOT_: 43| 256| { 44| 256| return Deriv::visit_node(std::forward(args)...); 45| 256| } _ZN5immer6detail15auto_const_castINS_22unsafe_refcount_policyEEERT_RKS3_: 45| 280M|{ 46| 280M| return const_cast(x); 47| 280M|} _ZN5immer6detail9static_ifILb1EZNS0_4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE14delete_inner_rEPSC_jEUlT_E_EENSt3__19enable_ifIXT_EvE4typeEOT0_: 231| 18.3M|{ 232| 18.3M| std::forward(f)(empty_t{}); 233| 18.3M|} _ZN5immer6detail9destroy_nIPijEENSt3__19enable_ifIX20can_trivially_detroyIT_EES5_E4typeES5_T0_: 90| 1.31M|{ 91| 1.31M| return first + n; 92| 1.31M|} _ZN5immer6detail18uninitialized_copyIPiS2_S2_EENSt3__19enable_ifIX18can_trivially_copyIT_T1_EES6_E4typeES5_T0_S6_: 138| 1.81M|{ 139| 1.81M| return std::copy(first, last, out); 140| 1.81M|} _ZN5immer6detail9static_ifILb0EPNS0_4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEZNSC_15make_inner_sr_nEjPNS0_3csl10member_twoINSC_14relaxed_data_tENSE_6memberIS8_NSE_7inheritINSA_5applyIS7_E4type5owneeEvE4typeEE4typeEE4typeEEUlT_E_ZNSC_15make_inner_sr_nEjST_EUlSU_E0_EENSt3__19enable_ifIXntT_ET0_E4typeEOT1_OT2_: 245| 105k|{ 246| 105k| return std::forward(f2)(empty_t{}); 247| 105k|} _ZN5immer6detail4ipowImEET_S2_j: 225| 33.7M|{ 226| 33.7M| return pow == 0 ? 1 : num * ipow(num, pow - 1); ------------------ | Branch (226:12): [True: 1.60M, False: 32.1M] ------------------ 227| 33.7M|} _ZN5immer6detail9static_ifILb0EPNS0_3csl10member_twoINS0_4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE14relaxed_data_tENS2_6memberISA_NS2_7inheritINSC_5applyIS9_E4type5owneeEvE4typeEE4typeEE4typeEZNSE_24ensure_mutable_relaxed_nENSK_4editEjEUlT_E_ZNSE_24ensure_mutable_relaxed_nEST_jEUlSU_E0_EENSt3__19enable_ifIXntT_ET0_E4typeEOT1_OT2_: 245| 175k|{ 246| 175k| return std::forward(f2)(empty_t{}); 247| 175k|} _ZN5immer6detail9static_ifILb1EZNS0_4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE14make_inner_r_eENSA_5applyIS7_E4type4editEEUlT_E_EENSt3__19enable_ifIXT_EvE4typeEOT0_: 231| 128k|{ 232| 128k| std::forward(f)(empty_t{}); 233| 128k|} _ZN5immer6detail9static_ifILb0EPNS0_4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEZNSC_15make_inner_sr_eENSA_5applyIS7_E4type4editEPNS0_3csl10member_twoINSC_14relaxed_data_tENSI_6memberIS8_NSI_7inheritINSG_5owneeEvE4typeEE4typeEE4typeEEUlT_E_ZNSC_15make_inner_sr_eESH_SU_EUlSV_E0_EENSt3__19enable_ifIXntT_ET0_E4typeEOT1_OT2_: 245| 7.67k|{ 246| 7.67k| return std::forward(f2)(empty_t{}); 247| 7.67k|} _ZN5immer6detail9destroy_nIPimEENSt3__19enable_ifIX20can_trivially_detroyIT_EES5_E4typeES5_T0_: 90| 113|{ 91| 113| return first + n; 92| 113|} _ZN5immer6detail9static_ifILb0EPNS0_3csl10member_twoINS0_4rbts4nodeIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE14relaxed_data_tENS2_6memberISA_NS2_7inheritINSC_5applyIS9_E4type5owneeEvE4typeEE4typeEE4typeEZNSE_22ensure_mutable_relaxedENSK_4editEEUlT_E_ZNSE_22ensure_mutable_relaxedEST_EUlSU_E0_EENSt3__19enable_ifIXntT_ET0_E4typeEOT1_OT2_: 245| 91.2k|{ 246| 91.2k| return std::forward(f2)(empty_t{}); 247| 91.2k|} _ZN5immer6detail18uninitialized_moveIPiS2_EENSt3__19enable_ifIX18can_trivially_copyIT_T0_EES6_E4typeES5_S5_S6_: 112| 7.54k|{ 113| 7.54k| return std::copy(first, last, out); 114| 7.54k|} _ZN5immer6detail8as_constIiEEPKT_PS2_: 29| 395k|{ 30| 395k| return x; 31| 395k|} _ZN5immer6detail4makeINS_15debug_size_heapINS_8cpp_heapEEENS_3boxIiNS_13memory_policyINS_21free_list_heap_policyIS3_Lm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6holderEJiEEEPT0_DpOT1_: 162| 1.19k|{ 163| 1.19k| auto ptr = Heap::allocate(sizeof(T)); 164| 1.19k| IMMER_TRY { ------------------ | | 41| 1.19k|#define IMMER_TRY try ------------------ 165| 1.19k| return new (ptr) T{std::forward(args)...}; 166| 1.19k| } 167| 1.19k| IMMER_CATCH (...) { 168| 0| Heap::deallocate(sizeof(T), ptr); 169| 0| IMMER_RETHROW; ------------------ | | 44| 0|#define IMMER_RETHROW throw ------------------ 170| 0| } 171| 1.19k|} _ZN5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEC2Ev: 96| 2.40k| flex_vector() = default; _ZNKR5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE9push_backEi: 242| 153k| { 243| 153k| return impl_.push_back(std::move(value)); 244| 153k| } _ZN5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEC2ENS_6detail4rbts7rrbtreeIiS8_Lj3ELj3EEE: 532| 963k| { 533| |#if IMMER_DEBUG_PRINT 534| | // force the compiler to generate debug_print, so we can call 535| | // it from a debugger 536| | [](volatile auto) {}(&flex_vector::debug_print); 537| |#endif 538| 963k| } _ZNK5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE4sizeEv: 177| 2.77M| IMMER_NODISCARD size_type size() const { return impl_.size; } flex-vector-st.cpp:_ZNKR5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE6updateIZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSE_E_EES9_mOSE_: 319| 330k| { 320| 330k| return impl_.update(index, std::forward(fn)); 321| 330k| } _ZNKR5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE4takeEm: 346| 2.13k| { 347| 2.13k| return impl_.take(elems); 348| 2.13k| } _ZNKR5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE4dropEm: 372| 1.82k| { 373| 1.82k| return impl_.drop(elems); 374| 1.82k| } _ZN5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE8max_sizeEv: 90| 1.12M| constexpr static size_type max_size() { return impl_t::max_size(); } _ZN5immerplERKNS_11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEESB_: 399| 475k| { 400| 475k| return l.impl_.concat(r.impl_); 401| 475k| } _ZNO5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE9push_backEi: 247| 2.55k| { 248| 2.55k| return push_back_move(move_t{}, std::move(value)); 249| 2.55k| } _ZN5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE14push_back_moveENSt3__117integral_constantIbLb1EEEi: 541| 2.55k| { 542| 2.55k| impl_.push_back_mut({}, std::move(value)); 543| 2.55k| return std::move(*this); 544| 2.55k| } flex-vector-st.cpp:_ZNO5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE6updateIZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSE_E0_EEDcmOSE_: 325| 4.29k| { 326| 4.29k| return update_move(move_t{}, index, std::forward(fn)); 327| 4.29k| } flex-vector-st.cpp:_ZN5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11update_moveIZZ22LLVMFuzzerTestOneInputENK3$_6clI12fuzzer_inputEEDaRT_EUlSE_E0_EEOS9_NSt3__117integral_constantIbLb1EEEmOSE_: 562| 4.29k| { 563| 4.29k| impl_.update_mut({}, index, std::forward(fn)); 564| 4.29k| return std::move(*this); 565| 4.29k| } _ZNO5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE4takeEm: 351| 8.20k| { 352| 8.20k| return take_move(move_t{}, elems); 353| 8.20k| } _ZN5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE9take_moveENSt3__117integral_constantIbLb1EEEm: 573| 8.20k| { 574| 8.20k| impl_.take_mut({}, elems); 575| 8.20k| return std::move(*this); 576| 8.20k| } _ZNO5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE4dropEm: 377| 25.0k| { 378| 25.0k| return drop_move(move_t{}, elems); 379| 25.0k| } _ZN5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE9drop_moveENSt3__117integral_constantIbLb1EEEm: 583| 25.0k| { 584| 25.0k| impl_.drop_mut({}, elems); 585| 25.0k| return std::move(*this); 586| 25.0k| } _ZN5immerplEONS_11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEERKS9_: 405| 339k| { 406| 339k| return concat_move(move_t{}, std::move(l), r); 407| 339k| } _ZN5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11concat_moveENSt3__117integral_constantIbLb1EEEOS9_RKS9_: 594| 339k| { 595| 339k| concat_mut_l(l.impl_, {}, r.impl_); 596| 339k| return std::move(l); 597| 339k| } _ZN5immerplERKNS_11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEEOS9_: 411| 185| { 412| 185| return concat_move(move_t{}, l, std::move(r)); 413| 185| } _ZN5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11concat_moveENSt3__117integral_constantIbLb1EEERKS9_OS9_: 600| 185| { 601| 185| concat_mut_r(l.impl_, r.impl_, {}); 602| 185| return std::move(r); 603| 185| } _ZN5immerplEONS_11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEESA_: 417| 232k| { 418| 232k| return concat_move(move_t{}, std::move(l), std::move(r)); 419| 232k| } _ZN5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE11concat_moveENSt3__117integral_constantIbLb1EEEOS9_SD_: 606| 232k| { 607| 232k| concat_mut_lr_l(l.impl_, {}, r.impl_, {}); 608| 232k| return std::move(l); 609| 232k| } _ZNK5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EEeqERKS9_: 218| 1.68k| { 219| 1.68k| return impl_.equals(other.impl_); 220| 1.68k| } _ZNKR5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE5eraseEm: 476| 378| { 477| 378| return take(pos) + drop(pos + 1); 478| 378| } _ZNKR5immer11flex_vectorIiNS_13memory_policyINS_11heap_policyINS_8cpp_heapEEENS_22unsafe_refcount_policyENS_14no_lock_policyENS_20no_transience_policyELb0ELb1EEELj3ELj3EE6insertEmi: 438| 1.19k| { 439| 1.19k| return take(pos).push_back(std::move(value)) + drop(pos); 440| 1.19k| } _ZN5immer8cpp_heap10deallocateEmPv: 37| 39.2M| { 38| 39.2M| ::operator delete(data); 39| 39.2M| } _ZN5immer8cpp_heap8allocateIJEEEPvmDpT_: 27| 21.0M| { 28| 21.0M| return ::operator new(size); 29| 21.0M| } _ZN5immer8cpp_heap8allocateIJNS_10norefs_tagEEEEPvmDpT_: 27| 18.2M| { 28| 18.2M| return ::operator new(size); 29| 18.2M| } _ZN5immer15debug_size_heapINS_8cpp_heapEE8allocateIJEEEPvmDpT_: 47| 1.19k| { 48| 1.19k| auto p = (std::size_t*) Base::allocate(size + extra_size, tags...); 49| 1.19k| new (p) std::size_t{size}; 50| 1.19k| return ((char*) p) + extra_size; 51| 1.19k| } _ZN5immer15debug_size_heapINS_8cpp_heapEE10deallocateIJEEEvmPvDpT_: 55| 1.19k| { 56| 1.19k| auto p = (std::size_t*) (((char*) data) - extra_size); 57| 1.19k| assert(*p == size); 58| 0| Base::deallocate(size + extra_size, p, tags...); 59| 1.19k| } _ZN5immer15refcount_policyC2Ev: 28| 1.19k| : refcount{1} {}; _ZN5immer15refcount_policy3decEv: 35| 1.19k| bool dec() { return 1 == refcount.fetch_sub(1, std::memory_order_acq_rel); } _ZN5immer22unsafe_refcount_policyC2Ev: 27| 39.2M| : refcount{1} {}; _ZN5immer22unsafe_refcount_policy3incEv: 32| 119M| void inc() { ++refcount; } _ZN5immer22unsafe_refcount_policy3decEv: 33| 159M| bool dec() { return --refcount == 0; } _ZN5immer22unsafe_refcount_policy6uniqueEv: 34| 1.94M| bool unique() { return refcount == 1; } _ZNK5immer20no_transience_policy5applyINS_11heap_policyINS_8cpp_heapEEEE4type5ownee5ownedEv: 36| 39.2M| bool owned() const { return false; } _ZNK5immer20no_transience_policy5applyINS_11heap_policyINS_8cpp_heapEEEE4type5ownee10can_mutateENS6_4editE: 35| 75.5k| bool can_mutate(edit) const { return false; } _ZN5immer20no_transience_policy5applyINS_11heap_policyINS_8cpp_heapEEEE4type5owneeaSENS6_4editE: 34| 561k| ownee& operator=(edit) { return *this; };