28 #include <sys/types.h>
43 #if defined(PASTIX_BLEND_GENTRACE)
68 blendAddVar(
int clustnum, varPrec time,
const char* type,
69 const char* cont, varPrec val )
71 if ( clustnum == 0 ) {
72 addVar( time, type, cont, val );
97 blendSubVar(
int clustnum, varPrec time,
const char* type,
98 const char* cont, varPrec val )
100 if ( clustnum == 0 ) {
101 subVar( time, type, cont, val );
107 #define blendAddVar( clustnum, time, type, cont, val ) \
110 #define blendSubVar( clustnum, time, type, cont, val ) \
151 pastix_int_t clustsrc,
152 pastix_int_t sync_comm_nbr,
158 double startup, bandwidth, addcost;
163 if( clustsrc == clustdst ) {
167 assert( (clustsrc >= 0) && (clustdst >= 0) );
172 assert( (N > 0) && (M > 0) );
176 *send = (startup + bandwidth * (M * N *
sizeof(double) + FTGT_MAXINFO *
sizeof(pastix_int_t)));
177 addcost = PERF_GEAM( M, N );
178 *add = addcost > 0. ? addcost : 0.0;
207 pastix_int_t i, j, k;
208 pastix_int_t facebloknum, firstbloknum;
218 for(i=0; i<symbptr->
cblknbr; i++, curcblk++)
220 pastix_int_t fbloknum = curcblk[0].
bloknum + 1;
221 pastix_int_t lbloknum = curcblk[1].
bloknum;
224 for(j=fbloknum; j<lbloknum; j++)
229 for(k=j; k<lbloknum; k++)
232 if(facebloknum >= 0) {
234 firstbloknum = facebloknum;
245 for(i=0;i<simuctrl->
tasknbr;i++)
251 for(j=fbloknum; j<lbloknum; j++) {
299 for(i=0; i<symbptr->
cblknbr; i++, curcblk++)
301 pastix_int_t fbloknum = curcblk[0].
bloknum + 1;
302 pastix_int_t lbloknum = curcblk[1].
bloknum;
305 for(j=fbloknum; j<lbloknum; j++)
307 fprintf(fd1,
"%ld %ld\n", (
long)j, (
long)simuctrl->
bloktab[j].
ctrbcnt);
309 #if defined(PASTIX_SYMBOL_DUMP_SYMBMTX)
310 fprintf(fd2,
"%ld %ld %ld\n", (
long)i, (
long)simuctrl->
cblktab[i].
ctrbcnt, (
long)curcblk->split_cblk);
312 fprintf(fd2,
"%ld %ld\n", (
long)i, (
long)simuctrl->
cblktab[i].
ctrbcnt);
347 pastix_int_t tasknum )
352 double ready_date = 0.0;
353 pastix_int_t procnum;
354 pastix_int_t bloknum = task->
bloknum;
355 #if defined(PASTIX_BLEND_COSTLEVEL)
358 pastix_int_t level = cblkcand->
treelevel;
360 assert( tasknum != -1 );
371 procnum <= cblkcand->lcandnum; procnum++, sproc++)
387 procnum <= cblkcand->lcandnum; procnum++, sproc++)
431 static inline pastix_int_t
434 pastix_int_t *procnumptr )
437 pastix_int_t procnum = -1;
438 pastix_int_t tasknum;
439 double earlytimeready = PASTIX_INT_MAX;
440 double earlyproctimer = PASTIX_INT_MAX;
442 pastix_int_t earlytask = -1;
493 timeready = MAX( timeready,
timerVal( &(task->
time) ) );
499 if((timeready == earlytimeready) && (
timerVal(TIMER(p)) < earlyproctimer))
502 earlyproctimer =
timerVal(TIMER(p));
504 earlytimeready = timeready;
507 if(timeready < earlytimeready)
511 earlytimeready = timeready;
516 #if defined(PASTIX_BLEND_GENTRACE)
517 if ( (earlytask != -1) && (ctrl->
clustnum == 0) )
524 p <= cblkcand->lcandnum; p++, sproc++)
529 blendSubVar( ctrl->
clustnum, earlytimeready,
"VR_AP",
"Appli", 1 );
545 *procnumptr = procnum;
579 pastix_int_t tasknum )
582 double lftgttime = 0;
583 double sftgttime = 0;
584 pastix_int_t lftgtnum = -1;
585 pastix_int_t cblknum;
586 pastix_int_t bloknum;
587 pastix_int_t clustdst;
605 for(i=simuctrl->
bloktab[bloknum].
ftgtnum; i<simuctrl->bloktab[bloknum+1].ftgtnum; i++)
608 clustdst = INDEX2CLUST(i, bloknum);
630 #if defined(PASTIX_DEBUG_BLEND)
632 pastix_print_error(
"ftgt %ld costsend %f", (
long)i, simuctrl->
ftgttab[i].
costsend );
635 pastix_print_error(
"ftgt %ld costadd %f", (
long)i, simuctrl->
ftgttab[i].
costadd );
663 for(i=simuctrl->
bloktab[bloknum].
ftgtnum; i<simuctrl->bloktab[bloknum+1].ftgtnum;i++)
706 pastix_int_t ftgtnum,
707 pastix_int_t bloknum,
708 pastix_int_t fbloknum )
771 pastix_int_t tasknum )
774 pastix_int_t cblknum;
775 pastix_int_t fbloknum;
776 pastix_int_t lbloknum;
777 pastix_int_t firstfacingblok;
778 pastix_int_t facingblok;
779 pastix_int_t facingcblk;
781 pastix_int_t ftgtnum;
782 pastix_int_t procnum;
783 pastix_int_t clustnum;
788 procnum = simuctrl->
ownetab[cblknum];
790 sproc = &(simuctrl->
proctab[procnum]);
797 (procnum <= ctrl->candtab[cblknum].lcandnum) );
802 for(i=fbloknum+1; i<lbloknum; i++)
818 for(j=i; j<lbloknum; j++)
824 if( facingblok >= 0 ) {
825 pastix_int_t facingdiagblok;
826 pastix_int_t facingtask;
837 firstfacingblok = facingblok;
843 assert( facingtask < simuctrl->tasknbr );
847 ftgtnum = CLUST2INDEX(facingblok, clustnum);
851 ftgtnum = CLUST2INDEX( facingdiagblok, clustnum );
903 pastix_int_t procnum )
907 pastix_int_t tasknum;
908 pastix_int_t cblknum;
909 pastix_int_t clustnum;
912 sproc = &(simuctrl->
proctab[procnum]);
935 #
if defined(PASTIX_BLEND_COSTLEVEL)
984 pastix_int_t i, j, b;
985 pastix_int_t cblknum, bloknum;
989 #if defined(PASTIX_BLEND_GENTRACE)
990 static volatile pastix_atomic_lock_t trace_lock = PASTIX_ATOMIC_UNLOCKED;
991 char **procnames = NULL;
995 pastix_atomic_lock( &trace_lock );
996 char *tracename = NULL;
1000 tracename = strdup(
"blend" );
1003 rc = asprintf( &tracename,
"%s/blend", ctrl->
dirname );
1006 setTraceType (PAJE);
1007 initTrace (tracename, 0, GTG_FLAG_NONE);
1008 pajeEventDefAddParam( GTG_PAJE_EVTDEF_SetState,
"TaskId", GTG_PAJE_FIELDTYPE_Int );
1011 addContType (
"CT_Appli",
"0",
"Application" );
1012 addContType (
"CT_P",
"CT_Appli",
"Process" );
1013 addContType (
"CT_T",
"CT_P",
"Thread" );
1014 addStateType(
"ST_TS",
"CT_T",
"Thread State");
1015 addVarType (
"VR_TS",
"Ready tasks per thread",
"CT_T" );
1016 addVarType (
"VR_AP",
"Ready tasks",
"CT_Appli" );
1018 addLinkType (
"LT_TL",
"Split Event Link",
"CT_P",
"CT_T",
"CT_T");
1021 addContainer (0.00000,
"Appli",
"CT_Appli",
"0",
"PaStiX Blend Simulation",
"");
1024 addEntityValue (
"Wait",
"ST_TS",
"Waiting", GTG_LIGHTGREY);
1025 addEntityValue (
"Comp",
"ST_TS",
"Computing", GTG_RED);
1027 setVar( 0.0,
"VR_AP",
"Appli", 0 );
1032 procnames = (
char**) malloc ( ctrl->
total_nbthrds *
sizeof(
char*) );
1038 rc = asprintf( &clustname,
"Process %02d", (
int)i); assert(rc!=-1);
1039 rc = asprintf( &clustalias,
"P%d", (
int)i); assert(rc!=-1);
1040 addContainer (0.00000, clustalias,
"CT_P",
"Appli", clustname,
"");
1046 rc = asprintf( &procname,
"Thread %02d", (
int)pr); assert(rc!=-1);
1047 rc = asprintf( &procalias,
"T%d", (
int)pr); assert(rc!=-1);
1048 addContainer (0.00000, procalias,
"CT_T", clustname, procname,
"");
1052 procnames[pr] = procalias;
1056 free(clustname); free(clustalias);
1072 for(i=0;i<symbptr->
cblknbr;i++)
1074 pastix_int_t tasknum;
1097 pastix_int_t clustnum;
1107 task = &(simuctrl->
tasktab[i]);
1112 assert(cblknum < symbptr->cblknbr);
1113 assert(bloknum < symbptr->bloknbr);
1116 assert( simuctrl->
ownetab[cblknum] < 0 );
1117 simuctrl->
ownetab[cblknum] = pr;
1120 j < symbptr->cblktab[cblknum+1].bloknum; j++)
1153 #if defined(PASTIX_BLEND_GENTRACE)
1157 assert( (procnames != NULL) && (pr < ctrl->total_nbthrds) );
1158 assert( procnames[pr] != NULL );
1159 rc = asprintf( &str_val,
"Comp\" \"%d", (
int)i );
1160 setState(
timerVal( TIMER(pr) ),
"ST_TS", procnames[pr], str_val );
1174 for(j=simuctrl->
bloktab[b].
ftgtnum; j<simuctrl->bloktab[b+1].ftgtnum; j++)
1177 (j != CLUST2INDEX(b, clustnum)) )
1203 #if defined(PASTIX_BLEND_GENTRACE)
1207 assert( (procnames != NULL) && (pr < ctrl->total_nbthrds) );
1208 assert( procnames[pr] != NULL );
1209 rc = asprintf( &str_val,
"Wait\" \"%d", (
int)i );
1210 setState(
timerVal( TIMER(pr) ),
"ST_TS", procnames[pr], str_val );
1223 if(
timerVal(TIMER(pr)) > maxtime) {
1230 #if defined(PASTIX_BLEND_GENTRACE)
1232 assert( procnames != NULL );
1234 free(procnames[pr]);
1239 pastix_atomic_unlock( &trace_lock );
1243 #if defined(PASTIX_DEBUG_BLEND)
1244 for(i=0;i<simuctrl->
cblknbr;i++) {
1246 assert( simuctrl->
ownetab[i] >= 0 );
1248 for(i=0;i<symbptr->
bloknbr;i++) {