jdk8-mips64-public/hotspot: comparison src/share/vm/memory/allocation.hpp

-:4d3a43351904
+:833b0f92429a
 /*
-* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2014, 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.
 };
 #endif
 /*
-* MemoryType bitmap layout:
+* Memory types
-* | 16 15 14 13 12 11 10 09 | 08 07 06 05 | 04 03 02 01 |
-* |      memory type        |   object    | reserved    |
-* |                         |     type    |             |
 */
 enum MemoryType {
 // Memory type by sub systems. It occupies lower byte.
-mtNone              = 0x0000,  // undefined
+mtJavaHeap          = 0x00,  // Java heap
-mtClass             = 0x0100,  // memory class for Java classes
+mtClass             = 0x01,  // memory class for Java classes
-mtThread            = 0x0200,  // memory for thread objects
+mtThread            = 0x02,  // memory for thread objects
-mtThreadStack       = 0x0300,
+mtThreadStack       = 0x03,
-mtCode              = 0x0400,  // memory for generated code
+mtCode              = 0x04,  // memory for generated code
-mtGC                = 0x0500,  // memory for GC
+mtGC                = 0x05,  // memory for GC
-mtCompiler          = 0x0600,  // memory for compiler
+mtCompiler          = 0x06,  // memory for compiler
-mtInternal          = 0x0700,  // memory used by VM, but does not belong to
+mtInternal          = 0x07,  // memory used by VM, but does not belong to
 // any of above categories, and not used for
 // native memory tracking
-mtOther             = 0x0800,  // memory not used by VM
+mtOther             = 0x08,  // memory not used by VM
-mtSymbol            = 0x0900,  // symbol
+mtSymbol            = 0x09,  // symbol
-mtNMT               = 0x0A00,  // memory used by native memory tracking
+mtNMT               = 0x0A,  // memory used by native memory tracking
-mtChunk             = 0x0B00,  // chunk that holds content of arenas
+mtClassShared       = 0x0B,  // class data sharing
-mtJavaHeap          = 0x0C00,  // Java heap
+mtChunk             = 0x0C,  // chunk that holds content of arenas
-mtClassShared       = 0x0D00,  // class data sharing
+mtTest              = 0x0D,  // Test type for verifying NMT
-mtTest              = 0x0E00,  // Test type for verifying NMT
+mtTracing           = 0x0E,  // memory used for Tracing
-mtTracing           = 0x0F00,  // memory used for Tracing
+mtNone              = 0x0F,  // undefined
-mt_number_of_types  = 0x000F,  // number of memory types (mtDontTrack
+mt_number_of_types  = 0x10   // number of memory types (mtDontTrack
 // is not included as validate type)
-mtDontTrack         = 0x0F00,  // memory we do not or cannot track
+};
-mt_masks            = 0x7F00,
+typedef MemoryType MEMFLAGS;
-// object type mask
-otArena             = 0x0010, // an arena object
-otNMTRecorder       = 0x0020, // memory recorder object
-ot_masks            = 0x00F0
-};
-#define IS_MEMORY_TYPE(flags, type) ((flags & mt_masks) == type)
-#define HAS_VALID_MEMORY_TYPE(flags)((flags & mt_masks) != mtNone)
-#define FLAGS_TO_MEMORY_TYPE(flags) (flags & mt_masks)
-#define IS_ARENA_OBJ(flags)         ((flags & ot_masks) == otArena)
-#define IS_NMT_RECORDER(flags)      ((flags & ot_masks) == otNMTRecorder)
-#define NMT_CAN_TRACK(flags)        (!IS_NMT_RECORDER(flags) && !(IS_MEMORY_TYPE(flags, mtDontTrack)))
-typedef unsigned short MEMFLAGS;
 #if INCLUDE_NMT
 extern bool NMT_track_callsite;
 const bool NMT_track_callsite = false;
 #endif // INCLUDE_NMT
