Пример #1
0
/*
 * map: map LPs->KPs->PEs linearly
 */
void map_linear(void) {
    tw_pe   *pe;

    int  nlp_per_kp;
    int  lpid;
    int  kpid;
    int  i;
    int  j;

    // may end up wasting last KP, but guaranteed each KP has == nLPs
    nlp_per_kp = (int)ceil((double) g_tw_nlp / (double) g_tw_nkp);

    if(!nlp_per_kp) {
        tw_error(TW_LOC, "Not enough KPs defined: %d", g_tw_nkp);
    }

    g_tw_lp_offset = g_tw_mynode * g_tw_nlp;

#if VERIFY_MAPPING
    printf("NODE %d: nlp %lld, offset %lld\n", g_tw_mynode, g_tw_nlp, g_tw_lp_offset);
#endif

    for(kpid = 0, lpid = 0, pe = NULL; (pe = tw_pe_next(pe)); ) {
#if VERIFY_MAPPING
        printf("\tPE %d\n", pe->id);
#endif

        for(i = 0; i < nkp_per_pe; i++, kpid++) {
            tw_kp_onpe(kpid, pe);

#if VERIFY_MAPPING
            printf("\t\tKP %d", kpid);
#endif

            for(j = 0; j < nlp_per_kp && lpid < g_tw_nlp; j++, lpid++) {
                tw_lp_onpe(lpid, pe, g_tw_lp_offset+lpid);
                tw_lp_onkp(g_tw_lp[lpid], g_tw_kp[kpid]);

#if VERIFY_MAPPING
                if(0 == j % 20) {
                    printf("\n\t\t\t");
                }
                printf("%lld ", lpid+g_tw_lp_offset);
#endif
            }

#if VERIFY_MAPPING
            printf("\n");
#endif
        }
    }

    if(!g_tw_lp[g_tw_nlp-1]) {
        tw_error(TW_LOC, "Not all LPs defined! (g_tw_nlp=%d)", g_tw_nlp);
    }

    if(g_tw_lp[g_tw_nlp-1]->gid != g_tw_lp_offset + g_tw_nlp - 1) {
        tw_error(TW_LOC, "LPs not sequentially enumerated!");
    }
}
Пример #2
0
void torus_mapping(void)
{
  tw_lpid kpid;
  tw_pe * pe;
  int nkp_per_pe=16;

  for(kpid = 0; kpid < nkp_per_pe; kpid++)
   tw_kp_onpe(kpid, g_tw_pe[0]);

  int i;
  for(i = 0; i < nlp_nodes_per_pe; i++)
   {
     kpid = i % g_tw_nkp;
     pe = tw_getpe(kpid % g_tw_npe);
     tw_lp_onpe(i, pe, g_tw_mynode * nlp_nodes_per_pe + i + getRem() );
     tw_lp_onkp(g_tw_lp[i], g_tw_kp[kpid]);
     tw_lp_settype(i, &nodes_lps[0]);
   }
  for(i = 0; i < nlp_mpi_procs_per_pe; i++)
   {
     kpid = i % g_tw_nkp;
     pe = tw_getpe(kpid % g_tw_npe);
     tw_lp_onpe(nlp_nodes_per_pe+i, pe, N_nodes + g_tw_mynode * nlp_mpi_procs_per_pe + i + getRem() );
     tw_lp_onkp(g_tw_lp[nlp_nodes_per_pe + i], g_tw_kp[kpid]);
     tw_lp_settype(nlp_nodes_per_pe + i, &nodes_lps[1]);
   }
}
Пример #3
0
int main(int argc, char * argv[]) {
  int NumPE = 0;
  int i = 0;
  tw_lp *lp;
  tw_kp *kp;
  g_tw_ts_end = 300;
  g_tw_gvt_interval = 16;

  printf("Please enter the number of processors: ");
  scanf("%d",&NumPE);

  if(NumPE < 1 && NumPE > 4){
    printf("Invalid number of processors %d\n", NumPE);
    exit(0);
  }
  /* tw_lptype NumPE NumKP NumLP Message_Size*/
  
  tw_init(airport_lps, NumPE, 3, 3, sizeof(Msg_Data));
  
  for(i = 0; i < 3; i++){
    lp = tw_getlp(i);
    kp = tw_getkp(i);
    tw_lp_settype(lp, AIR_LP);
    tw_lp_onkp(lp, kp);
    
    if(i >= NumPE){
      tw_lp_onpe(lp, tw_getpe(NumPE - 1));
      tw_kp_onpe(kp, tw_getpe(NumPE - 1));
    }
    else {
      tw_lp_onpe(lp, tw_getpe(i));
      tw_kp_onpe(kp, tw_getpe(i));
    }
  }
  tw_run();

  printf("Number of Landings: %d\n", NumLanded);

  return 0;
}
Пример #4
0
void map_round_robin(void) {
    tw_pe   *pe;

    int  kpid;
    int  i;

    for(i = 0; i < g_tw_nlp; i++) {
        kpid = i % g_tw_nkp;
        pe = tw_getpe(kpid % g_tw_npe);

        tw_lp_onpe(i, pe, g_tw_lp_offset+i);
        tw_kp_onpe(kpid, pe);
        tw_lp_onkp(g_tw_lp[i], g_tw_kp[kpid]);

#if VERIFY_MAPPING
        printf("LP %4d KP %4d PE %4d\n", i, kp->id, pe->id);
#endif
    }
}
Пример #5
0
void traffic_grid_mapping()
{
	tw_lpid         x, y;
	tw_lpid         lpid, kpid;
	tw_lpid         num_cells_per_kp, vp_per_proc;
	tw_lpid         local_lp_count;

	num_cells_per_kp = (NUM_CELLS_X * NUM_CELLS_Y) / (NUM_VP_X * NUM_VP_Y);
	vp_per_proc = (NUM_VP_X * NUM_VP_Y) / ((tw_nnodes() * g_tw_npe)) ;
	g_tw_nlp = nlp_per_pe;
	g_tw_nkp = vp_per_proc;

	local_lp_count=0;
	for (y = 0; y < NUM_CELLS_Y; y++)
	{
		for (x = 0; x < NUM_CELLS_X; x++)
		{
			lpid = (x + (y * NUM_CELLS_X));
			if( g_tw_mynode == CellMapping_lp_to_pe(lpid) )
			{

				kpid = local_lp_count/num_cells_per_kp;
				local_lp_count++; // MUST COME AFTER!! DO NOT PRE-INCREMENT ELSE KPID is WRONG!!

				if( kpid >= g_tw_nkp )
					tw_error(TW_LOC, "Attempting to mapping a KPid (%llu) for Global LPid %llu that is beyond g_tw_nkp (%llu)\n",
					kpid, lpid, g_tw_nkp );

				tw_lp_onpe(CellMapping_to_local_index(lpid), g_tw_pe[0], lpid);
				if( g_tw_kp[kpid] == NULL )
					tw_kp_onpe(kpid, g_tw_pe[0]);
				tw_lp_onkp(g_tw_lp[CellMapping_to_local_index(lpid)], g_tw_kp[kpid]);
				tw_lp_settype( CellMapping_to_local_index(lpid), &mylps[0]);
			}
		}
	}
}