i#3048 drcachesim record funcs: infrastructure

clients/drcachesim/CMakeLists.txt

@@ -205,10 +205,13 @@ macro(add_drmemtrace name type)
     tracer/instru_offline.cpp
     tracer/instru_online.cpp
     tracer/physaddr.cpp
+    tracer/func_trace.cpp
     ${client_and_sim_srcs}
     )
   configure_DynamoRIO_client(${name})
   use_DynamoRIO_extension(${name} drmgr${ext_sfx})
+  use_DynamoRIO_extension(${name} drsyms${ext_sfx})
+  use_DynamoRIO_extension(${name} drwrap${ext_sfx})
   use_DynamoRIO_extension(${name} drreg${ext_sfx})
   use_DynamoRIO_extension(${name} drutil${ext_sfx})
   use_DynamoRIO_extension(${name} drx${ext_sfx})
@@ -430,6 +433,11 @@ if (BUILD_TESTS)
     use_DynamoRIO_extension(tool.drcacheoff.burst_replaceall drcontainers)
     use_DynamoRIO_drmemtrace_tracer(tool.drcacheoff.burst_replaceall)
 
+    add_executable(tool.drcacheoff.burst_malloc tests/burst_malloc.cpp)
+    configure_DynamoRIO_static(tool.drcacheoff.burst_malloc)
+    use_DynamoRIO_static_client(tool.drcacheoff.burst_malloc drmemtrace_static)
+    add_win32_flags(tool.drcacheoff.burst_malloc)
+
     add_executable(tool.drcacheoff.burst_threads tests/burst_threads.cpp)
     configure_DynamoRIO_static(tool.drcacheoff.burst_threads)
     use_DynamoRIO_static_client(tool.drcacheoff.burst_threads drmemtrace_static)

clients/drcachesim/common/options.cpp

@@ -333,3 +333,39 @@ droption_t<bool> op_reuse_verify_skip
  "Verifies every skip list-calculated reuse distance with a full list walk. "
  "This incurs significant additional overhead.  This option is only available "
  "in debug builds.");
+
+#define OP_RECORD_FUNC_ITEM_SEP "&"
+// XXX i#3048: replace function return address with function callstack
+// XXX i#3048: add a section to drcachesim.dox.in on function tracing
+droption_t<std::string> op_record_function
+(DROPTION_SCOPE_ALL, "record_function", DROPTION_FLAG_ACCUMULATE,
+ OP_RECORD_FUNC_ITEM_SEP, "",
+ "Record invocations trace for the specified function(s).",
+ "Record invocations trace for the specified function(s) in the option"
+ " value. Default value is empty. The value should fit this format:"
+ " function_name|function_id|func_args_num"
+ " (example: -record_function \"memset|10|3\"). The trace would contain"
+ " information for function return address, function argument value(s),"
+ " and function return value. We only record pointer-sized arguments and"
+ " return value. The trace is labeled with the function_id via an ID entry"
+ " prior to each set of value entries."
+ " Note that the provided function id should be unique, and not collide with"
+ " existing heap functions (see -record_heap_value ) if record_heap"
+ " option is enabled.");
+droption_t<bool> op_record_heap
+(DROPTION_SCOPE_ALL, "record_heap", false,
+ "Enable recording trace for the defined heap functions.",
+ "It is a convenient option to enable recording trace for the defined heap"
+ " functions in -record_heap_value. Specify this option is equivalent to"
+ " -record_function [heap_functions], where [heap_functions] is"
+ " the value in -record_heap_value.");
+droption_t<std::string> op_record_heap_value
+(DROPTION_SCOPE_ALL, "record_heap_value", DROPTION_FLAG_ACCUMULATE,
+ OP_RECORD_FUNC_ITEM_SEP,
+ "malloc|0|1" OP_RECORD_FUNC_ITEM_SEP "free|1|1" OP_RECORD_FUNC_ITEM_SEP
+ "tc_malloc|2|1" OP_RECORD_FUNC_ITEM_SEP "tc_free|3|1" OP_RECORD_FUNC_ITEM_SEP
+ "__libc_malloc|4|1" OP_RECORD_FUNC_ITEM_SEP "__libc_free|5|1",
+ " The actual value of the defined heap functions.",
+ " The actual value of the defined heap functions. Value should fit the same"
+ " format required by -record_function. These functions will not"
+ " be traced unless -record_heap is specified.");

