cct_insert_backtrace.c

Go to the documentation of this file.

// -*-Mode: C++;-*- // technically C99

// * BeginRiceCopyright *****************************************************
//
// $HeadURL$
// $Id$
//
// --------------------------------------------------------------------------
// Part of HPCToolkit (hpctoolkit.org)
//
// Information about sources of support for research and development of
// HPCToolkit is at 'hpctoolkit.org' and in 'README.Acknowledgments'.
// --------------------------------------------------------------------------
//
// Copyright ((c)) 2002-2019, Rice University
// 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 Rice University (RICE) 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 RICE 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 RICE 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.
//
// ******************************************************* EndRiceCopyright *

#include <stdint.h>
#include <stdbool.h>
#include <ucontext.h>

#include <cct/cct_bundle.h>
#include <cct/cct.h>
#include <messages/messages.h>
#include <hpcrun/metrics.h>
// #include <hpcrun/unresolved.h>

#include <lib/prof-lean/lush/lush-support.h>
#include <lib/prof-lean/placeholders.h>
#include <lush/lush-backtrace.h>
#include <thread_data.h>
#include <hpcrun_stats.h>
#include <trace.h>
#include <trampoline/common/trampoline.h>
#include <utilities/ip-normalized.h>
#include "frame.h"
#include <unwind/common/backtrace_info.h>
#include <unwind/common/fence_enum.h>
#include "cct_insert_backtrace.h"
#include "cct_backtrace_finalize.h"


//--------------------------------------------------------------------------
// forward declaration
//--------------------------------------------------------------------------

static cct_node_t*
help_hpcrun_backtrace2cct(cct_bundle_t* cct, ucontext_t* context,
        int metricId, hpcrun_metricVal_t metricIncr,
        int skipInner, int isSync, struct cct_custom_update_s *custom_update);


//
// Misc externals (not in an include file)
//
extern bool hpcrun_inbounds_main(void* addr);

//--------------------------------------------------------------------------
// local variables
//--------------------------------------------------------------------------
// local variable records the on/off state of
// special recursive compression:
static bool retain_recursion = false;


//--------------------------------------------------------------------------
// Implementation
//--------------------------------------------------------------------------

static cct_node_t*
cct_insert_raw_backtrace(cct_node_t* cct,
                            frame_t* path_beg, frame_t* path_end)
{
  TMSG(BT_INSERT, "%s : start", __func__);
  if (!cct) return NULL; // nowhere to insert

#if 0
  if (path_beg < path_end) { // null backtrace 
     return cct_backtrace_null_handler(cct);
  }
#endif

  ip_normalized_t parent_routine = ip_normalized_NULL;
  for(; path_beg >= path_end; path_beg--){
    if ( (! retain_recursion) &&
         (path_beg >= path_end + 1) && 
         ip_normalized_eq(&(path_beg->the_function), &(parent_routine)) &&
         ip_normalized_eq(&(path_beg->the_function), &((path_beg-1)->the_function))) { 
      TMSG(REC_COMPRESS, "recursive routine compression!");
    }
    else {
      cct_addr_t tmp = 
        (cct_addr_t) {.as_info = path_beg->as_info, 
                      .ip_norm = path_beg->ip_norm, 
                      .lip = path_beg->lip};
      TMSG(BT_INSERT, "inserting addr (%d, %p)", tmp.ip_norm.lm_id, tmp.ip_norm.lm_ip);
      cct = hpcrun_cct_insert_addr(cct, &tmp);
    }
    parent_routine = path_beg->the_function;
  }
  hpcrun_cct_terminate_path(cct);
  return cct;
}


//
// 
void
hpcrun_set_retain_recursion_mode(bool mode)
{
  TMSG(REC_COMPRESS, "retain_recursion set to %s", mode ? "true" : "false");
  retain_recursion = mode;
}


// See usage in header.
cct_node_t*
hpcrun_cct_insert_backtrace(cct_node_t* treenode, frame_t* path_beg, frame_t* path_end)
{
  TMSG(FENCE, "insert backtrace into treenode %p", treenode);
  TMSG(FENCE, "backtrace below");
  bool bt_ins = ENABLED(BT_INSERT);
  if (ENABLED(FENCE)) {
    ENABLE(BT_INSERT);
  }

  cct_node_t* path = cct_insert_raw_backtrace(treenode, path_beg, path_end);
  if (! bt_ins) DISABLE(BT_INSERT);

  // Put lush as_info class correction here

  // N.B. If 'frm' is a 1-to-1 bichord and 'path' is not (i.e., 'path'
  // is M-to-1 or 1-to-M), then update the association of 'path' to
  // reflect that 'path' is now a proxy for two bichord types (1-to-1
  // and M-to-1 or 1-to-M)

  cct_addr_t* addr = hpcrun_cct_addr(path);

  lush_assoc_t as_frm = lush_assoc_info__get_assoc(path_beg->as_info);
  lush_assoc_t as_path = lush_assoc_info__get_assoc(addr->as_info);

  if (as_frm == LUSH_ASSOC_1_to_1 && as_path != LUSH_ASSOC_1_to_1) {
    // INVARIANT: path->as_info should be either M-to-1 or 1-to-M
    lush_assoc_info__set_assoc(hpcrun_cct_addr(path)->as_info, LUSH_ASSOC_1_to_1);
  }
  return path;
}



