void trace_communicationAt (unsigned ptask, unsigned task_s, unsigned thread_s, unsigned vthread_s, unsigned task_r, unsigned thread_r, unsigned vthread_r, event_t *send_begin, event_t *send_end, event_t *recv_begin, event_t *recv_end, int atposition, off_t position) { thread_t *thread_r_info, *thread_s_info; unsigned long long log_s, log_r, phy_s, phy_r; unsigned cpu_r, cpu_s; /* Look for the receive partner ... in the sender events */ thread_r_info = GET_THREAD_INFO(ptask, task_r, thread_r); cpu_r = thread_r_info->cpu; /* Look for the sender partner ... in the receiver events */ thread_s_info = GET_THREAD_INFO(ptask, task_s, thread_s); cpu_s = thread_s_info->cpu; /* Synchronize event times */ log_s = TIMESYNC(ptask-1, task_s-1, Get_EvTime (send_begin)); phy_s = TIMESYNC(ptask-1, task_s-1, Get_EvTime (send_end)); log_r = TIMESYNC(ptask-1, task_r-1, Get_EvTime (recv_begin)); phy_r = TIMESYNC(ptask-1, task_r-1, Get_EvTime (recv_end)); #if defined(DEBUG) fprintf (stderr, "trace_communicationAt: %u.%u.%u -> %u.%u.%u atposition=%d position=%llu\n", ptask, task_s, thread_s, ptask, task_r, thread_r, atposition, position); #endif trace_paraver_communication (cpu_s, ptask, task_s, thread_s, vthread_s, log_s, phy_s, cpu_r, ptask, task_r, thread_r, vthread_r, log_r, phy_r, Get_EvSize (recv_end), Get_EvTag (recv_end), atposition, position); }
int MPI_Start_Event (event_t * current_event, unsigned long long current_time, unsigned int cpu, unsigned int ptask, unsigned int task, unsigned int thread, FileSet_t *fset) { unsigned int EvType, EvValue; thread_t * thread_info; UNREFERENCED_PARAMETER(fset); EvType = Get_EvEvent (current_event); EvValue = Get_EvValue (current_event); Switch_State (STATE_MIXED, (EvValue == EVT_BEGIN), ptask, task, thread); trace_paraver_state (cpu, ptask, task, thread, current_time); trace_paraver_event (cpu, ptask, task, thread, current_time, EvType, EvValue); thread_info = GET_THREAD_INFO(ptask, task, thread); switch (EvValue) { /* We don't know if the start will issue a send or recv, so we store both. This will be solved in MPI_PersistentRequest_Event */ case EVT_BEGIN: thread_info->Send_Rec = current_event; thread_info->Recv_Rec = current_event; break; case EVT_END: break; } return 0; }
/****************************************************************************** *** trace_paraver_unmatched_communication ******************************************************************************/ void trace_paraver_unmatched_communication (unsigned int cpu_s, unsigned int ptask_s, unsigned int task_s, unsigned int thread_s, unsigned int vthread_s, unsigned long long log_s, unsigned long long phy_s, unsigned int cpu_r, unsigned int ptask_r, unsigned int task_r, unsigned int thread_r, unsigned int size, unsigned int tag) { thread_t * thread_info_s = GET_THREAD_INFO (ptask_s, task_s, thread_s); WriteFileBuffer_t *wfb = thread_info_s->file->wfb; paraver_rec_t record; UNREFERENCED_PARAMETER(thread_r); if (!EnabledTasks[ptask_s-1][task_s-1]) return; record.type = UNMATCHED_COMMUNICATION; record.cpu = cpu_s; record.ptask = ptask_s; record.task = task_s; record.thread = vthread_s; record.time = log_s; record.end_time = phy_s; record.event = size; record.value = tag; record.cpu_r = cpu_r; record.ptask_r = ptask_r; record.task_r = task_r; record.thread_r = thread_r; trace_paraver_record (wfb, &record); }
/****************************************************************************** *** MPI_Persistent_req_use_Event ******************************************************************************/ static int MPI_Persistent_req_use_Event (event_t * current, unsigned long long current_time, unsigned int cpu, unsigned int ptask, unsigned int task, unsigned int thread, FileSet_t *fset) { thread_t * thread_info = GET_THREAD_INFO(ptask, task, thread); UINT64 valor; int tipus; double temps; UNREFERENCED_PARAMETER(cpu); temps = current_time-thread_info->Previous_Event_Time; temps /= 1000000000.0f; switch (Get_EvValue(current)) { case EVT_BEGIN: Dimemas_CPU_Burst(fset->output_file, task-1, thread-1, temps); break; case EVT_END: #ifdef CPUZERO Dimemas_CPU_Burst(fset->output_file, task-1, thread-1, 0); #endif break; } Translate_MPI_MPIT2PRV (Get_EvEvent(current), Get_EvValue(current), &tipus, &valor); Dimemas_User_Event (fset->output_file, task-1, thread-1, tipus, valor); return 0; }
static int ANY_Send_Event (event_t * current, unsigned long long current_time, unsigned int cpu, unsigned int ptask, unsigned int task, unsigned int thread, FileSet_t *fset) { thread_t * thread_info = GET_THREAD_INFO(ptask, task, thread); int tipus; int isimmediate; int comunicador; UINT64 valor; double temps; UNREFERENCED_PARAMETER(cpu); if (MPI_IBSEND_EV == Get_EvEvent(current) || MPI_ISSEND_EV == Get_EvEvent(current) || MPI_IRSEND_EV == Get_EvEvent(current) || MPI_ISEND_EV == Get_EvEvent(current)) isimmediate = TRUE; else isimmediate = FALSE; temps = current_time-thread_info->Previous_Event_Time; temps /= 1000000000.0f; comunicador = alies_comunicador (Get_EvComm(current), 1, task); switch (Get_EvValue(current)) { case EVT_BEGIN: Dimemas_CPU_Burst (fset->output_file, task-1, thread-1, temps); break; case EVT_END: if (Get_EvTarget(current) != MPI_PROC_NULL) { #ifdef CPUZERO Dimemas_CPU_Burst (fset->output_file, task-1, thread-1, 0); #endif if (!isimmediate) Dimemas_NX_BlockingSend (fset->output_file, task-1, thread-1, Get_EvTarget(current), comunicador, Get_EvSize(current), Get_EvTag(current)); else Dimemas_NX_ImmediateSend (fset->output_file, task-1, thread-1, Get_EvTarget(current), comunicador, Get_EvSize(current), Get_EvTag(current)); } #ifdef CPUZERO Dimemas_CPU_Burst (fset->output_file, task-1, thread-1, 0); #endif break; } Translate_MPI_MPIT2PRV (Get_EvEvent(current), Get_EvValue(current), &tipus, &valor); Dimemas_User_Event (fset->output_file, task-1, thread-1, tipus, valor); return 0; }
int trace_paraver_pending_communication (unsigned int cpu_s, unsigned int ptask_s, unsigned int task_s, unsigned int thread_s, unsigned vthread_s, unsigned long long log_s, unsigned long long phy_s, unsigned int cpu_r, unsigned int ptask_r, unsigned int task_r, unsigned int thread_r, unsigned vthread_r, unsigned long long log_r, unsigned long long phy_r, unsigned int size, unsigned int tag) { thread_t * thread_info_s = GET_THREAD_INFO (ptask_s, task_s, thread_s); off_t where; paraver_rec_t record; WriteFileBuffer_t *wfb = thread_info_s->file->wfb; UNREFERENCED_PARAMETER(thread_r); UNREFERENCED_PARAMETER(log_r); UNREFERENCED_PARAMETER(phy_r); if (!(EnabledTasks[ptask_s-1][task_s-1] || EnabledTasks[ptask_r-1][task_r-1])) return 0; record.type = PENDING_COMMUNICATION; record.cpu = cpu_s; record.ptask = ptask_s; record.task = task_s; record.thread = vthread_s; record.time = log_s; record.end_time = phy_s; record.event = size; record.value = tag; record.cpu_r = cpu_r; record.ptask_r = ptask_r; record.task_r = task_r; record.thread_r = vthread_r; /* may need fixing? thread_r instead? */ /* record.receive[LOGICAL_COMMUNICATION] stores the matching zone (see FixPendingCommunication) */ record.receive[LOGICAL_COMMUNICATION] = MatchComms_GetZone(ptask_s, task_s); record.receive[PHYSICAL_COMMUNICATION] = MatchComms_GetZone(ptask_s, task_s); where = WriteFileBuffer_getPosition (wfb); AddPendingCommunication (WriteFileBuffer_getFD(wfb), where, tag, task_r-1, task_s-1, MatchComms_GetZone(ptask_s, task_s)); trace_paraver_record (wfb, &record); return 0; }
/****************************************************************************** *** trace_paraver_state_noahead ******************************************************************************/ void trace_paraver_state_noahead ( unsigned int cpu, unsigned int ptask, unsigned int task, unsigned int thread, unsigned long long current_time) { thread_t * thread_info = GET_THREAD_INFO (ptask, task, thread); WriteFileBuffer_t *wfb = thread_info->file->wfb; unsigned current_state = Top_State(ptask, task, thread); UNREFERENCED_PARAMETER(cpu); #if 0 fprintf (stderr, "trace_paraver_state (..)\n"); fprintf (stderr, "thread_info->incomplete_state_offset = %u\n", thread_info->incomplete_state_offset); #endif /* Complete the previous state */ if (thread_info->incomplete_state_offset != (off_t)-1) /* This isn't the first state */ { #if 0 fprintf (stderr, "get_option_merge_JointStates() = %d Get_Last_State() = %d\n", get_option_merge_JointStates(), Get_Last_State()); fprintf (stderr, "thread_info->incomplete_state_record.value = %d == current_state = %d\n", thread_info->incomplete_state_record.value, current_state); #endif /* Do not split states whether appropriate */ if (get_option_merge_JointStates() && !Get_Last_State()) if (thread_info->incomplete_state_record.value == current_state) return; /* Write the record into the *.tmp file if the state isn't excluded */ #if defined(DEBUG_STATES) fprintf(stderr, "mpi2prv: DEBUG [T:%d] Closing state %u at %llu\n", task, (unsigned int)thread_info->incomplete_state_record.value, current_time); fprintf (stderr, "Excluded? %d\n", State_Excluded(thread_info->incomplete_state_record.value)); #endif if (!State_Excluded(thread_info->incomplete_state_record.value)) { thread_info->incomplete_state_record.end_time = current_time; WriteFileBuffer_writeAt (wfb, &(thread_info->incomplete_state_record), thread_info->incomplete_state_offset); } } }
/****************************************************************************** *** trace_paraver_event ******************************************************************************/ void trace_paraver_event ( unsigned int cpu, unsigned int ptask, unsigned int task, unsigned int thread, unsigned long long time, unsigned int type, UINT64 value) { thread_t * thread_info; paraver_rec_t record; int tipus; UINT64 valor; thread_info = GET_THREAD_INFO (ptask, task, thread); WriteFileBuffer_t *wfb = thread_info->file->wfb; #if !defined(DCARRERA_HADOOP) if (!EnabledTasks[ptask - 1][task - 1]) return; #endif if (type >= MPI_MIN_EV && type <= MPI_MAX_EV) { Translate_MPI_MPIT2PRV (type, value, &tipus, &valor); } else { tipus = type; valor = value; } record.type = EVENT; record.cpu = cpu; record.ptask = ptask; record.task = task; record.thread = thread_info->virtual_thread; record.time = time; record.event = tipus; record.value = valor; trace_paraver_record (wfb, &record); }
/****************************************************************************** *** trace_paraver_communication ******************************************************************************/ void trace_paraver_communication (unsigned int cpu_s, unsigned int ptask_s, unsigned int task_s, unsigned int thread_s, unsigned vthread_s, unsigned long long log_s, unsigned long long phy_s, unsigned int cpu_r, unsigned int ptask_r, unsigned int task_r, unsigned int thread_r, unsigned vthread_r, unsigned long long log_r, unsigned long long phy_r, unsigned int size, unsigned int tag, int giveOffset, off_t position) { thread_t * thread_info_s = GET_THREAD_INFO (ptask_s, task_s, thread_s); WriteFileBuffer_t *wfb = thread_info_s->file->wfb; paraver_rec_t record; UNREFERENCED_PARAMETER(thread_r); if (!(EnabledTasks[ptask_s-1][task_s-1] || EnabledTasks[ptask_r-1][task_r-1])) return; record.type = COMMUNICATION; record.cpu = cpu_s; record.ptask = ptask_s; record.task = task_s; record.thread = vthread_s; record.time = log_s; record.end_time = phy_s; record.event = size; record.value = tag; record.cpu_r = cpu_r; record.ptask_r = ptask_r; record.task_r = task_r; record.thread_r = vthread_r; record.receive[LOGICAL_COMMUNICATION] = log_r; record.receive[PHYSICAL_COMMUNICATION] = phy_r; if (!giveOffset) trace_paraver_record (wfb, &record); else trace_paraver_recordAt (wfb, &record, position); }
static int GlobalOP_Event (event_t * current, unsigned long long current_time, unsigned int cpu, unsigned int ptask, unsigned int task, unsigned int thread, FileSet_t *fset) { thread_t * thread_info = GET_THREAD_INFO(ptask, task, thread); UINT64 valor; int tipus; double temps; UNREFERENCED_PARAMETER(cpu); temps = current_time-thread_info->Previous_Event_Time; temps /= 1000000000.0f; if (EVT_BEGIN == Get_EvValue(current)) { UINT64 bsent = Get_GlobalOP_SendSize(current); UINT64 brecv = Get_GlobalOP_RecvSize(current); int root_rank = Get_GlobalOP_RootRank(current); int thd_rank = Get_GlobalOP_RootThd(current); int commid = Get_GlobalOP_CommID(current, task); int ID = Get_GlobalOP_ID(Get_EvEvent(current)); Dimemas_CPU_Burst (fset->output_file, task-1, thread-1, temps); Dimemas_Global_OP (fset->output_file, task-1, thread-1, ID, commid, root_rank, thd_rank, bsent, brecv ); } else if (EVT_END == Get_EvValue(current)) { #ifdef CPUZERO Dimemas_CPU_Burst (fset->output_file, task-1, thread-1, 0); #endif } Translate_MPI_MPIT2PRV (Get_EvEvent(current), Get_EvValue(current), &tipus, &valor); Dimemas_User_Event (fset->output_file, task-1, thread-1, tipus, valor); return 0; }
/****************************************************************************** *** trace_paraver_state ******************************************************************************/ void trace_paraver_state ( unsigned int cpu, unsigned int ptask, unsigned int task, unsigned int thread, unsigned long long current_time) { thread_t * thread_info = GET_THREAD_INFO (ptask, task, thread); WriteFileBuffer_t *wfb = thread_info->file->wfb; unsigned current_state = Top_State(ptask, task, thread); #if 0 fprintf (stderr, "trace_paraver_state (..)\n"); fprintf (stderr, "thread_info->incomplete_state_offset = %u\n", thread_info->incomplete_state_offset); #endif /* Complete the previous state */ if (thread_info->incomplete_state_offset != (off_t)-1) /* This isn't the first state */ { #if 0 fprintf (stderr, "get_option_merge_JointStates() = %d Get_Last_State() = %d\n", get_option_merge_JointStates(), Get_Last_State()); fprintf (stderr, "thread_info->incomplete_state_record.value = %d == current_state = %d\n", thread_info->incomplete_state_record.value, current_state); #endif /* Do not split states whether appropriate */ if (get_option_merge_JointStates() && !Get_Last_State()) if (thread_info->incomplete_state_record.value == current_state) return; /* Write the record into the *.tmp file if the state isn't excluded */ #if defined(DEBUG_STATES) fprintf(stderr, "mpi2prv: DEBUG [T:%d] Closing state %u at %llu\n", task, (unsigned int)thread_info->incomplete_state_record.value, current_time); fprintf (stderr, "Excluded? %d\n", State_Excluded(thread_info->incomplete_state_record.value)); #endif if (!State_Excluded(thread_info->incomplete_state_record.value)) { thread_info->incomplete_state_record.end_time = current_time; WriteFileBuffer_writeAt (wfb, &(thread_info->incomplete_state_record), thread_info->incomplete_state_offset); } } /* Start the next state */ thread_info->incomplete_state_record.type = STATE; thread_info->incomplete_state_record.cpu = cpu; thread_info->incomplete_state_record.ptask = ptask; thread_info->incomplete_state_record.task = task; thread_info->incomplete_state_record.thread = thread_info->virtual_thread; thread_info->incomplete_state_record.time = current_time; thread_info->incomplete_state_record.value = current_state; /* Save a slot in the *.tmp file for this record if this state isn't excluded */ #if defined(DEBUG_STATES) fprintf(stderr, "mpi2prv: DEBUG [T:%d] Starting state %u (excluded? %d) at %llu\n", task, current_state, State_Excluded(current_state), current_time); #endif if (!State_Excluded(current_state)) { paraver_rec_t fake_record; fake_record.type = UNFINISHED_STATE; fake_record.ptask = ptask; fake_record.task = task; fake_record.thread = thread; fake_record.time = current_time; thread_info->incomplete_state_offset = WriteFileBuffer_getPosition (wfb); trace_paraver_record (wfb, &fake_record); } }
/****************************************************************************** *** InitializeObjectTable ******************************************************************************/ void InitializeObjectTable (unsigned num_appl, struct input_t * files, unsigned long nfiles) { unsigned int ptask, task, thread, i, j; unsigned int ntasks[num_appl], **nthreads = NULL; /* First step, collect number of applications, number of tasks per application and number of threads per task within an app */ for (i = 0; i < num_appl; i++) ntasks[i] = 0; for (i = 0; i < nfiles; i++) ntasks[files[i].ptask-1] = MAX(files[i].task, ntasks[files[i].ptask-1]); nthreads = (unsigned**) malloc (num_appl*sizeof(unsigned*)); ASSERT(nthreads!=NULL, "Cannot allocate memory to store nthreads for whole applications"); for (i = 0; i < num_appl; i++) { nthreads[i] = (unsigned*) malloc (ntasks[i]*sizeof(unsigned)); ASSERT(nthreads[i]!=NULL, "Cannot allocate memory to store nthreads for application"); for (j = 0; j < ntasks[i]; j++) nthreads[i][j] = 0; } for (i = 0; i < nfiles; i++) nthreads[files[i].ptask-1][files[i].task-1] = MAX(files[i].thread, nthreads[files[i].ptask-1][files[i].task-1]); /* Second step, allocate structures respecting the number of apps, tasks and threads found */ ApplicationTable.nptasks = num_appl; ApplicationTable.ptasks = (ptask_t*) malloc (sizeof(ptask_t)*num_appl); ASSERT(ApplicationTable.ptasks!=NULL, "Unable to allocate memory for ptasks"); for (i = 0; i < ApplicationTable.nptasks; i++) { /* Allocate per task information within each ptask */ ApplicationTable.ptasks[i].ntasks = ntasks[i]; ApplicationTable.ptasks[i].tasks = (task_t*) malloc (sizeof(task_t)*ntasks[i]); ASSERT(ApplicationTable.ptasks[i].tasks!=NULL, "Unable to allocate memory for tasks"); for (j = 0; j < ApplicationTable.ptasks[i].ntasks; j++) { /* Initialize pending communication queues for each task */ CommunicationQueues_Init ( &(ApplicationTable.ptasks[i].tasks[j].send_queue), &(ApplicationTable.ptasks[i].tasks[j].recv_queue)); /* Allocate per thread information within each task */ ApplicationTable.ptasks[i].tasks[j].threads = (thread_t*) malloc (sizeof(thread_t)*nthreads[i][j]); ASSERT(ApplicationTable.ptasks[i].tasks[j].threads!=NULL,"Unable to allocate memory for threads"); } } #if USE_HARDWARE_COUNTERS || defined(HETEROGENEOUS_SUPPORT) INIT_QUEUE (&CountersTraced); #endif /* 3rd step, Initialize the object table structure */ for (ptask = 0; ptask < ApplicationTable.nptasks; ptask++) for (task = 0; task < ApplicationTable.ptasks[ptask].ntasks; task++) { task_t *task_info = GET_TASK_INFO(ptask+1,task+1); task_info->tracing_disabled = FALSE; task_info->nthreads = nthreads[ptask][task]; task_info->num_virtual_threads = nthreads[ptask][task]; task_info->num_binary_objects = 0; task_info->binary_objects = NULL; for (thread = 0; thread < nthreads[ptask][task]; thread++) { thread_t *thread_info = GET_THREAD_INFO(ptask+1,task+1,thread+1); /* Look for the appropriate CPU for this ptask, task, thread */ for (i = 0; i < nfiles; i++) if (files[i].ptask == ptask+1 && files[i].task == task+1 && files[i].thread == thread+1) { thread_info->cpu = files[i].cpu; break; } thread_info->dimemas_size = 0; thread_info->virtual_thread = thread+1; thread_info->nStates = 0; thread_info->First_Event = TRUE; thread_info->HWCChange_count = 0; thread_info->MatchingComms = TRUE; #if USE_HARDWARE_COUNTERS || defined(HETEROGENEOUS_SUPPORT) thread_info->HWCSets = NULL; thread_info->HWCSets_types = NULL; thread_info->num_HWCSets = 0; thread_info->current_HWCSet = 0; #endif } } /* 4th step Assign the node ID */ for (i = 0; i < nfiles; i++) { task_t *task_info = GET_TASK_INFO(files[i].ptask, files[i].task); task_info->nodeid = files[i].nodeid; } /* This is needed for get_option_merge_NanosTaskView() == FALSE */ for (ptask = 0; ptask < ApplicationTable.nptasks; ptask++) for (task = 0; task < ApplicationTable.ptasks[ptask].ntasks; task++) { task_t *task_info = GET_TASK_INFO(ptask+1, task+1); task_info->num_active_task_threads = 0; task_info->active_task_threads = NULL; } /* Clean up */ if (nthreads != NULL) { for (i = 0; i < num_appl; i++) if (nthreads[i] != NULL) free (nthreads[i]); free (nthreads); } }
/****************************************************************************** *** Sendrecv_Event ******************************************************************************/ static int SendRecv_Event (event_t * current, unsigned long long current_time, unsigned int cpu, unsigned int ptask, unsigned int task, unsigned int thread, FileSet_t *fset) { static unsigned int receiver, send_tag; static int send_size; thread_t * thread_info = GET_THREAD_INFO(ptask, task, thread); UINT64 valor; unsigned int sender = 0; unsigned int receive_tag = 0; unsigned int receive_size = 0; int tipus; int comunicador; double temps; UNREFERENCED_PARAMETER(cpu); temps = current_time-thread_info->Previous_Event_Time; temps /= 1000000000.0f; comunicador = alies_comunicador (Get_EvComm(current), 1, task); switch( Get_EvValue(current) ) { case EVT_BEGIN: Dimemas_CPU_Burst(fset->output_file, task-1, thread-1, temps); receiver= Get_EvTarget(current); send_tag= Get_EvTag(current); send_size= Get_EvSize(current); break; case EVT_END: #ifdef CPUZERO MPTRACE_ERROR(Dimemas_CPU_Burst(fset->output_file, task-1, thread-1, 0)); #endif if (Get_EvTarget( current ) != MPI_PROC_NULL) { sender= Get_EvTarget(current); receive_tag= Get_EvTag(current); receive_size= Get_EvSize(current); #ifdef CPUZERO Dimemas_CPU_Burst(fset->output_file, task-1, thread-1, 0); #endif Dimemas_NX_Irecv (fset->output_file, task-1, thread-1, sender, comunicador, receive_size, receive_tag); } if (receiver != MPI_PROC_NULL) { #ifdef CPUZERO Dimemas_CPU_Burst(fset->output_file, task-1, thread-1, 0); #endif Dimemas_NX_BlockingSend (fset->output_file, task-1, thread-1, receiver, Get_EvComm(current), send_size, send_tag); } if (Get_EvTarget( current ) != MPI_PROC_NULL) { #ifdef CPUZERO Dimemas_CPU_Burst(fset->output_file, task-1, thread-1, 0); #endif Dimemas_NX_Wait (fset->output_file, task-1, thread-1, sender, comunicador, receive_size, receive_tag); } #ifdef CPUZERO Dimemas_CPU_Burst(fset->output_file, task-1, thread-1, 0); #endif break; } Translate_MPI_MPIT2PRV (Get_EvEvent(current), Get_EvValue(current), &tipus, &valor); Dimemas_User_Event (fset->output_file, task-1, thread-1, tipus, valor); return 0; }
int MPI_PersistentRequest_Event (event_t * current_event, unsigned long long current_time, unsigned int cpu, unsigned int ptask, unsigned int task, unsigned int thread, FileSet_t *fset) { thread_t *thread_info; task_t *task_info, *task_info_partner; event_t *recv_begin, *recv_end; event_t *send_begin, *send_end; off_t send_position; unsigned recv_thread, send_thread, recv_vthread, send_vthread; int EvComm; EvComm = Get_EvComm( current_event ); thread_info = GET_THREAD_INFO(ptask, task, thread); task_info = GET_TASK_INFO(ptask, task); trace_paraver_state (cpu, ptask, task, thread, current_time); /* If this is a send, look for the receive */ if (Get_EvValue (current_event) == MPI_ISEND_EV) { thread_info->Send_Rec = current_event; if (MatchComms_Enabled(ptask, task)) { if (MPI_PROC_NULL != Get_EvTarget (current_event)) { int target_ptask = intercommunicators_get_target_ptask( ptask, task, EvComm ); if (isTaskInMyGroup (fset, target_ptask-1, Get_EvTarget(current_event))) { #if defined(DEBUG) fprintf (stderr, "PERS_REQ_ISEND_CMD(%u): TIME/TIMESTAMP %lld/%lld IAM %d PARTNER %d tag %d\n", Get_EvValue (current_event), current_time, Get_EvTime(current_event), task-1, Get_EvTarget(current_event), Get_EvTag(current_event)); #endif task_info_partner = GET_TASK_INFO(target_ptask, Get_EvTarget(current_event)+1); CommunicationQueues_ExtractRecv (task_info_partner->recv_queue, task-1, Get_EvTag (current_event), &recv_begin, &recv_end, &recv_thread, &recv_vthread, 0); if (recv_begin == NULL || recv_end == NULL) { off_t position; #if defined(DEBUG) fprintf (stderr, "PER_REQ_ISEND_CMD DID NOT find a partner\n"); #endif position = WriteFileBuffer_getPosition (thread_info->file->wfb); CommunicationQueues_QueueSend (task_info->send_queue, current_event, current_event, position, thread, thread_info->virtual_thread, Get_EvTarget(current_event), Get_EvTag(current_event), 0); trace_paraver_unmatched_communication (1, ptask, task, thread, thread_info->virtual_thread, current_time, Get_EvTime(current_event), 1, target_ptask, Get_EvTarget(current_event)+1, 1, Get_EvSize(current_event), Get_EvTag(current_event)); } else { #if defined(DEBUG) fprintf (stderr, "PER_REQ_ISEND_CMD DID NOT find a partner\n"); #endif trace_communicationAt (ptask, task, thread, thread_info->virtual_thread, target_ptask, 1+Get_EvTarget(current_event), recv_thread, recv_vthread, current_event, current_event, recv_begin, recv_end, FALSE, 0); } } #if defined(PARALLEL_MERGE) else { #if defined(DEBUG) fprintf (stdout, "SEND_CMD(%u): TIME/TIMESTAMP %lld/%lld IAM %d PARTNER %d tag %d >> PENDING\n", Get_EvEvent(current_event), current_time, Get_EvTime(current_event), task-1, Get_EvTarget(current_event), Get_EvTag(current_event)); #endif trace_pending_communication (ptask, task, thread, thread_info->virtual_thread, thread_info->Send_Rec, current_event, target_ptask, Get_EvTarget (current_event)); } #endif } } } /* If this is a receive, look for the send */ if (Get_EvValue(current_event) == MPI_IRECV_EV) { thread_info->Recv_Rec = current_event; if (MatchComms_Enabled(ptask, task)) { event_t *receive = Search_MPI_IRECVED (current_event, Get_EvAux (current_event), thread_info->file); if (NULL != receive) { int target_ptask = intercommunicators_get_target_ptask( ptask, task, EvComm ); if (MPI_PROC_NULL != Get_EvTarget(receive)) { if (isTaskInMyGroup (fset, target_ptask-1, Get_EvTarget(receive))) { #if defined(DEBUG) fprintf (stderr, "PERS_REQ_IRECV_CMD(%u): TIME/TIMESTAMP %lld/%lld IAM %d PARTNER %d tag %d\n", Get_EvValue (current_event), current_time, Get_EvTime(current_event), task-1, Get_EvTarget(receive), Get_EvTag(receive)); #endif task_info_partner = GET_TASK_INFO(ptask, Get_EvTarget(receive)+1); CommunicationQueues_ExtractSend (task_info_partner->send_queue, task-1, Get_EvTag (receive), &send_begin, &send_end, &send_position, &send_thread, &send_vthread, 0); if (NULL == send_begin || NULL == send_end) { #if defined(DEBUG) fprintf (stderr, "PER_REQ_IRECV_CMD DID NOT find a partner\n"); #endif CommunicationQueues_QueueRecv (task_info->recv_queue, current_event, receive, thread, thread_info->virtual_thread, Get_EvTarget(current_event), Get_EvTag(current_event), 0); } else if (NULL != send_begin && NULL != send_end) { #if defined(DEBUG) fprintf (stderr, "PERS_REQ_IRECV_CMD find partner (send position = %llu)\n", (unsigned long long) send_position); #endif trace_communicationAt (target_ptask, 1+Get_EvTarget(receive), send_thread, send_vthread, ptask, task, thread, thread_info->virtual_thread, send_begin, send_end, current_event, receive, TRUE, send_position); } else fprintf (stderr, "mpi2prv: Attention CommunicationQueues_ExtractSend returned send_begin = %p and send_end = %p\n", send_begin, send_end); } #if defined(PARALLEL_MERGE) else { UINT64 log_r, phy_r; log_r = TIMESYNC (ptask-1, task-1, Get_EvTime(current_event)); phy_r = TIMESYNC (ptask-1, task-1, Get_EvTime(receive)); AddForeignRecv (phy_r, log_r, Get_EvTag(receive), ptask-1, task-1, thread-1, thread_info->virtual_thread-1, target_ptask-1, Get_EvTarget(receive), fset, MatchComms_GetZone(ptask, task)); } #endif } } } } return 0; }
static int IRecv_Event (event_t * current_event, unsigned long long current_time, unsigned int cpu, unsigned int ptask, unsigned int task, unsigned int thread, FileSet_t *fset) { event_t *send_begin, *send_end; off_t send_position; unsigned EvType, EvValue, send_thread, send_vthread; thread_t *thread_info; task_t *task_info, *task_info_partner; int EvComm; thread_info = GET_THREAD_INFO(ptask, task, thread); task_info = GET_TASK_INFO(ptask, task); EvType = Get_EvEvent (current_event); EvValue = Get_EvValue (current_event); EvComm = Get_EvComm (current_event); Switch_State (STATE_IWAITMESS, (EvValue == EVT_BEGIN), ptask, task, thread); if (EvValue == EVT_END) { if (MatchComms_Enabled(ptask, task)) { event_t *receive = Search_MPI_IRECVED (current_event, Get_EvAux (current_event), thread_info->file); if (NULL != receive) { if (MPI_PROC_NULL != Get_EvTarget(receive)) { int target_ptask = intercommunicators_get_target_ptask( ptask, task, EvComm ); if (isTaskInMyGroup (fset, target_ptask-1, Get_EvTarget(receive))) { #if defined(DEBUG) fprintf (stderr, "IRECV_CMD: TIME/TIMESTAMP %lld/%lld IAM %d PARTNER %d tag %d\n", current_time, Get_EvTime(current_event), task-1, Get_EvTarget(receive), Get_EvTag(receive)); #endif task_info_partner = GET_TASK_INFO(target_ptask, Get_EvTarget(receive)+1); CommunicationQueues_ExtractSend (task_info_partner->send_queue, task-1, Get_EvTag (receive), &send_begin, &send_end, &send_position, &send_thread, &send_vthread, 0); if (NULL == send_begin || NULL == send_end) { #if defined(DEBUG) fprintf (stderr, "IRECV_CMD DID NOT find COMM\n"); #endif CommunicationQueues_QueueRecv (task_info->recv_queue, current_event, receive, thread, thread_info->virtual_thread, Get_EvTarget(receive), Get_EvTag(receive), 0); } else if (NULL != send_begin && NULL != send_end) { #if defined(DEBUG) fprintf (stderr, "IRECV_CMD find COMM (partner times = %lld/%lld)\n", Get_EvTime(send_begin), Get_EvTime(send_end)); #endif trace_communicationAt (target_ptask, 1+Get_EvTarget(receive), send_thread, send_vthread, ptask, task, thread, thread_info->virtual_thread, send_begin, send_end, current_event, receive, TRUE, send_position); } else fprintf (stderr, "mpi2prv: Attention CommunicationQueues_ExtractSend returned send_begin = %p and send_end = %p\n", send_begin, send_end); } #if defined(PARALLEL_MERGE) else { UINT64 log_r, phy_r; log_r = TIMESYNC (ptask-1, task-1, Get_EvTime(current_event)); phy_r = TIMESYNC (ptask-1, task-1, Get_EvTime(receive)); AddForeignRecv (phy_r, log_r, Get_EvTag(receive), ptask-1, task-1, thread-1, thread_info->virtual_thread-1, target_ptask-1, Get_EvTarget(receive), fset, MatchComms_GetZone(ptask, task)); } #endif } } } } trace_paraver_state (cpu, ptask, task, thread, current_time); trace_paraver_event (cpu, ptask, task, thread, current_time, EvType, EvValue); return 0; }
static int SendRecv_Event (event_t * current_event, unsigned long long current_time, unsigned int cpu, unsigned int ptask, unsigned int task, unsigned int thread, FileSet_t *fset) { thread_t *thread_info; task_t *task_info, *task_info_partner; #if !defined(AVOID_SENDRECV) unsigned recv_thread, send_thread, recv_vthread, send_vthread; event_t *recv_begin, *recv_end, *send_begin, *send_end; off_t send_position; #endif int EvComm = Get_EvComm (current_event); Switch_State (STATE_SENDRECVOP, (Get_EvValue(current_event) == EVT_BEGIN), ptask, task, thread); trace_paraver_state (cpu, ptask, task, thread, current_time); trace_paraver_event (cpu, ptask, task, thread, current_time, Get_EvEvent(current_event), Get_EvValue(current_event)); thread_info = GET_THREAD_INFO(ptask, task, thread); task_info = GET_TASK_INFO(ptask, task); if (!get_option_merge_SkipSendRecvComms()) { if (Get_EvValue (current_event) == EVT_BEGIN) { thread_info->Send_Rec = current_event; /* Treat the send part */ if (MatchComms_Enabled(ptask, task)) if (MPI_PROC_NULL != Get_EvTarget (thread_info->Send_Rec)) { int target_ptask = intercommunicators_get_target_ptask( ptask, task, EvComm ); if (isTaskInMyGroup (fset, target_ptask-1, Get_EvTarget(thread_info->Send_Rec))) { #if defined(DEBUG) fprintf (stderr, "SENDRECV/SEND: TIME/TIMESTAMP %lld/%lld IAM %d PARTNER %d tag %d\n", current_time, Get_EvTime(thread_info->Send_Rec), task-1, Get_EvTarget(thread_info->Send_Rec), Get_EvTag(thread_info->Send_Rec)); #endif task_info_partner = GET_TASK_INFO(target_ptask, Get_EvTarget(thread_info->Send_Rec)+1); CommunicationQueues_ExtractRecv (task_info_partner->recv_queue, task-1, Get_EvTag (thread_info->Send_Rec), &recv_begin, &recv_end, &recv_thread, &recv_vthread, 0); if (recv_begin == NULL || recv_end == NULL) { off_t position; #if defined(DEBUG) fprintf (stderr, "SENDRECV/SEND DID NOT find partner\n"); #endif position = WriteFileBuffer_getPosition (thread_info->file->wfb); CommunicationQueues_QueueSend (task_info->send_queue, thread_info->Send_Rec, current_event, position, thread, thread_info->virtual_thread, Get_EvTarget(thread_info->Send_Rec), Get_EvTag(thread_info->Send_Rec), 0); trace_paraver_unmatched_communication (1, ptask, task, thread, thread_info->virtual_thread, current_time, Get_EvTime(current_event), 1, target_ptask, Get_EvTarget(current_event)+1, 1, Get_EvSize(current_event), Get_EvTag(current_event)); } else if (recv_begin != NULL && recv_end != NULL) { #if defined(DEBUG) fprintf (stderr, "SENDRECV/SEND found partner\n"); #endif trace_communicationAt (ptask, task, thread, thread_info->virtual_thread, target_ptask, 1+Get_EvTarget(thread_info->Send_Rec), recv_thread, recv_vthread, thread_info->Send_Rec, current_event, recv_begin, recv_end, FALSE, 0); } else fprintf (stderr, "mpi2prv: Attention CommunicationQueues_ExtractRecv returned recv_begin = %p and recv_end = %p\n", recv_begin, recv_end); } #if defined(PARALLEL_MERGE) else { #if defined(DEBUG) fprintf (stdout, "SEND_CMD(%u): TIME/TIMESTAMP %lld/%lld IAM %d PARTNER %d tag %d >> PENDING\n", Get_EvEvent(current_event), current_time, Get_EvTime(current_event), task-1, Get_EvTarget(current_event), Get_EvTag(current_event)); #endif trace_pending_communication (ptask, task, thread, thread_info->virtual_thread, thread_info->Send_Rec, current_event, target_ptask, Get_EvTarget (thread_info->Send_Rec)); } #endif /* PARALLEL_MERGE */ } } else if (Get_EvValue (current_event) == EVT_END) { thread_info->Recv_Rec = current_event; /* Treat the receive part */ if (MatchComms_Enabled(ptask, task)) if (MPI_PROC_NULL != Get_EvTarget (thread_info->Recv_Rec)) { int target_ptask = intercommunicators_get_target_ptask( ptask, task, EvComm ); if (isTaskInMyGroup (fset, target_ptask-1, Get_EvTarget(thread_info->Recv_Rec))) { #if defined(DEBUG) fprintf (stderr, "SENDRECV/RECV: TIME/TIMESTAMP %lld/%lld IAM %d PARTNER %d tag %d\n", current_time, Get_EvTime(thread_info->Recv_Rec), task-1, Get_EvTarget(thread_info->Recv_Rec), Get_EvTag(thread_info->Recv_Rec)); #endif task_info_partner = GET_TASK_INFO(target_ptask, Get_EvTarget(thread_info->Recv_Rec)+1); CommunicationQueues_ExtractSend (task_info_partner->send_queue, task-1, Get_EvTag (thread_info->Recv_Rec), &send_begin, &send_end, &send_position, &send_thread, &send_vthread, 0); if (NULL == send_begin && NULL == send_end) { #if defined(DEBUG) fprintf (stderr, "SENDRECV/RECV DID NOT find partner\n"); #endif CommunicationQueues_QueueRecv (task_info->recv_queue, thread_info->Send_Rec, current_event, thread, thread_info->virtual_thread, Get_EvTarget(thread_info->Recv_Rec), Get_EvTag(thread_info->Recv_Rec), 0); } else if (NULL != send_begin && NULL != send_end) { #if defined(DEBUG) fprintf (stderr, "SENDRECV/RECV found partner\n"); #endif trace_communicationAt (target_ptask, 1+Get_EvTarget(thread_info->Recv_Rec), send_thread, send_vthread, ptask, task, thread, thread_info->virtual_thread, send_begin, send_end, thread_info->Send_Rec, thread_info->Recv_Rec, TRUE, send_position); } else fprintf (stderr, "mpi2prv: Attention CommunicationQueues_ExtractSend returned send_begin = %p and send_end = %p\n", send_begin, send_end); } #if defined(PARALLEL_MERGE) else { UINT64 log_r, phy_r; log_r = TIMESYNC (ptask-1, task-1, Get_EvTime(thread_info->Send_Rec)); phy_r = TIMESYNC (ptask-1, task-1, Get_EvTime(current_event)); AddForeignRecv (phy_r, log_r, Get_EvTag(current_event), ptask-1, task-1, thread-1, thread_info->virtual_thread-1, target_ptask-1, Get_EvTarget(current_event), fset, MatchComms_GetZone(ptask, task)); } #endif /* PARALLEL_MERGE */ } } } return 0; }
static int Any_Send_Event (event_t * current_event, unsigned long long current_time, unsigned int cpu, unsigned int ptask, unsigned int task, unsigned int thread, FileSet_t *fset) { unsigned recv_thread, recv_vthread, EvType, EvValue; thread_t *thread_info; task_t *task_info, *task_info_partner; event_t * recv_begin, * recv_end; int EvComm; EvType = Get_EvEvent(current_event); EvValue = Get_EvValue(current_event); EvComm = Get_EvComm (current_event); Switch_State (Get_State(EvType), (EvValue == EVT_BEGIN), ptask, task, thread); trace_paraver_state (cpu, ptask, task, thread, current_time); trace_paraver_event (cpu, ptask, task, thread, current_time, EvType, EvValue); thread_info = GET_THREAD_INFO(ptask, task, thread); task_info = GET_TASK_INFO(ptask, task); switch (EvValue) { case EVT_BEGIN: thread_info->Send_Rec = current_event; break; case EVT_END: if (MatchComms_Enabled(ptask, task)) { if (MPI_PROC_NULL != Get_EvTarget (current_event)) { int target_ptask = intercommunicators_get_target_ptask( ptask, task, EvComm ); if (isTaskInMyGroup (fset, target_ptask-1, Get_EvTarget(current_event))) { #if defined(DEBUG) fprintf (stderr, "SEND_CMD(%u): TIME/TIMESTAMP %lld/%lld IAM %d PARTNER %d tag %d\n", EvType, current_time, Get_EvTime(current_event), task-1, Get_EvTarget(current_event), Get_EvTag(current_event)); #endif task_info_partner = GET_TASK_INFO(target_ptask, Get_EvTarget(current_event)+1); CommunicationQueues_ExtractRecv (task_info_partner->recv_queue, task-1, Get_EvTag (current_event), &recv_begin, &recv_end, &recv_thread, &recv_vthread, 0); if (recv_begin == NULL || recv_end == NULL) { off_t position; #if defined(DEBUG) fprintf (stderr, "SEND_CMD(%u) DID NOT find receiver\n", EvType); #endif position = WriteFileBuffer_getPosition (thread_info->file->wfb); CommunicationQueues_QueueSend (task_info->send_queue, thread_info->Send_Rec, current_event, position, thread, thread_info->virtual_thread, Get_EvTarget(current_event), Get_EvTag(current_event), 0); trace_paraver_unmatched_communication (1, ptask, task, thread, thread_info->virtual_thread, current_time, Get_EvTime(current_event), 1, target_ptask, Get_EvTarget(current_event)+1, 1, Get_EvSize(current_event), Get_EvTag(current_event)); } else { #if defined(DEBUG) fprintf (stderr, "SEND_CMD(%u) find receiver\n", EvType); #endif trace_communicationAt (ptask, task, thread, thread_info->virtual_thread, target_ptask, 1+Get_EvTarget(current_event), recv_thread, recv_vthread, thread_info->Send_Rec, current_event, recv_begin, recv_end, FALSE, 0); } } #if defined(PARALLEL_MERGE) else { #if defined(DEBUG) fprintf (stdout, "SEND_CMD(%u): TIME/TIMESTAMP %lld/%lld IAM %d PARTNER %d tag %d >> PENDING\n", Get_EvEvent(current_event), current_time, Get_EvTime(current_event), task-1, Get_EvTarget(current_event), Get_EvTag(current_event)); #endif trace_pending_communication (ptask, task, thread, thread_info->virtual_thread, thread_info->Send_Rec, current_event, target_ptask, Get_EvTarget (current_event)); } #endif } } break; } return 0; }