i#6751 trace_entry_t: pretty printer

clients/drcachesim/CMakeLists.txt

@@ -165,13 +165,15 @@ add_exported_library(drmemtrace_opcode_mix STATIC tools/opcode_mix.cpp)
 add_exported_library(drmemtrace_syscall_mix STATIC tools/syscall_mix.cpp)
 add_exported_library(drmemtrace_view STATIC tools/view.cpp)
 add_exported_library(drmemtrace_func_view STATIC tools/func_view.cpp)
+add_exported_library(drmemtrace_record_view STATIC tools/record_view.cpp)
 add_exported_library(drmemtrace_invariant_checker STATIC tools/invariant_checker.cpp)
 add_exported_library(drmemtrace_schedule_stats STATIC tools/schedule_stats.cpp)
 
 target_link_libraries(drmemtrace_invariant_checker drdecode)
 
 configure_DynamoRIO_standalone(drmemtrace_opcode_mix)
 configure_DynamoRIO_standalone(drmemtrace_view)
+configure_DynamoRIO_standalone(drmemtrace_record_view)
 configure_DynamoRIO_standalone(drmemtrace_invariant_checker)
 
 # We combine the cache and TLB simulators as they share code already.
@@ -276,8 +278,8 @@ configure_DynamoRIO_standalone(drcachesim)
 target_link_libraries(drcachesim drmemtrace_simulator drmemtrace_reuse_distance
   drmemtrace_histogram drmemtrace_reuse_time drmemtrace_basic_counts
   drmemtrace_opcode_mix drmemtrace_syscall_mix drmemtrace_view drmemtrace_func_view
-  drmemtrace_raw2trace directory_iterator drmemtrace_invariant_checker
-  drmemtrace_schedule_stats drmemtrace_record_filter)
+  drmemtrace_record_view drmemtrace_raw2trace directory_iterator
+  drmemtrace_invariant_checker drmemtrace_schedule_stats drmemtrace_record_filter)
 if (UNIX)
     target_link_libraries(drcachesim dl)
 endif ()
@@ -357,6 +359,7 @@ install_client_nonDR_header(drmemtrace simulator/cache_simulator_create.h)
 install_client_nonDR_header(drmemtrace simulator/tlb_simulator_create.h)
 install_client_nonDR_header(drmemtrace tools/view_create.h)
 install_client_nonDR_header(drmemtrace tools/func_view_create.h)
+install_client_nonDR_header(drmemtrace tools/record_view_create.h)
 # TODO i#6412: Create a separate directory for non-tracer headers so that
 # we can more cleanly separate tracer and raw2trace code.
 install_client_nonDR_header(drmemtrace tracer/raw2trace.h)
@@ -578,6 +581,7 @@ restore_nonclient_flags(drmemtrace_opcode_mix)
 restore_nonclient_flags(drmemtrace_syscall_mix)
 restore_nonclient_flags(drmemtrace_view)
 restore_nonclient_flags(drmemtrace_func_view)
+restore_nonclient_flags(drmemtrace_record_view)
 restore_nonclient_flags(drmemtrace_record_filter)
 restore_nonclient_flags(drmemtrace_analyzer)
 restore_nonclient_flags(drmemtrace_invariant_checker)
@@ -644,6 +648,7 @@ add_win32_flags(drmemtrace_opcode_mix)
 add_win32_flags(drmemtrace_syscall_mix)
 add_win32_flags(drmemtrace_view)
 add_win32_flags(drmemtrace_func_view)
+add_win32_flags(drmemtrace_record_view)
 add_win32_flags(drmemtrace_record_filter)
 add_win32_flags(drmemtrace_analyzer)
 add_win32_flags(drmemtrace_invariant_checker)
@@ -821,8 +826,9 @@ if (BUILD_TESTS)
     drmemtrace_raw2trace drmemtrace_simulator drmemtrace_reuse_distance
     drmemtrace_histogram drmemtrace_reuse_time drmemtrace_basic_counts
     drmemtrace_opcode_mix drmemtrace_syscall_mix drmemtrace_view drmemtrace_func_view
