808 lines
36 KiB
Makefile
808 lines
36 KiB
Makefile
## Process this file with automake to produce Makefile.in
|
|
|
|
# Note: for every library we create, we're explicit about what symbols
|
|
# we export. In order to avoid complications with C++ mangling, we always
|
|
# use the regexp for of specifying symbols.
|
|
|
|
# Make sure that when we re-make ./configure, we get the macros we need
|
|
ACLOCAL_AMFLAGS = -I m4
|
|
|
|
# This is so we can #include <google/foo>
|
|
AM_CPPFLAGS = -I$(top_srcdir)/src
|
|
|
|
# This is mostly based on configure options
|
|
AM_CXXFLAGS =
|
|
|
|
# These are good warnings to turn on by default,
|
|
if GCC
|
|
AM_CXXFLAGS += -Wall -Wwrite-strings -Woverloaded-virtual -Wno-sign-compare
|
|
endif GCC
|
|
|
|
# We know our low-level code cannot trigger an exception. On some
|
|
# systems, such as cygwin, it would be disastrous if they did, because
|
|
# the exception handler might call malloc! If our low-level routines
|
|
# raised an exception within the malloc, they'd deadlock. Luckily,
|
|
# we control all this code, and do not need exceptions for it.
|
|
if GCC
|
|
NO_EXCEPTIONS = -fno-exceptions
|
|
else !GCC
|
|
NO_EXCEPTIONS =
|
|
endif !GCC
|
|
|
|
# These are x86-specific, having to do with frame-pointers
|
|
if X86_64
|
|
if ENABLE_FRAME_POINTERS
|
|
AM_CXXFLAGS += -fno-omit-frame-pointer
|
|
else
|
|
# TODO(csilvers): check if -fomit-frame-pointer might be in $(CXXFLAGS),
|
|
# before setting this.
|
|
AM_CXXFLAGS += -DNO_FRAME_POINTER
|
|
endif !ENABLE_FRAME_POINTERS
|
|
endif X86_64
|
|
|
|
# For windows systems (mingw and cygwin), we need to tell all our
|
|
# tests to link in libtcmalloc using -u. This is because libtcmalloc
|
|
# accomplishes its tasks via patching, leaving no work for the linker
|
|
# to identify, so the linker will ignore libtcmalloc by default unless
|
|
# we explicitly create a dependency via -u.
|
|
TCMALLOC_FLAGS =
|
|
if MINGW
|
|
TCMALLOC_FLAGS += -Wl,-u__tcmalloc
|
|
endif MINGW
|
|
|
|
googleincludedir = $(includedir)/google
|
|
# The .h files you want to install (that is, .h files that people
|
|
# who install this package can include in their own applications.)
|
|
# We'll add to this later, on a library-by-library basis
|
|
googleinclude_HEADERS =
|
|
|
|
docdir = $(prefix)/share/doc/$(PACKAGE)-$(VERSION)
|
|
# This is for HTML and other documentation you want to install.
|
|
# Add your documentation files (in doc/) in addition to these
|
|
# top-level boilerplate files. Also add a TODO file if you have one.
|
|
# We'll add to this later, on a library-by-library basis
|
|
dist_doc_DATA = AUTHORS COPYING ChangeLog INSTALL NEWS README README.windows \
|
|
TODO
|
|
|
|
# The libraries (.so's) you want to install
|
|
# We'll add to this later, on a library-by-library basis
|
|
lib_LTLIBRARIES =
|
|
# This is for 'convenience libraries' -- basically just a container for sources
|
|
noinst_LTLIBRARIES =
|
|
## The location of the windows project file for each binary we make
|
|
WINDOWS_PROJECTS = google-perftools.sln
|
|
|
|
# unittests you want to run when people type 'make check'.
|
|
# Note: tests cannot take any arguments!
|
|
# In theory, unittests that are scripts should be added to check_SCRIPTS
|
|
# instead. But check_SCRIPTS is definitely a second-class testing mechanims:
|
|
# it don't get TESTS_ENVIRONMENT, and it doesn't get success/failure counting
|
|
# (in fact, a script failure aborts all the rest of the tests, even with -k).
|
|
# So, for scripts, we add the script to tests, and also put in an empty
|
|
# rule so automake doesn't try to build the script as a C binary.
|
|
TESTS =
|
|
# TESTS_ENVIRONMENT sets environment variables for when you run unittest.
|
|
# We always get "srcdir" set for free.
|
|
# We'll add to this later, on a library-by-library basis.
|
|
TESTS_ENVIRONMENT =
|
|
# All script tests should be added here
|
|
noinst_SCRIPTS =
|
|
# If your test calls another program that, like the test itself, shouldn't
|
|
# be installed, add it here. (Stuff in TESTS is automatically added later).
|
|
noinst_PROGRAMS =
|
|
|
|
|
|
## vvvv RULES TO MAKE THE LIBRARIES, BINARIES, AND UNITTESTS
|
|
|
|
dist_doc_DATA += doc/index.html doc/designstyle.css
|
|
|
|
|
|
### ------- library routines, in src/base
|
|
|
|
# This is a 'convenience library' -- it's not actually installed or anything
|
|
LOGGING_INCLUDES = src/base/logging.h \
|
|
src/base/commandlineflags.h \
|
|
src/base/basictypes.h \
|
|
src/base/dynamic_annotations.h
|
|
noinst_LTLIBRARIES += liblogging.la
|
|
liblogging_la_SOURCES = src/base/logging.cc \
|
|
src/base/dynamic_annotations.cc \
|
|
$(LOGGING_INCLUDES)
|
|
|
|
SYSINFO_INCLUDES = src/base/sysinfo.h \
|
|
src/base/logging.h \
|
|
src/base/commandlineflags.h \
|
|
src/base/cycleclock.h \
|
|
src/base/basictypes.h
|
|
noinst_LTLIBRARIES += libsysinfo.la
|
|
libsysinfo_la_SOURCES = src/base/sysinfo.cc \
|
|
$(SYSINFO_INCLUDES)
|
|
|
|
# For MinGW, we use libwindows and not libspinlock. For every other
|
|
# unix system, we use libspinlock and don't need libwindows. Luckily,
|
|
# we need the windows.a library in exactly the same place we need
|
|
# spinlock.a (pretty much everywhere), so we can use the same variable
|
|
# name for each. In addition, there is a bunch of functionality in
|
|
# libwindows that obsoletes the need for other files like
|
|
# system_alloc.cc.
|
|
if MINGW
|
|
WINDOWS_INCLUDES = src/windows/port.h \
|
|
src/windows/mingw.h \
|
|
src/windows/mini_disassembler.h \
|
|
src/windows/mini_disassembler_types.h \
|
|
src/windows/preamble_patcher.h
|
|
noinst_LTLIBRARIES += libwindows.la
|
|
libwindows_la_SOURCES = $(WINDOWS_INCLUDES) \
|
|
src/windows/port.cc \
|
|
src/windows/ia32_modrm_map.cc \
|
|
src/windows/ia32_opcode_map.cc \
|
|
src/windows/mini_disassembler.cc \
|
|
src/windows/patch_functions.cc \
|
|
src/windows/preamble_patcher.cc \
|
|
src/windows/preamble_patcher_with_stub.cc
|
|
LIBSPINLOCK = libwindows.la libsysinfo.la liblogging.la
|
|
|
|
# We also need to tell mingw that sysinfo.cc needs shlwapi.lib.
|
|
# (We do this via a #pragma for msvc, but need to do it here for mingw).
|
|
libsysinfo_la_LIBADD = -lshlwapi
|
|
|
|
MAYBE_THREADS_CC =
|
|
SYSTEM_ALLOC_CC =
|
|
else !MINGW
|
|
# spinlock is the only code that uses atomicops.
|
|
SPINLOCK_INCLUDES = src/base/spinlock.h \
|
|
src/base/atomicops.h \
|
|
src/base/atomicops-internals-macosx.h \
|
|
src/base/atomicops-internals-linuxppc.h \
|
|
src/base/atomicops-internals-x86-msvc.h \
|
|
src/base/atomicops-internals-x86.h
|
|
|
|
noinst_LTLIBRARIES += libspinlock.la
|
|
libspinlock_la_SOURCES = src/base/spinlock.cc \
|
|
src/base/atomicops-internals-x86.cc \
|
|
$(SPINLOCK_INCLUDES)
|
|
# spinlock also needs NumCPUs, from libsysinfo, which in turn needs liblogging
|
|
LIBSPINLOCK = libspinlock.la libsysinfo.la liblogging.la
|
|
|
|
MAYBE_THREADS_CC = src/maybe_threads.cc
|
|
SYSTEM_ALLOC_CC = src/system-alloc.cc
|
|
endif !MINGW
|
|
|
|
### Unittests
|
|
TESTS += low_level_alloc_unittest
|
|
WINDOWS_PROJECTS += vsprojects/low_level_alloc_unittest/low_level_alloc_unittest.vcproj
|
|
LOW_LEVEL_ALLOC_UNITTEST_INCLUDES = src/base/low_level_alloc.h \
|
|
src/base/basictypes.h \
|
|
src/google/malloc_hook.h \
|
|
src/google/malloc_hook_c.h \
|
|
src/malloc_hook-inl.h \
|
|
$(SPINLOCK_INCLUDES) \
|
|
$(LOGGING_INCLUDES)
|
|
low_level_alloc_unittest_SOURCES = src/base/low_level_alloc.cc \
|
|
src/malloc_hook.cc \
|
|
src/tests/low_level_alloc_unittest.cc \
|
|
$(LOW_LEVEL_ALLOC_UNITTEST_INCLUDES)
|
|
low_level_alloc_unittest_LDADD = libstacktrace.la
|
|
|
|
if !MINGW
|
|
TESTS += atomicops_unittest
|
|
ATOMICOPS_UNITTEST_INCLUDES = src/base/atomicops.h \
|
|
src/base/atomicops-internals-macosx.h \
|
|
src/base/atomicops-internals-x86-msvc.h \
|
|
src/base/atomicops-internals-x86.h \
|
|
$(LOGGING_INCLUDES)
|
|
atomicops_unittest_SOURCES = src/tests/atomicops_unittest.cc \
|
|
$(ATOMICOPS_UNITTEST_INCLUDES)
|
|
atomicops_unittest_LDADD = $(LIBSPINLOCK)
|
|
endif !MINGW
|
|
|
|
|
|
### ------- stack trace
|
|
|
|
### The header files we use. We divide into categories based on directory
|
|
S_STACKTRACE_INCLUDES = src/stacktrace_generic-inl.h \
|
|
src/stacktrace_libunwind-inl.h \
|
|
src/stacktrace_powerpc-inl.h \
|
|
src/stacktrace_x86_64-inl.h \
|
|
src/stacktrace_x86-inl.h \
|
|
src/stacktrace_win32-inl.h
|
|
SG_STACKTRACE_INCLUDES = src/google/stacktrace.h
|
|
STACKTRACE_INCLUDES = $(S_STACKTRACE_INCLUDES) $(SG_STACKTRACE_INCLUDES)
|
|
googleinclude_HEADERS += $(SG_STACKTRACE_INCLUDES)
|
|
|
|
### Making the library
|
|
noinst_LTLIBRARIES += libstacktrace.la
|
|
libstacktrace_la_SOURCES = src/stacktrace.cc \
|
|
$(STACKTRACE_INCLUDES)
|
|
libstacktrace_la_LIBADD = $(UNWIND_LIBS) $(LIBSPINLOCK)
|
|
STACKTRACE_SYMBOLS = '(GetStackTrace)'
|
|
libstacktrace_la_LDFLAGS = -export-symbols-regex $(STACKTRACE_SYMBOLS)
|
|
|
|
### Unittests
|
|
TESTS += stacktrace_unittest
|
|
STACKTRACE_UNITTEST_INLCUDES = src/config_for_unittests.h \
|
|
src/base/commandlineflags.h \
|
|
$(STACKTRACE_INCLUDES) \
|
|
$(LOGGING_INCLUDES)
|
|
stacktrace_unittest_SOURCES = src/tests/stacktrace_unittest.cc \
|
|
$(STACKTRACE_UNITTEST_INLCUDES)
|
|
stacktrace_unittest_LDADD = libstacktrace.la liblogging.la
|
|
|
|
### Documentation
|
|
dist_doc_DATA +=
|
|
|
|
|
|
### ------- pprof
|
|
|
|
bin_SCRIPTS = src/pprof
|
|
|
|
### Unittests
|
|
|
|
if !MINGW
|
|
check_SCRIPTS = pprof_unittest
|
|
pprof_unittest: $(top_srcdir)/src/pprof
|
|
$(top_srcdir)/src/pprof -test
|
|
|
|
# Let unittests find pprof if they need to run it
|
|
TESTS_ENVIRONMENT += PPROF_PATH=$(top_srcdir)/src/pprof
|
|
endif !MINGW
|
|
|
|
### Documentation
|
|
dist_man_MANS = doc/pprof.1
|
|
dist_doc_DATA += doc/pprof_remote_servers.html
|
|
|
|
|
|
### ------- tcmalloc_minimal (thread-caching malloc)
|
|
|
|
### The header files we use. We divide into categories based on directory
|
|
S_TCMALLOC_MINIMAL_INCLUDES = src/common.h \
|
|
src/internal_logging.h \
|
|
src/system-alloc.h \
|
|
src/packed-cache-inl.h \
|
|
$(SPINLOCK_INCLUDES) \
|
|
src/tcmalloc_guard.h \
|
|
src/base/commandlineflags.h \
|
|
src/base/basictypes.h \
|
|
src/pagemap.h \
|
|
src/central_freelist.h \
|
|
src/linked_list.h \
|
|
src/page_heap.h \
|
|
src/page_heap_allocator.h \
|
|
src/span.h \
|
|
src/static_vars.h \
|
|
src/thread_cache.h \
|
|
src/base/thread_annotations.h \
|
|
src/malloc_hook-inl.h \
|
|
src/maybe_threads.h
|
|
SG_TCMALLOC_MINIMAL_INCLUDES = src/google/malloc_hook.h \
|
|
src/google/malloc_hook_c.h \
|
|
src/google/malloc_extension.h \
|
|
src/google/stacktrace.h
|
|
TCMALLOC_MINIMAL_INCLUDES = $(S_TCMALLOC_MINIMAL_INCLUDES) $(SG_TCMALLOC_MINIMAL_INCLUDES)
|
|
googleinclude_HEADERS += $(SG_TCMALLOC_MINIMAL_INCLUDES)
|
|
|
|
### Making the library
|
|
|
|
# As we describe at the top of this file, we want to turn off exceptions
|
|
# for all files in this library -- except tcmalloc.cc which needs them
|
|
# to fulfill its API. Automake doesn't allow per-file CXXFLAGS, so we need
|
|
# to separate into two libraries.
|
|
noinst_LTLIBRARIES += libtcmalloc_minimal_internal.la
|
|
libtcmalloc_minimal_internal_la_SOURCES = src/common.cc \
|
|
src/internal_logging.cc \
|
|
$(SYSTEM_ALLOC_CC) \
|
|
src/memfs_malloc.cc \
|
|
src/central_freelist.cc \
|
|
src/page_heap.cc \
|
|
src/span.cc \
|
|
src/static_vars.cc \
|
|
src/thread_cache.cc \
|
|
src/malloc_hook.cc \
|
|
src/malloc_extension.cc \
|
|
$(MAYBE_THREADS_CC) \
|
|
$(TCMALLOC_MINIMAL_INCLUDES)
|
|
# We #define NO_TCMALLOC_SAMPLES, since sampling is turned off for _minimal.
|
|
libtcmalloc_minimal_internal_la_CXXFLAGS = -DNO_TCMALLOC_SAMPLES \
|
|
$(PTHREAD_CFLAGS) -DNDEBUG \
|
|
$(AM_CXXFLAGS) $(NO_EXCEPTIONS)
|
|
libtcmalloc_minimal_internal_la_LDFLAGS = $(PTHREAD_CFLAGS)
|
|
libtcmalloc_minimal_internal_la_LIBADD = $(PTHREAD_LIBS) $(LIBSPINLOCK)
|
|
|
|
lib_LTLIBRARIES += libtcmalloc_minimal.la
|
|
WINDOWS_PROJECTS += vsprojects/libtcmalloc_minimal/libtcmalloc_minimal.vcproj
|
|
libtcmalloc_minimal_la_SOURCES = src/tcmalloc.cc \
|
|
$(TCMALLOC_MINIMAL_INCLUDES)
|
|
libtcmalloc_minimal_la_CXXFLAGS = -DNO_TCMALLOC_SAMPLES \
|
|
$(PTHREAD_CFLAGS) -DNDEBUG $(AM_CXXFLAGS)
|
|
libtcmalloc_minimal_la_LDFLAGS = $(PTHREAD_CFLAGS)
|
|
libtcmalloc_minimal_la_LIBADD = $(PTHREAD_LIBS) libtcmalloc_minimal_internal.la
|
|
|
|
# For windows, we're playing around with trying to do some stacktrace
|
|
# support even with libtcmalloc_minimal. For everyone else, though,
|
|
# we turn off all stack-trace activity for libtcmalloc_minimal.
|
|
# TODO(csilvers): when we're done experimenting, do something principled here
|
|
if MINGW
|
|
LIBTCMALLOC_MINIMAL = libtcmalloc_minimal.la libstacktrace.la
|
|
else !MINGW
|
|
LIBTCMALLOC_MINIMAL = libtcmalloc_minimal.la
|
|
endif !MINGW
|
|
|
|
### Unittests
|
|
|
|
# Commented out for the moment because malloc(very_big_num) is broken in
|
|
# standard libc! At least, in some situations, some of the time.
|
|
## TESTS += malloc_unittest
|
|
## MALLOC_UNITEST_INCLUDES = src/google/malloc_extension.h \
|
|
## src/google/malloc_hook.h \
|
|
## src/google/malloc_hook_c.h \
|
|
## src/malloc_hook-inl.h \
|
|
## src/base/basictypes.h \
|
|
## src/maybe_threads.h
|
|
## malloc_unittest_SOURCES = src/tests/tcmalloc_unittest.cc \
|
|
## src/malloc_hook.cc \
|
|
## src/malloc_extension.cc \
|
|
## $(MAYBE_THREADS_CC) \
|
|
## $(MALLOC_UNITTEST_INCLUDES)
|
|
## malloc_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
|
|
## malloc_unittest_LDFLAGS = $(PTHREAD_CFLAGS)
|
|
## malloc_unittest_LDADD = $(PTHREAD_LIBS)
|
|
|
|
TESTS += tcmalloc_minimal_unittest
|
|
WINDOWS_PROJECTS += vsprojects/tcmalloc_minimal_unittest/tcmalloc_minimal_unittest.vcproj
|
|
WINDOWS_PROJECTS += vsprojects/tmu-static/tmu-static.vcproj
|
|
tcmalloc_minimal_unittest_SOURCES = src/tests/tcmalloc_unittest.cc \
|
|
src/tests/testutil.h src/tests/testutil.cc \
|
|
$(TCMALLOC_UNITTEST_INCLUDES)
|
|
tcmalloc_minimal_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
|
|
tcmalloc_minimal_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
|
|
tcmalloc_minimal_unittest_LDADD = $(LIBTCMALLOC_MINIMAL) \
|
|
liblogging.la $(PTHREAD_LIBS)
|
|
|
|
TESTS += tcmalloc_minimal_large_unittest
|
|
WINDOWS_PROJECTS += vsprojects/tcmalloc_minimal_large/tcmalloc_minimal_large_unittest.vcproj
|
|
tcmalloc_minimal_large_unittest_SOURCES = src/tests/tcmalloc_large_unittest.cc
|
|
tcmalloc_minimal_large_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
|
|
tcmalloc_minimal_large_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
|
|
tcmalloc_minimal_large_unittest_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
|
|
|
|
# This tests it works to LD_PRELOAD libtcmalloc (tests maybe_threads.cc)
|
|
# In theory this should work under mingw, but mingw has trouble running
|
|
# shell scripts that end in .exe. And it doesn't seem to build shared
|
|
# libraries anyway (so can't be LD_PRELOADed).
|
|
# TODO(csilvers): figure out how to nix ".exe" or otherwise work under mingw
|
|
if !MINGW
|
|
TESTS += maybe_threads_unittest.sh
|
|
maybe_threads_unittest_sh_SOURCES = src/tests/maybe_threads_unittest.sh
|
|
noinst_SCRIPTS += $(maybe_threads_unittest_sh_SOURCES)
|
|
# This script preloads libtcmalloc, and calls two other binaries as well
|
|
maybe_threads_unittest.sh$(EXEEXT): $(top_srcdir)/$(maybe_threads_unittest_sh_SOURCES) \
|
|
$(LIBTCMALLOC_MINIMAL) \
|
|
low_level_alloc_unittest
|
|
rm -f $@
|
|
cp -p $(top_srcdir)/$(maybe_threads_unittest_sh_SOURCES) $@
|
|
endif !MINGW
|
|
|
|
# These all tests components of tcmalloc_minimal
|
|
|
|
TESTS += addressmap_unittest
|
|
WINDOWS_PROJECTS += vsprojects/addressmap_unittest/addressmap_unittest.vcproj
|
|
ADDRESSMAP_UNITTEST_INCLUDES = src/addressmap-inl.h \
|
|
src/base/commandlineflags.h \
|
|
$(LOGGING_INCLUDES)
|
|
addressmap_unittest_SOURCES = src/tests/addressmap_unittest.cc \
|
|
$(ADDRESSMAP_UNITTEST_INCLUDES)
|
|
addressmap_unittest_CXXFLAGS = -g $(AM_CXXFLAGS)
|
|
addressmap_unittest_LDADD = liblogging.la
|
|
|
|
if !MINGW
|
|
TESTS += system_alloc_unittest
|
|
system_alloc_unittest_SOURCES = src/config_for_unittests.h \
|
|
src/tests/system-alloc_unittest.cc
|
|
system_alloc_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
|
|
system_alloc_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
|
|
system_alloc_unittest_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
|
|
endif !MINGW
|
|
|
|
TESTS += packed_cache_test
|
|
WINDOWS_PROJECTS += vsprojects/packed-cache_test/packed-cache_test.vcproj
|
|
packed_cache_test_SOURCES = src/tests/packed-cache_test.cc \
|
|
src/packed-cache-inl.h \
|
|
src/base/logging.h
|
|
|
|
TESTS += frag_unittest
|
|
WINDOWS_PROJECTS += vsprojects/frag_unittest/frag_unittest.vcproj
|
|
frag_unittest_SOURCES = src/tests/frag_unittest.cc src/config_for_unittests.h
|
|
frag_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
|
|
frag_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
|
|
frag_unittest_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
|
|
|
|
TESTS += markidle_unittest
|
|
WINDOWS_PROJECTS += vsprojects/markidle_unittest/markidle_unittest.vcproj
|
|
markidle_unittest_SOURCES = src/tests/markidle_unittest.cc \
|
|
src/config_for_unittests.h \
|
|
src/tests/testutil.h src/tests/testutil.cc
|
|
markidle_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
|
|
markidle_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
|
|
markidle_unittest_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
|
|
|
|
if !MINGW
|
|
TESTS += memalign_unittest
|
|
memalign_unittest_SOURCES = src/tests/memalign_unittest.cc \
|
|
src/config_for_unittests.h \
|
|
src/tcmalloc.h \
|
|
src/tests/testutil.h src/tests/testutil.cc
|
|
memalign_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
|
|
memalign_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
|
|
memalign_unittest_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
|
|
endif !MINGW
|
|
|
|
TESTS += thread_dealloc_unittest
|
|
WINDOWS_PROJECTS += vsprojects/thread_dealloc_unittest/thread_dealloc_unittest.vcproj
|
|
thread_dealloc_unittest_SOURCES = src/tests/thread_dealloc_unittest.cc \
|
|
src/config_for_unittests.h \
|
|
src/tests/testutil.h src/tests/testutil.cc
|
|
thread_dealloc_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
|
|
thread_dealloc_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
|
|
thread_dealloc_unittest_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
|
|
|
|
# performance/unittests originally from ptmalloc2
|
|
# Commented out for now because they don't compile on all systems.
|
|
# However, you can still make/run by hand like so:
|
|
# make ptmalloc_unittest1 ptmalloc_unittest2
|
|
# ./ptmalloc_unittest1; ./ptmalloc_unittest2
|
|
##TESTS += ptmalloc_unittest1 ptmalloc_unittest2
|
|
EXTRA_PROGRAMS = ptmalloc_unittest1 ptmalloc_unittest2
|
|
PTMALLOC_UNITTEST_INCLUDES = src/tests/ptmalloc/t-test.h \
|
|
src/tests/ptmalloc/thread-m.h \
|
|
src/tests/ptmalloc/lran2.h \
|
|
src/tests/ptmalloc/thread-st.h \
|
|
src/tests/ptmalloc/malloc-machine.h
|
|
ptmalloc_unittest1_SOURCES = src/tests/ptmalloc/t-test1.c \
|
|
$(PTMALLOC_UNITTEST_INCLUDES)
|
|
ptmalloc_unittest1_CFLAGS = $(PTHREAD_CFLAGS) -DUSE_PTHREADS
|
|
ptmalloc_unittest1_LDFLAGS = $(PTHREAD_CFLAGS)
|
|
ptmalloc_unittest1_LDADD = $(PTHREAD_LIBS)
|
|
ptmalloc_unittest2_SOURCES = src/tests/ptmalloc/t-test2.c \
|
|
$(PTMALLOC_UNITTEST_INCLUDES)
|
|
ptmalloc_unittest2_CFLAGS = $(PTHREAD_CFLAGS) -DUSE_PTHREADS
|
|
ptmalloc_unittest2_LDFLAGS = $(PTHREAD_CFLAGS)
|
|
ptmalloc_unittest2_LDADD = $(PTHREAD_LIBS)
|
|
|
|
### Documentation
|
|
dist_doc_DATA += doc/tcmalloc.html \
|
|
doc/overview.gif \
|
|
doc/pageheap.gif \
|
|
doc/spanmap.gif \
|
|
doc/threadheap.gif \
|
|
doc/t-test1.times.txt \
|
|
doc/tcmalloc-opspercpusec.vs.threads.1024.bytes.png \
|
|
doc/tcmalloc-opspercpusec.vs.threads.128.bytes.png \
|
|
doc/tcmalloc-opspercpusec.vs.threads.131072.bytes.png \
|
|
doc/tcmalloc-opspercpusec.vs.threads.16384.bytes.png \
|
|
doc/tcmalloc-opspercpusec.vs.threads.2048.bytes.png \
|
|
doc/tcmalloc-opspercpusec.vs.threads.256.bytes.png \
|
|
doc/tcmalloc-opspercpusec.vs.threads.32768.bytes.png \
|
|
doc/tcmalloc-opspercpusec.vs.threads.4096.bytes.png \
|
|
doc/tcmalloc-opspercpusec.vs.threads.512.bytes.png \
|
|
doc/tcmalloc-opspercpusec.vs.threads.64.bytes.png \
|
|
doc/tcmalloc-opspercpusec.vs.threads.65536.bytes.png \
|
|
doc/tcmalloc-opspercpusec.vs.threads.8192.bytes.png \
|
|
doc/tcmalloc-opspersec.vs.size.1.threads.png \
|
|
doc/tcmalloc-opspersec.vs.size.12.threads.png \
|
|
doc/tcmalloc-opspersec.vs.size.16.threads.png \
|
|
doc/tcmalloc-opspersec.vs.size.2.threads.png \
|
|
doc/tcmalloc-opspersec.vs.size.20.threads.png \
|
|
doc/tcmalloc-opspersec.vs.size.3.threads.png \
|
|
doc/tcmalloc-opspersec.vs.size.4.threads.png \
|
|
doc/tcmalloc-opspersec.vs.size.5.threads.png \
|
|
doc/tcmalloc-opspersec.vs.size.8.threads.png
|
|
|
|
# I don't know how to say "distribute the .dot files but don't install them";
|
|
# noinst doesn't seem to work with data. I separate them out anyway, in case
|
|
# one day we figure it out. Regardless, installing the dot files isn't the
|
|
# end of the world.
|
|
dist_doc_DATA += doc/overview.dot \
|
|
doc/pageheap.dot \
|
|
doc/spanmap.dot \
|
|
doc/threadheap.dot
|
|
|
|
### ------- tcmalloc (thread-caching malloc + heap profiler + heap checker)
|
|
|
|
# The full tcmalloc does not work on windows yet
|
|
if !MINGW
|
|
|
|
### The header files we use. We divide into categories based on directory
|
|
S_TCMALLOC_INCLUDES = $(S_TCMALLOC_MINIMAL_INCLUDES) \
|
|
$(LOGGING_INCLUDES) \
|
|
src/addressmap-inl.h \
|
|
src/base/elfcore.h \
|
|
src/base/googleinit.h \
|
|
src/base/linux_syscall_support.h \
|
|
src/base/linuxthreads.h \
|
|
src/base/stl_allocator.h \
|
|
src/base/sysinfo.h \
|
|
src/base/thread_lister.h \
|
|
src/heap-profile-table.h
|
|
SG_TCMALLOC_INCLUDES = $(SG_TCMALLOC_MINIMAL_INCLUDES) \
|
|
src/google/heap-profiler.h \
|
|
src/google/heap-checker.h
|
|
TCMALLOC_INCLUDES = $(S_TCMALLOC_INCLUDES) $(SG_TCMALLOC_INCLUDES)
|
|
googleinclude_HEADERS += $(SG_TCMALLOC_INCLUDES)
|
|
|
|
### Making the library
|
|
lib_LTLIBRARIES += libtcmalloc.la
|
|
# Note: heap-checker-bcad is last, in hopes its global ctor will run first
|
|
# TODO(csilvers): break libtcmalloc.la into two pieces, like we do for
|
|
# libtcmalloc_minimal.la. Right now we don't need it,
|
|
# since the break-up is for a cygwin-specific bug, and
|
|
# cygwin doesn't support libtcmalloc anyway. But one day?
|
|
libtcmalloc_la_SOURCES = $(libtcmalloc_minimal_internal_la_SOURCES) \
|
|
$(libtcmalloc_minimal_la_SOURCES) \
|
|
$(TCMALLOC_INCLUDES) \
|
|
src/base/linuxthreads.cc \
|
|
src/base/low_level_alloc.cc \
|
|
src/base/thread_lister.c \
|
|
src/heap-checker.cc \
|
|
src/heap-profile-table.cc \
|
|
src/heap-profiler.cc \
|
|
src/memory_region_map.cc \
|
|
src/heap-checker-bcad.cc
|
|
libtcmalloc_la_CXXFLAGS = $(PTHREAD_CFLAGS) -DNDEBUG $(AM_CXXFLAGS)
|
|
libtcmalloc_la_LDFLAGS = $(PTHREAD_CFLAGS)
|
|
libtcmalloc_la_LIBADD = $(PTHREAD_LIBS) \
|
|
libstacktrace.la
|
|
|
|
LIBTCMALLOC = libtcmalloc.la
|
|
|
|
|
|
### Unittests
|
|
|
|
TESTS += tcmalloc_unittest
|
|
TCMALLOC_UNITTEST_INCLUDES = src/config_for_unittests.h \
|
|
src/google/malloc_extension.h
|
|
tcmalloc_unittest_SOURCES = src/tests/tcmalloc_unittest.cc \
|
|
src/tcmalloc.h \
|
|
src/tests/testutil.h src/tests/testutil.cc \
|
|
$(TCMALLOC_UNITTEST_INCLUDES)
|
|
tcmalloc_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
|
|
tcmalloc_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
|
|
tcmalloc_unittest_LDADD = $(LIBTCMALLOC) liblogging.la $(PTHREAD_LIBS)
|
|
|
|
# This makes sure it's safe to link in both tcmalloc and
|
|
# tcmalloc_minimal. (One would never do this on purpose, but perhaps
|
|
# by accident...) When we can compile libprofiler, we also link it in
|
|
# to make sure that works too.
|
|
|
|
TESTS += tcmalloc_both_unittest
|
|
tcmalloc_both_unittest_SOURCES = src/tests/tcmalloc_unittest.cc \
|
|
src/tests/testutil.h src/tests/testutil.cc \
|
|
$(TCMALLOC_UNITTEST_INCLUDES)
|
|
tcmalloc_both_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
|
|
tcmalloc_both_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
|
|
if HAS_PC
|
|
tcmalloc_both_unittest_LDADD = $(LIBTCMALLOC) $(LIBTCMALLOC_MINIMAL) \
|
|
libprofiler.la liblogging.la $(PTHREAD_LIBS)
|
|
else
|
|
tcmalloc_both_unittest_LDADD = $(LIBTCMALLOC) $(LIBTCMALLOC_MINIMAL) \
|
|
liblogging.la $(PTHREAD_LIBS)
|
|
endif !HAS_PC
|
|
|
|
TESTS += tcmalloc_large_unittest
|
|
tcmalloc_large_unittest_SOURCES = src/tests/tcmalloc_large_unittest.cc
|
|
tcmalloc_large_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
|
|
tcmalloc_large_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
|
|
tcmalloc_large_unittest_LDADD = $(LIBTCMALLOC) $(PTHREAD_LIBS)
|
|
|
|
# These unittests often need to run binaries. They're in the current dir
|
|
TESTS_ENVIRONMENT += BINDIR=.
|
|
TESTS_ENVIRONMENT += TMPDIR=/tmp/perftools
|
|
|
|
TESTS += sampling_test.sh
|
|
sampling_test_sh_SOURCES = src/tests/sampling_test.sh
|
|
noinst_SCRIPTS += $(sampling_test_sh_SOURCES)
|
|
sampling_test.sh$(EXEEXT): $(top_srcdir)/$(sampling_test_sh_SOURCES) \
|
|
sampling_test
|
|
rm -f $@
|
|
cp -p $(top_srcdir)/$(sampling_test_sh_SOURCES) $@
|
|
|
|
# This is the sub-program using by sampling_test.sh
|
|
# The -g is so pprof can get symbol information.
|
|
noinst_PROGRAMS += sampling_test
|
|
SAMPLING_TEST_INCLUDES = src/config_for_unittests.h \
|
|
src/base/logging.h \
|
|
src/google/malloc_extension.h
|
|
sampling_test_SOURCES = src/tests/sampling_test.cc \
|
|
$(SAMPLING_TEST_INCLUDES)
|
|
sampling_test_CXXFLAGS = -g $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
|
|
sampling_test_LDFLAGS = -g $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
|
|
sampling_test_LDADD = $(LIBTCMALLOC) $(PTHREAD_LIBS)
|
|
|
|
|
|
TESTS += heap-profiler_unittest.sh
|
|
heap_profiler_unittest_sh_SOURCES = src/tests/heap-profiler_unittest.sh
|
|
noinst_SCRIPTS += $(heap_profiler_unittest_sh_SOURCES)
|
|
heap-profiler_unittest.sh$(EXEEXT): $(top_srcdir)/$(heap_profiler_unittest_sh_SOURCES) \
|
|
heap-profiler_unittest
|
|
rm -f $@
|
|
cp -p $(top_srcdir)/$(heap_profiler_unittest_sh_SOURCES) $@
|
|
|
|
# These are sub-programs used by heap-profiler_unittest.sh
|
|
noinst_PROGRAMS += heap-profiler_unittest
|
|
HEAP_PROFILER_UNITTEST_INCLUDES = src/config_for_unittests.h \
|
|
src/google/heap-profiler.h
|
|
heap_profiler_unittest_SOURCES = src/tests/heap-profiler_unittest.cc \
|
|
$(HEAP_PROFILER_UNITTEST_INCLUDES)
|
|
heap_profiler_unittest_CXXFLAGS = -g $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
|
|
heap_profiler_unittest_LDFLAGS = -g $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
|
|
heap_profiler_unittest_LDADD = $(LIBTCMALLOC) $(PTHREAD_LIBS)
|
|
|
|
TESTS += heap-checker_unittest.sh
|
|
heap_checker_unittest_sh_SOURCES = src/tests/heap-checker_unittest.sh
|
|
noinst_SCRIPTS += $(heap_checker_unittest_sh_SOURCES)
|
|
heap-checker_unittest.sh$(EXEEXT): $(top_srcdir)/$(heap_checker_unittest_sh_SOURCES) \
|
|
heap-checker_unittest
|
|
rm -f $@
|
|
cp -p $(top_srcdir)/$(heap_checker_unittest_sh_SOURCES) $@
|
|
|
|
TESTS += heap-checker-death_unittest.sh
|
|
heap_checker_death_unittest_sh_SOURCES = src/tests/heap-checker-death_unittest.sh
|
|
noinst_SCRIPTS += $(top_srcdir)/$(heap_checker_death_unittest_sh_SOURCES)
|
|
heap-checker-death_unittest.sh$(EXEEXT): $(heap_checker_death_unittest_sh_SOURCES) \
|
|
heap-checker_unittest
|
|
rm -f $@
|
|
cp -p $(top_srcdir)/$(heap_checker_death_unittest_sh_SOURCES) $@
|
|
|
|
# These are sub-programs used by heap-checker_unittest.sh
|
|
noinst_PROGRAMS += heap-checker_unittest
|
|
HEAP_CHECKER_UNITTEST_INCLUDES = src/config_for_unittests.h \
|
|
src/memory_region_map.h \
|
|
src/base/commandlineflags.h \
|
|
src/base/googleinit.h \
|
|
src/google/heap-checker.h \
|
|
$(LOGGING_INCLUDES)
|
|
heap_checker_unittest_SOURCES = src/tests/heap-checker_unittest.cc \
|
|
$(HEAP_CHECKER_UNITTEST_INCLUDES)
|
|
heap_checker_unittest_CXXFLAGS = -g $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
|
|
heap_checker_unittest_LDFLAGS = -g $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
|
|
# tcmalloc has to be specified last!
|
|
heap_checker_unittest_LDADD = $(PTHREAD_LIBS) liblogging.la $(LIBTCMALLOC)
|
|
|
|
### Documentation (above and beyond tcmalloc_minimal documentation)
|
|
dist_doc_DATA += doc/heapprofile.html \
|
|
doc/heap-example1.png \
|
|
doc/heap_checker.html
|
|
|
|
endif !MINGW
|
|
|
|
### ------- CPU profiler
|
|
|
|
# The CPU profiler doesn't work on windows yet. It also doesn't work
|
|
# if there's no way to get the PC.
|
|
if !MINGW
|
|
if HAS_PC
|
|
|
|
### The header files we use. We divide into categories based on directory
|
|
S_CPU_PROFILER_INCLUDES = src/profiledata.h \
|
|
src/getpc.h \
|
|
src/base/basictypes.h \
|
|
src/base/commandlineflags.h \
|
|
src/base/googleinit.h \
|
|
src/base/logging.h \
|
|
src/base/simple_mutex.h \
|
|
src/base/sysinfo.h \
|
|
$(SPINLOCK_INCLUDES) \
|
|
$(LOGGING_INCLUDES)
|
|
SG_CPU_PROFILER_INCLUDES = src/google/profiler.h \
|
|
src/google/stacktrace.h
|
|
CPU_PROFILER_INCLUDES = $(S_CPU_PROFILER_INCLUDES) $(SG_CPU_PROFILER_INCLUDES)
|
|
googleinclude_HEADERS += $(SG_CPU_PROFILER_INCLUDES)
|
|
|
|
### Making the library
|
|
lib_LTLIBRARIES += libprofiler.la
|
|
libprofiler_la_SOURCES = src/profiler.cc \
|
|
src/profiledata.cc \
|
|
$(CPU_PROFILER_INCLUDES)
|
|
libprofiler_la_LIBADD = libstacktrace.la
|
|
# We have to include ProfileData for profiledata_unittest
|
|
CPU_PROFILER_SYMBOLS = '(ProfilerStart|ProfilerStop|ProfilerEnable|ProfilerDisable|ProfilerFlush|ProfilerRegisterThread|ProfileData)'
|
|
libprofiler_la_LDFLAGS = -export-symbols-regex $(CPU_PROFILER_SYMBOLS)
|
|
|
|
# See discussion above (under LIBTCMALLOC_MINIMAL) for why we do this.
|
|
# Basically it's to work around systems where --rpath doesn't work right.
|
|
LIBPROFILER = libstacktrace.la libprofiler.la
|
|
|
|
### Unittests
|
|
TESTS += getpc_test
|
|
#WINDOWS_PROJECTS += vsprojects/getpc_test/getpc_test.vcproj
|
|
getpc_test_SOURCES = src/tests/getpc_test.cc src/getpc.h
|
|
|
|
TESTS += profiledata_unittest
|
|
#WINDOWS_PROJECTS += vsprojects/profiledata_unittest/profiledata_unittest.vcproj
|
|
profiledata_unittest_SOURCES = src/tests/profiledata_unittest.cc \
|
|
src/profiledata.h \
|
|
src/base/commandlineflags.h \
|
|
src/base/logging.h \
|
|
src/base/basictypes.h
|
|
profiledata_unittest_LDADD = $(LIBPROFILER)
|
|
|
|
TESTS += profiler_unittest.sh
|
|
profiler_unittest_sh_SOURCES = src/tests/profiler_unittest.sh
|
|
noinst_SCRIPTS += $(profiler_unittest_sh_SOURCES)
|
|
profiler_unittest.sh$(EXEEXT): $(top_srcdir)/$(profiler_unittest_sh_SOURCES) \
|
|
profiler1_unittest profiler2_unittest \
|
|
profiler3_unittest profiler4_unittest
|
|
rm -f $@
|
|
cp -p $(top_srcdir)/$(profiler_unittest_sh_SOURCES) $@
|
|
|
|
# These are sub-programs used by profiler_unittest.sh
|
|
noinst_PROGRAMS += profiler1_unittest profiler2_unittest profiler3_unittest \
|
|
profiler4_unittest
|
|
PROFILER_UNITTEST_INCLUDES = src/config_for_unittests.h \
|
|
src/google/profiler.h
|
|
PROFILER_UNITTEST_SRCS = src/tests/profiler_unittest.cc \
|
|
src/tests/testutil.h src/tests/testutil.cc \
|
|
$(PROFILER_UNITTEST_INCLUDES)
|
|
profiler1_unittest_SOURCES = $(PROFILER_UNITTEST_SRCS)
|
|
profiler1_unittest_CXXFLAGS = -g -DNO_THREADS $(AM_CXXFLAGS)
|
|
profiler1_unittest_LDADD = $(LIBPROFILER)
|
|
profiler2_unittest_SOURCES = $(PROFILER_UNITTEST_SRCS)
|
|
profiler2_unittest_CXXFLAGS = -g -DNO_THREADS $(AM_CXXFLAGS)
|
|
profiler2_unittest_LDADD = -lstacktrace -lprofiler
|
|
# We depend on -lprofiler but haven't yet said how to build it. Do so now.
|
|
profiler2_unittest_DEPENDENCIES = $(LIBPROFILER)
|
|
profiler3_unittest_SOURCES = $(PROFILER_UNITTEST_SRCS)
|
|
profiler3_unittest_CXXFLAGS = -g $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
|
|
profiler3_unittest_LDFLAGS = $(PTHREAD_CFLAGS)
|
|
profiler3_unittest_LDADD = $(LIBPROFILER) $(PTHREAD_LIBS)
|
|
profiler4_unittest_SOURCES = $(PROFILER_UNITTEST_SRCS)
|
|
profiler4_unittest_CXXFLAGS = -g $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
|
|
profiler4_unittest_LDFLAGS = $(PTHREAD_CFLAGS)
|
|
profiler4_unittest_LDADD = -lstacktrace -lprofiler $(PTHREAD_LIBS)
|
|
# We depend on -lprofiler but haven't yet said how to build it. Do so now.
|
|
profiler4_unittest_DEPENDENCIES = $(LIBPROFILER)
|
|
|
|
|
|
### Documentation
|
|
dist_doc_DATA += doc/cpuprofile.html \
|
|
doc/cpuprofile-fileformat.html \
|
|
doc/pprof-test-big.gif \
|
|
doc/pprof-test.gif \
|
|
doc/pprof-vsnprintf-big.gif \
|
|
doc/pprof-vsnprintf.gif
|
|
|
|
endif HAS_PC
|
|
endif !MINGW
|
|
|
|
# Some windows-only projects
|
|
WINDOWS_PROJECTS += vsprojects/nm-pdb/nm-pdb.vcproj
|
|
WINDOWS_PROJECTS += vsprojects/addr2line-pdb/addr2line-pdb.vcproj
|
|
|
|
## ^^^^ END OF RULES TO MAKE YOUR LIBRARIES, BINARIES, AND UNITTESTS
|
|
|
|
|
|
# This should always include $(TESTS), but may also include other
|
|
# binaries that you compile but don't want automatically installed.
|
|
# We'll add to this later, on a library-by-library basis
|
|
noinst_PROGRAMS += $(TESTS)
|
|
|
|
rpm: dist-gzip packages/rpm.sh packages/rpm/rpm.spec
|
|
@cd packages && ./rpm.sh ${PACKAGE} ${VERSION}
|
|
|
|
deb: dist-gzip packages/deb.sh packages/deb/*
|
|
@cd packages && ./deb.sh ${PACKAGE} ${VERSION}
|
|
|
|
libtool: $(LIBTOOL_DEPS)
|
|
$(SHELL) ./config.status --recheck
|
|
|
|
# Windows wants write permission to .vcproj files and maybe even sln files.
|
|
dist-hook:
|
|
test -e "$(distdir)/vsprojects" \
|
|
&& chmod -R u+w $(distdir)/*.sln $(distdir)/vsprojects/
|
|
|
|
EXTRA_DIST = packages/rpm.sh packages/rpm/rpm.spec packages/deb.sh packages/deb \
|
|
$(SCRIPTS) libtool \
|
|
src/windows/nm-pdb.c src/windows/addr2line-pdb.c \
|
|
src/windows/get_mangled_names.cc \
|
|
src/windows/config.h $(WINDOWS_PROJECTS) \
|
|
src/solaris/libstdc++.la
|