src/hotspot/share/runtime/thread.cpp
changeset 58282 03fce7b04b42
parent 58279 448fe2bfd505
child 58291 a013100f7a35
equal deleted inserted replaced
58281:49836127542b 58282:03fce7b04b42
  1551 }
  1551 }
  1552 
  1552 
  1553 // Attempt to enlarge the array for per thread counters.
  1553 // Attempt to enlarge the array for per thread counters.
  1554 jlong* resize_counters_array(jlong* old_counters, int current_size, int new_size) {
  1554 jlong* resize_counters_array(jlong* old_counters, int current_size, int new_size) {
  1555   jlong* new_counters = NEW_C_HEAP_ARRAY(jlong, new_size, mtJVMCI);
  1555   jlong* new_counters = NEW_C_HEAP_ARRAY(jlong, new_size, mtJVMCI);
  1556   if (new_counters == NULL) {
       
  1557     return NULL;
       
  1558   }
       
  1559   if (old_counters == NULL) {
  1556   if (old_counters == NULL) {
  1560     old_counters = new_counters;
  1557     old_counters = new_counters;
  1561     memset(old_counters, 0, sizeof(jlong) * new_size);
  1558     memset(old_counters, 0, sizeof(jlong) * new_size);
  1562   } else {
  1559   } else {
  1563     for (int i = 0; i < MIN2((int) current_size, new_size); i++) {
  1560     for (int i = 0; i < MIN2((int) current_size, new_size); i++) {
  1570   }
  1567   }
  1571   return new_counters;
  1568   return new_counters;
  1572 }
  1569 }
  1573 
  1570 
  1574 // Attempt to enlarge the array for per thread counters.
  1571 // Attempt to enlarge the array for per thread counters.
  1575 bool JavaThread::resize_counters(int current_size, int new_size) {
  1572 void JavaThread::resize_counters(int current_size, int new_size) {
  1576   jlong* new_counters = resize_counters_array(_jvmci_counters, current_size, new_size);
  1573   _jvmci_counters = resize_counters_array(_jvmci_counters, current_size, new_size);
  1577   if (new_counters == NULL) {
       
  1578     return false;
       
  1579   } else {
       
  1580     _jvmci_counters = new_counters;
       
  1581     return true;
       
  1582   }
       
  1583 }
  1574 }
  1584 
  1575 
  1585 class VM_JVMCIResizeCounters : public VM_Operation {
  1576 class VM_JVMCIResizeCounters : public VM_Operation {
  1586  private:
  1577  private:
  1587   int _new_size;
  1578   int _new_size;
  1588   bool _failed;
       
  1589 
  1579 
  1590  public:
  1580  public:
  1591   VM_JVMCIResizeCounters(int new_size) : _new_size(new_size), _failed(false) { }
  1581   VM_JVMCIResizeCounters(int new_size) : _new_size(new_size) { }
  1592   VMOp_Type type()                  const        { return VMOp_JVMCIResizeCounters; }
  1582   VMOp_Type type()                  const        { return VMOp_JVMCIResizeCounters; }
  1593   bool allow_nested_vm_operations() const        { return true; }
  1583   bool allow_nested_vm_operations() const        { return true; }
  1594   void doit() {
  1584   void doit() {
  1595     // Resize the old thread counters array
  1585     // Resize the old thread counters array
  1596     jlong* new_counters = resize_counters_array(JavaThread::_jvmci_old_thread_counters, JVMCICounterSize, _new_size);
  1586     jlong* new_counters = resize_counters_array(JavaThread::_jvmci_old_thread_counters, JVMCICounterSize, _new_size);
  1597     if (new_counters == NULL) {
  1587     JavaThread::_jvmci_old_thread_counters = new_counters;
  1598       _failed = true;
       
  1599       return;
       
  1600     } else {
       
  1601       JavaThread::_jvmci_old_thread_counters = new_counters;
       
  1602     }
       
  1603 
  1588 
  1604     // Now resize each threads array
  1589     // Now resize each threads array
  1605     for (JavaThreadIteratorWithHandle jtiwh; JavaThread *tp = jtiwh.next(); ) {
  1590     for (JavaThreadIteratorWithHandle jtiwh; JavaThread *tp = jtiwh.next(); ) {
  1606       if (!tp->resize_counters(JVMCICounterSize, _new_size)) {
  1591       tp->resize_counters(JVMCICounterSize, _new_size);
  1607         _failed = true;
  1592     }
  1608         break;
  1593     JVMCICounterSize = _new_size;
  1609       }
  1594   }
  1610     }
       
  1611     if (!_failed) {
       
  1612       JVMCICounterSize = _new_size;
       
  1613     }
       
  1614   }
       
  1615 
       
  1616   bool failed() { return _failed; }
       
  1617 };
  1595 };
  1618 
  1596 
  1619 bool JavaThread::resize_all_jvmci_counters(int new_size) {
  1597 void JavaThread::resize_all_jvmci_counters(int new_size) {
  1620   VM_JVMCIResizeCounters op(new_size);
  1598   VM_JVMCIResizeCounters op(new_size);
  1621   VMThread::execute(&op);
  1599   VMThread::execute(&op);
  1622   return !op.failed();
       
  1623 }
  1600 }
  1624 
  1601 
  1625 #endif // INCLUDE_JVMCI
  1602 #endif // INCLUDE_JVMCI
  1626 
  1603 
  1627 // A JavaThread is a normal Java thread
  1604 // A JavaThread is a normal Java thread