void Module_DCREATE::receive_from_master() const {
size_t length;
MPI::Status status;
int k;
int blockLength;
MPI::COMM_WORLD.Recv(&k,1,MPI::INT,0,COMMUNICATION_CHANNEL);
MPI::COMM_WORLD.Recv(&blockLength,1,MPI::INT,0,COMMUNICATION_CHANNEL);
MPI::COMM_WORLD.Probe(0,COMMUNICATION_CHANNEL,status);
length = status.Get_count(MPI::CHAR);
char input[length];
MPI::COMM_WORLD.Recv(input,length,MPI::CHAR,0,COMMUNICATION_CHANNEL);
MPI::COMM_WORLD.Probe(0,COMMUNICATION_CHANNEL,status);
length = status.Get_count(MPI::CHAR);
char output[length];
MPI::COMM_WORLD.Recv(output,length,MPI::CHAR,0,COMMUNICATION_CHANNEL);
DEFAULT_CHANNEL << "Informations from master received by node " << my_rank << endl;
if (strlen(input) != 0 and strlen(output) != 0)
compute_hash(k,blockLength,input,output,false); //TODO handle methyl_hash
}
void HPC::MPICommunication::waitReception(Request::Handle ioRequest) const
{
Beagle_StackTraceBeginM();
Beagle_NonNullPointerAssertM(ioRequest);
MPI::Status lStatus;
ioRequest->mSizeRequest.Wait(lStatus);
if(lStatus.Is_cancelled()) return;
int lRank = lStatus.Get_source();
int lMsgSize = ioRequest->mSize;
std::string lStringTag = ioRequest->mTag + "_str";
MPI::COMM_WORLD.Probe(lRank,hashTag(lStringTag),lStatus);
Beagle_AssertM(lStatus.Get_count(MPI::CHAR) == lMsgSize);
//constructing a string of the right size.
std::string lMsg(lMsgSize, ' ');
MPI::COMM_WORLD.Recv(&lMsg[0], lMsgSize, MPI::CHAR, lRank, hashTag(lStringTag));
#ifdef BEAGLE_HAVE_LIBZ
if(mCompressionLevel->getWrappedValue() > 0){
ioRequest->mMessage = new Beagle::String;
decompressString(lMsg, ioRequest->mMessage->getWrappedValue());
} else {
ioRequest->mMessage = new Beagle::String(lMsg);
}
#else
ioRequest->mMessage = new Beagle::String(lMsg);
#endif
Beagle_HPC_StackTraceEndM("void HPC::MPICommunication::waitReception(Request::Handle) const");
}
bool recvData(std::vector<double>& receivedData)
{
bool isDataReceived = false;
if ( intraComm != MPI::COMM_NULL)
{
MPI::Status status;
double buffer[100];
intraComm.Recv(buffer, 100,
MPI::DOUBLE,
MPI::ANY_SOURCE,
/*tag*/ 100,
status);
int count = status.Get_count(MPI::DOUBLE);
receivedData = std::vector<double>(buffer, buffer+count);
log.Info() << "RECV [ " << getRank()
<< " <-- "
<< status.Get_source()
<< " ] data : "
<< receivedData
<< std::endl;
isDataReceived = true;
}else
{
log.Err() << "PID " << getProcessId()
<< " failed to RECV"
<< std::endl;
}
return isDataReceived;
}
//#####################################################################
// Function Recv_Columns
//#####################################################################
template<class T_GRID> template<class T_ARRAYS_HORIZONTAL_COLUMN> void MPI_RLE_GRID<T_GRID>::
Recv_Columns(T_ARRAYS_HORIZONTAL_COLUMN& columns,const ARRAY<T_BOX_HORIZONTAL_INT>& regions,const int tag,const MPI::Status& probe_status) const
{
ARRAY<char> buffer(probe_status.Get_count(MPI::PACKED));
int position=0;
comm->Recv(&buffer(1),buffer.m,MPI::PACKED,probe_status.Get_source(),tag);
TV_HORIZONTAL_INT direction;
MPI_UTILITIES::Unpack(direction,buffer,position,*comm);
int neighbor=0;
all_neighbor_directions.Find(-direction,neighbor);
for(typename T_HORIZONTAL_GRID::CELL_ITERATOR iterator(local_grid.horizontal_grid,regions(neighbor)); iterator.Valid(); iterator.Next())
MPI_UTILITIES::Unpack(columns(iterator.Cell_Index()),buffer,position,*comm);
}
bool Neatzsche_MPI::readPopulation(Phenotypes * p, Coevolution * c, TransferFunctions * tfs)
{
MPI::Status status;
MPI::Datatype ndt,gdt;
int genomes,genes,nodes,id;
MPI::COMM_WORLD.Recv(&genomes,1,MPI::INT,0,0);//Receive the number of genome
NeuralNodeSmall * nns;
GeneSmall * gs;
Genome * genome = NULL;
int stringc=0;
char *strbuf;
vector<string> * ftypes = NULL;
for(int i=0;i<genomes;i++){
ftypes = new vector<string>();
MPI::COMM_WORLD.Recv(&id,1,MPI_INT,0,0);
MPI::COMM_WORLD.Recv(&nodes,1,MPI_INT,0,0);
MPI::COMM_WORLD.Recv(&genes,1,MPI_INT,0,0);
// nns = (NeuralNodeSmall*)malloc(sizeof(NeuralNodeSmall)*nodes);
// gs = (GeneSmall*)malloc(sizeof(GeneSmall)*genes);
nns = new NeuralNodeSmall [nodes];
gs = new GeneSmall[genes];
nodetype = Build_neuralnode_type(&nns[0]);
MPI::COMM_WORLD.Recv(nns,nodes,nodetype,0,0);
for(int i=0;i<nodes;i++){//blargh, 1 int would be more usefull in this case:P
MPI::COMM_WORLD.Probe(0, MPI_Cont, status);
stringc = status.Get_count(MPI_CHAR);
strbuf = (char*) malloc(sizeof(char)*stringc);
MPI::COMM_WORLD.Recv(strbuf,stringc,MPI::CHAR,0,0);//receive the ftype of the node
ftypes->push_back(string(strbuf).substr(0,stringc));
free(strbuf);
}
genetype = Build_gene_type(&gs[0]);
MPI::COMM_WORLD.Recv(gs,genes,genetype,0,0);
genome = new Genome(tfs);
genome->fromSmall(id,nodes,nns,genes,gs,ftypes);
delete ftypes;
p->push_back(new Phenotype(genome));
if(nodes>0)
delete[] nns;
if(genes>0)
delete[] gs;
}
unsigned int cont;
MPI::COMM_WORLD.Recv(&cont,1,MPI::INT,0,0);//continue or stop?
return cont == MPI_Cont;
}
int HPC::MPICommunication::waitAny(Request::Bag& ioRequests) const
{
Beagle_StackTraceBeginM();
unsigned int lSize = ioRequests.size();
std::vector<MPI::Request> lRequests;
lRequests.reserve(lSize);
for(unsigned int i = 0; i < lSize; ++i){
lRequests.push_back(ioRequests[i]->mSizeRequest);
}
MPI::Status lStatus;
int lIndex = MPI::Request::Waitany(lSize, &lRequests[0], lStatus);
ioRequests[lIndex]->mSizeRequest = lRequests[lIndex];
if(lStatus.Is_cancelled()) return -1;
if(ioRequests[lIndex]->mType == Request::RECEPTION){
int lRank = lStatus.Get_source();
std::string lStringTag = ioRequests[lIndex]->mTag + "_str";
int lMsgSize = ioRequests[lIndex]->mSize;
MPI::COMM_WORLD.Probe(lRank,hashTag(lStringTag),lStatus);
Beagle_AssertM(lStatus.Get_count(MPI::CHAR) == lMsgSize);
//constructing a string of the right size.
std::string lMsg(lMsgSize,' ');
MPI::COMM_WORLD.Recv(&lMsg[0], lMsgSize, MPI::CHAR, lRank, hashTag(lStringTag));
#ifdef BEAGLE_HAVE_LIBZ
if(mCompressionLevel->getWrappedValue() > 0){
ioRequests[lIndex]->mMessage = new Beagle::String;
decompressString(lMsg, ioRequests[lIndex]->mMessage->getWrappedValue());
} else {
ioRequests[lIndex]->mMessage = new Beagle::String(lMsg);
}
#else
ioRequests[lIndex]->mMessage = new Beagle::String(lMsg);
#endif
} else if(ioRequests[lIndex]->mType == Request::SENDING){
ioRequests[lIndex]->mMsgRequest.Wait();
} else {
throw RunTimeException("MPI::Communication::waitAll(Request&) the request"+uint2str(lIndex)+
" is invalid",__FILE__,__LINE__);
}
return lIndex;
Beagle_HPC_StackTraceEndM("int HPC::MPICommunication::waitAny(Request::Bag&) const");
}
/*!
* \brief Receive message from a specific node rank via MPI
* \param outMessage Message receive.
* \param inTag Tag associated to the message to be received.
* \param inRank Node rank of the sending node.
*/
void HPC::MPICommunication::receive(std::string& outMessage, const std::string& inTag, int inRank) const
{
Beagle_StackTraceBeginM();
MPI::Status lStatus;
int lSize = 0;
MPI::COMM_WORLD.Recv(&lSize, 1, MPI::INT, inRank, hashTag(inTag+"_size"));
MPI::COMM_WORLD.Probe(inRank,hashTag(inTag+"_str"),lStatus);
Beagle_AssertM(lStatus.Get_count(MPI::CHAR) == lSize);
outMessage.resize(lSize);
MPI::COMM_WORLD.Recv(&outMessage[0], lSize, MPI::CHAR, lStatus.Get_source(), hashTag(inTag+"_str"));
#ifdef BEAGLE_HAVE_LIBZ
if(mCompressionLevel->getWrappedValue() > 0){
std::string lString;
decompressString(outMessage, lString);
outMessage = lString;
}
#endif
Beagle_HPC_StackTraceEndM("void HPC::MPICommunication::receive(std::string&, const std::string&, int) const");
}
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;
}
Module_DMAP::Transmitting_Result Module_DMAP::recv_output(int node, int id) {
int count;
unsigned long int * positions;
unsigned long int * global_positions;
int * contigs;
//t_alignment * types;
int * NMs;
int * lengths;
int * algn;
unsigned short int * bools;
unsigned int * trim_info;
char * informations;
unsigned short int bool_temp;
Mask * reads;
{
mutex::scoped_lock lock(mpi_mutex);
//DEFAULT_CHANNEL << '[' << my_rank << ',' << id << "] Waiting info from node " << node << " to node " << my_rank << endl;
if (finished)
return Transmitting_Result(NULL,0);
MPI::COMM_WORLD.Recv(&count,1,MPI::INT,my_rank-1,COMMUNICATION_CHANNEL);
//DEFAULT_CHANNEL << '[' << my_rank << ',' << id << "] Receive " << count << " OUTPUTs from node " << node << " to node " << my_rank << endl;
if (count == 0) {
finished = true;
return Transmitting_Result(NULL,0);
}
positions = new unsigned long int[count*2];
global_positions = new unsigned long int[count*2];
contigs = new int[count];
//types = new t_alignment[count];
NMs = new int[count*2];
lengths = new int[count*2];
algn = new int[count];
bools = new unsigned short int[count];
trim_info = new unsigned int[count*2];
size_t sum;
MPI::Status status;
MPI::COMM_WORLD.Probe(node,DATA_CHANNEL,status);
sum = status.Get_count(MPI::CHAR);
informations = new char[sum];
MPI::COMM_WORLD.Recv(informations,sum,MPI::CHAR,node,DATA_CHANNEL);
MPI::COMM_WORLD.Recv(positions,count*2,MPI::UNSIGNED_LONG,node,DATA_CHANNEL);
MPI::COMM_WORLD.Recv(global_positions,count*2,MPI::UNSIGNED_LONG,node,DATA_CHANNEL);
MPI::COMM_WORLD.Recv(contigs,count,MPI::INT,node,DATA_CHANNEL);
//MPI::COMM_WORLD.Recv(types,count*sizeof(t_alignment),MPI::CHAR,node,DATA_CHANNEL);
MPI::COMM_WORLD.Recv(NMs,count*2,MPI::INT,node,DATA_CHANNEL);
MPI::COMM_WORLD.Recv(lengths,count*2,MPI::INT,node,DATA_CHANNEL);
MPI::COMM_WORLD.Recv(algn,count,MPI::INT,node,DATA_CHANNEL);
MPI::COMM_WORLD.Recv(bools,count,MPI::UNSIGNED_SHORT,node,DATA_CHANNEL);
MPI::COMM_WORLD.Recv(trim_info,count*2,MPI::UNSIGNED,node,DATA_CHANNEL);
}
reads = new Mask[count];
char * h = informations;
for (int i = 0; i < count; i++) {
Mask & r = reads[i];
r.id = string(h);
h += r.id.size() + 1;
r.sequence = string(h);
h += r.sequence.size() + 1;
r.quality = string(h);
h += r.sequence.size() + 1;
r.position = positions[i*2];
r.position_gap = positions[i*2+1];
r.globalPosition = global_positions[i*2];
r.globalPosition_gap = global_positions[i*2+1];
r.contig = contigs[i];
r.length1_gap = lengths[i*2];
r.length2_gap = lengths[i*2+1];
//r.type = types[i];
r.NM = NMs[i*2];
r.NM_gap = NMs[i*2+1];
r.algn = algn[i];
r.good_region_start = trim_info[i*2];
r.good_region_stop = trim_info[i*2+1];
bool_temp = bools[i];
r.strand = bool_temp & 0x01;
r.masked = bool_temp & 0x02;
r.low_quality = bool_temp & 0x04;
r.trimmed = bool_temp & 0x08;
r.discarded = bool_temp & 0x10;
r.low_complexity = bool_temp & 0x20;
r.contaminated = bool_temp & 0x40;
r.gapped = bool_temp & 0x80;
}
delete [] positions;
delete [] contigs;
//delete [] types;
delete [] NMs;
delete [] algn;
delete [] bools;
delete [] trim_info;
delete [] lengths;
delete [] global_positions;
delete [] informations;
//DEFAULT_CHANNEL << '[' << my_rank << ',' << id << "] Received " << count << " OUTPUTs from node " << node << " to node " << my_rank << endl;
return Transmitting_Result(reads,count);
}
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 DAY1.
//
// Discussion:
//
// DAY1 is exercise 3 for first day of the MPI workshop
//
// The instructions say:
//
// Process 1 computes the squares of the first 200 integers.
// It sends this data to process 3.
//
// Process 3 should divide the integers between 20 and 119 by 53,
// getting a real result, and passes this data back to process 1.
//
// * I presume the first 200 integers are the numbers 0 through 199.
//
// * The instructions literally mean that process 3 should look
// at integers whose VALUES are between 20 and 119. I doubt that
// is what the instructor meant, but it's more interesting than
// simply picking the entries with index between 20 and 119,
// so that's what I'll do.
//
// * It is also not completely clear whether only the selected data
// should be sent back, or the entire array. Again, it is more
// interesting to send back only part of the data.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// 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.
//
// Modified:
//
// 26 October 2011
//
// Author:
//
// John Burkardt
//
{
# define I_DIM 200
# define R_DIM 200
int count;
int count2;
int dest;
int i;
int i_buffer[I_DIM];
int id;
int p;
float r_buffer[R_DIM];
int source;
MPI::Status status;
int tag;
//
// Initialize MPI.
//
MPI::Init ( argc, argv );
//
// Determine this process's rank.
//
id = MPI::COMM_WORLD.Get_rank ( );
//
// Get the number of processes.
//
p = MPI::COMM_WORLD.Get_size ( );
//
// Have Process 0 say hello.
//
if ( id == 0 )
{
timestamp ( );
cout << "\n";
cout << "DAY1:\n";
cout << " C++ version\n";
cout << " An MPI example program.\n";
cout << "\n";
cout << " Compiled on " << __DATE__ << " at " << __TIME__ << "\n";
cout << "\n";
cout << " The number of processes available is " << p << "\n";
}
//
// If we don't have at least 4 processes, then bail out now.
//
if ( p < 4 )
{
cout << "\n";
cout << "DAY1 - Process " << id << ".\n";
cout << " Not enough processes for this task!\n";
cout << " Bailing out now!\n";
MPI::Finalize ( );
return 1;
}
//
// Process 1 knows that it will generate 200 integers, and may receive no more
// than 200 reals.
//
if ( id == 1 )
{
count = 200;
for ( i = 0; i < count; i++ )
{
i_buffer[i] = i * i;
}
dest = 3;
tag = 1;
MPI::COMM_WORLD.Send ( i_buffer, count, MPI::INT, dest, tag );
cout << "P:" << id << " sent " << count
<< " integers to process " << dest << ".\n";
source = 3;
tag = 2;
MPI::COMM_WORLD.Recv ( r_buffer, R_DIM, MPI::FLOAT, source, tag, status );
cout << "P:" << id << " received real values from process 3.\n";
count = status.Get_count ( MPI::FLOAT );
cout << "P:" << id << " Number of real values received is "
<< count << ".\n";
cout << "P:" << id << " First 3 values = "
<< r_buffer[0] << " "
<< r_buffer[1] << " "
<< r_buffer[2] << "\n";
}
//
// Process 3 receives the integer data from process 1, selects some of the data, does
// a real computation on it, and sends that part back to process 1.
//
else if ( id == 3 )
{
source = 1;
tag = 1;
MPI::COMM_WORLD.Recv ( i_buffer, I_DIM, MPI::INT, source, tag, status );
cout << "\n";
cout << "P:" << id << " received integer values from process 1.\n";
count = status.Get_count ( MPI::INT );
cout << "P:" << id << " - Number of integers received is "
<< count << ".\n";
cout << "P:" << id << " First 3 values = "
<< i_buffer[0] << " "
<< i_buffer[1] << " "
<< i_buffer[2] << "\n";
count2 = 0;
for ( i = 0; i < count; i++ )
{
if ( 20 <= i_buffer[i] && i_buffer[i] <= 119 )
{
r_buffer[count2] = ( float ) i_buffer[i] / 53.0E+00;
count2 = count2 + 1;
if ( count2 <= 3 )
{
cout << "P:" << id << " Input integer " << i_buffer[i]
<< " becomes " << r_buffer[count2-1] << ".\n";
}
}
}
dest = 1;
tag = 2;
MPI::COMM_WORLD.Send ( r_buffer, count2, MPI::FLOAT, dest, tag );
cout << "P:" << id << " sent " << count2 << " reals to process "
<< dest << ".\n";
}
else
{
cout << "\n";
cout << "P:" << id << " - MPI has no work for me!\n";
}
//
// Terminate MPI.
//
MPI::Finalize ( );
//
// Terminate.
//
if ( id == 0 )
{
cout << "\n";
cout << "DAY1:\n";
cout << " Normal end of execution.\n";
cout << "\n";
timestamp ( );
}
return 0;
# undef I_DIM
# undef R_DIM
}
// int reducethread(Wordtoword *allwords, int totalwordsize, map_stringtostringint &localmap, WordFrequency *allwordsfreq, int totalwordsizefreq, std::unordered_map<string,int> &frequencymap)
// {
// reduce(allwords, totalwordsize, localmap);
// reducefreq(allwordsfreq, totalwordsizefreq, frequencymap);
// if(allwords!=nullptr)delete(allwords);
// if(allwordsfreq!=nullptr)delete(allwordsfreq);
// return 0;
// }
int main(int argc, char *argv[])
{
MPI::Init(argc, argv);
/*//////Datatype for Sending words*/
MPI_Datatype MPI_Customword;
MPI_Datatype type0[1] = { MPI_CHAR };
int blocklen0[1] = { STRING_LENGTH};
MPI_Aint disp0[1];
disp0[0] = 0;
MPI_Type_create_struct(1, blocklen0, disp0, type0, &MPI_Customword);
MPI_Type_commit(&MPI_Customword);
/*//////Datatype for Sending words*/
/*//////Datatype for Sending words*/
MPI_Datatype MPI_Custom_byte;
MPI_Datatype type2[1] = { MPI_BYTE };
int blocklen2[1] = { 1000 };
MPI_Aint disp2[1];
disp2[0] = 0;
MPI_Type_create_struct(1, blocklen2, disp2, type2, &MPI_Custom_byte);
MPI_Type_commit(&MPI_Custom_byte);
/*//////Datatype for Sending words*/
/*//////Datatype for Sending word cooccurances*/
MPI_Datatype MPI_SingleWordtoWord;
MPI_Datatype type[3] = { MPI_CHAR, MPI_CHAR, MPI_INT };
int blocklen[3] = { STRING_LENGTH, STRING_LENGTH , 1 };
MPI_Aint disp[3];
disp[0] = 0;
disp[1] = STRING_LENGTH;
disp[2] = STRING_LENGTH*2;
MPI_Type_create_struct(3, blocklen, disp, type, &MPI_SingleWordtoWord);
MPI_Type_commit(&MPI_SingleWordtoWord);
/*//////Datatype for Sending word cooccurances*/
/*//////Datatype for Sending word frequencies*/
MPI_Datatype MPI_SingleWordFrequency;
MPI_Datatype type1[2] = { MPI_CHAR, MPI_INT };
int blocklen1[2] = { STRING_LENGTH, 1 };
MPI_Aint disp1[2];
disp1[0] = 0;
disp1[1] = STRING_LENGTH;
MPI_Type_create_struct(2, blocklen1, disp1, type1, &MPI_SingleWordFrequency);
MPI_Type_commit(&MPI_SingleWordFrequency);
/*//////Datatype for Sending word frequencies*/
/*//////Declarations//////*/
MPI::Status status;
int myrank = MPI::COMM_WORLD.Get_rank();
int size = MPI::COMM_WORLD.Get_size();
std::vector<string> files=getallfilenames("/work/scratch/vv52zasu/inputfiles/");
std::unordered_map<string,int> frequencymap;
std::unordered_map<string,std::unordered_map<string, int>> localmap;
std::unordered_map<string,std::unordered_map<string, int>> localsecondlevelmap;
int bufsize, *buf;
string bufchar1;
char filename[128];
/*//////Declarations//////*/
/*//////Read files in a loop and write initial data to localmap/////*/
std::clock_t fileprocessing_timestart = clock();
for(std::vector<string>::iterator it = files.begin(); it != files.end(); ++it)
{
if(myrank ==0)
std::cout<<"Processing file:"<<(*it).c_str()<<endl;
MPI::File thefile = MPI::File::Open(MPI::COMM_WORLD, (*it).c_str(), MPI::MODE_RDONLY, MPI::INFO_NULL);
MPI::Offset filesize = thefile.Get_size();
char *bufchar;
int CHUNKSIZE = (filesize/size)+1;
CHUNKSIZE = std::max(CHUNKSIZE, 10000);
bufchar = new char[CHUNKSIZE+2];
MPI_Status status1;
int i=0;
MPI_File_seek(thefile, (myrank)*CHUNKSIZE, MPI_SEEK_SET);
MPI_File_read( thefile, bufchar, CHUNKSIZE, MPI_CHAR, &status1);
int count=0;
MPI_Get_count( &status1, MPI_CHAR, &count );
string str(bufchar,bufchar+count);
MPI::COMM_WORLD.Barrier();
int occurrences = 0;
string::size_type start = 0;
int from =0, to=0,index=0;
string tosend(str);
while(1)
{
index=index+to+1;
to = tosend.find("\n\n");
if(to==string::npos) break;
tosend=tosend.substr(to+1);
}
string trimstr=str.substr(0,index-1);
str="";
MPI::COMM_WORLD.Barrier();
int length = tosend.length();
char *recvptr;
recvptr = new char[CHUNKSIZE];
int dest=0,src=0;
if(myrank==size-1)
{
dest=0;
src=myrank-1;
}
else if(myrank==0)
{
dest=1;src=size-1;
}
else
{
dest=myrank+1;src=myrank-1;
}
MPI::COMM_WORLD.Sendrecv(tosend.c_str(), length, MPI_CHAR, dest, 123, recvptr, CHUNKSIZE, MPI_CHAR, src, 123, status);
string finalstr="";
for (int i=0; i<size; i++)
{
if (i == myrank) {
string recvstr;
if(myrank !=0)
{
recvstr.assign(recvptr,recvptr+status.Get_count(MPI_CHAR));
finalstr = recvstr+trimstr;
}
else finalstr=trimstr;
}
MPI::COMM_WORLD.Barrier();
}
delete(recvptr);
str="";
trimstr="";
tosend="";
process_string(finalstr, localmap, frequencymap);
if(myrank ==0)
std::cout<<"Processing file Ended: "<<(*it).c_str()<<endl;
}
MPI::COMM_WORLD.Barrier();
if(myrank==0) cout<<" Time taken to process the files: "<< (clock()-fileprocessing_timestart)/(double) CLOCKS_PER_SEC<<"\n";
/*//////Read files in a loop and write initial data to localmap/////*/
/*////////////Sending the strings to hash%size process//////////*/
vector<vector<string>> vecgrouped(size, vector<string>(0));
for(auto &entry: localmap){
vecgrouped[std::hash<string>()(entry.first)%size].push_back(entry.first);
}
int locsize = localmap.size();
for(auto &entry: localmap)
locsize += entry.second.size();
cout << "Process: " << myrank << " Local map size: "<< localmap.size() << vecgrouped[0].size() + vecgrouped[1].size() + vecgrouped[2].size() + vecgrouped[3].size() << endl;
char* recvdata;
int sizeofint = sizeof(int);
int recvsize_me=0;
for( int i=0 ; i < size ; i++ )
{
//if ( myrank ==0 )
//cout << "Process: " << myrank << " Entered the loop. Round: "<< i << endl;
auto &tosend_twords = vecgrouped[i];
int data_size = 0;
for( auto& entry: tosend_twords )
{
data_size+=localmap[entry].size();
}
//Allocate memory
int allocsize = (tosend_twords.size() + data_size) * (STRING_LENGTH + sizeofint) + ( tosend_twords.size() * sizeofint );
char* memptr_head = new char[ allocsize ];
char* memptr = memptr_head;
//Add the data to the allocated memory
const int N = tosend_twords.size();
int torecv=0;
MPI_Reduce(&N , &recvsize_me, 1, MPI_INT, MPI_SUM, i, MPI_COMM_WORLD);
if ( myrank == i )
cout << "Process: " << myrank << " receive size: "<< recvsize_me << endl;
//memcpy( memptr , &N , sizeof(int));
//memptr += sizeofint;
for( auto &entry : tosend_twords )
{
memcpy( memptr , entry.c_str() , entry.size() + 1);
memptr += STRING_LENGTH;
int N = frequencymap[entry];
memcpy( memptr , &N , sizeof(int) );
memptr += sizeofint;
N = localmap[entry].size();
memcpy( memptr , &N , sizeof(int) );
memptr += sizeofint;
for( auto &entry_cword : localmap[entry] )
{
memcpy( memptr , entry_cword.first.c_str() , entry_cword.first.size() + 1);
memptr += STRING_LENGTH;
const int N = entry_cword.second;
memcpy( memptr , &N , sizeofint );
memptr += sizeofint;
}
}
//After copying data in the ptr, the corresponding data in localmap can be deleted
for( auto& entry: tosend_twords )
{
localmap.erase(entry);
}
tosend_twords.clear();
int *allocsizes= new int[size];
MPI_Gather(&allocsize, 1, MPI_INT, allocsizes, 1, MPI_INT, i, MPI_COMM_WORLD);
int *allocdisplacements = new int[size];
allocdisplacements[0] = 0;
for( int i=0 ; i < size ; i++ )
{
allocdisplacements[i]=allocdisplacements[i-1]+allocsizes[i-1];
}
int totalrecvsize = allocdisplacements[size-1]+ allocsizes[size-1];
if ( myrank == i )
recvdata = new char[totalrecvsize];
MPI_Gatherv(memptr_head, allocsize, MPI_CHAR, recvdata, allocsizes, allocdisplacements, MPI_CHAR , i , MPI_COMM_WORLD);
delete[](memptr_head);
if ( myrank == 0 )
cout << "Process: " << myrank << "Finished round: " << i << "\n";
}
localmap.clear();
frequencymap.clear();
//copy the received data into localmap
char *recvdata_head = recvdata;
for( int i=0 ; i < recvsize_me ; i++ )
{
char tword[STRING_LENGTH];
memcpy( tword , recvdata , STRING_LENGTH);
recvdata += STRING_LENGTH;
int frequency;
memcpy( &frequency , recvdata , sizeof(int) );
recvdata += sizeofint;
frequencymap[tword] += frequency;
int cwords_size;
memcpy( &cwords_size , recvdata , sizeof(int) );
recvdata += sizeofint;
auto &submap = localmap[tword];
for( int i=0 ; i < cwords_size ; i++ )
{
char cword[STRING_LENGTH];
memcpy( cword , recvdata , STRING_LENGTH);
recvdata += STRING_LENGTH;
int ccount;
memcpy( &ccount , recvdata , sizeofint );
recvdata += sizeofint;
submap[cword] += ccount;
}
}
delete[] recvdata_head;
cout << "Process: " << myrank << " Localmap size:" << localmap.size() << endl;
for(auto &entry: localmap)
{
auto &submap = entry.second;
for(auto it=submap.begin();it!=submap.end();)
if(it->second<5)submap.erase(it++);else it++;
}
/*//////////broadcasting rootwords and getting the entries in other processes////////*/
//----------------------------------------------------------------------------------------------------------
////broadcasting first level cooccurances and getting entries of second level coccurances from other processes
//----------------------------------------------------------------------------------------------------------
auto it=localmap.begin();
while(1)
{
std::clock_t whilestart=clock();
MPI::COMM_WORLD.Barrier();
if(myrank==0)cout<<"while start lo"<<endl;
int totalwordsize=0;
int totalwordsizefreq=0;
Wordtoword *allwords=nullptr;
WordFrequency *allwordsfreq=nullptr;
int subwordscount=0;
for(int i=0;i<size;i++)
{
subwordscount=0;
int mapsize = localmap.size();
std::clock_t start=clock();
std::set<string> uniquestrings;
if(myrank==i)
{
for( ;it!=localmap.end();it++)
{
if((it->second).size()==0)continue;
for (auto &entry : it->second)
{
if(localmap.find(entry.first)==localmap.end() && localsecondlevelmap.find(entry.first)==localsecondlevelmap.end())
uniquestrings.insert(entry.first);
}
subwordscount= uniquestrings.size();
//break doesnt increment it before quitting loop.
if(subwordscount>=2000){cout<<"\n";it++;break;}
}
//+mapsize;
// cout<< "Came1:"<<myrank<<" and subcount:"<<subwordscount;
}
int j=0;
MPI_Bcast( &subwordscount, 1, MPI_INT, i, MPI_COMM_WORLD);
if(subwordscount==0)continue;
//char rootwords[subwordscount][STRING_LENGTH];
char rootwords[subwordscount][STRING_LENGTH]; //char (*rootwords)[STRING_LENGTH] = new
if(myrank==i)
{
for (auto entry : uniquestrings)
{
std::size_t length = entry.copy(rootwords[j],STRING_LENGTH-1);
rootwords[j][length]='\0';
j++;
}
}
//broadcasting all the words
MPI_Bcast( rootwords, subwordscount, MPI_Customword, i, MPI_COMM_WORLD);
int numofwordstosend=0;
int numofwordfreqstosend=0;
Wordtoword *wordtoword_ptr=nullptr;
WordFrequency *wordfrequency_ptr=nullptr;
//sending the number of words to the broadcaster process
if(myrank != i)
{
//get all the word entries matching in the local map
wordtoword_ptr = get_wordtoword_ifpresent(localmap,numofwordstosend, rootwords, subwordscount);
wordfrequency_ptr = get_wordfrequency_ifpresent(frequencymap,numofwordfreqstosend, rootwords, subwordscount);
}
int *recvcounts= new int[size];
int *recvdisplacements= new int[size];
MPI::COMM_WORLD.Barrier();
int *recvcountsfreq= new int[size];
int *recvdisplacementsfreq= new int[size];
MPI_Gather(&numofwordstosend, 1, MPI_INT, recvcounts, 1, MPI_INT, i, MPI_COMM_WORLD);
MPI_Gather(&numofwordfreqstosend, 1, MPI_INT, recvcountsfreq, 1, MPI_INT, i, MPI_COMM_WORLD);
//cout<<" STEP1 "<<(clock()-start)/ (double) CLOCKS_PER_SEC;
if(myrank==i)
{
recvdisplacements[0]=0;
for(int x=0;x<size;x++)
{
if(x!=0)
{recvdisplacements[x]=recvdisplacements[x-1]+recvcounts[x-1];}
totalwordsize+=recvcounts[x];
}
allwords = new Wordtoword[totalwordsize];
recvdisplacementsfreq[0]=0;
for(int x=0;x<size;x++)
{
if(x!=0)
{
recvdisplacementsfreq[x]=recvdisplacementsfreq[x-1]+recvcountsfreq[x-1];
}
totalwordsizefreq+=recvcountsfreq[x];
}
allwordsfreq= new WordFrequency[totalwordsizefreq];
// cout<<" STEP1 "<<(clock()-start)/ (double) CLOCKS_PER_SEC<<" Totalwordssize:"<<totalwordsize;
}
MPI_Gatherv(wordtoword_ptr, numofwordstosend, MPI_SingleWordtoWord, allwords, recvcounts, recvdisplacements, MPI_SingleWordtoWord,i , MPI_COMM_WORLD);
MPI_Gatherv(wordfrequency_ptr, numofwordfreqstosend, MPI_SingleWordFrequency, allwordsfreq, recvcountsfreq, recvdisplacementsfreq, MPI_SingleWordFrequency , i, MPI_COMM_WORLD);
//cout<<" STEP3 "<<(clock()-start)/ (double) CLOCKS_PER_SEC;
if(recvcounts!=nullptr)delete recvcounts;
if(recvdisplacements!=nullptr)delete recvdisplacements;
if(recvcountsfreq!=nullptr)delete recvcountsfreq;
if(recvdisplacementsfreq!=nullptr)delete recvdisplacementsfreq;
if(wordtoword_ptr!=nullptr)delete wordtoword_ptr;
if(wordfrequency_ptr!=nullptr)delete wordfrequency_ptr;
// cout<<" STEP4 "<<(clock()-start)/ (double) CLOCKS_PER_SEC<<"\n";
}
//cout<<"Process Memory: "<<myrank<<" Mapsize"<<mapsize(localmap)+mapsize(localsecondlevelmap)<<endl;
if(allwords!=nullptr){
reduce(allwords, totalwordsize, localsecondlevelmap,1);
delete allwords;
}
//cout<<"Process : "<< myrank <<" Reduce ended "<<(clock()-whilestart)/ (double) CLOCKS_PER_SEC<<endl;
if(allwordsfreq!=nullptr){
reducefreq(allwordsfreq, totalwordsizefreq, frequencymap,1);
delete allwordsfreq;
}
//cout<<"Process Memory: "<<myrank<<" Mapsize"<<mapsize(localmap)+mapsize(localsecondlevelmap)<<endl;
MPI::COMM_WORLD.Barrier();
//ll
cout<<"Process: "<< myrank <<" While ended "<<(clock()-whilestart)/ (double) CLOCKS_PER_SEC<<endl;
int arewedone=0;
MPI_Allreduce(&subwordscount, &arewedone, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
if(arewedone==0)break;
}
MPI::COMM_WORLD.Barrier();
if ( myrank == 0 )
cout << "Process: " << myrank << " writing to file started.." << "\n";
//----------------------------------------------------------------------------------------------------------
////writing to file
//----------------------------------------------------------------------------------------------------------
std::fstream fs;
string filenamefs ="file"+to_string(myrank)+".txt";
fs.open (filenamefs.c_str(), std::fstream::in | std::fstream::out | std::fstream::app);
char *line = new char[20];
int x=0;
int totallength=0;
int maxlocalmapsize=0;
int localmap_size = localmap.size();
MPI_Allreduce(&localmap_size, &maxlocalmapsize, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);
long long sizeofstr=0;
int counter=0,counter1=0;
it = localmap.begin();
char *localstr= new char[20];
int length=0;
int length1=0;
for(it = localmap.begin();it!=localmap.end();it++)
{
if((it->first).substr( (it->first).length() - 2 ) == "NN")
{
string rootentry ="";//= it->first +" ";
auto &submap = it->second;
string secondlevelstring="(";
for(auto& secondlevelentry : submap)
{
//if(secondlevelentry.second>=6)
secondlevelstring+=secondlevelentry.first+"::"+std::to_string(secondlevelentry.second)+",";
}
secondlevelstring.replace(secondlevelstring.end()-1,secondlevelstring.end(),")\n");
rootentry+=it->first +" "+it->first+"::"+ std::to_string(frequencymap[it->first]) + secondlevelstring;
for(auto &firstlevelentry : submap)
{
//if(firstlevelentry.second>=6)
{
//cout<<firstlevelentry.second<<"came"<<endl;
if(localmap.find(firstlevelentry.first)!=localmap.end())
{
auto &secondlevelsubmap = localmap[firstlevelentry.first];
string secondlevelstring="(";
for(auto& secondlevelentry : secondlevelsubmap)
{
//if(secondlevelentry.second>=5)
secondlevelstring+=secondlevelentry.first+"::"+std::to_string(secondlevelentry.second)+",";
}
secondlevelstring.replace(secondlevelstring.end()-1,secondlevelstring.end(),")\n");
rootentry+=it->first +" "+firstlevelentry.first+"::"+ std::to_string(frequencymap[firstlevelentry.first]) + secondlevelstring;
}
else if(localsecondlevelmap.find(firstlevelentry.first)!=localsecondlevelmap.end())
{
auto &secondlevelsubmap = localsecondlevelmap[firstlevelentry.first];
string secondlevelstring="(";
for(auto& secondlevelentry : secondlevelsubmap)
{
//if(secondlevelentry.second>=5)
secondlevelstring+=secondlevelentry.first+"::"+std::to_string(secondlevelentry.second)+",";
}
secondlevelstring.replace(secondlevelstring.end()-1,secondlevelstring.end(),")\n");
rootentry+=it->first +" "+firstlevelentry.first+"::"+std::to_string(frequencymap[firstlevelentry.first]) +secondlevelstring;
}
// else
// if((it->first).compare("absence::NN")==0)counter1++;
}
}
length = rootentry.length();
free(localstr);
localstr = new char[length+1];
strcpy(localstr, rootentry.c_str());
if(myrank==0)
counter++;
fs<<localstr;
}
}
fs.close();
if(myrank==0)cout<<"writing to file done..size="<<sizeofstr<<"\n";
MPI::Finalize();
return 0;
}