Merge pull request twitter#23 from michalbiesek/feat-vtune-cc-support

[RFC] Add abstraction layer for ITT

deps/ccommon/CMakeLists.txt

@@ -147,6 +147,17 @@ if(NOT CHECK_FOUND)
     find_package(Check QUIET 0.10)
 endif()
 
+if (HAVE_ITT_INSTRUMENTATION)
+    if(PKG_CONFIG_FOUND)
+        pkg_check_modules(ITTNOTIFY REQUIRED ittnotify>=1.0)
+    else()
+        find_package(ITTNOTIFY REQUIRED 1.0)
+    endif()
+    include_directories(${ITTNOTIFY_INCLUDE_DIRS})
+    link_directories(${ITTNOTIFY_LIBRARY_DIRS})
+    link_libraries(${ITTNOTIFY_LIBRARIES})
+endif(HAVE_ITT_INSTRUMENTATION)
+
 find_package(Threads)
 
 

deps/ccommon/cmake/FindITTNOTIFY.cmake

@@ -0,0 +1,65 @@
+# ITTNOTIFY is the instrumentation and tracing technology (ITT) APIs provided by
+# the Intel® VTune™Amplifier enable your application to generate and control
+# the collection of trace data during its execution.
+#
+# The following variables are set when ITTNOTIFY is found:
+#  ITTNOTIFY_FOUND          = Set to true, if all components of ITTNOTIFY have been found.
+#  ITTNOTIFY_INCLUDE_DIRS   = Include path for the header files of ITTNOTIFY.
+#  ITTNOTIFY_LIBRARY_DIRS   = Library search path for the ITTNOTIFY libraries.
+#  ITTNOTIFY_LIBRARIES      = Link these to use ITTNOTIFY.
+#  ITTNOTIFY_LFLAGS         = Linker flags (optional).
+
+if (NOT ITTNOTIFY_FOUND)
+
+  find_program(VTUNE_EXECUTABLE amplxe-cl)
+
+  if(NOT VTUNE_EXECUTABLE)
+    set(ITTNOTIFY_FOUND false)
+      return()
+  endif()
+
+  get_filename_component(VTUNE_DIR ${VTUNE_EXECUTABLE} PATH)
+  set(ITTNOTIFY_ROOT_DIR "${VTUNE_DIR}/..")
+
+  ##_____________________________________________________________________________
+  ## Check for the header files
+
+  find_path (ITTNOTIFY_INCLUDE_DIRS
+    NAMES ittnotify.h
+    HINTS ${ITTNOTIFY_ROOT_DIR}
+    PATHS /usr /usr/local
+    PATH_SUFFIXES include
+    )
+
+  ##_____________________________________________________________________________
+  ## Check for the library
+
+  find_library (ITTNOTIFY_LIBRARIES ittnotify
+    HINTS ${ITTNOTIFY_ROOT_DIR}
+    PATHS /usr /usr/local /opt/local
+    PATH_SUFFIXES lib64 lib
+    )
+
+  ##_____________________________________________________________________________
+  ## Actions taken when all components have been found
+
+  find_package_handle_standard_args (ITTNOTIFY DEFAULT_MSG ITTNOTIFY_LIBRARIES ITTNOTIFY_INCLUDE_DIRS)
+
+  if (ITTNOTIFY_FOUND)
+    if (NOT ITTNOTIFY_FIND_QUIETLY)
+      message (STATUS "Found components for ITTNOTIFY")
+      message (STATUS "ITTNOTIFY_ROOT_DIR  = ${ITTNOTIFY_ROOT_DIR}")
+      message (STATUS "ITTNOTIFY_INCLUDE_DIRS  = ${ITTNOTIFY_INCLUDE_DIRS}")
+      message (STATUS "ITTNOTIFY_LIBRARIES = ${ITTNOTIFY_LIBRARIES}")
+    endif (NOT ITTNOTIFY_FIND_QUIETLY)
+  else (ITTNOTIFY_FOUND)
+    if (ITTNOTIFY_FIND_REQUIRED)
+      message (FATAL_ERROR "Could not find ITTNOTIFY!")
+    endif (ITTNOTIFY_FIND_REQUIRED)
+  endif (ITTNOTIFY_FOUND)
+
+  if(UNIX)
+    list(APPEND ITTNOTIFY_LIBRARIES dl)
+  endif()
+
+endif (NOT ITTNOTIFY_FOUND)

