#include <BroadcastObject.h>

Inheritance diagram for SimpleBroadcastObject< T >:

Public Member Functions
	SimpleBroadcastObject (int id_in, const LDObjHandle h=0, NodeBroadcast nodeBroadcastIn=0, const bool useSharedIfPossible=false)
	Creates a new SimpleBroadcastObject with given id. More...

	~SimpleBroadcastObject ()

T	get (int tag, const int expected=-1)
	Attempts to retrieve a previously published value for a given tag and id. More...

int	getSize ()

int	getBcastSize ()

int	getTaggedSize ()

void	publish (int tag, const T &t)

Public Member Functions inherited from BroadcastClient
	BroadcastClient (int id)

	~BroadcastClient ()

void	awaken (int id, int tag)

Public Attributes
const LDObjHandle *	ldObjPtr

bool	useShared = false

int	id = -1

NodeBroadcast *	nodeBroadcast

Public Attributes inherited from BroadcastClient
int	id

Additional Inherited Members
Protected Member Functions inherited from BroadcastClient
void	suspendFor (int tag)

Protected Attributes inherited from BroadcastClient
int	suspended

int	waitForTag

CthThread	thread

Detailed Description

template<class T>
class SimpleBroadcastObject< T >

Definition at line 53 of file BroadcastObject.h.

Constructor & Destructor Documentation

◆ SimpleBroadcastObject()

template<class T>

SimpleBroadcastObject< T >::SimpleBroadcastObject	(	int	id_in,
		const LDObjHandle *	h = `0`,
		NodeBroadcast *	nodeBroadcastIn = `0`,
		const bool	useSharedIfPossible = `false`
	)

inline

Creates a new SimpleBroadcastObject with given id.

NodeBroadcast is used by the shared memory backend and the same pointer should be given to all objects on all Pes.

Even if we are using the shared memory backend, some of the broadcast objects must still use the charm++ backend since they are used for barriers, like scriptBarrier. The shared memory backend must be explicitly enabled using the useSharedIfPossible parameter

Definition at line 74 of file BroadcastObject.h.

       : BroadcastClient(id_in), ldObjPtr(h), nodeBroadcast(nodeBroadcastIn), id(id_in) {
       if ( sizeof(T) > BCASTMSGSIZE ) {
         NAMD_bug("SimpleBroadcastObject instantiated on class larger than BCASTMSGSIZE");
       }
 
       if (nodeBroadcast != 0) {
         useShared = Node::Object()->simParameters->GPUresidentSingleProcessMode && useSharedIfPossible;
 
         if (useShared) {
           // Add a map for this broadcast object if needed
           CmiLock(nodeBroadcast->lock);
           if (nodeBroadcast->data.find(id) == nodeBroadcast->data.end()) {
             nodeBroadcast->data[id] = new std::map<int, T>();
           }
           CmiUnlock(nodeBroadcast->lock);
         }
       }
     }

◆ ~SimpleBroadcastObject()

template<class T>

SimpleBroadcastObject< T >::~SimpleBroadcastObject ( )

inline

Definition at line 94 of file BroadcastObject.h.

94 { }

Member Function Documentation

◆ get()

template<class T>

T SimpleBroadcastObject< T >::get	(	int	tag,
		const int	expected = `-1`
	)

inline

Attempts to retrieve a previously published value for a given tag and id.

This function has slightly different behavior between the shared memory and charm++ backends. The Charm++ backend will suspend and wait if it attempts to retrieve an unpublished tag, while the shared memory backend will throw an error. The shared memory backend also should be given the expected number of retrievals so the data can be removed

Definition at line 105 of file BroadcastObject.h.

Referenced by Sequencer::adaptTempUpdate(), Sequencer::algorithm(), Controller::algorithm(), Sequencer::berendsenPressure(), Sequencer::berendsenPressure_SOA(), Sequencer::correctMomentum(), Sequencer::langevinPiston(), Sequencer::langevinPiston_SOA(), Sequencer::minimize(), Sequencer::multigratorPressure(), Sequencer::multigratorTemperature(), Sequencer::rescaleaccelMD(), Sequencer::rescaleVelocities(), Sequencer::stochRescaleVelocities(), Sequencer::stochRescaleVelocities_SOA(), Sequencer::submitCollections(), Sequencer::tcoupleVelocities(), and Sequencer::traceBarrier().

                                             {
       T tmp;
       if (useShared) {
         CmiLock(nodeBroadcast->lock);
         // Attempt to retrieve data from map
         if (nodeBroadcast->data.find(id) == nodeBroadcast->data.end()) {
           NAMD_bug("SimpleBroadcastObject: Did not find id");
         }
         std::map<int, T>* data = std::any_cast<std::map<int, T>*>(nodeBroadcast->data[id]);
         if (data->find(tag) == data->end()) {
           NAMD_bug("SimpleBroadcastObject: Did not find tag");
         } 
         tmp = (*data)[tag];
         // Check if the data has been retrieved the expected number of times, if so, delete it.
         nodeBroadcast->current[id][tag]++;
         if (nodeBroadcast->current[id][tag] == expected) {
           data->erase(tag);
           nodeBroadcast->current[id].erase(tag);
         }
         CmiUnlock(nodeBroadcast->lock);
       } else {
         if ( ldObjPtr ) LdbCoordinator::Object()->pauseWork(*ldObjPtr);
         while ( BroadcastMgr::Object()->getbuf(*this, tag, (void*)(&tmp)) < 0 ) {
           suspendFor(tag);
         }
         if ( ldObjPtr ) LdbCoordinator::Object()->startWork(*ldObjPtr);
       }
       return tmp;
     }

◆ getBcastSize()

template<class T>

int SimpleBroadcastObject< T >::getBcastSize ( )

inline

Definition at line 137 of file BroadcastObject.h.

                        {
     return BroadcastMgr::Object()->boidBroadcastSize();
   }

◆ getSize()

template<class T>

int SimpleBroadcastObject< T >::getSize ( )

inline

Definition at line 134 of file BroadcastObject.h.

                 {
     return BroadcastMgr::Object()->boidSize();
   }

◆ getTaggedSize()

template<class T>

int SimpleBroadcastObject< T >::getTaggedSize ( )

inline

Definition at line 140 of file BroadcastObject.h.

                           {
     return BroadcastMgr::Object()->boidTaggedMsgSize();
   }

◆ publish()

template<class T>

void SimpleBroadcastObject< T >::publish	(	int	tag,
		const T &	t
	)

inline

Definition at line 143 of file BroadcastObject.h.

Referenced by Controller::adaptTempUpdate(), Controller::berendsenPressure(), Controller::correctMomentum(), Controller::langevinPiston1(), Controller::minimize(), Controller::monteCarloPressure_accept(), Controller::monteCarloPressure_prepare(), Controller::multigratorPressure(), Controller::multigratorTemperature(), Controller::printEnergies(), Controller::rescaleaccelMD(), Controller::rescaleVelocities(), Controller::resumeAfterTraceBarrier(), Controller::stochRescaleVelocities(), and Controller::tcoupleVelocities().

                                       {
       if (useShared) {
         CmiLock(nodeBroadcast->lock);
         // Insert new data into map.
         std::map<int, T>* data = std::any_cast<std::map<int, T>*>(nodeBroadcast->data[id]);
         data->insert({tag, t});
         // Reset retrieval counter to 0.
         nodeBroadcast->current[id][tag] = 0;
         CmiUnlock(nodeBroadcast->lock);
       } else {
         BroadcastMgr::Object()->send(*this, tag, (void*)(&t), sizeof(T));
       }
     }