// See usage in header.
cct_node_t*
hpcrun_cct_insert_backtrace_w_metric(cct_bundle_t* cct, cct_node_t* treenode,
                                     int metric_id,
                                     frame_t* path_beg, frame_t* path_end,
                                     cct_metric_data_t datum, 
                                     struct cct_custom_update_s *custom_update)
{
  // user-custom cct before official backtrace
  if (custom_update != NULL && custom_update->update_before_fn != NULL) {
    treenode = custom_update->update_before_fn(cct, treenode, custom_update->data_aux);
  }

  // the official backtrace insertion
  cct_node_t* path = hpcrun_cct_insert_backtrace(treenode, path_beg, path_end);

  // user-custom cct after the official backtrace
  if (custom_update != NULL && custom_update->update_after_fn != NULL) {
    path = custom_update->update_after_fn(path, custom_update->data_aux);
  }

  metric_set_t* mset = hpcrun_reify_metric_set(path);

  metric_upd_proc_t* upd_proc = hpcrun_get_metric_proc(metric_id);
  if (upd_proc) {
    upd_proc(metric_id, mset, datum);
  }

  // POST-INVARIANT: metric set has been allocated for 'path'

  return path;
}

//
// Insert new backtrace in cct
//

cct_node_t*
hpcrun_cct_insert_bt(cct_node_t* node,
                     int metricId,
                     backtrace_t* bt,
                     cct_metric_data_t datum, void **trace_pc)
{
  return hpcrun_cct_insert_backtrace_w_metric(NULL, node, metricId,
                                              bt->beg + bt->len - 1,
                                              bt->beg, 
                                              datum, NULL);
}


//-----------------------------------------------------------------------------
// function: hpcrun_backtrace2cct
// purpose:
//     if successful, returns the leaf node representing the sample;
//     otherwise, returns NULL.
//-----------------------------------------------------------------------------

//
// TODO: one more flag:
//   backtrace needs to either:
//       IGNORE_TRAMPOLINE (usually, but not always called when isSync is true)
//       PLACE_TRAMPOLINE  (standard for normal async samples).
//             

cct_node_t*
hpcrun_backtrace2cct(cct_bundle_t* cct, ucontext_t* context,
                     int metricId, hpcrun_metricVal_t metricIncr,
                     int skipInner, int isSync, struct cct_custom_update_s *custom_update)
{
  cct_node_t* n = NULL;
  if (hpcrun_isLogicalUnwind()) {
    TMSG(LUSH,"lush backtrace2cct invoked");
    n = lush_backtrace2cct(cct, context, metricId, metricIncr, skipInner,
                           isSync);
  }
  else {
    TMSG(BT_INSERT,"regular (NON-lush) backtrace2cct invoked");
    n = help_hpcrun_backtrace2cct(cct, context,
                                  metricId, metricIncr,
                                  skipInner, isSync, custom_update);
  }

  // N.B.: for lush_backtrace() it may be that n = NULL

  return n;
}


cct_node_t*
hpcrun_cct_record_backtrace(
  cct_bundle_t* cct, 
  bool partial, 
  backtrace_info_t *bt,
  bool tramp_found
)
{
  TMSG(FENCE, "Recording backtrace");
  thread_data_t* td = hpcrun_get_thread_data();
  cct_node_t* cct_cursor = cct->tree_root;
  TMSG(FENCE, "Initially picking tree root = %p", cct_cursor);
  if (tramp_found) {
    // start insertion below caller's frame, which is marked with the trampoline
    cct_cursor = hpcrun_cct_parent(td->tramp_cct_node);
    TMSG(FENCE, "Tramp found ==> cursor = %p", cct_cursor);
  }
  if (partial) {
    cct_cursor = cct->partial_unw_root;
    TMSG(FENCE, "Partial unwind ==> cursor = %p", cct_cursor);
  }
  if (bt->fence == FENCE_THREAD) {
    cct_cursor = cct->thread_root;
    TMSG(FENCE, "Thread stop ==> cursor = %p", cct_cursor);
  }

#if 0
  // datacentric support: attach samples to data allocation cct
  cct_node_t *data_node = TD_GET(mem_data.data_node);
  if(data_node) {
    cct_node_t *prefix = hpcrun_cct_insert_path_return_leaf(data_node, cct_cursor);
    cct_cursor = prefix;
    TD_GET(mem_data.data_node) = NULL;
  }
#endif

  TMSG(FENCE, "sanity check cursor = %p", cct_cursor);
  TMSG(FENCE, "further sanity check: bt->last frame = (%d, %p)", 
       bt->last->ip_norm.lm_id, bt->last->ip_norm.lm_ip);

  return hpcrun_cct_insert_backtrace(cct_cursor, bt->last, bt->begin);

}