-// debug build does not inline
+class NativeCallStack;
-#if defined(_NMT_NOINLINE_)
-#define CURRENT_PC       (NMT_track_callsite ? os::get_caller_pc(1) : 0)
-#define CALLER_PC        (NMT_track_callsite ? os::get_caller_pc(2) : 0)
-#define CALLER_CALLER_PC (NMT_track_callsite ? os::get_caller_pc(3) : 0)
-#else
-#define CURRENT_PC      (NMT_track_callsite? os::get_caller_pc(0) : 0)
-#define CALLER_PC       (NMT_track_callsite ? os::get_caller_pc(1) : 0)
-#define CALLER_CALLER_PC (NMT_track_callsite ? os::get_caller_pc(2) : 0)
-#endif
 template <MEMFLAGS F> class CHeapObj ALLOCATION_SUPER_CLASS_SPEC {
 public:
-_NOINLINE_ void* operator new(size_t size, address caller_pc = 0) throw();
+_NOINLINE_ void* operator new(size_t size, const NativeCallStack& stack) throw();
+_NOINLINE_ void* operator new(size_t size) throw();
 _NOINLINE_ void* operator new (size_t size, const std::nothrow_t&  nothrow_constant,
-address caller_pc = 0) throw();
+const NativeCallStack& stack) throw();
-_NOINLINE_ void* operator new [](size_t size, address caller_pc = 0) throw();
+_NOINLINE_ void* operator new (size_t size, const std::nothrow_t&  nothrow_constant)
+throw();
+_NOINLINE_ void* operator new [](size_t size, const NativeCallStack& stack) throw();
+_NOINLINE_ void* operator new [](size_t size) throw();
 _NOINLINE_ void* operator new [](size_t size, const std::nothrow_t&  nothrow_constant,
-address caller_pc = 0) throw();
+const NativeCallStack& stack) throw();
+_NOINLINE_ void* operator new [](size_t size, const std::nothrow_t&  nothrow_constant)
+throw();
 void  operator delete(void* p);
 void  operator delete [] (void* p);
 };
 // Base class for objects allocated on the stack only.
 static void clean_chunk_pool();
 };
 //------------------------------Arena------------------------------------------
 // Fast allocation of memory
-class Arena : public CHeapObj<mtNone|otArena> {
+class Arena : public CHeapObj<mtNone> {
 protected:
 friend class ResourceMark;
 friend class HandleMark;
 friend class NoHandleMark;
 friend class VMStructs;
+MEMFLAGS    _flags;           // Memory tracking flags
 Chunk *_first;                // First chunk
 Chunk *_chunk;                // current chunk
 char *_hwm, *_max;            // High water mark and max in current chunk
 // Get a new Chunk of at least size x
 }
 return true;
 }
 public:
-Arena();
+Arena(MEMFLAGS memflag);
-Arena(size_t init_size);
+Arena(MEMFLAGS memflag, size_t init_size);
 ~Arena();
 void  destruct_contents();
 char* hwm() const             { return _hwm; }
 // new operators
 void set_size_in_bytes(size_t size);
 static void free_malloced_objects(Chunk* chunk, char* hwm, char* max, char* hwm2)  PRODUCT_RETURN;
 static void free_all(char** start, char** end)                                     PRODUCT_RETURN;
-// how many arena instances
-NOT_PRODUCT(static volatile jint _instance_count;)
 private:
 // Reset this Arena to empty, access will trigger grow if necessary
 void   reset(void) {
 _first = _chunk = NULL;
 _hwm = _max = NULL;
 #define NEW_C_HEAP_ARRAY2_RETURN_NULL(type, size, memflags, pc)\
 NEW_C_HEAP_ARRAY3(type, (size), memflags, pc, AllocFailStrategy::RETURN_NULL)
 #define NEW_C_HEAP_ARRAY_RETURN_NULL(type, size, memflags)\
-NEW_C_HEAP_ARRAY3(type, (size), memflags, (address)0, AllocFailStrategy::RETURN_NULL)
+NEW_C_HEAP_ARRAY3(type, (size), memflags, CURRENT_PC, AllocFailStrategy::RETURN_NULL)
 #define REALLOC_C_HEAP_ARRAY(type, old, size, memflags)\
 (type*) (ReallocateHeap((char*)(old), (size) * sizeof(type), memflags))
 #define REALLOC_C_HEAP_ARRAY_RETURN_NULL(type, old, size, memflags)\

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/memory/allocation.hpp

src/share/vm/memory/allocation.hpp