8208671: Runtime, JFR, Serviceability changes to allow enabling -Wreorder
Reviewed-by: dholmes, hseigel
This commit is contained in:
parent
e98c176026
commit
9c0720b156
src/hotspot/share
classfile
classLoaderData.cppclassLoaderData.hppclassLoaderHierarchyDCmd.cppclassLoaderStats.hppdefaultMethods.cppdictionary.cppjavaClasses.cppstackMapFrame.cppstackMapFrame.hppstringTable.cpp
interpreter
jfr
dcmd
instrumentation
leakprofiler/sampling
periodic/sampling
recorder
checkpoint/types
service
stacktrace
libadt
logging
memory
heapInspection.hppmetaspace.cpp
metaspace
metachunk.cppmetaspaceDCmd.cppprintCLDMetaspaceInfoClosure.cppspaceManager.cppvirtualSpaceList.cppvirtualSpaceNode.cppvirtualSpaceNode.hpp
virtualspace.cppoops
prims
runtime
services
diagnosticCommand.cppheapDumper.hppmallocSiteTable.hppmemBaseline.hppthreadService.cppthreadService.hpp
utilities
test/hotspot/gtest
@ -142,19 +142,22 @@ void ClassLoaderData::initialize_name(Handle class_loader) {
|
||||
}
|
||||
|
||||
ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_anonymous) :
|
||||
_is_anonymous(is_anonymous),
|
||||
_metaspace(NULL),
|
||||
_metaspace_lock(new Mutex(Monitor::leaf+1, "Metaspace allocation lock", true,
|
||||
Monitor::_safepoint_check_never)),
|
||||
_unloading(false), _is_anonymous(is_anonymous),
|
||||
_modified_oops(true), _accumulated_modified_oops(false),
|
||||
// An anonymous class loader data doesn't have anything to keep
|
||||
// it from being unloaded during parsing of the anonymous class.
|
||||
// The null-class-loader should always be kept alive.
|
||||
_keep_alive((is_anonymous || h_class_loader.is_null()) ? 1 : 0),
|
||||
_metaspace(NULL), _unloading(false), _klasses(NULL),
|
||||
_modules(NULL), _packages(NULL), _unnamed_module(NULL), _dictionary(NULL),
|
||||
_claimed(0), _modified_oops(true), _accumulated_modified_oops(false),
|
||||
_jmethod_ids(NULL), _handles(), _deallocate_list(NULL),
|
||||
_claimed(0),
|
||||
_handles(),
|
||||
_klasses(NULL), _packages(NULL), _modules(NULL), _unnamed_module(NULL), _dictionary(NULL),
|
||||
_jmethod_ids(NULL),
|
||||
_deallocate_list(NULL),
|
||||
_next(NULL),
|
||||
_class_loader_klass(NULL), _name(NULL), _name_and_id(NULL),
|
||||
_metaspace_lock(new Mutex(Monitor::leaf+1, "Metaspace allocation lock", true,
|
||||
Monitor::_safepoint_check_never)) {
|
||||
_class_loader_klass(NULL), _name(NULL), _name_and_id(NULL) {
|
||||
|
||||
if (!h_class_loader.is_null()) {
|
||||
_class_loader = _handles.add(h_class_loader());
|
||||
|
@ -185,7 +185,7 @@ class ClassLoaderData : public CHeapObj<mtClass> {
|
||||
volatile juint _size;
|
||||
Chunk* _next;
|
||||
|
||||
Chunk(Chunk* c) : _next(c), _size(0) { }
|
||||
Chunk(Chunk* c) : _size(0), _next(c) { }
|
||||
};
|
||||
|
||||
Chunk* volatile _head;
|
||||
|
@ -299,7 +299,7 @@ public:
|
||||
|
||||
LoaderTreeNode(const oop loader_oop)
|
||||
: _loader_oop(loader_oop), _cld(NULL), _child(NULL), _next(NULL),
|
||||
_classes(NULL), _anon_classes(NULL), _num_classes(0), _num_anon_classes(0),
|
||||
_classes(NULL), _num_classes(0), _anon_classes(NULL), _num_anon_classes(0),
|
||||
_num_folded(0)
|
||||
{}
|
||||
|
||||
|
@ -87,8 +87,8 @@ public:
|
||||
_chunk_sz(0),
|
||||
_block_sz(0),
|
||||
_classes_count(0),
|
||||
_anon_block_sz(0),
|
||||
_anon_chunk_sz(0),
|
||||
_anon_block_sz(0),
|
||||
_anon_classes_count(0) {
|
||||
}
|
||||
};
|
||||
@ -118,11 +118,11 @@ protected:
|
||||
public:
|
||||
ClassLoaderStatsClosure(outputStream* out) :
|
||||
_out(out),
|
||||
_stats(new StatsTable()),
|
||||
_total_loaders(0),
|
||||
_total_block_sz(0),
|
||||
_total_chunk_sz(0),
|
||||
_total_classes(0),
|
||||
_stats(new StatsTable()) {
|
||||
_total_chunk_sz(0),
|
||||
_total_block_sz(0) {
|
||||
}
|
||||
|
||||
virtual void do_cld(ClassLoaderData* cld);
|
||||
|
@ -688,8 +688,8 @@ class FindMethodsByErasedSig : public HierarchyVisitor<FindMethodsByErasedSig> {
|
||||
|
||||
public:
|
||||
FindMethodsByErasedSig(Symbol* name, Symbol* signature, bool is_interf) :
|
||||
_method_name(name), _method_signature(signature), _cur_class_is_interface(is_interf),
|
||||
_family(NULL) {}
|
||||
_method_name(name), _method_signature(signature), _family(NULL),
|
||||
_cur_class_is_interface(is_interf) {}
|
||||
|
||||
void get_discovered_family(MethodFamily** family) {
|
||||
if (_family != NULL) {
|
||||
|
@ -53,16 +53,16 @@ size_t Dictionary::entry_size() {
|
||||
}
|
||||
|
||||
Dictionary::Dictionary(ClassLoaderData* loader_data, int table_size, bool resizable)
|
||||
: _loader_data(loader_data), _resizable(resizable), _needs_resizing(false),
|
||||
Hashtable<InstanceKlass*, mtClass>(table_size, (int)entry_size()) {
|
||||
: Hashtable<InstanceKlass*, mtClass>(table_size, (int)entry_size()),
|
||||
_resizable(resizable), _needs_resizing(false), _loader_data(loader_data) {
|
||||
};
|
||||
|
||||
|
||||
Dictionary::Dictionary(ClassLoaderData* loader_data,
|
||||
int table_size, HashtableBucket<mtClass>* t,
|
||||
int number_of_entries, bool resizable)
|
||||
: _loader_data(loader_data), _resizable(resizable), _needs_resizing(false),
|
||||
Hashtable<InstanceKlass*, mtClass>(table_size, (int)entry_size(), t, number_of_entries) {
|
||||
: Hashtable<InstanceKlass*, mtClass>(table_size, (int)entry_size(), t, number_of_entries),
|
||||
_resizable(resizable), _needs_resizing(false), _loader_data(loader_data) {
|
||||
};
|
||||
|
||||
Dictionary::~Dictionary() {
|
||||
|
@ -2005,7 +2005,7 @@ class BacktraceBuilder: public StackObj {
|
||||
public:
|
||||
|
||||
// constructor for new backtrace
|
||||
BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL), _mirrors(NULL), _names(NULL) {
|
||||
BacktraceBuilder(TRAPS): _head(NULL), _methods(NULL), _bcis(NULL), _mirrors(NULL), _names(NULL) {
|
||||
expand(CHECK);
|
||||
_backtrace = Handle(THREAD, _head);
|
||||
_index = 0;
|
||||
@ -2102,7 +2102,7 @@ struct BacktraceElement : public StackObj {
|
||||
Symbol* _name;
|
||||
Handle _mirror;
|
||||
BacktraceElement(Handle mirror, int mid, int version, int bci, Symbol* name) :
|
||||
_mirror(mirror), _method_id(mid), _version(version), _bci(bci), _name(name) {}
|
||||
_method_id(mid), _bci(bci), _version(version), _name(name), _mirror(mirror) {}
|
||||
};
|
||||
|
||||
class BacktraceIterator : public StackObj {
|
||||
|
@ -33,8 +33,8 @@
|
||||
|
||||
StackMapFrame::StackMapFrame(u2 max_locals, u2 max_stack, ClassVerifier* v) :
|
||||
_offset(0), _locals_size(0), _stack_size(0),
|
||||
_stack_mark(0), _flags(0), _max_locals(max_locals),
|
||||
_max_stack(max_stack), _verifier(v) {
|
||||
_stack_mark(0), _max_locals(max_locals),
|
||||
_max_stack(max_stack), _flags(0), _verifier(v) {
|
||||
Thread* thr = v->thread();
|
||||
_locals = NEW_RESOURCE_ARRAY_IN_THREAD(thr, VerificationType, max_locals);
|
||||
_stack = NEW_RESOURCE_ARRAY_IN_THREAD(thr, VerificationType, max_stack);
|
||||
|
@ -105,12 +105,12 @@ class StackMapFrame : public ResourceObj {
|
||||
u2 max_stack,
|
||||
VerificationType* locals,
|
||||
VerificationType* stack,
|
||||
ClassVerifier* v) : _offset(offset), _flags(flags),
|
||||
ClassVerifier* v) : _offset(offset),
|
||||
_locals_size(locals_size),
|
||||
_stack_size(stack_size),
|
||||
_stack_mark(-1),
|
||||
_max_locals(max_locals),
|
||||
_max_stack(max_stack),
|
||||
_max_stack(max_stack), _flags(flags),
|
||||
_locals(locals), _stack(stack),
|
||||
_verifier(v) { }
|
||||
|
||||
|
@ -122,7 +122,7 @@ class StringTableLookupJchar : StackObj {
|
||||
|
||||
public:
|
||||
StringTableLookupJchar(Thread* thread, uintx hash, const jchar* key, int len)
|
||||
: _thread(thread), _hash(hash), _str(key), _len(len) {
|
||||
: _thread(thread), _hash(hash), _len(len), _str(key) {
|
||||
}
|
||||
uintx get_hash() const {
|
||||
return _hash;
|
||||
|
@ -159,21 +159,21 @@ class LinkInfo : public StackObj {
|
||||
LinkInfo(Klass* resolved_klass, Symbol* name, Symbol* signature, Klass* current_klass,
|
||||
AccessCheck check_access = needs_access_check,
|
||||
constantTag tag = JVM_CONSTANT_Invalid) :
|
||||
_resolved_klass(resolved_klass),
|
||||
_name(name), _signature(signature), _current_klass(current_klass), _current_method(methodHandle()),
|
||||
_name(name),
|
||||
_signature(signature), _resolved_klass(resolved_klass), _current_klass(current_klass), _current_method(methodHandle()),
|
||||
_check_access(check_access == needs_access_check), _tag(tag) {}
|
||||
|
||||
LinkInfo(Klass* resolved_klass, Symbol* name, Symbol* signature, const methodHandle& current_method,
|
||||
AccessCheck check_access = needs_access_check,
|
||||
constantTag tag = JVM_CONSTANT_Invalid) :
|
||||
_resolved_klass(resolved_klass),
|
||||
_name(name), _signature(signature), _current_klass(current_method->method_holder()), _current_method(current_method),
|
||||
_name(name),
|
||||
_signature(signature), _resolved_klass(resolved_klass), _current_klass(current_method->method_holder()), _current_method(current_method),
|
||||
_check_access(check_access == needs_access_check), _tag(tag) {}
|
||||
|
||||
// Case where we just find the method and don't check access against the current class
|
||||
LinkInfo(Klass* resolved_klass, Symbol*name, Symbol* signature) :
|
||||
_resolved_klass(resolved_klass),
|
||||
_name(name), _signature(signature), _current_klass(NULL), _current_method(methodHandle()),
|
||||
_name(name),
|
||||
_signature(signature), _resolved_klass(resolved_klass), _current_klass(NULL), _current_method(methodHandle()),
|
||||
_check_access(false), _tag(JVM_CONSTANT_Invalid) {}
|
||||
|
||||
// accessors
|
||||
|
@ -345,8 +345,8 @@ JfrStartFlightRecordingDCmd::JfrStartFlightRecordingDCmd(outputStream* output,
|
||||
_settings("settings", "Settings file(s), e.g. profile or default. See JRE_HOME/lib/jfr", "STRING SET", false),
|
||||
_delay("delay", "Delay recording start with (s)econds, (m)inutes), (h)ours), or (d)ays, e.g. 5h.", "NANOTIME", false, "0"),
|
||||
_duration("duration", "Duration of recording in (s)econds, (m)inutes, (h)ours, or (d)ays, e.g. 300s.", "NANOTIME", false, "0"),
|
||||
_filename("filename", "Resulting recording filename, e.g. \\\"" JFR_FILENAME_EXAMPLE "\\\"", "STRING", false),
|
||||
_disk("disk", "Recording should be persisted to disk", "BOOLEAN", false),
|
||||
_filename("filename", "Resulting recording filename, e.g. \\\"" JFR_FILENAME_EXAMPLE "\\\"", "STRING", false),
|
||||
_maxage("maxage", "Maximum time to keep recorded data (on disk) in (s)econds, (m)inutes, (h)ours, or (d)ays, e.g. 60m, or 0 for no limit", "NANOTIME", false, "0"),
|
||||
_maxsize("maxsize", "Maximum amount of bytes to keep (on disk) in (k)B, (M)B or (G)B, e.g. 500M, or 0 for no limit", "MEMORY SIZE", false, "0"),
|
||||
_dump_on_exit("dumponexit", "Dump running recording when JVM shuts down", "BOOLEAN", false),
|
||||
|
@ -265,8 +265,8 @@ class AnnotationElementIterator : public StackObj {
|
||||
AnnotationElementIterator(const InstanceKlass* ik, address buffer, u2 limit) : _ik(ik),
|
||||
_buffer(buffer),
|
||||
_limit(limit),
|
||||
_next(element_name_offset),
|
||||
_current(element_name_offset) {
|
||||
_current(element_name_offset),
|
||||
_next(element_name_offset) {
|
||||
assert(_buffer != NULL, "invariant");
|
||||
assert(_next == element_name_offset, "invariant");
|
||||
assert(_current == element_name_offset, "invariant");
|
||||
@ -319,10 +319,10 @@ class AnnotationIterator : public StackObj {
|
||||
|
||||
public:
|
||||
AnnotationIterator(const InstanceKlass* ik, AnnotationArray* ar) : _ik(ik),
|
||||
_current(0),
|
||||
_next(0),
|
||||
_limit(ar != NULL ? ar->length() : 0),
|
||||
_buffer(_limit > 2 ? ar->adr_at(2) : NULL) {
|
||||
_buffer(_limit > 2 ? ar->adr_at(2) : NULL),
|
||||
_current(0),
|
||||
_next(0) {
|
||||
if (_buffer != NULL) {
|
||||
_limit -= 2; // subtract sizeof(u2) number of annotations field
|
||||
}
|
||||
|
@ -31,9 +31,9 @@ SampleList::SampleList(size_t limit, size_t cache_size) :
|
||||
_free_list(),
|
||||
_in_use_list(),
|
||||
_last_resolved(NULL),
|
||||
_allocated(0),
|
||||
_limit(limit),
|
||||
_cache_size(cache_size),
|
||||
_allocated(0) {
|
||||
_cache_size(cache_size) {
|
||||
}
|
||||
|
||||
SampleList::~SampleList() {
|
||||
|
@ -37,7 +37,7 @@ class JfrGetCallTrace : public StackObj {
|
||||
bool _in_java;
|
||||
|
||||
public:
|
||||
JfrGetCallTrace(bool in_java, JavaThread* thread) : _in_java(in_java), _thread(thread) {}
|
||||
JfrGetCallTrace(bool in_java, JavaThread* thread) : _thread(thread), _in_java(in_java) {}
|
||||
bool find_top_frame(frame& topframe, Method** method, frame& first_frame);
|
||||
bool get_topframe(void* ucontext, frame& top);
|
||||
};
|
||||
|
@ -28,7 +28,7 @@
|
||||
#include "oops/oop.inline.hpp"
|
||||
#include "oops/symbol.hpp"
|
||||
|
||||
JfrSymbolId::JfrSymbolId() : _symbol_id_counter(0), _sym_table(new SymbolTable(this)), _cstring_table(new CStringTable(this)) {
|
||||
JfrSymbolId::JfrSymbolId() : _sym_table(new SymbolTable(this)), _cstring_table(new CStringTable(this)), _symbol_id_counter(0) {
|
||||
assert(_sym_table != NULL, "invariant");
|
||||
assert(_cstring_table != NULL, "invariant");
|
||||
initialize();
|
||||
|
@ -239,8 +239,8 @@ JfrRecorderService::JfrRecorderService() :
|
||||
_checkpoint_manager(JfrCheckpointManager::instance()),
|
||||
_chunkwriter(JfrRepository::chunkwriter()),
|
||||
_repository(JfrRepository::instance()),
|
||||
_storage(JfrStorage::instance()),
|
||||
_stack_trace_repository(JfrStackTraceRepository::instance()),
|
||||
_storage(JfrStorage::instance()),
|
||||
_string_pool(JfrStringPool::instance()) {}
|
||||
|
||||
void JfrRecorderService::start() {
|
||||
|
@ -78,8 +78,8 @@ class JfrStackTrace : public StackObj {
|
||||
_id(0),
|
||||
_nr_of_frames(0),
|
||||
_hash(0),
|
||||
_reached_root(false),
|
||||
_max_frames(max_frames),
|
||||
_reached_root(false),
|
||||
_lineno(false) {}
|
||||
bool record_thread(JavaThread& thread, frame& frame);
|
||||
bool record_safe(JavaThread* thread, int skip, bool leakp = false);
|
||||
|
@ -54,8 +54,8 @@ public:
|
||||
// doubled in size; the total amount of EXTRA times all hash functions are
|
||||
// computed for the doubling is no more than the current size - thus the
|
||||
// doubling in size costs no more than a constant factor in speed.
|
||||
Dict::Dict(CmpKey initcmp, Hash inithash) : _hash(inithash), _cmp(initcmp),
|
||||
_arena(Thread::current()->resource_area()) {
|
||||
Dict::Dict(CmpKey initcmp, Hash inithash) : _arena(Thread::current()->resource_area()),
|
||||
_hash(inithash), _cmp(initcmp) {
|
||||
int i;
|
||||
|
||||
// Precompute table of null character hashes
|
||||
@ -74,7 +74,7 @@ Dict::Dict(CmpKey initcmp, Hash inithash) : _hash(inithash), _cmp(initcmp),
|
||||
}
|
||||
|
||||
Dict::Dict(CmpKey initcmp, Hash inithash, Arena *arena, int size)
|
||||
: _hash(inithash), _cmp(initcmp), _arena(arena) {
|
||||
: _arena(arena), _hash(inithash), _cmp(initcmp) {
|
||||
int i;
|
||||
|
||||
// Precompute table of null character hashes
|
||||
@ -161,7 +161,7 @@ void Dict::doubhash(void) {
|
||||
|
||||
//------------------------------Dict-----------------------------------------
|
||||
// Deep copy a dictionary.
|
||||
Dict::Dict( const Dict &d ) : _size(d._size), _cnt(d._cnt), _hash(d._hash),_cmp(d._cmp), _arena(d._arena) {
|
||||
Dict::Dict( const Dict &d ) : _arena(d._arena), _size(d._size), _cnt(d._cnt), _hash(d._hash), _cmp(d._cmp) {
|
||||
_bin = (bucket*)_arena->Amalloc_4(sizeof(bucket)*_size);
|
||||
memcpy( (void*)_bin, (void*)d._bin, sizeof(bucket)*_size );
|
||||
for( uint i=0; i<_size; i++ ) {
|
||||
|
@ -44,9 +44,9 @@ char LogFileOutput::_vm_start_time_str[StartTimeBufferSize];
|
||||
|
||||
LogFileOutput::LogFileOutput(const char* name)
|
||||
: LogFileStreamOutput(NULL), _name(os::strdup_check_oom(name, mtLogging)),
|
||||
_file_name(NULL), _archive_name(NULL), _archive_name_len(0),
|
||||
_rotate_size(DefaultFileSize), _file_count(DefaultFileCount),
|
||||
_current_size(0), _current_file(0), _rotation_semaphore(1) {
|
||||
_file_name(NULL), _archive_name(NULL), _current_file(0),
|
||||
_file_count(DefaultFileCount), _archive_name_len(0),
|
||||
_rotate_size(DefaultFileSize), _current_size(0), _rotation_semaphore(1) {
|
||||
assert(strstr(name, Prefix) == name, "invalid output name '%s': missing prefix: %s", name, Prefix);
|
||||
_file_name = make_file_name(name + strlen(Prefix), _pid_str, _vm_start_time_str);
|
||||
}
|
||||
|
@ -72,7 +72,7 @@ class LogMessageBuffer : public StackObj {
|
||||
|
||||
public:
|
||||
Iterator(const LogMessageBuffer& message, LogLevelType level, LogDecorations& decorations)
|
||||
: _message(message), _level(level), _decorations(decorations), _current_line_index(0) {
|
||||
: _message(message), _current_line_index(0), _level(level), _decorations(decorations) {
|
||||
skip_messages_with_finer_level();
|
||||
}
|
||||
|
||||
|
@ -192,7 +192,7 @@ class KlassInfoEntry: public CHeapObj<mtInternal> {
|
||||
|
||||
public:
|
||||
KlassInfoEntry(Klass* k, KlassInfoEntry* next) :
|
||||
_klass(k), _instance_count(0), _instance_words(0), _next(next), _index(-1),
|
||||
_next(next), _klass(k), _instance_count(0), _instance_words(0), _index(-1),
|
||||
_do_print(false), _subclasses(NULL)
|
||||
{}
|
||||
~KlassInfoEntry();
|
||||
|
@ -1364,8 +1364,8 @@ bool Metaspace::contains_non_shared(const void* ptr) {
|
||||
// ClassLoaderMetaspace
|
||||
|
||||
ClassLoaderMetaspace::ClassLoaderMetaspace(Mutex* lock, Metaspace::MetaspaceType type)
|
||||
: _lock(lock)
|
||||
, _space_type(type)
|
||||
: _space_type(type)
|
||||
, _lock(lock)
|
||||
, _vsm(NULL)
|
||||
, _class_vsm(NULL)
|
||||
{
|
||||
|
@ -53,13 +53,13 @@ size_t Metachunk::overhead() {
|
||||
Metachunk::Metachunk(ChunkIndex chunktype, bool is_class, size_t word_size,
|
||||
VirtualSpaceNode* container)
|
||||
: Metabase<Metachunk>(word_size),
|
||||
_container(container),
|
||||
_top(NULL),
|
||||
_sentinel(CHUNK_SENTINEL),
|
||||
_chunk_type(chunktype),
|
||||
_is_class(is_class),
|
||||
_sentinel(CHUNK_SENTINEL),
|
||||
_origin(origin_normal),
|
||||
_use_count(0),
|
||||
_top(NULL),
|
||||
_container(container)
|
||||
_use_count(0)
|
||||
{
|
||||
_top = initial_top();
|
||||
set_is_tagged_free(false);
|
||||
|
@ -35,14 +35,14 @@ MetaspaceDCmd::MetaspaceDCmd(outputStream* output, bool heap)
|
||||
: DCmdWithParser(output, heap)
|
||||
, _basic("basic", "Prints a basic summary (does not need a safepoint).", "BOOLEAN", false, "false")
|
||||
, _show_loaders("show-loaders", "Shows usage by class loader.", "BOOLEAN", false, "false")
|
||||
, _show_classes("show-classes", "If show-loaders is set, shows loaded classes for each loader.", "BOOLEAN", false, "false")
|
||||
, _by_chunktype("by-chunktype", "Break down numbers by chunk type.", "BOOLEAN", false, "false")
|
||||
, _by_spacetype("by-spacetype", "Break down numbers by loader type.", "BOOLEAN", false, "false")
|
||||
, _by_chunktype("by-chunktype", "Break down numbers by chunk type.", "BOOLEAN", false, "false")
|
||||
, _show_vslist("vslist", "Shows details about the underlying virtual space.", "BOOLEAN", false, "false")
|
||||
, _show_vsmap("vsmap", "Shows chunk composition of the underlying virtual spaces", "BOOLEAN", false, "false")
|
||||
, _scale("scale", "Memory usage in which to scale. Valid values are: 1, KB, MB or GB (fixed scale) "
|
||||
"or \"dynamic\" for a dynamically choosen scale.",
|
||||
"STRING", false, "dynamic")
|
||||
"STRING", false, "dynamic")
|
||||
, _show_classes("show-classes", "If show-loaders is set, shows loaded classes for each loader.", "BOOLEAN", false, "false")
|
||||
{
|
||||
_dcmdparser.add_dcmd_option(&_basic);
|
||||
_dcmdparser.add_dcmd_option(&_show_loaders);
|
||||
|
@ -38,7 +38,7 @@ PrintCLDMetaspaceInfoClosure::PrintCLDMetaspaceInfoClosure(outputStream* out, si
|
||||
bool do_print_classes, bool break_down_by_chunktype)
|
||||
: _out(out), _scale(scale), _do_print(do_print), _do_print_classes(do_print_classes)
|
||||
, _break_down_by_chunktype(break_down_by_chunktype)
|
||||
, _num_loaders(0), _num_loaders_unloading(0), _num_loaders_without_metaspace(0)
|
||||
, _num_loaders(0), _num_loaders_without_metaspace(0), _num_loaders_unloading(0)
|
||||
{
|
||||
memset(_num_loaders_by_spacetype, 0, sizeof(_num_loaders_by_spacetype));
|
||||
}
|
||||
|
@ -228,16 +228,15 @@ void SpaceManager::print_on(outputStream* st) const {
|
||||
SpaceManager::SpaceManager(Metaspace::MetadataType mdtype,
|
||||
Metaspace::MetaspaceType space_type,//
|
||||
Mutex* lock) :
|
||||
_lock(lock),
|
||||
_mdtype(mdtype),
|
||||
_space_type(space_type),
|
||||
_chunk_list(NULL),
|
||||
_current_chunk(NULL),
|
||||
_overhead_words(0),
|
||||
_capacity_words(0),
|
||||
_used_words(0),
|
||||
_overhead_words(0),
|
||||
_block_freelists(NULL),
|
||||
_lock(lock),
|
||||
_chunk_list(NULL),
|
||||
_current_chunk(NULL)
|
||||
{
|
||||
_block_freelists(NULL) {
|
||||
Metadebug::init_allocation_fail_alot_count();
|
||||
memset(_num_chunks_by_type, 0, sizeof(_num_chunks_by_type));
|
||||
log_trace(gc, metaspace, freelist)("SpaceManager(): " PTR_FORMAT, p2i(this));
|
||||
|
@ -149,9 +149,9 @@ void VirtualSpaceList::retire_current_virtual_space() {
|
||||
}
|
||||
|
||||
VirtualSpaceList::VirtualSpaceList(size_t word_size) :
|
||||
_is_class(false),
|
||||
_virtual_space_list(NULL),
|
||||
_current_virtual_space(NULL),
|
||||
_is_class(false),
|
||||
_reserved_words(0),
|
||||
_committed_words(0),
|
||||
_virtual_space_count(0) {
|
||||
@ -161,9 +161,9 @@ VirtualSpaceList::VirtualSpaceList(size_t word_size) :
|
||||
}
|
||||
|
||||
VirtualSpaceList::VirtualSpaceList(ReservedSpace rs) :
|
||||
_is_class(true),
|
||||
_virtual_space_list(NULL),
|
||||
_current_virtual_space(NULL),
|
||||
_is_class(true),
|
||||
_reserved_words(0),
|
||||
_committed_words(0),
|
||||
_virtual_space_count(0) {
|
||||
|
@ -57,7 +57,7 @@ static bool should_commit_large_pages_when_reserving(size_t bytes) {
|
||||
|
||||
// byte_size is the size of the associated virtualspace.
|
||||
VirtualSpaceNode::VirtualSpaceNode(bool is_class, size_t bytes) :
|
||||
_is_class(is_class), _top(NULL), _next(NULL), _rs(), _container_count(0), _occupancy_map(NULL) {
|
||||
_next(NULL), _is_class(is_class), _rs(), _top(NULL), _container_count(0), _occupancy_map(NULL) {
|
||||
assert_is_aligned(bytes, Metaspace::reserve_alignment());
|
||||
bool large_pages = should_commit_large_pages_when_reserving(bytes);
|
||||
_rs = ReservedSpace(bytes, Metaspace::reserve_alignment(), large_pages);
|
||||
|
@ -79,7 +79,7 @@ class VirtualSpaceNode : public CHeapObj<mtClass> {
|
||||
|
||||
VirtualSpaceNode(bool is_class, size_t byte_size);
|
||||
VirtualSpaceNode(bool is_class, ReservedSpace rs) :
|
||||
_is_class(is_class), _top(NULL), _next(NULL), _rs(rs), _container_count(0), _occupancy_map(NULL) {}
|
||||
_next(NULL), _is_class(is_class), _rs(rs), _top(NULL), _container_count(0), _occupancy_map(NULL) {}
|
||||
~VirtualSpaceNode();
|
||||
|
||||
// Convenience functions for logical bottom and end
|
||||
|
@ -36,7 +36,7 @@
|
||||
|
||||
// Dummy constructor
|
||||
ReservedSpace::ReservedSpace() : _base(NULL), _size(0), _noaccess_prefix(0),
|
||||
_alignment(0), _special(false), _executable(false), _fd_for_heap(-1) {
|
||||
_alignment(0), _special(false), _fd_for_heap(-1), _executable(false) {
|
||||
}
|
||||
|
||||
ReservedSpace::ReservedSpace(size_t size, size_t preferred_page_size) : _fd_for_heap(-1) {
|
||||
|
@ -966,7 +966,7 @@ class SymbolHashMapEntry : public CHeapObj<mtSymbol> {
|
||||
void set_value(u2 value) { _value = value; }
|
||||
|
||||
SymbolHashMapEntry(unsigned int hash, Symbol* symbol, u2 value)
|
||||
: _hash(hash), _symbol(symbol), _value(value), _next(NULL) {}
|
||||
: _hash(hash), _next(NULL), _symbol(symbol), _value(value) {}
|
||||
|
||||
}; // End SymbolHashMapEntry class
|
||||
|
||||
|
@ -402,13 +402,13 @@ Array<int>* InstanceKlass::create_new_default_vtable_indices(int len, TRAPS) {
|
||||
|
||||
InstanceKlass::InstanceKlass(const ClassFileParser& parser, unsigned kind, KlassID id) :
|
||||
Klass(id),
|
||||
_nest_members(NULL),
|
||||
_nest_host_index(0),
|
||||
_nest_host(NULL),
|
||||
_static_field_size(parser.static_field_size()),
|
||||
_nonstatic_oop_map_size(nonstatic_oop_map_size(parser.total_oop_map_count())),
|
||||
_itable_len(parser.itable_size()),
|
||||
_reference_type(parser.reference_type()),
|
||||
_nest_members(NULL),
|
||||
_nest_host_index(0),
|
||||
_nest_host(NULL) {
|
||||
_reference_type(parser.reference_type()) {
|
||||
set_vtable_length(parser.vtable_size());
|
||||
set_kind(kind);
|
||||
set_access_flags(parser.access_flags());
|
||||
|
@ -191,9 +191,9 @@ void* Klass::operator new(size_t size, ClassLoaderData* loader_data, size_t word
|
||||
// Need to set the _java_mirror field explicitly to not hit an assert that the field
|
||||
// should be NULL before setting it.
|
||||
Klass::Klass(KlassID id) : _id(id),
|
||||
_java_mirror(NULL),
|
||||
_prototype_header(markOopDesc::prototype()),
|
||||
_shared_class_path_index(-1),
|
||||
_java_mirror(NULL) {
|
||||
_shared_class_path_index(-1) {
|
||||
CDS_ONLY(_shared_class_flags = 0;)
|
||||
CDS_JAVA_HEAP_ONLY(_archived_mirror = 0;)
|
||||
_primary_supers[0] = this;
|
||||
|
@ -2051,7 +2051,7 @@ class JNIMethodBlock : public CHeapObj<mtClass> {
|
||||
// Something that can't be mistaken for an address or a markOop
|
||||
Method* const JNIMethodBlock::_free_method = (Method*)55;
|
||||
|
||||
JNIMethodBlockNode::JNIMethodBlockNode(int num_methods) : _next(NULL), _top(0) {
|
||||
JNIMethodBlockNode::JNIMethodBlockNode(int num_methods) : _top(0), _next(NULL) {
|
||||
_number_of_methods = MAX2(num_methods, min_block_size);
|
||||
_methods = NEW_C_HEAP_ARRAY(Method*, _number_of_methods, mtInternal);
|
||||
for (int i = 0; i < _number_of_methods; i++) {
|
||||
|
@ -733,7 +733,7 @@ protected:
|
||||
const int _base_off;
|
||||
|
||||
TypeEntries(int base_off)
|
||||
: _base_off(base_off), _pd(NULL) {}
|
||||
: _pd(NULL), _base_off(base_off) {}
|
||||
|
||||
void set_intptr_at(int index, intptr_t value) {
|
||||
_pd->set_intptr_at(index, value);
|
||||
|
@ -41,7 +41,7 @@ private:
|
||||
Thread* _cur_thread;
|
||||
|
||||
public:
|
||||
LoadedClassesClosure(Thread* thread, JvmtiEnv* env) : _cur_thread(thread), _env(env) {
|
||||
LoadedClassesClosure(Thread* thread, JvmtiEnv* env) : _env(env), _cur_thread(thread) {
|
||||
assert(_cur_thread == Thread::current(), "must be current thread");
|
||||
}
|
||||
|
||||
|
@ -531,8 +531,8 @@ VM_GetOrSetLocal::VM_GetOrSetLocal(JavaThread* thread, jint depth, jint index, B
|
||||
, _depth(depth)
|
||||
, _index(index)
|
||||
, _type(type)
|
||||
, _set(false)
|
||||
, _jvf(NULL)
|
||||
, _set(false)
|
||||
, _result(JVMTI_ERROR_NONE)
|
||||
{
|
||||
}
|
||||
@ -545,8 +545,8 @@ VM_GetOrSetLocal::VM_GetOrSetLocal(JavaThread* thread, jint depth, jint index, B
|
||||
, _index(index)
|
||||
, _type(type)
|
||||
, _value(value)
|
||||
, _set(true)
|
||||
, _jvf(NULL)
|
||||
, _set(true)
|
||||
, _result(JVMTI_ERROR_NONE)
|
||||
{
|
||||
}
|
||||
@ -558,8 +558,8 @@ VM_GetOrSetLocal::VM_GetOrSetLocal(JavaThread* thread, JavaThread* calling_threa
|
||||
, _depth(depth)
|
||||
, _index(index)
|
||||
, _type(T_OBJECT)
|
||||
, _set(false)
|
||||
, _jvf(NULL)
|
||||
, _set(false)
|
||||
, _result(JVMTI_ERROR_NONE)
|
||||
{
|
||||
}
|
||||
|
@ -779,7 +779,7 @@ class ClassFieldDescriptor: public CHeapObj<mtInternal> {
|
||||
char _field_type;
|
||||
public:
|
||||
ClassFieldDescriptor(int index, char type, int offset) :
|
||||
_field_index(index), _field_type(type), _field_offset(offset) {
|
||||
_field_index(index), _field_offset(offset), _field_type(type) {
|
||||
}
|
||||
int field_index() const { return _field_index; }
|
||||
char field_type() const { return _field_type; }
|
||||
|
@ -75,8 +75,7 @@ class VM_Handshake: public VM_Operation {
|
||||
HandshakeThreadsOperation* const _op;
|
||||
|
||||
VM_Handshake(HandshakeThreadsOperation* op) :
|
||||
_op(op),
|
||||
_handshake_timeout(TimeHelper::millis_to_counter(HandshakeTimeout)) {}
|
||||
_handshake_timeout(TimeHelper::millis_to_counter(HandshakeTimeout)), _op(op) {}
|
||||
|
||||
void set_handshake(JavaThread* target) {
|
||||
target->set_handshake_operation(_op);
|
||||
|
@ -80,8 +80,7 @@ const char* PerfDataManager::_name_spaces[] = {
|
||||
};
|
||||
|
||||
PerfData::PerfData(CounterNS ns, const char* name, Units u, Variability v)
|
||||
: _name(NULL), _u(u), _v(v), _valuep(NULL),
|
||||
_on_c_heap(false) {
|
||||
: _name(NULL), _v(v), _u(u), _on_c_heap(false), _valuep(NULL) {
|
||||
|
||||
const char* prefix = PerfDataManager::ns_to_string(ns);
|
||||
|
||||
|
@ -614,8 +614,7 @@ private:
|
||||
|
||||
public:
|
||||
ParallelSPCleanupThreadClosure(DeflateMonitorCounters* counters) :
|
||||
_counters(counters),
|
||||
_nmethod_cl(NMethodSweeper::prepare_mark_active_nmethods()) {}
|
||||
_nmethod_cl(NMethodSweeper::prepare_mark_active_nmethods()), _counters(counters) {}
|
||||
|
||||
void do_thread(Thread* thread) {
|
||||
ObjectSynchronizer::deflate_thread_local_monitors(thread, _counters);
|
||||
@ -636,9 +635,9 @@ private:
|
||||
public:
|
||||
ParallelSPCleanupTask(uint num_workers, DeflateMonitorCounters* counters) :
|
||||
AbstractGangTask("Parallel Safepoint Cleanup"),
|
||||
_subtasks(SubTasksDone(SafepointSynchronize::SAFEPOINT_CLEANUP_NUM_TASKS)),
|
||||
_cleanup_threads_cl(ParallelSPCleanupThreadClosure(counters)),
|
||||
_num_workers(num_workers),
|
||||
_subtasks(SubTasksDone(SafepointSynchronize::SAFEPOINT_CLEANUP_NUM_TASKS)),
|
||||
_counters(counters) {}
|
||||
|
||||
void work(uint worker_id) {
|
||||
|
@ -414,8 +414,8 @@ class VM_FindDeadlocks: public VM_Operation {
|
||||
// which protects the JavaThreads in _deadlocks.
|
||||
|
||||
public:
|
||||
VM_FindDeadlocks(bool concurrent_locks) : _concurrent_locks(concurrent_locks), _out(NULL), _deadlocks(NULL), _setter() {};
|
||||
VM_FindDeadlocks(outputStream* st) : _concurrent_locks(true), _out(st), _deadlocks(NULL) {};
|
||||
VM_FindDeadlocks(bool concurrent_locks) : _concurrent_locks(concurrent_locks), _deadlocks(NULL), _out(NULL), _setter() {};
|
||||
VM_FindDeadlocks(outputStream* st) : _concurrent_locks(true), _deadlocks(NULL), _out(st) {};
|
||||
~VM_FindDeadlocks();
|
||||
|
||||
DeadlockCycle* result() { return _deadlocks; };
|
||||
|
@ -560,10 +560,10 @@ int ClassHistogramDCmd::num_arguments() {
|
||||
#define DEFAULT_COLUMNS "InstBytes,KlassBytes,CpAll,annotations,MethodCount,Bytecodes,MethodAll,ROAll,RWAll,Total"
|
||||
ClassStatsDCmd::ClassStatsDCmd(outputStream* output, bool heap) :
|
||||
DCmdWithParser(output, heap),
|
||||
_csv("-csv", "Print in CSV (comma-separated values) format for spreadsheets",
|
||||
"BOOLEAN", false, "false"),
|
||||
_all("-all", "Show all columns",
|
||||
"BOOLEAN", false, "false"),
|
||||
_csv("-csv", "Print in CSV (comma-separated values) format for spreadsheets",
|
||||
"BOOLEAN", false, "false"),
|
||||
_help("-help", "Show meaning of all the columns",
|
||||
"BOOLEAN", false, "false"),
|
||||
_columns("columns", "Comma-separated list of all the columns to show. "
|
||||
|
@ -50,7 +50,7 @@ class HeapDumper : public StackObj {
|
||||
elapsedTimer _t;
|
||||
|
||||
HeapDumper(bool gc_before_heap_dump, bool print_to_tty, bool oome) :
|
||||
_gc_before_heap_dump(gc_before_heap_dump), _error(NULL), _print_to_tty(print_to_tty), _oome(oome) { }
|
||||
_error(NULL), _print_to_tty(print_to_tty), _gc_before_heap_dump(gc_before_heap_dump), _oome(oome) { }
|
||||
|
||||
// string representation of error
|
||||
char* error() const { return _error; }
|
||||
@ -66,7 +66,7 @@ class HeapDumper : public StackObj {
|
||||
|
||||
public:
|
||||
HeapDumper(bool gc_before_heap_dump) :
|
||||
_gc_before_heap_dump(gc_before_heap_dump), _error(NULL), _print_to_tty(false), _oome(false) { }
|
||||
_error(NULL), _print_to_tty(false), _gc_before_heap_dump(gc_before_heap_dump), _oome(false) { }
|
||||
|
||||
~HeapDumper();
|
||||
|
||||
|
@ -146,7 +146,7 @@ class MallocSiteTable : AllStatic {
|
||||
volatile int* _lock;
|
||||
public:
|
||||
AccessLock(volatile int* lock) :
|
||||
_lock(lock), _lock_state(NoLock) {
|
||||
_lock_state(NoLock), _lock(lock) {
|
||||
}
|
||||
|
||||
~AccessLock() {
|
||||
|
@ -88,8 +88,8 @@ class MemBaseline {
|
||||
public:
|
||||
// create a memory baseline
|
||||
MemBaseline():
|
||||
_baseline_type(Not_baselined),
|
||||
_instance_class_count(0), _array_class_count(0) {
|
||||
_instance_class_count(0), _array_class_count(0),
|
||||
_baseline_type(Not_baselined) {
|
||||
}
|
||||
|
||||
bool baseline(bool summaryOnly = true);
|
||||
|
@ -421,7 +421,7 @@ DeadlockCycle* ThreadService::find_deadlocks_at_safepoint(ThreadsList * t_list,
|
||||
return deadlocks;
|
||||
}
|
||||
|
||||
ThreadDumpResult::ThreadDumpResult() : _num_threads(0), _num_snapshots(0), _snapshots(NULL), _next(NULL), _last(NULL), _setter() {
|
||||
ThreadDumpResult::ThreadDumpResult() : _num_threads(0), _num_snapshots(0), _snapshots(NULL), _last(NULL), _next(NULL), _setter() {
|
||||
|
||||
// Create a new ThreadDumpResult object and append to the list.
|
||||
// If GC happens before this function returns, Method*
|
||||
@ -429,7 +429,7 @@ ThreadDumpResult::ThreadDumpResult() : _num_threads(0), _num_snapshots(0), _snap
|
||||
ThreadService::add_thread_dump(this);
|
||||
}
|
||||
|
||||
ThreadDumpResult::ThreadDumpResult(int num_threads) : _num_threads(num_threads), _num_snapshots(0), _snapshots(NULL), _next(NULL), _last(NULL), _setter() {
|
||||
ThreadDumpResult::ThreadDumpResult(int num_threads) : _num_threads(num_threads), _num_snapshots(0), _snapshots(NULL), _last(NULL), _next(NULL), _setter() {
|
||||
// Create a new ThreadDumpResult object and append to the list.
|
||||
// If GC happens before this function returns, oops
|
||||
// will be visited.
|
||||
|
@ -213,8 +213,9 @@ private:
|
||||
|
||||
public:
|
||||
// Dummy snapshot
|
||||
ThreadSnapshot() : _thread(NULL), _threadObj(NULL), _stack_trace(NULL), _concurrent_locks(NULL), _next(NULL),
|
||||
_blocker_object(NULL), _blocker_object_owner(NULL) {};
|
||||
ThreadSnapshot() : _thread(NULL), _threadObj(NULL),
|
||||
_blocker_object(NULL), _blocker_object_owner(NULL),
|
||||
_stack_trace(NULL), _concurrent_locks(NULL), _next(NULL) {};
|
||||
ThreadSnapshot(ThreadsList * t_list, JavaThread* thread);
|
||||
~ThreadSnapshot();
|
||||
|
||||
@ -560,7 +561,7 @@ class JavaThreadBlockedOnMonitorEnterState : public JavaThreadStatusChanger {
|
||||
}
|
||||
|
||||
JavaThreadBlockedOnMonitorEnterState(JavaThread *java_thread, ObjectMonitor *obj_m) :
|
||||
_stat(NULL), _active(false), JavaThreadStatusChanger(java_thread) {
|
||||
JavaThreadStatusChanger(java_thread), _stat(NULL), _active(false) {
|
||||
assert((java_thread != NULL), "Java thread should not be null here");
|
||||
// Change thread status and collect contended enter stats for monitor contended
|
||||
// enter done for external java world objects and it is contended. All other cases
|
||||
|
@ -999,8 +999,8 @@ inline size_t ConcurrentHashTable<VALUE, CONFIG, F>::
|
||||
template <typename VALUE, typename CONFIG, MEMFLAGS F>
|
||||
inline ConcurrentHashTable<VALUE, CONFIG, F>::
|
||||
ConcurrentHashTable(size_t log2size, size_t log2size_limit, size_t grow_hint)
|
||||
: _new_table(NULL), _log2_start_size(log2size),
|
||||
_log2_size_limit(log2size_limit), _grow_hint(grow_hint),
|
||||
: _new_table(NULL), _log2_size_limit(log2size_limit),
|
||||
_log2_start_size(log2size), _grow_hint(grow_hint),
|
||||
_size_limit_reached(false), _resize_lock_owner(NULL),
|
||||
_invisible_epoch(0)
|
||||
{
|
||||
|
@ -48,8 +48,8 @@ class ConcurrentHashTable<VALUE, CONFIG, F>::BucketsOperation {
|
||||
bool _is_mt;
|
||||
|
||||
BucketsOperation(ConcurrentHashTable<VALUE, CONFIG, F>* cht, bool is_mt = false)
|
||||
: _cht(cht), _is_mt(is_mt), _next_to_claim(0), _task_size_log2(DEFAULT_TASK_SIZE_LOG2),
|
||||
_stop_task(0), _size_log2(0) {}
|
||||
: _cht(cht), _next_to_claim(0), _task_size_log2(DEFAULT_TASK_SIZE_LOG2),
|
||||
_stop_task(0), _size_log2(0), _is_mt(is_mt) {}
|
||||
|
||||
// Returns true if you succeeded to claim the range start -> (stop-1).
|
||||
bool claim(size_t* start, size_t* stop) {
|
||||
|
@ -106,9 +106,9 @@ MarkedFileReader::~MarkedFileReader() {
|
||||
}
|
||||
|
||||
ElfFile::ElfFile(const char* filepath) :
|
||||
_string_tables(NULL), _symbol_tables(NULL), _funcDesc_table(NULL),
|
||||
_next(NULL), _status(NullDecoder::no_error),
|
||||
_shdr_string_table(NULL), _file(NULL), _filepath(NULL) {
|
||||
_next(NULL), _filepath(NULL), _file(NULL),
|
||||
_symbol_tables(NULL), _string_tables(NULL), _shdr_string_table(NULL), _funcDesc_table(NULL),
|
||||
_status(NullDecoder::no_error) {
|
||||
memset(&_elfHdr, 0, sizeof(_elfHdr));
|
||||
|
||||
int len = strlen(filepath) + 1;
|
||||
|
@ -31,7 +31,7 @@
|
||||
#include "utilities/elfFuncDescTable.hpp"
|
||||
|
||||
ElfFuncDescTable::ElfFuncDescTable(FILE* file, Elf_Shdr shdr, int index) :
|
||||
_file(file), _index(index), _section(file, shdr) {
|
||||
_section(file, shdr), _file(file), _index(index) {
|
||||
assert(file, "null file handle");
|
||||
// The actual function address (i.e. function entry point) is always the
|
||||
// first value in the function descriptor (on IA64 and PPC64 they look as follows):
|
||||
|
@ -34,7 +34,7 @@
|
||||
// We will try to load whole string table into memory if we can.
|
||||
// Otherwise, fallback to more expensive file operation.
|
||||
ElfStringTable::ElfStringTable(FILE* const file, Elf_Shdr& shdr, int index) :
|
||||
_section(file, shdr), _index(index), _fd(file), _next(NULL) {
|
||||
_next(NULL), _index(index), _section(file, shdr), _fd(file) {
|
||||
_status = _section.status();
|
||||
}
|
||||
|
||||
|
@ -31,7 +31,7 @@
|
||||
#include "utilities/elfSymbolTable.hpp"
|
||||
|
||||
ElfSymbolTable::ElfSymbolTable(FILE* const file, Elf_Shdr& shdr) :
|
||||
_section(file, shdr), _fd(file), _next(NULL) {
|
||||
_next(NULL), _fd(file), _section(file, shdr) {
|
||||
assert(file != NULL, "null file handle");
|
||||
_status = _section.status();
|
||||
|
||||
|
@ -86,11 +86,11 @@ template <class T> class EventLogBase : public EventLog {
|
||||
|
||||
public:
|
||||
EventLogBase<T>(const char* name, int length = LogEventsBufferEntries):
|
||||
_mutex(Mutex::event, name, false, Monitor::_safepoint_check_never),
|
||||
_name(name),
|
||||
_length(length),
|
||||
_count(0),
|
||||
_index(0),
|
||||
_mutex(Mutex::event, name, false, Monitor::_safepoint_check_never) {
|
||||
_count(0) {
|
||||
_records = new EventRecord<T>[length];
|
||||
}
|
||||
|
||||
|
@ -42,8 +42,8 @@ const char* strchrnul_(const char *s, int c) {
|
||||
}
|
||||
|
||||
JSON::JSON(const char* text, bool silent, outputStream* st)
|
||||
: start(text), pos(text), mark(text),
|
||||
level(0), line(1), column(0), silent(silent), _valid(true), _st(st)
|
||||
: _st(st), start(text), pos(text), mark(text),
|
||||
level(0), line(1), column(0), silent(silent), _valid(true)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -104,7 +104,7 @@ double AbsSeq::dsd() const {
|
||||
}
|
||||
|
||||
NumberSeq::NumberSeq(double alpha) :
|
||||
AbsSeq(alpha), _maximum(0.0), _last(0.0) {
|
||||
AbsSeq(alpha), _last(0.0), _maximum(0.0) {
|
||||
}
|
||||
|
||||
bool NumberSeq::check_nums(NumberSeq *total, int n, NumberSeq **parts) {
|
||||
|
@ -33,8 +33,8 @@
|
||||
template <MEMFLAGS F> StackBase<F>::StackBase(size_t segment_size, size_t max_cache_size,
|
||||
size_t max_size):
|
||||
_seg_size(segment_size),
|
||||
_max_cache_size(max_cache_size),
|
||||
_max_size(adjust_max_size(max_size, segment_size))
|
||||
_max_size(adjust_max_size(max_size, segment_size)),
|
||||
_max_cache_size(max_cache_size)
|
||||
{
|
||||
assert(_max_size % _seg_size == 0, "not a multiple");
|
||||
}
|
||||
|
@ -32,7 +32,7 @@
|
||||
#include "unittest.hpp"
|
||||
#include "utilities/ostream.hpp"
|
||||
|
||||
LogTestFixture::LogTestFixture() : _configuration_snapshot(NULL), _n_snapshots(0) {
|
||||
LogTestFixture::LogTestFixture() : _n_snapshots(0), _configuration_snapshot(NULL) {
|
||||
// Set up TestLogFileName to include PID, testcase name and test name
|
||||
int ret = jio_snprintf(_filename, sizeof(_filename), "testlog.pid%d.%s.%s.log",
|
||||
os::current_process_id(),
|
||||
|
@ -85,7 +85,7 @@ struct ValVerify {
|
||||
uintptr_t _val;
|
||||
bool called_get;
|
||||
bool called_insert;
|
||||
ValVerify(uintptr_t val) : called_get(false), called_insert(false), _val(val) {}
|
||||
ValVerify(uintptr_t val) : _val(val), called_get(false), called_insert(false) {}
|
||||
void operator()(bool inserted, uintptr_t* val) {
|
||||
EXPECT_EQ(_val, *val) << "The value inserted is not correct.";
|
||||
if (inserted) {
|
||||
|
Loading…
x
Reference in New Issue
Block a user