clients/drcachesim/common/options.h

@@ -110,4 +110,7 @@ extern droption_t<unsigned int> op_reuse_distance_threshold;
 extern droption_t<bool> op_reuse_distance_histogram;
 extern droption_t<unsigned int> op_reuse_skip_dist;
 extern droption_t<bool> op_reuse_verify_skip;
+extern droption_t<std::string> op_record_function;
+extern droption_t<bool> op_record_heap;
+extern droption_t<std::string> op_record_heap_value;
 #endif /* _OPTIONS_H_ */

clients/drcachesim/common/trace_entry.h

@@ -191,6 +191,35 @@ typedef enum {
      */
     TRACE_MARKER_TYPE_CPU_ID,
 
+    /**
+     * The marker value contains function id defined by the user in droption.
+     */
+    TRACE_MARKER_TYPE_FUNC_ID,
+
+    // XXX i#3048: replace return address with callstack information.
+    /**
+     * The marker value contains the return address of the function call,
+     * whose id is specified by the closest previous
+     * marker entry.
+     */
+    TRACE_MARKER_TYPE_FUNC_RETADDR,
+
+    /**
+     * The marker value contains one argument value of the function call,
+     * whose id is specified by the closest previous #TRACE_MARKER_TYPE_FUNC_ID
+     * marker entry. The number of such entries for one function invocation is
+     * expected to be equal to the specified arugment in -record_function or
+     * pre-defined functions in -record_heap (if enabled).
+     */
+    TRACE_MARKER_TYPE_FUNC_ARG,
+
+    /**
+     * The marker value contains return value of the function call,
+     * whose id is specified by the closest previous #TRACE_MARKER_TYPE_FUNC_ID
+     * marker entry
+     */
+    TRACE_MARKER_TYPE_FUNC_RETVAL,
+
     // ...
     // These values are reserved for future built-in marker types.
     // ...

clients/drcachesim/tests/basic_counts.templatex

@@ -32,6 +32,10 @@ Total counts:
 #else
           13 total transfer markers
 #endif
+     .* total function id markers
+     .* total function return address markers
+     .* total function argument markers
+     .* total function return value markers
            0 total other markers
 Thread .* counts:
      .* \(fetched\) instructions
@@ -45,4 +49,8 @@ Thread .* counts:
 #else
           13 transfer markers
 #endif
+     .* function id markers
+     .* function return address markers
+     .* function argument markers
+     .* function return value markers
            0 other markers

clients/drcachesim/tests/burst_malloc.cpp

@@ -0,0 +1,126 @@
+/* **********************************************************
+ * Copyright (c) 2016-2017 Google, Inc.  All rights reserved.
+ * **********************************************************/
+
+/*
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Google, Inc. nor the names of its contributors may be
+ *   used to endorse or promote products derived from this software without
+ *   specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL GOOGLE, INC. OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+/* This application links in drmemtrace_static and acquires a trace during
+ * a "burst" of execution and memory allocations (malloc() and free())
+ * in the middle of the application. It then detaches. Later it re-attaches
+ * and detaches again for several times.
+ */
+
+/* Like burst_static we deliberately do not include configure.h here */
+
+#include "dr_api.h"
+#include <assert.h>
+#include <iostream>
+#include <math.h>
+#include <stdlib.h>
+
+bool
+my_setenv(const char *var, const char *value)
+{
+#ifdef UNIX
+    return setenv(var, value, 1/*override*/) == 0;
+#else
+    return SetEnvironmentVariable(var, value) == TRUE;
+#endif
+}
+
+static int
+do_some_work(int arg)
+{
+    static const int iters = 1000;
+    static double *vals[iters];
+
+    double val = (double)arg;
+    for (int i = 0; i < iters; ++i) {
+        vals[i] = (double *)malloc(sizeof(double));
+        *vals[i] = sin(val);
+        val += *vals[i];
+    }
+    for (int i = 0; i < iters; i++) {
+        val += *vals[i];
+    }
+    for (int i = 0; i < iters; i++) {
+        free(vals[i]);
+    }
+    return (val > 0);
+}
+
+int
+main(int argc, const char *argv[])
+{
+    /* We also test -rstats_to_stderr */
+    if (!my_setenv("DYNAMORIO_OPTIONS", "-stderr_mask 0xc -rstats_to_stderr"
+                   " -client_lib ';;-offline -record_heap"
+                   " -record_function \"malloc|0|1\"'"))
+        std::cerr << "failed to set env var!\n";
+
+    for (int i = 0; i < 3; i++) {
+        std::cerr << "pre-DR init\n";
+        dr_app_setup();
+        assert(!dr_app_running_under_dynamorio());
+
+        std::cerr << "pre-DR start\n";
+        if (do_some_work(i * 1) < 0)
+            std::cerr << "error in computation\n";
+
+        dr_app_start();
+        if (do_some_work(i * 2) < 0)
+            std::cerr << "error in computation\n";
+        std::cerr << "pre-DR detach\n";
+        dr_app_stop_and_cleanup();
+
+        if (do_some_work(i * 3) < 0)
+            std::cerr << "error in computation\n";
+        std::cerr << "all done\n";
+    }
+
+    return 0;
+}
+
+#if defined(UNIX) && defined(TEST_APP_DR_CLIENT_MAIN)
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/* This dr_client_main should be called instead of the one in tracer.cpp */
+DR_EXPORT void
+dr_client_main(client_id_t id, int argc, const char *argv[])
+{
+    std::cerr << "app dr_client_main\n";
+    drmemtrace_client_main(id, argc, argv);
+}
+
+# ifdef __cplusplus
+}
+# endif
+#endif  /* UNIX && TEST_APP_DR_CLIENT_MAIN */

