void StackTest(threadParam param)
{
float workperthread = HEIGHT / (NUM_THREADS); //Aslong as HEIGHT == WIDTH this will work
float threadStartPos = workperthread * param.id;
MemStack* stack = param.al_the_croc->CreateStack(56, 4, false);
if(param.customAllocation)
Mandelbrot(param.stack, threadStartPos, workperthread, WIDTH, HEIGHT, param.pixmap);
else
MandelbrotNormalStack(param.stack, threadStartPos, workperthread, WIDTH, HEIGHT, param.pixmap);
}
fenetremandelbrot::fenetremandelbrot(QWidget *parent) :
QWidget(parent) , pixmap(1200,1200)
{
setFixedSize(1100,650);
QGraphicsScene *scene = new QGraphicsScene();
QGraphicsView *view = new QGraphicsView(scene,this);
QPainter *p_fractale = new QPainter(&pixmap);
//le compteur est initialisé à 0. Il va servir à l'it_max
int a[2];
int c[2];
a[0]=0;
a[1]=0;
c[0]=1200;
c[1]=1200; // On commence par le carré classique
vector<vector<int> > mandelbrot = Mandelbrot(100, a, c); //ici l'iteration max est 100.
int compteur = 0;
while (compteur<1200*1200)
{
if (mandelbrot[compteur][2]==100) //100 est l'iteration max ici
{
p_fractale->setPen(QPen(Qt::black));
p_fractale->drawPoint(mandelbrot[compteur][0],mandelbrot[compteur][1]);
}
if (1<=mandelbrot[compteur][2] && mandelbrot[compteur][2]<15)
{
p_fractale->setPen(QPen(Qt::darkBlue));
p_fractale->drawPoint(mandelbrot[compteur][0],mandelbrot[compteur][1]);
}
if (15<=mandelbrot[compteur][2] && mandelbrot[compteur][2]<30)
{
p_fractale->setPen(QPen(Qt::blue));
p_fractale->drawPoint(mandelbrot[compteur][0],mandelbrot[compteur][1]);
}
if (30<=mandelbrot[compteur][2] && mandelbrot[compteur][2]<45)
{
p_fractale->setPen(QPen(Qt::darkCyan));
p_fractale->drawPoint(mandelbrot[compteur][0],mandelbrot[compteur][1]);
}
if (45<=mandelbrot[compteur][2] && mandelbrot[compteur][2]<100)
{
p_fractale->setPen(QPen(Qt::cyan));
p_fractale->drawPoint(mandelbrot[compteur][0],mandelbrot[compteur][1]);
}
compteur++;
}
delete p_fractale;
scene->addPixmap(pixmap);
view->move(10,10);
}
void *CreateDisplay(ALLEGRO_THREAD *thr, void *arg)
{
DISPLAY_DATA *data = (DISPLAY_DATA*) arg;
ALLEGRO_DISPLAY *display;
ALLEGRO_EVENT_QUEUE *queue = al_create_event_queue();
if(!queue) {
fprintf(stderr, "failed to create event queue");
return NULL;
}
al_lock_mutex(data->mutex);
display = AllegroNewDisplay(data->sizeX, data->sizeY, queue);
al_broadcast_cond(data->cond);
// Define the size of the image
Window<int> scr(0, data->sizeX, 0, data->sizeY);
// Define the domain in which we test for points
Window<double> fract(data->zoomXmin, data->zoomXmax, data->zoomYmin, data->zoomYmax);
al_unlock_mutex(data->mutex);
// Generate the fractal
Mandelbrot(scr, fract);
while(!al_get_thread_should_stop(thr)) {
ALLEGRO_EVENT ev;
al_wait_for_event(queue, &ev);
if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
al_set_thread_should_stop(thr);
al_lock_mutex(data->mutex);
al_broadcast_cond(data->cond);
al_unlock_mutex(data->mutex);
break;
}
}
al_destroy_display(display);
al_destroy_event_queue(queue);
}
int main(void)
{
tColor deepBlue = {0x80,0x17,0x0F, 0x00};
tComplex erste = {0.0};
tComplex zweite = {1.0};
tComplex dritte = {0.0,(2.0/3.0)};
tComplex vierte = {-2.0,-1.0};
//deepblue.blue = 0x80;
//deepblue.green = 0x17;
//deepblue.red = 0x0F;
VOpenGraphics("Mandelbrot", 1, SIZE_X, SIZE_Y);
VideoRam = VGetGraphicsPointer();
/* Ab hier folgt Ihre Lösung */
Fillscreen(deepBlue);
//Iteration(dritte);
Mandelbrot(vierte);
VWait();
return 0;
}
int main(int argc, char** argv)
{
Timer mainTimer(Timer::Mode::Single), mainTimerWithoutEnv(Timer::Mode::Single);
mainTimer.Start();
MPI_Init(&argc, &argv);
mainTimerWithoutEnv.Start();
int width, height;
int commSize, commRank;
int processNameLenght;
int PACKAGE_AMOUNT;
int singlePackageOffset = 1024;
MPI_Status status;
MPI_Comm_size(MPI_COMM_WORLD, &commSize);
MPI_Comm_rank(MPI_COMM_WORLD, &commRank);
MPI_Request request[commSize-1];
MPI_Status statuses[commSize-1];
if (commRank == 0)
{
if(argc != 2)
{
printf("%d", argc);
printf("Wrong number of arguments, correct number is: 1- width\n");
return 0;
}
width = atoi(argv[1]);
height = width;
singlePackageOffset = (width * height)/((commSize-1));//std::min((width * height)/(2*(commSize-1)), 1024);
PACKAGE_AMOUNT = (width * height) / singlePackageOffset;
int sendParameters[3];
sendParameters[0] = width;
sendParameters[1] = height;
sendParameters[2] = singlePackageOffset;
for (int i = 1; i < commSize; i++) {
MPI_Isend(sendParameters, 3, MPI_INT, i, PARAMETERS, MPI_COMM_WORLD, &request[i-1]);
}
MPI_Waitall(commSize-1, request, statuses);
}
else
{
int receiveParameters[3];
MPI_Recv(receiveParameters, 3, MPI_INT, 0, PARAMETERS, MPI_COMM_WORLD, &status);
width = receiveParameters[0];
height = receiveParameters[1];
singlePackageOffset = receiveParameters[2];
}
if (commRank == 0)
{
char *results = (char*)_mm_malloc(sizeof(char) * width * height, ALLOC_TRANSFER_ALIGN);
MPI_Request request;
MPI_Status status;
int totalNumberOfIterations = PACKAGE_AMOUNT;
auto indexProvider = [&](const int index) {
return singlePackageOffset*index;
};
int outValue;
CoreStatus* currentIndexes = (CoreStatus*)_mm_malloc((commSize-1)*sizeof(CoreStatus), ALLOC_ALIGN);
for (int j = std::min(commSize-1, totalNumberOfIterations); j > 0 ; --j) {
currentIndexes[j-1].indexes[0] = j-1;
currentIndexes[j-1].currentlyCalculating = 0;
MPI_Isend(currentIndexes[j-1].indexes, 1, MPI_INT, j, DATA, MPI_COMM_WORLD, &request);
}
for (int j = std::min(commSize-1, totalNumberOfIterations - (commSize-1)); j > 0 ; --j) {
currentIndexes[j-1].indexes[1] = commSize-1+j-1;
MPI_Isend(currentIndexes[j-1].indexes + 1, 1, MPI_INT, j, DATA, MPI_COMM_WORLD, &request);
}
double value;
for (int i = PACKAGE_AMOUNT-1; i >= 2*(commSize-1); --i) {
MPI_Probe(MPI_ANY_SOURCE, DATA, MPI_COMM_WORLD, &status);
MPI_Recv(results + indexProvider(currentIndexes[status.MPI_SOURCE-1].indexes[currentIndexes[status.MPI_SOURCE-1].currentlyCalculating]), singlePackageOffset, MPI_CHAR, status.MPI_SOURCE, DATA, MPI_COMM_WORLD, &status);
currentIndexes[status.MPI_SOURCE-1].indexes[currentIndexes[status.MPI_SOURCE-1].currentlyCalculating] = i;
MPI_Isend(currentIndexes[status.MPI_SOURCE-1].indexes + currentIndexes[status.MPI_SOURCE-1].currentlyCalculating, 1, MPI_INT, status.MPI_SOURCE, DATA, MPI_COMM_WORLD, &request);
currentIndexes[status.MPI_SOURCE-1].currentlyCalculating = (currentIndexes[status.MPI_SOURCE-1].currentlyCalculating +1)%2;
}
for (int i = std::min(2*(commSize-1), totalNumberOfIterations); i > 0; --i) {
MPI_Probe(MPI_ANY_SOURCE, DATA, MPI_COMM_WORLD, &status);
MPI_Recv(results + indexProvider(currentIndexes[status.MPI_SOURCE-1].indexes[currentIndexes[status.MPI_SOURCE-1].currentlyCalculating]), singlePackageOffset, MPI_CHAR, status.MPI_SOURCE, DATA, MPI_COMM_WORLD, &status);
currentIndexes[status.MPI_SOURCE-1].currentlyCalculating = (currentIndexes[status.MPI_SOURCE-1].currentlyCalculating +1)%2;
}
for (int i = commSize-1; i > 0; --i) {
MPI_Isend(nullptr, 0, MPI_INT, i, ENDGEN, MPI_COMM_WORLD,
&request);
}
_mm_free(currentIndexes);
_mm_free(results);
}
else
{
char* results = (char*)_mm_malloc(2*singlePackageOffset, ALLOC_TRANSFER_ALIGN);
int currentlyCalculating = 0;
int inValue[2];
int value[2];
MPI_Status status[2];
MPI_Request request[2];
MPI_Recv(inValue, 1, MPI_INT,0, MPI_ANY_TAG, MPI_COMM_WORLD, status);
while (status->MPI_TAG != ENDGEN){
MPI_Irecv(inValue+((currentlyCalculating+1)%2), 1, MPI_INT,0, MPI_ANY_TAG, MPI_COMM_WORLD, request+((currentlyCalculating+1)%2));
Mandelbrot(results+currentlyCalculating*singlePackageOffset, singlePackageOffset*inValue[currentlyCalculating], width, height, singlePackageOffset);
MPI_Isend(results+currentlyCalculating*singlePackageOffset, singlePackageOffset ,MPI_CHAR ,0 ,DATA ,MPI_COMM_WORLD ,request + currentlyCalculating);
currentlyCalculating = (currentlyCalculating+1)%2;
MPI_Wait(request + currentlyCalculating, status);
};
}
if (commRank == 0) {
mainTimerWithoutEnv.Stop();
#ifndef __MIC__
printf("MPI,%d,%d,%lu,", commSize - 1, width, mainTimerWithoutEnv.Get());
#endif
}
MPI_Finalize();
if (commRank == 0) {
mainTimer.Stop();
#ifndef __MIC__
printf("%lu,", mainTimer.Get());
#endif
}
return 0;
}
//afisare Mandelbrot
void Display8() {
double x;
double y;
Mandelbrot man(0,0,1);
glBegin(GL_POINTS);
for(x=-2;x<2;x+=0.01)
for(y=-2;y<2;y+=0.01)
{
man=Mandelbrot(x,y,100);
man.trym();
if(man.ism==0)
{
if(man.iter<2)
glColor3f(0,0,0);
else if(man.iter<3)
glColor3f(0.1,0,0);
else if(man.iter<5)
glColor3f(0.2,0,0);
else if(man.iter<10)
glColor3f(0.4,0,0);
else if(man.iter<15)
glColor3f(0.6,0,0);
else if(man.iter<20)
glColor3f(0.8,0,0);
glVertex2d(x/2, y/2);
}
else
{
glColor3f(1,0.5,0.5);
glVertex2d(x/2, y/2);
}
}
glEnd();
/*
char cx[3];
sprintf(cx, "%2d", x);
char cy[3];
sprintf(cy, "%2d", y);
glRasterPos2d(-0.98,-0.98);
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, '(');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, cx[0]);
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, cx[1]);
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ',');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, cy[0]);
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, cy[1]);
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ')');
*/
glRasterPos2d(-1.0,0.9);
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 'M');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 'u');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 'l');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 't');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 'i');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 'm');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 'e');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 'a');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ' ');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 'M');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 'a');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 'n');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 'd');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 'e');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, '1');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 'b');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 'r');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 'o');
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, 't');
}
