MPI_UMemoryReclaimer.h

浏览该文件的文档。

#ifndef __MPI_UMemoryReclaimer_h__
#define __MPI_UMemoryReclaimer_h__

#include "MPI_HGeometry.h"

namespace MPI {
  template <class FOREST>
    class MemoryReclaimer {
  public:
    enum { dim = FOREST::dim, dow = FOREST::dow };
    typedef FOREST tree_t;
    typedef BirdView<tree_t> ir_mesh_t;
  private:
    tree_t * h_tree;
    std::list<ir_mesh_t *> ir_mesh;

  public:
  MemoryReclaimer() : h_tree(NULL) {}
  MemoryReclaimer(tree_t& _h_tree) : h_tree(&_h_tree) {}
    virtual ~MemoryReclaimer() {}

  public:
    void setGeometryTree(tree_t& _h_tree) {
      h_tree = &_h_tree;
    }
    void addIrregularMesh(ir_mesh_t& _ir_mesh) {
      if (&(_ir_mesh.getForest()) != h_tree) {
        std::cout << "warning: the irregular mesh added is not based on the geometry tree used."
                  << std::endl;
      }
      ir_mesh.push_back(&_ir_mesh);
    }
    void clear() {
      h_tree = NULL;
      ir_mesh.clear();
    }
    void reclaim() {
      typename std::list<ir_mesh_t *>::iterator 
        the_ir_mesh = ir_mesh.begin(),
        end_ir_mesh = ir_mesh.end();
      for (;the_ir_mesh != end_ir_mesh;++ the_ir_mesh) {
        reclaimIrregularMesh(**the_ir_mesh);
      }
  
      initialTreeLabel();

      the_ir_mesh = ir_mesh.begin();
      for (;the_ir_mesh != end_ir_mesh;++ the_ir_mesh) {
        labelIrregularMesh(**the_ir_mesh);
      }

      reclaimTreeMemory();
    }

  private:
    void reclaimIrregularMesh(ir_mesh_t& m) {
      ActiveElementIterator<dim,dow>
        the_ele = m.beginActiveElement(),
        end_ele = m.endActiveElement();
      for (;the_ele != end_ele;++ the_ele) {
        if (the_ele->isRefined()) {
          for (int i = 0;i < the_ele->n_child;++ i) {
            m.deleteTree(the_ele->child[i]);
            the_ele->child[i] = NULL;
          }
        }
      }
    }

    void initialTreeLabel() {
      typename HGeometryTree<dim,dow>::RootIterator 
        the_ele = h_tree->beginRootElement(),
        end_ele = h_tree->endRootElement();
      for (;the_ele != end_ele;++ the_ele) {
        labelHGeometryRecursively(*the_ele, -1);
      }
    }

    void labelIrregularMesh(ir_mesh_t& m) {
      RootFirstElementIterator<dim,dow>
        the_ele = m.beginRootFirstElement(),
        end_ele = m.endRootFirstElement();
      for (;the_ele != end_ele;++ the_ele) {
        labelHGeometry(*(the_ele->h_element), 1);
      }
    }

    void reclaimTreeMemory() {
      typename HGeometryTree<dim,dow>::RootIterator
        the_ele = h_tree->beginRootElement(),
        end_ele = h_tree->endRootElement();
      for (;the_ele != end_ele;++ the_ele) {
        relabelHGeometryRecursively(*the_ele);
      }

      the_ele = h_tree->beginRootElement();
      for (;the_ele != end_ele;++ the_ele) {
        reclaimHGeometryRecursively(*the_ele);
      }
    }

  private:
    template <class GEO> bool
      is_shared_geometry(const GEO& g) const {
      return (h_tree->get_shared_info(g) != NULL);
    }

    template <int D> void 
      labelHGeometry(HGeometry<D,dow>& g, int lab) const {
      for (int i = 0;i < g.n_vertex;++ i) {
        labelHGeometry(*(g.vertex[i]), lab);
      }
      for (int i = 0;i < g.n_boundary;++ i) {
        labelHGeometry(*(g.boundary[i]), lab);
      }
      g.index = lab;
    }

    template <int D> void 
      labelHGeometryRecursively(HGeometry<D,dow>& g, int lab) const {
      if (g.isRefined()) {
        for (int i = 0;i < g.n_child;++ i) {
          labelHGeometryRecursively(*(g.child[i]), lab);
        }
      }

      labelHGeometry(g, lab);
    }

    template <int D> int 
      relabelHGeometryRecursively(HGeometry<D,dow>& g) const {
      if (is_shared_geometry(g)) g.index = 1;

      for (int i = 0;i < g.n_vertex;++ i) {
        if (g.vertex[i] == NULL) continue;
        if (relabelHGeometryRecursively(*(g.vertex[i])) == -2) {
          g.vertex[i] = NULL;
        }
      }
      for (int i = 0;i < g.n_boundary;++ i) {
        if (g.boundary[i] == NULL) continue;
        if (relabelHGeometryRecursively(*(g.boundary[i])) == -2) {
          g.boundary[i] = NULL;
        }
      }
      if (g.isRefined()) {
        for (int i = 0;i < g.n_child;++ i) {
          if (g.child[i] == NULL) continue;
          if (relabelHGeometryRecursively(*(g.child[i])) == -2) {
            g.child[i] = NULL;
          }
        }
      }
      if (g.index == -1) {
        g.index = -2;
        return -1;
      } else {
        return g.index;
      }
    }

    template <int D> int 
      reclaimHGeometryRecursively(HGeometry<D,dow>& g) const {
      if (is_shared_geometry(g)) return 1;

      for (int i = 0;i < g.n_vertex;++ i) {
        if (g.vertex[i] != NULL) {
          if (reclaimHGeometryRecursively(*(g.vertex[i])) == -1) {
            g.vertex[i] = NULL;
          }
        }
      }
      for (int i = 0;i < g.n_boundary;++ i) {
        if (g.boundary[i] != NULL) {
          if (reclaimHGeometryRecursively(*(g.boundary[i])) == -1) {
            g.boundary[i] = NULL;
          }
        }
      }
      for (int i = 0;i < g.n_child;++ i) {
        if (g.child[i] == NULL) continue;
        if (reclaimHGeometryRecursively(*(g.child[i])) == -1) {
          g.child[i] = NULL;
        }
      }
      Assert (((g.index == 1) || 
               (g.index == -1) || 
               (g.index == -2)), ExcInternalError());
      if (g.index == -2) {
        this->reclaimHGeometry(&g);
        return -1;
      } else {
        return 1;
      }
    }

    template <int D> void 
      reclaimHGeometry(HGeometry<D,dow> * p_geo) const {
      delete p_geo;
    }
  };

}
#endif // __MPI_UMemoryReclaimer_h__