Merge branch 'upstream-master'

Author: Datadog Syncup Service

src/demo/share/java2d/J2DBench/Makefile

@@ -31,10 +31,10 @@
 
 
 ifndef SOURCE
-export SOURCE := 7
+export SOURCE := 8
 endif
 ifndef TARGET
-export TARGET := 7
+export TARGET := 8
 endif
 ifndef JAVAC
 export JAVAC := javac

src/demo/share/java2d/J2DBench/build.xml

@@ -39,12 +39,12 @@
   <property name="dist"  location="dist"/>
   <property name="resources"  location="resources"/>
 
-  <condition property="source" value="7">
+  <condition property="source" value="8">
      <not>
         <isset property="source"/>
      </not>
   </condition>
-  <condition property="target" value="7">
+  <condition property="target" value="8">
      <not>
         <isset property="target"/>
      </not>
@@ -54,11 +54,6 @@
         <isset property="java"/>
      </not>
   </condition>
-  <condition property="javac" value="javac">
-     <not>
-        <isset property="javac"/>
-     </not>
-  </condition>
 
   <target name="init">
     <!-- Create the time stamp -->
@@ -70,7 +65,7 @@
   <target name="compile" depends="init"
         description="compile the source " >
     <!-- Compile the java code from ${src} into ${build} -->
-    <javac debug="off" source="${source}" target="${target}" srcdir="${src}" destdir="${build}" fork="true" executable="${javac}"/>
+    <javac debug="off" source="${source}" target="${target}" srcdir="${src}" destdir="${build}"/>
   </target>
 
   <target name="run" depends="dist"

src/hotspot/os/bsd/semaphore_bsd.cpp

@@ -31,18 +31,23 @@
 #ifdef __APPLE__
 // OS X doesn't support unnamed POSIX semaphores, so the implementation in os_posix.cpp can't be used.
 
