Changeset 894a5f for src/comm/mpi/key.hpp

Timestamp:

Feb 2, 2012, 1:58:12 PM (14 years ago)

Author:

Julian Iseringhausen <isering@…>

Children:

32ff22

Parents:

01be70

Message:

Parallel performance update.

git-svn-id: ​https://svn.version.fz-juelich.de/scafacos/trunk@1314 5161e1c8-67bf-11de-9fd5-51895aff932f

File:

• src/comm/mpi/key.hpp (modified) (2 diffs)

src/comm/mpi/key.hpp

@@ -15 +15 @@
 #endif /* HAVE_MPI */
 
-#include <vector>
+#include <iostream>
+#include <list>
+
+#include "grid/grid.hpp"
 
 namespace VMG
@@ -26 +29 @@
 {
 
-class Key {
+class KeyStorage
+{
 public:
-  Key();
-  Key(const VMG::MPI::Key& other);
-  Key(const Grid& grid);
-  Key(const Grid& grid_1, const Grid& grid_2);
-  Key(const Index& i1, const Index& i2, const Index& i3);
+  KeyStorage(const Grid& grid) :
+    begin(grid.Global().BeginLocal()),
+    end(grid.Global().EndLocal()),
+    size_local(grid.Local().SizeTotal()),
+    size_global(grid.Global().SizeGlobal())
+  {}
 
-  void AddKey(const Grid& grid);
-  void AddKey(const Index& index);
-  void AddKey(const int& i);
-  void AddKey(const void* addr);
+  KeyStorage(const Index& begin, const Index& end, const Index& size_local, const Index& size_global) :
+    begin(begin),
+    end(end),
+    size_local(size_local),
+    size_global(size_global)
+  {}
 
-  bool operator<(const Key& other) const;
+  KeyStorage(const KeyStorage& other) :
+    begin(other.begin),
+    end(other.end),
+    size_local(other.size_local),
+    size_global(other.size_global)
+  {}
+
+  ~KeyStorage() {}
+
+  bool operator==(const KeyStorage& other) const
+  {
+    return this->begin == other.begin &&
+           this->end == other.end &&
+           this->size_local == other.size_local &&
+           this->size_global == other.size_global;
+  }
+
+  bool operator!=(const KeyStorage& other) const
+  {
+    return !(*this==other);
+  }
+
+  bool operator<(const KeyStorage& other) const
+  {
+    if (this->begin < other.begin) return true;
+    else if (this->begin != other.begin) return false;
+    else if (this->end < other.end) return true;
+    else if (this->end != other.end) return false;
+    else if (this->size_local < other.size_local) return true;
+    else if (this->size_local != other.size_local) return false;
+    else if (this->size_global < other.size_global) return true;
+    else return false;
+  }
 
 private:
-  std::vector<int> int_keys;
-  std::vector<const void*> addr_keys;
+  const Index begin, end, size_local, size_global;
+  const void* ptr;
+};
+
+class KeySorted {
+public:
+  KeySorted(const KeySorted& other)
+  {
+    std::list<KeyStorage>::const_iterator i;
+    this->keys.clear();
+    for (i=other.keys.begin(); i!=other.keys.end(); ++i)
+      this->keys.push_back(*i);
+  }
+
+  KeySorted(const Grid& grid)
+  {
+    keys.push_back(KeyStorage(grid));
+  }
+
+  KeySorted(const Grid& grid_1, const Grid& grid_2)
+  {
+    keys.push_back(KeyStorage(grid_1));
+    keys.push_back(KeyStorage(grid_2));
+    keys.sort();
+  }
+
+  KeySorted(const Index& begin, const Index& end, const Index& size_local, const Index& size_global)
+  {
+    keys.push_back(KeyStorage(begin, end, size_local, size_global));
+  }
+
+  ~KeySorted() {}
+
+  bool operator<(const KeySorted& other) const
+  {
+    if (this->keys.size() < other.keys.size()) return true;
+    if (this->keys.size() > other.keys.size()) return false;
+
+    std::list<KeyStorage>::const_iterator i1, i2;
+    for (i1=this->keys.begin(), i2=other.keys.begin();
+         i1!=this->keys.end(), i2!=other.keys.end();
+         ++i1, ++i2) {
+      if (*i1 < *i2) return true;
+      if (*i1 != *i2) return false;
+    }
+
+    return false;
+  }
+
+private:
+  std::list<KeyStorage> keys;
+};
+
+class KeyUnsorted {
+public:
+  KeyUnsorted(const KeyUnsorted& other)
+  {
+    std::list<KeyStorage>::const_iterator i;
+    this->keys.clear();
+    for (i=other.keys.begin(); i!=other.keys.end(); ++i)
+      this->keys.push_back(*i);
+  }
+
+  KeyUnsorted(const Grid& grid)
+  {
+    keys.push_back(KeyStorage(grid));
+  }
+
+  KeyUnsorted(const Grid& grid_1, const Grid& grid_2)
+  {
+    keys.push_back(KeyStorage(grid_1));
+    keys.push_back(KeyStorage(grid_2));
+  }
+
+  KeyUnsorted(const Index& begin, const Index& end, const Index& size_local, const Index& size_global)
+  {
+    keys.push_back(KeyStorage(begin, end, size_local, size_global));
+  }
+
+  ~KeyUnsorted() {}
+
+  bool operator<(const KeyUnsorted& other) const
+  {
+    if (this->keys.size() < other.keys.size()) return true;
+    if (this->keys.size() > other.keys.size()) return false;
+
+    std::list<KeyStorage>::const_iterator i1, i2;
+    for (i1=this->keys.begin(), i2=other.keys.begin();
+         i1!=this->keys.end(), i2!=other.keys.end();
+         ++i1, ++i2) {
+      if (*i1 < *i2) return true;
+      if (*i1 != *i2) return false;
+    }
+
+    return false;
+  }
+
+private:
+  std::list<KeyStorage> keys;
 };