| /oneTBB/src/tbbmalloc/ |
| H A D | backref.cpp | 143 bl->nextForUse = listForUse.load(std::memory_order_relaxed); in addToForUseList()
201 …if (active.load(std::memory_order_relaxed)->allocatedCount.load(std::memory_order_relaxed) == BR_M… in requestNewSpace()
240 if (!(backRefMain.load(std::memory_order_acquire)) in getBackRef()
241 …|| backRefIdx.getMain() > (backRefMain.load(std::memory_order_relaxed)->lastUsed.load(std::memory_… in getBackRef()
250 return backRefEntry.load(std::memory_order_relaxed); in getBackRef()
255 …MALLOC_ASSERT(backRefIdx.getMain()<=backRefMain.load(std::memory_order_relaxed)->lastUsed.load(std… in setBackRef()
297 … !backRefMain.load(std::memory_order_relaxed)->listForUse.load(std::memory_order_relaxed)) { in newBackRef()
323 …MALLOC_ASSERT(backRefIdx.getMain()<=backRefMain.load(std::memory_order_relaxed)->lastUsed.load(std… in removeBackRef()
344 if (!currBlock->addedToForUse.load(std::memory_order_relaxed) && in removeBackRef()
345 … currBlock!=backRefMain.load(std::memory_order_relaxed)->active.load(std::memory_order_relaxed)) { in removeBackRef()
[all …]
|
| H A D | large_objects.cpp | 488 if (last.load(std::memory_order_relaxed) && in cleanToThreshold()
489 …(intptr_t)(currTime - oldest.load(std::memory_order_relaxed)) > ageThreshold.load(std::memory_orde… in cleanToThreshold()
510 if (last.load(std::memory_order_relaxed)) { in releaseAllToBackend()
544 …(last.load(std::memory_order_relaxed)->age != 0 && last.load(std::memory_order_relaxed)->age != -1… in putList()
567 if (!last.load(std::memory_order_relaxed)) { in putList()
630 if ( !last.load(std::memory_order_relaxed) || in cleanToThreshold()
631 …(intptr_t)(currTime - last.load(std::memory_order_relaxed)->age) < ageThreshold.load(std::memory_o… in cleanToThreshold()
647 …(intptr_t)(currTime - last.load(std::memory_order_relaxed)->age) > ageThreshold.load(std::memory_o… in cleanToThreshold()
650 if (last.load(std::memory_order_relaxed)) { in cleanToThreshold()
677 if (!usedSize.load(std::memory_order_relaxed)) in cleanAll()
[all …]
|
| H A D | backend.cpp | 55 if (left < leftBound.load(std::memory_order_relaxed)) in registerAlloc()
57 if (right > rightBound.load(std::memory_order_relaxed)) in registerAlloc()
60 …MALLOC_ASSERT(leftBound.load(std::memory_order_relaxed) < rightBound.load(std::memory_order_relaxe… in registerAlloc()
61 …MALLOC_ASSERT(leftBound.load(std::memory_order_relaxed) <= left && right <= rightBound.load(std::m… in registerAlloc()
67 if (leftBound.load(std::memory_order_relaxed) == left) { in registerFree()
75 …MALLOC_ASSERT((!rightBound.load(std::memory_order_relaxed) && leftBound.load(std::memory_order_rel… in registerFree()
76 …|| leftBound.load(std::memory_order_relaxed) < rightBound.load(std::memory_order_relaxed), ASSERT_… in registerFree()
176 size_t sz = value.load(std::memory_order_acquire); in tryLock()
481 if (head.load(std::memory_order_relaxed) == fBlock) in removeBlock()
731 if (!memSoftLimit.load(std::memory_order_relaxed) in releaseCachesToLimit()
[all …]
|
| H A D | large_objects.h | 194 intptr_t threshold = ageThreshold.load(std::memory_order_relaxed); in decreaseThreshold()
196 …ageThreshold.store((threshold + meanHitRange.load(std::memory_order_relaxed)) / 2, std::memory_ord… in decreaseThreshold()
199 …binsSummary->update(usedSize.load(std::memory_order_relaxed), cachedSize.load(std::memory_order_re… in updateBinsSummary()
201 size_t getSize() const { return cachedSize.load(std::memory_order_relaxed); } in getSize()
202 size_t getUsedSize() const { return usedSize.load(std::memory_order_relaxed); } in getUsedSize()
213 if (!usedSize.load(std::memory_order_relaxed)) bitMask->set(idx, true); in updateUsedSize()
214 … usedSize.store(usedSize.load(std::memory_order_relaxed) + size, std::memory_order_relaxed); in updateUsedSize()
215 if (!usedSize.load(std::memory_order_relaxed) && !first) bitMask->set(idx, false); in updateUsedSize()
219 intptr_t mean = meanHitRange.load(std::memory_order_relaxed); in updateMeanHitRange()
228 … cachedSize.store(cachedSize.load(std::memory_order_relaxed) + size, std::memory_order_relaxed); in updateCachedSize()
|
| /oneTBB/src/tbb/ |
| H A D | arena_slot.h | 169 return task_pool.load(std::memory_order_relaxed) != EmptyTaskPool; in is_task_pool_published()
174 head.load(std::memory_order_relaxed) >= tail.load(std::memory_order_relaxed); in is_empty()
178 return my_is_occupied.load(std::memory_order_relaxed); in is_occupied()
214 std::size_t T = tail.load(std::memory_order_relaxed); // mirror in prepare_task_pool()
228 std::size_t H = head.load(std::memory_order_relaxed); // mirror in prepare_task_pool()
276 __TBB_ASSERT ( head.load(std::memory_order_relaxed) < tail.load(std::memory_order_relaxed), in publish_task_pool()
296 d1::task** tp = task_pool.load(std::memory_order_relaxed); in acquire_task_pool()
328 victim_task_pool = task_pool.load(std::memory_order_relaxed); in lock_task_pool()
361 d1::task** tp = task_pool.load(std::memory_order_relaxed); in is_local_task_pool_quiescent()
367 return head.load(std::memory_order_relaxed) == tail.load(std::memory_order_relaxed); in is_quiescent_local_task_pool_empty()
[all …]
|
| H A D | observer_proxy.cpp | 82 if (my_head.load(std::memory_order_relaxed) == nullptr) { in clear()
87 …__TBB_ASSERT(my_head.load(std::memory_order_relaxed) == nullptr && my_tail.load(std::memory_order_… in clear()
92 if (my_head.load(std::memory_order_relaxed)) { in insert()
93 p->my_prev = my_tail.load(std::memory_order_relaxed); in insert()
94 my_tail.load(std::memory_order_relaxed)->my_next = p; in insert()
104 if (p == my_tail.load(std::memory_order_relaxed)) { in remove()
111 if (p == my_head.load(std::memory_order_relaxed)) { in remove()
118 …__TBB_ASSERT((my_head.load(std::memory_order_relaxed) && my_tail.load(std::memory_order_relaxed)) … in remove()
119 … (!my_head.load(std::memory_order_relaxed) && !my_tail.load(std::memory_order_relaxed)), nullptr); in remove()
181 p = my_head.load(std::memory_order_relaxed); in do_notify_entry_observers()
[all …]
|
| H A D | queuing_rw_mutex.cpp | 60 static T* load( std::atomic<word>& location, std::memory_order memory_order ) { in load() function in tbb::detail::r1::tricky_atomic_pointer
61 return reinterpret_cast<T*>(location.load(memory_order)); in load()
202 pred_state = predecessor->my_state.load(std::memory_order_relaxed); in acquire()
210 (void)predecessor->my_state.load(std::memory_order_acquire); in acquire()
258 if( m.q_tail.load(std::memory_order_relaxed) ) in try_acquire()
303 next = tricky_pointer::load(s.my_next, std::memory_order_acquire); in release()
422 if( &s == s.my_mutex->q_tail.load(std::memory_order_seq_cst) ) { in downgrade_to_reader()
434 next = tricky_pointer::load(s.my_next, std::memory_order_acquire); in downgrade_to_reader()
457 if (s.my_state.load(std::memory_order_relaxed) == STATE_WRITER) { in upgrade_to_writer()
481 unsigned short n_state = next->my_state.load(std::memory_order_acquire); in upgrade_to_writer()
[all …]
|
| H A D | mailbox.h | 66 intptr_t tat = task_and_tag.load(std::memory_order_acquire); in extract_task()
116 task_proxy* curr = my_first.load(std::memory_order_acquire); in internal_pop()
124 curr = curr->next_in_mailbox.load(std::memory_order_acquire); in internal_pop()
131 if ( task_proxy* second = curr->next_in_mailbox.load(std::memory_order_acquire) ) { in internal_pop()
141 __TBB_ASSERT( !curr->next_in_mailbox.load(std::memory_order_relaxed), nullptr); in internal_pop()
172 return my_first.load(std::memory_order_relaxed) == nullptr; in empty()
181 __TBB_ASSERT( !my_first.load(std::memory_order_relaxed), nullptr ); in construct()
182 __TBB_ASSERT( !my_last.load(std::memory_order_relaxed), nullptr ); in construct()
183 __TBB_ASSERT( !my_is_idle.load(std::memory_order_relaxed), nullptr ); in construct()
199 return my_is_idle.load(std::memory_order_relaxed); in recipient_is_idle()
[all …]
|
| H A D | task_group_context.cpp | 58 …__TBB_ASSERT(ctx.my_state.load(std::memory_order_relaxed) == d1::task_group_context::state::bound,… in destroy()
68 auto exception = ctx.my_exception.load(std::memory_order_relaxed); in destroy()
141 …uintptr_t local_count_snapshot = ctx.my_parent->my_context_list->epoch.load(std::memory_order_acqu… in bind_to_impl()
151 … if (local_count_snapshot != the_context_state_propagation_epoch.load(std::memory_order_relaxed)) { in bind_to_impl()
166 d1::task_group_context::state state = ctx.my_state.load(std::memory_order_acquire); in bind_to()
196 …__TBB_ASSERT(ctx.my_state.load(std::memory_order_relaxed) != d1::task_group_context::state::create… in bind_to()
197 …__TBB_ASSERT(ctx.my_state.load(std::memory_order_relaxed) != d1::task_group_context::state::locked… in bind_to()
215 if ((ctx.*mptr_state).load(std::memory_order_relaxed) != new_state && &ctx != &src) { in propagate_task_group_state()
229 …if (ctx.my_cancellation_requested.load(std::memory_order_relaxed) || ctx.my_cancellation_requested… in cancel_group_execution()
240 return ctx.my_cancellation_requested.load(std::memory_order_relaxed) != 0; in is_group_execution_cancelled()
[all …]
|
| H A D | arena_slot.cpp | 29 __TBB_ASSERT(tail.load(std::memory_order_relaxed) <= T || is_local_task_pool_quiescent(), in get_task_impl()
64 std::size_t T0 = tail.load(std::memory_order_relaxed); in get_task()
76 if ( (std::intptr_t)( head.load(std::memory_order_acquire) ) > (std::intptr_t)T ) { in get_task()
78 H0 = head.load(std::memory_order_relaxed); in get_task()
81 __TBB_ASSERT( H0 == head.load(std::memory_order_relaxed) in get_task()
82 && T == tail.load(std::memory_order_relaxed) in get_task()
143 __TBB_ASSERT( (std::intptr_t)tail.load(std::memory_order_relaxed) >= 0, nullptr ); in get_task()
154 std::size_t H = head.load(std::memory_order_relaxed); // mirror in steal_task()
162 if ((std::intptr_t)H > (std::intptr_t)(tail.load(std::memory_order_acquire))) { in steal_task()
|
| H A D | rtm_rw_mutex.cpp | 46 …__TBB_ASSERT(!s.m_mutex->write_flag.load(std::memory_order_relaxed), "write_flag set but read lock… in release()
51 …__TBB_ASSERT(s.m_mutex->write_flag.load(std::memory_order_relaxed), "write_flag unset but write lo… in release()
72 if(m.m_state.load(std::memory_order_acquire)) { in acquire_writer()
80 … if(m.m_state.load(std::memory_order_relaxed)) { // add spin_rw_mutex to read-set. in acquire_writer()
97 …__TBB_ASSERT(!m.write_flag.load(std::memory_order_relaxed), "After acquire for write, write_flag a… in acquire_writer()
113 if(m.write_flag.load(std::memory_order_acquire)) { in acquire_reader()
121 … if(m.write_flag.load(std::memory_order_relaxed)) { // add write_flag to read-set. in acquire_reader()
156 …__TBB_ASSERT(!s.m_mutex->write_flag.load(std::memory_order_relaxed), "After upgrade, write_flag al… in upgrade()
162 if(m.m_state.load(std::memory_order_acquire)) { // add spin_rw_mutex to read-set. in upgrade()
184 …__TBB_ASSERT(s.m_mutex->write_flag.load(std::memory_order_relaxed), "Before downgrade write_flag n… in downgrade()
[all …]
|
| H A D | concurrent_monitor_mutex.h | 40 if (my_init_flag.load(std::memory_order_relaxed)) { in destroy()
48 return my_flag.load(std::memory_order_relaxed) == 0; in lock()
64 if (my_waiters.load(std::memory_order_relaxed)) { in unlock()
92 if (!my_init_flag.load(std::memory_order_acquire)) { in get_semaphore()
94 if (!my_init_flag.load(std::memory_order_relaxed)) { in get_semaphore()
|
| H A D | private_server.cpp | 158 if( my_asleep_list_root.load(std::memory_order_relaxed) ) in propagate_chain_reaction()
237 …__TBB_ASSERT(my_state.load(std::memory_order_relaxed) != st_quit, "The quit state is expected to b… in start_shutdown()
269 while( my_state.load(std::memory_order_seq_cst)!=st_quit ) { in run()
270 if( my_server.my_slack.load(std::memory_order_acquire)>=0 ) { in run()
274 …__TBB_ASSERT(my_state.load(std::memory_order_relaxed) == st_quit || !my_next, "Thread monitor miss… in run()
285 state_t state = my_state.load(std::memory_order_relaxed); in wake_or_launch()
342 t->my_next = my_asleep_list_root.load(std::memory_order_relaxed); in private_server()
361 auto expected = my_slack.load(std::memory_order_relaxed); in try_insert_in_asleep_list()
364 t.my_next = my_asleep_list_root.load(std::memory_order_relaxed); in try_insert_in_asleep_list()
386 int old = my_slack.load(std::memory_order_relaxed); in wake_some()
[all …]
|
| H A D | concurrent_monitor.h | 50 inline std::size_t size() const { return count.load(std::memory_order_relaxed); } in size()
58 count.store(count.load(std::memory_order_relaxed) + 1, std::memory_order_relaxed); in add()
68 count.store(count.load( std::memory_order_relaxed ) - 1, std::memory_order_relaxed); in remove()
171 __TBB_ASSERT(!this->my_is_in_list.load(std::memory_order_relaxed), "Still in the queue?"); in wait()
217 node.my_epoch = my_epoch.load(std::memory_order_relaxed); in prepare_wait()
229 const bool do_it = node.my_epoch == my_epoch.load(std::memory_order_relaxed); in commit_wait()
245 bool in_list = node.my_is_in_list.load(std::memory_order_acquire); in cancel_wait()
248 if (node.my_is_in_list.load(std::memory_order_relaxed)) { in cancel_wait()
289 my_epoch.store(my_epoch.load(std::memory_order_relaxed) + 1, std::memory_order_relaxed); in notify_one_relaxed()
328 my_epoch.store(my_epoch.load(std::memory_order_relaxed) + 1, std::memory_order_relaxed); in notify_all_relaxed()
[all …]
|
| /oneTBB/include/oneapi/tbb/ |
| H A D | rw_mutex.h | 40 __TBB_ASSERT(!m_state.load(std::memory_order_relaxed), "destruction of an acquired mutex"); in ~rw_mutex()
58 if (!(m_state.load(std::memory_order_relaxed) & WRITER_PENDING)) { // no pending writers in lock()
62 … auto wakeup_condition = [&] { return !(m_state.load(std::memory_order_relaxed) & BUSY); }; in lock()
75 state_type s = m_state.load(std::memory_order_relaxed); in try_lock()
104 … auto wakeup_condition = [&] { return !(m_state.load(std::memory_order_relaxed) & has_writer); }; in lock_shared()
107 …__TBB_ASSERT(m_state.load(std::memory_order_relaxed) & READERS, "invalid state of a read lock: no … in lock_shared()
116 if (!(m_state.load(std::memory_order_relaxed) & has_writer)) { in try_lock_shared()
130 …__TBB_ASSERT(m_state.load(std::memory_order_relaxed) & READERS, "invalid state of a read lock: no … in unlock_shared()
151 state_type s = m_state.load(std::memory_order_relaxed); in upgrade()
159 while ((m_state.load(std::memory_order_relaxed) & READERS) != ONE_READER) { in upgrade()
[all …]
|
| H A D | concurrent_hash_map.h | 168 n->next = b->node_list.load(std::memory_order_relaxed); in add_to_bucket()
243 segment_ptr_type seg = my_table[s].load(std::memory_order_acquire); in get_bucket()
262 m_now = my_mask.load(std::memory_order_acquire); in check_mask_race()
297 if (!(my_table[new_seg].load(std::memory_order_acquire)) in insert_new_node()
307 bool is_initial = !my_size.load(std::memory_order_relaxed); in reserve()
309 m = my_mask.load(std::memory_order_relaxed)) in reserve()
328 auto temp = my_table[i].load(std::memory_order_relaxed); in internal_swap_content()
441 while (k <= my_map->my_mask.load(std::memory_order_relaxed)) { in advance_to_next_bucket()
1009 hashcode_type m = this->my_mask.load(std::memory_order_relaxed); in __TBB_requires()
1279 hashcode_type m = this->my_mask.load(std::memory_order_acquire); in __TBB_requires()
[all …]
|
| H A D | task_scheduler_observer.h | 60 bool is_observing() const { return my_proxy.load(std::memory_order_relaxed) != nullptr; } in is_observing()
91 if (my_proxy.load(std::memory_order_acquire)) { in ~task_scheduler_observer()
100 if( state && !my_proxy.load(std::memory_order_relaxed) ) {
101 …__TBB_ASSERT( my_busy_count.load(std::memory_order_relaxed) == 0, "Inconsistent state of task_sche…
|
| H A D | spin_rw_mutex.h | 68 state_type s = m_state.load(std::memory_order_relaxed); in lock()
84 state_type s = m_state.load(std::memory_order_relaxed); in try_lock()
104 state_type s = m_state.load(std::memory_order_relaxed); in lock_shared()
121 state_type s = m_state.load(std::memory_order_relaxed); in try_lock_shared()
148 state_type s = m_state.load(std::memory_order_relaxed); in upgrade()
156 … while ((m_state.load(std::memory_order_relaxed) & READERS) != ONE_READER) backoff.pause(); in upgrade()
|
| H A D | concurrent_priority_queue.h | 131 my_size.store(other.my_size.load(std::memory_order_relaxed), std::memory_order_relaxed);
141 my_size.store(other.my_size.load(std::memory_order_relaxed), std::memory_order_relaxed);
170 size_type size() const { return my_size.load(std::memory_order_relaxed); } in size()
219 size_type sz = my_size.load(std::memory_order_relaxed); in swap()
220 my_size.store(other.my_size.load(std::memory_order_relaxed), std::memory_order_relaxed); in swap()
272 op_list = op_list->next.load(std::memory_order_relaxed); in handle_operations()
279 … my_size.store(my_size.load(std::memory_order_relaxed) - 1, std::memory_order_relaxed); in handle_operations()
299 … my_size.store(my_size.load(std::memory_order_relaxed) + 1, std::memory_order_relaxed); in handle_operations()
313 pop_list = pop_list->next.load(std::memory_order_relaxed); in handle_operations()
324 … my_size.store(my_size.load(std::memory_order_relaxed) - 1, std::memory_order_relaxed); in handle_operations()
[all …]
|
| H A D | concurrent_vector.h | 488 return std::min(this->my_size.load(std::memory_order_acquire), capacity()); in size()
559 embedded_table[segment_index].load(std::memory_order_relaxed)); in allocate_long_table()
574 if (table[0].load(std::memory_order_acquire) != nullptr) { in create_segment()
700 auto curr_segment = table[j].load(std::memory_order_relaxed); in copy_segment()
723 auto curr_segment = table[j].load(std::memory_order_relaxed); in move_segment()
751 if (index >= this->my_size.load(std::memory_order_acquire)) { in internal_subscript_with_exceptions()
834 if (seg_index > this->my_first_block.load(std::memory_order_relaxed)) { in internal_grow()
837 if (table[seg_index].load(std::memory_order_relaxed) == nullptr) { in internal_grow()
865 size_type old_size = this->my_size.load(std::memory_order_relaxed); in internal_grow_to_at_least()
907 size_type old_size = this->my_size.load(std::memory_order_acquire); in internal_resize()
[all …]
|
| /oneTBB/include/oneapi/tbb/detail/ |
| H A D | _segment_table.h | 187 segment = table[seg_index].load(std::memory_order_acquire); in enable_segment()
238 size_type size = my_size.load(std::memory_order_relaxed); in reserve()
290 table = my_segment_table.load(std::memory_order_acquire); in extend_table_if_necessary()
302 table = my_segment_table.load(std::memory_order_acquire); in extend_table_if_necessary()
356 other.my_size.load(std::memory_order_relaxed) : end_segment_size; in internal_transfer()
488 auto first_block = other.my_first_block.load(std::memory_order_relaxed); in internal_swap_fields()
492 auto size = other.my_size.load(std::memory_order_relaxed); in internal_swap_fields()
513 segment = table[seg_index].load(std::memory_order_acquire); in internal_subscript()
523 segment = table[seg_index].load(std::memory_order_acquire); in internal_subscript()
532 if (this->my_first_block.load(std::memory_order_relaxed) == zero) { in assign_first_block_if_necessary()
[all …]
|
| H A D | _concurrent_queue_base.h | 131 padded_page* q = tail_page.load(std::memory_order_relaxed); in prepare_page()
139 p = tail_page.load(std::memory_order_relaxed); in prepare_page()
182 padded_page *p = head_page.load(std::memory_order_relaxed); in pop()
209 …size_type n_items = (tail_counter.load(std::memory_order_relaxed) - head_counter.load(std::memory… in assign()
269 padded_page* q = tail_page.load(std::memory_order_relaxed); in invalidate_page()
280 return head_page.load(std::memory_order_relaxed); in get_head_page()
342 ticket_type c = counter.load(std::memory_order_acquire); in spin_wait_until_my_turn()
463 …__TBB_ASSERT(head_counter.load(std::memory_order_relaxed) == src.head_counter.load(std::memory_ord… in assign()
464 … tail_counter.load(std::memory_order_relaxed) == src.tail_counter.load(std::memory_order_relaxed), in assign()
469 ticket_type tc = tail_counter.load(std::memory_order_acquire); in empty()
[all …]
|
| H A D | _concurrent_unordered_base.h | 147 return my_next.load(std::memory_order_acquire); in next()
282 : my_size(other.my_size.load(std::memory_order_relaxed)), in concurrent_unordered_base()
283 my_bucket_count(other.my_bucket_count.load(std::memory_order_relaxed)), in concurrent_unordered_base()
297 : my_size(other.my_size.load(std::memory_order_relaxed)), in concurrent_unordered_base()
298 my_bucket_count(other.my_bucket_count.load(std::memory_order_relaxed)), in concurrent_unordered_base()
312 : my_size(other.my_size.load(std::memory_order_relaxed)), in concurrent_unordered_base()
313 my_bucket_count(other.my_bucket_count.load(std::memory_order_relaxed)), in concurrent_unordered_base()
323 : my_size(other.my_size.load(std::memory_order_relaxed)), in concurrent_unordered_base()
324 my_bucket_count(other.my_bucket_count.load(std::memory_order_relaxed)), in concurrent_unordered_base()
1090 return my_segments[bucket_index].load(std::memory_order_acquire); in get_bucket()
[all …]
|
| /oneTBB/python/rml/ |
| H A D | ipc_server.cpp | 150 int old = my_global_thread_count.load(std::memory_order_relaxed); in release_thread_sem()
189 if( my_global_thread_count.load(std::memory_order_acquire)!=0 ) { in release_resources()
409 if( my_slack.load(std::memory_order_acquire)>0 ) { in propagate_chain_reaction()
522 state_t s = my_state.load(std::memory_order_relaxed); in start_shutdown()
541 state_t s = my_state.load(std::memory_order_relaxed); in start_stopping()
565 state_t state = my_state.load(std::memory_order_acquire); in run()
571 state = my_state.load(std::memory_order_seq_cst); in run()
579 state = my_state.load(std::memory_order_seq_cst); in run()
662 while( my_state.load(std::memory_order_seq_cst)!=st_quit ) { in run()
760 while( my_state.load(std::memory_order_acquire)!=st_quit ) { in run()
[all …]
|
| /oneTBB/test/tbbmalloc/ |
| H A D | test_malloc_whitebox.cpp | 282 …for (int i=0; i<=backRefMain.load(std::memory_order_relaxed)->lastUsed.load(std::memory_order_rela… in allocatedBackRefCount()
283 cnt += backRefMain.load(std::memory_order_relaxed)->backRefBl[i]->allocatedCount; in allocatedBackRefCount()
349 …int sustLastUsed = backRefMain.load(std::memory_order_relaxed)->lastUsed.load(std::memory_order_re… in TestBackRef()
351 …REQUIRE_MESSAGE(sustLastUsed == backRefMain.load(std::memory_order_relaxed)->lastUsed.load(std::me… in TestBackRef()
941 if ( cacheBinModel.cachedSize.load(std::memory_order_relaxed) > in doCleanup()
991 intptr_t mean = cacheBinModel.meanHitRange.load(std::memory_order_relaxed); in get()
1031 …CHECK_FAST(cacheBinModel.oldest.load(std::memory_order_relaxed) == cacheBin.oldest.load(std::memor… in check()
1033 …CHECK_FAST(cacheBinModel.ageThreshold.load(std::memory_order_relaxed) == cacheBin.ageThreshold.loa… in check()
1034 …CHECK_FAST(cacheBinModel.usedSize.load(std::memory_order_relaxed) == cacheBin.usedSize.load(std::m… in check()
1035 …CHECK_FAST(cacheBinModel.cachedSize.load(std::memory_order_relaxed) == cacheBin.cachedSize.load(st… in check()
[all …]
|