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 trace_pending_communication (unsigned int ptask, unsigned int task, unsigned int thread, unsigned vthread, event_t * begin_s, event_t * end_s, unsigned int recvr) { unsigned long long log_s, phy_s; /* Synchronize event times */ log_s = TIMESYNC (ptask-1, task-1, Get_EvTime (begin_s)); phy_s = TIMESYNC (ptask-1, task-1, Get_EvTime (end_s)); trace_paraver_pending_communication (task, ptask, task, thread, vthread, log_s, phy_s, recvr + 1, ptask, recvr + 1, thread /* 1? */ , thread /*vthread_r?*/, 0ULL, 0ULL, Get_EvSize (begin_s), Get_EvTag (begin_s)); return 0; }
BufferIterator_t * BufferIterator_NewRange (Buffer_t *buffer, unsigned long long start_time, unsigned long long end_time) { BufferIterator_t *itf, *itb, *itrange; int found_start_bound = FALSE, found_end_bound = FALSE; int count1 = 0, count2 = 0; itrange = new_Iterator(buffer); ASSERT_VALID_ITERATOR(itrange); itf = BIT_NewForward(buffer); itb = BIT_NewBackward(buffer); /* Search for the start boundary */ while ((!BIT_OutOfBounds(itf)) && (!found_start_bound)) { event_t *cur = BIT_GetEvent(itf); if (Get_EvTime(cur) >= start_time) { found_start_bound = TRUE; itrange->StartBound = cur; } count1++; BIT_Next(itf); } /* Search for the end boundary */ while ((!BIT_OutOfBounds(itb)) && (!found_end_bound)) { event_t *cur = BIT_GetEvent(itb); if (Get_EvTime(cur) <= end_time) { found_end_bound = TRUE; itrange->EndBound = cur; } count2++; BIT_Prev(itb); } itrange->CurrentElement = itrange->StartBound; itrange->OutOfBounds = !(found_start_bound && found_end_bound); return itrange; }
void SpectralWorker::ProcessPeriods(vector<Period> &AllPeriods, BurstsExtractor *ExtractedBursts) { Buffer_t *buffer = ExtractedBursts->GetBuffer(); unsigned long long FirstEvtTime = Get_EvTime(Buffer_GetFirstEvent(buffer)); unsigned long long LastEvtTime = Get_EvTime(Buffer_GetLastEvent(buffer)); int LevelAtPeriodZone = Online_GetSpectralPeriodZoneLevel(); int LevelAtNonPeriodZone = Online_GetSpectralNonPeriodZoneLevel(); unsigned long long NonPeriodZoneMinDuration = Online_GetSpectralNonPeriodZoneMinDuration(); unsigned long long PreviousPeriodZoneEnd = 0; unsigned long long AutomaticBurstThreshold = 100000; int NumDetectedPeriods = AllPeriods.size(); Bursts *BurstsData = ExtractedBursts->GetBursts(); Chopper *Chop = new Chopper(); if (FirstEvtTime < Online_GetAppResumeTime()) FirstEvtTime = Online_GetAppResumeTime(); if (LastEvtTime > Online_GetAppPauseTime()) LastEvtTime = Online_GetAppPauseTime(); /* Mask out all traced data */ Chop->MaskAll(); /* Compute the burst threshold that keeps the configured percentage of computations */ if (LevelAtNonPeriodZone == BURST_MODE) { AutomaticBurstThreshold = ExtractedBursts->AdjustThreshold( Online_GetSpectralBurstThreshold() ); } /* Process each period */ for (int i=0; i<NumDetectedPeriods; i++) { Period *CurrentPeriod = &(AllPeriods[i]); Period *PreviousPeriod = (i > 0 ? &(AllPeriods[i-1]) : NULL); Period *NextPeriod = (i < NumDetectedPeriods - 1 ? &(AllPeriods[i+1]) : NULL); unsigned long long PeriodZoneIni = TIMEDESYNC(0, TASKID, CurrentPeriod->info.ini); unsigned long long PeriodZoneEnd = TIMEDESYNC(0, TASKID, CurrentPeriod->info.end); unsigned long long BestItersIni = TIMEDESYNC(0, TASKID, CurrentPeriod->info.best_ini); unsigned long long BestItersEnd = TIMEDESYNC(0, TASKID, CurrentPeriod->info.best_end); long long int PeriodLength = CurrentPeriod->info.length * 1000000; /* Nanoseconds resolution */ int AllIters = (int)(CurrentPeriod->info.iters); int DetailedIters = (int)( (BestItersEnd - BestItersIni) / PeriodLength ); int DetailedItersLeft = DetailedIters; unsigned long long CurrentTime = 0; unsigned long long CurrentTimeFitted = 0; vector<unsigned long long> ItersStartingTimes; vector<bool> ItersInDetail; unsigned long long NonPeriodZoneStart = 0; unsigned long long NonPeriodZoneEnd = 0; bool InsideDetailedZone = false; /* XXX */ if ((AllIters < 1) || (DetailedIters < 1)) continue; /* Project the starting time of each iteration from the first detailed one */ CurrentTime = BestItersIni; while (CurrentTime >= PeriodZoneIni) { CurrentTime -= PeriodLength; } CurrentTime += PeriodLength; /* Now points to the start time of the first iteration in the periodic zone */ /* Adjust the starting time of the iteration to the closest running burst starting time */ for (int count = 0; count <= AllIters; count ++) { CurrentTimeFitted = Chop->FindCloserRunningTime(0, CurrentTime ); ItersStartingTimes.push_back( CurrentTimeFitted ); if ( (CurrentTime >= BestItersIni) && (DetailedItersLeft > 0) ) { ItersInDetail.push_back( true ); DetailedItersLeft --; } else { ItersInDetail.push_back( false ); } CurrentTime += PeriodLength; } /* * vector ItersStartingTimes contains the starting time adjusted to the closest running for each iteration in the periodic zone. * vector ItersInDetail marks for each iteration if it has to be traced in detail or not. */ /* Discard the first and/or last iterations if the time adjustment exceeds the timestamps when the application was resumed/paused */ if (ItersStartingTimes[0] < Online_GetAppResumeTime()) { ItersStartingTimes.erase( ItersStartingTimes.begin() ); } if (ItersStartingTimes[ ItersStartingTimes.size() - 1 ] > Online_GetAppPauseTime()) { ItersStartingTimes.pop_back(); } /* Now emit events marking the phases, the structure is as follows : * ---------------------------------------------------------------------------------------------------------------- * ... ANALYSIS | NON-PERIOD | PERIOD #1 | BEST ITERS | PERIOD #1 | NON-PERIOD | PERIOD #2 | NON-PERIOD | ANALYSIS | * ---------------------------------------------------------------------------------------------------------------- * | | * FirstEvt LastEvt */ if (PreviousPeriod == NULL) /* First period in the current block of trace data */ { if (Online_GetAppResumeTime() > 0) /* Not the first round of analysis */ { /* Mark NOT TRACING from the last analysis */ TRACE_ONLINE_EVENT(Online_GetAppResumeTime(), DETAIL_LEVEL_EV, NOT_TRACING); } /* NON-PERIODIC zone from the first event in the buffer until the start of the first periodic zone */ NonPeriodZoneStart = FirstEvtTime; NonPeriodZoneEnd = ItersStartingTimes[0]; } else /* Further periods in the current block of trace data */ { /* NON-PERIODIC zone from the end of the previous period to the start of the current one */ NonPeriodZoneStart = PreviousPeriodZoneEnd; NonPeriodZoneEnd = ItersStartingTimes[0]; } Summarize( NonPeriodZoneStart, NonPeriodZoneEnd, NonPeriodZoneMinDuration, LevelAtNonPeriodZone, BurstsData, AutomaticBurstThreshold ); /* PERIODIC zone */ TRACE_ONLINE_EVENT(ItersStartingTimes[0], DETAIL_LEVEL_EV, LevelAtPeriodZone); for (unsigned int current_iter = 0; current_iter < ItersStartingTimes.size() - 1; current_iter ++) { if (ItersInDetail[current_iter] && !InsideDetailedZone) { InsideDetailedZone = true; TRACE_ONLINE_EVENT(ItersStartingTimes[current_iter], DETAIL_LEVEL_EV, DETAIL_MODE); /* Entry of detailed zone */ } else if (!ItersInDetail[current_iter] && InsideDetailedZone) { InsideDetailedZone = false; TRACE_ONLINE_EVENT(ItersStartingTimes[current_iter], DETAIL_LEVEL_EV, LevelAtPeriodZone); /* Exit of detailed zone */ } /* Emit the period ID at the start of each iteration */ TRACE_ONLINE_EVENT(ItersStartingTimes[current_iter], PERIODICITY_EV, REPRESENTATIVE_PERIOD + CurrentPeriod->id); if (LevelAtPeriodZone == PHASE_PROFILE) { BurstsData->EmitPhase( ItersStartingTimes[current_iter], ItersStartingTimes[current_iter + 1], (current_iter == 0), !InsideDetailedZone ); } } /* NON-PERIODIC zone after the PERIODIC zone */ TRACE_ONLINE_EVENT(ItersStartingTimes[ ItersStartingTimes.size() - 1 ], PERIODICITY_EV, NON_PERIODIC_ZONE); PreviousPeriodZoneEnd = ItersStartingTimes[ ItersStartingTimes.size() - 1 ]; if (NextPeriod == NULL) { NonPeriodZoneStart = PreviousPeriodZoneEnd; NonPeriodZoneEnd = LastEvtTime; Summarize( NonPeriodZoneStart, NonPeriodZoneEnd, NonPeriodZoneMinDuration, LevelAtNonPeriodZone, BurstsData, AutomaticBurstThreshold ); TRACE_ONLINE_EVENT( NonPeriodZoneEnd, DETAIL_LEVEL_EV, NOT_TRACING ); } if (CurrentPeriod->traced) { Chop->UnmaskAll( BestItersIni, BestItersEnd ); } /* DEBUG -- Raw values returned by the spectral analysis TRACE_ONLINE_EVENT(PeriodZoneIni, RAW_PERIODICITY_EV, REPRESENTATIVE_PERIOD + CurrentPeriod->id); TRACE_ONLINE_EVENT(PeriodZoneEnd, RAW_PERIODICITY_EV, 0); TRACE_ONLINE_EVENT(BestItersIni, RAW_BEST_ITERS_EV, REPRESENTATIVE_PERIOD + CurrentPeriod->id); TRACE_ONLINE_EVENT(BestItersEnd, RAW_BEST_ITERS_EV, 0); */ } delete Chop; }
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; }
/****************************************************************************** *** BuildCommunicatorFromFile ******************************************************************************/ static unsigned int BuildCommunicatorFromFile (event_t *current_event, unsigned long long current_time, unsigned int cpu, unsigned int ptask, unsigned int task, unsigned int thread, FileSet_t * fset) { TipusComunicador new_comm; unsigned int i = 0; unsigned int foo; unsigned int EvType = Get_EvEvent (current_event); UNREFERENCED_PARAMETER(current_time); UNREFERENCED_PARAMETER(cpu); /* New communicator definition starts */ new_comm.id = Get_EvComm (current_event); new_comm.num_tasks = Get_EvSize (current_event); new_comm.tasks = (int*) malloc(sizeof(int)*new_comm.num_tasks); if (NULL == new_comm.tasks) { fprintf (stderr, "mpi2prv: Can't allocate memory for a COMM SELF alias\n"); fflush (stderr); exit (-1); } #if defined(DEBUG_COMMUNICATORS) fprintf (stderr, "DEBUG: New comm: id=%lu, num_tasks=%u\n", new_comm.id, new_comm.num_tasks); #endif /* Process each communicator member */ current_event = GetNextEvent_FS (fset, &foo, &ptask, &task, &thread); if (current_event != NULL) EvType = Get_EvEvent (current_event); while (i < new_comm.num_tasks && current_event != NULL && (EvType == MPI_RANK_CREACIO_COMM_EV || EvType == FLUSH_EV)) { if (EvType == MPI_RANK_CREACIO_COMM_EV) { /* Save this task as member of the communicator */ new_comm.tasks[i] = Get_EvValue (current_event); #if defined(DEBUG_COMMUNICATORS) fprintf (stderr, " -- task %d\n", new_comm.tasks[i]); #endif i++; } if (i < new_comm.num_tasks) { current_event = GetNextEvent_FS (fset, &foo, &ptask, &task, &thread); if (current_event != NULL) EvType = Get_EvEvent (current_event); } } /* End of communicator definition. Assign an alias for this communicator. */ if (i != new_comm.num_tasks) { unsigned long long tmp_time = 0; if (current_event != NULL) tmp_time = Get_EvTime(current_event); fprintf (stderr, "mpi2prv: Error: Incorrect communicator definition! (%d out of %d definitions)\n" "EvType: %u, Time: %llu, ptask: %u, task: %u, thread: %u\n", i, new_comm.num_tasks, EvType, tmp_time, ptask, task, thread); exit (0); } else { #if defined(PARALLEL_MERGE) ParallelMerge_AddIntraCommunicator (ptask, task, 0, new_comm.id, new_comm.num_tasks, new_comm.tasks); #else afegir_comunicador (&new_comm, ptask, task); #endif } free (new_comm.tasks); return i; }