Commit 02a06f79 authored by Mike Hommey's avatar Mike Hommey
Browse files

Bug 1363992 - Remove support for making jemalloc4 the default. r=njn 

--HG--
extra : rebase_source : 77e1c13aa329637d0ec875439d572ee06e6919fa
parent 1a9d4c6f

build/autoconf/jemalloc.m4

+3 −36
Original line number Diff line number Diff line
@@ -8,7 +8,7 @@ if test "$MOZ_BUILD_APP" != js -o -n "$JS_STANDALONE"; then 


  # Run jemalloc configure script



  if test "$MOZ_MEMORY" && test -n "$MOZ_JEMALLOC4" -o -n "$MOZ_REPLACE_MALLOC"; then

  if test "$MOZ_MEMORY" && test -n "$MOZ_REPLACE_MALLOC"; then

    ac_configure_args="--build=$build --host=$target --enable-stats --with-jemalloc-prefix=je_ --disable-valgrind"

    if test -n "$MOZ_DEBUG"; then

      ac_configure_args="$ac_configure_args --enable-debug"
@@ -25,41 +25,8 @@ if test "$MOZ_BUILD_APP" != js -o -n "$JS_STANDALONE"; then 
        ac_configure_args="$ac_configure_args --enable-ivsalloc"

      fi

    fi

    if test -n "$MOZ_JEMALLOC4"; then

      case "${OS_ARCH}" in

        WINNT|Darwin)

          # We want jemalloc functions to be kept hidden on both Mac and Windows

          # See memory/build/mozmemory_wrap.h for details.

          ac_configure_args="$ac_configure_args --without-export"

          ;;

      esac

      if test "${OS_ARCH}" = WINNT; then

        # Lazy lock initialization doesn't play well with lazy linking of

        # mozglue.dll on Windows XP (leads to startup crash), so disable it.

        ac_configure_args="$ac_configure_args --disable-lazy-lock"



        # 64-bit Windows builds require a minimum 16-byte alignment.

        if test -n "$HAVE_64BIT_BUILD"; then

          ac_configure_args="$ac_configure_args --with-lg-tiny-min=4"

        fi

      fi

    elif test "${OS_ARCH}" = Darwin; then

      # When building as a replace-malloc lib, disabling the zone allocator

      # forces to use pthread_atfork.

      ac_configure_args="$ac_configure_args --disable-zone-allocator"

    fi

    _MANGLE="malloc posix_memalign aligned_alloc calloc realloc free memalign valloc malloc_usable_size"

    JEMALLOC_WRAPPER=

    if test -z "$MOZ_REPLACE_MALLOC"; then

      case "$OS_ARCH" in

        Linux|DragonFly|FreeBSD|NetBSD|OpenBSD)

          MANGLE=$_MANGLE

          ;;

      esac

    elif test -z "$MOZ_JEMALLOC4"; then

      MANGLE=$_MANGLE

    MANGLE="malloc posix_memalign aligned_alloc calloc realloc free memalign valloc malloc_usable_size"

    JEMALLOC_WRAPPER=replace_

    fi

    if test -n "$MANGLE"; then

      MANGLED=

      for mangle in ${MANGLE}; do

build/moz.configure/memory.configure

+13 −23
Original line number Diff line number Diff line
@@ -5,11 +5,12 @@ 
# file, You can obtain one at http://mozilla.org/MPL/2.0/.





option(env='MOZ_JEMALLOC4', help='Enable jemalloc 4')

imply_option('--enable-jemalloc', depends_if('MOZ_JEMALLOC4')(lambda x: '4'))

@deprecated_option(env='MOZ_JEMALLOC4')

def moz_jemalloc4(value):

    die('MOZ_JEMALLOC4 is deprecated')