deps/ccommon/include/cc_itt.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <cc_define.h>
+
+#ifdef CC_ITT
+#include "ittnotify.h"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef CC_ITT
+
+#define ITT_DOMAIN_NAME "cc_itt"
+
+#define cc_declare_itt_function(_name)                                           \
+    __itt_heap_function _name
+
+#define cc_create_itt_malloc(_name)                                              \
+    _name = __itt_heap_function_create(#_name, ITT_DOMAIN_NAME)
+
+#define cc_create_itt_free(_name)                                                \
+    _name = __itt_heap_function_create(#_name, ITT_DOMAIN_NAME)
+
+#define cc_create_itt_realloc(_name)                                             \
+    _name = __itt_heap_function_create(#_name, ITT_DOMAIN_NAME)
+
+#define cc_itt_alloc(_itt_heap_f, _p, _s) do {                                   \
+    __itt_heap_allocate_begin(_itt_heap_f, (size_t)(_s), 0);                     \
+    __itt_heap_allocate_end(_itt_heap_f, (void *)&(_p), (size_t)(_s), 0);        \
+} while (0)
+
+#define cc_itt_zalloc(_itt_heap_f, _p, _s) do {                                  \
+    __itt_heap_allocate_begin(_itt_heap_f, (size_t)(_s), 1);                     \
+    __itt_heap_allocate_end(_itt_heap_f, (void *)&(_p), (size_t)(_s), 1);        \
+} while (0)
+
+#define cc_itt_free(_itt_heap_f, _p) do {                                        \
+    __itt_heap_free_begin(_itt_heap_f, _p);                                      \
+    __itt_heap_free_end(_itt_heap_f, _p);                                        \
+} while (0)
+
+#define cc_itt_realloc(_itt_heap_f, _p, _np, _s) do {                            \
+    __itt_heap_reallocate_begin(_itt_heap_f, _p, (size_t)(_s), 0);               \
+    __itt_heap_reallocate_end(_itt_heap_f, _p, (void *)&(_np), (size_t)(_s), 0); \
+} while (0)
+
+#define cc_itt_heap_internal_access()                                            \
+    __itt_heap_internal_access_begin()
+
+#define cc_itt_heap_internal_access_end()                                        \
+    __itt_heap_internal_access_end()
+
+#else
+#define cc_declare_itt_function(_name)
+#define cc_create_itt_malloc(_name)
+#define cc_create_itt_free(_name)
+#define cc_create_itt_realloc(_name)
+#define cc_itt_alloc(_itt_heap_f, _p, _s)
+#define cc_itt_zalloc(_itt_heap_f, _p, _s)
+#define cc_itt_free(_itt_heap_f, _p)
+#define cc_itt_realloc(_itt_heap_f, _p, _np, _s)
+#define cc_itt_heap_internal_access_begin()
+#define cc_itt_heap_internal_access_end()
+#endif /* CC_ITT */
+
+#ifdef __cplusplus
+}
+#endif

src/storage/cuckoo/cuckoo.c

@@ -4,19 +4,14 @@
 #include <cc_define.h>
 #include <hash/cc_murmur3.h>
 #include <cc_mm.h>
+#include <cc_itt.h>
 
 #include <datapool/datapool.h>
 
 /* TODO(yao): make D and iv[] configurable */
 #include <stdlib.h>
 #include <sysexits.h>
 
-#if CC_ITT
-#include "ittnotify.h"
-
-__itt_heap_function cuckoo_malloc;
-#endif
-
 #define CUCKOO_MODULE_NAME "storage::cuckoo"
 
 /* D is the degree/cardinality of the hash values computed for each key */
@@ -68,6 +63,9 @@ static size_t hash_size; /* item_size * max_nitem, computed at setup */
     DECR_N(cuckoo_metrics, item_data_curr, item_datalen(it));               \
 } while(0)
 
+static cc_declare_itt_function(cuckoo_malloc);
+static cc_declare_itt_function(cuckoo_free);
+
 static inline uint32_t vlen(struct val *val)
 {
     if (val->type == VAL_TYPE_INT) {
@@ -296,14 +294,9 @@ cuckoo_setup(cuckoo_options_st *options, cuckoo_metrics_st *metrics)
     }
     ds = datapool_addr(pool);
 
-#if CC_ITT
-    cuckoo_malloc = __itt_heap_function_create("cuckoo_malloc", "pelikan");
-    for(size_t n = 0; n < max_nitem; ++n) {
-        __itt_heap_allocate_begin(cuckoo_malloc, item_size, 0);
-        void *it = OFFSET2ITEM(n);
-        __itt_heap_allocate_end(cuckoo_malloc, &it, item_size, 0);
-    }
-#endif
+    cc_create_itt_malloc(cuckoo_malloc);
+    cc_create_itt_free(cuckoo_free);
+
     cuckoo_init = true;
 }
 
@@ -408,6 +401,7 @@ cuckoo_insert(struct bstring *key, struct val *val, proc_time_i expire)
     item_set(it, key, val, expire);
     INCR(cuckoo_metrics, item_insert);
     ITEM_METRICS_INCR(it);
+    cc_itt_alloc(cuckoo_malloc, it, item_size);
 
     return it;
 }
@@ -451,6 +445,7 @@ cuckoo_delete(struct bstring *key)
         ITEM_METRICS_DECR(it);
         item_delete(it);
         log_verb("deleting item at location %p", it);
+        cc_itt_free(cuckoo_free, it);
 
         return true;
     } else {