/**
* handle reinvade message from server and return true if anything has to be changed
*/
bool handleReinvadeNonblocking()
{
if (shutdown_in_progress)
return false;
if (verbose_level > 3)
std::cout << this_pid << ": CHANGING RESOURCES (NONBLOCKING)" << std::endl;
assert(sPMOMessage->data.invade_answer.number_of_cores > 0);
// update number of threads
setNumberOfThreads(sPMOMessage->data.invade_answer.number_of_cores);
// update the affinities
setAffinities(sPMOMessage->data.invade_answer.affinity_array, sPMOMessage->data.invade_answer.number_of_cores);
// send update to server
sPMOMessage->package_type = SPMOMessage::CLIENT_REINVADE_ACK_NONBLOCKING;
cMessageQueue->sendToServer(
(size_t)&(sPMOMessage->data.reinvade_ack_async) - (size_t)sPMOMessage +
sizeof(sPMOMessage->data.reinvade_ack_async) +
sizeof(int)*(sPMOMessage->data.reinvade_ack_async.number_of_cores-1)
);
return true;
}
void Settings::copyFrom(Settings *other)
{
setDefaultFullScore(other->getDefaultFullScore());
setDefaultTimeLimit(other->getDefaultTimeLimit());
setDefaultMemoryLimit(other->getDefaultMemoryLimit());
setCompileTimeLimit(other->getCompileTimeLimit());
setSpecialJudgeTimeLimit(other->getSpecialJudgeTimeLimit());
setFileSizeLimit(other->getFileSizeLimit());
setNumberOfThreads(other->getNumberOfThreads());
setDefaultInputFileExtension(other->getDefaultInputFileExtension());
setDefaultOutputFileExtension(other->getDefaultOutputFileExtension());
setInputFileExtensions(other->getInputFileExtensions().join(";"));
setOutputFileExtensions(other->getOutputFileExtensions().join(";"));
for (int i = 0; i < compilerList.size(); i ++) {
delete compilerList[i];
}
compilerList.clear();
const QList<Compiler*> &list = other->getCompilerList();
for (int i = 0; i < list.size(); i ++) {
Compiler *compiler = new Compiler;
compiler->copyFrom(list[i]);
addCompiler(compiler);
}
}
/**
* handle invade message from server and return true if anything has to be changed
*/
bool handleInvadeAnswer()
{
if (shutdown_in_progress)
return false;
// nothing to do if nothing was changed!
if (!sPMOMessage->data.invade_answer.anythingChanged)
return false;
if (verbose_level > 3)
std::cout << this_pid << ": CHANGING RESOURCES" << std::endl;
assert(sPMOMessage->data.invade_answer.number_of_cores > 0);
// std::cout << "HANDLE INVADE ANSWER: setNumberOfThreads" << std::endl;
// update number of threads
setNumberOfThreads(sPMOMessage->data.invade_answer.number_of_cores);
// update the affinities
// std::cout << "HANDLE INVADE ANSWER: setAffinities" << std::endl;
setAffinities(sPMOMessage->data.invade_answer.affinity_array, sPMOMessage->data.invade_answer.number_of_cores);
// std::cout << "HANDLE INVADE ANSWER: END" << std::endl;
return true;
}
void Workers::pauseAllThreadsAndWait ()
{
setNumberOfThreads (0);
m_allPaused.wait ();
bassert (numberOfCurrentlyRunningTasks () == 0);
}
Workers::Workers (Callback& callback, String const& threadNames, int numberOfThreads)
: m_callback (callback)
, m_threadNames (threadNames)
, m_allPaused (true, true)
, m_semaphore (0)
, m_numberOfThreads (0)
{
setNumberOfThreads (numberOfThreads);
}
//*************************************************************************************************
// Constructor with original image chain provided. This source becomes the first clone in the list.
//*************************************************************************************************
ossimImageChainMtAdaptor::ossimImageChainMtAdaptor(ossimImageChain* original,
ossim_uint32 num_threads_req)
: m_numThreads (0),
d_useSharedHandlers(true),
d_debugEnabled(false)
{
//###### DEBUG ############
ossimMtDebug* mt_debug = ossimMtDebug::instance();
d_useSharedHandlers = mt_debug->chainSharedHandlers;
d_debugEnabled = mt_debug->chainDebugEnabled;
//###### END DEBUG ############
setNumberOfThreads(num_threads_req);
setOriginalChain(original);
}
/**
* constructor
*/
CPMO_OMP(
int i_max_threads = -1,
bool i_delayed_parallel_region_mode = false,
bool i_wait_for_ack = true ///< specifies for how many mpi nodes to wait
///< before starting execution in case that MPI is activated
) :
CPMO(0, i_wait_for_ack),
delayed_parallel_region_mode(i_delayed_parallel_region_mode)
{
if (i_max_threads <= 0)
max_threads = omp_get_max_threads();
else
max_threads = i_max_threads;
setNumberOfThreads(1);
}
/**
* handle message
*
* return true if the resources were changed
*/
bool msg_recv_message_innerloop()
{
switch(sPMOMessage->package_type)
{
case SPMOMessage::SERVER_QUIT:
// std::cout << this_pid << ": Processing message type SERVER_QUIT" << std::endl;
std::cerr << "QUIT requested from server" << std::endl;
exit(-1);
return false;
case SPMOMessage::CLIENT_ACK_SHUTDOWN:
// std::cout << this_pid << ": Processing message type CLIENT_ACK_SHUTDOWN" << std::endl;
if (sPMOMessage->data.ack_quit.seq_id <= last_seq_id)
std::cerr << "SEQ ID wrong " << sPMOMessage->data.ack_quit.seq_id << " <= " << last_seq_id << std::endl;
assert(sPMOMessage->data.ack_quit.seq_id > last_seq_id);
last_seq_id = sPMOMessage->data.ack_quit.seq_id;
// update client shutdown hint
std::cout << "SUM CLIENT SHUTDOWN HINT: " << sPMOMessage->data.ack_quit.client_shutdown_hint << std::endl;
std::cout << "SUM CLIENT SHUTDOWN HINT DIV TIME: " << sPMOMessage->data.ack_quit.client_shutdown_hint_div_time << std::endl;
return false;
case SPMOMessage::SERVER_INVADE_ANSWER:
// std::cout << this_pid << ": Processing message type SERVER_INVADE_ANSWER" << std::endl;
if (sPMOMessage->data.invade_answer.seq_id <= last_seq_id)
std::cerr << "SEQ ID wrong " << sPMOMessage->data.invade_answer.seq_id << " <= " << last_seq_id << std::endl;
assert(sPMOMessage->data.invade_answer.seq_id > last_seq_id);
last_seq_id = sPMOMessage->data.invade_answer.seq_id;
return handleInvadeAnswer();
case SPMOMessage::SERVER_REINVADE_NONBLOCKING:
// std::cout << this_pid << ": Processing message type SERVER_REINVADE_NONBLOCKING" << std::endl;
if (sPMOMessage->data.invade.seq_id <= last_seq_id)
std::cerr << "SEQ ID wrong " << sPMOMessage->data.invade.seq_id << " <= " << last_seq_id << std::endl;
assert(sPMOMessage->data.invade.seq_id > last_seq_id);
last_seq_id = sPMOMessage->data.invade_answer.seq_id;
if (retreat_in_progress)
return false;
return handleReinvadeNonblocking();
case SPMOMessage::SERVER_ACK:
// std::cout << this_pid << ": Processing message type SERVER_ACK" << std::endl;
if (sPMOMessage->data.ack.seq_id <= last_seq_id)
std::cerr << "SEQ ID wrong " << sPMOMessage->data.ack.seq_id << " <= " << last_seq_id << std::endl;
assert(sPMOMessage->data.ack.seq_id > last_seq_id);
last_seq_id = sPMOMessage->data.ack.seq_id;
if (getNumberOfThreads() == 0)
setNumberOfThreads(1);
return false;
default:
std::cerr << "UNKNOWN MESSAGE TYPE " << sPMOMessage->package_type << std::endl;
assert(false);
exit(-1);
return false;
}
}
