MPIProxy クラスのインスタンスを 1 つだけ持つ Singleton クラスがあります (そうしないと、多くの構造が作成されるため)。
単一の MPIProxy クラスを作成するには、次の typedef を使用します。
typedef Singleton<MPIProxy_> MPIProxySingleton;
ただし、インスタンスにアクセスするには、次のコードが必要です。
int myrank = MPIProxySingleton::instance().getRank();
クライアントがMPIProxySingleton::instance().xy()単にMPIProxy.xy(). .xy は MPIProxy_ クラスの関数です。上記のコードは次のようになります。
int myrank = MPIProxy.getRank();
私は次のことを試しました：
typedef MPIProxySingleton::instance() MPIProxy;
ただし、これによりコンパイルエラーが発生します。
/Users/david/Desktop/GSOC/miind/miind/./libs/MPILib/include/utilities/MPIProxy.hpp:158:31: error: C++ requires a type specifier for all declarations
typedef Singleton<MPIProxy_>::instance() MPIProxy;
~~~~~~~ ^
/Users/david/Desktop/GSOC/miind/miind/./libs/MPILib/include/utilities/MPIProxy.hpp:158:41: error: expected ';' after top level declarator
typedef Singleton<MPIProxy_>::instance() MPIProxy;
私のSingletonクラスのコードは次のとおりです。
/** Singleton holder template class.
* Template class to create singletons. A singleton instance of class
* MyType is created and accessed using
* \code
* typedef Singleton<MyType> MySingletonType;
* MyType& myRef = MySingletonType::instance()
* // ... do something ...
* \endcode
*/
template<class T>
class Singleton
{
public:
// disallow creation, copying and assignment
/** Deleted constructor to disallow explicit construction.
* Is not defined.
*/
Singleton()=delete;
/** Deleted copy constructor to disallow explicit copying.
* Is not defined.
* @param S A singleton object.
*/
Singleton(const Singleton& S)=delete;
/** Deleted assignment operator to disallow explicit assignment.
* @param S A singleton object.
* @return The current singleton.
*/
Singleton& operator=(const Singleton& S)=delete;
/** Return a reference to the only instance of \c Singleton<T>.
* @return A reference to the instance of the object.
*/
static T& instance();
/** Destructor.
*/
~Singleton();
private:
/** Create method. Creates the singleton instance (a Meyers singleton, ie.
* a function static object) upon the first call to \c instance().
*/
static void create();
/** Pointer to the instance.
*/
static T* pInstance_;
/** Status of the singleton. True if the singleton was destroyed.
*/
static bool destroyed_;
};
/** Returns the unique instance of class T. If it was already
* deleted an exception is thrown. If the class T was never used
* before a new instance is generated.
*
* @return Unique instance of class T
*/
template<class T> T& Singleton<T>::instance()
{
if (!pInstance_) {
if (destroyed_) {
// dead reference
throw Exception("The instance was already destroyed");
} else {
// initial creation
create();
}
}
return *pInstance_;
}
template<class T> Singleton<T>::~Singleton()
{
pInstance_ = 0;
destroyed_ = true;
}
template<class T> void Singleton<T>::create()
{
static T theInstance;
pInstance_ = &theInstance;
}
template<class T> T* Singleton<T>::pInstance_ = 0;
template<class T> bool Singleton<T>::destroyed_ = false;
そして、ここに私の MPIProxy_ クラスのヘッダーがあります
class MPIProxy_ {
public:
/**
* destructor
*/
virtual ~MPIProxy_();
/**
* wrapper method to return the process id, if mpi is disabled it returns 0
* @return the world rank of a process
*/
int getRank() const;
/**
* wrapper method to return the size, if MPI is disabled it returns 1
* @return
*/
int getSize() const;
/**
* wrapper for mpi barrier
*/
void barrier();
/**
* waits until all request stored in the vector _mpiStatus are finished
*/
void waitAll();
/**
* Broadcast the value from root
* @param value The value to be broadcast
* @param root The root process
*/
template<typename T>
void broadcast(T& value, int root);
/**
* asynchronous receive operation the mpi status is stored in _mpiStatus
* @param source The source of the message
* @param tag The tag of the message
* @param value The value received
*/
template<typename T>
void irecv(int source, int tag, T& value) const;
/**
* asynchronous send operation the mpi status is stored in _mpiStatus
* @param dest The destination of the message
* @param tag The tag of the message
* @param value The value sended
*/
template<typename T>
void isend(int dest, int tag, const T& value) const;
private:
/**
* Declare the Singleton class a friend to allow construction of the MPIProxy_ class
*/
friend class Singleton<MPIProxy_>;
/**
* constructor sets the MPI rank and size
*/
MPIProxy_();
#ifdef ENABLE_MPI
/**
* stores the mpi statuses
*/
static std::vector<boost::mpi::request> _mpiStatus;
#endif
/**
* storage of the rank to avoid function calls
*/
static int _rank;
/**
* storage of the size to avoid function calls
*/
static int _size;
};
template<typename T>
void MPIProxy_::broadcast(T& value, int root) {
#ifdef ENABLE_MPI
mpi::communicator world;
boost::mpi::broadcast(world, value, root);
#endif
}
template<typename T>
void MPIProxy_::irecv(int source, int tag, T& value) const {
#ifdef ENABLE_MPI
mpi::communicator world;
_mpiStatus.push_back(world.irecv(source, tag, value));
#else
MPILib::utilities::Exception("MPI Code called from serial code in irecv");
#endif
}
template<typename T>
void MPIProxy_::isend(int dest, int tag, const T& value) const {
#ifdef ENABLE_MPI
mpi::communicator world;
_mpiStatus.push_back(world.isend(dest, tag, value));
#else
MPILib::utilities::Exception("MPI Code called from serial code in isend");
#endif
}
typedef Singleton<MPIProxy_> MPIProxySingleton;
//typedef MPIProxySingleton::instance() MPIProxy;