Mercurial > hg > graal-jvmci-8
view src/share/vm/runtime/osThread.hpp @ 2368:dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
6627787: CMS: JVM refuses to start up with -Xms16m -Xmx16m
7000125: CMS: Anti-monotone young gen sizing with respect to maximum whole heap size specification
7027529: CMS: retire CMSUseOldDefaults flag
Summary: Simplify CMS heap sizing code, relying on ergonomic initial sizing consistent with other collectors for the most part, controlling only young gen sizing to rein in pause times. Make CMS young gen sizing default statically cpu-dependant. Remove inconsistencies wrt generation sizing and policy code, allowing for the fixing for 6627787 and 7000125. For 7027529, retire the flag CMSUseOldDefaults which had been introduced as a bridge from JDK 5 to JDK 6 a number of years ago.
Reviewed-by: brutisso, poonam
author | ysr |
---|---|
date | Wed, 16 Mar 2011 10:37:08 -0700 |
parents | 828eafbd85cc |
children | 083f13976b51 |
line wrap: on
line source
/* * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #ifndef SHARE_VM_RUNTIME_OSTHREAD_HPP #define SHARE_VM_RUNTIME_OSTHREAD_HPP #include "runtime/frame.hpp" #include "runtime/handles.hpp" #include "runtime/javaFrameAnchor.hpp" #include "runtime/objectMonitor.hpp" #include "utilities/top.hpp" // The OSThread class holds OS-specific thread information. It is equivalent // to the sys_thread_t structure of the classic JVM implementation. // The thread states represented by the ThreadState values are platform-specific // and are likely to be only approximate, because most OSes don't give you access // to precise thread state information. // Note: the ThreadState is legacy code and is not correctly implemented. // Uses of ThreadState need to be replaced by the state in the JavaThread. enum ThreadState { ALLOCATED, // Memory has been allocated but not initialized INITIALIZED, // The thread has been initialized but yet started RUNNABLE, // Has been started and is runnable, but not necessarily running MONITOR_WAIT, // Waiting on a contended monitor lock CONDVAR_WAIT, // Waiting on a condition variable OBJECT_WAIT, // Waiting on an Object.wait() call BREAKPOINTED, // Suspended at breakpoint SLEEPING, // Thread.sleep() ZOMBIE // All done, but not reclaimed yet }; // I'd make OSThread a ValueObj embedded in Thread to avoid an indirection, but // the assembler test in java.cpp expects that it can install the OSThread of // the main thread into its own Thread at will. class OSThread: public CHeapObj { friend class VMStructs; private: //void* _start_proc; // Thread start routine OSThreadStartFunc _start_proc; // Thread start routine void* _start_parm; // Thread start routine parameter volatile ThreadState _state; // Thread state *hint* jint _interrupted; // Thread.isInterrupted state // Note: _interrupted must be jint, so that Java intrinsics can access it. // The value stored there must be either 0 or 1. It must be possible // for Java to emulate Thread.currentThread().isInterrupted() by performing // the double indirection Thread::current()->_osthread->_interrupted. // Methods public: void set_state(ThreadState state) { _state = state; } ThreadState get_state() { return _state; } // Constructor OSThread(OSThreadStartFunc start_proc, void* start_parm); // Destructor ~OSThread(); // Accessors OSThreadStartFunc start_proc() const { return _start_proc; } void set_start_proc(OSThreadStartFunc start_proc) { _start_proc = start_proc; } void* start_parm() const { return _start_parm; } void set_start_parm(void* start_parm) { _start_parm = start_parm; } bool interrupted() const { return _interrupted != 0; } void set_interrupted(bool z) { _interrupted = z ? 1 : 0; } // Printing void print_on(outputStream* st) const; void print() const { print_on(tty); } // For java intrinsics: static ByteSize interrupted_offset() { return byte_offset_of(OSThread, _interrupted); } // Platform dependent stuff #ifdef TARGET_OS_FAMILY_linux # include "osThread_linux.hpp" #endif #ifdef TARGET_OS_FAMILY_solaris # include "osThread_solaris.hpp" #endif #ifdef TARGET_OS_FAMILY_windows # include "osThread_windows.hpp" #endif }; // Utility class for use with condition variables: class OSThreadWaitState : public StackObj { OSThread* _osthread; ThreadState _old_state; public: OSThreadWaitState(OSThread* osthread, bool is_object_wait) { _osthread = osthread; _old_state = osthread->get_state(); if (is_object_wait) { osthread->set_state(OBJECT_WAIT); } else { osthread->set_state(CONDVAR_WAIT); } } ~OSThreadWaitState() { _osthread->set_state(_old_state); } }; // Utility class for use with contended monitors: class OSThreadContendState : public StackObj { OSThread* _osthread; ThreadState _old_state; public: OSThreadContendState(OSThread* osthread) { _osthread = osthread; _old_state = osthread->get_state(); osthread->set_state(MONITOR_WAIT); } ~OSThreadContendState() { _osthread->set_state(_old_state); } }; #endif // SHARE_VM_RUNTIME_OSTHREAD_HPP