clients/drcachesim/tests/offline-basic_counts.templatex

@@ -31,6 +31,10 @@ Total counts:
 #else
           13 total transfer markers
 #endif
+     .* total function id markers
+     .* total function return address markers
+     .* total function argument markers
+     .* total function return value markers
            0 total other markers
 Thread .* counts:
      .* \(fetched\) instructions
@@ -44,4 +48,8 @@ Thread .* counts:
 #else
           13 transfer markers
 #endif
+     .* function id markers
+     .* function return address markers
+     .* function argument markers
+     .* function return value markers
            0 other markers

clients/drcachesim/tests/offline-burst_malloc.templatex

@@ -0,0 +1,14 @@
+pre-DR init
+Warning: duplicated function id .*
+.*
+pre-DR start
+pre-DR detach
+DynamoRIO statistics:
+ *Peak threads under DynamoRIO control : *1
+.*
+all done
+.*
+.* 4000 function id markers.*
+.* 2000 function return address markers.*
+.* 2000 function argument markers.*
+.* 2000 function return value markers.*

clients/drcachesim/tests/offline-burst_threadL0filter.templatex

@@ -21,4 +21,8 @@ Total counts:
            4 total threads
     *[0-9]* total scheduling markers
     *[0-9]* total transfer markers
+           0 total function id markers
+           0 total function return address markers
+           0 total function argument markers
+           0 total function return value markers
            0 total other markers

clients/drcachesim/tests/offline-burst_threadfilter.templatex

