int main(int argc, char *argv[])
{
int rank;
int nproc;
FILE *input;
MPI_Init(&argc,&argv);
MPI_Comm_rank(MPI_COMM_WORLD,&rank);
MPI_Comm_size(MPI_COMM_WORLD,&nproc);
if ( nproc<2 && rank==0 )
{
fprintf(stderr,"%s: At least 2 MPI processes required!\n",argv[0]);
exit(-1);
}
if ( rank==0 )
{
if ( argc>1 )
{
input = fopen(argv[1],"r");
}
else
{
input = stdin;
}
mastermind(nproc-1,input);
}
else
{
minion(rank);
}
MPI_Finalize();
return(0);
}
Worker::Worker(const std::vector<uint>& jobIDs, const WorkerSettings& settings)
: context_(1), heartbeat_(context_, settings.heartbeat)
{
// Setup sockets
std::unique_ptr<zmq::socket_t> minion(new zmq::socket_t(context_, ZMQ_ROUTER));
std::unique_ptr<zmq::socket_t> heartbeat(new zmq::socket_t(context_, ZMQ_PAIR));
std::unique_ptr<zmq::socket_t> network(new zmq::socket_t(context_, ZMQ_DEALER));
minion->bind(WORKER_SOCKET_ADDR.c_str());
heartbeat->bind(CLIENT_HB_SOCKET_ADDR.c_str());
auto networkSocketID = stateline::comms::randomSocketID();
stateline::comms::setSocketID(networkSocketID, *(network));
std::string address = "tcp://" + settings.address;
LOG(INFO)<< "Worker connecting to " << address;
network->connect(address.c_str());
// Transfer sockets to the router
router_.add_socket(SocketID::MINION, minion);
router_.add_socket(SocketID::HEARTBEAT, heartbeat);
router_.add_socket(SocketID::NETWORK, network);
// Specify the Worker functionality
auto onRcvJOBREQUEST = [&] (const Message&m)
{ forwardToNetwork(m, this->router_);};
auto onRcvJOB = [&] (const Message&m)
{ forwardToMinion(m, this->router_);};
auto onRcvJOBSWAP = [&] (const Message&m)
{ forwardToNetwork(m, this->router_);};
auto fForwardToHB = [&] (const Message&m)
{ this->router_.send(SocketID::HEARTBEAT, m);};
auto fForwardToNetwork = [&] (const Message&m)
{ this->router_.send(SocketID::NETWORK,m);};
auto fDisconnect = [&] (const Message&m)
{ disconnectFromServer(m);};
// Bind functionality to the router
router_(SocketID::MINION).onRcvJOBREQUEST.connect(onRcvJOBREQUEST);
router_(SocketID::NETWORK).onRcvJOB.connect(onRcvJOB);
router_(SocketID::MINION).onRcvJOBSWAP.connect(onRcvJOBSWAP);
router_(SocketID::NETWORK).onRcvHEARTBEAT.connect(fForwardToHB);
router_(SocketID::NETWORK).onRcvHELLO.connect(fForwardToHB);
router_(SocketID::NETWORK).onRcvGOODBYE.connect(fForwardToHB);
router_(SocketID::HEARTBEAT).onRcvHEARTBEAT.connect(fForwardToNetwork);
router_(SocketID::HEARTBEAT).onRcvGOODBYE.connect(fDisconnect);
// Initialise the connection and problemspec
router_.send(SocketID::NETWORK, Message(HELLO, { serialise(jobIDs) }));
auto msgProblemSpec = router_.receive(SocketID::NETWORK);
VLOG(3) << "Received " << msgProblemSpec;
globalSpec_ = msgProblemSpec.data[0];
uint index = 1;
while (index + 3 <= msgProblemSpec.data.size())
{
uint jobid = std::stoi(msgProblemSpec.data[index++]);
jobsEnabled_.insert(jobid);
std::string spec = msgProblemSpec.data[index++];
std::string readings = msgProblemSpec.data[index++];
jobSpecs_.insert(std::make_pair(jobid, spec));
jobResults_.insert(std::make_pair(jobid, readings));
}
LOG(INFO)<< "Problem Specification Initialised";
// Start the router and heartbeating
router_.start(settings.msPollRate);
heartbeat_.start();
}
void Board::play(Card card, Turn turn, int target /*no target*/)
{
minions[turn].push_back(minion(card));
//TODO: interact with board...
}
