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;
}
