//

// Author:

//

// Levi Barnes

//

// Copyright 2015

#include "mpi.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "unistd.h"

#include "limits.h"

#include <pthread.h>

#include "time.h"

#include "math.h" //exp

#include "GPUDegrid/degrid_gpu.cuh"

#include "Defines.h"

#include "GPUDebug.h"

typedef struct {float x,y;} float2;

typedef struct {double x,y;} double2;

int rank;

FILE* logfid;

#define rankprintf(format, ...) \

{ time_t t = time(NULL); \

char* foo = asctime(localtime(&t));\

foo[24]='\0';\

fprintf(logfid, "(%s) ", foo); \

fprintf(logfid, format, ##__VA_ARGS__); \

for (int q=0;q<rank;q++) printf(" ");\

printf("%d: ", rank);\

printf(format, ##__VA_ARGS__); \

fflush(logfid); }

//Length of each task message

//The first item is the task type

//If you create a task that needs more than TASK_LEN-1 integers, increase TASK_LEN

#define TASK_LEN 3

//Messages

#define MSG_CHECK 0

#define MSG_OK 1

#define MSG_STATUS 2

#define MSG_TASK_COMPLETE 3

#define MSG_ACK 4

#define MSG_TASK_COMING 5

//Task types

#define TASK_STATUS 101

#define TASK_DEGRID 102

#define TASK_SENDTOK 103

#define TASK_RECVTOK 104

#define TASK_KILLTOK 105

#define TASK_GENVIS 106

#define TASK_GENIMG 107

//Status responses

#define STATUS_IDLE 0

#define STATUS_BUSY 1

//Token types

#define TOKEN_VIS 1

#define TOKEN_IMG 2

typedef struct {

int tid;

int token_type; //TOKEN_VIS or TOKEN_IMG

int size;

void* data;

int on_rank;

void display() {

}

} token;

void throw_error(const char* txt) {

fprintf(stderr, "ERROR: %s\n", txt);

}

//TODO make variadic

//template <integer... MSG>

//void send_task(MPI_Comm comm, MSG... in) {

void send_task(MPI_Comm comm, int task_id, int token_id, int to) {

}

pthread_t tid[2];

pthread_mutex_t lock;

int node_status=45;

void* gpu_mem;

token* token_list[256];

int PAD(const int in) {

int pad_size = 128/sizeof(PRECISION2);

return ((in + pad_size - 1) / pad_size) * pad_size;

}

template <class CmplxType>

void init_gcf(CmplxType *gcf, size_t size) {

}

const char* task_name(int task_in) {

switch (task_in) {

case (TASK_STATUS): return "TASK_STATUS";

case (TASK_DEGRID): return "TASK_DEGRID";

case (TASK_SENDTOK): return "TASK_SENDTOK";

case (TASK_RECVTOK): return "TASK_RECVTOK";

case (TASK_KILLTOK): return "TASK_KILLTOK";

case (TASK_GENVIS): return "TASK_GENVIS";

case (TASK_GENIMG): return "TASK_GENIMG";

default: return "UNKNOWN";

};

}

void* exec_task(void* msg_in) {

int* msg = (int*) msg_in;

rankprintf("Beginning task %s on token %d. Setting status to BUSY.\n", task_name(msg[0]), msg[1]);

//Change status to IDLE

pthread_mutex_lock(&lock);

node_status = STATUS_BUSY;

pthread_mutex_unlock(&lock);

if (TASK_GENVIS == msg[0]) {

//Generate some visibilities

//This won't be needed long term

// msg[0] : task type

// msg[1] : tokenid;

// msg[2] : size

int next_tok=0;

while(token_list[next_tok] != 0 && next_tok < 256) next_tok++;

if(next_tok>=256) throw_error("Too many tokens\n");

token_list[next_tok] = new token;

token_list[next_tok]->tid = msg[1];

token_list[next_tok]->token_type = TOKEN_VIS;

int npts = msg[2];

token_list[next_tok]->size = npts;

//TODO padding for degrid

token_list[next_tok]->data = malloc(sizeof(PRECISION2)*(PAD(npts)+npts)); //in and out

token_list[next_tok]->on_rank = rank;

PRECISION2* vis = (PRECISION2*)token_list[next_tok]->data;

vis += PAD(npts);

//Random visibilities

for(int n=0; n<npts;n++) {

vis[n].x = ((float)rand())/RAND_MAX*1000;

vis[n].y = ((float)rand())/RAND_MAX*1000;

}

} else if (TASK_GENIMG == msg[0]) {

//Generate an image

//This won't be needed long term

// msg[0] : task type

// msg[1] : tokenid

// msg[2] : size

int next_tok=0;

while(token_list[next_tok] != 0 && next_tok < 256) next_tok++;

if(next_tok>=256) throw_error("Too many tokens\n");

token_list[next_tok] = new token;

token_list[next_tok]->tid = msg[1];

token_list[next_tok]->token_type = TOKEN_IMG;

int img_dim = msg[2];

token_list[next_tok]->size = img_dim;

//TODO padding for degrid

token_list[next_tok]->data = malloc(sizeof(PRECISION2)*img_dim*img_dim); //out and in

token_list[next_tok]->on_rank = rank;

PRECISION2* img = (PRECISION2*)token_list[next_tok]->data;

//Some image

for(int x=0; x<img_dim;x++)

for(int y=0; y<img_dim;y++) {

img[x+img_dim*y].x = exp(-((x-1400.0)*(x-1400.0)+(y-3800.0)*(y-3800.0))/8000000.0)+1.0;

img[x+img_dim*y].y = 0.4;

}

} else if (TASK_KILLTOK == msg[0]) {

free(token_list[msg[0]]->data);

delete token_list[msg[0]];

token_list[msg[0]] = NULL;

} else if (TASK_DEGRID == msg[0]) {

// Degrid

// msg[1] : visibility tokenid

// msg[2] : image tokenid

int vistok=0, imgtok=0;

while(token_list[vistok]->tid != msg[1] && vistok<500) vistok++;

if (token_list[vistok]->token_type != TOKEN_VIS)

throw_error("First token passed to degrid "

"does not contain visibilities");

while(token_list[imgtok]->tid != msg[2]&& imgtok<500) imgtok++;

if (token_list[imgtok]->token_type != TOKEN_IMG)

throw_error("Second token passed to degrid "

"is not an image");

int img_size = token_list[imgtok]->size;

PRECISION2* img = (PRECISION2*) token_list[imgtok]->data;

int npts = token_list[vistok]->size;

PRECISION2* out = (PRECISION2*) token_list[vistok]->data;

PRECISION2* in = out + PAD(npts);

PRECISION2* gcf = (PRECISION2*)malloc(sizeof(PRECISION2*)*64*GCF_DIM*GCF_DIM);

init_gcf(gcf, GCF_DIM);

degridGPU(out, in, npts, img, img_size, gcf, GCF_DIM);

} else {

sleep(2);

}

rankprintf("Task complete. Setting status to IDLE.\n");

//Change status to IDLE

pthread_mutex_lock(&lock);

node_status = STATUS_IDLE;

pthread_mutex_unlock(&lock);

return NULL;

}

void run_server(int size) {

}

int get_status(MPI_Comm comm1) {

}

class task {

};

class taskQueue {

};

void run_client(int size) {

}

int main( int argc, char *argv[] )

}