From nobody Mon Sep 17 00:00:00 2001 From: Pavel Afremov Date: Fri, 6 Apr 2007 19:42:16 +0400 Subject: [PATCH] Fix broken finalization work balance subsystem. --- vm/gc_cc/src/gc_for_vm.cpp | 9 + vm/tests/smoke/gc/SynchronizedFinalizersTest.java | 130 ++++++++++++++++++++ vm/tests/smoke/gc/SynchronizedFinilazersTest.java | 127 -------------------- vm/vmcore/src/init/finalize.cpp | 14 +- .../javasrc/java/lang/FinalizerThread.java | 2 5 files changed, 148 insertions(+), 134 deletions(-) create mode 100644 vm/tests/smoke/gc/SynchronizedFinalizersTest.java delete mode 100644 vm/tests/smoke/gc/SynchronizedFinilazersTest.java 60d8d651eeaa99155e9220cbcedfa05218548292 diff --git a/vm/gc_cc/src/gc_for_vm.cpp b/vm/gc_cc/src/gc_for_vm.cpp index 85ef5cb..c9a8476 100644 --- a/vm/gc_cc/src/gc_for_vm.cpp +++ b/vm/gc_cc/src/gc_for_vm.cpp @@ -37,6 +37,8 @@ static hythread_tls_key_t tls_key_curren fast_list finalizible_objects; +static unsigned int pending_finalizers_hint_counter = 0; + #ifdef POINTER64 GCExport Boolean gc_supports_compressed_references() { vtable_base = (Ptr) vm_get_vtable_base(); @@ -233,9 +235,16 @@ Managed_Object_Handle gc_alloc(unsigned unsigned size = get_instance_data_size(in_size); if (gcvt->is_finalizible()) { + pending_finalizers_hint_counter++; unsigned char *obj; unsigned char *endpos; bool allocated = place_into_old_objects(obj, endpos, size); + + if (pending_finalizers_hint_counter > 100) { + pending_finalizers_hint_counter = 0; + pending_finalizers = true; + } + if (allocated) { memset(obj, 0, size); finalizible_objects.push_back((Partial_Reveal_Object*) obj); diff --git a/vm/tests/smoke/gc/SynchronizedFinalizersTest.java b/vm/tests/smoke/gc/SynchronizedFinalizersTest.java new file mode 100644 index 0000000..4aee62f --- /dev/null +++ b/vm/tests/smoke/gc/SynchronizedFinalizersTest.java @@ -0,0 +1,130 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/** + * @author Pavel Afremov + * @version $Revision: 1.8.8.3.4.3 $ + */ + +package gc; + +/** + * Tests synchronized finalizers in multiple threads. + */ +public class SynchronizedFinalizersTest implements Runnable { + int n; + byte[] array; + + static final int N_THREADS = 100; + static final int N_OBJECTS = 300; + static final int OBJECT_SIZE = 20000; + + static int started = 0; + static int finished = 0; + static int created = 0; + static int finalized = 0; + + static boolean stop = false; + + public SynchronizedFinalizersTest(int nn) { + n=nn; + synchronized(SynchronizedFinalizersTest.class) { + created++; + array = new byte[OBJECT_SIZE]; + checkPass(); + } + } + + public static void main(String[] args) { + updateInfo(); + + for (int i=0;ifinalize_thread_flags & (FINALIZER_STARTER | FINALIZER_THREAD)) != 0) { TRACE2("finalize", "recursive finalization prevented"); - //return; + return; } p_TLS_vmthread->finalize_thread_flags |= FINALIZER_STARTER; @@ -401,7 +401,7 @@ void Objects_To_Finalize::run_finalizers exn_clear(); if (FRAME_COMPILATION == - (FRAME_COMPILATION | m2n_get_frame_type(m2n_get_last_frame()))) { + (FRAME_COMPILATION & m2n_get_frame_type(m2n_get_last_frame()))) { assert(work_lock); IDATA r = jthread_monitor_try_enter(work_lock); @@ -615,10 +615,12 @@ void vm_run_pending_finalizers() NativeObjectHandles nhs; assert(hythread_is_suspend_enabled()); /* BEGIN: modified for NATIVE FINALIZER THREAD */ - if(get_native_finalizer_thread_flag()) + if(get_native_finalizer_thread_flag()) { activate_finalizer_threads(FALSE); - else + } + else { objects_to_finalize.run_finalizers(); + } /* END: modified for NATIVE FINALIZER THREAD */ } //vm_run_pending_finalizers @@ -626,7 +628,7 @@ int vm_do_finalization(int quantity) { assert(hythread_is_suspend_enabled()); return objects_to_finalize.do_finalization(quantity); -} //vm_run_pending_finalizers +} //vm_do_finalization bool is_it_finalize_thread() { return ((p_TLS_vmthread->finalize_thread_flags & FINALIZER_THREAD) != 0); diff --git a/vm/vmcore/src/kernel_classes/javasrc/java/lang/FinalizerThread.java b/vm/vmcore/src/kernel_classes/javasrc/java/lang/FinalizerThread.java index 630c69e..f8895c6 100644 --- a/vm/vmcore/src/kernel_classes/javasrc/java/lang/FinalizerThread.java +++ b/vm/vmcore/src/kernel_classes/javasrc/java/lang/FinalizerThread.java @@ -254,7 +254,7 @@ class FinalizerThread extends Thread { FinalizerThread newThread = null; if (waitFinishCounter >= MAX_THREADS) { - // do nothing + Thread.yield(); } else { try { for (int i = 0; i < processorsQuantity; i++) { -- 1.3.3