* refactored MpiRequest

 * added missing files

cellular_automaton/wireworld_c++/CollectiveCommunicator.cpp

@@ -16,7 +16,7 @@ void CollectiveCommunicator::Communicate(State* model) {
 	                       );
 }
 
-Communicator::MpiRequest CollectiveCommunicator::AsyncCommunicate(State* model) {
+MpiRequest CollectiveCommunicator::AsyncCommunicate(State* model) {
 	if (commDistGraph_ == MPI_COMM_NULL)
 		MpiReportErrorAbort("Communicator not initialized");
 

cellular_automaton/wireworld_c++/CommunicationMode.hpp

+#pragma once
+
+#include <array>
+#include <tuple>
+
+enum class CommunicationMode {
+	Collective, //
+	P2P         //
+};
+
+constexpr std::array<std::pair<const char*, CommunicationMode>, 2> StringToCommunicationMode() {
+	return {{
+	    std::make_pair("Collective", CommunicationMode::Collective), //
+	    std::make_pair("P2P", CommunicationMode::P2P)                //
+	}};
+}

cellular_automaton/wireworld_c++/Communicator.cpp

@@ -4,19 +4,6 @@
 
 #include "Communicator.hpp"
 
-Communicator::MpiRequest::MpiRequest(DoubleVector<MPI_Request> reqs)
-    : reqs_(reqs) {}
-
-void Communicator::MpiRequest::Wait() {
-	MPI_Waitall(static_cast<int>(reqs_.size()), //
-	            reqs_.data(),                   //
-	            MPI_STATUSES_IGNORE);           //
-	finished = true;
-}
-Communicator::MpiRequest::~MpiRequest() {
-	if (!finished) { MpiReportErrorAbort("Forgot to Wait for MPI_Request"); }
-}
-
 // defines types and graph topology
 Communicator::Communicator(const MpiEnvironment& env, const Size& procsSize,
                            const Size& tileSize) {

cellular_automaton/wireworld_c++/Communicator.hpp

@@ -5,6 +5,7 @@
 
 #include "Configuration.hpp"
 #include "MpiEnvironment.hpp"
+#include "MpiRequest.hpp"
 #include "State.hpp"
 #include "Util.hpp"
 
@@ -17,28 +18,6 @@ class Communicator {
 	template <typename T>
 	using Vector = boost::container::static_vector<T, NoNeighbors>;
 
-  public:
-	// Life cycle handling for MPI_Requests
-	class MpiRequest { // TODO: unnest
-	  public:
-		template <typename T>
-		using DoubleVector =
-		    boost::container::static_vector<T, NoNeighbors * 2>;
-
-	  private:
-		DoubleVector<MPI_Request> reqs_;
-		bool finished{};
-
-	  public:
-		MpiRequest(DoubleVector<MPI_Request> reqs);
-		MpiRequest(const MpiRequest&) = default;
-		MpiRequest(MpiRequest&&) = default;
-		MpiRequest& operator=(const MpiRequest&) = default;
-		MpiRequest& operator=(MpiRequest&&) = default;
-		void Wait();
-		~MpiRequest();
-	};
-
   protected:
 	// data members for graph topology
 	Vector<int> neighbors_;

cellular_automaton/wireworld_c++/CommunicatorFactory.hpp

+#pragma once
+
+#include <array>
+#include <memory>
+#include <tuple>
+
+#include "CollectiveCommunicator.hpp"
+#include "CommunicationMode.hpp"
+#include "Configuration.hpp"
+#include "P2PCommunicator.hpp"
+#include "Tile.hpp"
+#include "Util.hpp"
+
+struct CommunicatorFactory {
+	static std::unique_ptr<Communicator> Create(Configuration cfg, const Tile& tile, const MpiEnvironment& env) {
+		switch (cfg.CommMode) {
+		case CommunicationMode::Collective:
+			return std::make_unique<CollectiveCommunicator>(env, cfg.Procs, tile.tileSize());
+		case CommunicationMode::P2P:
+			return std::make_unique<P2PCommunicator>(env, cfg.Procs, tile.tileSize());
+		default:
+			MpiReportErrorAbort("Unknown CommunicationMode");
+		}
+	}
+};

cellular_automaton/wireworld_c++/MpiRequest.hpp

+#pragma once
+
+#include <boost/container/static_vector.hpp>
+#include <mpi.h>
+
+class MpiRequest {
+	constexpr static std::size_t NoNeighbors{ 8 };
+
+  public:
+	template <typename T> using DoubleVector = boost::container::static_vector<T, NoNeighbors * 2>;
+
+  private:
+	DoubleVector<MPI_Request> reqs_;
+	bool finished{};
+
+  public:
+	MpiRequest(DoubleVector<MPI_Request> reqs) : reqs_(reqs) {}
+
+	MpiRequest(const MpiRequest&) = default;
+	MpiRequest(MpiRequest&&) = default;
+	MpiRequest& operator=(const MpiRequest&) = default;
+	MpiRequest& operator=(MpiRequest&&) = default;
+	void Wait() {
+		MPI_Waitall(static_cast<int>(reqs_.size()), //
+		            reqs_.data(),                   //
+		            MPI_STATUSES_IGNORE);           //
+		finished = true;
+	}
+	~MpiRequest() {
+		if (!finished) { MpiReportErrorAbort("Forgot to Wait for MPI_Request"); }
+	}
+};

cellular_automaton/wireworld_c++/P2PCommunicator.cpp

@@ -4,8 +4,8 @@ void P2PCommunicator::Communicate(State* model) {
 	AsyncCommunicate(model).Wait();
 }
 
-Communicator::MpiRequest P2PCommunicator::AsyncCommunicate(State* model) {
-	Communicator::MpiRequest::DoubleVector<MPI_Request> reqs;
+MpiRequest P2PCommunicator::AsyncCommunicate(State* model) {
+	MpiRequest::DoubleVector<MPI_Request> reqs;
 	for (std::size_t i{0}; i < neighbors_.size(); ++i) {
 		{
 			MPI_Request req;