void
ParaCommMpiWorld::probe(
int* source,
int* tag
)
{
MPI::Status mpiStatus;
MPI::COMM_WORLD.Probe(MPI::ANY_SOURCE, MPI::ANY_TAG, mpiStatus);
*source = mpiStatus.Get_source();
*tag = mpiStatus.Get_tag();
TAG_TRACE (Probe, From, *source, *tag);
}
bool
ParaCommMpiWorld::iProbe(
int* source,
int* tag
)
{
bool flag;
MPI::Status mpiStatus;
flag = MPI::COMM_WORLD.Iprobe(MPI::ANY_SOURCE, MPI::ANY_TAG, mpiStatus);
if( flag )
{
*source = mpiStatus.Get_source();
*tag = mpiStatus.Get_tag();
TAG_TRACE (Iprobe, From, *source, *tag);
}
return flag;
}
int
ParaCommMpiWorld::waitSpecTagFromSpecSource(
const int source,
const int datatypeId,
const int tag,
int *receivedTag
)
{
MPI::Status mpiStatus;
MPI::COMM_WORLD.Probe(source, MPI::ANY_TAG, mpiStatus);
(*receivedTag) = mpiStatus.Get_tag();
TAG_TRACE (Probe, From, source, (*receivedTag));
if( tag == (*receivedTag) )
{
return 0;
}
else
{
return 1;
}
}
bool
ParaCommMpiWorld::waitToken(
int tempRank
)
{
pthread_mutex_lock(&tokenAccessLock);
if( token[0] == myRank )
{
pthread_mutex_unlock(&tokenAccessLock);
return true;
}
else
{
int previousRank = myRank - 1;
if( previousRank == 0 )
{
if( token[0] != -1 )
{
previousRank = comSize - 1;
}
}
int receivedTag;
MPI::Status mpiStatus;
MPI::COMM_WORLD.Probe(MPI::ANY_SOURCE, MPI::ANY_TAG, mpiStatus);
receivedTag = mpiStatus.Get_tag();
TAG_TRACE (Probe, From, mpiStatus.Get_source(), receivedTag);
if( receivedTag == TagToken )
{
receive(token, 2, ParaINT, 0, TagToken);
assert(token[0] == myRank);
pthread_mutex_unlock(&tokenAccessLock);
return true;
}
else
{
pthread_mutex_unlock(&tokenAccessLock);
return false;
}
}
}
void PSO::Swarm::evaluate_slave() {
double f(log(0.0));
int id(0);
int flag(0);
int tag(0);
int dest(0);
Point position(numParams);
MPI::Status status;
// fprintf(stderr,"Slave %d ready.\n",mpi_rank);
while (1) {
// flag = MPI::COMM_WORLD.Iprobe(0,MPI::ANY_TAG,status);
// if (flag) {
// tag = status.Get_tag();
MPI::COMM_WORLD.Recv(&id,1,MPI::INT,0,MPI::ANY_TAG,status);
if (status.Get_tag() == 0) break;
MPI::COMM_WORLD.Recv(position.data(),numParams,MPI::DOUBLE,0,MPI::ANY_TAG,status);
f = p->evalFunc(position,p->evalParams);
MPI::COMM_WORLD.Send(&id,1,MPI::INT,0,2);
MPI::COMM_WORLD.Send(&f,1,MPI::DOUBLE,0,2);
// }
}
// fprintf(stderr,"Slave %d done.\n",mpi_rank);
}
int main(int argc, char** argv)
{
//_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
//_CrtMemState s1;
//_CrtMemCheckpoint( &s1 );
/* run multiple trials of Develep
input: trial text file
first column: number of trials to run
second column: parameter file for trials
third column: data for trials
*/
string trialsetup(argv[1]);
// cout << "trialsetup: " + trialsetup + "\n";
int totaltrials = 0;
vector<int> trialset;
vector<string> paramfile;
vector<string> datafile;
ifstream fs(trialsetup);
getTrialSetup(fs,totaltrials,trialset,paramfile,datafile);
int numsent=0;
//MPI stuff
int master=0;
int ierr;
MPI::Init();
int numprocs = MPI::COMM_WORLD.Get_size();
int myid = MPI::COMM_WORLD.Get_rank();
//cout << "I am process " + to_string(static_cast<long long>(myid)) + " of " + to_string(static_cast<long long>(numprocs)) + "\n";
MPI::Status status;
//const char * pbuff,dbuff;
try
{
if (myid==master){
//cout << "total trials: " + to_string(static_cast<long long>(totaltrials)) + "\n";
//cout << "In master loop\n";
cout << "Running trials of ellenGP: \n Number of trials: " + to_string(static_cast<long long>(totaltrials)) +"\n Number of processors: " + to_string(static_cast<long long>(numprocs)) + "\n";
// schedule tasks from master node
for (int i=0;i<min(numprocs-1,totaltrials);i++){
//cout << "sending " + paramfile.at(i) + " to process " + to_string(static_cast<long long>(i)) + "\n";
MPI::COMM_WORLD.Send(paramfile.at(i).c_str(),paramfile.at(i).length(),MPI::CHAR,i+1,i+1);
//cout << "sending " + datafile.at(i) + " to process " + to_string(static_cast<long long>(i)) + "\n";
MPI::COMM_WORLD.Send(datafile.at(i).c_str(),datafile.at(i).length(),MPI::CHAR,i+1,i+1);
numsent++;
//cout << "numsent: " + to_string(static_cast<long long>(numsent)) + "\n";
}
//int curnumsent=numsent;
int stops =0;
while(numsent<=totaltrials && stops<numprocs-1){
int ans;
MPI::COMM_WORLD.Recv(&ans,1,MPI::INT,MPI::ANY_SOURCE,MPI::ANY_TAG,status);
const int sender = status.Get_source();
//int anstype = status.Get_tag();
if (numsent < totaltrials){
MPI::COMM_WORLD.Send(paramfile.at(numsent).c_str(),paramfile.at(numsent).length(),MPI::CHAR,sender,numsent+1);
MPI::COMM_WORLD.Send(datafile.at(numsent).c_str(),datafile.at(numsent).length(),MPI::CHAR,sender,numsent+1);
++numsent;
}
else{
//cout << "sending stop command to process " + to_string(static_cast<long long>(sender)) + "\n";
MPI::COMM_WORLD.Send(MPI::BOTTOM,0,MPI::CHAR,sender,0);
++stops;
}
} cout << "out of master while loop\n";
}
else{
//cout << "in slave task \n";
// receive tasks and send completion messages to master
//cout << "in slave task. myid is " + to_string(static_cast<long long>(myid)) + " and totaltrials is " + to_string(static_cast<long long>(totaltrials)) + "\n";
bool cont = true;
while (cont){
if (myid <= totaltrials){
//char * pbuff,dbuff;
//cout << "probe master status\n";
MPI::COMM_WORLD.Probe(master, MPI::ANY_TAG, status);
int l1 = status.Get_count(MPI::CHAR);
char * pbuff = new char[l1];
//cout << "Receive packet\n";
MPI::COMM_WORLD.Recv(pbuff,l1,MPI::CHAR,master, MPI::ANY_TAG,status);
//cout << "received pbuff value: " + string(pbuff) + "\n";
if(status.Get_tag() !=0 ){
MPI::COMM_WORLD.Probe(master, MPI::ANY_TAG, status);
int l2 = status.Get_count(MPI::CHAR);
char * dbuff = new char[l2];
MPI::COMM_WORLD.Recv(dbuff,l2,MPI::CHAR,master, MPI::ANY_TAG,status);
//cout << "received dbuff value: " + string(dbuff) + "\n";
if(status.Get_tag() !=0 ){
int tag = status.Get_tag();
string pfile(pbuff,l1);
string dfile(dbuff,l2);
cout << "running process " + to_string(static_cast<long long>(tag)) + " of " + to_string(static_cast<long long>(totaltrials)) + " on processor " + to_string(static_cast<long long>(myid)) + " : " + pfile.substr(pfile.rfind('/')+1,pfile.size()) + ", " + dfile.substr(dfile.rfind('/')+1,dfile.size()) + "\n";
//run develep
runEllenGP(pfile,dfile,1,myid);
//cout << "hello\n";
cout << "\nfinished process " + to_string(static_cast<long long>(tag)) + " of " + to_string(static_cast<long long>(totaltrials)) + " on processor " + to_string(static_cast<long long>(myid)) + " : " + pfile.substr(pfile.rfind('/')+1,pfile.size()) + ", " + dfile.substr(dfile.rfind('/')+1,dfile.size()) + "\n";
// send message when finished
int tmp = 1;
MPI::COMM_WORLD.Send(&tmp,1,MPI::INT,master,myid);
}
else{
//cout << "status tag is zero on process " + to_string(static_cast<long long>(myid)) + "\n";
cont=false;
}
delete [] dbuff;
}
else{
//cout << "status tag is zero on process " + to_string(static_cast<long long>(myid)) + "\n";
cont=false;
}
delete [] pbuff;
}
}
}
MPI::Finalize();
char key;
if(myid==master)
cout << "All trials completed. Exiting..." << endl;
//key = getchar();
}
catch(const std::bad_alloc&)
{
cout << "bad allocation error from processor " << to_string(static_cast<long long>(myid)) << "\n";
exit(1);
}
catch(exception& er)
{
cout << "Error: " << er.what() << endl;
exit(1);
}
catch(...)
{
cout << "Exception Occurred."<<endl;
exit(1);
}
return 0;
}
int main(int argc, char * argv[]){
int tag, send_tag;
int to,from;
int st_count, st_source, st_tag;
double start_time = 0.0;
double end_time = 0.0;
MPI::Status status;
MPI::Init(argc, argv);
int rank = MPI::COMM_WORLD.Get_rank();
int size = MPI::COMM_WORLD.Get_size();
MPI_Barrier(MPI_COMM_WORLD);
start_time = MPI_Wtime();
int option;
opterr = 0;
int N = 0;
string web_file;
while ((option = getopt(argc, argv, "l:n:"))!= -1)
{
switch (option)
{
case 'n':
N = atoi(optarg);
break;
case 'l':
web_file = string(optarg);
break;
case '?':
if (optopt == 'n')
cerr<< "Option -"<<char(optopt)<<" requires an argument." <<endl;
else if (isprint (optopt))
cerr<< "Unknown option `-"<<char(optopt)<<"'.\n"<<endl;
else
cerr<< "Unknown option character `"<<std::hex<<optopt<<"'."<<endl;
}
}
vector<string> URLs;
char buffer[1024];
string line;
system("rm -fr /tmp/xiw412/");
system("mkdir /tmp/xiw412/");
if(rank == 0)
{
fstream fread_file(web_file.c_str(), ios::in);
while (getline(fread_file, line)){
URLs.push_back(line);
}
}
if(rank == 0)
{
to = 0;
send_tag = 0;
int round = 0;
while(round * size < URLs.size())
{
for(int i = round * size; i < (round + 1) * size && i < URLs.size(); i++)
{
sprintf(buffer, "%s", URLs[i].c_str());
cout << rank << ":"<< "sending " << buffer << endl;
MPI::COMM_WORLD.Send(buffer,1024, MPI::CHAR, i%size, send_tag);
to++;
send_tag++;
}
tag = MPI::ANY_TAG;
from = MPI::ANY_SOURCE;
MPI::COMM_WORLD.Recv(buffer, 1024, MPI::CHAR, from, tag, status);
st_count = status.Get_count(MPI::CHAR);
st_source = status.Get_source();
st_tag = status.Get_tag();
string result("");
result = parse(buffer, N);
strcpy(buffer,result.c_str());
MPI::COMM_WORLD.Send(buffer,1024, MPI::CHAR, 0, st_tag);
for(int i = round * size; i < (round + 1) * size && i < URLs.size(); i++)
{
tag = MPI::ANY_TAG;
from = MPI::ANY_SOURCE;
MPI::COMM_WORLD.Recv(buffer, 1024, MPI::CHAR, from, tag, status);
st_count = status.Get_count(MPI::CHAR);
st_source = status.Get_source();
st_tag = status.Get_tag();
cout << rank <<":" << "received from "<<st_source<<endl<< buffer << endl;
}
round++;
}
for (int i = 1; i < size; ++i)
{
strcpy(buffer, "Finish");
MPI::COMM_WORLD.Send(buffer,1024, MPI::CHAR, i, 0);
}
}
else
{
while(1)
{
tag = MPI::ANY_TAG;
from = MPI::ANY_SOURCE;
MPI::COMM_WORLD.Recv(buffer, 1024, MPI::CHAR, from, tag, status);
st_count = status.Get_count(MPI::CHAR);
st_source = status.Get_source();
st_tag = status.Get_tag();
// cout<<" rank " << rank <<": " << "st_count:"<<st_count<<" st_source"<< st_source << " st_tag "<< st_tag << endl;
// cout<<" " << buffer <<endl;
if (strcmp(buffer, "Finish") == 0)
break;
string result("");
result = parse(buffer, N);
strcpy(buffer,result.c_str());
MPI::COMM_WORLD.Send(buffer,1024, MPI::CHAR, 0, st_tag);
}
}
cout << "rank " << rank <<": "<<"I am dying, goodbye!"<<endl;
MPI_Barrier(MPI_COMM_WORLD);
end_time = MPI_Wtime();
printf("The running time is : %lf \n",end_time-start_time);
MPI::Finalize();
return 0;
}
void *mpi_thread(void *arg) {
struct State *state = (struct State *)arg;
int buf;
MPI::Status status;
set<int> queue;
bool inside = false;
while (1) {
MPI::COMM_WORLD.Recv(&buf, 1, MPI::INT, MPI::ANY_SOURCE, MPI::ANY_TAG, status);
state->lamport = max(state->lamport, buf) + 1;
switch (status.Get_tag()) {
case INSIDE_TAG: // enter/exit
if (!inside) {
for (int i = 0; i < state->size; i++) {
if (i != state->rank) {
MPI::COMM_WORLD.Send(&state->lamport, 1, MPI::INT, i, REQUEST_TAG);
}
}
int request_clock = state->lamport;
int replies_received = 0;
while (replies_received < state->size - 1) {
MPI::COMM_WORLD.Recv(&buf, 1, MPI::INT, MPI::ANY_SOURCE, MPI::ANY_TAG, status);
state->lamport = max(state->lamport, buf) + 1;
switch (status.Get_tag()) {
case REQUEST_TAG:
if (request_clock < buf || (buf == request_clock && state->rank < status.Get_source())) {
// current process has higher priority
queue.insert(status.Get_source());
} else {
// other process has higher priority
MPI::COMM_WORLD.Send(&state->lamport, 1, MPI::INT, status.Get_source(), AGREE_TAG);
}
break;
case AGREE_TAG:
if (buf > request_clock) {
replies_received++;
log(state, "comm: Agree %d received from %d", buf, status.Get_source());
}
break;
default:
log(state, "comm: Unknown message tag %d", status.Get_tag());
}
}
inside = true;
unique_lock<mutex> lck(state->mtx);
state->ready = true;
state->cv.notify_all();
lck.unlock();
} else {
// broadcast agree to all in queue
char *repr = (char *)malloc(1024);
*repr = '\0';
for (int p : queue) {
sprintf(repr + strlen(repr), "%d, ", p);
}
state->lamport++;
log(state, "comm: !!! LEFT, %s", repr);
free(repr);
for (int p : queue) {
MPI::COMM_WORLD.Send(&state->lamport, 1, MPI::INT, p, AGREE_TAG);
}
queue.clear();
inside = false;
}
break;
case REQUEST_TAG:
if (inside) {
queue.insert(status.Get_source());
} else {
MPI::COMM_WORLD.Send(&state->lamport, 1, MPI::INT, status.Get_source(), AGREE_TAG);
state->lamport++;
}
break;
case AGREE_TAG:
break;
default:
log(state, "comm: Unknown message tag %d", status.Get_tag());
}
}
}
int main(int argc, char* argv[])
{
int pid; //For rank of current process
int no_of_process; //To find the total number of processes
int size; //Size of processes to be allocated for each process.
//Initializing the MPI environment
MPI::Init ( argc, argv );
//Getting the number of processes
no_of_process = MPI::COMM_WORLD.Get_size();
//Handling if run as a single application.
if(no_of_process<2){
cout<<"\n ERROR: You'll need atleast 2 processes to run this application.\n\n";
MPI_Finalize();
return 0;
}
//argv[1] - PERCENT OF KEYWORDS REQUIRED ; argv[2] - FOLDER PATH
if(!argv[1] || !argv[2]){
cout<<"\n\n Parameter not provided. Quitting\n";
MPI_Finalize();
return 0;
}
//Get the process ID
pid = MPI::COMM_WORLD.Get_rank();
// Process ID 0 => Initial Process
if(pid==0){
queue<string> que;
que.push(string(argv[2],strlen(argv[2])));
/********* INITIAL STRUCTURE TO HAVE SOME VALUES IN THE QUEUE ***************/
string dir = que.front();
que.pop();
DIR *dp;
struct dirent *dirp;
if((dp = opendir(dir.c_str())) == NULL) {
cout << "Error(" << errno << ") opening " << dir << endl;
return errno;
}
while ((dirp = readdir(dp)) != NULL) {
if(((string)dirp->d_name).compare(".")==0||((string)dirp->d_name).compare("..")==0){
continue;
}
que.push(dir+"/"+string(dirp->d_name)); //If only this statement is present, we push all the files into the queue
}
closedir(dp);
/********* INITIAL STRUCTURE TO HAVE SOME VALUES IN THE QUEUE ***************/
while(!que.empty()){
// ======== FUNCTION TO PRINT QUEUE VALUES ========
queue<string> que3;
que3=que;
cout<<"\n\n PARENT Queue : "<<endl;
//Temp function to print the value of the queue
while(!que3.empty()){
cout<<que3.front()<<endl;
que3.pop();
}
//Allocate work to processes equally.
int i=0;
size=1; //By default, allocating one directory per process
string buf; //Buffer to send the folders to the subordinate processes
if(que.size()>(no_of_process-1)){
size=ceil((float)que.size()/(no_of_process-1));
}
/************* PARENT SENDER PROCESS ***********************/
/************* ===================== ***********************/
while(!que.empty() && i<=no_of_process-1){
int j=0;
buf="";
while(j<size && !que.empty()){
buf+=que.front();
que.pop();
buf+=";";
j++;
}
// MPI::Comm::Send(const void* buf, int count, MPI::Datatype& datatype, int dest, int tag)
MPI::COMM_WORLD.Send(buf.c_str(), buf.length(), MPI::CHAR, i+1, i+1);
i++;
}
/************* PARENT RECEIVER PROCESS ***********************/
/************* ======================= ***********************/
while(i>0){
// cout<<"\n\n Process 0 Waiting to receive from child";
MPI::Status status;
//Probe for values first
MPI::COMM_WORLD.Probe(MPI::ANY_SOURCE, MPI::ANY_TAG, status);
int l = status.Get_count(MPI::CHAR);
char *buf = new char[l];
const auto sender = status.Get_source();
const auto tag = status.Get_tag();
//MPI::Comm::Recv(void* buf, int count, MPI::Datatype& datatype, int source, int tag, MPI::Status* status)
MPI::COMM_WORLD.Recv(buf, l, MPI::CHAR, sender, tag, status);
string fname(buf, l);
delete [] buf;
vector<string> fnames;
boost::split(fnames, fname, boost::is_any_of(";"));
for(int k=0;k<fnames.size();k++){
if(fnames[k].length())
que.push(fnames[k]);
}
i--;
}
}
vector<int> processes_with_files; //Vector to store only the files with ranks
set<string> queue_values;
vector<string> vec_queue_values;
/************* IF QUEUE EMPTY, PROCEED TO QUERY PROCESSING ***********************/
/************* =========================================== ***********************/
if(que.empty()){
//Message asking children to send their file availability
string send_rank_message="SEND IF YOU HAVE";
//Send message to children to send if they have files with them
for(int rank_values=1;rank_values<no_of_process;rank_values++){
//MPI::Comm::Send(const void* buf, int count, MPI::Datatype& datatype, int dest, int tag)
MPI::COMM_WORLD.Send(send_rank_message.c_str(), send_rank_message.length(), MPI::CHAR, rank_values, rank_values);
}
//Values for reception
int rank_received[no_of_process];
rank_received[0]=0; //Parent process - So excluding it.
for(int rank_values=1;rank_values<no_of_process;rank_values++){
//For probe status store
MPI::Status status;
//Probe for incoming values
MPI::COMM_WORLD.Probe(MPI::ANY_SOURCE, MPI::ANY_TAG, status);
//Get source and tag
const auto sender = status.Get_source();
const auto tag = status.Get_tag();
//MPI::Comm::Recv(void* buf, int count, MPI::Datatype& datatype, int source, int tag, MPI::Status* status)
MPI::COMM_WORLD.Recv(&rank_received[sender], 1, MPI::INT, sender, tag, status);
}
//String for rank values to be sent to all the child processes
string processes_with_files_str="";
//Storing the rank of processes that have files
for(int i=1;i<no_of_process;i++){
if(rank_received[i]==1){
processes_with_files_str+= to_string(i) + ";";
processes_with_files.push_back(i);
}
}
string process_list_message = "ABOUT TO SEND PROCESS VALUES";
for(int i=0;i<processes_with_files.size();i++){
//MPI::Comm::Send(const void* buf, int count, MPI::Datatype& datatype, int dest, int tag)
MPI::COMM_WORLD.Send(process_list_message.c_str(), process_list_message.length(), MPI::CHAR, processes_with_files[i], processes_with_files[i]);
MPI::COMM_WORLD.Send(processes_with_files_str.c_str(), processes_with_files_str.length(), MPI::CHAR, processes_with_files[i], processes_with_files[i]);
// cout<<"\n\n Parent has sent the value!\n";
}
}//End of queue empty condition
int val_recv;
//Expecting reply from all child processes
for(int i=0;i<processes_with_files.size();i++){
MPI::Status status;
//Probe for incoming values
MPI::COMM_WORLD.Probe(MPI::ANY_SOURCE, MPI::ANY_TAG, status);
//Get source and tag
auto sender = status.Get_source();
auto tag = status.Get_tag();
//MPI::Comm::Recv(void* buf, int count, MPI::Datatype& datatype, int source, int tag, MPI::Status* status)
MPI::COMM_WORLD.Recv(&val_recv, 1, MPI::INT, sender, tag, status);
}
while(1){
int choice;
string task_message;
char whatfile[400];
cout<<"\n\n Graph Processed. What do you want to do now? \n 1. Find all the files related to another file\n 2. Find the Transitive Closure of a file\n 3. Exit\n 4. Choice : ";
cin>>choice;
cin.ignore (std::numeric_limits<std::streamsize>::max(), '\n');
switch(choice) {
case 1: cout<<"\n Enter the file name : ";
cin.getline(whatfile,400);
task_message=string(whatfile,strlen(whatfile))+";Related Files";
cout<<"\n"<<task_message;
break;
case 2: cout<<"\n Enter the file name you wish to find the transitive closure for : ";
cin.getline(whatfile,400);
task_message=string(whatfile,strlen(whatfile))+";Transitive Closure;Just Tell";
queue_values.insert(whatfile);
vec_queue_values.push_back(whatfile);
break;
case 3: task_message="EXIT NOW";
default:;
}
for(int rank_values=1;rank_values<no_of_process;rank_values++){
//MPI::Comm::Send(const void* buf, int count, MPI::Datatype& datatype, int dest, int tag)
MPI::COMM_WORLD.Send(task_message.c_str(), task_message.length(), MPI::CHAR, rank_values, rank_values);
}
if(choice==3){
cout<<"\n PARENT : QUITTING. BYE!";
break;
}
else if (choice==2){
int send_flag=1;
while(send_flag) {
send_flag=0;
char* char_value=NULL;
int char_length;
// cout<<"\n\n ********************************** Value Sent for Transitive closure!";
for(int i=0;i<vec_queue_values.size();i++){
MPI::Status status;
//Probe for incoming values
MPI::COMM_WORLD.Probe(MPI::ANY_SOURCE, MPI::ANY_TAG, status);
//Get source and tag
char_length = status.Get_count(MPI::CHAR);
char_value = new char[char_length];
auto sender = status.Get_source();
auto tag = status.Get_tag();
//MPI::Comm::Recv(void* buf, int count, MPI::Datatype& datatype, int source, int tag, MPI::Status* status)
// cout<<"\n\n Parent waiting to receive!\n\n ";
MPI::COMM_WORLD.Recv(char_value, char_length, MPI::CHAR, sender, tag, status);
}
string recd_string(char_value,char_length);
delete [] char_value;
vector<string> recd_file_vector;
string send_string_val="";
//Clear the vector queue value
vec_queue_values.clear();
boost::split(recd_file_vector, recd_string, boost::is_any_of(";"));
for(int i=0;i<recd_file_vector.size();i++){
if(recd_file_vector[i].length()){
if(queue_values.find(recd_file_vector[i])==queue_values.end()){
send_flag=1;
queue_values.insert(recd_file_vector[i]);
vec_queue_values.push_back(recd_file_vector[i]);
send_string_val += recd_file_vector[i] + ";";
}
}
}
send_string_val += "Transitive Closure;Find One";
if(send_flag){
for(int rank_values=1;rank_values<no_of_process;rank_values++){
// cout<<"\n\n Sending value to "<<rank_values;
MPI::COMM_WORLD.Send(send_string_val.c_str(), send_string_val.length(), MPI::CHAR, rank_values, rank_values);
}
}
else{
cout<<"\n\n Connected File Names : \n";
queue_values.erase(whatfile);
for(auto x: queue_values){
cout<<x<<"\n";
}
queue_values.clear();
vec_queue_values.clear();
}
}
}
else{
MPI::Status status;
//Probe for incoming values
MPI::COMM_WORLD.Probe(MPI::ANY_SOURCE, MPI::ANY_TAG, status);
//Get source and tag
auto sender = status.Get_source();
auto tag = status.Get_tag();
//MPI::Comm::Recv(void* buf, int count, MPI::Datatype& datatype, int source, int tag, MPI::Status* status)
// cout<<"\n\n Parent waiting to receive!\n\n ";
MPI::COMM_WORLD.Recv(&val_recv, 1, MPI::INT, sender, tag, status);
// cout<<"\n Parent received!";
}
} // End of While Loop
} //END OF PROCESS 0
int main(int argc, char * argv[]){
int tag, send_tag;//tag in MPI_Recv
int to,from;//destination and source of MPI send/receive
int st_count, st_source, st_tag;
double start_time = 0.0;//set start and end time for MPI_Wtime()
double end_time = 0.0;
MPI::Status status;
MPI::Init(argc, argv);//start MPI
int rank = MPI::COMM_WORLD.Get_rank();//The rank label of the machines
int size = MPI::COMM_WORLD.Get_size();//The number of tasks to be done
// MPI_Barrier(MPI_COMM_WORLD);
int option;
opterr = 0;
int N = 0;
string directory;
while ((option = getopt(argc, argv, "d:n:"))!= -1)//getopt parses the parameters of commands, -n is the first n words that occur most frequently in files, -d is the directory which contains the files that need to be parsed.
{
switch (option)
{
case 'n':
N = atoi(optarg);//the first N words
break;
case 'd':
directory = string(optarg);// parameter of the directory
// cout << dir <<endl;
break;
case '?'://when the parameter of option n is wrong, show the error information
if (optopt == 'n')
cerr<< "Option -"<<char(optopt)<<" requires an argument." <<endl;
else if (isprint (optopt))
cerr<< "Unknown option `-"<<char(optopt)<<"'.\n"<<endl;
else
cerr<< "Unknown option character `"<<std::hex<<optopt<<"'."<<endl;
}
}
vector<string> filenames;//use this vector to store file names
char buffer[1024];
if(rank == 0)//Machine 0 parses the name of directory and files in the directory.
{
struct dirent *ptr;
DIR *dir;
dir = opendir(directory.c_str());//open the directory
while((ptr = readdir(dir))!=NULL)//read the name of the directory
{
if(ptr->d_name[0]=='.')
continue;
strcpy(buffer,directory.c_str());
strcat(buffer,ptr->d_name);
// cout<<buffer<<endl;
filenames.push_back(string(buffer));//put the file names of the directory in the vector filenames
};
}
if(rank == 0)//machine 0 send messages and assign tasks to all the machines, including itself.
{
start_time = MPI_Wtime();//star time stamp
to = 0;
send_tag = 0;
int round = 0;
while(round * size < filenames.size())
{
for(int i = round * size; i < (round + 1) * size && i < filenames.size(); i++)
{
sprintf(buffer, "%s", filenames[i].c_str());
// cout << rank << ":"<< "sending " << buffer << endl;
MPI::COMM_WORLD.Send(buffer,1024, MPI::CHAR, i%size, send_tag);//send filenames to the other machines and let them parse the files, including itself.
to++;
send_tag++;
}
tag = MPI::ANY_TAG;
from = MPI::ANY_SOURCE;
MPI::COMM_WORLD.Recv(buffer, 1024, MPI::CHAR, from, tag, status);//rank 0 receive parsing result from the rest machines, including itself
st_count = status.Get_count(MPI::CHAR);
st_source = status.Get_source();
st_tag = status.Get_tag();
string result("");
result = parse(buffer, N);
strcpy(buffer,result.c_str());
MPI::COMM_WORLD.Send(buffer,1024, MPI::CHAR, 0, st_tag);//rank 0 send message to itself
for(int i = round * size; i < (round + 1) * size && i < filenames.size(); i++)
{
tag = MPI::ANY_TAG;
from = MPI::ANY_SOURCE;
MPI::COMM_WORLD.Recv(buffer, 1024, MPI::CHAR, from, tag, status);
st_count = status.Get_count(MPI::CHAR);
st_source = status.Get_source();
st_tag = status.Get_tag();
// cout << rank <<":" << "received from "<<st_source<<endl<< buffer << endl;
cout << buffer << endl;
}
round++;
}
for (int i = 1; i < size; ++i)
{
strcpy(buffer, "Finish");
MPI::COMM_WORLD.Send(buffer,1024, MPI::CHAR, i, 0);//rank 0 send Finish information to the other machines
}
end_time = MPI_Wtime();
printf("The running time is : %lf \n",end_time-start_time);
}
else
{
while(1)
{
tag = MPI::ANY_TAG;
from = MPI::ANY_SOURCE;
MPI::COMM_WORLD.Recv(buffer, 1024, MPI::CHAR, from, tag, status);//receive end information from rank 0
st_count = status.Get_count(MPI::CHAR);
st_source = status.Get_source();
st_tag = status.Get_tag();
// cout<<" rank " << rank <<": " << "st_count:"<<st_count<<" st_source"<< st_source << " st_tag "<< st_tag << endl;
// cout<<" " << buffer <<endl;
if (strcmp(buffer, "Finish") == 0)//if the machine receives the finish information, stop receive and send
break;
string result("");
result = parse(buffer, N);//parse the file received from rank 0
strcpy(buffer,result.c_str());
MPI::COMM_WORLD.Send(buffer,1024, MPI::CHAR, 0, st_tag);//send information back to rank 0
}
}
// cout << "rank " << rank <<": "<<"I am dying, goodbye!"<<endl;
// MPI_Barrier(MPI_COMM_WORLD);
MPI::Finalize();//MPI finalize
return 0;
}
int main ( int argc, char *argv[] )
//****************************************************************************80
//
// Purpose:
//
// MAIN is the main program for SEARCH.
//
// Discussion:
//
// SEARCH demonstrates the use of MPI routines to carry out a search
//
// An array of given size is to be searched for occurrences of a
// specific value.
//
// The search is done in parallel. A master process generates the
// array and the target value, then distributes the information among
// a set of worker processes, and waits for them to communicate back
// the (global) index values at which occurrences of the target value
// were found.
//
// An interesting feature of this program is the use of allocatable
// arrays, which allows the master program to set aside just enough
// memory for the whole array, and for each worker program to set aside
// just enough memory for its own part of the array.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 01 September 2009
//
// Author:
//
// John Burkardt
//
// Reference:
//
// William Gropp, Ewing Lusk, Anthony Skjellum,
// Using MPI: Portable Parallel Programming with the
// Message-Passing Interface,
// Second Edition,
// MIT Press, 1999,
// ISBN: 0262571323.
//
{
int *a;
int dest;
float factor;
int global;
int i;
int id;
int ierr;
int n;
int npart;
int p;
int source;
int start;
MPI::Status status;
int tag;
int tag_target = 1;
int tag_size = 2;
int tag_data = 3;
int tag_found = 4;
int tag_done = 5;
int target;
int workers_done;
int x;
//
// Initialize MPI.
//
MPI::Init ( argc, argv );
//
// Get this processes's rank.
//
id = MPI::COMM_WORLD.Get_rank ( );
//
// Find out how many processes are available.
//
p = MPI::COMM_WORLD.Get_size ( );
if ( id == 0 )
{
timestamp ( );
cout << "\n";
cout << "SEARCH - Master process:\n";
cout << " C++ version\n";
cout << " An example MPI program to search an array.\n";
cout << "\n";
cout << " Compiled on " << __DATE__ << " at " << __TIME__ << ".\n";
cout << "\n";
cout << " The number of processes is " << p << "\n";
}
cout << "\n";
cout << "Process " << id << " is active.\n";
//
// Have the master process generate the target and data. In a more
// realistic application, the data might be in a file which the master
// process would read. Here, the master process decides.
//
if ( id == 0 )
{
//
// Pick the number of data items per process, and set the total.
//
factor = ( float ) rand ( ) / ( float ) RAND_MAX;
npart = 50 + ( int ) ( factor * 100.0E+00 );
n = npart * p;
cout << "\n";
cout << "SEARCH - Master process:\n";
cout << " The number of data items per process is " << npart << "\n";
cout << " The total number of data items is " << n << ".\n";
//
// Now allocate the master copy of A, fill it with values, and pick
// a value for the target.
//
a = new int[n];
factor = ( float ) n / 10.0E+00 ;
for ( i = 0; i < n; i++ )
{
a[i] = ( int ) ( factor * ( float ) rand ( ) / ( float ) RAND_MAX );
}
target = a[n/2];
cout << " The target value is " << target << ".\n";
//
// The worker processes need to have the target value, the number of data items,
// and their individual chunk of the data vector.
//
for ( i = 1; i <= p-1; i++ )
{
dest = i;
tag = tag_target;
MPI::COMM_WORLD.Send ( &target, 1, MPI::INT, dest, tag );
tag = tag_size;
MPI::COMM_WORLD.Send ( &npart, 1, MPI::INT, dest, tag );
start = ( i - 1 ) * npart;
tag = tag_data;
MPI::COMM_WORLD.Send ( a+start, npart, MPI::INT, dest, tag );
}
//
// Now the master process simply waits for each worker process to report that
// it is done.
//
workers_done = 0;
while ( workers_done < p-1 )
{
MPI::COMM_WORLD.Recv ( &x, 1, MPI::INT, MPI::ANY_SOURCE, MPI::ANY_TAG, status );
source = status.Get_source ( );
tag = status.Get_tag ( );
if ( tag == tag_done )
{
workers_done = workers_done + 1;
}
else if ( tag == tag_found )
{
cout << "P" << source << " " << x << " " << a[x] << "\n";
}
else
{
cout << " Master process received message with unknown tag = "
<< tag << ".\n";
}
}
//
// The master process can throw away A now.
//
delete [] a;
}
//
// Each worker process expects to receive the target value, the number of data
// items, and the data vector.
//
else
{
source = 0;
tag = tag_target;
MPI::COMM_WORLD.Recv ( &target, 1, MPI::INT, source, tag, status );
source = 0;
tag = tag_size;
MPI::COMM_WORLD.Recv ( &npart, 1, MPI::INT, source, tag, status );
a = new int[npart];
source = 0;
tag = tag_data;
MPI::COMM_WORLD.Recv ( a, npart, MPI::INT, source, tag, status );
//
// The worker simply checks each entry to see if it is equal to the target
// value.
//
for ( i = 0; i < npart; i++ )
{
if ( a[i] == target )
{
global = ( id - 1 ) * npart + i;
dest = 0;
tag = tag_found;
MPI::COMM_WORLD.Send ( &global, 1, MPI::INT, dest, tag );
}
}
//
// When the worker is finished with the loop, it sends a dummy data value with
// the tag "TAG_DONE" indicating that it is done.
//
dest = 0;
tag = tag_done;
MPI::COMM_WORLD.Send ( &target, 1, MPI::INT, dest, tag );
delete [] ( a );
}
//
// Terminate MPI.
//
MPI::Finalize ( );
//
// Terminate.
//
if ( id == 0 )
{
cout << "\n";
cout << "SEARCH - Master process:\n";
cout << " Normal end of execution.\n";
cout << "\n";
timestamp ( );
}
return 0;
}
template<class T_GRID> int FLOOD_FILL_MPI<T_GRID>::
Synchronize_Colors()
{
if(mpi_grid.threaded_grid) return Synchronize_Colors_Threaded();
ARRAY<RANGE<typename T_PARALLEL_GRID::VECTOR_INT> > boundary_regions;
mpi_grid.Find_Boundary_Regions(boundary_regions,RANGE<typename T_PARALLEL_GRID::VECTOR_INT>::Zero_Box(),false,RANGE<VECTOR<int,1> >(-1,0),false,true,local_grid);
// figure out which colors are global
int global_color_count=0;
ARRAY<int,VECTOR<int,1> > color_map(-1,number_of_regions);color_map(-1)=-1;color_map(0)=0;
{ARRAY<bool,VECTOR<int,1> > color_is_global(-1,number_of_regions);
Find_Global_Colors(color_is_global,RANGE<typename T_PARALLEL_GRID::VECTOR_INT>::Centered_Box());
for(int color=1;color<=number_of_regions;color++)if(color_is_global(color)) color_map(color)=++global_color_count;}
// send numbers of global colors to everyone
ARRAY<int> global_color_counts(mpi_grid.number_of_processes);
mpi_grid.comm->Allgather(&global_color_count,1,MPI_UTILITIES::Datatype<int>(),&global_color_counts(1),1,MPI_UTILITIES::Datatype<int>());
int total_global_colors=ARRAYS_COMPUTATIONS::Sum(global_color_counts);
int global_color_offset=ARRAYS_COMPUTATIONS::Sum(global_color_counts.Prefix(mpi_grid.rank));
LOG::cout<<"initial colors: "<<number_of_regions<<" total, "<<global_color_count<<" out of "<<total_global_colors<<" global"<<std::endl;
if(!total_global_colors){color_ranks.Clean_Memory();return 0;}
ARRAY<MPI_PACKAGE> packages;
ARRAY<T_ARRAYS_INT> colors_copy(boundary_regions.m);
// send left (front) colors
ARRAY<MPI::Request> send_requests;
for(int side=1;side<=T_PARALLEL_GRID::number_of_faces_per_cell;side+=2)if(mpi_grid.side_neighbor_ranks(side)!=MPI::PROC_NULL){
Resize_Helper(colors_copy(side),local_grid,boundary_regions(side));
Translate_Local_Colors_To_Global_Colors(color_map,colors_copy(side),boundary_regions(side),global_color_offset);
MPI_PACKAGE package=mpi_grid.Package_Cell_Data(colors_copy(side),boundary_regions(side));
packages.Append(package);
send_requests.Append(package.Isend(*mpi_grid.comm,mpi_grid.side_neighbor_ranks(side),mpi_grid.Get_Send_Tag(mpi_grid.side_neighbor_directions(side))));}
// receive right (back) colors and initialize union find
UNION_FIND<> union_find(total_global_colors);
{ARRAY<MPI::Request> recv_requests;
for(int side=2;side<=T_PARALLEL_GRID::number_of_faces_per_cell;side+=2)if(mpi_grid.side_neighbor_ranks(side)!=MPI::PROC_NULL){
Resize_Helper(colors_copy(side),local_grid,boundary_regions(side));
MPI_PACKAGE package=mpi_grid.Package_Cell_Data(colors_copy(side),boundary_regions(side));
packages.Append(package);
recv_requests.Append(package.Irecv(*mpi_grid.comm,mpi_grid.side_neighbor_ranks(side),mpi_grid.Get_Recv_Tag(mpi_grid.side_neighbor_directions(side))));}
MPI::Status status;
while(MPI_UTILITIES::Wait_Any(recv_requests,status)){
int side;for(side=2;side<=T_PARALLEL_GRID::number_of_faces_per_cell;side+=2)if(mpi_grid.Get_Recv_Tag(mpi_grid.side_neighbor_directions(side))==status.Get_tag()) break;
Find_Color_Matches(color_map,union_find,colors_copy(side),boundary_regions(side),global_color_offset);}}
// synchronize union find
UNION_FIND<> final_union_find;
{ARRAY<char> union_find_buffer(MPI_UTILITIES::Pack_Size(union_find,*mpi_grid.comm)+1);
{int position=0;MPI_UTILITIES::Pack(union_find,union_find_buffer,position,*mpi_grid.comm);}
MPI::Datatype union_find_type=MPI::PACKED.Create_contiguous(union_find_buffer.m);union_find_type.Commit();
MPI::Op union_find_merge_op;union_find_merge_op.Init(Union_Find_Merge_Op,true);
ARRAY<char> final_union_find_buffer(union_find_buffer.m);
union_find_merge_op_comm=mpi_grid.comm;
mpi_grid.comm->Allreduce(union_find_buffer.Get_Array_Pointer(),final_union_find_buffer.Get_Array_Pointer(),1,union_find_type,union_find_merge_op);
{int position=0;MPI_UTILITIES::Unpack(final_union_find,final_union_find_buffer,position,*mpi_grid.comm);}
union_find_type.Free();union_find_merge_op.Free();}
// fix color map for global colors
number_of_regions=0;
ARRAY<int> global_to_final_color_map(total_global_colors);
for(int i=1;i<=total_global_colors;i++){
int root=final_union_find.Find(i);
if(!global_to_final_color_map(root)) global_to_final_color_map(root)=++number_of_regions;
global_to_final_color_map(i)=global_to_final_color_map(root);}
for(int i=1;i<=color_map.domain.max_corner.x;i++)if(color_map(i)>0) color_map(i)=global_to_final_color_map(color_map(i)+global_color_offset);
// find list of processes corresponding to each color
int end=0;
color_ranks.Clean_Memory();
color_ranks.Resize(number_of_regions);
for(int r=0;r<mpi_grid.number_of_processes;r++){
int start=end+1;end+=global_color_counts(r+1);
for(int i=start;i<=end;i++)color_ranks(global_to_final_color_map(i)).Append_Unique(r);}
for(int color=1;color<=color_ranks.m;color++) assert(color_ranks(color).m>1 || mpi_grid.side_neighbor_ranks.Contains(mpi_grid.rank));
// remap colors
Remap_Colors(color_map,RANGE<typename T_PARALLEL_GRID::VECTOR_INT>::Centered_Box());
LOG::cout<<"final colors: "<<color_ranks.m<<" global, "<<number_of_regions-color_ranks.m<<" local"<<std::endl;
// remap color_touches_uncolorable
if(color_touches_uncolorable){
ARRAY<bool> new_color_touches_uncolorable(number_of_regions);
for(int i=1;i<=color_touches_uncolorable->m;i++)if(color_map(i)>0) new_color_touches_uncolorable(color_map(i))|=(*color_touches_uncolorable)(i);
color_touches_uncolorable->Exchange(new_color_touches_uncolorable);
// synchronize color_touches_uncolorable, TODO: this could be merged with above communication
ARRAY<bool> global_color_touches_uncolorable(color_ranks.m);
ARRAY<bool>::Get(global_color_touches_uncolorable,*color_touches_uncolorable);
mpi_grid.comm->Allreduce(&global_color_touches_uncolorable(1),&(*color_touches_uncolorable)(1),color_ranks.m,MPI_UTILITIES::Datatype<bool>(),MPI::LOR);}
// finish
MPI_UTILITIES::Wait_All(send_requests);
MPI_PACKAGE::Free_All(packages);
return color_ranks.m;
}