#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)

	~SimpleBroadcastObject ()

T	get (int tag, const int expected=-1)

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 44 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

Definition at line 65 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 85 of file BroadcastObject.h.

85 { }

Member Function Documentation

◆ get()

template<class T>

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

inline

Definition at line 96 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);
         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];
         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 126 of file BroadcastObject.h.

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

◆ getSize()

template<class T>

int SimpleBroadcastObject< T >::getSize ( )

inline

Definition at line 123 of file BroadcastObject.h.

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

◆ getTaggedSize()

template<class T>

int SimpleBroadcastObject< T >::getTaggedSize ( )

inline

Definition at line 129 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 132 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);
         std::map<int, T>* data = std::any_cast<std::map<int, T>*>(nodeBroadcast->data[id]);
         data->insert({tag, t});
         nodeBroadcast->current[id][tag] = 0;
         CmiUnlock(nodeBroadcast->lock);
       } else {
         BroadcastMgr::Object()->send(*this, tag, (void*)(&t), sizeof(T));
       }
     }