option('--enable-jemalloc', nargs='?', choices=('4', 'moz'), env='MOZ_MEMORY',

option('--enable-jemalloc', env='MOZ_MEMORY',

       help='Replace memory allocator with jemalloc')



@depends('--enable-jemalloc', target, build_project, c_compiler)
@@ -30,36 +31,25 @@ def jemalloc(value, target, build_project, c_compiler): 
    if target.kernel == 'Linux':

        return True



@depends('--enable-jemalloc')

def jemalloc4(jemalloc):

    if len(jemalloc) and jemalloc[0] == '4':

        return True





set_config('MOZ_MEMORY', jemalloc)

set_define('MOZ_MEMORY', jemalloc)

add_old_configure_assignment('MOZ_MEMORY', jemalloc)



set_config('MOZ_JEMALLOC4', jemalloc4)

set_define('MOZ_JEMALLOC4', jemalloc4)

add_old_configure_assignment('MOZ_JEMALLOC4', jemalloc4)





# Because --enable-jemalloc doesn't use a default because of the dependency

# on the target, we can't use a js_option for it to propagate to js/src

# through the old-configure.

@depends(jemalloc, jemalloc4)

def jemalloc_for_old_configure(jemalloc, jemalloc4):

    if jemalloc:

        return '--enable-jemalloc=4' if jemalloc4 else '--enable-jemalloc'

    return '--disable-jemalloc'

@depends(jemalloc)

def jemalloc_for_old_configure(jemalloc):

    return '--%s-jemalloc' % ('enable' if jemalloc else 'disable')



add_old_configure_arg(jemalloc_for_old_configure)





@depends(jemalloc, jemalloc4, target)

def jemalloc_os_define(jemalloc, jemalloc4, target):

    if jemalloc and not jemalloc4:

@depends(jemalloc, target)

def jemalloc_os_define(jemalloc, target):

    if jemalloc:

        if target.kernel == 'WINNT':

            return 'MOZ_MEMORY_WINDOWS'

        if target.kernel == 'Linux':
@@ -72,9 +62,9 @@ def jemalloc_os_define(jemalloc, jemalloc4, target): 


set_define(jemalloc_os_define, '1')



@depends(jemalloc, jemalloc4, target)

def jemalloc_os_define_android(jemalloc, jemalloc4, target):

    if jemalloc and not jemalloc4 and target.os == 'Android':

@depends(jemalloc, target)

def jemalloc_os_define_android(jemalloc, target):

    if jemalloc and target.os == 'Android':

        return 'MOZ_MEMORY_ANDROID'



set_define(jemalloc_os_define_android, '1')

js/xpconnect/src/XPCJSContext.cpp

+0 −4
Original line number Diff line number Diff line
@@ -65,10 +65,6 @@ 
#include "nsExceptionHandler.h"

#endif



#if defined(MOZ_JEMALLOC4)

#include "mozmemory.h"

#endif



#ifdef XP_WIN

#include <windows.h>

#endif

js/xpconnect/src/XPCJSRuntime.cpp

+0 −16
Original line number Diff line number Diff line
@@ -64,10 +64,6 @@ 
#include "nsExceptionHandler.h"

#endif



#if defined(MOZ_JEMALLOC4)

#include "mozmemory.h"

#endif



#ifdef XP_WIN

#include <windows.h>

#endif
@@ -152,18 +148,6 @@ public: 
              mActive = false;

          }

      } else {

#if defined(MOZ_JEMALLOC4)

          if (mPurge) {

              /* Jemalloc purges dirty pages regularly during free() when the

               * ratio of dirty pages compared to active pages is higher than

               * 1 << lg_dirty_mult. A high ratio can have an impact on

               * performance, so we use the default ratio of 8, but force a

               * regular purge of all remaining dirty pages, after cycle

               * collection. */

              Telemetry::AutoTimer<Telemetry::MEMORY_FREE_PURGED_PAGES_MS> timer;

              jemalloc_free_dirty_pages();

          }

#endif

          mActive = false;

      }

      return NS_OK;

memory/build/jemalloc_config.cpp

+0 −150
Original line number Diff line number Diff line
@@ -2,157 +2,7 @@ 
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,

 * You can obtain one at http://mozilla.org/MPL/2.0/. */



#ifdef MOZ_JEMALLOC4



#define MOZ_JEMALLOC_IMPL



/* mozmemory_wrap.h needs to be included before MFBT headers */

#include "mozmemory_wrap.h"

#include <mozilla/Assertions.h>

#include "mozilla/Types.h"



#define DLLEXPORT

#include "jemalloc/jemalloc.h"



#ifdef XP_WIN

#include <windows.h>

#endif

#ifdef XP_DARWIN

#include <sys/mman.h>

#endif



/* Override some jemalloc defaults */

#ifdef DEBUG

#define MOZ_MALLOC_BUILD_OPTIONS ",junk:true"

#else

#define MOZ_MALLOC_BUILD_OPTIONS ",junk:free"

#endif



