549 caps.can_generate_sampled_alloc_events = 1;
550 caps.can_get_source_file_name = 1;
551 caps.can_generate_garbage_collection_events = 1;
552 if (check_error((*jvmti)->AddCapabilities(jvmti, &caps), "Add capabilities")){
553 return JNI_ERR;
554 }
555
556 if (check_error((*jvmti)->SetEventCallbacks(jvmti, &callbacks,
557 sizeof(jvmtiEventCallbacks)),
558 " Set Event Callbacks")) {
559 return JNI_ERR;
560 }
561 return JNI_OK;
562 }
563
564 JNIEXPORT void JNICALL
565 Java_MyPackage_HeapMonitor_setSamplingRate(JNIEnv* env, jclass cls, jint value) {
566 (*jvmti)->SetHeapSamplingRate(jvmti, value);
567 }
568
569 JNIEXPORT void JNICALL
570 Java_MyPackage_HeapMonitor_setGarbageHistory(JNIEnv* env, jclass cls, jint value) {
571 event_storage_set_garbage_history(&global_event_storage, value);
572 }
573
574 JNIEXPORT jboolean JNICALL
575 Java_MyPackage_HeapMonitor_eventStorageIsEmpty(JNIEnv* env, jclass cls) {
576 return event_storage_get_count(&global_event_storage) == 0;
577 }
578
579 JNIEXPORT jint JNICALL
580 Java_MyPackage_HeapMonitor_getEventStorageElementCount(JNIEnv* env, jclass cls) {
581 return event_storage_get_count(&global_event_storage);
582 }
583
584 JNIEXPORT void JNICALL
585 Java_MyPackage_HeapMonitor_enableSamplingEvents(JNIEnv* env, jclass cls) {
586 enable_notifications();
587 }
588
625 }
626
627 JNIEXPORT jboolean JNICALL
628 Java_MyPackage_HeapMonitorNoCapabilityTest_allSamplingMethodsFail(JNIEnv *env,
629 jclass cls) {
630 jvmtiCapabilities caps;
631 memset(&caps, 0, sizeof(caps));
632 caps.can_generate_sampled_alloc_events = 1;
633 if (check_error((*jvmti)->RelinquishCapabilities(jvmti, &caps),
634 "Add capabilities\n")){
635 return FALSE;
636 }
637
638 if (check_capability_error((*jvmti)->SetHeapSamplingRate(jvmti, 1<<19),
639 "Set Heap Sampling Rate")) {
640 return FALSE;
641 }
642 return TRUE;
643 }
644
645 JNIEXPORT jdouble JNICALL
646 Java_MyPackage_HeapMonitorStatRateTest_getAverageRate(JNIEnv *env, jclass cls) {
647 return event_storage_get_average_rate(&global_event_storage);
648 }
649
650 typedef struct sThreadsFound {
651 jthread* threads;
652 int num_threads;
653 } ThreadsFound;
654
655 static void find_threads_in_array(ThreadsFound* thread_data,
656 ObjectTrace** array,
657 int array_size) {
658 int i;
659 jthread* threads = thread_data->threads;
660 int num_threads = thread_data->num_threads;
661
662 for (i = 0; i < array_size; i++) {
663 ObjectTrace* object = array[i];
664
696 threads[num_threads] = thread;
697 num_threads++;
698 }
699 }
700 thread_data->num_threads = num_threads;
701 }
702
703 JNIEXPORT jboolean JNICALL
704 Java_MyPackage_HeapMonitorThreadTest_checkSamples(JNIEnv* env, jclass cls,
705 jint num_threads) {
706 pthread_mutex_lock(&global_event_storage.storage_mutex);
707 jint trace_counter;
708
709 ThreadsFound thread_data;
710 thread_data.num_threads = 0;
711 thread_data.threads = malloc(sizeof(jthread) * num_threads);
712 memset(thread_data.threads, 0, sizeof(jthread) * num_threads);
713
714 find_threads_in_array(&thread_data, global_event_storage.live_objects,
715 global_event_storage.live_object_count);
716 find_threads_in_array(&thread_data,
717 global_event_storage.garbage_collected_objects,
718 global_event_storage.garbage_history_size);
719
720 free(thread_data.threads);
721 pthread_mutex_unlock(&global_event_storage.storage_mutex);
722 return thread_data.num_threads == num_threads;
723 }
724
725 #ifdef __cplusplus
726 }
727 #endif
|
549 caps.can_generate_sampled_alloc_events = 1;
550 caps.can_get_source_file_name = 1;
551 caps.can_generate_garbage_collection_events = 1;
552 if (check_error((*jvmti)->AddCapabilities(jvmti, &caps), "Add capabilities")){
553 return JNI_ERR;
554 }
555
556 if (check_error((*jvmti)->SetEventCallbacks(jvmti, &callbacks,
557 sizeof(jvmtiEventCallbacks)),
558 " Set Event Callbacks")) {
559 return JNI_ERR;
560 }
561 return JNI_OK;
562 }
563
564 JNIEXPORT void JNICALL
565 Java_MyPackage_HeapMonitor_setSamplingRate(JNIEnv* env, jclass cls, jint value) {
566 (*jvmti)->SetHeapSamplingRate(jvmti, value);
567 }
568
569 // TODO: should be removed, no tests using it.
570 JNIEXPORT void JNICALL
571 Java_MyPackage_HeapMonitor_setGarbageHistory(JNIEnv* env, jclass cls, jint value) {
572 event_storage_set_garbage_history(&global_event_storage, value);
573 }
574
575 JNIEXPORT jboolean JNICALL
576 Java_MyPackage_HeapMonitor_eventStorageIsEmpty(JNIEnv* env, jclass cls) {
577 return event_storage_get_count(&global_event_storage) == 0;
578 }
579
580 JNIEXPORT jint JNICALL
581 Java_MyPackage_HeapMonitor_getEventStorageElementCount(JNIEnv* env, jclass cls) {
582 return event_storage_get_count(&global_event_storage);
583 }
584
585 JNIEXPORT void JNICALL
586 Java_MyPackage_HeapMonitor_enableSamplingEvents(JNIEnv* env, jclass cls) {
587 enable_notifications();
588 }
589
626 }
627
628 JNIEXPORT jboolean JNICALL
629 Java_MyPackage_HeapMonitorNoCapabilityTest_allSamplingMethodsFail(JNIEnv *env,
630 jclass cls) {
631 jvmtiCapabilities caps;
632 memset(&caps, 0, sizeof(caps));
633 caps.can_generate_sampled_alloc_events = 1;
634 if (check_error((*jvmti)->RelinquishCapabilities(jvmti, &caps),
635 "Add capabilities\n")){
636 return FALSE;
637 }
638
639 if (check_capability_error((*jvmti)->SetHeapSamplingRate(jvmti, 1<<19),
640 "Set Heap Sampling Rate")) {
641 return FALSE;
642 }
643 return TRUE;
644 }
645
646 JNIEXPORT jboolean JNICALL
647 Java_MyPackage_HeapMonitorIllegalArgumentTest_testIllegalArgument(JNIEnv *env,
648 jclass cls) {
649 if (check_error((*jvmti)->SetHeapSamplingRate(jvmti, 0),
650 "Sampling rate 0 failed\n")){
651 return FALSE;
652 }
653
654 if (check_error((*jvmti)->SetHeapSamplingRate(jvmti, 1024),
655 "Sampling rate 1024 failed\n")){
656 return FALSE;
657 }
658
659 if (!check_error((*jvmti)->SetHeapSamplingRate(jvmti, -1),
660 "Sampling rate -1 passed\n")){
661 return FALSE;
662 }
663
664 if (!check_error((*jvmti)->SetHeapSamplingRate(jvmti, -1024),
665 "Sampling rate -1024 passed\n")){
666 return FALSE;
667 }
668
669 return TRUE;
670 }
671
672 JNIEXPORT jdouble JNICALL
673 Java_MyPackage_HeapMonitorStatRateTest_getAverageRate(JNIEnv *env, jclass cls) {
674 return event_storage_get_average_rate(&global_event_storage);
675 }
676
677 typedef struct sThreadsFound {
678 jthread* threads;
679 int num_threads;
680 } ThreadsFound;
681
682 static void find_threads_in_array(ThreadsFound* thread_data,
683 ObjectTrace** array,
684 int array_size) {
685 int i;
686 jthread* threads = thread_data->threads;
687 int num_threads = thread_data->num_threads;
688
689 for (i = 0; i < array_size; i++) {
690 ObjectTrace* object = array[i];
691
723 threads[num_threads] = thread;
724 num_threads++;
725 }
726 }
727 thread_data->num_threads = num_threads;
728 }
729
730 JNIEXPORT jboolean JNICALL
731 Java_MyPackage_HeapMonitorThreadTest_checkSamples(JNIEnv* env, jclass cls,
732 jint num_threads) {
733 pthread_mutex_lock(&global_event_storage.storage_mutex);
734 jint trace_counter;
735
736 ThreadsFound thread_data;
737 thread_data.num_threads = 0;
738 thread_data.threads = malloc(sizeof(jthread) * num_threads);
739 memset(thread_data.threads, 0, sizeof(jthread) * num_threads);
740
741 find_threads_in_array(&thread_data, global_event_storage.live_objects,
742 global_event_storage.live_object_count);
743
744 free(thread_data.threads);
745 pthread_mutex_unlock(&global_event_storage.storage_mutex);
746 fprintf(stderr, "Obtained %d - %d\n",
747 thread_data.num_threads,
748 num_threads);
749 return thread_data.num_threads == num_threads;
750 }
751
752 #ifdef __cplusplus
753 }
754 #endif
|