< prev index next >

src/share/vm/services/lowMemoryDetector.cpp

Print this page




 276   }
 277 }
 278 
 279 void SensorInfo::oops_do(OopClosure* f) {
 280   f->do_oop((oop*) &_sensor_obj);
 281 }
 282 
 283 void SensorInfo::process_pending_requests(TRAPS) {
 284   int pending_count = pending_trigger_count();
 285   if (pending_clear_count() > 0) {
 286     clear(pending_count, CHECK);
 287   } else {
 288     trigger(pending_count, CHECK);
 289   }
 290 
 291 }
 292 
 293 void SensorInfo::trigger(int count, TRAPS) {
 294   assert(count <= _pending_trigger_count, "just checking");
 295   if (_sensor_obj != NULL) {
 296     Klass* k = Management::sun_management_Sensor_klass(CHECK);
 297     instanceKlassHandle sensorKlass (THREAD, k);
 298     Handle sensor_h(THREAD, _sensor_obj);
 299     Handle usage_h = MemoryService::create_MemoryUsage_obj(_usage, CHECK);
 300 
 301     JavaValue result(T_VOID);
 302     JavaCallArguments args(sensor_h);
 303     args.push_int((int) count);
 304     args.push_oop(usage_h);
 305 
 306     JavaCalls::call_virtual(&result,
 307                             sensorKlass,
 308                             vmSymbols::trigger_name(),
 309                             vmSymbols::trigger_method_signature(),
 310                             &args,
 311                             CHECK);
 312   }
 313 
 314   {
 315     // Holds Service_lock and update the sensor state
 316     MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag);
 317     assert(_pending_trigger_count > 0, "Must have pending trigger");


 320     _pending_trigger_count = _pending_trigger_count - count;
 321   }
 322 }
 323 
 324 void SensorInfo::clear(int count, TRAPS) {
 325   {
 326     // Holds Service_lock and update the sensor state
 327     MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag);
 328     if (_pending_clear_count == 0) {
 329       // Bail out if we lost a race to set_*_sensor_level() which may have
 330       // reactivated the sensor in the meantime because it was triggered again.
 331       return;
 332     }
 333     _sensor_on = false;
 334     _sensor_count += count;
 335     _pending_clear_count = 0;
 336     _pending_trigger_count = _pending_trigger_count - count;
 337   }
 338 
 339   if (_sensor_obj != NULL) {
 340     Klass* k = Management::sun_management_Sensor_klass(CHECK);
 341     instanceKlassHandle sensorKlass (THREAD, k);
 342     Handle sensor(THREAD, _sensor_obj);
 343 
 344     JavaValue result(T_VOID);
 345     JavaCallArguments args(sensor);
 346     args.push_int((int) count);
 347     JavaCalls::call_virtual(&result,
 348                             sensorKlass,
 349                             vmSymbols::clear_name(),
 350                             vmSymbols::int_void_signature(),
 351                             &args,
 352                             CHECK);
 353   }
 354 }
 355 
 356 //--------------------------------------------------------------
 357 // Non-product code
 358 
 359 #ifndef PRODUCT
 360 void SensorInfo::print() {
 361   tty->print_cr("%s count = " SIZE_FORMAT " pending_triggers = %d pending_clears = %d",


 276   }
 277 }
 278 
 279 void SensorInfo::oops_do(OopClosure* f) {
 280   f->do_oop((oop*) &_sensor_obj);
 281 }
 282 
 283 void SensorInfo::process_pending_requests(TRAPS) {
 284   int pending_count = pending_trigger_count();
 285   if (pending_clear_count() > 0) {
 286     clear(pending_count, CHECK);
 287   } else {
 288     trigger(pending_count, CHECK);
 289   }
 290 
 291 }
 292 
 293 void SensorInfo::trigger(int count, TRAPS) {
 294   assert(count <= _pending_trigger_count, "just checking");
 295   if (_sensor_obj != NULL) {
 296     InstanceKlass* sensorKlass = Management::sun_management_Sensor_klass(CHECK);

 297     Handle sensor_h(THREAD, _sensor_obj);
 298     Handle usage_h = MemoryService::create_MemoryUsage_obj(_usage, CHECK);
 299 
 300     JavaValue result(T_VOID);
 301     JavaCallArguments args(sensor_h);
 302     args.push_int((int) count);
 303     args.push_oop(usage_h);
 304 
 305     JavaCalls::call_virtual(&result,
 306                             sensorKlass,
 307                             vmSymbols::trigger_name(),
 308                             vmSymbols::trigger_method_signature(),
 309                             &args,
 310                             CHECK);
 311   }
 312 
 313   {
 314     // Holds Service_lock and update the sensor state
 315     MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag);
 316     assert(_pending_trigger_count > 0, "Must have pending trigger");


 319     _pending_trigger_count = _pending_trigger_count - count;
 320   }
 321 }
 322 
 323 void SensorInfo::clear(int count, TRAPS) {
 324   {
 325     // Holds Service_lock and update the sensor state
 326     MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag);
 327     if (_pending_clear_count == 0) {
 328       // Bail out if we lost a race to set_*_sensor_level() which may have
 329       // reactivated the sensor in the meantime because it was triggered again.
 330       return;
 331     }
 332     _sensor_on = false;
 333     _sensor_count += count;
 334     _pending_clear_count = 0;
 335     _pending_trigger_count = _pending_trigger_count - count;
 336   }
 337 
 338   if (_sensor_obj != NULL) {
 339     InstanceKlass* sensorKlass = Management::sun_management_Sensor_klass(CHECK);

 340     Handle sensor(THREAD, _sensor_obj);
 341 
 342     JavaValue result(T_VOID);
 343     JavaCallArguments args(sensor);
 344     args.push_int((int) count);
 345     JavaCalls::call_virtual(&result,
 346                             sensorKlass,
 347                             vmSymbols::clear_name(),
 348                             vmSymbols::int_void_signature(),
 349                             &args,
 350                             CHECK);
 351   }
 352 }
 353 
 354 //--------------------------------------------------------------
 355 // Non-product code
 356 
 357 #ifndef PRODUCT
 358 void SensorInfo::print() {
 359   tty->print_cr("%s count = " SIZE_FORMAT " pending_triggers = %d pending_clears = %d",
< prev index next >