void myinit(int argc, char **argv)
{
int status, i;
char * p;
char * p_dbg;
char * cmdline;
char * v;
const char * rankA[] = {"PMI_RANK", "OMPI_COMM_WORLD_RANK", "MV2_COMM_WORLD_RANK", NULL};
const char * sizeA[] = {"PMI_SIZE", "OMPI_COMM_WORLD_SIZE", "MV2_COMM_WORLD_SIZE", NULL};
struct timeval tv;
struct utsname u;
uuid_t uuid;
unsetenv("LD_PRELOAD");
/* Stop tracking if XALT is turned off */
p_dbg = getenv("XALT_TRACING");
if (p_dbg && strcmp(p_dbg,"yes") == 0)
{
xalt_tracing = 1;
errfd = dup(STDERR_FILENO);
}
v = getenv("XALT_EXECUTABLE_TRACKING");
if (xalt_tracing)
{
abspath(path,sizeof(path));
FULL_DEBUG3(stderr,"myinit(%s,%s):\n Test for XALT_EXECUTABLE_TRACKING: \"%s\"\n", STR(STATE),path,(v != NULL) ? v : "(NULL)");
}
if (!v || strcmp(v,"yes") != 0)
{
FULL_DEBUG0(stderr," XALT_EXECUTABLE_TRACKING is off -> exiting\n\n");
return;
}
v = getenv("__XALT_INITIAL_STATE__");
FULL_DEBUG2(stderr," Test for __XALT_INITIAL_STATE__: \"%s\", STATE: \"%s\"\n", (v != NULL) ? v : "(NULL)", STR(STATE));
/* Stop tracking if any myinit routine has been called */
if (v && (strcmp(v,STR(STATE)) != 0))
{
FULL_DEBUG2(stderr," __XALT_INITIAL_STATE__ has a value: \"%s\" -> and it is different from STATE: \"%s\" exiting\n\n",v,STR(STATE));
return;
}
/* Stop tracking if my mpi rank is not zero */
my_rank = compute_value(rankA);
FULL_DEBUG1(stderr," Test for rank == 0, rank: %ld\n",my_rank);
if (my_rank > 0L)
{
FULL_DEBUG0(stderr," MPI Rank is not zero -> exiting\n\n");
return;
}
my_size = compute_value(sizeA);
if (my_size < 1L)
my_size = 1L;
errno = 0;
if (uname(&u) != 0)
{
perror("uname");
exit(EXIT_FAILURE);
}
/* Get full absolute path to executable */
abspath(path,sizeof(path));
reject_flag = reject(path, u.nodename);
FULL_DEBUG3(stderr," Test for path and hostname, hostname: %s, path: %s, reject: %d\n", u.nodename, path, reject_flag);
if (reject_flag)
{
FULL_DEBUG0(stderr," reject_flag is true -> exiting\n\n");
return;
}
setenv("__XALT_INITIAL_STATE__",STR(STATE),1);
errfd = dup(STDERR_FILENO);
syshost = xalt_syshost();
/* Build a json version of the user's command line. */
/* Calculate size of buffer*/
int sz = 0;
for (i = 0; i < argc; ++i)
sz += strlen(argv[i]);
/* this size formula uses 3 facts:
* 1) if every character was a utf-16 character that is four bytes converts to 12 (sz*3)
* 2) Each entry has two quotes and a comma (argc*3)
* 3) There are two square brackets and a null byte (+3)
*/
sz = sz*3 + argc*3 + 3;
usr_cmdline = (char *) malloc(sz);
p = &usr_cmdline[0];
*p++ = '[';
for (i = 0; i < argc; ++i)
{
*p++ = '"';
const char* qs = xalt_quotestring(argv[i]);
int len = strlen(qs);
memcpy(p,qs,len);
p += len;
*p++= '"';
*p++= ',';
}
*--p = ']';
*++p = '\0';
if (p > &usr_cmdline[sz])
{
fprintf(stderr,"XALT: Failure in building user command line json string!\n");
reject_flag = 1;
return;
}
uuid_generate(uuid);
uuid_unparse_lower(uuid,uuid_str);
gettimeofday(&tv,NULL);
start_time = tv.tv_sec + 1.e-6*tv.tv_usec;
asprintf(&cmdline, "LD_LIBRARY_PATH=%s PATH=/usr/bin:/bin %s --syshost \"%s\" --start \"%.3f\" --end 0 --exec \"%s\" --ntasks %ld --uuid \"%s\" '%s'",
SYS_LD_LIB_PATH, PREFIX "/libexec/xalt_run_submission", syshost, start_time, path, my_size, uuid_str, usr_cmdline);
DEBUG1(stderr, " Start Tracking: %s\nEnd myinit()\n",cmdline);
system(cmdline);
free(cmdline);
}
int main(int argc, char* argv[])
{
const char* executable_tracking = getenv("XALT_EXECUTABLE_TRACKING");
if (executable_tracking == NULL || (strcmp(executable_tracking,"yes") != 0))
{
std::cout << "*------------------------------------------------------------------------------*\n";
std::cout << " Warning: XALT_EXECUTABLE_TRACKING is not set to \"yes\"!!\n";
std::cout << "\n";
std::cout << " XALT will not do anything without this variable\n";
std::cout << " set to \"yes\"\n";
std::cout << "*------------------------------------------------------------------------------*\n";
return 1;
}
std::string syshost(xalt_syshost());
std::string syslog_tag("XALT_LOGGING_");
syslog_tag.append(syshost);
Vstring resultA;
std::string cmd = XALT_DIR "/bin/xalt_print_os";
capture(cmd, resultA);
std::string current_os_descript = resultA[0];
char dateStr[dateSZ];
time_t now = (time_t) epoch();
strftime(dateStr,dateSZ, "%c", localtime(&now));
const char* transmission = getenv("XALT_TRANSMISSION_STYLE");
if (transmission == NULL)
transmission = TRANSMISSION;
if ((strcasecmp(transmission,"file") != 0 ) &&
(strcasecmp(transmission,"none") != 0 ) &&
(strcasecmp(transmission,"syslog") != 0 ) &&
(strcasecmp(transmission,"syslogv1") != 0 ) &&
(strcasecmp(transmission,"direct2db") != 0 ))
transmission = "file";
const char* computeSHA1 = getenv("XALT_COMPUTE_SHA1");
if (computeSHA1 == NULL)
computeSHA1 = XALT_COMPUTE_SHA1;
const char* xalt_etc_dir = getenv("XALT_ETC_DIR");
if (xalt_etc_dir == NULL)
xalt_etc_dir = XALT_ETC_DIR;
const char* xalt_mpi_tracking = getenv("XALT_MPI_TRACKING");
if (xalt_mpi_tracking == NULL)
xalt_mpi_tracking = XALT_MPI_TRACKING;
const char* xalt_gpu_tracking = getenv("XALT_GPU_TRACKING");
if (xalt_gpu_tracking == NULL)
xalt_gpu_tracking = XALT_GPU_TRACKING;
if (strcmp(HAVE_DCGM,"no") == 0)
xalt_gpu_tracking = HAVE_DCGM;
const char* xalt_func_tracking = getenv("XALT_FUNCTION_TRACKING");
if (xalt_func_tracking == NULL)
xalt_func_tracking = XALT_FUNCTION_TRACKING;
else if (strcmp(xalt_func_tracking,"no") != 0)
xalt_func_tracking = "yes";
const char* xalt_scalar_tracking = getenv("XALT_SCALAR_TRACKING");
if (xalt_scalar_tracking == NULL)
xalt_scalar_tracking = XALT_SCALAR_TRACKING;
const char* xalt_scalar_sampling = getenv("XALT_SCALAR_SAMPLING");
if (!xalt_scalar_sampling)
xalt_scalar_sampling = getenv("XALT_SCALAR_AND_SPSR_SAMPLING");
if (xalt_scalar_sampling == NULL || strcmp(xalt_scalar_sampling,"yes") != 0)
xalt_scalar_sampling = "no";
const char* xalt_preload_only = XALT_PRELOAD_ONLY;
std::string cxx_ld_library_path = CXX_LD_LIBRARY_PATH;
if (cxx_ld_library_path == "")
cxx_ld_library_path = "<empty>";
if (argc == 2 && strcmp(argv[1],"--json") == 0)
{
Json json;
json.add("DATE", dateStr);
json.add("XALT_EXECUTABLE_TRACKING", executable_tracking);
json.add("XALT_PRELOAD_ONLY", xalt_preload_only);
json.add("XALT_SYSHOST", syshost);
json.add("XALT_VERSION", XALT_VERSION);
json.add("XALT_INTERFACE_VERSION", XALT_INTERFACE_VERSION);
json.add("XALT_GIT_VERSION", XALT_GIT_VERSION);
json.add("XALT_VERSION_STR", XALT_VERSION_STR);
json.add("XALT_FILE_PREFIX", XALT_FILE_PREFIX);
json.add("XALT_TRANSMISSION_STYLE", transmission);
json.add("XALT_FUNCTION_TRACKING", xalt_func_tracking);
if (strcmp(transmission,"syslog") == 0)
json.add("XALT_LOGGING_TAG", syslog_tag);
json.add("XALT_COMPUTE_SHA1", computeSHA1);
json.add("XALT_ETC_DIR", xalt_etc_dir);
json.add("XALT_DIR", XALT_DIR);
json.add("BAD_INSTALL", BAD_INSTALL);
json.add("XALT_CONFIG_PY", XALT_CONFIG_PY);
json.add("XALT_SYSTEM_PATH", XALT_SYSTEM_PATH);
json.add("XALT_SYSHOST_CONFIG", SYSHOST_CONFIG);
json.add("XALT_MPI_TRACKING", xalt_mpi_tracking);
json.add("XALT_GPU_TRACKING", xalt_gpu_tracking);
json.add("XALT_SCALAR_TRACKING", xalt_scalar_tracking);
json.add("XALT_SCALAR_SAMPLING", xalt_scalar_sampling);
json.add("XALT_SYSLOG_MSG_SZ", SYSLOG_MSG_SZ);
json.add("XALT_INSTALL_OS", XALT_INSTALL_OS);
json.add("XALT_CURRENT_OS", current_os_descript);
json.add("CXX_LD_LIBRARY_PATH", cxx_ld_library_path);
json.add("HAVE_32BIT", HAVE_32BIT);
json.add("MY_HOSTNAME_PARSER", MY_HOSTNAME_PARSER);
json.add("HAVE_DCGM", HAVE_DCGM);
json.add("hostnameA", hostnameSz, hostnameA);
json.add("pathPatternA", pathPatternSz, pathPatternA);
json.add("envPatternA", envPatternSz, envPatternA);
json.fini();
std::string jsonStr = json.result();
std::cout << jsonStr << std::endl;
return 0;
}
std::cout << "*------------------------------------------------------------------------------*\n";
std::cout << " XALT Configuration Report\n";
std::cout << "*------------------------------------------------------------------------------*\n\n";
std::cout << "Today's DATE: " << dateStr << "\n";
std::cout << "XALT_VERSION: " << XALT_VERSION << "\n";
std::cout << "XALT_GIT_VERSION: " << XALT_GIT_VERSION << "\n";
std::cout << "XALT_VERSION_STR: " << XALT_VERSION_STR << "\n";
std::cout << "*------------------------------------------------------------------------------*\n";
std::cout << "XALT_EXECUTABLE_TRACKING: " << executable_tracking << "\n";
std::cout << "XALT_FUNCTION_TRACKING: " << xalt_func_tracking << "\n";
std::cout << "XALT_SYSHOST: " << syshost << "\n";
std::cout << "XALT_FILE_PREFIX: " << XALT_FILE_PREFIX << "\n";
std::cout << "XALT_INTERFACE_VERSION: " << XALT_INTERFACE_VERSION << "\n";
std::cout << "XALT_TRANSMISSION_STYLE: " << transmission << "\n";
if (strcmp(transmission,"syslog") == 0)
std::cout << "XALT_LOGGING_TAG: " << syslog_tag << "\n";
std::cout << "XALT_COMPUTE_SHA1: " << computeSHA1 << "\n";
std::cout << "XALT_ETC_DIR: " << xalt_etc_dir << "\n";
std::cout << "XALT_DIR: " << XALT_DIR << "\n";
std::cout << "BAD_INSTALL: " << BAD_INSTALL << "\n";
std::cout << "XALT_CONFIG_PY: " << XALT_CONFIG_PY << "\n";
std::cout << "XALT_MPI_TRACKING: " << xalt_mpi_tracking << "\n";
std::cout << "XALT_GPU_TRACKING: " << xalt_gpu_tracking << "\n";
std::cout << "XALT_SCALAR_TRACKING: " << xalt_scalar_tracking << "\n";
std::cout << "XALT_SCALAR_SAMPLING: " << xalt_scalar_sampling << "\n";
std::cout << "XALT_SYSTEM_PATH: " << XALT_SYSTEM_PATH << "\n";
std::cout << "XALT_SYSHOST_CONFIG: " << SYSHOST_CONFIG << "\n";
std::cout << "XALT_SYSLOG_MSG_SZ: " << SYSLOG_MSG_SZ << "\n";
std::cout << "CXX_LD_LIBRARY_PATH: " << cxx_ld_library_path << "\n";
std::cout << "XALT_INSTALL_OS: " << XALT_INSTALL_OS << "\n";
std::cout << "CURRENT_OS: " << current_os_descript << "\n";
std::cout << "XALT_PRELOAD_ONLY: " << XALT_PRELOAD_ONLY << "\n";
std::cout << "HAVE_32BIT: " << HAVE_32BIT << "\n";
std::cout << "MY_HOSTNAME_PARSER: " << MY_HOSTNAME_PARSER << "\n";
std::cout << "Built with DCGM: " << HAVE_DCGM << "\n";
std::cout << "*------------------------------------------------------------------------------*\n\n";
displayArray("hostnameA", hostnameSz, hostnameA);
std::cout << "\nRemember that \"PKGS\" means a program that can also track internal packages\n";
displayArray("pathPatternA", pathPatternSz, pathPatternA);
displayArray("envPatternA", envPatternSz, envPatternA);
std::cout << "*----------------------*\n";
std::cout << " Array: interval\n";
std::cout << "*----------------------*\n";
for (int i = 0; i < rangeSz-1; ++i)
std::cout << "Time Range(seconds): [" << rangeA[i].left << ", " << rangeA[i+1].left
<< "]: probability: "<< rangeA[i].prob << "\n";
std::cout << "\n";
return 0;
}