-static const char* sem_init_strerror(kern_return_t value) {
+static const char* sem_strerror(kern_return_t value) {
   switch (value) {
-    case KERN_INVALID_ARGUMENT:  return "Invalid argument";
-    case KERN_RESOURCE_SHORTAGE: return "Resource shortage";
-    default:                     return "Unknown";
+    case KERN_INVALID_ARGUMENT:    return "Invalid argument";
+    case KERN_RESOURCE_SHORTAGE:   return "Resource shortage";
+    case KERN_TERMINATED:          return "Resource has been destroyed";
+    case KERN_ABORTED:             return "Operation was aborted";
+    case KERN_INVALID_VALUE:       return "Invalid time specified";
+    case KERN_OPERATION_TIMED_OUT: return "Operation timed-out";
+    default:                       return "Unknown";
   }
 }
 
 OSXSemaphore::OSXSemaphore(uint value) {
   kern_return_t ret = semaphore_create(mach_task_self(), &_semaphore, SYNC_POLICY_FIFO, value);
 
-  guarantee(ret == KERN_SUCCESS, "Failed to create semaphore: %s", sem_init_strerror(ret));
+  guarantee(ret == KERN_SUCCESS, "Failed to create semaphore: %s (0x%x)",
+            sem_strerror(ret), (uint)ret);
 }
 
 OSXSemaphore::~OSXSemaphore() {
@@ -53,7 +58,8 @@ void OSXSemaphore::signal(uint count) {
   for (uint i = 0; i < count; i++) {
     kern_return_t ret = semaphore_signal(_semaphore);
 
-    assert(ret == KERN_SUCCESS, "Failed to signal semaphore");
+    assert(ret == KERN_SUCCESS, "Failed to signal semaphore: %s (0x%x)",
+           sem_strerror(ret), (uint)ret);
   }
 }
 
@@ -62,7 +68,8 @@ void OSXSemaphore::wait() {
   while ((ret = semaphore_wait(_semaphore)) == KERN_ABORTED) {
     // Semaphore was interrupted. Retry.
   }
-  assert(ret == KERN_SUCCESS, "Failed to wait on semaphore");
+  assert(ret == KERN_SUCCESS, "Failed to wait on semaphore: %s (0x%x)",
+         sem_strerror(ret), (uint)ret);
 }
 
 bool OSXSemaphore::trywait() {
@@ -100,6 +107,10 @@ bool OSXSemaphore::timedwait(int64_t millis) {
     kr = semaphore_timedwait(_semaphore, waitspec);
   }
 
+  assert(kr == KERN_SUCCESS || kr == KERN_OPERATION_TIMED_OUT,
+         "Failed to timed-wait on semaphore: %s (0x%x)",
+         sem_strerror(kr), (uint)kr);
+
   return kr == KERN_SUCCESS;
 }
 #endif // __APPLE__

src/hotspot/share/code/nmethod.cpp

@@ -1936,10 +1936,7 @@ void nmethod::inc_decompile_count() {
   if (!is_compiled_by_c2() && !is_compiled_by_jvmci()) return;
   // Could be gated by ProfileTraps, but do not bother...
 #if INCLUDE_JVMCI
-  // Deoptimization count is used by the CompileBroker to reason about compilations
-  // it requests so do not pollute the count for deoptimizations in non-default (i.e.
-  // non-CompilerBroker) compilations.
-  if (is_jvmci_hosted()) {
+  if (jvmci_skip_profile_deopt()) {
     return;
   }
 #endif
@@ -4066,7 +4063,7 @@ const char* nmethod::jvmci_name() {
   return nullptr;
 }
 
-bool nmethod::is_jvmci_hosted() const {
-  return jvmci_nmethod_data() != nullptr && !jvmci_nmethod_data()->is_default();
+bool nmethod::jvmci_skip_profile_deopt() const {
+  return jvmci_nmethod_data() != nullptr && !jvmci_nmethod_data()->profile_deopt();
 }
 #endif

src/hotspot/share/code/nmethod.hpp

@@ -914,9 +914,9 @@ class nmethod : public CodeBlob {
     return jvmci_data_size() == 0 ? nullptr : (JVMCINMethodData*) jvmci_data_begin();
   }
 
-  // Returns true if a JVMCI compiled method is non-default,
-  // i.e., not triggered by CompilerBroker
-  bool is_jvmci_hosted() const;
+  // Returns true if the runtime should NOT collect deoptimization profile for a JVMCI
+  // compiled method
+  bool jvmci_skip_profile_deopt() const;
 #endif
 
   void oops_do(OopClosure* f) { oops_do(f, false); }

src/hotspot/share/compiler/compileBroker.cpp

@@ -236,7 +236,7 @@ CompileTaskWrapper::~CompileTaskWrapper() {
 #if INCLUDE_JVMCI
       if (CompileBroker::compiler(task->comp_level())->is_jvmci()) {
         if (!task->has_waiter()) {
-          // The waiting thread timed out and thus did not free the task.
+          // The waiting thread timed out and thus did not delete the task.
           free_task = true;
         }
         task->set_blocking_jvmci_compile_state(nullptr);
@@ -249,15 +249,15 @@ CompileTaskWrapper::~CompileTaskWrapper() {
       }
     }
     if (free_task) {
-      // The task can only be freed once the task lock is released.
-      CompileTask::free(task);
+      // The task can only be deleted once the task lock is released.
+      delete task;
     }
   } else {
     task->mark_complete();
 
-    // By convention, the compiling thread is responsible for
-    // recycling a non-blocking CompileTask.
-    CompileTask::free(task);
+    // By convention, the compiling thread is responsible for deleting
+    // a non-blocking CompileTask.
+    delete task;
   }
 }
 
@@ -360,12 +360,12 @@ void CompileQueue::add(CompileTask* task) {
 }
 
 /**
- * Empties compilation queue by putting all compilation tasks onto
- * a freelist. Furthermore, the method wakes up all threads that are
- * waiting on a compilation task to finish. This can happen if background
+ * Empties compilation queue by deleting all compilation tasks.
+ * Furthermore, the method wakes up all threads that are waiting
+ * on a compilation task to finish. This can happen if background
  * compilation is disabled.
  */
-void CompileQueue::free_all() {
+void CompileQueue::delete_all() {
   MutexLocker mu(MethodCompileQueue_lock);
   CompileTask* next = _first;
 
@@ -385,11 +385,10 @@ void CompileQueue::free_all() {
       }
     }
     if (!found_waiter) {
-      // If no one was waiting for this task, we need to free it ourselves. In this case, the task
-      // is also certainly unlocked, because, again, there is no waiter.
-      // Otherwise, by convention, it's the waiters responsibility to free the task.
-      // Put the task back on the freelist.
-      CompileTask::free(current);
+      // If no one was waiting for this task, we need to delete it ourselves.
+      // In this case, the task is also certainly unlocked, because, again, there is no waiter.
+      // Otherwise, by convention, it's the waiters responsibility to delete the task.
+      delete current;
     }
   }
   _first = nullptr;
@@ -1627,10 +1626,8 @@ CompileTask* CompileBroker::create_compile_task(CompileQueue*       queue,
                                                 int                 hot_count,
                                                 CompileTask::CompileReason compile_reason,
                                                 bool                blocking) {
-  CompileTask* new_task = CompileTask::allocate();
-  new_task->initialize(compile_id, method, osr_bci, comp_level,
-                       hot_count, compile_reason,
-                       blocking);
+  CompileTask* new_task = new CompileTask(compile_id, method, osr_bci, comp_level,
+                                          hot_count, compile_reason, blocking);
   queue->add(new_task);
   return new_task;
 }
@@ -1651,7 +1648,7 @@ static const int JVMCI_COMPILATION_PROGRESS_WAIT_ATTEMPTS = 10;
  * JVMCI_COMPILATION_PROGRESS_WAIT_TIMESLICE *
  * JVMCI_COMPILATION_PROGRESS_WAIT_ATTEMPTS.
  *
- * @return true if this thread needs to free/recycle the task
+ * @return true if this thread needs to delete the task
  */
 bool CompileBroker::wait_for_jvmci_completion(JVMCICompiler* jvmci, CompileTask* task, JavaThread* thread) {
   assert(UseJVMCICompiler, "sanity");
@@ -1734,19 +1731,19 @@ void CompileBroker::wait_for_completion(CompileTask* task) {
 
   if (free_task) {
     if (is_compilation_disabled_forever()) {
-      CompileTask::free(task);
+      delete task;
       return;
     }
 
     // It is harmless to check this status without the lock, because
-    // completion is a stable property (until the task object is recycled).
+    // completion is a stable property (until the task object is deleted).
     assert(task->is_complete(), "Compilation should have completed");
 
-    // By convention, the waiter is responsible for recycling a
+    // By convention, the waiter is responsible for deleting a
     // blocking CompileTask. Since there is only one waiter ever
     // waiting on a CompileTask, we know that no one else will
-    // be using this CompileTask; we can free it.
-    CompileTask::free(task);
+    // be using this CompileTask; we can delete it.
+    delete task;
   }
 }
 
@@ -1827,11 +1824,11 @@ void CompileBroker::shutdown_compiler_runtime(AbstractCompiler* comp, CompilerTh
 
     // Delete all queued compilation tasks to make compiler threads exit faster.
     if (_c1_compile_queue != nullptr) {
-      _c1_compile_queue->free_all();
+      _c1_compile_queue->delete_all();
     }
 
     if (_c2_compile_queue != nullptr) {
-      _c2_compile_queue->free_all();
+      _c2_compile_queue->delete_all();
     }
 
     // Set flags so that we continue execution with using interpreter only.

src/hotspot/share/compiler/compileBroker.hpp

@@ -140,7 +140,7 @@ class CompileQueue : public CHeapObj<mtCompiler> {
 
   // Redefine Classes support
   void mark_on_stack();
-  void free_all();
+  void delete_all();
   void print_tty();
   void print(outputStream* st = tty);
 

src/hotspot/share/compiler/compileTask.cpp

@@ -36,72 +36,15 @@
 #include "runtime/jniHandles.hpp"
 #include "runtime/mutexLocker.hpp"
 
-CompileTask*  CompileTask::_task_free_list = nullptr;
 int CompileTask::_active_tasks = 0;
 
-/**
- * Allocate a CompileTask, from the free list if possible.
- */
-CompileTask* CompileTask::allocate() {
-  MonitorLocker locker(CompileTaskAlloc_lock);
-  CompileTask* task = nullptr;
-
-  if (_task_free_list != nullptr) {
-    task = _task_free_list;
-    _task_free_list = task->next();
-    task->set_next(nullptr);
-  } else {
-    task = new CompileTask();
-    task->set_next(nullptr);
-    task->set_is_free(true);
-  }
-  assert(task->is_free(), "Task must be free.");
-  task->set_is_free(false);
-  _active_tasks++;
-  return task;
-}
-
-/**
-* Add a task to the free list.
-*/
-void CompileTask::free(CompileTask* task) {
-  MonitorLocker locker(CompileTaskAlloc_lock);
-  if (!task->is_free()) {
-    if ((task->_method_holder != nullptr && JNIHandles::is_weak_global_handle(task->_method_holder))) {
-      JNIHandles::destroy_weak_global(task->_method_holder);
-    } else {
-      JNIHandles::destroy_global(task->_method_holder);
-    }
-    if (task->_failure_reason_on_C_heap && task->_failure_reason != nullptr) {
-      os::free((void*) task->_failure_reason);
-    }
-    task->_failure_reason = nullptr;
-    task->_failure_reason_on_C_heap = false;
-
-    task->set_is_free(true);
-    task->set_next(_task_free_list);
-    _task_free_list = task;
-    _active_tasks--;
-    if (_active_tasks == 0) {
-      locker.notify_all();
-    }
-  }
-}
-
-void CompileTask::wait_for_no_active_tasks() {
-  MonitorLocker locker(CompileTaskAlloc_lock);
-  while (_active_tasks > 0) {
-    locker.wait();
-  }
-}
-
-void CompileTask::initialize(int compile_id,
-                             const methodHandle& method,
-                             int osr_bci,
-                             int comp_level,
-                             int hot_count,
-                             CompileTask::CompileReason compile_reason,
-                             bool is_blocking) {
+CompileTask::CompileTask(int compile_id,
+                         const methodHandle& method,
+                         int osr_bci,
+                         int comp_level,
+                         int hot_count,
+                         CompileReason compile_reason,
+                         bool is_blocking) {
   Thread* thread = Thread::current();
   _compile_id = compile_id;
   _method = method();
@@ -133,6 +76,33 @@ void CompileTask::initialize(int compile_id,
   _arena_bytes = 0;
 
   _next = nullptr;
+
+  Atomic::add(&_active_tasks, 1, memory_order_relaxed);
+}
+
+CompileTask::~CompileTask() {
+  if (_method_holder != nullptr && JNIHandles::is_weak_global_handle(_method_holder)) {
+    JNIHandles::destroy_weak_global(_method_holder);
+  } else {
+    JNIHandles::destroy_global(_method_holder);
+  }
+  if (_failure_reason_on_C_heap && _failure_reason != nullptr) {
+    os::free((void*) _failure_reason);
+    _failure_reason = nullptr;
+    _failure_reason_on_C_heap = false;
+  }
+
+  if (Atomic::sub(&_active_tasks, 1, memory_order_relaxed) == 0) {
+    MonitorLocker wait_ml(CompileTaskWait_lock);
+    wait_ml.notify_all();
+  }
+}
+
+void CompileTask::wait_for_no_active_tasks() {
+  MonitorLocker locker(CompileTaskWait_lock);
+  while (Atomic::load(&_active_tasks) > 0) {
+    locker.wait();
+  }
 }
 
 /**