int writeExecuteEvent(WriteUserLog *log)
{
ExecuteEvent execute;
execute.setExecuteHost("<128.105.165.12:32779>");
if ( !log->writeEvent(&execute) ) {
printf("Bad execute write\n");
exit(1);
}
return(0);
}
int writeExecuteEvent()
{
ExecuteEvent execute;
execute.setExecuteHost("<128.105.165.12:32779>");
if ( !logFile.writeEvent(&execute) ) {
printf("Complain about bad execute write\n");
exit(1);
}
return(0);
}
ULogEvent *
EventInfo::GenEventExecute( void )
{
SetName( "Execute" );
SetNote( "<128.105.165.12:32779>" );
ExecuteEvent *e = new ExecuteEvent;
e->setExecuteHost(GetNote());
return SetEvent( e );
}
extern "C" void
log_execute (char *host)
{
if( WroteExecuteEvent ) {
return;
}
// log execute event
ExecuteEvent event;
event.setExecuteHost(host);
if( !ULog.writeEvent(&event) ) {
dprintf (D_ALWAYS, "Unable to log ULOG_EXECUTE event\n");
} else {
WroteExecuteEvent = 1;
}
}
extern "C" void
log_execute (char *host)
{
if( WroteExecuteEvent ) {
return;
}
// log execute event
ExecuteEvent event;
event.setExecuteHost(host);
WroteExecuteEvent = 1;
for(std::vector<WriteUserLog*>::iterator p = ULog.begin(); p != ULog.end(); ++p) {
if( !(*p)->writeEvent(&event) ) {
dprintf (D_ALWAYS, "Unable to log ULOG_EXECUTE event\n");
WroteExecuteEvent = 0;
}
}
}
bool
LocalUserLog::logExecute( ClassAd* ad )
{
if( ! is_initialized ) {
EXCEPT( "LocalUserLog::logExecute() called before init()" );
}
if( ! should_log ) {
return true;
}
ExecuteEvent event;
event.setExecuteHost( daemonCore->InfoCommandSinfulString() );
if( !u_log.writeEvent(&event,ad) ) {
dprintf( D_ALWAYS, "Unable to log ULOG_EXECUTE event: "
"can't write to UserLog!\n" );
return false;
}
return true;
}
bool
WriteExecuteEventToUserLog( ClassAd *job_ad )
{
int cluster, proc;
char hostname[128];
WriteUserLog *ulog = InitializeUserLog( job_ad );
if ( ulog == NULL ) {
// User doesn't want a log
return true;
}
job_ad->LookupInteger( ATTR_CLUSTER_ID, cluster );
job_ad->LookupInteger( ATTR_PROC_ID, proc );
dprintf( D_FULLDEBUG,
"(%d.%d) Writing execute record to user logfile\n",
cluster, proc );
hostname[0] = '\0';
job_ad->LookupString( ATTR_GRID_RESOURCE, hostname,
sizeof(hostname) );
ExecuteEvent event;
event.setExecuteHost( hostname );
int rc = ulog->writeEvent(&event,job_ad);
delete ulog;
if (!rc) {
dprintf( D_ALWAYS,
"(%d.%d) Unable to log ULOG_EXECUTE event\n",
cluster, proc );
return false;
}
return true;
}
void
read_log(const char *filename, int select_cluster, int select_proc)
{
ReadUserLog ulog;
ULogEventOutcome result;
ULogEvent *event=NULL;
char hash[40];
HashTable<HashKey, ExecuteEvent *> ExecRecs(1024, hashFunction);
HashTable<HashKey, CheckpointedEvent *> CkptRecs(1024, hashFunction);
if (ulog.initialize(filename,0,false,true)==false) {
fprintf(stderr,
"Error: unable to read log file.\n");
exit(0);
}
while ((result = ulog.readEvent(event)) != ULOG_NO_EVENT) {
if ((result == ULOG_OK) &&
(select_cluster == -1 || select_cluster == event->cluster) &&
(select_proc == -1 || select_proc == event->proc)) {
switch (event->eventNumber) {
case ULOG_SUBMIT:
delete event;
break;
case ULOG_EXECUTE: {
sprintf(hash, "%d.%d", event->cluster, event->proc);
HashKey key(hash);
// check if we already have an execute event for this job
ExecuteEvent *execEvent;
if (ExecRecs.lookup(key, execEvent) >= 0) {
// This means we found two execute events for the
// job not separated by an evict or terminate
// event. Which one should we throw out? If the
// executeHosts are the same, then we throw out
// the later event, since the 6.1.15 and 6.1.16
// shadows logged execute events before every
// other event, so keeping the first execute event
// gives correct results for those shadows.
// Otherwise, we throw out the previous event.
if (!strcmp(((ExecuteEvent *)event)->getExecuteHost(),
execEvent->getExecuteHost())) {
if (debug_mode) {
fprintf(stderr,
"warning: discarding execute event "
"(job %s)\n found before evict or "
"termination event for previous execute "
"event.\n", hash);
}
delete event;
break;
}
if (ExecRecs.remove(key) < 0) {
if (debug_mode) {
fprintf(stderr, "internal error: hashtable remove "
"failed for exec event %s!\n", hash);
}
delete event;
break;
}
if (debug_mode) {
fprintf(stderr, "warning: discarding execute event "
"(job %s)\n with no corresponding evict or "
"termination event.\n", hash);
}
delete execEvent;
}
ExecRecs.insert(key, (ExecuteEvent *)event);
break;
}
case ULOG_CHECKPOINTED: {
sprintf(hash, "%d.%d", event->cluster, event->proc);
HashKey key(hash);
// remove any previous ckpt events for this job
CheckpointedEvent *ckptEvent;
if (CkptRecs.lookup(key, ckptEvent) >= 0) {
if (CkptRecs.remove(key) < 0) {
if (debug_mode) {
fprintf(stderr, "internal error: hashtable remove "
"failed for ckpt event %s!\n", hash);
}
delete event;
break;
}
delete ckptEvent;
}
CkptRecs.insert(HashKey(hash), (CheckpointedEvent *)event);
break;
}
case ULOG_JOB_EVICTED: {
ExecuteEvent *execEvent;
JobEvictedEvent *evictEvent = (JobEvictedEvent *)event;
sprintf(hash, "%d.%d", event->cluster, event->proc);
HashKey key(hash);
if (ExecRecs.lookup(key, execEvent) < 0) {
if (debug_mode) {
fprintf(stderr,
"internal error: can't find execute event for "
"evicted job %s!\n", hash);
}
delete event;
break;
}
if (ExecRecs.remove(key) < 0) {
if (debug_mode) {
fprintf(stderr,
"internal error: hashtable remove failed for "
"%s!\n", hash);
}
delete event;
break;
}
time_t start_time, end_time, ckpt_time=0;
start_time = mktime(&execEvent->eventTime);
end_time = mktime(&event->eventTime);
int cpu_usage = 0;
if (evictEvent->checkpointed) {
ckpt_time = end_time;
cpu_usage = evictEvent->run_remote_rusage.ru_utime.tv_sec +
evictEvent->run_remote_rusage.ru_stime.tv_sec;
} else {
CheckpointedEvent *ckptEvent;
if (CkptRecs.lookup(key, ckptEvent) >= 0) {
ckpt_time = mktime(&ckptEvent->eventTime);
cpu_usage =
ckptEvent->run_remote_rusage.ru_utime.tv_sec +
ckptEvent->run_remote_rusage.ru_stime.tv_sec;
}
if (ckpt_time < start_time) {
ckpt_time = start_time;
cpu_usage = 0;
}
}
new_record(event->cluster, event->proc, (int)start_time,
(int)end_time,
(int)ckpt_time-start_time, cpu_usage,
execEvent->getExecuteHost());
delete execEvent;
delete event;
break;
}
case ULOG_JOB_TERMINATED: {
ExecuteEvent *execEvent;
JobTerminatedEvent *terminateEvent =
(JobTerminatedEvent *)event;
sprintf(hash, "%d.%d", event->cluster, event->proc);
HashKey key(hash);
if (ExecRecs.lookup(key, execEvent) < 0) {
if (debug_mode) {
fprintf(stderr,
"internal error: can't find execute event for "
"terminated job %s!\n", hash);
}
delete event;
break;
}
if (ExecRecs.remove(key) < 0) {
if (debug_mode) {
fprintf(stderr,
"internal error: hashtable remove failed "
"for %s!\n", hash);
}
delete event;
break;
}
time_t start_time, end_time;
start_time = mktime(&execEvent->eventTime);
end_time = mktime(&event->eventTime);
if (!evict_only) {
new_record(event->cluster, event->proc, (int)start_time,
(int)end_time,
(int)end_time-start_time,
terminateEvent->
run_remote_rusage.ru_utime.tv_sec +
terminateEvent->
run_remote_rusage.ru_stime.tv_sec,
execEvent->getExecuteHost());
}
delete execEvent;
delete event;
break;
}
case ULOG_IMAGE_SIZE:
delete event;
break;
case ULOG_EXECUTABLE_ERROR:
case ULOG_SHADOW_EXCEPTION: {
ExecuteEvent *execEvent;
sprintf(hash, "%d.%d", event->cluster, event->proc);
HashKey key(hash);
if (ExecRecs.lookup(key, execEvent) < 0) {
if (debug_mode) {
fprintf(stderr,
"internal error: can't find execute event for "
"job %s!\n", hash);
}
delete event;
break;
}
if (ExecRecs.remove(key) < 0) {
if (debug_mode) {
fprintf(stderr,
"internal error: hashtable remove failed for "
"%s!\n", hash);
}
delete event;
break;
}
time_t start_time, end_time, ckpt_time=0;
start_time = mktime(&execEvent->eventTime);
end_time = mktime(&event->eventTime);
int cpu_usage = 0;
CheckpointedEvent *ckptEvent;
if (CkptRecs.lookup(key, ckptEvent) >= 0) {
ckpt_time = mktime(&ckptEvent->eventTime);
cpu_usage = ckptEvent->run_remote_rusage.ru_utime.tv_sec +
ckptEvent->run_remote_rusage.ru_stime.tv_sec;
}
if (ckpt_time < start_time) {
ckpt_time = start_time;
cpu_usage = 0;
}
if (!evict_only) {
new_record(event->cluster, event->proc, (int)start_time,
(int)end_time,
(int)ckpt_time-start_time, cpu_usage,
execEvent->getExecuteHost());
}
delete execEvent;
delete event;
break;
}
default:
// ignore the rest of the eveats
break;
}
} else {
if (event!=NULL) delete event;
if ((result==ULOG_RD_ERROR) || (result == ULOG_UNK_ERROR)) {
fprintf(stderr,
"Error: unable to read log file.\n");
exit(0);
}
}
}
// delete any remaining items in the tables
ExecuteEvent *execEvent;
ExecRecs.startIterations();
while (ExecRecs.iterate(execEvent) == 1) {
delete execEvent;
}
CheckpointedEvent *ckptEvent;
CkptRecs.startIterations();
while (CkptRecs.iterate(ckptEvent) == 1) {
delete ckptEvent;
}
}
