mm_lock_getstat(struct mm_lock_stat_info *info) { // Get statistics collection pertinent to the lock in question. struct mm_lock_stat_set *stat_set = mm_memory_load(info->stat); if (stat_set == NULL) stat_set = mm_lock_get_stat_set(info); // Get a statistic entry specific to the calling thread. struct mm_thread *thread = mm_thread_selfptr(); struct mm_domain *domain = mm_thread_getdomain(thread); if (domain != NULL) return mm_lock_get_domain_stat(stat_set, thread, domain); else return mm_lock_get_thread_stat(stat_set, thread); }
mm_chunk_destroy(struct mm_chunk *chunk) { mm_chunk_t tag = mm_chunk_gettag(chunk); // A chunk from a shared memory space can be freed by any thread in // the same manner utilizing synchronization mechanisms built-in to // the corresponding memory allocation routines. if (tag == MM_CHUNK_COMMON) { mm_common_free(chunk); return; } if (unlikely(tag == MM_CHUNK_GLOBAL)) { mm_global_free(chunk); return; } if (tag == MM_CHUNK_REGULAR) { #if ENABLE_SMP // In SMP mode regular memory space is just another case of // shared space with built-in synchronization. So it can be // freed by any thread alike. mm_regular_free(chunk); return; #else struct mm_domain *domain = mm_domain_selfptr(); if (domain == mm_regular_domain) { mm_regular_free(chunk); return; } #endif } // A chunk from a private space can be immediately freed by its // originating thread but it is a subject for asynchronous memory // reclamation mechanism for any other thread. struct mm_thread *thread = mm_thread_selfptr(); struct mm_domain *domain = mm_thread_getdomain(thread); if (domain == mm_regular_domain && tag == mm_thread_getnumber(thread)) { mm_private_free(chunk); return; } thread->deferred_chunks_count++; mm_chunk_stack_insert(&thread->deferred_chunks, chunk); mm_chunk_enqueue_deferred(thread, false); }