void trace_enter_global_op (unsigned int cpu, unsigned int ptask,
unsigned int task, unsigned int thread, unsigned long long time,
unsigned int com_id, unsigned int send_size, unsigned int recv_size,
unsigned int is_root)
{
trace_paraver_event (cpu, ptask, task, thread, time, MPI_GLOBAL_OP_SENDSIZE, send_size);
trace_paraver_event (cpu, ptask, task, thread, time, MPI_GLOBAL_OP_RECVSIZE, recv_size);
trace_paraver_event (cpu, ptask, task, thread, time, MPI_GLOBAL_OP_COMM, com_id);
if (is_root)
trace_paraver_event (cpu, ptask, task, thread, time, MPI_GLOBAL_OP_ROOT, is_root);
}
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;
}
static int Any_Incoming_OPENSHMEM_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)
{
UNREFERENCED_PARAMETER(fset);
unsigned int EvType = Get_EvEvent(current_event);
unsigned long EvValue = ((Get_EvValue (current_event) > 0) ? EvType - OPENSHMEM_BASE_EVENT + 1 : 0);
unsigned int EvSize = Get_EvSize (current_event);
Switch_State (Get_State(EvType), (EvValue != EVT_END), ptask, task, thread);
trace_paraver_state (cpu, ptask, task, thread, current_time);
trace_paraver_event (cpu, ptask, task, thread, current_time, OPENSHMEM_BASE_EVENT, EvValue);
trace_paraver_event (cpu, ptask, task, thread, current_time, OPENSHMEM_RECVBYTES_EV, EvSize);
return 0;
}
static int Other_MPI_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;
UNREFERENCED_PARAMETER(fset);
EvType = Get_EvEvent (current_event);
EvValue = Get_EvValue (current_event);
Switch_State (Get_State(EvType), (EvValue == EVT_BEGIN), ptask, task, thread);
/* XXX: Workaround to set the state to NOT_TRACING after the MPI_Init when using circular buffer.
* We should definitely do this another way round.
*/
if ((EvType == MPI_INIT_EV) && (EvValue == EVT_END))
{
if ((tracingCircularBuffer()) && (getBehaviourForCircularBuffer() == CIRCULAR_SKIP_MATCHES))
{
/* The first event beyond the MPI_Init will remove the STATE_NOT_TRACING (see Push_State) */
Push_State (STATE_NOT_TRACING, ptask, task, thread);
}
}
trace_paraver_state (cpu, ptask, task, thread, current_time);
trace_paraver_event (cpu, ptask, task, thread, current_time, EvType, EvValue);
if (EvType == MPI_INIT_EV && EvValue == EVT_BEGIN)
{
UINT32 PID = Get_EvTarget (current_event);
UINT32 PPID = Get_EvSize (current_event);
UINT32 Depth = Get_EvTag (current_event);
trace_paraver_event (cpu, ptask, task, thread, current_time, PID_EV, PID);
trace_paraver_event (cpu, ptask, task, thread, current_time, PPID_EV, PPID);
trace_paraver_event (cpu, ptask, task, thread, current_time, FORK_DEPTH_EV, Depth);
}
return 0;
}
/******************************************************************************
*** MPI_RMA_Event (Remote Memory Address)
******************************************************************************/
int MPI_RMA_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)
{
UNREFERENCED_PARAMETER(fset);
Switch_State (Get_State(Get_EvEvent(current_event)),
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));
return 0;
}
int MPI_Request_get_status_SoftwareCounter_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;
UNREFERENCED_PARAMETER(fset);
EvType = Get_EvEvent (current_event);
EvValue = Get_EvValue (current_event);
trace_paraver_state (cpu, ptask, task, thread, current_time);
trace_paraver_event (cpu, ptask, task, thread, current_time, EvType, EvValue);
Enable_MPI_Soft_Counter (EvType);
return 0;
}
int MPI_PersistentRequest_Free_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;
UNREFERENCED_PARAMETER(fset);
EvType = Get_EvEvent (current_event);
EvValue = Get_EvValue (current_event);
Switch_State (STATE_TWRECV, (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);
return 0;
}
int MPI_ElapsedTimeOutsideRequest_get_status_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;
unsigned long long EvValue;
UINT64 elapsed_time;
UNREFERENCED_PARAMETER(fset);
EvType = Get_EvEvent (current_event);
elapsed_time = Get_EvValue (current_event);
EvValue = (unsigned long long) (elapsed_time);
trace_paraver_state (cpu, ptask, task, thread, current_time);
trace_paraver_event (cpu, ptask, task, thread, current_time, EvType, EvValue);
Enable_MPI_Soft_Counter (EvType);
return 0;
}
static int GlobalOP_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;
unsigned int comm_id, send_size, receive_size, is_root;
UNREFERENCED_PARAMETER(fset);
EvType = Get_EvEvent (current_event);
EvValue = Get_EvValue (current_event);
/* First global operation found, start matching communications from now on */
if ((tracingCircularBuffer()) && /* Circular buffer is enabled */
(getBehaviourForCircularBuffer() == CIRCULAR_SKIP_MATCHES) && /* The buffer behavior is to skip matches */
(!MatchComms_Enabled(ptask, task)) && /* Not matching already */
(EvValue == EVT_END) && /* End of the collective */
(Get_EvSize(current_event) == GET_NUM_TASKS(ptask)) /* World collective */
/* (getTagForCircularBuffer() == Get_EvAux(current_event)) */)
{
MatchComms_On(ptask, task);
}
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);
if (EVT_BEGIN == EvValue)
{
comm_id = Get_GlobalOP_CommID (current_event);
is_root = Get_GlobalOP_isRoot (current_event, task);
send_size = Get_GlobalOP_SendSize (current_event, is_root);
receive_size = Get_GlobalOP_RecvSize (current_event, is_root);
trace_enter_global_op (cpu, ptask, task, thread, current_time, comm_id,
send_size, receive_size, is_root?1:0);
Enable_MPI_Soft_Counter (EvType);
}
return 0;
}
static int OpenCL_Acc_Call (event_t * event, unsigned long long time,
unsigned int cpu, unsigned int ptask, unsigned int task,
unsigned int thread, FileSet_t *fset )
{
unsigned state;
unsigned EvType, nEvType;
unsigned long long EvValue, nEvValue;
UNREFERENCED_PARAMETER(fset);
EvType = Get_EvEvent (event);
EvValue = Get_EvValue (event);
switch (EvType)
{
case OPENCL_CLENQUEUEFILLBUFFER_ACC_EV:
case OPENCL_CLENQUEUECOPYBUFFER_ACC_EV:
case OPENCL_CLENQUEUECOPYBUFFERRECT_ACC_EV:
case OPENCL_CLENQUEUEREADBUFFER_ACC_EV:
case OPENCL_CLENQUEUEWRITEBUFFER_ACC_EV:
case OPENCL_CLENQUEUEREADBUFFERRECT_ACC_EV:
case OPENCL_CLENQUEUEWRITEBUFFERRECT_ACC_EV:
case OPENCL_CLENQUEUEMAPBUFFER_ACC_EV:
case OPENCL_CLENQUEUEMIGRATEMEMOBJECTS_ACC_EV:
state = STATE_MEMORY_XFER;
Switch_State (state, (EvValue != EVT_END), ptask, task, thread);
break;
case OPENCL_CLENQUEUEBARRIERWITHWAITLIST_ACC_EV:
case OPENCL_CLENQUEUEBARRIER_ACC_EV:
state = STATE_BARRIER;
Switch_State (state, (EvValue != EVT_END), ptask, task, thread);
break;
case OPENCL_CLENQUEUENDRANGEKERNEL_ACC_EV:
case OPENCL_CLENQUEUETASK_ACC_EV:
case OPENCL_CLENQUEUENATIVEKERNEL_ACC_EV:
state = STATE_RUNNING;
Switch_State (state, (EvValue != EVT_END), ptask, task, thread);
break;
default:
state = STATE_OVHD;
Switch_State (state, (EvValue != EVT_END), ptask, task, thread);
break;
}
trace_paraver_state (cpu, ptask, task, thread, time);
Translate_OpenCL_Operation (EvType, EvValue, &nEvType, &nEvValue);
trace_paraver_event (cpu, ptask, task, thread, time, nEvType, nEvValue);
if (EvType == OPENCL_CLENQUEUENDRANGEKERNEL_ACC_EV ||
EvType == OPENCL_CLENQUEUETASK_ACC_EV)
{
unsigned long long EvParam;
EvParam = Get_EvParam (event);
trace_paraver_event (cpu, ptask, task, thread, time,
OPENCL_KERNEL_NAME_EV, EvParam);
}
if (EvType == OPENCL_CLENQUEUEREADBUFFER_ACC_EV ||
EvType == OPENCL_CLENQUEUEWRITEBUFFER_ACC_EV ||
EvType == OPENCL_CLENQUEUEREADBUFFERRECT_ACC_EV ||
EvType == OPENCL_CLENQUEUEWRITEBUFFERRECT_ACC_EV ||
EvType == OPENCL_CLENQUEUEREADBUFFER_ASYNC_ACC_EV ||
EvType == OPENCL_CLENQUEUEWRITEBUFFER_ASYNC_ACC_EV ||
EvType == OPENCL_CLENQUEUEREADBUFFERRECT_ASYNC_ACC_EV ||
EvType == OPENCL_CLENQUEUEWRITEBUFFERRECT_ASYNC_ACC_EV)
{
unsigned long long EvParam;
EvParam = Get_EvParam (event);
trace_paraver_event (cpu, ptask, task, thread, time,
OPENCL_CLMEMOP_SIZE_EV, EvParam);
}
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;
}
/******************************************************************************
*** GenerateAliesComunicator
******************************************************************************/
int GenerateAliesComunicator (
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 long long *num_events, int traceformat)
{
unsigned int i = 0;
unsigned int EvValue = Get_EvValue (current_event);
unsigned int EvCommType = Get_EvTarget (current_event);
unsigned int EvType = Get_EvEvent (current_event);
if (EvValue == EVT_BEGIN)
{
#if defined(DEBUG_COMMUNICATORS)
fprintf (stderr, "DEBUG: new communicator definition (commtype = %d)\n",
EvCommType);
#endif
if (PRV_SEMANTICS == traceformat)
if (Get_EvAux (current_event)) /* Shall we emit this into tracefile? */
{
trace_paraver_state (cpu, ptask, task, thread, current_time);
trace_paraver_event (cpu, ptask, task, thread, current_time, EvType, EVT_BEGIN);
}
/* Build COMM WORLD communicator */
if (MPI_COMM_WORLD_ALIAS == EvCommType)
{
TipusComunicador new_comm;
unsigned int i;
#if defined(DEBUG_COMMUNICATORS)
fprintf (stderr, "DEBUG: defining MPI_COMM_WORLD (%d members)\n", Get_EvSize (current_event));
#endif
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 WORLD alias\n");
fflush (stderr);
exit (-1);
}
for (i = 0; i < new_comm.num_tasks; i++)
new_comm.tasks[i] = i;
#if defined(PARALLEL_MERGE)
ParallelMerge_AddIntraCommunicator (ptask, task, MPI_COMM_WORLD_ALIAS, new_comm.id, new_comm.num_tasks, new_comm.tasks);
#else
afegir_comunicador (&new_comm, ptask, task);
#endif
free (new_comm.tasks);
}
/* Build COMM SELF communicator */
else if (MPI_COMM_SELF_ALIAS == EvCommType)
{
TipusComunicador new_comm;
#if defined(DEBUG_COMMUNICATORS)
fprintf (stderr, "DEBUG: defining MPI_COMM_SELF (%d members)\n", Get_EvSize (current_event));
#endif
new_comm.id = Get_EvComm (current_event);
new_comm.num_tasks = 1;
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);
}
new_comm.tasks[0] = task-1;
#if defined(PARALLEL_MERGE)
ParallelMerge_AddIntraCommunicator (ptask, task, MPI_COMM_SELF_ALIAS, new_comm.id, new_comm.num_tasks, new_comm.tasks);
#else
afegir_comunicador (&new_comm, ptask, task);
#endif
free (new_comm.tasks);
}
else if (MPI_NEW_INTERCOMM_ALIAS == EvCommType)
{
#if defined(DEBUG_COMMUNICATORS)
fprintf (stderr, "DEBUG: defining new INTERCOMM\n");
#endif
i = BuildInterCommunicatorFromFile (current_event, current_time, cpu, ptask, task, thread, fset);
}
else
{
#if defined(DEBUG_COMMUNICATORS)
fprintf (stderr, "DEBUG: defining new COMM (%d members id = %d)\n", Get_EvSize(current_event), Get_EvComm (current_event));
#endif
i = BuildCommunicatorFromFile (current_event, current_time, cpu, ptask, task,
thread, fset);
}
}
else if (EvValue == EVT_END)
{
if (PRV_SEMANTICS == traceformat)
if (Get_EvAux (current_event)) /* Shall we emit this into tracefile? */
trace_paraver_event (cpu, ptask, task, thread, current_time, EvType, EVT_END);
}
*num_events = i+1;
/* Count how many records have we processed
(i communicator members + begin of communicator event) */
return 0;
}