cct_node_t*
hpcrun_cct_record_backtrace_w_metric(cct_bundle_t* cct, bool partial, 
                                     backtrace_info_t *bt, bool tramp_found,
                                     int metricId, hpcrun_metricVal_t metricIncr,
                                     struct cct_custom_update_s *custom_update)
{
  TMSG(FENCE, "Recording backtrace");
  TMSG(BT_INSERT, "Record backtrace w metric to id %d, incr = %d", 
       metricId, metricIncr.i);

  thread_data_t* td = hpcrun_get_thread_data();
  cct_node_t* cct_cursor = cct->tree_root;
  TMSG(FENCE, "Initially picking tree root = %p", cct_cursor);
  if (tramp_found) {
    // start insertion below caller's frame, which is marked with the trampoline
    cct_cursor = hpcrun_cct_parent(td->tramp_cct_node);
    TMSG(FENCE, "Tramp found ==> cursor = %p", cct_cursor);
  }
  if (partial) {
    cct_cursor = cct->partial_unw_root;
    TMSG(FENCE, "Partial unwind ==> cursor = %p", cct_cursor);
  }
  if (bt->fence == FENCE_THREAD) {
    cct_cursor = cct->thread_root;
    TMSG(FENCE, "Thread stop ==> cursor = %p", cct_cursor);
  }

  cct_cursor = cct_cursor_finalize(cct, bt, cct_cursor);

  TMSG(FENCE, "sanity check cursor = %p", cct_cursor);
  TMSG(FENCE, "further sanity check: bt->last frame = (%d, %p)", 
       bt->last->ip_norm.lm_id, bt->last->ip_norm.lm_ip);

  return hpcrun_cct_insert_backtrace_w_metric(cct, cct_cursor, metricId,
                                              bt->last, bt->begin, 
                                              (cct_metric_data_t) metricIncr, 
                                              custom_update);

}


static cct_node_t*
help_hpcrun_backtrace2cct(cct_bundle_t* bundle, ucontext_t* context,
                          int metricId, 
                          hpcrun_metricVal_t metricIncr,
                          int skipInner, int isSync, 
                          struct cct_custom_update_s *custom_update)
{
  bool tramp_found;

  thread_data_t* td = hpcrun_get_thread_data();
  backtrace_info_t bt;

  bool success = hpcrun_generate_backtrace(&bt, context, skipInner);

  assert(!success == bt.partial_unwind);

  tramp_found = bt.has_tramp;

  //
  // Check to make sure node below monitor_main is "main" node
  //
  // TMSG(GENERIC1, "tmain chk");
  if (ENABLED(CHECK_MAIN)) {
    if ( bt.fence == FENCE_MAIN &&
         ! bt.partial_unwind &&
         ! tramp_found &&
         (bt.last == bt.begin || 
          ! hpcrun_inbounds_main(hpcrun_frame_get_unnorm(bt.last - 1)))) {
      hpcrun_bt_dump(TD_GET(btbuf_cur), "WRONG MAIN");
      hpcrun_stats_num_samples_dropped_inc();
      bt.partial_unwind = true;
    }
  }

 // bt.trace_pc = bt.begin->cursor.pc_unnorm;  // JMC

  cct_backtrace_finalize(&bt, isSync); 

  if (bt.partial_unwind) {
    if (ENABLED(NO_PARTIAL_UNW)){
      return NULL;
    }

    TMSG(PARTIAL_UNW, "recording partial unwind from graceful failure, "
         "len partial unw = %d", (bt.last - bt.begin)+1);
    hpcrun_stats_num_samples_partial_inc();
  }

  cct_node_t* n = 
    hpcrun_cct_record_backtrace_w_metric(bundle, bt.partial_unwind, &bt, 
                                         tramp_found, metricId, metricIncr, 
                                         custom_update);

  // *trace_pc = bt.trace_pc;  // JMC

  if (bt.n_trolls != 0) hpcrun_stats_trolled_inc();
  hpcrun_stats_frames_total_inc((long)(bt.last - bt.begin + 1));
  hpcrun_stats_trolled_frames_inc((long) bt.n_trolls);

  if (ENABLED(USE_TRAMP)){
    TMSG(TRAMP, "--NEW SAMPLE--: Remove old trampoline");
    hpcrun_trampoline_remove();
    td->tramp_frame = td->cached_bt;
    TMSG(TRAMP, "--NEW SAMPLE--: Insert new trampoline");
    hpcrun_trampoline_insert(n);
  }

  return n;
}