src/hotspot/share/gc/epsilon/epsilonHeap.hpp

rev 53444 : Epsilon + Mark-Compact

*** 23,32 ****
--- 23,33 ----
  
  #ifndef SHARE_GC_EPSILON_EPSILONHEAP_HPP
  #define SHARE_GC_EPSILON_EPSILONHEAP_HPP
  
  #include "gc/shared/collectedHeap.hpp"
+ #include "gc/shared/markBitMap.hpp"
  #include "gc/shared/softRefPolicy.hpp"
  #include "gc/shared/space.hpp"
  #include "services/memoryManager.hpp"
  #include "gc/epsilon/epsilonCollectorPolicy.hpp"
  #include "gc/epsilon/epsilonMonitoringSupport.hpp"
*** 47,56 ****
--- 48,58 ----
    size_t _step_counter_update;
    size_t _step_heap_print;
    int64_t _decay_time_ns;
    volatile size_t _last_counter_update;
    volatile size_t _last_heap_print;
+   MarkBitMap _bitmap;
  
  public:
    static EpsilonHeap* heap();
  
    EpsilonHeap(EpsilonCollectorPolicy* p) :
*** 88,107 ****
      return _space->is_in(p);
    }
  
    virtual bool is_scavengable(oop obj) {
      // No GC is going to happen, therefore no objects ever move.
!     return false;
    }
  
    virtual bool is_maximal_no_gc() const {
      // No GC is going to happen. Return "we are at max", when we are about to fail.
      return used() == capacity();
    }
  
    // Allocation
    HeapWord* allocate_work(size_t size);
    virtual HeapWord* mem_allocate(size_t size, bool* gc_overhead_limit_was_exceeded);
    virtual HeapWord* allocate_new_tlab(size_t min_size,
                                        size_t requested_size,
                                        size_t* actual_size);
  
--- 90,111 ----
      return _space->is_in(p);
    }
  
    virtual bool is_scavengable(oop obj) {
      // No GC is going to happen, therefore no objects ever move.
!     // Or are they... (evil laugh).
!     return EpsilonWhyNotGCAnyway;
    }
  
    virtual bool is_maximal_no_gc() const {
      // No GC is going to happen. Return "we are at max", when we are about to fail.
      return used() == capacity();
    }
  
    // Allocation
    HeapWord* allocate_work(size_t size);
+   HeapWord* allocate_or_collect_work(size_t size);
    virtual HeapWord* mem_allocate(size_t size, bool* gc_overhead_limit_was_exceeded);
    virtual HeapWord* allocate_new_tlab(size_t min_size,
                                        size_t requested_size,
                                        size_t* actual_size);
  
*** 120,130 ****
    virtual void object_iterate(ObjectClosure* cl) {
      safe_object_iterate(cl);
    }
  
    // Object pinning support: every object is implicitly pinned
!   virtual bool supports_object_pinning() const           { return true; }
    virtual oop pin_object(JavaThread* thread, oop obj)    { return obj; }
    virtual void unpin_object(JavaThread* thread, oop obj) { }
  
    // No support for block parsing.
    virtual HeapWord* block_start(const void* addr) const { return NULL;  }
--- 124,135 ----
    virtual void object_iterate(ObjectClosure* cl) {
      safe_object_iterate(cl);
    }
  
    // Object pinning support: every object is implicitly pinned
!   // Or is it... (evil laugh)
!   virtual bool supports_object_pinning() const           { return !EpsilonWhyNotGCAnyway; }
    virtual oop pin_object(JavaThread* thread, oop obj)    { return obj; }
    virtual void unpin_object(JavaThread* thread, oop obj) { }
  
    // No support for block parsing.
    virtual HeapWord* block_start(const void* addr) const { return NULL;  }
*** 145,156 ****
--- 150,168 ----
    }
  
    virtual void print_on(outputStream* st) const;
    virtual void print_tracing_info() const;
  
+   void entry_collect(GCCause::Cause cause);
+ 
  private:
    void print_heap_info(size_t used) const;
    void print_metaspace_info() const;
  
+   void vmentry_collect(GCCause::Cause cause);
+ 
+   void process_all_roots(OopClosure* cl);
+   void walk_bitmap(ObjectClosure* cl);
+ 
  };
  
  #endif // SHARE_GC_EPSILON_EPSILONHEAP_HPP