#define MOZ_MALLOC_OPTIONS "narenas:1,tcache:false"

MFBT_DATA const char* je_(malloc_conf) =

  MOZ_MALLOC_OPTIONS MOZ_MALLOC_BUILD_OPTIONS;



#ifdef ANDROID

#include <android/log.h>



static void

_je_malloc_message(void* cbopaque, const char* s)

{

  __android_log_print(ANDROID_LOG_INFO, "GeckoJemalloc", "%s", s);

}



void (*je_(malloc_message))(void*, const char* s) = _je_malloc_message;

#endif



/* Jemalloc supports hooks that are called on chunk

 * allocate/deallocate/commit/decommit/purge/etc.

 *

 * We currently only hook commit, decommit and purge. We do this to tweak

 * the way chunks are handled so that RSS stays lower than it normally

 * would with the default jemalloc uses.

 * This somewhat matches the behavior of mozjemalloc, except it doesn't

 * rely on a double purge on mac, instead purging directly. (Yes, this

 * means we can get rid of jemalloc_purge_freed_pages at some point)

 *

 * The default for jemalloc is to do the following:

 * - commit, decommit: nothing

 * - purge: MEM_RESET on Windows, MADV_FREE on Mac/BSD, MADV_DONTNEED on Linux

 *

 * The hooks we setup do the following:

 * on Windows:

 * - commit: MEM_COMMIT

 * - decommit: MEM_DECOMMIT

 * on Mac:

 * - purge: mmap new anonymous memory on top of the chunk

 *

 * We only set the above hooks, others are left with the default.

 */

#if defined(XP_WIN) || defined(XP_DARWIN)

class JemallocInit {

public:

  JemallocInit()

  {

    chunk_hooks_t hooks;

    size_t hooks_len;

    unsigned narenas;

    size_t mib[3];

    size_t size;



    size = sizeof(narenas);

    je_(mallctl)("arenas.narenas", &narenas, &size, nullptr, 0);



    size = sizeof(mib) / sizeof(mib[0]);

    je_(mallctlnametomib)("arena.0.chunk_hooks", mib, &size);



    /* Set the hooks on all the existing arenas. */

    for (unsigned arena = 0; arena < narenas; arena++) {

      mib[1] = arena;

      hooks_len = sizeof(hooks);

      je_(mallctlbymib)(mib, size, &hooks, &hooks_len, nullptr, 0);



#ifdef XP_WIN

      hooks.commit = CommitHook;

      hooks.decommit = DecommitHook;

#endif

#ifdef XP_DARWIN

      hooks.purge = PurgeHook;

#endif



      je_(mallctlbymib)(mib, size, nullptr, nullptr, &hooks, hooks_len);

    }

  }



private:

#ifdef XP_WIN

  static bool

  CommitHook(void* chunk, size_t size, size_t offset, size_t length,

             unsigned arena_ind)

  {

    void* addr = reinterpret_cast<void*>(

      reinterpret_cast<uintptr_t>(chunk) + static_cast<uintptr_t>(offset));



    if (!VirtualAlloc(addr, length, MEM_COMMIT, PAGE_READWRITE))

      return true;



    return false;

  }



  static bool

  DecommitHook(void* chunk, size_t size, size_t offset, size_t length,

               unsigned arena_ind)

  {

    void* addr = reinterpret_cast<void*>(

      reinterpret_cast<uintptr_t>(chunk) + static_cast<uintptr_t>(offset));



    if (!VirtualFree(addr, length, MEM_DECOMMIT))

      MOZ_CRASH();



    return false;

  }

#endif



#ifdef XP_DARWIN

  static bool

  PurgeHook(void* chunk, size_t size, size_t offset, size_t length,

            unsigned arena_ind)

  {

    void* addr = reinterpret_cast<void*>(

      reinterpret_cast<uintptr_t>(chunk) + static_cast<uintptr_t>(offset));



    void* new_addr = mmap(addr, length, PROT_READ | PROT_WRITE,

                          MAP_FIXED | MAP_PRIVATE | MAP_ANON, -1, 0);

    return (new_addr != addr);

  }

#endif

};



/* For the static constructor from the class above */

JemallocInit gJemallocInit;

#endif



#else

#include <mozilla/Assertions.h>

#endif /* MOZ_JEMALLOC4 */



/* Provide an abort function for use in jemalloc code */

extern "C" void moz_abort() {