Map initRoom() {
Map m = map_new();
unsigned short tileMap[] = {
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 1, 1, 1, 1, 1, 1, 1,
2, 1, 1, 1, 1, 1, 1, 1,
2, 1, 1, 2, 2, 1, 1, 2,
2, 1, 1, 2, 2, 1, 1, 2,
2, 1, 1, 1, 1, 1, 1, 2,
2, 1, 1, 1, 1, 1, 1, 2,
2, 1, 1, 2, 1, 1, 2, 2
};
m = map_init(m,
"cage",
(mapVec){8, 8, 4},
tileMap,
3
);
Tile floorTile = tile_init(
tile_new(),
0
);
Tile wallTile = tile_init(
tile_new(),
3
);
map_add_tile(m, floorTile);
map_add_tile(m, wallTile);
return m;
}
void partition (inspector_t* insp)
{
// aliases
insp_strategy strategy = insp->strategy;
map_list* meshMaps = insp->meshMaps;
map_list* partitionings = insp->partitionings;
int tileSize = insp->avgTileSize;
int prefetchHalo = insp->prefetchHalo;
loop_list* loops = insp->loops;
int nLoops = loops->size();
int seed = insp->seed;
loop_t* seedLoop = insp->loops->at(seed);
set_t* seedLoopSet = seedLoop->set;
int setSize = seedLoopSet->size;
int nThreads = insp->nThreads;
// partition the seed loop iteration space
int* indMap = NULL;
int nCore, nExec, nNonExec;
if (partitionings) {
indMap = inherit (seedLoop, tileSize, partitionings, &nCore, &nExec, &nNonExec, nThreads);
insp->partitioningMode = "inherited";
}
#ifdef SLOPE_METIS
if (! indMap && meshMaps) {
indMap = metis (seedLoop, tileSize, meshMaps, &nCore, &nExec, &nNonExec, nThreads);
insp->partitioningMode = "metis";
}
#endif
if (! indMap) {
indMap = chunk (seedLoop, tileSize, &nCore, &nExec, &nNonExec, nThreads);
insp->partitioningMode = "chunk";
}
// initialize tiles:
// ... start with creating as many empty tiles as needed ...
int t;
tile_list* tiles = new tile_list (nCore + nExec + nNonExec);
for (t = 0; t < nCore; t++) {
tiles->at(t) = tile_init (nLoops, LOCAL, prefetchHalo);
}
for (; t < nCore + nExec; t++) {
tiles->at(t) = tile_init (nLoops, EXEC_HALO, prefetchHalo);
}
for (; t < nCore + nExec + nNonExec; t++) {
tiles->at(t) = tile_init (nLoops, NON_EXEC_HALO, prefetchHalo);
}
// ... explicitly track the tile region (core, exec_halo, and non_exec_halo) ...
set_t* tileRegions = set("tiles", nCore, nExec, nNonExec);
// ... and, finally, map the partitioned seed loop to tiles
assign_loop (seedLoop, loops, tiles, indMap, SEED);
insp->tileRegions = tileRegions;
insp->iter2tile = map ("i2t", set_cpy(seedLoopSet), set_cpy(tileRegions), indMap, setSize);
insp->tiles = tiles;
}
void grid_init(void)
{
unsigned char i;
unsigned char j;
for(i=0; i<width; i++) {
for(j=0; j<width; j++) {
tile *tile = &grid[i][j];
tile_init(tile, j, i, 0);
}
}
tile_init(&tile_null, 0, 0, 0);
}
int
_aoi_new(lua_State *L) {
int realwidth = luaL_checkinteger(L, 1);
int realhigh = luaL_checkinteger(L, 2);
int tile_len = luaL_checkinteger(L, 3);
int max_x_index = realwidth / tile_len - 1;
int max_y_index = realhigh / tile_len - 1;
int width = (max_x_index + 1) * tile_len;
int high = (max_y_index + 1) * tile_len;
struct aoi_context *aoictx = malloc(sizeof(*aoictx));
memset(aoictx,0,sizeof(*aoictx));
aoictx->pool = malloc(sizeof(*aoictx->pool));
memset(aoictx->pool,0,sizeof(*aoictx->pool));
aoictx->map.realwidth = realwidth;
aoictx->map.realhigh = realhigh;
aoictx->map.width = width;
aoictx->map.high = high;
aoictx->map.max_x_index = max_x_index;
aoictx->map.max_y_index = max_y_index;
aoictx->map.tile_len = tile_len; //tile length
aoictx->map.tile_sz = (max_x_index + 1) * (max_y_index + 1); //amount of tiles in map
tile_init(&aoictx->map);
lua_pushlightuserdata(L, aoictx);
return 1;
}
/**************************************************************************
...
**************************************************************************/
void handle_map_info(struct packet_map_info *pinfo)
{
int x, y;
map.xsize=pinfo->xsize;
map.ysize=pinfo->ysize;
map.is_earth=pinfo->is_earth;
if(!(map.tiles=(struct tile*)malloc(map.xsize*map.ysize*
sizeof(struct tile)))) {
log(LOG_FATAL, "malloc failed in handle_map_info");
exit(1);
}
for(y=0; y<map.ysize; y++)
for(x=0; x<map.xsize; x++)
tile_init(map_get_tile(x, y));
set_overview_dimensions(map.xsize, map.ysize);
}
