* moved files to one diorectory

26f8e73d · Paul Heinzlreiter · f6fdcbb8 · 26f8e73d · 26f8e73d · 26f8e73d
Commit 26f8e73d authored 8 years ago by Paul Heinzlreiter
--- a/bh_tree_mpi/datastructures/BarnesHutTree.cpp
+++ b/bh_tree_mpi/datastructures/BarnesHutTree.cpp
--- a/bh_tree_mpi/datastructures/BarnesHutTree.hpp
+++ b/bh_tree_mpi/datastructures/BarnesHutTree.hpp
--- a/bh_tree_mpi/datastructures/Body.cpp
+++ b/bh_tree_mpi/datastructures/Body.cpp
--- a/bh_tree_mpi/datastructures/Body.hpp
+++ b/bh_tree_mpi/datastructures/Body.hpp
--- a/bh_tree_mpi/datastructures/Box.cpp
+++ b/bh_tree_mpi/datastructures/Box.cpp
--- a/bh_tree_mpi/datastructures/Box.hpp
+++ b/bh_tree_mpi/datastructures/Box.hpp
--- a/bh_tree_mpi/parallelization/MpiBodyComm.cpp
+++ b/bh_tree_mpi/parallelization/MpiBodyComm.cpp
--- a/bh_tree_mpi/parallelization/MpiBodyComm.hpp
+++ b/bh_tree_mpi/parallelization/MpiBodyComm.hpp
--- a/bh_tree_mpi/parallelization/MpiSimulation.cpp
+++ b/bh_tree_mpi/parallelization/MpiSimulation.cpp
--- a/bh_tree_mpi/parallelization/MpiSimulation.hpp
+++ b/bh_tree_mpi/parallelization/MpiSimulation.hpp
--- a/bh_tree_mpi/datastructures/Node.cpp
+++ b/bh_tree_mpi/datastructures/Node.cpp
--- a/bh_tree_mpi/datastructures/Node.hpp
+++ b/bh_tree_mpi/datastructures/Node.hpp
--- a/bh_tree_mpi/PthreadSimulation.cpp
+++ b/bh_tree_mpi/PthreadSimulation.cpp
+#include "PthreadSimulation.hpp"
+
+namespace nbody {
+	PthreadSimulation::PthreadSimulation() {
+		this->correctState = -1;
+	}
+
+	PthreadSimulation::~PthreadSimulation() {
+	}
+
+	void PthreadSimulation::cleanup() {
+
+	}
+
+	int PthreadSimulation::getNumberOfProcesses() {
+		return this->threads.size();
+	}
+
+	int PthreadSimulation::getProcessId() {
+		vector<pthread_t>::iterator it = this->threads.begin();
+		int id = 0;
+
+		while (*it != pthread_self() && it != this->threads.end()) {
+			id++;
+			it++;
+		}
+		if (it != this->threads.end()) {
+			return id;
+		} else {
+			return -1;
+		}
+	}
+
+	bool PthreadSimulation::readInputData(string filename) {
+		this->bodies = Tree::dubinskiParse(filename);
+		return !this->bodies.empty();
+	}
+
+	void PthreadSimulation::runStep() {
+
+	}
+
+}
--- a/bh_tree_mpi/PthreadSimulation.hpp
+++ b/bh_tree_mpi/PthreadSimulation.hpp
+#ifndef PTHREAD_SIMULATION_HPP
+#define PTHREAD_SIMULATION_HPP
+
+#include "../datastructures/BarnesHutTree.hpp"
+#include <vector>
+#include <pthread.h>
+
+namespace nbody {
+	class PthreadSimulation {
+	protected:
+		int correctState;
+		vector<Body> bodies;
+		BarnesHutTree tree;
+		vector<pthread_t> threads;
+	public:
+		PthreadSimulation();
+		virtual ~PthreadSimulation();
+		virtual void cleanup() = 0;
+		virtual int getNumberOfProcesses() = 0;
+		virtual int getProcessId() = 0;
+		virtual bool readInputData(string filename) = 0;
+		virtual void runStep() = 0;
+	};
+}
+
+#endif
--- a/bh_tree_mpi/ReadWriteLock.cpp
+++ b/bh_tree_mpi/ReadWriteLock.cpp
+#include "ReadWriteLock.hpp"
+
+namespace nbody {
+	ReadWriteLock::ReadWriteLock() {
+		pthread_mutex_init(&this->mutex, NULL);
+		pthread_rwlock_init(&this->rwlock, NULL);
+		this->owner = NULL;
+	}
+
+	ReadWriteLock::~ReadWriteLock() {
+		pthread_mutex_destroy(&this->mutex);
+		pthread_rwlock_destroy(&this->rwlock);
+	}
+
+	bool ReadWriteLock::readLock(pthread_t* myThread) {
+		bool result;
+
+		pthread_mutex_lock(&this->mutex);
+		result = (pthread_rwlock_tryrdlock(&this->rwlock) == 0);
+		if (result) {
+			this->owner = myThread;
+		}
+		pthread_mutex_unlock(&this->mutex);
+		return result;
+	}
+
+	bool ReadWriteLock::writeLock(pthread_t* myThread) {
+		bool result;
+
+		pthread_mutex_lock(&this->mutex);
+		result = (pthread_rwlock_trywrlock(&this->rwlock) == 0);
+		if (result) {
+			this->owner = myThread;
+		}
+		pthread_mutex_unlock(&this->mutex);
+		return result;
+	}
+
+	bool ReadWriteLock::upgradeToWriteLock(pthread_t* myThread) {
+		bool result = false;
+
+		pthread_mutex_lock(&this->mutex);
+		if (this->owner == myThread) {
+			pthread_rwlock_unlock(&this->rwlock);
+			pthread_rwlock_wrlock(&this->rwlock);
+			result = true;
+		}
+		pthread_mutex_unlock(&this->mutex);
+		return result;
+	}
+
+	bool ReadWriteLock::downgradeToReadLock(pthread_t* myThread) {
+		bool result = false;
+
+		pthread_mutex_lock(&this->mutex);
+		if (this->owner == myThread) {
+			pthread_rwlock_unlock(&this->rwlock);
+			pthread_rwlock_rdlock(&this->rwlock);
+			result = true;
+		}
+		pthread_mutex_unlock(&this->mutex);
+		return result;
+	}
+
+	bool ReadWriteLock::unLock(pthread_t* myThread) {
+		bool result = false;
+
+		pthread_mutex_lock(&this->mutex);
+		if (this->owner == myThread) {
+			pthread_rwlock_unlock(&this->rwlock);
+			this->owner = NULL;
+			result = true;
+		}
+		pthread_mutex_unlock(&this->mutex);
+		return result;
+	}
+}
--- a/bh_tree_mpi/ReadWriteLock.hpp
+++ b/bh_tree_mpi/ReadWriteLock.hpp
+#ifndef READ_WRITE_LOCK
+#define READ_WRITE_LOCK
+
+#include <pthread.h>
+
+namespace nbody {
+	class ReadWriteLock {
+	protected:
+		pthread_mutex_t mutex;
+		pthread_rwlock_t rwlock;
+		pthread_t* owner;
+	public:
+		ReadWriteLock();
+		virtual ~ReadWriteLock();
+		virtual bool readLock(pthread_t* myThread);
+		virtual bool writeLock(pthread_t* myThread);
+		virtual bool upgradeToWriteLock(pthread_t* myThread);
+		virtual bool downgradeToReadLock(pthread_t* myThread);
+		virtual bool unLock(pthread_t* myThread);
+	};
+}
+
+#endif
--- a/bh_tree_mpi/parallelization/Simulation.cpp
+++ b/bh_tree_mpi/parallelization/Simulation.cpp
--- a/bh_tree_mpi/parallelization/Simulation.hpp
+++ b/bh_tree_mpi/parallelization/Simulation.hpp
--- a/bh_tree_mpi/datastructures/Tree.cpp
+++ b/bh_tree_mpi/datastructures/Tree.cpp
--- a/bh_tree_mpi/datastructures/Tree.hpp
+++ b/bh_tree_mpi/datastructures/Tree.hpp