use int64 for time (instead of double)

This commit is contained in:
daan 2019-11-04 08:44:40 -08:00
parent 9d6a5acb22
commit 8afd06b248
5 changed files with 70 additions and 59 deletions

View file

@ -106,8 +106,11 @@ uintptr_t _mi_heap_random(mi_heap_t* heap);
// "stats.c" // "stats.c"
void _mi_stats_done(mi_stats_t* stats); void _mi_stats_done(mi_stats_t* stats);
double _mi_clock_end(double start);
double _mi_clock_start(void); typedef int64_t mi_msecs_t;
mi_msecs_t _mi_clock_now(void);
mi_msecs_t _mi_clock_end(mi_msecs_t start);
mi_msecs_t _mi_clock_start(void);
// "alloc.c" // "alloc.c"
void* _mi_page_malloc(mi_heap_t* heap, mi_page_t* page, size_t size) mi_attr_noexcept; // called from `_mi_malloc_generic` void* _mi_page_malloc(mi_heap_t* heap, mi_page_t* page, size_t size) mi_attr_noexcept; // called from `_mi_malloc_generic`

View file

@ -28,7 +28,7 @@ void* _mi_os_alloc_aligned(size_t size, size_t alignment, bool commit, bool* lar
//int _mi_os_alloc_huge_os_pages(size_t pages, double max_secs, void** pstart, size_t* pages_reserved, size_t* psize) mi_attr_noexcept; //int _mi_os_alloc_huge_os_pages(size_t pages, double max_secs, void** pstart, size_t* pages_reserved, size_t* psize) mi_attr_noexcept;
void _mi_os_free(void* p, size_t size, mi_stats_t* stats); void _mi_os_free(void* p, size_t size, mi_stats_t* stats);
void* _mi_os_alloc_huge_os_pages(size_t pages, int numa_node, double max_secs, size_t* pages_reserved, size_t* psize); void* _mi_os_alloc_huge_os_pages(size_t pages, int numa_node, mi_msecs_t max_secs, size_t* pages_reserved, size_t* psize);
void _mi_os_free_huge_pages(void* p, size_t size, mi_stats_t* stats); void _mi_os_free_huge_pages(void* p, size_t size, mi_stats_t* stats);
int _mi_os_numa_node_count(void); int _mi_os_numa_node_count(void);
@ -390,7 +390,7 @@ int mi_reserve_huge_os_pages_at(size_t pages, int numa_node) mi_attr_noexcept {
if (numa_node >= 0) numa_node = numa_node % _mi_os_numa_node_count(); if (numa_node >= 0) numa_node = numa_node % _mi_os_numa_node_count();
size_t hsize = 0; size_t hsize = 0;
size_t pages_reserved = 0; size_t pages_reserved = 0;
void* p = _mi_os_alloc_huge_os_pages(pages, numa_node, (double)pages / 2.0, &pages_reserved, &hsize); void* p = _mi_os_alloc_huge_os_pages(pages, numa_node, pages*500, &pages_reserved, &hsize);
if (p==NULL || pages_reserved==0) { if (p==NULL || pages_reserved==0) {
_mi_warning_message("failed to reserve %zu gb huge pages\n", pages); _mi_warning_message("failed to reserve %zu gb huge pages\n", pages);
return ENOMEM; return ENOMEM;

View file

@ -564,6 +564,7 @@ void _mi_mem_collect(mi_stats_t* stats) {
} }
} }
/* ---------------------------------------------------------------------------- /* ----------------------------------------------------------------------------
Other Other
-----------------------------------------------------------------------------*/ -----------------------------------------------------------------------------*/

View file

@ -871,6 +871,7 @@ static void* mi_os_alloc_huge_os_pagesx(void* addr, size_t size, int numa_node)
} }
#endif #endif
#if (MI_INTPTR_SIZE >= 8)
// To ensure proper alignment, use our own area for huge OS pages // To ensure proper alignment, use our own area for huge OS pages
static _Atomic(uintptr_t) mi_huge_start; // = 0 static _Atomic(uintptr_t) mi_huge_start; // = 0
@ -899,18 +900,25 @@ static uint8_t* mi_os_claim_huge_pages(size_t pages, size_t* total_size) {
if (total_size != NULL) *total_size = size; if (total_size != NULL) *total_size = size;
return (uint8_t*)start; return (uint8_t*)start;
} }
#else
static uint8_t* mi_os_claim_huge_pages(size_t pages, size_t* total_size) {
if (total_size != NULL) *total_size = 0;
return NULL;
}
#endif
// Allocate MI_SEGMENT_SIZE aligned huge pages // Allocate MI_SEGMENT_SIZE aligned huge pages
void* _mi_os_alloc_huge_os_pages(size_t pages, int numa_node, double max_secs, size_t* pages_reserved, size_t* psize) { void* _mi_os_alloc_huge_os_pages(size_t pages, int numa_node, mi_msecs_t max_msecs, size_t* pages_reserved, size_t* psize) {
if (psize != NULL) *psize = 0; if (psize != NULL) *psize = 0;
if (pages_reserved != NULL) *pages_reserved = 0; if (pages_reserved != NULL) *pages_reserved = 0;
size_t size = 0; size_t size = 0;
uint8_t* start = mi_os_claim_huge_pages(pages, &size); uint8_t* start = mi_os_claim_huge_pages(pages, &size);
if (start == NULL) return NULL; // or 32-bit systems
// Allocate one page at the time but try to place them contiguously // Allocate one page at the time but try to place them contiguously
// We allocate one page at the time to be able to abort if it takes too long // We allocate one page at the time to be able to abort if it takes too long
// or to at least allocate as many as available on the system. // or to at least allocate as many as available on the system.
double start_t = _mi_clock_start(); mi_msecs_t start_t = _mi_clock_start();
size_t page; size_t page;
for (page = 0; page < pages; page++) { for (page = 0; page < pages; page++) {
// allocate a page // allocate a page
@ -932,14 +940,14 @@ void* _mi_os_alloc_huge_os_pages(size_t pages, int numa_node, double max_secs, s
_mi_stat_increase(&_mi_stats_main.reserved, MI_HUGE_OS_PAGE_SIZE); _mi_stat_increase(&_mi_stats_main.reserved, MI_HUGE_OS_PAGE_SIZE);
// check for timeout // check for timeout
double elapsed = _mi_clock_end(start_t); mi_msecs_t elapsed = _mi_clock_end(start_t);
if (page >= 1) { if (page >= 1) {
double estimate = ((elapsed / (double)(page+1)) * (double)pages); mi_msecs_t estimate = ((elapsed / (page+1)) * pages);
if (estimate > 1.5*max_secs) { // seems like we are going to timeout, break if (estimate > 2*max_msecs) { // seems like we are going to timeout, break
elapsed = max_secs + 1.0; elapsed = max_msecs + 1;
} }
} }
if (elapsed > max_secs) { if (elapsed > max_msecs) {
_mi_warning_message("huge page allocation timed out\n"); _mi_warning_message("huge page allocation timed out\n");
break; break;
} }

View file

@ -231,9 +231,9 @@ static void mi_stats_print_bins(mi_stat_count_t* all, const mi_stat_count_t* bin
#endif #endif
static void mi_process_info(double* utime, double* stime, size_t* peak_rss, size_t* page_faults, size_t* page_reclaim, size_t* peak_commit); static void mi_process_info(mi_msecs_t* utime, mi_msecs_t* stime, size_t* peak_rss, size_t* page_faults, size_t* page_reclaim, size_t* peak_commit);
static void _mi_stats_print(mi_stats_t* stats, double secs, mi_output_fun* out) mi_attr_noexcept { static void _mi_stats_print(mi_stats_t* stats, mi_msecs_t elapsed, mi_output_fun* out) mi_attr_noexcept {
mi_print_header(out); mi_print_header(out);
#if MI_STAT>1 #if MI_STAT>1
mi_stat_count_t normal = { 0,0,0,0 }; mi_stat_count_t normal = { 0,0,0,0 };
@ -266,16 +266,16 @@ static void _mi_stats_print(mi_stats_t* stats, double secs, mi_output_fun* out)
mi_stat_print(&stats->threads, "threads", -1, out); mi_stat_print(&stats->threads, "threads", -1, out);
mi_stat_counter_print_avg(&stats->searches, "searches", out); mi_stat_counter_print_avg(&stats->searches, "searches", out);
_mi_fprintf(out, "%10s: %7i\n", "numa nodes", _mi_os_numa_node_count()); _mi_fprintf(out, "%10s: %7i\n", "numa nodes", _mi_os_numa_node_count());
if (secs >= 0.0) _mi_fprintf(out, "%10s: %9.3f s\n", "elapsed", secs); if (elapsed > 0) _mi_fprintf(out, "%10s: %7ld.%03ld s\n", "elapsed", elapsed/1000, elapsed%1000);
double user_time; mi_msecs_t user_time;
double sys_time; mi_msecs_t sys_time;
size_t peak_rss; size_t peak_rss;
size_t page_faults; size_t page_faults;
size_t page_reclaim; size_t page_reclaim;
size_t peak_commit; size_t peak_commit;
mi_process_info(&user_time, &sys_time, &peak_rss, &page_faults, &page_reclaim, &peak_commit); mi_process_info(&user_time, &sys_time, &peak_rss, &page_faults, &page_reclaim, &peak_commit);
_mi_fprintf(out,"%10s: user: %.3f s, system: %.3f s, faults: %lu, reclaims: %lu, rss: ", "process", user_time, sys_time, (unsigned long)page_faults, (unsigned long)page_reclaim ); _mi_fprintf(out,"%10s: user: %ld.%03ld s, system: %ld.%03ld s, faults: %lu, reclaims: %lu, rss: ", "process", user_time/1000, user_time%1000, sys_time/1000, sys_time%1000, (unsigned long)page_faults, (unsigned long)page_reclaim );
mi_printf_amount((int64_t)peak_rss, 1, out, "%s"); mi_printf_amount((int64_t)peak_rss, 1, out, "%s");
if (peak_commit > 0) { if (peak_commit > 0) {
_mi_fprintf(out,", commit charge: "); _mi_fprintf(out,", commit charge: ");
@ -284,9 +284,7 @@ static void _mi_stats_print(mi_stats_t* stats, double secs, mi_output_fun* out)
_mi_fprintf(out,"\n"); _mi_fprintf(out,"\n");
} }
double _mi_clock_end(double start); static mi_msecs_t mi_time_start; // = 0
double _mi_clock_start(void);
static double mi_time_start = 0.0;
static mi_stats_t* mi_stats_get_default(void) { static mi_stats_t* mi_stats_get_default(void) {
mi_heap_t* heap = mi_heap_get_default(); mi_heap_t* heap = mi_heap_get_default();
@ -316,71 +314,72 @@ void _mi_stats_done(mi_stats_t* stats) { // called from `mi_thread_done`
} }
static void mi_stats_print_ex(mi_stats_t* stats, double secs, mi_output_fun* out) { static void mi_stats_print_ex(mi_stats_t* stats, mi_msecs_t elapsed, mi_output_fun* out) {
mi_stats_merge_from(stats); mi_stats_merge_from(stats);
_mi_stats_print(&_mi_stats_main, secs, out); _mi_stats_print(&_mi_stats_main, elapsed, out);
} }
void mi_stats_print(mi_output_fun* out) mi_attr_noexcept { void mi_stats_print(mi_output_fun* out) mi_attr_noexcept {
mi_stats_print_ex(mi_stats_get_default(),_mi_clock_end(mi_time_start),out); mi_msecs_t elapsed = _mi_clock_end(mi_time_start);
mi_stats_print_ex(mi_stats_get_default(),elapsed,out);
} }
void mi_thread_stats_print(mi_output_fun* out) mi_attr_noexcept { void mi_thread_stats_print(mi_output_fun* out) mi_attr_noexcept {
_mi_stats_print(mi_stats_get_default(), _mi_clock_end(mi_time_start), out); mi_msecs_t elapsed = _mi_clock_end(mi_time_start);
_mi_stats_print(mi_stats_get_default(), elapsed, out);
} }
// ----------------------------------------------------------------
// -------------------------------------------------------- // Basic timer for convenience; use milli-seconds to avoid doubles
// Basic timer for convenience // ----------------------------------------------------------------
// --------------------------------------------------------
#ifdef _WIN32 #ifdef _WIN32
#include <windows.h> #include <windows.h>
static double mi_to_seconds(LARGE_INTEGER t) { static mi_msecs_t mi_to_msecs(LARGE_INTEGER t) {
static double freq = 0.0; static LARGE_INTEGER mfreq; // = 0
if (freq <= 0.0) { if (mfreq.QuadPart == 0LL) {
LARGE_INTEGER f; LARGE_INTEGER f;
QueryPerformanceFrequency(&f); QueryPerformanceFrequency(&f);
freq = (double)(f.QuadPart); mfreq.QuadPart = f.QuadPart/1000LL;
if (mfreq.QuadPart == 0) mfreq.QuadPart = 1;
} }
return ((double)(t.QuadPart) / freq); return (mi_msecs_t)(t.QuadPart / mfreq.QuadPart);
} }
static double mi_clock_now(void) { mi_msecs_t _mi_clock_now(void) {
LARGE_INTEGER t; LARGE_INTEGER t;
QueryPerformanceCounter(&t); QueryPerformanceCounter(&t);
return mi_to_seconds(t); return mi_to_msecs(t);
} }
#else #else
#include <time.h> #include <time.h>
#ifdef CLOCK_REALTIME #ifdef CLOCK_REALTIME
static double mi_clock_now(void) { mi_msecs_t _mi_clock_now(void) {
struct timespec t; struct timespec t;
clock_gettime(CLOCK_REALTIME, &t); clock_gettime(CLOCK_REALTIME, &t);
return (double)t.tv_sec + (1.0e-9 * (double)t.tv_nsec); return ((mi_msecs_t)t.tv_sec * 1000) + ((mi_msecs_t)t.tv_nsec / 1000000);
} }
#else #else
// low resolution timer // low resolution timer
static double mi_clock_now(void) { mi_msecs_t _mi_clock_now(void) {
return ((double)clock() / (double)CLOCKS_PER_SEC); return ((mi_msecs_t)clock() / ((mi_msecs_t)CLOCKS_PER_SEC / 1000));
} }
#endif #endif
#endif #endif
static double mi_clock_diff = 0.0; static mi_msecs_t mi_clock_diff;
double _mi_clock_start(void) { mi_msecs_t _mi_clock_start(void) {
if (mi_clock_diff == 0.0) { if (mi_clock_diff == 0.0) {
double t0 = mi_clock_now(); mi_msecs_t t0 = _mi_clock_now();
mi_clock_diff = mi_clock_now() - t0; mi_clock_diff = _mi_clock_now() - t0;
} }
return mi_clock_now(); return _mi_clock_now();
} }
double _mi_clock_end(double start) { mi_msecs_t _mi_clock_end(mi_msecs_t start) {
double end = mi_clock_now(); mi_msecs_t end = _mi_clock_now();
return (end - start - mi_clock_diff); return (end - start - mi_clock_diff);
} }
@ -394,21 +393,21 @@ double _mi_clock_end(double start) {
#include <psapi.h> #include <psapi.h>
#pragma comment(lib,"psapi.lib") #pragma comment(lib,"psapi.lib")
static double filetime_secs(const FILETIME* ftime) { static mi_msecs_t filetime_msecs(const FILETIME* ftime) {
ULARGE_INTEGER i; ULARGE_INTEGER i;
i.LowPart = ftime->dwLowDateTime; i.LowPart = ftime->dwLowDateTime;
i.HighPart = ftime->dwHighDateTime; i.HighPart = ftime->dwHighDateTime;
double secs = (double)(i.QuadPart) * 1.0e-7; // FILETIME is in 100 nano seconds mi_msecs_t msecs = (i.QuadPart / 10000); // FILETIME is in 100 nano seconds
return secs; return msecs;
} }
static void mi_process_info(double* utime, double* stime, size_t* peak_rss, size_t* page_faults, size_t* page_reclaim, size_t* peak_commit) { static void mi_process_info(mi_msecs_t* utime, mi_msecs_t* stime, size_t* peak_rss, size_t* page_faults, size_t* page_reclaim, size_t* peak_commit) {
FILETIME ct; FILETIME ct;
FILETIME ut; FILETIME ut;
FILETIME st; FILETIME st;
FILETIME et; FILETIME et;
GetProcessTimes(GetCurrentProcess(), &ct, &et, &st, &ut); GetProcessTimes(GetCurrentProcess(), &ct, &et, &st, &ut);
*utime = filetime_secs(&ut); *utime = filetime_msecs(&ut);
*stime = filetime_secs(&st); *stime = filetime_msecs(&st);
PROCESS_MEMORY_COUNTERS info; PROCESS_MEMORY_COUNTERS info;
GetProcessMemoryInfo(GetCurrentProcess(), &info, sizeof(info)); GetProcessMemoryInfo(GetCurrentProcess(), &info, sizeof(info));
@ -427,11 +426,11 @@ static void mi_process_info(double* utime, double* stime, size_t* peak_rss, size
#include <mach/mach.h> #include <mach/mach.h>
#endif #endif
static double timeval_secs(const struct timeval* tv) { static mi_msecs_t timeval_secs(const struct timeval* tv) {
return (double)tv->tv_sec + ((double)tv->tv_usec * 1.0e-6); return ((mi_msecs_t)tv->tv_sec * 1000L) + ((mi_msecs_t)tv->tv_usec / 1000L);
} }
static void mi_process_info(double* utime, double* stime, size_t* peak_rss, size_t* page_faults, size_t* page_reclaim, size_t* peak_commit) { static void mi_process_info(mi_msecs_t* utime, mi_msecs_t* stime, size_t* peak_rss, size_t* page_faults, size_t* page_reclaim, size_t* peak_commit) {
struct rusage rusage; struct rusage rusage;
getrusage(RUSAGE_SELF, &rusage); getrusage(RUSAGE_SELF, &rusage);
#if defined(__APPLE__) && defined(__MACH__) #if defined(__APPLE__) && defined(__MACH__)
@ -452,12 +451,12 @@ static void mi_process_info(double* utime, double* stime, size_t* peak_rss, size
#pragma message("define a way to get process info") #pragma message("define a way to get process info")
#endif #endif
static void mi_process_info(double* utime, double* stime, size_t* peak_rss, size_t* page_faults, size_t* page_reclaim, size_t* peak_commit) { static void mi_process_info(mi_msecs_t* utime, mi_msecs_t* stime, size_t* peak_rss, size_t* page_faults, size_t* page_reclaim, size_t* peak_commit) {
*peak_rss = 0; *peak_rss = 0;
*page_faults = 0; *page_faults = 0;
*page_reclaim = 0; *page_reclaim = 0;
*peak_commit = 0; *peak_commit = 0;
*utime = 0.0; *utime = 0;
*stime = 0.0; *stime = 0;
} }
#endif #endif