int BackEndNode_proc_deleteStream( BackEndNode_t* be, Packet_t* ipacket )
{
unsigned int stream_id;
Stream_t * strm;
mrn_dbg_func_begin();
if (Packet_unpack(ipacket, "%ud", &stream_id) == -1) {
mrn_dbg(1, mrn_printf(FLF, stderr, "Packet_unpack() failed\n"));
return -1;
}
strm = Network_get_Stream(be->network, stream_id);
if(Network_is_UserStreamId(stream_id)) {
if (strm != NULL) {
// close user streams
strm->_was_closed = 1;
} else {
mrn_dbg(1, mrn_printf(FLF, stderr, "stream %u lookup failed\n", stream_id));
return -1;
}
} else {
if( strm != NULL ) {
// kill internal streams
delete_Stream_t( strm );
}
}
mrn_dbg_func_end();
return 0;
}
void CBTF_Waitfor_MRNet_Shutdown()
{
Packet_t * p;
p = (Packet_t *)malloc(sizeof(Packet_t));
Assert(p);
if (CBTF_MRNet_netPtr && Network_is_ShutDown(CBTF_MRNet_netPtr)) {
fprintf(stderr,"CBTF_Waitfor_MRNet_Shutdown -- already SHUTDOWN %d\n",getpid());
return;
}
if (CBTF_MRNet_netPtr) {
/* get our stream */
Stream_t* stream = Network_get_Stream(CBTF_MRNet_netPtr,stream_id);
int tag = 0;
/* wait for FE to request the shutdown */
do {
//fprintf(stderr,"CBTF_Waitfor_MRNet_Shutdown WAIT FOR FE request of shutdown %d\n",getpid());
if( CBTF_MRNet_netPtr && Network_recv(CBTF_MRNet_netPtr, &tag, p, &stream) != 1 ) {
fprintf(stderr, "BE: receive failure\n");
break;
}
} while ( tag != 101 );
/* send the FE the acknowledgement of shutdown */
//fprintf(stderr,"CBTF_Waitfor_MRNet_Shutdown SENDS FE acknowledgement of shutdown %d\n",getpid());
if ( (Stream_send(stream, /*tag*/ 102, "%d", 102) == -1) ||
Stream_flush(stream) == -1 ) {
fprintf(stderr, "CBTF_Waitfor_MRNet_Shutdown BE: stream::send() failure\n");
}
/* Now wait for mrnet to shutdown */
if (CBTF_MRNet_netPtr && !Network_is_ShutDown(CBTF_MRNet_netPtr)) {
//fprintf(stderr,"CBTF_Waitfor_MRNet_Shutdown Network_waitfor_ShutDown %d\n",getpid());
Network_waitfor_ShutDown(CBTF_MRNet_netPtr);
}
}
/* delete out network pointer */
if (CBTF_MRNet_netPtr != NULL) {
//fprintf(stderr,"CBTF_Waitfor_MRNet_Shutdown delete_Network_t CBTF_MRNet_netPtr %d\n",getpid());
delete_Network_t(CBTF_MRNet_netPtr);
}
if (p != NULL)
free(p);
//fprintf(stderr,"EXIT CBTF_Waitfor_MRNet_Shutdown %d\n",getpid());
}
void CBTF_MRNet_LW_sendToFrontend(const int tag, const int size, void *data)
{
const char* fmt_str = "%auc";
/*
* No need to repeatedly check mrnet_connected within a while loop as is
* typical with a condition variable because it is only ever set once by
* CBTF_MRNet_LW_connect() above.
*/
pthread_mutex_lock(&mrnet_connected_mutex);
if (!mrnet_connected)
{
pthread_cond_wait(&mrnet_connected_cond, &mrnet_connected_mutex);
}
pthread_mutex_unlock(&mrnet_connected_mutex);
#if defined(ENABLE_CBTF_MRNET_PLAYBACK)
if (playback_intercept(tag, (uint32_t)size, data))
{
return; /* Squelch the actual sending of this message. */
}
#endif
#ifndef NDEBUG
if (IsMRNetDebugEnabled) {
fprintf(stderr,"[%d,%d] CBTF_MRNet_LW_sendToFrontend: sends message with tag %d\n",
getpid(),monitor_get_thread_num(),tag);
}
#endif
Stream_t* CBTF_MRNet_stream = Network_get_Stream(CBTF_MRNet_netPtr,stream_id);
if ( (Stream_send(CBTF_MRNet_stream, tag, fmt_str, data, size) == -1) ||
Stream_flush(CBTF_MRNet_stream) == -1 ) {
fprintf(stderr, "BE: stream::send() failure\n");
}
fflush(stdout);
fflush(stderr);
}
int BackEndNode_proc_DataFromParent( BackEndNode_t* be, Packet_t* ipacket )
{
Stream_t* stream;
Packet_t* opacket;
vector_t * opackets = new_empty_vector_t();
vector_t * opackets_reverse = new_empty_vector_t();
unsigned int i;
mrn_dbg_func_begin();
stream = Network_get_Stream(be->network, ipacket->stream_id);
if (stream == NULL) {
mrn_dbg(1, mrn_printf(FLF, stderr, "stream %u lookup failed\n",
ipacket->stream_id));
return -1;
}
if (Stream_push_Packet(stream, ipacket, opackets, opackets_reverse, false) == -1) {
return -1;
}
for (i = 0; i < opackets->size; i++) {
opacket = opackets->vec[i];
Packet_set_DestroyData( opacket, true );
mrn_dbg(5, mrn_printf(FLF, stderr, "adding Packet on stream[%u]\n",
stream->id));
Stream_add_IncomingPacket(stream, opacket);
}
delete_vector_t( opackets );
delete_vector_t( opackets_reverse );
mrn_dbg_func_end();
return 0;
}
int CBTF_MRNet_LW_connect (const int con_rank)
{
pthread_mutex_lock(&mrnet_connected_mutex);
if (mrnet_connected) {
pthread_mutex_unlock(&mrnet_connected_mutex);
return 1;
}
const char* connfile = getenv("CBTF_MRNETBE_CONNECTIONS");
if (connfile == NULL) {
const char* connections_dir = getenv("PWD");
char buf[4096];
sprintf(buf,"%s%s",connections_dir,"/attachBE_connections");
connfile = strdup(buf);
}
char parHostname[64], myHostname[64], parPort[10], parRank[10], myRank[10];
/* sequential jobs pass con_rank of -1. In that case we need to
* use a rank of 0 and mRank of 10000 for the connection.
*/
Rank mRank;
int rank_to_use = con_rank;
if (con_rank < 0 ) {
mRank = 10000;
rank_to_use = 0;
} else {
mRank = 10000 + con_rank;
}
sprintf(myRank, "%d", mRank);
if( CBTF_MRNet_getParentInfo(connfile, rank_to_use, parHostname, parPort, parRank) != 0 ) {
fprintf(stderr, "CBTF_MRNet_LW_connect: Failed to parse connections file %s\n",connfile);
fprintf(stderr, "CBTF_MRNet_LW_connect: Failed for myRank %s, mrank %d, con_rank %d\n",myRank,mRank,rank_to_use);
abort();
}
while( gethostname(myHostname, 64) == -1 ) {}
myHostname[63] = '\0';
#ifndef NDEBUG
if (IsMRNetDebugEnabled) {
fprintf(stderr, "CBTF_MRNet_LW_connect: myRank %s, mRank %d, host %s\n",myRank,mRank,myHostname);
}
#endif
int BE_argc = 6;
char* BE_argv[6];
char be_name[24];
sprintf(be_name,"%s%s","cbtfBE",myRank);
BE_argv[0] = be_name;
BE_argv[1] = parHostname;
BE_argv[2] = parPort;
BE_argv[3] = parRank;
BE_argv[4] = myHostname;
BE_argv[5] = myRank;
#ifndef NDEBUG
if (IsMRNetDebugEnabled) {
fprintf(stderr,"CBTF_MRNet_LW_connect: argv 0=%s, 1=%s, 2=%lu, 3=%lu, 4=%s, 5=%lu\n",
BE_argv[0], BE_argv[1], strtoul( BE_argv[2], NULL, 10 ),
strtoul( BE_argv[3], NULL, 10 ), BE_argv[4], strtoul( BE_argv[5], NULL, 10 ));
fprintf( stderr, "CBTF_MRNet_LW_connect: Backend %s[%s] connecting to %s:%s[%s]\n",
myHostname,myRank,parHostname,parPort,myRank);
}
#endif
Packet_t * p;
p = (Packet_t *)malloc(sizeof(Packet_t));
Assert(p);
CBTF_MRNet_netPtr = Network_CreateNetworkBE(BE_argc, BE_argv);
Assert(CBTF_MRNet_netPtr);
int tag;
#ifndef NDEBUG
if (IsMRNetDebugEnabled) {
fprintf(stderr, "CBTF_MRNet_LW_connect: TRYING TO ESTABLISH CBTF_MRNet_stream\n");
}
#endif
Stream_t* CBTF_MRNet_stream;
if (Network_recv(CBTF_MRNet_netPtr, &tag, p, &CBTF_MRNet_stream) != 1) {
fprintf(stderr, "CBTF_MRNet_LW_connect: BE receive failure\n");
abort();
}
stream_id = CBTF_MRNet_stream->id;
#ifndef NDEBUG
if (IsMRNetDebugEnabled) {
fprintf(stderr,
"CBTF_MRNet_LW_connect: got tag %d, stream id %d, sync_filter_id %d, us_filter_id %d, ds_filter_id %d\n",
tag, CBTF_MRNet_stream->id,CBTF_MRNet_stream->sync_filter_id,
CBTF_MRNet_stream->us_filter_id, CBTF_MRNet_stream->ds_filter_id);
}
#endif
/* wait for FE to notify netowrk is ready
* Use the SpecifyFilter tag for this since once all commnodes
* have loaded a filter, this message is passed down to the BE.
* This holds the collectors from continuing until any needed
* filter is loaded above.
*/
if (CBTF_MRNet_netPtr) {
/* get our stream */
Stream_t* stream = Network_get_Stream(CBTF_MRNet_netPtr,stream_id);
int readytag = 0;
#ifndef NDEBUG
if (IsMRNetDebugEnabled) {
fprintf(stderr, "BE: waiting for specify filter tag from FE\n");
}
#endif
/* use KRELL_INSTITUTE_CBTF_IMPL_SPECIFY_FILTER for readytag 105
* include/from KrellInstitute/CBTF/Impl/MessageTags.h
*/
do {
if( CBTF_MRNet_netPtr && Network_recv(CBTF_MRNet_netPtr, &readytag, p, &stream) != 1 ) {
fprintf(stderr, "BE: receive failure\n");
break;
}
} while ( readytag != KRELL_INSTITUTE_CBTF_IMPL_NETWORK_READY /*107*/ );
#ifndef NDEBUG
if (IsMRNetDebugEnabled) {
fprintf(stderr, "BE: GOT TAG for filter tag %d from FE\n",readytag);
}
#endif
}
#if defined(ENABLE_CBTF_MRNET_PLAYBACK)
playback_configure(Network_get_LocalRank(CBTF_MRNet_netPtr));
#endif
mrnet_connected = 1;
pthread_cond_broadcast(&mrnet_connected_cond);
pthread_mutex_unlock(&mrnet_connected_mutex);
if (p != NULL) {
free(p);
}
return 1;
}
