/* ========== MAIN ========== */
int main(int argc, char* argv[]) {
/* Print out starting time */
double start = when();
printf("Starting time: %f\n", start);
/* Create plate */
float* plate = createPlate();
float* prev_plate = createPlate();
char* lockedCells = createCharPlate();// bool array of locked cells
/* Init main plate and make a duplicate copy */
initPlate(plate, lockedCells);
copy(plate, prev_plate);
/* Start updating */
printf("Updating plate to steady state\n");
char flag = '1';
int iterations = 0;
do {
iterations++;
switch(flag) {
case '1':
update_plate(plate, prev_plate, lockedCells);
flag = '0';
break;
case '0':
update_plate(prev_plate, plate, lockedCells);
flag = '1';
break;
}
} while(steady(((flag == '0') ? plate : prev_plate), lockedCells));
double end = when();
printf("\nEnding time: %f\n", end);
printf("Total execution time: %f\n", end - start);
printf("Number of iterations: %d\n\n", iterations);
/* Copy final array to main one and write it to the file */
if (flag == '1')
copy(prev_plate, plate);
/* write to file */
printf("Writing to file\n");
FILE* ofp = fopen(argv[1], "w+");
int i, j;
for (i = 0; i < ROWS; i++) {
for (j = 0; j < COLS; j++) {
fprintf(ofp, "%f," ,plate[i + j * COLS]);
}
fprintf(ofp, "\n");
}
fclose(ofp);
/* free memory */
printf("Cleanup\n");
cleanupFloat(plate);
cleanupFloat(prev_plate);
cleanupChar(lockedCells);
return EXIT_SUCCESS;
}
int main(int argc , char** argv){
x = atoi(argv[1]);
y = atoi(argv[2]);
dx = WIDTH / (x - 1);
dy = HEIGHT / (y - 1);
int countNodes = x * y , currentProc;
voltage = new double*[countNodes + 1];
for(int i = 0 ; i < countNodes + 1 ; i++)
voltage[i] = new double[1];
plate = createPlate(x , y , voltage);
argThread* args = new argThread();
struct timeval begin;
struct timeval end;
struct timezone zone;
gettimeofday(&begin, &zone);
MPI_Init (&argc, &argv);
MPI_Comm_size (MPI_COMM_WORLD, &countThreads);
MPI_Comm_rank (MPI_COMM_WORLD, ¤tProc);
MPI_Barrier(MPI_COMM_WORLD);
int** intervals = createBlockOrder(&plate -> getOrder()[1] , y , x , countThreads);
if(countThreads > 1){
Plate* plates;
if(currentProc == 0)
plates = new Plate(&plate -> getNodes()[intervals[0][0]] , intervals[1][1] - intervals[0][0]);
else if(currentProc == countThreads - 1)
plates = new Plate(&plate -> getNodes()[intervals[2 * currentProc - 1][0]] , intervals[2 * currentProc][1] - intervals[2 * currentProc - 1][0]);
else
plates = new Plate(&plate -> getNodes()[intervals[2 * currentProc - 1][0]] , intervals[2 * currentProc + 1][1] - intervals[2 * currentProc - 1][0]);
args -> init(currentProc , plates , intervals[2 * currentProc][1] - intervals[2 * currentProc][0]);
}
else
args -> init(0 , plate , intervals[0][1] - intervals[0][0]);
MPI_Barrier(MPI_COMM_WORLD);
action((void*)(args));
gettimeofday(&end, &zone);
fprintf(stderr , "Time executing :: %lu on number of process %d\n" , end.tv_sec * 1000000 + end.tv_usec - begin.tv_usec - begin.tv_sec * 1000000 , countThreads);
createScript(x , y , MaxToGnuPlot);
MPI_Finalize();
delete args;
delete plate;
delete voltage;
delete test;
return 0;
}
/* ========== MAIN ========== */
int main(int argc, char* argv[]) {
/* Print out starting time */
double start = when();
printf("Starting time: %f\n", start);
/* Create thread count */
int nthreads = atoi(argv[1]);
/* Create plate */
main_plate = createPlate();
main_prev_plate = createPlate();
main_locked_cells = createCharPlate(); // bool array of locked cells
/* Init barriers and mutex */
pthread_mutex_init(&finished_count, NULL);
barr = (barrier_node*)malloc(sizeof(barrier_node));
mylib_init_barrier(barr, nthreads);
/* Init main plate and make a duplicate copy */
initPlate(main_plate, main_prev_plate);
/* Start updating */
startUpdate(nthreads);//, barr);
/* Report time and cleanup */
double end = when();
printf("\nEnding time: %f\n", end);
printf("Total execution time: %f\n", end - start);
printf("Number of iterations: %d\n\n", iterations);
/* Destroy mutex and barriers */
pthread_mutex_destroy(&finished_count);
mylib_destroy_barrier(barr);
/* free memory */
printf("Cleanup\n");
free(barr);
cleanupFloat(main_plate);
cleanupFloat(main_prev_plate);
cleanupChar(main_locked_cells);
return EXIT_SUCCESS;
}
PlateModel* PlateModelFactory::createPlateModel(DataSource *dataSource)
{
int numberOfEntries = dataSource->getNumberOfEntries();
Plate *plate;
PlateModel *plateModel = new PlateModel();
for (int i = 0; i < numberOfEntries; i++) {
plate = createPlate(i);
plateModel->addPlate(*plate);
}
return plateModel;
}
bool SceneGame::init()
{
if (!Layer::init())
{
return false;
}
Size visibleSize = Director::getInstance()->getVisibleSize();
Vec2 origin = Director::getInstance()->getVisibleOrigin();
_c = new std::vector<Chess*>();
_c->resize(1000);
_steps = new std::vector<Step*>();
_steps->reserve(1000);
createPlate();
Chess::_d = Director::getInstance()->getWinSize().height / 10;
Chess::_offx = Chess::_d;
Chess::_offy = Chess::_d / 2;
for (int i = 0; i < 32; i++)
{
_c->at(i) = Chess::create();
_c->at(i)->initChess(i);
addChild(_c->at(i));
}
EventDispatcher *eventDispatcher = Director::getInstance()->getEventDispatcher();
auto listener = EventListenerTouchOneByOne::create();
listener->onTouchBegan = CC_CALLBACK_2(SceneGame::onTouchBegan, this);
listener->onTouchEnded = CC_CALLBACK_2(SceneGame::onTouchEnd, this);
eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);
_selectid = 1;
_selectSprite = Sprite::create("selected.png");
_selectSprite->setVisible(false);
addChild(_selectSprite);
_selectSprite->setScale(0.6f);
_selectSprite->setZOrder(100);
_bRedTurn = true;
_steps->clear();
addCtrlPanel();
return true;
}
Figure* Texture::makePlate() {
// キャッシュにFigureが存在しないか検索
Figure *figure = cache->searchFigure(MAX_FIGURE_ID, MAX_FIGURE_SUB_ID, 0, 0);
if (figure) {
return figure;
}
Rectf rect;
rect.top = 0;
rect.left = 0;
rect.right = 1;
rect.bottom = 1;
float w = (rect.right - rect.left) * this->width / dispW;
float p = (rect.bottom - rect.top) / (rect.right - rect.left);
figure = createPlate(w, w*p);
figure->build();
// キャッシュに登録
cache->putFigure(MAX_FIGURE_ID, MAX_FIGURE_SUB_ID, 0, 0, figure);
return figure;
}
int main(int argc, char *argv[])
{
setbuf(stdout, 0);
float **plate, **prev_plate, **temp_plate, **locked_cells;
int start, end, rows_assinged;
MPI_Init(&argc, &argv);
char host[255];
gethostname(host,253);
int nproc, iproc;
MPI_Status status;
MPI_Request request;
MPI_Comm_size(MPI_COMM_WORLD, &nproc);
MPI_Comm_rank(MPI_COMM_WORLD, &iproc);
printf("I am process rank %d of %d running on %s\n", iproc, nproc,host);
/* Determine how much I should be doing and allocate the arrays*/
rows_assinged = SIZE / nproc; // rows for a specific processor to look at
plate = createPlate(rows_assinged);
prev_plate = createPlate(rows_assinged);
locked_cells = createPlate(rows_assinged);
start = 1;
end = rows_assinged + 1;
/* Initialize the cells */
initPlate(plate, prev_plate, locked_cells, rows_assinged, iproc);
if (iproc == 0) {
start = 2;
}
if (iproc == (nproc - 1)) {
end = rows_assinged;
}
/* First we need to get the 0th row of locked cells from my previous neighbor */
if (iproc != 0) {
MPI_Isend(locked_cells[1], SIZE, MPI_FLOAT, iproc - 1, 0, MPI_COMM_WORLD, &request);
MPI_Recv(locked_cells[0], SIZE, MPI_FLOAT, iproc - 1, 0, MPI_COMM_WORLD, &status);
}
if (iproc != (nproc - 1)) {
MPI_Isend(locked_cells[rows_assinged], SIZE, MPI_FLOAT, iproc + 1, 0, MPI_COMM_WORLD, &request);
MPI_Recv(locked_cells[rows_assinged + 1], SIZE, MPI_FLOAT, iproc + 1, 0, MPI_COMM_WORLD, &status);
}
/* Now run the relaxation */
double starttime = When();
int done = 0, reallydone = 0, iterations = 0;
while(!reallydone)
{
iterations++;
/* First, I must get my neighbors boundary values */
if (iproc != 0)
{
/* If I'm not the first processor I want to send/receive to my previous neighbour */
MPI_Isend(prev_plate[1], SIZE, MPI_FLOAT, iproc - 1, 0, MPI_COMM_WORLD, &request);
MPI_Recv(prev_plate[0], SIZE, MPI_FLOAT, iproc - 1, 0, MPI_COMM_WORLD, &status);
}
if (iproc != nproc - 1)
{
/* If I'm not the last processor I want to send/receice from my next neighbor */
MPI_Isend(prev_plate[rows_assinged], SIZE, MPI_FLOAT, iproc + 1, 0, MPI_COMM_WORLD, &request);
MPI_Recv(prev_plate[rows_assinged + 1], SIZE, MPI_FLOAT, iproc + 1, 0, MPI_COMM_WORLD, &status);
}
/* Do the calculations */
update_plate(iproc, plate, prev_plate, locked_cells, rows_assinged, start, end);
/* Check to see if we are done */
done = steady(iproc, plate, locked_cells, rows_assinged, start, end);
/* Do a reduce and distribute it to all processors */
MPI_Allreduce(&done, &reallydone, 1, MPI_INT, MPI_MIN, MPI_COMM_WORLD);
/* Swap the pointers */
temp_plate = plate;
plate = prev_plate;
prev_plate = temp_plate;
}
/* print out the number of iterations to relax */
printf("%d :It took %d iterations and %lf seconds to relax the system\n",
iproc, iterations, When() - starttime);
/* Deallocate everything */
// cleanup(plate, rows_assinged, iproc, nproc);
// cleanup(prev_plate, rows_assinged, iproc, nproc);
// cleanup(locked_cells, rows_assinged, iproc, nproc);
MPI_Finalize();
return EXIT_SUCCESS;
}
