void Requester::batchSubmit(uint id, const std::vector<JobData>& jobs)
{
uint nJobs = jobs.size();
batches_[id] = std::vector<ResultData>(nJobs);
batchLeft_[id] = nJobs;
for (uint i = 0; i < nJobs; i++)
{
sendJob(socket_, { id, i }, std::move(jobs[i]));
}
}
void Server::handleData(QTcpSocket* socket, QByteArray data) {
QDataStream ds(&data, QIODevice::ReadWrite);
WhiteNetwork::Message type;
ds >> type;
if(type == WhiteNetwork::Message::RegisterClient) {
client_socket = socket;
qDebug() << "Client";
start_time = std::chrono::system_clock::now();
sendJobs();
}
else if(type == WhiteNetwork::Message::RegisterWorker) {
workers_sockets.push_back(socket);
qDebug() << "Worker";
}
else if(type == WhiteNetwork::Message::PixelsData) {
collectResult(ds);
}
else if(type == WhiteNetwork::Message::JobDone) {
sendJob(socket);
}
}
void Server::sendJobs()
{
for(const auto socket : workers_sockets) {
sendJob(socket);
}
}
void Master::solve() {
lastCubeFinished = wallClockTime();
num_threads = so.num_threads;
job_start_time.growTo(num_threads, DONT_DISTURB);
job_start_time_backup.growTo(num_threads, DONT_DISTURB);
cur_job.growTo(num_threads, NULL);
lhead.growTo(num_threads, 0);
last_send_learnts.growTo(num_threads, 0);
global_learnts.reserve(10000000);
long maxCycleTime = 0;
stoppedInit = false;
if(engine.opt_var){
bestObjReceived = engine.opt_type ? engine.opt_var->getMin() : engine.opt_var->getMax();
}
if(so.purePortfolio){
for(int i = 0 ; i < num_threads ; i++)
job_queue.push(new SClause());
}
else
job_queue.push(new SClause());
for(int i = 0 ; i < num_threads ; i++){
if(so.greedyInit && (i % 3 < 2)){
slaveStates.push_back(RUNNING_GREEDY);
slavesRunningGreedy++;
setState(i, RUNNING_GREEDY);
}
else{
slaveStates.push_back(NORMAL_SEARCH);
setState(i, NORMAL_SEARCH);
}
}
MPI_Buffer_attach(malloc(MPI_BUFFER_SIZE), MPI_BUFFER_SIZE);
// Search:
int lastPrinted = time(NULL);
int tStart = lastPrinted;
long lastSleep = clock();
bool stealJobsNow = true;
while (status == RES_UNK && time(NULL) < so.time_out) {
//fprintf(stderr, "Trying to send jobs...\n");
while (num_free_slaves > 0 && job_queue.size() > 0) {
if(!sendJob())
break;
}
/**************************************************************************
* Ask all jobs to finish the first phase, if this has not happened yet.
* */
if(!stoppedInit && time(NULL) > engine.half_time){
if(PAR_DEBUG) fprintf(stderr, "Asking remaining init-workers to continue with normal search...\n");
for(int i = 0 ; i < num_threads ; i++){
if(slaveStates[i] == RUNNING_GREEDY){
setState(i, NORMAL_SEARCH);
}
}
stoppedInit = true;
}
int received;
MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &received, &s);
if (received) {
double t;
profile_start();
// printf("Profiling started...\n");
switch (s.MPI_TAG) {
case REPORT_TAG:
// printf("It was a report!\n");
receiveReport();
// printf("ReceiveReport done!\n");
profile_end("receive report", 0);
continue;
case SPLIT_TAG:
// printf("Split tag received!\n");
receiveJobs();
profile_end("receive jobs", 0);
continue;
case REPORT_SOLUTION_TAG:
if(PAR_DEBUG) fprintf(stderr, "Received solution! \n");
receiveSolution();
continue;
case REPORT_OPTIMUM_TAG:
receiveOptObj();
continue;
case SOLUTION_PHASE_TAG:
receivePhase();
continue;
case SLAVE_NEW_STATE_TAG:
int dummy;
MPI_Recv(&dummy, 1, MPI_INT, s.MPI_SOURCE, SLAVE_NEW_STATE_TAG, MPI_COMM_WORLD, &s);
if(PAR_DEBUG) fprintf(stderr, "Setting state of slave %d to %d\n", s.MPI_SOURCE-1, dummy);
if(slaveStates[s.MPI_SOURCE-1] == RUNNING_GREEDY && dummy == NORMAL_SEARCH)
slavesRunningGreedy--;
slaveStates[s.MPI_SOURCE-1] = dummy;
continue;
continue;
default:
assert(false);
}
}
if (job_queue.size() < 2*num_threads-2 && !so.purePortfolio ) {
// Steal jobs if
// - normal mode
// - greedy-init, and at least one job finished now...
if(!so.greedyInit || slavesRunningGreedy < num_threads){
stealJobs();
//continue;
}
}
long now = clock();
maxCycleTime = std::max(maxCycleTime, now - lastSleep);
usleep(500);
lastSleep = clock();
}
if (PAR_DEBUG){
fprintf(stderr, "Waiting for slaves to terminate...\n");
fprintf(stderr, "Max cycle time: %d (%lf)\n", maxCycleTime, (double)maxCycleTime/CLOCKS_PER_SEC);
fprintf(stderr, "End of problem called\n");
}
MPI_Request r;
for (int i = 0; i < num_threads; i++) {
MPI_Isend(NULL, 0, MPI_INT, i+1, INTERRUPT_TAG, MPI_COMM_WORLD, &r);
MPI_Isend(NULL, 0, MPI_INT, i+1, FINISH_TAG, MPI_COMM_WORLD, &r);
}
while (num_free_slaves != num_threads) {
MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &s);
int thread_no = s.MPI_SOURCE-1;
MPI_Get_count(&s, MPI_INT, &message_length);
message = (int*) malloc(message_length*sizeof(int));
MPI_Recv(message, message_length, MPI_INT, s.MPI_SOURCE, s.MPI_TAG, MPI_COMM_WORLD, &s);
if (s.MPI_TAG == REPORT_TAG) {
if (message[0] != RES_SEA) {
assert(job_start_time[thread_no] != NOT_WORKING);
num_free_slaves++;
job_start_time[thread_no] = NOT_WORKING;
if (PAR_DEBUG) fprintf(stderr, "%d is free, %f\n", thread_no, wallClockTime());
}
}
free(message);
}
collectStats();
if(PAR_DEBUG) fprintf(stderr, "Master terminating with obj in %d and %d, bestResult= %d\n", engine.opt_var->getMin(), engine.opt_var->getMax(), bestObjReceived);
if(so.verbosity > 0)
printStats();
}
