357 //
358 // Stat load
359 //
360 class ZStatLoad : public AllStatic {
361 public:
362 static void print();
363 };
364
365 //
366 // Stat mark
367 //
368 class ZStatMark : public AllStatic {
369 private:
370 static size_t _nstripes;
371 static size_t _nproactiveflush;
372 static size_t _nterminateflush;
373 static size_t _ntrycomplete;
374 static size_t _ncontinue;
375
376 public:
377 static void set_at_mark_start(size_t nstripes) {
378 _nstripes = nstripes;
379 }
380
381 static void set_at_mark_end(size_t nproactiveflush,
382 size_t nterminateflush,
383 size_t ntrycomplete,
384 size_t ncontinue) {
385 _nproactiveflush = nproactiveflush;
386 _nterminateflush = nterminateflush;
387 _ntrycomplete = ntrycomplete;
388 _ncontinue = ncontinue;
389 }
390
391 static void print();
392 };
393
394 //
395 // Stat relocation
396 //
397 class ZStatRelocation : public AllStatic {
398 private:
399 static size_t _relocating;
400 static bool _success;
401
402 public:
403 static void set_at_select_relocation_set(size_t relocating) {
404 _relocating = relocating;
405 }
406
407 static void set_at_relocate_end(bool success) {
408 _success = success;
409 }
410
411 static void print();
412 };
413
414 //
415 // Stat nmethods
416 //
417 class ZStatNMethods : public AllStatic {
418 public:
419 static void print();
420 };
421
422 //
423 // Stat references
424 //
425 class ZStatReferences : public AllStatic {
426 private:
427 static struct ZCount {
428 size_t encountered;
429 size_t discovered;
430 size_t dropped;
431 size_t enqueued;
432 } _soft, _weak, _final, _phantom;
433
434 static void set(ZCount* count, size_t encountered, size_t dropped, size_t enqueued) {
435 count->encountered = encountered;
436 count->discovered = dropped + enqueued;
437 count->dropped = dropped;
438 count->enqueued = enqueued;
439 }
440
441 static void print(const char* name, const ZCount& ref);
442
443 public:
444 static void set_soft(size_t encountered, size_t dropped, size_t enqueued) {
445 set(&_soft, encountered, dropped, enqueued);
446 }
447
448 static void set_weak(size_t encountered, size_t dropped, size_t enqueued) {
449 set(&_weak, encountered, dropped, enqueued);
450 }
451
452 static void set_final(size_t encountered, size_t dropped, size_t enqueued) {
453 set(&_final, encountered, dropped, enqueued);
454 }
455
456 static void set_phantom(size_t encountered, size_t dropped, size_t enqueued) {
457 set(&_phantom, encountered, dropped, enqueued);
458 }
459
460 static void print();
461 };
462
463 //
464 // Stat heap
465 //
466 class ZStatHeap : public AllStatic {
467 private:
468 static struct ZAtInitialize {
469 size_t max_capacity;
470 size_t max_reserve;
471 } _at_initialize;
472
473 static struct ZAtMarkStart {
474 size_t capacity;
475 size_t reserve;
476 size_t used;
477 size_t free;
478 } _at_mark_start;
498 } _at_relocate_start;
499
500 static struct ZAtRelocateEnd {
501 size_t capacity;
502 size_t capacity_high;
503 size_t capacity_low;
504 size_t reserve;
505 size_t reserve_high;
506 size_t reserve_low;
507 size_t garbage;
508 size_t allocated;
509 size_t reclaimed;
510 size_t used;
511 size_t used_high;
512 size_t used_low;
513 size_t free;
514 size_t free_high;
515 size_t free_low;
516 } _at_relocate_end;
517
518 static size_t available(size_t used) {
519 return _at_initialize.max_capacity - used;
520 }
521
522 static size_t reserve(size_t used) {
523 return MIN2(_at_initialize.max_reserve, available(used));
524 }
525
526 static size_t free(size_t used) {
527 return available(used) - reserve(used);
528 }
529
530 public:
531 static void set_at_initialize(size_t max_capacity,
532 size_t max_reserve) {
533 _at_initialize.max_capacity = max_capacity;
534 _at_initialize.max_reserve = max_reserve;
535 }
536
537 static void set_at_mark_start(size_t capacity,
538 size_t used) {
539 _at_mark_start.capacity = capacity;
540 _at_mark_start.reserve = reserve(used);
541 _at_mark_start.used = used;
542 _at_mark_start.free = free(used);
543 }
544
545 static void set_at_mark_end(size_t capacity,
546 size_t allocated,
547 size_t used) {
548 _at_mark_end.capacity = capacity;
549 _at_mark_end.reserve = reserve(used);
550 _at_mark_end.allocated = allocated;
551 _at_mark_end.used = used;
552 _at_mark_end.free = free(used);
553 }
554
555 static void set_at_select_relocation_set(size_t live,
556 size_t garbage,
557 size_t reclaimed) {
558 _at_mark_end.live = live;
559 _at_mark_end.garbage = garbage;
560
561 _at_relocate_start.garbage = garbage - reclaimed;
562 _at_relocate_start.reclaimed = reclaimed;
563 }
564
565 static void set_at_relocate_start(size_t capacity,
566 size_t allocated,
567 size_t used) {
568 _at_relocate_start.capacity = capacity;
569 _at_relocate_start.reserve = reserve(used);
570 _at_relocate_start.allocated = allocated;
571 _at_relocate_start.used = used;
572 _at_relocate_start.free = free(used);
573 }
574
575 static void set_at_relocate_end(size_t capacity,
576 size_t allocated,
577 size_t reclaimed,
578 size_t used,
579 size_t used_high,
580 size_t used_low) {
581 _at_relocate_end.capacity = capacity;
582 _at_relocate_end.capacity_high = capacity;
583 _at_relocate_end.capacity_low = _at_mark_start.capacity;
584 _at_relocate_end.reserve = reserve(used);
585 _at_relocate_end.reserve_high = reserve(used_high);
586 _at_relocate_end.reserve_low = reserve(used_low);
587 _at_relocate_end.garbage = _at_mark_end.garbage - reclaimed;
588 _at_relocate_end.allocated = allocated;
589 _at_relocate_end.reclaimed = reclaimed;
590 _at_relocate_end.used = used;
591 _at_relocate_end.used_high = used_high;
592 _at_relocate_end.used_low = used_low;
593 _at_relocate_end.free = free(used);
594 _at_relocate_end.free_high = free(used_low);
595 _at_relocate_end.free_low = free(used_high);
596 }
597
598 static size_t max_capacity() {
599 return _at_initialize.max_capacity;
600 }
601
602 static size_t used_at_mark_start() {
603 return _at_mark_start.used;
604 }
605
606 static size_t used_at_relocate_end() {
607 return _at_relocate_end.used;
608 }
609
610 static void print();
611 };
612
613 #endif // SHARE_GC_Z_ZSTAT_HPP
|
357 //
358 // Stat load
359 //
360 class ZStatLoad : public AllStatic {
361 public:
362 static void print();
363 };
364
365 //
366 // Stat mark
367 //
368 class ZStatMark : public AllStatic {
369 private:
370 static size_t _nstripes;
371 static size_t _nproactiveflush;
372 static size_t _nterminateflush;
373 static size_t _ntrycomplete;
374 static size_t _ncontinue;
375
376 public:
377 static void set_at_mark_start(size_t nstripes);
378 static void set_at_mark_end(size_t nproactiveflush,
379 size_t nterminateflush,
380 size_t ntrycomplete,
381 size_t ncontinue);
382
383 static void print();
384 };
385
386 //
387 // Stat relocation
388 //
389 class ZStatRelocation : public AllStatic {
390 private:
391 static size_t _relocating;
392 static bool _success;
393
394 public:
395 static void set_at_select_relocation_set(size_t relocating);
396 static void set_at_relocate_end(bool success);
397
398 static void print();
399 };
400
401 //
402 // Stat nmethods
403 //
404 class ZStatNMethods : public AllStatic {
405 public:
406 static void print();
407 };
408
409 //
410 // Stat references
411 //
412 class ZStatReferences : public AllStatic {
413 private:
414 static struct ZCount {
415 size_t encountered;
416 size_t discovered;
417 size_t dropped;
418 size_t enqueued;
419 } _soft, _weak, _final, _phantom;
420
421 static void set(ZCount* count, size_t encountered, size_t dropped, size_t enqueued);
422 static void print(const char* name, const ZCount& ref);
423
424 public:
425 static void set_soft(size_t encountered, size_t dropped, size_t enqueued);
426 static void set_weak(size_t encountered, size_t dropped, size_t enqueued);
427 static void set_final(size_t encountered, size_t dropped, size_t enqueued);
428 static void set_phantom(size_t encountered, size_t dropped, size_t enqueued);
429
430 static void print();
431 };
432
433 //
434 // Stat heap
435 //
436 class ZStatHeap : public AllStatic {
437 private:
438 static struct ZAtInitialize {
439 size_t max_capacity;
440 size_t max_reserve;
441 } _at_initialize;
442
443 static struct ZAtMarkStart {
444 size_t capacity;
445 size_t reserve;
446 size_t used;
447 size_t free;
448 } _at_mark_start;
468 } _at_relocate_start;
469
470 static struct ZAtRelocateEnd {
471 size_t capacity;
472 size_t capacity_high;
473 size_t capacity_low;
474 size_t reserve;
475 size_t reserve_high;
476 size_t reserve_low;
477 size_t garbage;
478 size_t allocated;
479 size_t reclaimed;
480 size_t used;
481 size_t used_high;
482 size_t used_low;
483 size_t free;
484 size_t free_high;
485 size_t free_low;
486 } _at_relocate_end;
487
488 static size_t available(size_t used);
489 static size_t reserve(size_t used);
490 static size_t free(size_t used);
491
492 public:
493 static void set_at_initialize(size_t max_capacity,
494 size_t max_reserve);
495 static void set_at_mark_start(size_t capacity,
496 size_t used);
497 static void set_at_mark_end(size_t capacity,
498 size_t allocated,
499 size_t used);
500 static void set_at_select_relocation_set(size_t live,
501 size_t garbage,
502 size_t reclaimed);
503 static void set_at_relocate_start(size_t capacity,
504 size_t allocated,
505 size_t used);
506 static void set_at_relocate_end(size_t capacity,
507 size_t allocated,
508 size_t reclaimed,
509 size_t used,
510 size_t used_high,
511 size_t used_low);
512
513 static size_t max_capacity();
514 static size_t used_at_mark_start();
515 static size_t used_at_relocate_end();
516
517 static void print();
518 };
519
520 #endif // SHARE_GC_Z_ZSTAT_HPP
|