void placepads()
{
if( padspacingG == EXACT_PADS ){
return ;
}
find_core(); /* GET THE UPDATED CORE'S DIMENSION */
D( "placepads/initially",
print_pads( "pads initially\n", padarrayG, totalpadsG ) ;
) ;
void cpu_manager::register_lp(const prl::affinity_mask& affinity_mask, const apic& apic) {
// register processor package
topology_package* pkg = find_pkg(apic.pkg);
if (pkg == NULL) m_pkgs.push_back(pkg = mp_allocator->make_new<topology_package>(affinity_mask, apic.pkg, m_pkgs.size()));
// register processor core
topology_core* core = find_core(apic.core);
if (core == NULL) m_cores.push_back(core = mp_allocator->make_new<topology_core>(affinity_mask, apic.core, m_cores.size()));
// register logical processor
topology_smt* smt = find_smt(apic.smt);
if (smt == NULL) m_smts.push_back(smt = mp_allocator->make_new<topology_smt>(affinity_mask, apic.smt, m_smts.size()));
// propagate affinity mask through layers
pkg->add_affinity_mask(affinity_mask);
core->add_affinity_mask(affinity_mask);
// construct hierarchy
//TODO: add
}
ERRORPTR buildYGraph()
{
int i ; /* counter */
int overlapx ; /* overlap conditions in x direction */
int overlapy ; /* overlap conditions in y direction */
int sortbyYX() ; /* sort the tiles Y then X */
int left, right ; /* coordinates of tiles */
int bottom, top ; /* coordinates of tiles */
BOOL firstPick ; /* TRUE if first picket which matches */
BOOL possibleEdgetoSource; /* TRUE if this could be edge to source */
BOOL *yancestorB ; /* TRUE for a cell if cell has B ancestors */
BOOL *yancestorF ; /* TRUE for a cell if cell has F ancestors */
COMPACTPTR candidate ; /* this is the tile in question */
COMPACTPTR t ; /* this is the current picket */
PICKETPTR freepick ; /* used to free the pickets at the end */
PICKETPTR curPick ; /* traverse the pickets */
PICKETPTR lowerLimit ; /* first picket tile overlaps/touches */
PICKETPTR upperLimit ; /* last picket tile overlaps or touches */
ERRORPTR errorPtr ; /* form a list of errors to be processed*/
ERRORPTR lasterror ; /* last error in list */
ERRORPTR violations ; /* head of the error list */
/* initialize error list */
lasterror = NULL ;
violations = NULL ;
yancestorB = (BOOL *) Ysafe_calloc( last_cellG+1,sizeof(BOOL) ) ;
yancestorF = (BOOL *) Ysafe_calloc( last_cellG+1,sizeof(BOOL) ) ;
inityPicket() ;
/* yGraphG is now initialized */
/* sort by ymin xmin of the bounding box */
/* we give it two chances - second time we expand core if necessary */
for( i=0; i <= 1 ; i++ ){
Yquicksort((char *)yGraphG,numtilesG+2,sizeof(COMPACTPTR),sortbyYX);
if( yGraphG[SOURCE]->cell == YSOURCEC &&
yGraphG[SINK]->cell == YSINKC ){
break ;
} else {
find_core( &left, &right, &bottom, &top ) ;
/* expand core region */
t = tileNodeG[YSOURCE] ;
t->b = bottom ;
t->t = t->b ;
t = tileNodeG[YSINK] ;
t->b = top ;
t->t = t->b ;
}
}
if( yGraphG[SOURCE]->cell != YSOURCEC || yGraphG[SINK]->cell != YSINKC ){
M( ERRMSG, "ycompact", "Fatal error in configuration\n" ) ;
if( graphicsG ){
G( TWcloseGraphics() ) ;
}
YexitPgm( PGMFAIL ) ;
}
for( i=1 ; i<= numtilesG ; i++ ){
firstPick = TRUE ;
lowerLimit = NULL ;
upperLimit = NULL ;
possibleEdgetoSource = FALSE ;
candidate = yGraphG[i] ;
/* search thru picket list for adjacencies */
for( curPick=leftPickS;curPick;curPick=curPick->next){
overlapx = projectX( curPick->pt2.lft, curPick->pt1.rght,
candidate->l, candidate->r) ;
if( overlapx > 0 ){ /* allow touching */
/* save span of overlap */
if( firstPick ){
lowerLimit = curPick ;
firstPick = FALSE ;
}
upperLimit = curPick ;
t = tileNodeG[curPick->node] ;
/* multiple tile case - no error possible */
if( candidate->cell == t->cell ){
continue ;
}
/* check for errors */
overlapy =
projectY( t->b, t->t, candidate->b, candidate->t ) ;
if( overlapx > 0 && overlapy > 0 ){
/* save violations - add to violation list */
if( lasterror ){
errorPtr =
(ERRORPTR) Ysafe_malloc( sizeof(ERRORBOX) ) ;
lasterror->next = errorPtr ;
lasterror = errorPtr ;
} else {
violations = errorPtr = lasterror =
(ERRORPTR) Ysafe_malloc( sizeof(ERRORBOX) ) ;
}
errorPtr->next = NULL ;
errorPtr->nodeI = candidate->node ;
errorPtr->nodeJ = t->node ;
/* for debug only :
sprintf( YmsgG,
Overlap detected: cell %d and cell %d\n",
candidate->cell, t->cell ) ;
M( MSG, NULL, YmsgG ) ;
*/
}
ASSERT( t->node == curPick->node, "buildCGraph",
"tileNodeG != curPick. Problem \n" ) ;
/* form edge on only first occurance of cell */
if( t->node == numtilesG+2 ){ /* source node */
/* delay adding this edge */
possibleEdgetoSource = TRUE ;
} else {
formyEdge( t->node, candidate->node ) ;
}
} else if( upperLimit ){
/* we are past the upper limit so break & save time */
break ;
}
}
ASSERT( lowerLimit, "compact", "lowerLimit is NULL" ) ;
ASSERT( upperLimit, "compact", "lowerLimit is NULL" ) ;
if( possibleEdgetoSource && yancestorF[candidate->cell] == FALSE ){
/* no need to make an edge to source if we already */
/* have an ancestor. Always make sure it is one of the lowest */
/* nodes of the multi-tiled cell */
formyEdge( numtilesG+2, cellarrayG[candidate->cell]->ylo ) ;
yancestorF[candidate->cell] = TRUE ;
}
update_ypicket( i, lowerLimit, upperLimit ) ;
} /* end for loop */
/* process sink last */
/* search thru picket list for adjacencies */
for( curPick=leftPickS;curPick;curPick=curPick->next){
/* remaining pickets must necessarily overlap sink */
t = tileNodeG[curPick->node] ;
ASSERT( t->node == curPick->node, "buildCGraph",
"tileNodeG != curPick. Problem \n" ) ;
if( curPick->node != numtilesG+2 && /* avoid the source */
yancestorB[t->cell] == FALSE ){ /* no parents */
formyEdge( cellarrayG[t->cell]->yhi, yGraphG[last_tileG]->node ) ;
yancestorB[t->cell] = TRUE ;
}
}
/* now add multiple tile edges to graph. Precomputed in multi.c */
add_mtiles_to_ygraph() ;
cleanupGraph( YFORWARD ) ;
cleanupGraph( YBACKWARD ) ;
Ysafe_free( yancestorB ) ;
Ysafe_free( yancestorF ) ;
/* delete all pickets */
for( curPick = leftPickS; curPick ; ) {
freepick = curPick ;
curPick = curPick->next ;
Ysafe_free( freepick ) ;
}
return( violations ) ;
} /* end buildYGraph */