-    drmemtrace_raw2trace directory_iterator drmemtrace_invariant_checker
-    drmemtrace_schedule_stats drmemtrace_analyzer drmemtrace_record_filter)
+    drmemtrace_record_view drmemtrace_raw2trace directory_iterator
+    drmemtrace_invariant_checker drmemtrace_schedule_stats drmemtrace_analyzer
+    drmemtrace_record_filter)
   if (UNIX)
     target_link_libraries(tool.drcachesim.core_sharded dl)
   endif ()

clients/drcachesim/analyzer_multi.cpp

@@ -64,6 +64,7 @@
 #include "tools/reuse_distance_create.h"
 #include "tools/reuse_time_create.h"
 #include "tools/view_create.h"
+#include "tools/record_view_create.h"
 #include "tools/loader/external_config_file.h"
 #include "tools/loader/external_tool_creator.h"
 #include "tools/filter/record_filter_create.h"
@@ -335,6 +336,8 @@ record_analyzer_multi_t::create_analysis_tool_from_options(
             op_filter_cache_size.get_value(), op_filter_trace_types.get_value(),
             op_filter_marker_types.get_value(), op_trim_before_timestamp.get_value(),
             op_trim_after_timestamp.get_value(), op_verbose.get_value());
+    } else if (simulator_type == RECORD_VIEW) {
+        return record_view_tool_create(op_sim_refs.get_value());
     }
     ERRMSG("Usage error: unsupported record analyzer type \"%s\".  Only " RECORD_FILTER
            " is supported.\n",

clients/drcachesim/common/options.h

@@ -49,6 +49,7 @@
 #define SYSCALL_MIX "syscall_mix"
 #define VIEW "view"
 #define FUNC_VIEW "func_view"
+#define RECORD_VIEW "record_view"
 #define INVARIANT_CHECKER "invariant_checker"
 #define SCHEDULE_STATS "schedule_stats"
 #define RECORD_FILTER "record_filter"

clients/drcachesim/common/trace_entry.cpp

@@ -88,5 +88,55 @@ const char *const trace_type_names[] = {
     "untaken_jump",
 };
 
+const char *const trace_version_names[] = {
+    "<unknown>",
+    "<unknown>",
+    "trace_entry_version_no_kernel_pc",
+    "trace_entry_version_kernel_pc",
+    "trace_entry_version_encodings",
+    "trace_entry_version_branch_info",
+    "trace_entry_version_frequent_timestamps",
+};
+
+const char *const trace_marker_names[] = {
+    "trace_marker_type_kernel_event",
+    "trace_marker_type_kernel_xfer",
+    "trace_marker_type_timestamp",
+    "trace_marker_type_cpu_id",
+    "trace_marker_type_func_id",
+    "trace_marker_type_func_retaddr",
+    "trace_marker_type_func_arg",
+    "trace_marker_type_func_retval",
+    "trace_marker_type_split_value",
+    "trace_marker_type_filetype",
+    "trace_marker_type_cache_line_size",
+    "trace_marker_type_instruction_count",
+    "trace_marker_type_version",
+    "trace_marker_type_rseq_abort",
+    "trace_marker_type_window_id",
+    "trace_marker_type_physical_address",
+    "trace_marker_type_physical_address_not_available",
+    "trace_marker_type_virtual_address",
+    "trace_marker_type_page_size",
+    "trace_marker_type_syscall_idx",
+    "trace_marker_type_chunk_instr_count",
+    "trace_marker_type_chunk_footer",
+    "trace_marker_type_record_ordinal",
+    "trace_marker_type_filter_endpoint",
+    "trace_marker_type_rseq_entry",
+    "trace_marker_type_syscall",
+    "trace_marker_type_maybe_blocking_syscall",
+    "trace_marker_type_syscall_trace_start",
+    "trace_marker_type_syscall_trace_end",
+    "trace_marker_type_branch_target",
+    "trace_marker_type_syscall_failed",
+    "trace_marker_type_direct_thread_switch",
+    "trace_marker_type_core_wait",
+    "trace_marker_type_core_idle",
+    "trace_marker_type_context_switch_start",
+    "trace_marker_type_context_switch_end",
+    "trace_marker_type_vector_length",
+};
+
 } // namespace drmemtrace
 } // namespace dynamorio

