jdk8-mips64-public/hotspot: comparison src/share/vm/utilities/taskqueue.hpp

-:28b50d07f6f8
+:710a3c8b516e
 class TaskQueueSuper: public CHeapObj<F> {
 protected:
 // Internal type for indexing the queue; also used for the tag.
 typedef NOT_LP64(uint16_t) LP64_ONLY(uint32_t) idx_t;
+#ifdef MIPS64
+private:
+#endif
 // The first free element after the last one pushed (mod N).
 volatile uint _bottom;
+#ifdef MIPS64
+protected:
+inline uint get_bottom() const {
+return OrderAccess::load_acquire((volatile juint*)&_bottom);
+}
+inline void set_bottom(uint new_bottom) {
+OrderAccess::release_store(&_bottom, new_bottom);
+}
+#endif
 enum { MOD_N_MASK = N - 1 };
 class Age {
 public:
 Age(size_t data = 0)         { _data = data; }
 Age(const Age& age)          { _data = age._data; }
 Age(idx_t top, idx_t tag)    { _fields._top = top; _fields._tag = tag; }
+#ifndef MIPS64
 Age   get()        const volatile { return _data; }
 void  set(Age age) volatile       { _data = age._data; }
 idx_t top()        const volatile { return _fields._top; }
 idx_t tag()        const volatile { return _fields._tag; }
+#else
+Age   get()        const volatile {
+size_t res = OrderAccess::load_ptr_acquire((volatile intptr_t*) &_data);
+return *(Age*)(&res);
+}
+void  set(Age age) volatile       { OrderAccess::release_store_ptr((volatile intptr_t*) &_data, *(size_t*)(&age._data)); }
+idx_t top()        const volatile { return OrderAccess::load_acquire((volatile idx_t*) &(_fields._top)); }
+idx_t tag()        const volatile { return OrderAccess::load_acquire((volatile idx_t*) &(_fields._tag)); }
+#endif
 // Increment top; if it wraps, increment tag also.
 void increment() {
 _fields._top = increment_index(_fields._top);
 if (_fields._top == 0) ++_fields._tag;
 public:
 TaskQueueSuper() : _bottom(0), _age() {}
 // Return true if the TaskQueue contains/does not contain any tasks.
-bool peek()     const { return _bottom != _age.top(); }
+bool peek()     const {
+#ifdef MIPS64
+return get_bottom() != _age.top();
+#else
+return _bottom != _age.top();
+#endif
+}
 bool is_empty() const { return size() == 0; }
 // Return an estimate of the number of elements in the queue.
 // The "careful" version admits the possibility of pop_local/pop_global
 // races.
 uint size() const {
+#ifdef MIPS64
+return size(get_bottom(), _age.top());
+#else
 return size(_bottom, _age.top());
+#endif
 }
 uint dirty_size() const {
+#ifdef MIPS64
+return dirty_size(get_bottom(), _age.top());
+#else
 return dirty_size(_bottom, _age.top());
+#endif
 }
 void set_empty() {
+#ifdef MIPS64
+set_bottom(0);
+#else
 _bottom = 0;
+#endif
 _age.set(0);
 }
 // Maximum number of elements allowed in the queue.  This is two less
 // than the actual queue size, for somewhat complicated reasons.
 ArrayAllocator<E, F> _array_allocator;
 protected:
 typedef typename TaskQueueSuper<N, F>::Age Age;
 typedef typename TaskQueueSuper<N, F>::idx_t idx_t;
+#ifndef MIPS64
 using TaskQueueSuper<N, F>::_bottom;
+#endif
 using TaskQueueSuper<N, F>::_age;
 using TaskQueueSuper<N, F>::increment_index;
 using TaskQueueSuper<N, F>::decrement_index;
 using TaskQueueSuper<N, F>::dirty_size;
 template<class E, MEMFLAGS F, unsigned int N>
 void GenericTaskQueue<E, F, N>::oops_do(OopClosure* f) {
 // tty->print_cr("START OopTaskQueue::oops_do");
 uint iters = size();
+#ifdef MIPS64
+uint index = this->get_bottom();
+#else
 uint index = _bottom;
+#endif
 for (uint i = 0; i < iters; ++i) {
 index = decrement_index(index);
 // tty->print_cr("  doing entry %d," INTPTR_T " -> " INTPTR_T,
 //            index, &_elems[index], _elems[index]);
 E* t = (E*)&_elems[index];      // cast away volatility
 template<class E, MEMFLAGS F, unsigned int N>
 bool GenericTaskQueue<E, F, N>::push_slow(E t, uint dirty_n_elems) {
 if (dirty_n_elems == N - 1) {
 // Actually means 0, so do the push.
+#ifdef MIPS64
+uint localBot = this->get_bottom();
+#else
 uint localBot = _bottom;
+#endif
 // g++ complains if the volatile result of the assignment is
 // unused, so we cast the volatile away.  We cannot cast directly
 // to void, because gcc treats that as not using the result of the
 // assignment.  However, casting to E& means that we trigger an
 // unused-value warning.  So, we cast the E& to void.
 (void)const_cast<E&>(_elems[localBot] = t);
+#ifdef MIPS64
+this->set_bottom(increment_index(localBot));
+#else
 OrderAccess::release_store(&_bottom, increment_index(localBot));
+#endif
 TASKQUEUE_STATS_ONLY(stats.record_push());
 return true;
 }
 return false;
 }
 // to guarantee that bottom is not older than age,
 // which is crucial for the correctness of the algorithm.
 #if !(defined SPARC || defined IA32 || defined AMD64)
 OrderAccess::fence();
 #endif
+#ifdef MIPS64
+uint localBot = this->get_bottom();
+#else
 uint localBot = OrderAccess::load_acquire((volatile juint*)&_bottom);
+#endif
 uint n_elems = size(localBot, oldAge.top());
 if (n_elems == 0) {
 return false;
 }
 #endif
 };
 template<class E, MEMFLAGS F, unsigned int N> inline bool
 GenericTaskQueue<E, F, N>::push(E t) {
+#ifdef MIPS64
+uint localBot = this->get_bottom();
+#else
 uint localBot = _bottom;
+#endif
 assert(localBot < N, "_bottom out of range.");
 idx_t top = _age.top();
 uint dirty_n_elems = dirty_size(localBot, top);
 assert(dirty_n_elems < N, "n_elems out of range.");
 if (dirty_n_elems < max_elems()) {
 // unused, so we cast the volatile away.  We cannot cast directly
 // to void, because gcc treats that as not using the result of the
 // assignment.  However, casting to E& means that we trigger an
 // unused-value warning.  So, we cast the E& to void.
 (void) const_cast<E&>(_elems[localBot] = t);
+#ifdef MIPS64
+this->set_bottom(increment_index(localBot));
+#else
 OrderAccess::release_store(&_bottom, increment_index(localBot));
+#endif
 TASKQUEUE_STATS_ONLY(stats.record_push());
 return true;
 } else {
 return push_slow(t, dirty_n_elems);
 }
 }
 template<class E, MEMFLAGS F, unsigned int N> inline bool
 GenericTaskQueue<E, F, N>::pop_local(volatile E& t) {
+#ifdef MIPS64
+uint localBot = this->get_bottom();
+#else
 uint localBot = _bottom;
+#endif
 // This value cannot be N-1.  That can only occur as a result of
 // the assignment to bottom in this method.  If it does, this method
 // resets the size to 0 before the next call (which is sequential,
 // since this is pop_local.)
 uint dirty_n_elems = dirty_size(localBot, _age.top());
 assert(dirty_n_elems != N - 1, "Shouldn't be possible...");
 if (dirty_n_elems == 0) return false;
 localBot = decrement_index(localBot);
+#ifdef MIPS64
+this->set_bottom(localBot);
+#else
 _bottom = localBot;
+#endif
 // This is necessary to prevent any read below from being reordered
 // before the store just above.
 OrderAccess::fence();
 // g++ complains if the volatile result of the assignment is
 // unused, so we cast the volatile away.  We cannot cast directly

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/utilities/taskqueue.hpp

src/share/vm/utilities/taskqueue.hpp