< prev index next >

src/share/vm/gc_implementation/shenandoah/shenandoahBarrierSet.hpp

Print this page
rev 11463 : Backport Traversal GC


  74   void read_ref_array(MemRegion mr)             shenandoah_not_implemented;
  75 
  76   void read_ref_field(void* v);
  77 
  78   bool read_ref_needs_barrier(void* v)          shenandoah_not_implemented_return(false);
  79   void read_region(MemRegion mr)                shenandoah_not_implemented;
  80   void resize_covered_region(MemRegion mr)      shenandoah_not_implemented;
  81   void write_prim_array(MemRegion mr)           shenandoah_not_implemented;
  82   void write_prim_field(HeapWord* hw, size_t s , juint x, juint y) shenandoah_not_implemented;
  83   bool write_prim_needs_barrier(HeapWord* hw, size_t s, juint x, juint y) shenandoah_not_implemented_return(false);
  84   void write_ref_array(HeapWord* start, size_t count);
  85   void write_ref_array_work(MemRegion r)        shenandoah_not_implemented;
  86 
  87   template <class T> void
  88   write_ref_array_pre_work(T* dst, size_t count);
  89 
  90   void write_ref_array_pre(oop* dst, int count, bool dest_uninitialized);
  91 
  92   void write_ref_array_pre(narrowOop* dst, int count, bool dest_uninitialized);
  93 
  94   template <class T> static void write_ref_field_pre_static(T* field, oop newVal);
  95 
  96   // We export this to make it available in cases where the static
  97   // type of the barrier set is known.  Note that it is non-virtual.
  98   template <class T> inline void inline_write_ref_field_pre(T* field, oop newVal);
  99 
 100   // These are the more general virtual versions.
 101   void write_ref_field_pre_work(oop* field, oop new_val);
 102   void write_ref_field_pre_work(narrowOop* field, oop new_val);
 103   void write_ref_field_pre_work(void* field, oop new_val) shenandoah_not_implemented;
 104 
 105   void write_ref_field_work(void* v, oop o, bool release = false);
 106   void write_region_work(MemRegion mr);
 107 
 108   static inline oop resolve_forwarded_not_null(oop p);
 109   static inline oop resolve_forwarded(oop p);
 110 
 111   static oopDesc* write_barrier_IRT(oopDesc* src);
 112   static oopDesc* write_barrier_JRT(oopDesc* src);
 113 
 114   oop write_barrier_mutator(oop obj);
 115 
 116   oop load_reference_barrier(oop obj);
 117   oop load_reference_barrier_mutator(oop obj);
 118   oop load_reference_barrier_not_null(oop obj);
 119 
 120   oop oop_atomic_cmpxchg_in_heap(oop new_value, volatile HeapWord* dest, oop compare_value);
 121 
 122   void enqueue(oop obj);
 123 
 124 private:
 125   inline bool need_update_refs_barrier();
 126 
 127   template <class T>
 128   void write_ref_array_loop(HeapWord* start, size_t count);
 129 
 130   oop load_reference_barrier_impl(oop obj);
 131 
 132   oop atomic_compare_exchange_oop(oop exchange_value,
 133                                   volatile HeapWord *dest,
 134                                   oop compare_value);
 135 };
 136 
 137 #endif //SHARE_VM_GC_SHENANDOAH_SHENANDOAHBARRIERSET_HPP


  74   void read_ref_array(MemRegion mr)             shenandoah_not_implemented;
  75 
  76   void read_ref_field(void* v);
  77 
  78   bool read_ref_needs_barrier(void* v)          shenandoah_not_implemented_return(false);
  79   void read_region(MemRegion mr)                shenandoah_not_implemented;
  80   void resize_covered_region(MemRegion mr)      shenandoah_not_implemented;
  81   void write_prim_array(MemRegion mr)           shenandoah_not_implemented;
  82   void write_prim_field(HeapWord* hw, size_t s , juint x, juint y) shenandoah_not_implemented;
  83   bool write_prim_needs_barrier(HeapWord* hw, size_t s, juint x, juint y) shenandoah_not_implemented_return(false);
  84   void write_ref_array(HeapWord* start, size_t count);
  85   void write_ref_array_work(MemRegion r)        shenandoah_not_implemented;
  86 
  87   template <class T> void
  88   write_ref_array_pre_work(T* dst, size_t count);
  89 
  90   void write_ref_array_pre(oop* dst, int count, bool dest_uninitialized);
  91 
  92   void write_ref_array_pre(narrowOop* dst, int count, bool dest_uninitialized);
  93 


  94   // We export this to make it available in cases where the static
  95   // type of the barrier set is known.  Note that it is non-virtual.
  96   template <class T> inline void inline_write_ref_field_pre(T* field, oop newVal);
  97 
  98   // These are the more general virtual versions.
  99   void write_ref_field_pre_work(oop* field, oop new_val);
 100   void write_ref_field_pre_work(narrowOop* field, oop new_val);
 101   void write_ref_field_pre_work(void* field, oop new_val) shenandoah_not_implemented;
 102 
 103   void write_ref_field_work(void* v, oop o, bool release = false);
 104   void write_region_work(MemRegion mr);
 105 
 106   static inline oop resolve_forwarded_not_null(oop p);
 107   static inline oop resolve_forwarded(oop p);
 108 
 109   void storeval_barrier(oop obj);
 110   void keep_alive_barrier(oop obj);


 111 
 112   oop load_reference_barrier(oop obj);
 113   oop load_reference_barrier_mutator(oop obj);
 114   oop load_reference_barrier_not_null(oop obj);
 115 
 116   oop oop_atomic_cmpxchg_in_heap(oop new_value, volatile HeapWord* dest, oop compare_value);
 117 
 118   void enqueue(oop obj);
 119 
 120 private:
 121   inline bool need_update_refs_barrier();
 122 
 123   template <class T, bool STOREVAL_EVAC_BARRIER>
 124   void write_ref_array_loop(HeapWord* start, size_t count);
 125 
 126   oop load_reference_barrier_impl(oop obj);
 127 
 128   oop atomic_compare_exchange_oop(oop exchange_value,
 129                                   volatile HeapWord *dest,
 130                                   oop compare_value);
 131 };
 132 
 133 #endif //SHARE_VM_GC_SHENANDOAH_SHENANDOAHBARRIERSET_HPP
< prev index next >