Mercurial > hg > truffle

comparison src/share/vm/prims/jvmtiImpl.hpp @ 2491:0654ee04b214

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge with OpenJDK.
author Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date Fri, 22 Apr 2011 15:30:53 +0200
parents 46a56fac55c7
children d2a62e0f25eb
comparison
equal deleted inserted replaced
2490:29246b1d2d3c 2491:0654ee04b214
449 private: 449 private:
450 typedef enum { 450 typedef enum {
451 TYPE_NONE, 451 TYPE_NONE,
452 TYPE_COMPILED_METHOD_LOAD, 452 TYPE_COMPILED_METHOD_LOAD,
453 TYPE_COMPILED_METHOD_UNLOAD, 453 TYPE_COMPILED_METHOD_UNLOAD,
454 TYPE_FLUSH // pseudo-event used to implement flush_queue() 454 TYPE_DYNAMIC_CODE_GENERATED
455 } Type; 455 } Type;
456 456
457 Type _type; 457 Type _type;
458 union { 458 union {
459 nmethod* compiled_method_load; 459 nmethod* compiled_method_load;
460 struct { 460 struct {
461 nmethod* nm;
461 jmethodID method_id; 462 jmethodID method_id;
462 const void* code_begin; 463 const void* code_begin;
463 } compiled_method_unload; 464 } compiled_method_unload;
464 int* flush_state_addr; 465 struct {
466 const char* name;
467 const void* code_begin;
468 const void* code_end;
469 } dynamic_code_generated;
465 } _event_data; 470 } _event_data;
466 471
467 JvmtiDeferredEvent(Type t) : _type(t) {} 472 JvmtiDeferredEvent(Type t) : _type(t) {}
468
469 void set_compiled_method_load(nmethod* nm) {
470 assert(_type == TYPE_COMPILED_METHOD_LOAD, "must be");
471 _event_data.compiled_method_load = nm;
472 }
473
474 nmethod* compiled_method_load() const {
475 assert(_type == TYPE_COMPILED_METHOD_LOAD, "must be");
476 return _event_data.compiled_method_load;
477 }
478
479 void set_compiled_method_unload(jmethodID id, const void* code) {
480 assert(_type == TYPE_COMPILED_METHOD_UNLOAD, "must be");
481 _event_data.compiled_method_unload.method_id = id;
482 _event_data.compiled_method_unload.code_begin = code;
483 }
484
485 jmethodID compiled_method_unload_method_id() const {
486 assert(_type == TYPE_COMPILED_METHOD_UNLOAD, "must be");
487 return _event_data.compiled_method_unload.method_id;
488 }
489
490 const void* compiled_method_unload_code_begin() const {
491 assert(_type == TYPE_COMPILED_METHOD_UNLOAD, "must be");
492 return _event_data.compiled_method_unload.code_begin;
493 }
494
495 bool is_flush_event() const { return _type == TYPE_FLUSH; }
496
497 int* flush_state_addr() const {
498 assert(is_flush_event(), "must be");
499 return _event_data.flush_state_addr;
500 }
501
502 void set_flush_state_addr(int* flag) {
503 assert(is_flush_event(), "must be");
504 _event_data.flush_state_addr = flag;
505 }
506 473
507 public: 474 public:
508 475
509 JvmtiDeferredEvent() : _type(TYPE_NONE) {} 476 JvmtiDeferredEvent() : _type(TYPE_NONE) {}
510 477
511 // Factory methods 478 // Factory methods
512 static JvmtiDeferredEvent compiled_method_load_event(nmethod* nm) 479 static JvmtiDeferredEvent compiled_method_load_event(nmethod* nm)
513 KERNEL_RETURN_(JvmtiDeferredEvent()); 480 KERNEL_RETURN_(JvmtiDeferredEvent());
514 static JvmtiDeferredEvent compiled_method_unload_event( 481 static JvmtiDeferredEvent compiled_method_unload_event(nmethod* nm,
515 jmethodID id, const void* code) KERNEL_RETURN_(JvmtiDeferredEvent()); 482 jmethodID id, const void* code) KERNEL_RETURN_(JvmtiDeferredEvent());
483 static JvmtiDeferredEvent dynamic_code_generated_event(
484 const char* name, const void* begin, const void* end)
485 KERNEL_RETURN_(JvmtiDeferredEvent());
516 486
517 // Actually posts the event. 487 // Actually posts the event.
518 void post() KERNEL_RETURN; 488 void post() KERNEL_RETURN;
519 }; 489 };
520 490
546 static volatile QueueNode* _pending_list; // Uses CAS for read/update 516 static volatile QueueNode* _pending_list; // Uses CAS for read/update
547 517
548 // Transfers events from the _pending_list to the _queue. 518 // Transfers events from the _pending_list to the _queue.
549 static void process_pending_events() KERNEL_RETURN; 519 static void process_pending_events() KERNEL_RETURN;
550 520
551 static void flush_complete(int* flush_state) KERNEL_RETURN;
552
553 public: 521 public:
554 // Must be holding Service_lock when calling these 522 // Must be holding Service_lock when calling these
555 static bool has_events() KERNEL_RETURN_(false); 523 static bool has_events() KERNEL_RETURN_(false);
556 static void enqueue(const JvmtiDeferredEvent& event) KERNEL_RETURN; 524 static void enqueue(const JvmtiDeferredEvent& event) KERNEL_RETURN;
557 static JvmtiDeferredEvent dequeue() KERNEL_RETURN_(JvmtiDeferredEvent()); 525 static JvmtiDeferredEvent dequeue() KERNEL_RETURN_(JvmtiDeferredEvent());
558
559 // This call blocks until all events enqueued prior to this call
560 // have been posted. The Service_lock is acquired and waited upon.
561 //
562 // Implemented by creating a "flush" event and placing it in the queue.
563 // When the flush event is "posted" it will call flush_complete(), which
564 // will release the caller.
565 //
566 // Can be called by any thread (maybe even the service thread itself).
567 // Not necessary for the caller to be a JavaThread.
568 static void flush_queue(Thread* current) KERNEL_RETURN;
569 526
570 // Used to enqueue events without using a lock, for times (such as during 527 // Used to enqueue events without using a lock, for times (such as during
571 // safepoint) when we can't or don't want to lock the Service_lock. 528 // safepoint) when we can't or don't want to lock the Service_lock.
572 // 529 //
573 // Events will be held off to the side until there's a call to 530 // Events will be held off to the side until there's a call to