//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void Backend::sendToFrontend(const MRN::PacketPtr& packet)
{
if (is_backend_debug_enabled)
{
std::cout << "[BE " << getpid() << "] "
<< "Sending " << packet->get_Tag() << "." << std::endl;
}
// Insure the packet containing the message has the correct stream ID
if (mrnet_stream == NULL)
{
raise<std::runtime_error>(
"The MRNet stream hasn't been created yet."
);
}
packet->set_StreamId(mrnet_stream->get_Id());
// Send the message
int retval = mrnet_stream->send(
const_cast<MRN::PacketPtr&>(packet)
);
if (retval != 0)
{
raise<std::runtime_error>("Failed to send the specified message.");
}
retval = mrnet_stream->flush();
if (retval != 0)
{
raise<std::runtime_error>("Failed to send the specified message.");
}
}
int
MRNetBE::mHandshake(void)
{
VCOMP_COUT("Starting lash-up handshake..." << endl);
//
MRN::PacketPtr packet;
const bool recvShouldBlock = true;
int tag = 0;
// This will setup the protocol stream.
auto status = mNet->recv(&tag, packet, &mProtoStream, recvShouldBlock);
if (1 != status) {
static const string f = "Stream::Recv";
GLADIUS_CERR << utils::formatCallFailed(f, GLADIUS_WHERE) << endl;
return GLADIUS_ERR_MRNET;
}
int ping = -1;
status = packet->unpack("%d", &ping);
if (0 != status) {
static const string f = "PacketPtr::unpack";
GLADIUS_CERR << utils::formatCallFailed(f, GLADIUS_WHERE) << endl;
return GLADIUS_ERR_MRNET;
}
if (toolcommon::MRNetCoreTags::InitHandshake != tag) {
static const string errs = "Received Invalid Tag From Tool Front-End";
GLADIUS_CERR << errs << endl;
return GLADIUS_ERR;
}
if (ping != GladiusMRNetProtoFilterMagic) {
static const string errs = "Received Invalid Data From Tool Front-End";
GLADIUS_CERR << errs << endl;
return GLADIUS_ERR;
}
int pong = -ping;
status = mProtoStream->send(tag, "%d", pong);
if (-1 == status) {
static const string f = "Stream::Send";
GLADIUS_CERR << utils::formatCallFailed(f, GLADIUS_WHERE) << endl;
return GLADIUS_ERR_MRNET;
}
status = mProtoStream->flush();
if (-1 == status) {
static const string f = "Stream::Flush";
GLADIUS_CERR << utils::formatCallFailed(f, GLADIUS_WHERE) << endl;
return GLADIUS_ERR_MRNET;
}
//
return GLADIUS_SUCCESS;
}
/**
* Receives valid plugin name and path from FE.
*/
int
MRNetBE::mPluginInfoRecv(
string &validPluginName,
string &pathToValidPlugin
) {
VCOMP_COUT("Receiving plugin info from front-end..." << endl);
//
MRN::PacketPtr packet;
MRN::Stream *stream = nullptr;
const bool recvShouldBlock = true;
int tag = 0;
auto status = mNet->recv(&tag, packet, &stream, recvShouldBlock);
if (1 != status) {
static const string f = "Network::Recv";
GLADIUS_CERR << utils::formatCallFailed(f, GLADIUS_WHERE) << endl;
return GLADIUS_ERR_MRNET;
}
// Make sure that we are dealing with a tag that we are expecting...
if (toolcommon::MRNetCoreTags::PluginNameInfo != tag) {
static const string errs = "Received Invalid Tag From Tool Front-End";
GLADIUS_CERR << errs << endl;
return GLADIUS_ERR;
}
char *pluginName = nullptr;
char *pluginPath = nullptr;
status = packet->unpack("%s %s", &pluginName, &pluginPath);
if (0 != status) {
static const string f = "PacketPtr::unpack";
GLADIUS_CERR << utils::formatCallFailed(f, GLADIUS_WHERE) << endl;
return GLADIUS_ERR_MRNET;
}
// Set returns.
validPluginName = string(pluginName);
pathToValidPlugin = string(pluginPath);
//
free(pluginName);
free(pluginPath);
//
VCOMP_COUT("Front-End Plugin Info:" << endl);
VCOMP_COUT("*Name: " << validPluginName << endl);
VCOMP_COUT("*Path: " << pathToValidPlugin << endl);
//
return GLADIUS_SUCCESS;
}
bool StopTrace::handleResultPackage(MRN::PacketPtr packet, MRN::Stream* stream) {
map<MRN::Stream*, StopTrace*>::iterator it = waitingForResults.find(stream);
if (it == waitingForResults.end()) {
return DYSECTWARN(false, "Unexpected packet on result stream!");
}
StopTrace* action = it->second;
char* data;
int dataSize;
if (packet->unpack("%ac", &data, &dataSize) != 0) {
return DYSECTFATAL(false, "Unexpected global result package content!");
}
action->trace->processGlobalResult(data, dataSize);
waitingForResults.erase(it);
TraceAPI::processedGlobalRes(action->trace);
free(data);
return true;
}
int
main( int argc, char* argv[] )
{
int ret = 0;
MRN::Network* net = NULL;
try
{
int myNid = FindMyNid();
// connect to the MRNet
net = MRN::Network::CreateNetworkBE( argc, argv );
assert( net != NULL );
int myRank = net->get_LocalRank();
//fprintf( stderr, "BE[%d] done creating MRNet net BE\n", myRank );
//fflush( stderr );
// receive the ALPS apid for the application to be monitored
MRN::Stream* strm = NULL;
MRN::PacketPtr pkt;
int tag = 0;
int rret = net->recv( &tag, pkt, &strm );
//fprintf( stderr, "BE[%d] received ALPS apid msg\n", myRank );
//fflush( stderr );
if( rret == -1 )
{
throw XTMException( "BE[%d] failed to receive control message from FE" );
}
if( tag != XTM_APID )
{
std::ostringstream mstr;
mstr << "BE[" << myRank << "] expected XTM_APID message, got tag=" << tag << std::ends;
throw XTMException( mstr.str().c_str() );
}
uint64_t apid = (uint64_t)-1;
pkt->unpack( "%uld", &apid );
//fprintf( stderr, "BE[%d] received apid=%lu\n", myRank, apid );
//fflush( stderr );
#ifdef TOOL_CODE_GOES_HERE
// ---- BEGIN TOOL-SPECIFIC CODE REGION ----
// 1. attach to local application process(es)
// 2. indicate to tool FE that we are attached
// 3. handle application process events until it finishes
// ---- END TOOL-SPECIFIC CODE REGION ----
#else
// fake to the FE as if we have connected to the application and
// waited for it to finish
tag = XTM_APPOK;
int dummyVal = 1;
int sret = strm->send( tag, "%d", dummyVal );
if( sret == -1 )
{
fprintf( stderr, "BE[%d] send of app OK msg failed\n", myRank );
fflush( stderr );
}
int fret = strm->flush();
if( fret == -1 )
{
fprintf( stderr, "BE[%d] flush of app OK msg failed\n", myRank );
fflush( stderr );
}
if( (sret == -1) || (fret == -1) )
{
std::ostringstream mstr;
mstr << "BE[" << myRank << "] failed to send app OK msg to FE" << std::ends;
throw XTMException( mstr.str().c_str() );
}
//fprintf( stderr, "BE[%d] sent app OK message to FE\n", myRank );
//fflush( stderr );
sleep( 5 );
#endif
//fprintf( stderr, "BE[%d] sending app done message to FE\n", myRank );
//fflush( stderr );
tag = XTM_APPDONE;
int appExitCode = 1;
sret = strm->send( tag, "%d", appExitCode );
if( sret == -1 )
{
fprintf( stderr, "BE[%d] send of app done msg failed\n", myRank );
fflush( stderr );
}
fret = strm->flush();
if( fret == -1 )
{
fprintf( stderr, "BE[%d] flush of app done msg failed\n", myRank );
fflush( stderr );
}
if( (sret == -1) || (fret == -1) )
{
std::ostringstream mstr;
mstr << "BE[" << myRank << "] failed to send app exit code to FE" << std::ends;
throw XTMException( mstr.str().c_str() );
}
//fprintf( stderr, "BE[%d] sent app done message to FE\n", myRank );
//fflush( stderr );
// wait for termination message from FE
rret = net->recv( &tag, pkt, &strm );
if( rret == -1 )
{
std::ostringstream mstr;
mstr << "BE[" << myRank << "] failed to receive control message from FE" << std::ends;
throw XTMException( mstr.str().c_str() );
}
if( tag != XTM_EXIT )
{
std::ostringstream mstr;
mstr << "BE[" << myRank << "] expected XTM_EXIT message, got tag=" << tag << std::ends;
throw XTMException( mstr.str().c_str() );
}
// clean up
//fprintf( stderr, "BE[%d] exiting\n", myRank );
//fflush( stderr );
net->waitfor_ShutDown();
delete net;
}
catch( std::exception& e )
{
fprintf( stderr, "!!BE EXCEPTION!! %s\n", e.what() );
ret = 1;
}
return ret;
}
DysectErrorCode FE::requestBackendSetup(const char *libPath) {
struct timeval start, end;
gettimeofday(&start, NULL);
MRN::Communicator* broadcastCommunicator = network->get_BroadcastCommunicator();
controlStream = network->new_Stream(broadcastCommunicator, MRN::TFILTER_SUM, MRN::SFILTER_WAITFORALL);
if(!controlStream) {
return Error;
}
// Check for pending acks
int ret = statFE->receiveAck(true);
if (ret != STAT_OK) {
return Error;
}
//
// Send library path to all backends
//
if (controlStream->send(PROT_LOAD_SESSION_LIB, "%s", libPath) == -1) {
return Error;
}
if (controlStream->flush() == -1) {
return Error;
}
//
// Block and wait for all backends to acknowledge
//
int tag;
MRN::PacketPtr packet;
Err::verbose(true, "Block and wait for all backends to confirm library load...");
if(controlStream->recv(&tag, packet, true) == -1) {
return Error;
}
int numIllBackends = 0;
//
// Unpack number of ill backends
//
if(packet->unpack("%d", &numIllBackends) == -1) {
return Error;
}
if(numIllBackends != 0) {
fprintf(stderr, "Frontend: %d backends reported error while loading session library '%s'\n", numIllBackends, libPath);
return Error;
}
//
// Broadcast request for notification upon finishing
// stream binding.
// Do not wait for response until all init packets have been broadcasted.
//
Err::verbose(true, "Broadcast request for notification upon finishing stream binding");
if(controlStream->send(DysectGlobalReadyTag, "") == -1) {
return Error;
}
if(controlStream->flush() == -1) {
return Error;
}
//
// Broadcast init packets on all created streams
//
Err::verbose(true, "Broadcast init packets on all created streams");
if(Frontend::broadcastStreamInits() != OK) {
return Error;
}
Err::verbose(true, "Waiting for backends to finish stream binding...");
if(controlStream->recv(&tag, packet, true) == -1) {
return Error;
}
//
// Unpack number of ill backends
//
if (packet->unpack("%d", &numIllBackends) == -1) {
return Error;
}
if (numIllBackends != 0) {
fprintf(stderr, "Frontend: %d backends reported error while bindings streams\n", numIllBackends);
return Error;
}
//
// Kick off session
//
Err::verbose(true, "Kick off session");
if (controlStream->send(DysectGlobalStartTag, "") == -1) {
return Error;
}
if (controlStream->flush() == -1) {
return Error;
}
gettimeofday(&end, NULL);
// Bring both times into milliseconds
long startms = ((start.tv_sec) * 1000) + ((start.tv_usec) / 1000);
long endms = ((end.tv_sec) * 1000) + ((end.tv_usec) / 1000);
long elapsedms = endms - startms;
Err::info(true, "DysectAPI setup took %ld ms", elapsedms);
return OK;
}
