Improved LatticeAccess

models/PDE/wave2D/conf.mk

@@ -0,0 +1 @@
+OPT="autosym"

src/Consts.h.Rt

@@ -16,10 +16,8 @@
 
 #ifdef CROSS_CPU
   #define MAX_THREADS 1
-  #define X_BLOCK 1
 #else
-  #define MAX_THREADS 512
-  #define X_BLOCK 32
+  #define MAX_THREADS 128
 #endif
 
 #define PART_MAR <?%f PartMargin ?>

src/Dynamics.h.Rt

@@ -4,4 +4,4 @@
   for (n in c_table_decl(unique(c(Density$name,Fields$name)))) { ?>
     real_t <?%s n ?>; <?R
   } ?>
-    flag_t NodeType; ///< Node flag/type
+

src/Geometry.cpp.Rt

@@ -1132,6 +1132,7 @@ int Geometry::Draw(pugi::xml_node & node)
 
         #else
             error("You need to compile PYTHON support for this geometry element");
+	    return -1;
         #endif
 
 	} else if (strcmp(n.name(), "STL") == 0) {

src/GetThreads.cpp

@@ -0,0 +1,45 @@
+#include "GetThreads.h"
+#ifdef HAS_CXXABI_H
+    #include <cxxabi.h>
+#endif
+#include <algorithm>
+
+void ThreadNumberCalculatorBase::InitAll() {
+    list_t list = List();
+    for (type* ptr : list) ptr->Init();
+    std::sort(list.begin(), list.end(), compare);
+    for (type* ptr : list) ptr->print();
+}
+
+ThreadNumberCalculatorBase::ThreadNumberCalculatorBase() {
+    List().push_back(this);
+}
+
+void ThreadNumberCalculatorBase::print() {
+    if (thr.x * thr.y < maxthr) {
+        notice( "  %3dx%-3d  | %s --- Reduced from maximum %d\n", thr.x, thr.y, name.c_str(), maxthr);
+    } else {
+        output( "  %3dx%-3d  | %s\n", thr.x, thr.y, name.c_str());
+    }
+}
+
+std::string cxx_demangle(std::string str) {
+#ifdef HAS_CXXABI_H
+    int status;
+    char *c_ret = abi::__cxa_demangle(str.c_str(), 0, 0, &status);
+    if (c_ret != NULL) {
+        std::string ret(c_ret);
+        free(c_ret);
+        if (status == 0) return ret;
+    }
+#endif
+    return str;
+}
+
+int InitDim() {
+    MPI_Barrier(MPMD.local);
+    output( "  Threads  |      Action\n");
+    ThreadNumberCalculatorBase::InitAll();
+    MPI_Barrier(MPMD.local);
+    return 0;
+}

src/GetThreads.h

@@ -0,0 +1,77 @@
+#include "Global.h"
+#include <typeinfo>
+#include "cross.h"
+
+template <class E> CudaGlobalFunction void Kernel();
+
+std::string cxx_demangle(std::string str);
+
+inline int ceiling_div(const int & x, const int & y) {
+  return x / y + (x % y != 0);
+}
+
+/// Get maximal number of threads for all the kernels on runtime
+template < class T > int GetThreads() {
+	dim3 ret;
+	CudaFuncAttributes * attr = new CudaFuncAttributes;
+	CudaFuncGetAttributes(attr, Kernel<T>) ;
+	debug1( "[%d] Constant mem:%ld\n", D_MPI_RANK, attr->constSizeBytes);
+	debug1( "[%d] Local    mem:%ld\n", D_MPI_RANK, attr->localSizeBytes);
+	debug1( "[%d] Max  threads:%d\n", D_MPI_RANK, attr->maxThreadsPerBlock);
+	debug1( "[%d] Reg   Number:%d\n", D_MPI_RANK, attr->numRegs);
+	debug1( "[%d] Shared   mem:%ld\n", D_MPI_RANK, attr->sharedSizeBytes);
+	return attr->maxThreadsPerBlock;
+}
+
+class ThreadNumberCalculatorBase {
+  typedef ThreadNumberCalculatorBase type;
+  typedef std::vector< type* > list_t;
+  static inline list_t& List() {
+    static list_t list;
+    return list;
+  }
+  static inline bool compare ( const type* a, const type* b ) { return a->name < b->name; }
+  protected:
+  dim3 thr;
+  unsigned int maxthr;
+  std::string name;
+  public:
+  static void InitAll();
+  ThreadNumberCalculatorBase();
+  virtual void Init() = 0;
+  inline dim3 threads() { return thr; }
+  void print();
+};
+
+template < class T > class ThreadNumberCalculator : public ThreadNumberCalculatorBase {
+  public:
+  virtual void Init() {
+    name = cxx_demangle(typeid(T).name());
+    maxthr = GetThreads< T >();
+    thr.z = 1;
+    int val = maxthr;
+    if (maxthr < X_BLOCK) {
+      thr.x = maxthr;
+      thr.y = 1;
+    } else {
+      if (val > MAX_THREADS) {
+        val = MAX_THREADS;
+      }
+      thr.x = X_BLOCK;
+      thr.y = val/X_BLOCK;
+    }
+  };
+};
+
+template < class T > class ThreadNumber {
+  typedef ThreadNumberCalculator< T > calc_t;
+  static calc_t calc;
+  public:
+  static inline dim3 threads() { return calc.threads(); }
+};
+
+template < class T > ThreadNumberCalculator<T> ThreadNumber<T>::calc;
+
+/// Initialize Thread/Block number variables
+int InitDim();
+