@@ -21,5 +21,9 @@ Total counts:
            4 total threads
     *[0-9]* total scheduling markers
     *[0-9]* total transfer markers
+           0 total function id markers
+           0 total function return address markers
+           0 total function argument markers
+           0 total function return value markers
            0 total other markers
 .*

clients/drcachesim/tools/basic_counts.cpp

@@ -49,6 +49,8 @@ basic_counts_tool_create(unsigned int verbose)
 basic_counts_t::basic_counts_t(unsigned int verbose) :
     total_threads(0), total_instrs(0), total_instrs_nofetch(0), total_prefetches(0),
     total_loads(0), total_stores(0), total_sched_markers(0), total_xfer_markers(0),
+    total_func_id_markers(0), total_func_retaddr_markers(0),
+    total_func_arg_markers(0), total_func_retval_markers(0),
     total_other_markers(0), knob_verbose(verbose)
 {
     // Empty.
@@ -87,8 +89,28 @@ basic_counts_t::process_memref(const memref_t &memref)
           ++thread_xfer_markers[memref.data.tid];
           ++total_xfer_markers;
       } else {
-          ++thread_other_markers[memref.data.tid];
-          ++total_other_markers;
+          switch(memref.marker.marker_type) {
+            case TRACE_MARKER_TYPE_FUNC_ID:
+              ++total_func_id_markers;
+              ++thread_func_id_markers[memref.data.tid];
+              break;
+            case TRACE_MARKER_TYPE_FUNC_RETADDR:
+              ++total_func_retaddr_markers;
+              ++thread_func_retaddr_markers[memref.data.tid];
+              break;
+            case TRACE_MARKER_TYPE_FUNC_ARG:
+              ++total_func_arg_markers;
+              ++thread_func_arg_markers[memref.data.tid];
+              break;
+            case TRACE_MARKER_TYPE_FUNC_RETVAL:
+              ++total_func_retval_markers;
+              ++thread_func_retval_markers[memref.data.tid];
+              break;
+            default:
+              ++thread_other_markers[memref.data.tid];
+              ++total_other_markers;
+              break;
+          }
       }
   } else if (memref.exit.type == TRACE_TYPE_THREAD_EXIT) {
       ++total_threads;
@@ -116,6 +138,14 @@ basic_counts_t::print_results() {
     std::cerr << std::setw(12) << total_threads << " total threads\n";
     std::cerr << std::setw(12) << total_sched_markers << " total scheduling markers\n";
     std::cerr << std::setw(12) << total_xfer_markers << " total transfer markers\n";
+    std::cerr << std::setw(12) << total_func_id_markers <<
+                 " total function id markers\n";
+    std::cerr << std::setw(12) << total_func_retaddr_markers <<
+                 " total function return address markers\n";
+    std::cerr << std::setw(12) << total_func_arg_markers <<
+                 " total function argument markers\n";
+    std::cerr << std::setw(12) << total_func_retval_markers <<
+                 " total function return value markers\n";
     std::cerr << std::setw(12) << total_other_markers << " total other markers\n";
 
     // Print the threads sorted by instrs.
@@ -134,6 +164,14 @@ basic_counts_t::print_results() {
         std::cerr << std::setw(12) << thread_sched_markers[tid] <<
             " scheduling markers\n";
         std::cerr << std::setw(12) << thread_xfer_markers[tid] << " transfer markers\n";
+        std::cerr << std::setw(12) << thread_func_id_markers[tid] <<
+                     " function id markers\n";
+        std::cerr << std::setw(12) << thread_func_retaddr_markers[tid] <<
+                     " function return address markers\n";
+        std::cerr << std::setw(12) << thread_func_arg_markers[tid] <<
+                     " function argument markers\n";
+        std::cerr << std::setw(12) << thread_func_retval_markers[tid] <<
+                     " function return value markers\n";
         std::cerr << std::setw(12) << thread_other_markers[tid] << " other markers\n";
     }
     return true;