test_list.c
#include "list.h"
#include <stdio.h>
#include <stdlib.h>
int main (){
char ans[2];
int num;
struct node *head = NULL;
do {
do {
printf("Enter a number: ");
scanf("%d", &num);
head = push(head, num);//Can change to append
printf("Do you want another num (y or n): ");
scanf("%1s",ans);
} while(ans[0] == 'y');
printf("Sort ascending or descending (a or d)? ");
scanf("%1s",ans);
if(ans[0] == 'a') head=sort_ascending(head);
else if(ans[0] == 'd') head=sort_descending(head);
print(head, length(head));
printf("Do you want to do this again (y or n)? ");
scanf("%1s",ans);
if(ans[0] == 'y') head = clear(head);
} while(ans[0] == 'y');
return 0;
}
void test(){
LL tab1 = NULL;
int tab[N]={12,2,0,3,55,88,42,26,17,8};
int i;
for (i=9;i>=0;i--){
add_queue(&tab1,tab[i]);
}
display_size(tab1);
printf("\n");
print_inc(tab1);
printf("\n");
printf("Valeur max de la liste: %d\n", maximum(tab1));
printf("\n");
printf("Valeur min de la liste: %d\n", minimum(tab1));
printf("\n");
printf("Tri de la liste: \n");
sort_ascending(tab1);
printf("\n");
if(delete_list(tab1)==NULL){
printf("Linked list has been deleted.\n");
}
}
int main (){
char ans[2];
int num;
struct node *head = NULL;
struct node * tail = NULL;
do {
do {
printf("Enter a number: ");
scanf("%d", &num);
// printf("hi");
head = push(head, num);//Can change to append
//printf("%d", length(head));
printf("Do you want another num (y or n): ");
scanf("%1s",ans);
} while(ans[0] == 'y');
//head = insert_middle(head, 1, 4);
//printf("4 was inserted into index 1 \n");
//head = remove_node(head, 3);
//printf("all 3's were removed from the list \n");
printf("Sort ascending or descending (a or d)? ");
scanf("%1s",ans);
if(ans[0] == 'a') head=sort_ascending(head);
else if(ans[0] == 'd') head=sort_descending(head);
//head = insert_middle(head, 3, 1);
print(head, length(head));
printf("Do you want to do this again (y or n)? ");
scanf("%1s",ans);
if(ans[0] == 'y') head = clear(head);
//print(head, length(head));
// printf("%d", length(head));
} while(ans[0] == 'y');
return 0;
}
void NEKTAR_MEX::MEX_init (int *map, int n, int *AdjacentPartitions, int NAdjacentPartitions, MPI_Comm comm_in){
/*
n - [INPUT] integer - length of array "map", number of degrees of freedom processed in this partition
map - [INPUT] - array of integers - global IDs of degrees of fredom processed in this partition
AdjacentPartitions - [INPUT] - array of integers - list of possible adjacent partitions
NAdjacentPartitions - [INPUT] integer - number of possible adjacent partitions
comm - [INPUT] - communicator
*/
/* at the beginning we assume that NAdjacentPartitions can be greater or equall to the
actuall number of partition to communicate with */
int *partner_map_size;
int **partners_map;
int *shared_dof;
int i,j,k,ii,jj,partner;
comm = comm_in;
MPI_Comm_rank(comm,&my_rank);
#ifdef MEX_REPORT
static int FLAG_INIT = 0;
#endif
MPI_Request *request_recv_tmp, *request_send_tmp;
//fprintf(stderr,"my_rank = %d, NAdjacentPartitions = %d\n",my_rank,NAdjacentPartitions);
request_recv_tmp = new MPI_Request[NAdjacentPartitions];
request_send_tmp = new MPI_Request[NAdjacentPartitions];
partner_map_size = new int[NAdjacentPartitions];
shared_dof = new int[NAdjacentPartitions];
for (i = 0; i < NAdjacentPartitions; ++i)
MPI_Irecv(&partner_map_size[i],1,MPI_INT,AdjacentPartitions[i],AdjacentPartitions[i],comm,&request_recv_tmp[i]);
for (i = 0; i < NAdjacentPartitions; ++i)
MPI_Isend(&n,1,MPI_INT,AdjacentPartitions[i],my_rank,comm,&request_send_tmp[i]);
MPI_Waitall(NAdjacentPartitions,request_recv_tmp,MPI_STATUS_IGNORE);
MPI_Waitall(NAdjacentPartitions,request_send_tmp,MPI_STATUS_IGNORE);
//allocate memory for incomming messages
partners_map = new int*[NAdjacentPartitions];
for (i = 0; i < NAdjacentPartitions; i++)
partners_map[i] = new int[partner_map_size[i]];
//get partners map
for (i = 0; i < NAdjacentPartitions; ++i)
MPI_Irecv(partners_map[i],partner_map_size[i],MPI_INT,AdjacentPartitions[i],AdjacentPartitions[i],comm,&request_recv_tmp[i]);
//send local map to partners
for (i = 0; i < NAdjacentPartitions; ++i)
MPI_Isend(map,n,MPI_INT,AdjacentPartitions[i],my_rank,comm,&request_send_tmp[i]);
MPI_Waitall(NAdjacentPartitions,request_recv_tmp,MPI_STATUS_IGNORE);
MPI_Waitall(NAdjacentPartitions,request_send_tmp,MPI_STATUS_IGNORE);
// compare local map and partners map
for (partner = 0; partner < NAdjacentPartitions; ++partner){
shared_dof[partner] = 0;
for (i = 0; i < n; ++i){
for (j = 0; j < partner_map_size[partner]; ++j){
if (map[i] == partners_map[partner][j]){
shared_dof[partner]++;
break;
}
}
}
}
/* calculate the number of partitions to communicate with */
for (partner = 0, Npartners = 0; partner < NAdjacentPartitions; ++partner){
if (shared_dof[partner] > 0)
Npartners++;
}
delete[] request_recv_tmp;
delete[] request_send_tmp;
request_recv = (MPI_Request *) malloc(Npartners*sizeof(MPI_Request));
request_send = (MPI_Request *) malloc(Npartners*sizeof(MPI_Request));
for (i = 0; i < Npartners; ++i){
request_recv[i] = MPI_REQUEST_NULL;
request_send[i] = MPI_REQUEST_NULL;
}
#if (defined (__bg__) || defined (__blrts__) )
posix_memalign((void**)&partner_list,16, Npartners*sizeof(int));
posix_memalign((void**)&message_size,16, Npartners*sizeof(int));
#else
partner_list = (int *) malloc(Npartners*sizeof(int));
message_size = (int *) malloc(Npartners*sizeof(int));
#endif
for (partner = 0, i = 0; partner < NAdjacentPartitions; ++partner){
if (shared_dof[partner] > 0){
partner_list[i] = AdjacentPartitions[partner];
message_size[i] = shared_dof[partner];
i++;
}
}
/*
the "partner_list" now can be sorted with respect to topology and message size
*/
int *pivot, *message_size_tmp, *partner_map_tmp;
#if (defined (__bg__) || defined (__blrts__) )
posix_memalign((void**)&my_coord,16, 4*sizeof(int));
posix_memalign((void**)&partners_coordinates,16, Npartners*4*sizeof(int));
get_rank_coordinates(my_coord);
get_partners_coordinates(Npartners,partner_list,my_coord,partners_coordinates,comm);
posix_memalign((void**)&pivot,16, Npartners*sizeof(int));
posix_memalign((void**)&message_size_tmp,16, Npartners*sizeof(int));
posix_memalign((void**)&partner_map_tmp,16, Npartners*sizeof(int));
#else
pivot = (int *) malloc( Npartners*sizeof(int));
message_size_tmp = (int *) malloc( Npartners*sizeof(int));
partner_map_tmp = (int *) malloc( Npartners*sizeof(int));
#endif
/* initialize pivot to default values */
for (i = 0; i < Npartners; ++i)
pivot[i] = i;
#if (defined (__bg__) || defined (__blrts__) )
reorder_partner_list_2(Npartners,partners_coordinates,my_coord,partner_list,message_size,pivot);
free(partners_coordinates);
#else
sort_ascending(Npartners,partner_list,message_size,pivot);
#endif
MPI_Barrier(comm);
//if (my_rank == 0)
// fprintf(stderr,"MEX: sort_ascending - done\n");
for (i = 0; i < Npartners; ++i)
message_size_tmp[pivot[i]] = message_size[i];
memcpy(message_size,message_size_tmp,Npartners*sizeof(int));
/*
map partner_list to AdjacentPartitions
partner_map_tmp will store the index of partner_list[i] in AdjacentPartitions
*/
for (i = 0; i < Npartners; ++i){
for (j = 0; j < NAdjacentPartitions; ++j){
if (AdjacentPartitions[j] == partner_list[i]){
partner_map_tmp[i] = j;
break;
}
}
}
free(pivot);
free(message_size_tmp);
MPI_Barrier(comm);
//if (my_rank == 0)
// fprintf(stderr,"MEX: partners reordering - done\n");
#if (defined (__bg__) || defined (__blrts__) )
posix_memalign((void**)&message_send_map,16, Npartners*sizeof(int*));
for (i = 0; i < Npartners; ++i){
posix_memalign((void**)&message_send_map[i],16, message_size[i]*sizeof(int));
memset(message_send_map[i],'\0',message_size[i]*sizeof(int));
}
posix_memalign((void**)&message_recv_map,16, Npartners*sizeof(int*));
for (i = 0; i < Npartners; ++i){
posix_memalign((void**)&message_recv_map[i],16, message_size[i]*sizeof(int));
memset(message_recv_map[i],'\0',message_size[i]*sizeof(int));
}
posix_memalign((void**)&send_buffer,16, Npartners*sizeof(double*));
for (i = 0; i < Npartners; ++i){
posix_memalign((void**)&send_buffer[i],16, message_size[i]*sizeof(double));
memset(send_buffer[i],'\0',message_size[i]*sizeof(double));
}
posix_memalign((void**)&recv_buffer,16, Npartners*sizeof(double*));
for (i = 0; i < Npartners; ++i){
posix_memalign((void**)&recv_buffer[i],16, message_size[i]*sizeof(double));
memset(recv_buffer[i],'\0',message_size[i]*sizeof(double));
}
#else
message_send_map = (int **) malloc(Npartners*sizeof(int*));
for (i = 0; i < Npartners; ++i){
message_send_map[i] = (int *) malloc(message_size[i]*sizeof(int));
memset(message_send_map[i],'\0',message_size[i]*sizeof(int));
}
message_recv_map = (int **) malloc(Npartners*sizeof(int*));
for (i = 0; i < Npartners; ++i){
message_recv_map[i] = (int *) malloc(message_size[i]*sizeof(int));
memset(message_recv_map[i],'\0',message_size[i]*sizeof(int));
}
send_buffer = (double **) malloc(Npartners*sizeof(double*));
for (i = 0; i < Npartners; ++i){
send_buffer[i] = (double *) malloc(message_size[i]*sizeof(double));
memset(send_buffer[i],'\0',message_size[i]*sizeof(double));
}
recv_buffer = (double **) malloc(Npartners*sizeof(double*));
for (i = 0; i < Npartners; ++i){
recv_buffer[i] = (double *) malloc(message_size[i]*sizeof(double));
memset(recv_buffer[i],'\0',message_size[i]*sizeof(double));
}
#endif
/* to support unsorted list of degrees of freedom
two maps are created
it is possible to check if the two maps are identical
so only one will be kept and pointers
message_send_map[k] and message_recv_map[k]
will be the same - this will help to save some memory
*/
MPI_Barrier(comm);
//if (my_rank == 0)
// fprintf(stderr,"MEX: file = %s, line = %d\n",__FILE__,__LINE__);
double map_time_start = MPI_Wtime();
#ifdef TEST_OMP
#pragma omp parallel private(partner, i, ii, j, jj)
{
#pragma omp for schedule(dynamic)
for (k = 0; k < Npartners; ++k){
partner = partner_map_tmp[k];
for (i = 0, ii=0; i < n; ++i){
for (j = 0; j < partner_map_size[partner]; ++j){
if (map[i] == partners_map[partner][j]){
message_send_map[k][ii] = i;
ii++;
break;
}
}
}
for (j = 0, jj = 0; j < partner_map_size[partner]; ++j){
for (i = 0; i < n; ++i){
if (map[i] == partners_map[partner][j]){
message_recv_map[k][jj] = i;
jj++;
break;
}
}
}
}
}
#else
for (k = 0; k < Npartners; ++k){
partner = partner_map_tmp[k];
for (i = 0, ii=0; i < n; ++i){
for (j = 0; j < partner_map_size[partner]; ++j){
if (map[i] == partners_map[partner][j]){
message_send_map[k][ii] = i;
ii++;
break;
}
}
}
for (j = 0, jj = 0; j < partner_map_size[partner]; ++j){
for (i = 0; i < n; ++i){
if (map[i] == partners_map[partner][j]){
message_recv_map[k][jj] = i;
jj++;
break;
}
}
}
}
#endif
MPI_Barrier(comm);
//if (my_rank == 0)
// fprintf(stderr,"MEX: file = %s, line = %d map_time = %f\n",__FILE__,__LINE__,MPI_Wtime() - map_time_start);
free(partner_map_tmp);
/*
for (partner = 0, k = 0; partner < NAdjacentPartitions; ++partner){
if (shared_dof[partner] == 0) continue;
for (i = 0, ii=0; i < n; ++i){
for (j = 0; j < partner_map_size[partner]; ++j){
if (map[i] == partners_map[partner][j]){
message_send_map[k][ii] = i;
ii++;
break;
}
}
}
for (j = 0, jj = 0; j < partner_map_size[partner]; ++j){
for (i = 0; i < n; ++i){
if (map[i] == partners_map[partner][j]){
message_recv_map[k][jj] = i;
jj++;
break;
}
}
}
k++;
}
*/
#ifdef MEX_REPORT
//print report to file
FILE *pFile;
char fname[128];
sprintf(fname,"report_gs_init.%d.%d",FLAG_INIT,my_rank);
pFile = fopen(fname,"w");
for (i = 0; i < NAdjacentPartitions; ++i){
if (shared_dof[i] > 0)
fprintf(pFile,"%d %d\n",AdjacentPartitions[i],shared_dof[i]);
}
fprintf(pFile,"-1 -1 \n");
fprintf(pFile,"**\n");
for (partner = 0; partner < Npartners; ++partner){
fprintf(pFile,"will send to partner %d array of size %d\n",partner_list[partner],message_size[partner]);
for (i = 0; i < message_size[partner]; ++i)
fprintf(pFile,"%d ", message_send_map[partner][i]);
fprintf(pFile,"\n");
}
fprintf(pFile,"**\n");
for (partner = 0; partner < Npartners; ++partner){
fprintf(pFile,"will recv from partner %d array of size %d\n",partner_list[partner],message_size[partner]);
for (i = 0; i < message_size[partner]; ++i)
fprintf(pFile,"%d ", message_recv_map[partner][i]);
fprintf(pFile,"\n");
}
fprintf(pFile,"**\n");
fprintf(pFile,"My d.o.f are:\n");
for (i = 0; i < n; ++i)
fprintf(pFile,"%d ",map[i]);
fprintf(pFile,"\n");
fclose(pFile);
FLAG_INIT++;
#endif
delete[] shared_dof;
delete[] partner_map_size;
for (i = 0; i < NAdjacentPartitions; i++)
delete partners_map[i];
delete[] partners_map;
}
