AI/rocm-systems
2
0
Fork 0
Código Incidencias Pull Requests Acciones Paquetes Proyectos Lanzamientos Wiki Actividad
Files
145a6ae06fc76b985fd47b7884e8f428e8fe9996
rocm-systems/source/bin/omnitrace/details.cpp
T
Jonathan R. Madsen 145a6ae06f omnitrace-dl-library (#25) 
* timemory submodule update

* Visibility, setting categories, and task-group protection

- OMNITRACE_VISIBILITY instead of TIMEMORY_VISIBILITY
- increased task group data-race protection
- add omnitrace categories to settings

* set component_apis type-trait

* omnitrace-dl-library implementation

- this library dlopen + dlsym's libomnitrace
- significantly reduces the instrumentation time

* omnitrace-avail categories

- suppress AVAILABLE column when --available

* omnitrace-exe update

- uses omnitrace-dl
- adds --print-excluded option
- removes --jump option
- comments out --stubs option
- removes --stdlib option
- support for C++ STL functions not in libstdc++
- tweak the --print-* outputs
- significantly refactors instrument_module and instrument_entity
- removes unused c_stdlib_module_constraint
- removes unused c_stdlib_function_constraint
- decreases get_whole_function_names() coverage

* library.cpp updates

- OMNITRACE_DEBUG -> OMNITRACE_DEBUG_F
- omnitrace_finalize sets state earlier
- omnitrace_finalize clears push/pop functors
- increased tasking shutdown safety

* - fix critical-trace thread hierarchy
- signal handler calls omnitrace_finalize
- get_cpu_cid_stack supports parent tid
- interval data reserves
- omnitrace-avail serialization support for module_functions
- omnitrace --simulate option
- omnitrace --print-format option
- omnitrace --load-instr option
- omnitrace runtime-inst doesn't oneTimeCode
- updated regex
- expand get_whole_function_names()
- Test Install CI update

* fixes to last commit

- expand get_whole_function_names()
- ignore sig c modules
- kill process in signal handler

* Remove RTLD_DEEPBIND + more

- removed use of RTLD_DEEPBIND
  - causes dyninst segfaults
- fixed signal handling
- updated timemory submodule

* Build/link static timemory libraries

* omnitrace --{module,function}-restrict option

- Added restrict regex options
- Reworked handling of regex options
- Reworked reporting of module/function skipping
- Handle -o w/o file specified

* timemory-avail

- category views
- backtrace::sample checks state

* get_debug_sampling()
2022-02-23 06:59:32 -06:00

835 líneas
28 KiB
C++
Original Blame Histórico

// MIT License
//
// Copyright (c) 2022 Advanced Micro Devices, Inc. All Rights Reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#include "omnitrace.hpp"
static int expect_error = NO_ERROR;
static int error_print = 0;
// set of whole function names to exclude
strset_t
get_whole_function_names()
{
#if 1
return strset_t{ "sem_init",
"sem_destroy",
"sem_open",
"sem_close",
"sem_post",
"sem_wait",
"sem_getvalue",
"sem_clockwait",
"sem_timedwait",
"sem_trywait",
"do_futex_wait",
"sem_unlink",
"fork",
"dl_iterate_phdr",
"dlinfo",
"dlopen",
"dlmopen",
"dlvsym",
"dlsym",
"getenv",
"setenv",
"unsetenv",
"fflush",
"malloc",
"malloc_stats",
"malloc_trim",
"mallopt",
"calloc",
"free",
"pvalloc",
"valloc",
"mmap",
"munmap",
"fmemopen",
"fmemclose",
"backtrace",
"backtrace_symbols",
"backtrace_symbols_fd",
"sigaddset",
"sigandset",
"sigdelset",
"sigemptyset",
"sigfillset",
"sighold",
"sigisemptyset",
"sigismember",
"sigorset",
"sigrelse",
"sigvec" };
#else
// should hopefully be removed soon
return strset_t{ "a64l",
"advance",
"aio_return",
"aio_return64",
"argp_error",
"argp_failure",
"argp_help",
"argp_parse",
"argp_state_help",
"argp_usage",
"argz_add",
"argz_add_sep",
"argz_append",
"argz_count",
"argz_create",
"argz_create_sep",
"argz_delete",
"argz_extract",
"argz_insert",
"argz_next",
"argz_replace",
"argz_stringify",
"atexit",
"atof",
"atoi",
"atol",
"atoll",
"atomic_flag_clear_explicit",
"atomic_flag_test_and_set_explicit",
"authdes_create",
"authdes_getucred",
"authdes_pk_create",
"authnone_create",
"authunix_create",
"authunix_create_default",
"backtrace",
"backtrace_symbols",
"backtrace_symbols_fd",
"bindresvport",
"bindtextdomain",
"bind_textdomain_codeset",
"bsearch",
"btowc",
"c16rtomb",
"callrpc",
"canonicalize_file_name",
"catclose",
"catgets",
"catopen",
"cfmakeraw",
"cfsetspeed",
"chflags",
"clearerr",
"clearerr_unlocked",
"clnt_broadcast",
"clnt_create",
"clnt_pcreateerror",
"clnt_perrno",
"clnt_perror",
"clntraw_create",
"clnt_spcreateerror",
"clnt_sperrno",
"clnt_sperror",
"clnttcp_create",
"clntudp_bufcreate",
"clntudp_create",
"clntunix_create",
"confstr",
"daemon",
"des_setparity",
"div",
"dlopen",
"dlsym",
"dlerror",
"dladdr",
"dlinfo",
"dlvsym",
"dlmopen",
"dl_iterate_phdr",
"dysize",
"endutxent",
"envz_add",
"envz_entry",
"envz_get",
"envz_merge",
"envz_remove",
"envz_strip",
"ether_aton",
"ether_hostton",
"ether_line",
"ether_ntoa",
"ether_ntohost",
"execl",
"execle",
"execlp",
"execv",
"execvp",
"execvpe",
"explicit_bzero",
"fattach",
"fclose",
"fdetach",
"fdopen",
"feof_unlocked",
"ferror_unlocked",
"fflush",
"fflush_unlocked",
"fgetpos",
"fgets",
"fgets_unlocked",
"fgetws",
"fgetws_unlocked",
"_fini",
"fini",
"fmemopen",
"fopen",
"fopen64",
"fopencookie",
"fork",
"fork_alias",
"fork_compat",
"fputc_unlocked",
"fputs",
"fputs_unlocked",
"fputwc_unlocked",
"fputws",
"fputws_unlocked",
"fread",
"fread_unlocked",
"fsetpos",
"fsetpos64",
"ftell",
"fwrite",
"fwrite_unlocked",
"getdelim",
"getgrouplist",
"gethostbyname2",
"getmntent",
"getmsg",
"getnetname",
"getopt_long",
"getopt_long_only",
"getpmsg",
"getpublickey",
"gets",
"getsecretkey",
"glob_pattern_p",
"gnu_dev_major",
"gnu_dev_makedev",
"gnu_dev_minor",
"gnu_get_libc_release",
"gnu_get_libc_version",
"group_member",
"gtty",
"hcreate",
"hdestroy",
"herror",
"host2netname",
"hsearch",
"hstrerror",
"htons",
"iconv",
"iconv_close",
"iconv_open",
"inet6_opt_append",
"inet6_opt_find",
"inet6_opt_finish",
"inet6_opt_get_val",
"inet6_opt_init",
"inet6_option_alloc",
"inet6_option_append",
"inet6_option_find",
"inet6_option_init",
"inet6_option_next",
"inet6_option_space",
"inet6_opt_next",
"inet6_opt_set_val",
"inet6_rth_add",
"inet6_rth_getaddr",
"inet6_rth_init",
"inet6_rth_reverse",
"inet6_rth_segments",
"inet6_rth_space",
"inet_addr",
"inet_aton",
"inet_lnaof",
"inet_makeaddr",
"inet_netof",
"inet_network",
"inet_nsap_addr",
"inet_nsap_ntoa",
"inet_ntoa",
"inet_ntop",
"inet_pton",
"_init",
"init",
"initgroups",
"initstate",
"insque",
"iruserok",
"iruserok_af",
"key_decryptsession",
"key_decryptsession_pk",
"key_encryptsession",
"key_encryptsession_pk",
"key_gendes",
"key_get_conv",
"key_secretkey_is_set",
"key_setnet",
"key_setsecret",
"l64a",
"lchmod",
"lckpwdf",
"lfind",
"llabs",
"lldiv",
"localeconv",
"lockf",
"lsearch",
"mbrtoc16",
"mbrtoc32",
"mcheck",
"mcheck_check_all",
"mcheck_pedantic",
"mkdtemp",
"mkdtemp64",
"mkostemp",
"mkostemp64",
"mkostemps",
"mkostemps64",
"mkstemp",
"mkstemp64",
"mkstemps",
"mkstemps64",
"mktemp",
"mktemp64",
"moncontrol",
"monstartup",
"mprobe",
"mtrace",
"muntrace",
"nanosleep",
"netname2host",
"netname2user",
"nl_langinfo",
"nl_langinfo_l",
"ntohs",
"parse_printf_format",
"passwd2des",
"pclose",
"perror",
"pmap_getmaps",
"pmap_getport",
"pmap_rmtcall",
"pmap_set",
"pmap_unset",
"popen",
"printf_size",
"printf_size_info",
"psiginfo",
"psignal",
"putchar",
"putchar_unlocked",
"putc_unlocked",
"putenv",
"putgrent",
"putmsg",
"putpmsg",
"putpwent",
"puts",
"putsgent",
"putspent",
"pututxline",
"putw",
"putwc",
"putwchar",
"putwchar_unlocked",
"putwc_unlocked",
"rcmd",
"rcmd_af",
"reallocarray",
"realpath",
"re_comp",
"re_compile_fastmap",
"re_compile_pattern",
"re_exec",
"regcomp",
"regerror",
"regexec",
"register_printf_modifier",
"register_printf_type",
"registerrpc",
"re_match",
"re_match_2",
"remque",
"re_search",
"re_search_2",
"re_set_registers",
"re_set_syntax",
"revoke",
"rexec",
"rexec_af",
"rpmatch",
"rresvport",
"rresvport_af",
"ruserok",
"ruserok_af",
"ruserpass",
"secure_getenv",
"seed48",
"setbuffer",
"setstate",
"setvbuf",
"sgetsgent",
"sgetspent",
"sigcancel_handler",
"sighandler_setxid",
"sstk",
"step",
"stty",
"svcerr_auth",
"svcerr_decode",
"svcerr_noproc",
"svcerr_noprog",
"svcerr_progvers",
"svcerr_systemerr",
"svcerr_weakauth",
"svc_exit",
"svcfd_create",
"svc_getreq",
"svc_getreq_common",
"svc_getreq_poll",
"svc_getreqset",
"svcraw_create",
"svc_register",
"svc_run",
"svc_sendreply",
"svctcp_create",
"svcudp_bufcreate",
"svcudp_create",
"svcudp_enablecache",
"svcunix_create",
"svcunixfd_create",
"svc_unregister",
"swab",
"tcgetsid",
"tdelete",
"tdestroy",
"tempnam",
"textdomain",
"tfind",
"thrd_create",
"thrd_current",
"thrd_detach",
"thrd_equal",
"thrd_exit",
"thrd_join",
"thrd_sleep",
"thrd_yield",
"tmpnam",
"tolower",
"toupper",
"towctrans",
"towctrans_l",
"tr_break",
"tsearch",
"tss_create",
"tss_delete",
"tss_get",
"tss_set",
"ttyslot",
"twalk",
"twalk_r",
"tzset",
"ulckpwdf",
"ungetc",
"ungetwc",
"unwind_stop",
"updwtmpx",
"user2netname",
"utmpname",
"utmpxname",
"vlimit",
"vtimes",
"wait",
"wait3",
"waitpid",
"wordexp",
"xdecrypt",
"xdr_accepted_reply",
"xdr_array",
"xdr_authdes_cred",
"xdr_authdes_verf",
"xdr_authunix_parms",
"xdr_bool",
"xdr_bytes",
"xdr_callhdr",
"xdr_callmsg",
"xdr_char",
"xdr_cryptkeyarg",
"xdr_cryptkeyarg2",
"xdr_cryptkeyres",
"xdr_des_block",
"xdr_double",
"xdr_enum",
"xdr_float",
"xdr_getcredres",
"xdr_hyper",
"xdr_int",
"xdr_int16_t",
"xdr_int64_t",
"xdr_int8_t",
"xdr_keybuf",
"xdr_key_netstarg",
"xdr_key_netstres",
"xdr_keystatus",
"xdr_longlong_t",
"xdrmem_create",
"xdr_netnamestr",
"xdr_netobj",
"xdr_opaque",
"xdr_opaque_auth",
"xdr_pmap",
"xdr_pmaplist",
"xdr_pointer",
"xdr_quad_t",
"xdrrec_create",
"xdrrec_endofrecord",
"xdrrec_eof",
"xdrrec_skiprecord",
"xdr_reference",
"xdr_rejected_reply",
"xdr_replymsg",
"xdr_rmtcall_args",
"xdr_rmtcallres",
"xdr_short",
"xdr_sizeof",
"xdrstdio_create",
"xdr_string",
"xdr_u_char",
"xdr_u_hyper",
"xdr_u_int",
"xdr_uint16_t",
"xdr_uint64_t",
"xdr_uint8_t",
"xdr_u_long",
"xdr_u_longlong_t",
"xdr_union",
"xdr_unixcred",
"xdr_u_quad_t",
"xdr_u_short",
"xdr_vector",
"xdr_void",
"xdr_wrapstring",
"xencrypt",
"xprt_register",
"xprt_unregister" };
#endif
}
//======================================================================================//
//
// For selective instrumentation (unused)
//
bool
are_file_include_exclude_lists_empty()
{
return true;
}
//======================================================================================//
//
// Gets information (line number, filename, and column number) about
// the instrumented loop and formats it properly.
//
function_signature
get_loop_file_line_info(module_t* mutatee_module, procedure_t* f, flow_graph_t* cfGraph,
basic_loop_t* loopToInstrument)
{
if(!cfGraph || !loopToInstrument || !f) return function_signature{ "", "", "" };
char fname[FUNCNAMELEN + 1];
char mname[FUNCNAMELEN + 1];
std::string typeName = {};
memset(fname, '\0', FUNCNAMELEN + 1);
memset(mname, '\0', FUNCNAMELEN + 1);
mutatee_module->getName(mname, FUNCNAMELEN);
bpvector_t<point_t*>* loopStartInst =
cfGraph->findLoopInstPoints(BPatch_locLoopStartIter, loopToInstrument);
bpvector_t<point_t*>* loopExitInst =
cfGraph->findLoopInstPoints(BPatch_locLoopEndIter, loopToInstrument);
if(!loopStartInst || !loopExitInst) return function_signature{ "", "", "" };
unsigned long baseAddr = (unsigned long) (*loopStartInst)[0]->getAddress();
unsigned long lastAddr =
(unsigned long) (*loopExitInst)[loopExitInst->size() - 1]->getAddress();
verbprintf(3, "Loop: size of lastAddr = %lu: baseAddr = %lu, lastAddr = %lu\n",
(unsigned long) loopExitInst->size(), (unsigned long) baseAddr,
(unsigned long) lastAddr);
f->getName(fname, FUNCNAMELEN);
auto* returnType = f->getReturnType();
if(returnType)
{
typeName = returnType->getName();
}
auto* params = f->getParams();
std::vector<string_t> _params;
if(params)
{
for(auto* itr : *params)
{
string_t _name = itr->getType()->getName();
if(_name.empty()) _name = itr->getName();
_params.push_back(_name);
}
}
bpvector_t<BPatch_statement> lines;
bpvector_t<BPatch_statement> linesEnd;
bool info1 = mutatee_module->getSourceLines(baseAddr, lines);
string_t filename = mname;
if(info1)
{
// filename = lines[0].fileName();
auto row1 = lines[0].lineNumber();
auto col1 = lines[0].lineOffset();
if(col1 < 0) col1 = 0;
// This following section is attempting to remedy the limitations of
// getSourceLines for loops. As the program goes through the loop, the resulting
// lines go from the loop head, through the instructions present in the loop, to
// the last instruction in the loop, back to the loop head, then to the next
// instruction outside of the loop. What this section does is starts at the last
// instruction in the loop, then goes through the addresses until it reaches the
// next instruction outside of the loop. We then bump back a line. This is not a
// perfect solution, but we will work with the Dyninst team to find something
// better.
bool info2 = mutatee_module->getSourceLines((unsigned long) lastAddr, linesEnd);
verbprintf(3, "size of linesEnd = %lu\n", (unsigned long) linesEnd.size());
if(info2)
{
auto row2 = linesEnd[0].lineNumber();
auto col2 = linesEnd[0].lineOffset();
if(col2 < 0) col2 = 0;
if(row2 < row1) row1 = row2; // Fix for wrong line numbers
return function_signature(typeName, fname, filename, _params, { row1, row2 },
{ col1, col2 }, true, info1, info2);
}
else
{
return function_signature(typeName, fname, filename, _params, { row1, 0 },
{ col1, 0 }, true, info1, info2);
}
}
else
{
return function_signature(typeName, fname, filename, _params);
}
}
//======================================================================================//
//
// We create a new name that embeds the file and line information in the name
//
function_signature
get_func_file_line_info(module_t* mutatee_module, procedure_t* f)
{
bool info1, info2;
unsigned long baseAddr, lastAddr;
char fname[FUNCNAMELEN + 1];
char mname[FUNCNAMELEN + 1];
int row1, col1, row2, col2;
string_t filename = {};
string_t typeName = {};
memset(fname, '\0', FUNCNAMELEN + 1);
memset(mname, '\0', FUNCNAMELEN + 1);
mutatee_module->getName(mname, FUNCNAMELEN);
baseAddr = (unsigned long) (f->getBaseAddr());
f->getAddressRange(baseAddr, lastAddr);
bpvector_t<BPatch_statement> lines;
f->getName(fname, FUNCNAMELEN);
auto* returnType = f->getReturnType();
if(returnType)
{
typeName = returnType->getName();
}
auto* params = f->getParams();
std::vector<string_t> _params;
if(params)
{
for(auto* itr : *params)
{
string_t _name = itr->getType()->getName();
if(_name.empty()) _name = itr->getName();
_params.push_back(_name);
}
}
info1 = mutatee_module->getSourceLines((unsigned long) baseAddr, lines);
filename = mname;
if(info1)
{
// filename = lines[0].fileName();
row1 = lines[0].lineNumber();
col1 = lines[0].lineOffset();
if(col1 < 0) col1 = 0;
info2 = mutatee_module->getSourceLines((unsigned long) (lastAddr - 1), lines);
if(info2)
{
row2 = lines[1].lineNumber();
col2 = lines[1].lineOffset();
if(col2 < 0) col2 = 0;
if(row2 < row1) row1 = row2;
return function_signature(typeName, fname, filename, _params, { row1, 0 },
{ 0, 0 }, false, info1, info2);
}
else
{
return function_signature(typeName, fname, filename, _params, { row1, 0 },
{ 0, 0 }, false, info1, info2);
}
}
else
{
return function_signature(typeName, fname, filename, _params, { 0, 0 }, { 0, 0 },
false, false, false);
}
}
//======================================================================================//
//
// Error callback routine.
//
void
errorFunc(error_level_t level, int num, const char** params)
{
char line[256];
const char* msg = bpatch->getEnglishErrorString(num);
bpatch->formatErrorString(line, sizeof(line), msg, params);
if(num != expect_error)
{
printf("Error #%d (level %d): %s\n", num, level, line);
// We consider some errors fatal.
if(num == 101) exit(-1);
}
}
//======================================================================================//
//
// For compatibility purposes
//
procedure_t*
find_function(image_t* app_image, const std::string& _name, const strset_t& _extra)
{
if(_name.empty()) return nullptr;
auto _find = [app_image](const string_t& _f) -> procedure_t* {
// Extract the vector of functions
bpvector_t<procedure_t*> _found;
auto* ret = app_image->findFunction(_f.c_str(), _found, false, true, true);
if(ret == nullptr || _found.empty()) return nullptr;
return _found.at(0);
};
procedure_t* _func = _find(_name);
auto itr = _extra.begin();
while(_func == nullptr && itr != _extra.end())
{
_func = _find(*itr);
++itr;
}
if(!_func)
{
verbprintf(1, "function: '%s' ... not found\n", _name.c_str());
}
else
{
verbprintf(1, "function: '%s' ... found\n", _name.c_str());
}
return _func;
}
//======================================================================================//
//
void
error_func_real(error_level_t level, int num, const char* const* params)
{
if(num == 0)
{
// conditional reporting of warnings and informational messages
if(error_print > 0)
{
if(level == BPatchInfo)
{
if(error_print > 1) printf("%s\n", params[0]);
}
else
printf("%s", params[0]);
}
}
else
{
// reporting of actual errors
char line[256];
const char* msg = bpatch->getEnglishErrorString(num);
bpatch->formatErrorString(line, sizeof(line), msg, params);
if(num != expect_error)
{
printf("Error #%d (level %d): %s\n", num, level, line);
// We consider some errors fatal.
if(num == 101) exit(-1);
}
}
}
//======================================================================================//
//
// We've a null error function when we don't want to display an error
//
void
error_func_fake(error_level_t level, int num, const char* const* params)
{
consume_parameters(level, num, params);
// It does nothing.
}
Referencia en una nueva incidencia Ver la culpa de Git Copiar Permalink