diff --git a/backends/kernels/config/config.hpp b/backends/kernels/config/config.hpp
index 2393a20349..9ce519c583 100644
--- a/backends/kernels/config/config.hpp
+++ b/backends/kernels/config/config.hpp
@@ -67,7 +67,11 @@ private:
    bool nvvp=false;
    // *************************************************************************
 private:
-   config() {}
+   config()
+#ifdef __NVCC__
+      :cuda(true)
+#endif
+   {}
    config(config const&);
    void operator=(config const&);
    // *************************************************************************
diff --git a/backends/kernels/engine/device.cpp b/backends/kernels/engine/device.cpp
index e6c45d22b0..758d414bb5 100644
--- a/backends/kernels/engine/device.cpp
+++ b/backends/kernels/engine/device.cpp
@@ -33,6 +33,10 @@ device::~device() {}
 bool device::hasSeparateMemorySpace()
 {
   push();
+  if (mfem::kernels::config::Get().Cuda()){
+     pop();
+     return true;
+  }
   pop();
   return false;
 }
diff --git a/backends/kernels/engine/memory.cpp b/backends/kernels/engine/memory.cpp
index 7660462cb0..a832e95414 100644
--- a/backends/kernels/engine/memory.cpp
+++ b/backends/kernels/engine/memory.cpp
@@ -46,14 +46,14 @@ size_t memory::size() const
 void memory::copyFrom(memory &src, size_t b) const {
    push();
    //memcpy(data,src,b);
-   mfem::kernels::kmemcpy::rDtoH(data,src,b);
+   mfem::kernels::kmemcpy::rHtoD(data,src,b);
    pop();
 }
 void memory::copyFrom(memory &src)
 {
    push();
    //memcpy(data,src,bytes);
-   mfem::kernels::kmemcpy::rDtoH(data,src,bytes);
+   mfem::kernels::kmemcpy::rHtoD(data,src,bytes);
    pop();
 }
 
@@ -61,13 +61,15 @@ void memory::copyFrom(memory &src)
 void memory::copyFrom(const void *src, size_t b) const {
    push();
    //memcpy(data,src,b);
-   mfem::kernels::kmemcpy::rDtoH(data,src,b);
+   mfem::kernels::kmemcpy::rHtoD(data,src,b);
    pop();
 }
 void memory::copyFrom(const void *src){
    push();
    //memcpy(data,src,bytes);
-   mfem::kernels::kmemcpy::rDtoH(data,src,bytes);
+   assert(data);
+   assert(src);
+   mfem::kernels::kmemcpy::rHtoD(data,src,bytes);
    pop();
 }
 
