src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.hpp
changeset 59270 d5a1c6545a2b
parent 59252 623722a6aeb9
equal deleted inserted replaced
59269:ac6f7738a0ee 59270:d5a1c6545a2b
    75   inline void arraycopy_update(oop* src, size_t count);
    75   inline void arraycopy_update(oop* src, size_t count);
    76   inline void arraycopy_update(narrowOop* src, size_t count);
    76   inline void arraycopy_update(narrowOop* src, size_t count);
    77   inline void clone_barrier(oop src);
    77   inline void clone_barrier(oop src);
    78   void clone_barrier_runtime(oop src);
    78   void clone_barrier_runtime(oop src);
    79 
    79 
    80   // We export this to make it available in cases where the static
       
    81   // type of the barrier set is known.  Note that it is non-virtual.
       
    82   template <class T> inline void inline_write_ref_field_pre(T* field, oop new_val);
       
    83 
       
    84   // These are the more general virtual versions.
       
    85   void write_ref_field_pre_work(oop* field, oop new_val);
       
    86   void write_ref_field_pre_work(narrowOop* field, oop new_val);
       
    87   void write_ref_field_pre_work(void* field, oop new_val);
       
    88 
       
    89   void write_ref_field_work(void* v, oop o, bool release = false);
       
    90 
       
    91   virtual void on_thread_create(Thread* thread);
    80   virtual void on_thread_create(Thread* thread);
    92   virtual void on_thread_destroy(Thread* thread);
    81   virtual void on_thread_destroy(Thread* thread);
    93   virtual void on_thread_attach(Thread* thread);
    82   virtual void on_thread_attach(Thread* thread);
    94   virtual void on_thread_detach(Thread* thread);
    83   virtual void on_thread_detach(Thread* thread);
    95 
    84 
    96   static inline oop resolve_forwarded_not_null(oop p);
    85   static inline oop resolve_forwarded_not_null(oop p);
    97   static inline oop resolve_forwarded(oop p);
    86   static inline oop resolve_forwarded(oop p);
    98 
    87 
    99   void storeval_barrier(oop obj);
    88   template <DecoratorSet decorators, typename T>
   100   void keep_alive_barrier(oop obj);
    89   inline void satb_barrier(T* field);
       
    90   inline void satb_enqueue(oop value);
       
    91   inline void storeval_barrier(oop obj);
       
    92 
       
    93   template <DecoratorSet decorators>
       
    94   inline void keep_alive_if_weak(oop value);
       
    95   inline void keep_alive_if_weak(DecoratorSet decorators, oop value);
       
    96   inline void keep_alive_barrier(oop value);
       
    97 
       
    98   inline void enqueue(oop obj);
   101 
    99 
   102   oop load_reference_barrier(oop obj);
   100   oop load_reference_barrier(oop obj);
   103   oop load_reference_barrier_not_null(oop obj);
   101   oop load_reference_barrier_not_null(oop obj);
   104 
   102 
   105   oop load_reference_barrier_mutator(oop obj, oop* load_addr);
   103   oop load_reference_barrier_mutator(oop obj, oop* load_addr);
   108   template <class T>
   106   template <class T>
   109   oop load_reference_barrier_mutator_work(oop obj, T* load_addr);
   107   oop load_reference_barrier_mutator_work(oop obj, T* load_addr);
   110 
   108 
   111   oop load_reference_barrier_native(oop obj, oop* load_addr);
   109   oop load_reference_barrier_native(oop obj, oop* load_addr);
   112   oop load_reference_barrier_native(oop obj, narrowOop* load_addr);
   110   oop load_reference_barrier_native(oop obj, narrowOop* load_addr);
   113 
       
   114   void enqueue(oop obj);
       
   115 
   111 
   116 private:
   112 private:
   117   template <class T>
   113   template <class T>
   118   inline void arraycopy_pre_work(T* src, T* dst, size_t count);
   114   inline void arraycopy_pre_work(T* src, T* dst, size_t count);
   119   template <class T, bool HAS_FWD, bool EVAC, bool ENQUEUE>
   115   template <class T, bool HAS_FWD, bool EVAC, bool ENQUEUE>
   124   oop load_reference_barrier_impl(oop obj);
   120   oop load_reference_barrier_impl(oop obj);
   125 
   121 
   126   template <class T>
   122   template <class T>
   127   oop load_reference_barrier_native_impl(oop obj, T* load_addr);
   123   oop load_reference_barrier_native_impl(oop obj, T* load_addr);
   128 
   124 
   129   static void keep_alive_if_weak(DecoratorSet decorators, oop value) {
       
   130     assert((decorators & ON_UNKNOWN_OOP_REF) == 0, "Reference strength must be known");
       
   131     const bool on_strong_oop_ref = (decorators & ON_STRONG_OOP_REF) != 0;
       
   132     const bool peek              = (decorators & AS_NO_KEEPALIVE) != 0;
       
   133     if (!peek && !on_strong_oop_ref && value != NULL) {
       
   134       ShenandoahBarrierSet::barrier_set()->keep_alive_barrier(value);
       
   135     }
       
   136   }
       
   137 
       
   138 public:
   125 public:
   139   // Callbacks for runtime accesses.
   126   // Callbacks for runtime accesses.
   140   template <DecoratorSet decorators, typename BarrierSetT = ShenandoahBarrierSet>
   127   template <DecoratorSet decorators, typename BarrierSetT = ShenandoahBarrierSet>
   141   class AccessBarrier: public BarrierSet::AccessBarrier<decorators, BarrierSetT> {
   128   class AccessBarrier: public BarrierSet::AccessBarrier<decorators, BarrierSetT> {
   142     typedef BarrierSet::AccessBarrier<decorators, BarrierSetT> Raw;
   129     typedef BarrierSet::AccessBarrier<decorators, BarrierSetT> Raw;
   143 
       
   144     template <typename T>
       
   145     static oop oop_atomic_cmpxchg_in_heap_impl(T* addr, oop compare_value, oop new_value);
       
   146 
       
   147     template <typename T>
       
   148     static oop oop_atomic_xchg_in_heap_impl(T* addr, oop new_value);
       
   149 
   130 
   150   public:
   131   public:
   151     // Heap oop accesses. These accessors get resolved when
   132     // Heap oop accesses. These accessors get resolved when
   152     // IN_HEAP is set (e.g. when using the HeapAccess API), it is
   133     // IN_HEAP is set (e.g. when using the HeapAccess API), it is
   153     // an oop_* overload, and the barrier strength is AS_NORMAL.
   134     // an oop_* overload, and the barrier strength is AS_NORMAL.