tracetools.h

Go to the documentation of this file.

#ifndef __TRACETOOLS_TRACETOOLS_H_
#define __TRACETOOLS_TRACETOOLS_H_

#include <boost/shared_ptr.hpp>
#include <boost/function.hpp>
#include <boost/version.hpp>
#include <stdint.h>
#include <string>
#include <typeinfo>

//#include "ros/callback_queue_interface.h"

namespace ros {
namespace trace {
  template<class P>
  const void* get_ptr(const boost::function<void (P)>& func_ptr) {
#if BOOST_VERSION < 106200
    return reinterpret_cast<void*>(func_ptr.functor.func_ptr);
#else
    return reinterpret_cast<void*>(func_ptr.functor.members.func_ptr);
#endif
  }

bool compile_status() throw();

void task_init(const char *task_name, const char *owner = NULL);
// emit a tracepoint giving the node name and its version
void node_init(const char *node_name, unsigned int roscpp_version);

void timer_added(const void *fun_ptr, const char *type_info, int period_sec,
                 int period_nsec);
void fn_name_info(const void *fun_ptr, const void *ref);

template <typename T>
void callback_wrapper(const void *func_ptr, const boost::shared_ptr<T> &helper) {
  fn_name_info(func_ptr, helper.get());
}

/*** Trace methods for callback queue processing */

void message_processed(const char *message_name, const void *callback_ref,
                       const uint32_t receipt_time_sec,
                       const uint32_t receipt_time_nsec);

void call_start(const void *ptr_ref, const void *data, const uint64_t trace_id);
void call_end(const void *ptr_ref, const void *data, const uint64_t trace_id);
void queue_delay(const char *queue_name, const void *ptr_ref, const void *data,
                 const uint32_t entry_time_sec, const uint32_t entry_time_nsec);

/******* Trace methods for subscription queue processing. ******/

void subscriber_call_start(const std::string &topic, const void *queue_ref,
                           const void *callback_ref, const void *message_ref,
                           int receipt_time_sec, int receipt_time_nsec);

void subscriber_call_end(const std::string &topic, const void *queue_ref,
                         const void *callback_ref, const void *message_ref,
                         int receipt_time_sec, int receipt_time_nsec);

/***** Timer-related tracing *****/

void timer_scheduled(const void *callback_ref, const void *timer_ref);
void time_sleep(const void *callback_ref, int sleep_sec, int sleep_nsec);

/****** Network-related tracing ******/

void new_connection(const char *local_hostport_arg,
                    const char *remote_hostport_arg,
                    const void *channel_ref_arg, const char *channel_type_arg,
                    const char *name_arg, const char *data_type_arg);
void publisher_link_handle_message(const void *channel_ref_arg,
                                   const void *buffer_ref_arg);
void subscriber_callback_added(const void *queue_ref_arg,
                               const void *callback_ref_arg,
                               const char *type_info_arg,
                               const char *data_type_arg,
                               const char *source_name_arg, int queue_size_arg);

void publisher_message_queued(const char *topic_arg,
                              const void *buffer_ref_arg);
void publisher_message_queued(const std::string &topic_arg,
                              const void *buffer_ref_arg);
void subscriber_link_message_write(const void *message_ref_arg,
                                   const void *channel_ref_arg);
void subscriber_link_message_dropped(const void *message_ref_arg);
void subscription_message_queued(const char *topic_arg,
                                 const void *buffer_ref_arg,
                                 const void *queue_ref_arg,
                                 const void *callback_ref_arg,
                                 const void *message_ref_arg,
                                 int receipt_time_sec_arg,
                                 int receipt_time_nsec_arg);
void subscription_message_dropped(const char *topic_arg, const void *buffer_arg,
                                  const void *queue_ref_arg,
                                  const void *callback_ref_arg,
                                  const void *message_ref_arg,
                                  int receipt_time_sec, int receipt_time_nsec);

void link_step(const char *element_name, const void *caller_name,
               const void *in_data_ref, const void *out_data_ref,
               const uint64_t trace_id);

// some helpers, not for public consumption
namespace impl {
template <typename T>
const void *getCallbackFunction(const boost::shared_ptr<T> &cb) {
  return cb.get();
}

std::string getCallbackInfo(const void *func_ptr, const char *name);

template <typename T>
std::string getCallbackInfo(const boost::shared_ptr<T> &cb) {
  return getCallbackInfo(cb.get(), typeid(*cb).name());
}
std::string get_backtrace(int index = -1);
std::string get_symbol(void *funptr);
}
}
}

#endif /* __TRACETOOLS_TRACETOOLS_H_ */