@@ -75,14 +77,14 @@ void memory::copyFrom(const void *src){
 void memory::copyTo(void *dest, size_t b) const {
    push();
    //memcpy(dest,data,b);
-   mfem::kernels::kmemcpy::rHtoD(dest,data,b);
+   mfem::kernels::kmemcpy::rDtoH(dest,data,b);
    pop();
  }
 void memory::copyTo(void *dest)
 {
    push();
    //memcpy(dest,data,bytes);
-   mfem::kernels::kmemcpy::rHtoD(dest,data,bytes);
+   mfem::kernels::kmemcpy::rDtoH(dest,data,bytes);
    pop();
 }
 
diff --git a/backends/kernels/fem/fespace.cpp b/backends/kernels/fem/fespace.cpp
index b28107bc60..eecf768c12 100644
--- a/backends/kernels/fem/fespace.cpp
+++ b/backends/kernels/fem/fespace.cpp
@@ -33,6 +33,7 @@ kFiniteElementSpace(const Engine& e,
      indices(localDofs, GetNE()),
      map(localDofs, GetNE()) {
    push(PowderBlue);
+   dbg("\033[7m[kFiniteElementSpace]");
    const mfem::FiniteElement& fe = *(fes->GetFE(0));
    const mfem::TensorBasisElement* el =
       dynamic_cast<const mfem::TensorBasisElement*>(&fe);
@@ -58,7 +59,7 @@ kFiniteElementSpace(const Engine& e,
          ++h_offsets[gid + 1];
       }
    }
-   // Aggregate to find offsets for each global dof
+   dbg("Aggregate to find offsets for each global dof");
    for (int i = 1; i <= globalDofs; ++i) {
       h_offsets[i] += h_offsets[i - 1];
    }
@@ -83,11 +84,14 @@ kFiniteElementSpace(const Engine& e,
    }
    h_offsets[0] = 0;
 
+   dbg("offsets, indices copy");
    offsets = h_offsets;
    indices = h_indices;
    map = h_map;
 
+   dbg("R");
    const mfem::SparseMatrix* R = fes->GetRestrictionMatrix();
+   dbg("P");
    const mfem::Operator* P = fes->GetProlongationMatrix();
 
    if (!P) {
@@ -118,15 +122,21 @@ kFiniteElementSpace(const Engine& e,
       }
    }
 
+   dbg("reorderIndices");
    reorderIndices = ::new kernels::array<int>(2*trueCount);
+   dbg("*=h");   
    *reorderIndices = h_reorderIndices;
-  
+
+   dbg("restrictionOp");
    restrictionOp = new kernels::RestrictionOperator(KernelsVLayout(),
                                                     KernelsTrueVLayout(),
                                                     *reorderIndices);
+   
+   dbg("ProlongationOperator");
    prolongationOp = new kernels::ProlongationOperator(KernelsTrueVLayout(),
                                                       KernelsVLayout(),
                                                       P);
+   dbg("done");
    pop();
 }
 
diff --git a/backends/kernels/fem/geom.cpp b/backends/kernels/fem/geom.cpp
index 5eb7d2f522..c8f81a4307 100644
--- a/backends/kernels/fem/geom.cpp
+++ b/backends/kernels/fem/geom.cpp
@@ -40,8 +40,8 @@ kGeometry::~kGeometry()
 // * kGeometry Get: use this one to fetch nodes from vector Sx
 // *****************************************************************************
 kGeometry* kGeometry::Get(kFiniteElementSpace& fes,
-                                      const IntegrationRule& ir,
-                                      const kvector& Sx)
+                          const IntegrationRule& ir,
+                          const kvector& Sx)
 {
    push();
    const Mesh *mesh = fes.GetFESpace()->GetMesh();
diff --git a/backends/kernels/general/array.cpp b/backends/kernels/general/array.cpp
index aee348f108..060782b22d 100644
--- a/backends/kernels/general/array.cpp
+++ b/backends/kernels/general/array.cpp
@@ -63,12 +63,14 @@ int Array::ResizeData(const Layout *lt, std::size_t item_size)
    const std::size_t new_bytes = lt->Size()*item_size;
    if (data.size() < new_bytes )
    {
+      dbg("Alloc");
       data = lt->Alloc(new_bytes);
       slice = data;
       // If memory allocation fails - an exception is thrown.
    }
    else if (slice.size() != new_bytes)
    {
+      dbg("slice");
       slice = data.slice(0, new_bytes);
    }
    pop();
@@ -78,12 +80,12 @@ int Array::ResizeData(const Layout *lt, std::size_t item_size)
 // *****************************************************************************
 void *Array::DoPullData(void *buffer, std::size_t item_size)
 {
+   push();
    if (!slice.getDevice().hasSeparateMemorySpace())
    {
       pop();
       return slice.ptr();
    }
-   push();
    if (buffer)
    {
       slice.copyTo(buffer);
diff --git a/backends/kernels/general/karray.hpp b/backends/kernels/general/karray.hpp
index f725c39fa5..fdaf9eaecd 100644
--- a/backends/kernels/general/karray.hpp
+++ b/backends/kernels/general/karray.hpp
@@ -39,13 +39,13 @@ public:
    array():data(NULL),sz(0),d{0,0,0,0} {}
    array(const size_t x) {allocate(x);}
    array(const size_t x,const size_t y) {allocate(x,y);}
-   array(const array<T,true> &r)
+   /*array(const array<T,true> &r)
    {
       //push();
       allocate(r.d[0], r.d[1], r.d[2], r.d[3]);
       memcpy(data,r.GetData(),r.bytes());
       //pop();
-   }
+      }
    array& operator=(const array<T,true> &r)
    {
       //push();
@@ -53,14 +53,14 @@ public:
       memcpy(data,r.GetData(),r.bytes());
       //pop();
       return *this;
-   }
+      }*/
    array& operator=(mfem::Array<T> &a)
    {
       //push();
       kmemcpy::rHtoD(data,a.GetData(),a.Size()*sizeof(T));
       //pop();
       return *this;
-   }
+      }
    ~array() {/*dbp("\033[32m[~i");*/ kmalloc<T>::operator delete (data);}
    inline size_t* dim() { return &d[0]; }
    inline T* ptr() { return data; }
@@ -115,13 +115,13 @@ private:
 public:
    array():data(NULL),sz(0),d{0,0,0,0} {}
    array(const size_t d0) {allocate(d0);}
-   array(const array<T,false> &r)
+   /*array(const array<T,false> &r)
    {
       //push();
       allocate(r.d[0], r.d[1], r.d[2], r.d[3]);
       memcpy(data,r.GetData(),r.bytes());
       //pop();
-   }
+      }
    array& operator=(const array<T,true> &r)
    {
       //push();
@@ -129,7 +129,7 @@ public:
       memcpy(data,r.GetData(),r.bytes());
       //pop();
       return *this;
-   }
+      }*/
    array& operator=(mfem::Array<T> &a)
    {
       //push();
diff --git a/backends/kernels/general/malloc.hpp b/backends/kernels/general/malloc.hpp
index 3f40c3a85e..7f1ffedcef 100644
--- a/backends/kernels/general/malloc.hpp
+++ b/backends/kernels/general/malloc.hpp
@@ -34,17 +34,23 @@ template<class T> struct kmalloc: public kmemcpy
    inline void* operator new (size_t n, bool lock_page = false)
    {
       dbp("+]\033[m");
-      if (!config::Get().Cuda()) { return ::new T[n]; }
+      if (!config::Get().Cuda()) {
+         assert(false);
+         dbg("\033[31;1m>!Cuda new");
+         return ::new T[n];
+      }
 #ifdef __NVCC__
       void *ptr;
       push(new,Purple);
       if (!config::Get().Uvm())
       {
+         dbg("\033[31;1m>cuMemAlloc");
          if (lock_page) { cuMemHostAlloc(&ptr, n*sizeof(T), CU_MEMHOSTALLOC_PORTABLE); }
          else { cuMemAlloc((CUdeviceptr*)&ptr, n*sizeof(T)); }
       }
       else
       {
+         dbg("\033[31;1m>cuMemAllocManaged");
          cuMemAllocManaged((CUdeviceptr*)&ptr, n*sizeof(T),CU_MEM_ATTACH_GLOBAL);
       }
       pop();