Homec4science
Diffusion Dynamic loop scheduling using MPI passive-target remote memory access (master) Browse

dls_MPI_RMA/Mandelbrot_one_sided_memoryless.c
4672720499a7master

Last Change
Raw File

Mandelbrot_one_sided_memoryless.c
View Options

/*********************************************************************************
* Copyright (c) 2018 *
* Ahmed Eleliemy <ahmed.eleliemy@unibas.ch> *
* University of Basel, Switzerland *
* All rights reserved. *
* This code is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. *
* This program is free software; you can redistribute it and/or modify it *
* under the terms of the license (GNU LGPL) which comes with this package. *
*********************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>
#include <math.h>
#include <complex.h>
#include "dls_core.h"
#include "SpinDataStructures.h"
#include "SpinCalculator.h"
#include "ObjectLoader.h"
#define MIN(a,b) (((a)<(b))?(a):(b))
#define DATAOWNER 0
//#define x_max -0.26
//#define x_min -1.26
//#define y_max 1
//#define y_min 0
#define x_max 0.5
#define x_min -0.5
#define y_max 0.5
#define y_min -0.5
#ifndef CHECK_PERIOD
#define CHECK_PERIOD 1
#endif
#define REQ_WORK 1000
#define ASSI_WORK 1001
#define TERMINATE 1002
//-------- function headers -------
void parallel_one_sided_memory(int argc, char** argv);
void Mandelbrot(int start, int end, int * computed_data,int image_width, int iterations);
//--------- main -------
int main (int argc, char** argv)
{
parallel_one_sided_memory(argc,argv);
return 0;
}
//------- master-worker functions ---------------
void all_processors_do(int argc, char ** argv, int number_of_workers, int id)
{
// variables for scheduling
int flag=0;
MPI_Status status;
int terminated=0;
int master_is_terminated=0;
int my_start_index=0;
int my_end_index=0;
struct Scheduling_params params;
char dummy='\0';
if(argc<4)
{
printf("Usgae: ./program image_width iterations iDLSMethods(0-STATIC 1-SS 2-FSC 3-GSS 4-FAC 5-TSS)\n");
MPI_Abort(MPI_COMM_WORLD, -1);
}
int number_of_tasks=atoi(argv[1])*atoi(argv[1]);
int method=atoi(argv[3]);
int iterations=atoi(argv[2]);
if(id==DATAOWNER)
{
printf("-------------------\n");
printf("Experiment one-sided stateful - based on step\n");
printf("Number of workers %d \n", number_of_workers);
printf("Number of tasks %d \n", number_of_tasks);
printf("Scheduling method %d \n", method);
printf("------------------- \n");
}
int * images = NULL;
int * results = NULL;
params.scheduled_tasks=0;
params.total_tasks=number_of_tasks;
params.total_workers=number_of_workers;
params.step=0;
params.method=method;
params.last_chunk=0;
if(method == 2 && argc == 6)
{
double h = atof(argv[4]);
double sigma = atof(argv[5]);
params.constant=helper_FSC(number_of_workers,number_of_tasks,h,sigma);
}
else if(method ==5 && argc == 6)
{
int F = atoi(argv[4]);
int L = atoi(argv[5]);
int D = helper_TSS(number_of_workers,number_of_tasks, F, L);
params.last_chunk = F + D;
params.constant = D;
params.minimum_chunk=L;
}
else if(method ==5 || method ==2 )
{
printf("Usgae: ./program image_width iterations iDLSMethods(0-STATIC 1-SS 2-FSC 3-GSS 4-FAC 5-TSS) (h,sigma) or (F,L) \n");
MPI_Abort(MPI_COMM_WORLD, -1);
}
else if(method==6)
{
char processor_name[30];
int name_len;
MPI_Get_processor_name(processor_name, &name_len);
params.knl_count= atoi(argv[4]);
params.my_weight= WF_helper(params.knl_count, processor_name, number_of_workers);
//printf("%s my weight %lf\n",processor_name,params.my_weight );
}
double start_time= MPI_Wtime();
images = (int *) calloc(number_of_tasks*3, sizeof(int));
results = (int *) calloc(number_of_tasks*3, sizeof(int));
double start_calc_time=0;
double end_calc_time=0;
double total_calc_time=0;
double total_request_time=0;
double max_loop_time=0;
double min_loop_time=0;
int check_request=0;
int to_execute=0;
int I_executed=0;
int I_executed_chunks=0;
double execution_times[number_of_workers];
int chunk_size;
int start=0;
int end=0;
MPI_Win win_global_scheduling_step;
MPI_Win win_global_scheduled_tasks;
int scheduling_step =0;
int scheduled_tasks=0;
int local_scheduling_step =0;
int local_scheduled_tasks=0;
MPI_Win_create(&scheduling_step, sizeof(int),sizeof(int), MPI_INFO_NULL,MPI_COMM_WORLD, &win_global_scheduling_step);
MPI_Win_create(&scheduled_tasks, sizeof(int),sizeof(int), MPI_INFO_NULL,MPI_COMM_WORLD, &win_global_scheduled_tasks);
const int one=1;
start_calc_time = MPI_Wtime();
while(start != -1)
{
//printf("Id %d local_scheduled_tasks %d\n", id,local_scheduled_tasks);
MPI_Win_lock(MPI_LOCK_SHARED,0,0,win_global_scheduling_step);
MPI_Get_accumulate(&one,1,MPI_INT,&local_scheduling_step,1,MPI_INT,0,0,1,MPI_INT,MPI_SUM,win_global_scheduling_step);
MPI_Win_unlock(0,win_global_scheduling_step);
params.step = local_scheduling_step;
calculate_next_chunk_stateful(params,&chunk_size);
if(params.method!=1)
{
MPI_Win_lock(MPI_LOCK_SHARED,0,0,win_global_scheduled_tasks);
MPI_Get_accumulate(&chunk_size,1,MPI_INT,&local_scheduled_tasks,1,MPI_INT,0,0,1,MPI_INT,MPI_SUM,win_global_scheduled_tasks);
MPI_Win_unlock(0,win_global_scheduled_tasks);
}
else
{
local_scheduled_tasks=local_scheduling_step;
}
if(local_scheduled_tasks>=params.total_tasks)
break;
start = local_scheduled_tasks;
end = start + MIN(params.total_tasks-local_scheduled_tasks, chunk_size);
//if(start==end)
//printf("Id %d start %d end %d local_scheduled_tasks %d\n", id , start, end, local_scheduled_tasks);
I_executed += end - start;
I_executed_chunks++;
if(end<start || start<0|| end<0)
break;
// start_calc_time = MPI_Wtime();
Mandelbrot(start,end,images,sqrt(params.total_tasks),iterations);
// printf("TO TERMINATE rank %d from %d to %d chunksize %d\n", id, end,start, end-start);
//end_calc_time = MPI_Wtime();
if(params.method==0)
{
start = -1;
}
}
end_calc_time = MPI_Wtime();
total_calc_time += end_calc_time - start_calc_time;
// get data from workers
// printf("master %d spent %f in loop\n",id ,total_calc_time);
MPI_Win_free(&win_global_scheduling_step);
MPI_Win_free(&win_global_scheduled_tasks);
MPI_Reduce(images,results,number_of_tasks*3,MPI_INT,MPI_SUM,DATAOWNER,MPI_COMM_WORLD);
double end_time= MPI_Wtime();
MPI_Gather(&total_calc_time,1,MPI_DOUBLE,&execution_times,1,MPI_DOUBLE,DATAOWNER,MPI_COMM_WORLD);
int * executed_at_id = (int *) calloc(params.total_workers,sizeof(int));
int * executed_chunks_at_id=(int *) calloc(params.total_workers,sizeof(int));
MPI_Gather(&I_executed,1,MPI_INT,executed_at_id,1,MPI_INT,DATAOWNER,MPI_COMM_WORLD);
MPI_Gather(&I_executed_chunks,1,MPI_INT,executed_chunks_at_id,1,MPI_INT,DATAOWNER,MPI_COMM_WORLD);
max_loop_time = execution_times[0];
min_loop_time = execution_times[0];
if(id==DATAOWNER)
{
// printf("----- ranks calculation times and total scheduled tasks -------\n");
printf("id time(s) \n");
printf("%d %lf\n",id, execution_times[id]);
for (int i = 1; i < number_of_workers; i++)
{
if(max_loop_time < execution_times[i] )
max_loop_time = execution_times[i];
else if(min_loop_time > execution_times[i])
min_loop_time = execution_times[i];
printf("%d %lf\n",i, execution_times[i]);
}
printf("Program execution time %lf\n", end_time-start_time);
printf("Paralell max calculation time %lf\n", max_loop_time);
// printf("Paralell min calculation time %lf\n", min_loop_time);
//for(int i=0;i<number_of_tasks*3;i=i+3)
// {
// printf("%d %d %d\n",results[i],results[i+1], results[i+2]);
// }
if(executed_at_id!=NULL)
free(executed_at_id);
if(executed_chunks_at_id!=NULL)
free(executed_chunks_at_id);
if(results!=NULL)
free(results);
if(images!=NULL)
free(images);
}
}
void Mandelbrot(int start, int end, int * computed_data,int image_width, int iterations)
{
int i ,j;
//#pragma omp parallel for private(i,j) schedule(runtime)
for(int counter=start;counter<end;++counter)
{
i = counter / image_width ;
j = counter % image_width;
double complex c= (x_min + i/(image_width-1.0)*(x_max-x_min)) + (y_min + j/(image_width-1.0)*(y_max-y_min)) * I;
double complex z = 0+(0 * I);
int k=0;
for (k = 0; k < iterations && cabs(z) < 2.0; ++k)
{
z = cpow(z,4) + c;
}
int R,G,B;
if (k==iterations)
{
R=0;
G=0;
B=0;
}
else if (k<16)
{
R=k*8;
G=k*8;
B=128+k*4;
}
else if (k>=16 && k<64)
{
R=128+k-16;
G=128+k-16;
B=192+k-16;
}
else if (k>=64)
{
R=iterations-k;
G=128+(iterations-k)/2;
B=iterations-k;
}
double temp = 0.0;
//printf("at %lf (%d,%d) (%f + i%f) %d,%d,%d\n",i,j,cabs(z),creal(c),cimag(c), R, G, B);
int index= 3*counter;
computed_data[index]= R;
computed_data[index+1]= G;
computed_data[index+2]= B;
}
}
//------- testing functions ----------
void parallel_one_sided_memory(int argc, char ** argv)
{
int id, number_of_workers;
MPI_Init(NULL,NULL);
MPI_Comm_size(MPI_COMM_WORLD, &number_of_workers);
MPI_Comm_rank(MPI_COMM_WORLD,&id);
all_processors_do(argc,argv,number_of_workers, id);
MPI_Finalize();
}
c4science · Help