From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.1 (2015-04-28) on dcvr.yhbt.net X-Spam-Level: X-Spam-ASN: X-Spam-Status: No, score=-3.9 required=3.0 tests=ALL_TRUSTED,AWL,BAYES_00 shortcircuit=no autolearn=ham autolearn_force=no version=3.4.1 Received: from localhost (dcvr.yhbt.net [127.0.0.1]) by dcvr.yhbt.net (Postfix) with ESMTP id E32FC208FC for ; Mon, 16 Jul 2018 21:19:38 +0000 (UTC) From: Eric Wong To: mwrap-public@80x24.org Subject: [PATCH 17/19] disable memalign tracking by default Date: Mon, 16 Jul 2018 21:19:31 +0000 Message-Id: <20180716211933.5835-18-e@80x24.org> In-Reply-To: <20180716211933.5835-1-e@80x24.org> References: <20180716211933.5835-1-e@80x24.org> List-Id: Users will still pay the cost in memory overhead, but this gets rid of misleading statistics. Tracking actual Ruby object allocations is better left to Ruby itself. --- ext/mwrap/mwrap.c | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/ext/mwrap/mwrap.c b/ext/mwrap/mwrap.c index 627bb63..2752598 100644 --- a/ext/mwrap/mwrap.c +++ b/ext/mwrap/mwrap.c @@ -23,6 +23,7 @@ #include "jhash.h" static ID id_uminus; +static unsigned int track_memalign; const char *rb_source_location_cstr(int *line); /* requires 2.6.0dev */ extern int __attribute__((weak)) ruby_thread_has_gvl_p(void); extern void * __attribute__((weak)) ruby_current_execution_context_ptr; @@ -92,6 +93,7 @@ lfht_new(void) __attribute__((constructor)) static void resolve_malloc(void) { int err; + const char *opt; ++locating; #ifdef __FreeBSD__ @@ -135,6 +137,11 @@ __attribute__((constructor)) static void resolve_malloc(void) if (err) fprintf(stderr, "pthread_atfork failed: %s\n", strerror(err)); page_size = sysconf(_SC_PAGESIZE); + opt = getenv("MWRAP"); + if (opt && (opt = strstr(opt, "memalign:"))) { + if (!sscanf(opt, "memalign:%u", &track_memalign)) + fprintf(stderr, "not an unsigned int: %s\n", opt); + } --locating; } @@ -461,7 +468,7 @@ internal_memalign(void **pp, size_t alignment, size_t size, uintptr_t caller) return ENOMEM; /* assert(asize == (alignment + size + sizeof(struct alloc_hdr))); */ - l = update_stats_rcu_lock(size, caller); + l = track_memalign ? update_stats_rcu_lock(size, caller) : 0; real = real_malloc(asize); if (real) { void *p = hdr2ptr(real); @@ -1008,9 +1015,16 @@ static VALUE src_loc_name(VALUE self) * * dump_fd: a writable FD to dump to * * dump_path: a path to dump to, the file is opened in O_APPEND mode * * dump_min: the minimum allocation size (total) to dump + * * memalign: use `1' to enable tracking the memalign family * * If both `dump_fd' and `dump_path' are specified, dump_path takes * precedence. + * + * Tracking the memalign family of functions is misleading for Ruby + * applications, as heap page allocations can happen anywhere a + * Ruby object is allocated, even in the coldest code paths. + * Furthermore, it is rarely-used outside of the Ruby object allocator. + * Thus tracking memalign functions is disabled by default. */ void Init_mwrap(void) { -- EW