clients/drcachesim/common/trace_entry.h

@@ -652,6 +652,8 @@ enum class func_trace_t : uint64_t { // VS2019 won't infer 64-bit with "enum {".
 };
 
 extern const char *const trace_type_names[];
+extern const char *const trace_version_names[];
+extern const char *const trace_marker_names[];
 
 /**
  * Returns whether the type represents an instruction fetch.

clients/drcachesim/launcher.cpp

@@ -323,7 +323,8 @@ _tmain(int argc, const TCHAR *targv[])
             FATAL_ERROR("invalid -outdir %s", op_outdir.get_value().c_str());
         }
     } else {
-        if (op_simulator_type.get_value() == RECORD_FILTER) {
+        if (op_simulator_type.get_value() == RECORD_FILTER ||
+            op_simulator_type.get_value() == RECORD_VIEW) {
             record_analyzer = new record_analyzer_multi_t;
             if (!*record_analyzer) {
                 std::string error_string_ = record_analyzer->get_error_string();

clients/drcachesim/tools/record_view.cpp

@@ -0,0 +1,215 @@
+/* **********************************************************
+ * Copyright (c) 2024 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 VMWARE, 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.
+ */
+
+#include "record_view.h"
+
+#include <cstdio>
+#include <inttypes.h>
+#include <iostream>
+#include <stdint.h>
+#include <string>
+
+#include "memtrace_stream.h"
+#include "trace_entry.h"
+
+namespace dynamorio {
+namespace drmemtrace {
+
+typedef unsigned int uint;
+
+record_analysis_tool_t *
+record_view_tool_create(uint64_t sim_refs)
+{
+    return new dynamorio::drmemtrace::record_view_t(sim_refs);
+}
+
+record_view_t::record_view_t(uint64_t sim_refs)
+    : sim_refs_(sim_refs)
+{
+}
+
+record_view_t::~record_view_t()
+{
+}
+
+bool
+record_view_t::should_skip(void)
+{
+    if (sim_refs_ > 0) {
+        --sim_refs_;
+        return false;
+    }
+    return true;
+}
+
+bool
+record_view_t::parallel_shard_supported()
+{
+    return false;
+}
+
+std::string
+record_view_t::initialize_shard_type(shard_type_t shard_type)
+{
+    return "";
+}
+
+void *
+record_view_t::parallel_shard_init_stream(int shard_index, void *worker_data,
+                                          memtrace_stream_t *shard_stream)
+{
+    return shard_stream;
+}
+
+bool
+record_view_t::parallel_shard_exit(void *shard_data)
+{
+    return true;
+}
+
+std::string
+record_view_t::parallel_shard_error(void *shard_data)
+{
+    return "";
+}
+
+bool
+record_view_t::parallel_shard_memref(void *shard_data, const trace_entry_t &entry)
+{
+    if (should_skip())
+        return true;
+
+    trace_type_t trace_type = (trace_type_t)entry.type;
+    if (trace_type == TRACE_TYPE_INVALID) {
+        std::cerr << "ERROR: trace_entry_t invalid.\n";
+        return false;
+    }
+
+    std::string trace_type_name = std::string(trace_type_names[trace_type]);
+
+    /* Large if-else for all TRACE_TYPE_.  Prints one line per trace_entry_t.
+     * In some cases we use some helper functions (e.g., type_is_instr()), which group
+     * similar TRACE_TYPE_ together, otherwise we compare trace_type against one or two
+     * specific TRACE_TYPE_ directly.
+     */
+    if (trace_type == TRACE_TYPE_HEADER) {
+        trace_version_t trace_version = (trace_version_t)entry.addr;
+        std::string trace_version_name = std::string(trace_version_names[trace_version]);
+        std::cerr << trace_type_name << ", trace_version: " << trace_version_name << "\n";
+    } else if (trace_type == TRACE_TYPE_FOOTER) {
+        std::cerr << trace_type_name << "\n";
+    } else if ((trace_type == TRACE_TYPE_THREAD) ||
+               (trace_type == TRACE_TYPE_THREAD_EXIT)) {
+        uint tid = (uint)entry.addr;
+        std::cerr << trace_type_name << ", tid: " << tid << "\n";
+    } else if (trace_type == TRACE_TYPE_PID) {
+        uint pid = (uint)entry.addr;
+        std::cerr << trace_type_name << ", pid: " << pid << "\n";
+    } else if (trace_type == TRACE_TYPE_MARKER) {
+        /* XXX i#6751: we have a lot of different types of markers; we should use some
+         * kind of dispatching mechanism to print a more informative output for each of
+         * them.  For now we do so only for a few markers here.
+         */
+        trace_marker_type_t trace_marker_type = (trace_marker_type_t)entry.size;
+        std::string trace_marker_name =
+            std::string(trace_marker_names[trace_marker_type]);
+        addr_t trace_marker_value = entry.addr;
+        if (trace_marker_type == TRACE_MARKER_TYPE_FILETYPE) {
+            std::string file_type =
+                std::string(trace_arch_string((offline_file_type_t)trace_marker_value));
+            std::cerr << trace_type_name << ", trace_marker_type: " << trace_marker_name
+                      << ", trace_marker_value: " << file_type << "\n";
+        } else if (trace_marker_type == TRACE_MARKER_TYPE_VERSION) {
+            trace_version_t trace_version = (trace_version_t)entry.addr;
+            std::string trace_version_name =
+                std::string(trace_version_names[trace_version]);
+            std::cerr << trace_type_name << ", trace_marker_type: " << trace_marker_name
+                      << ", trace_marker_value: " << trace_version_name << "\n";
+        } else { // For all remaining markers we print their value in hex.
+            std::cerr << trace_type_name << ", trace_marker_type: " << trace_marker_name
+                      << ", trace_marker_value: 0x" << std::hex << trace_marker_value
+                      << std::dec << "\n";
+        }
+    } else if (trace_type == TRACE_TYPE_ENCODING) {
+        unsigned short num_encoding_bytes = entry.size;
+        std::cerr << trace_type_name << ", num_encoding_bytes: " << num_encoding_bytes
+                  << ", encoding_bytes: 0x" << std::hex;
+        /* Print encoding byte by byte (little-endian).
+         */
+        for (int i = num_encoding_bytes - 1; i >= 0; --i) {
+            uint encoding_byte = static_cast<uint>(entry.encoding[i]);
+            std::cerr << encoding_byte;
+        }
+        std::cerr << std::dec << "\n";
+    } else if (trace_type == TRACE_TYPE_INSTR_BUNDLE) {
+        unsigned short num_instructions_in_bundle = entry.size;
+        std::cerr << trace_type_name
+                  << ", num_instructions_in_bundle: " << num_instructions_in_bundle
+                  << ", instrs_length:";
+        /* Print length of each instr in the bundle.
+         */
+        for (int i = 0; i < num_instructions_in_bundle; ++i) {
+            unsigned char instr_length = entry.length[i];
+            std::cerr << " " << instr_length;
+        }
+        std::cerr << "\n";
+    } else if (type_is_instr(trace_type)) {
+        unsigned short instr_length = entry.size;
+        addr_t pc = entry.addr;
+        std::cerr << trace_type_name << ", length: " << instr_length << ", pc: 0x"
+                  << std::hex << pc << std::dec << "\n";
+    } else if (type_has_address(trace_type)) { // Includes no-fetch, prefetch, and flush.
+        unsigned short memref_size = entry.size;
+        addr_t memref_addr = entry.addr;
+        std::cerr << trace_type_name << ", memref_size: " << memref_size
+                  << ", memref_addr: 0x" << std::hex << memref_addr << std::dec << "\n";
+    } else {
+        std::cerr << "ERROR: unrecognized trace_entry_t.\n";
+        return false;
+    }
+    return true;
+}
+
+bool
+record_view_t::process_memref(const trace_entry_t &entry)
+{
+    return parallel_shard_memref(NULL, entry);
+}
+
+bool
+record_view_t::print_results()
+{
+    return true;
+}
+
+} // namespace drmemtrace
+} // namespace dynamorio