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

-:74533f63b116
+:d2a62e0f25eb
 /*
-* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2012, 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.
 #define ARENA_ALIGN_M1 (((size_t)(ARENA_AMALLOC_ALIGNMENT)) - 1)
 #define ARENA_ALIGN_MASK (~((size_t)ARENA_ALIGN_M1))
 #define ARENA_ALIGN(x) ((((size_t)(x)) + ARENA_ALIGN_M1) & ARENA_ALIGN_MASK)
+// noinline attribute
+#ifdef _WINDOWS
+#define _NOINLINE_  __declspec(noinline)
+#else
+#if __GNUC__ < 3    // gcc 2.x does not support noinline attribute
+#define _NOINLINE_
+#else
+#define _NOINLINE_ __attribute__ ((noinline))
+#endif
+#endif
 // All classes in the virtual machine must be subclassed
 // by one of the following allocation classes:
 //
 // For objects allocated in the resource area (see resourceArea.hpp).
 // - ResourceObj
 virtual void print_on(outputStream* st) const;
 virtual void print_value_on(outputStream* st) const;
 };
 #endif
-class CHeapObj ALLOCATION_SUPER_CLASS_SPEC {
-public:
+/*
-void* operator new(size_t size);
+* MemoryType bitmap layout:
-void* operator new (size_t size, const std::nothrow_t&  nothrow_constant);
+* | 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
+mtClass             = 0x0100,  // memory class for Java classes
+mtThread            = 0x0200,  // memory for thread objects
+mtThreadStack       = 0x0300,
+mtCode              = 0x0400,  // memory for generated code
+mtGC                = 0x0500,  // memory for GC
+mtCompiler          = 0x0600,  // memory for compiler
+mtInternal          = 0x0700,  // 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
+mtSymbol            = 0x0900,  // symbol
+mtNMT               = 0x0A00,  // memory used by native memory tracking
+mtChunk             = 0x0B00,  // chunk that holds content of arenas
+mtJavaHeap          = 0x0C00,  // Java heap
+mtDontTrack         = 0x0D00,  // memory we donot or cannot track
+mt_number_of_types  = 0x000C,  // number of memory types
+mt_masks            = 0x7F00,
+// 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;
+extern bool NMT_track_callsite;
+// debug build does not inline
+#if defined(_DEBUG_)
+#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);
+_NOINLINE_ void* operator new (size_t size, const std::nothrow_t&  nothrow_constant,
+address caller_pc = 0);
 void  operator delete(void* p);
-void* new_array(size_t size);
 };
 // Base class for objects allocated on the stack only.
 // Calling new or delete will result in fatal error.
 };
 //------------------------------Chunk------------------------------------------
 // Linked list of raw memory chunks
-class Chunk: public CHeapObj {
+class Chunk: CHeapObj<mtChunk> {
 friend class VMStructs;
 protected:
 Chunk*       _next;     // Next Chunk in list
 const size_t _len;      // Size of this Chunk
 static void clean_chunk_pool();
 };
 //------------------------------Arena------------------------------------------
 // Fast allocation of memory
-class Arena: public CHeapObj {
+class Arena : public CHeapObj<mtNone|otArena> {
 protected:
 friend class ResourceMark;
 friend class HandleMark;
 friend class NoHandleMark;
 friend class VMStructs;
 Chunk *_first;                // First chunk
 Chunk *_chunk;                // current chunk
 char *_hwm, *_max;            // High water mark and max in current chunk
 void* grow(size_t x);         // Get a new Chunk of at least size x
-NOT_PRODUCT(size_t _size_in_bytes;) // Size of arena (used for memory usage tracing)
+size_t _size_in_bytes;        // Size of arena (used for native memory tracking)
 NOT_PRODUCT(static julong _bytes_allocated;) // total #bytes allocated since start
 friend class AllocStats;
 debug_only(void* malloc(size_t size);)
 debug_only(void* internal_malloc_4(size_t x);)
 NOT_PRODUCT(void inc_bytes_allocated(size_t x);)
 Arena(size_t init_size);
 Arena(Arena *old);
 ~Arena();
 void  destruct_contents();
 char* hwm() const             { return _hwm; }
+// new operators
+void* operator new (size_t size);
+void* operator new (size_t size, const std::nothrow_t& nothrow_constant);
+// dynamic memory type tagging
+void* operator new(size_t size, MEMFLAGS flags);
+void* operator new(size_t size, const std::nothrow_t& nothrow_constant, MEMFLAGS flags);
+void  operator delete(void* p);
 // Fast allocate in the arena.  Common case is: pointer test + increment.
 void* Amalloc(size_t x) {
 assert(is_power_of_2(ARENA_AMALLOC_ALIGNMENT) , "should be a power of 2");
 x = ARENA_ALIGN(x);
 // Total of all chunks in use (not thread-safe)
 size_t used() const;
 // Total # of bytes used
-size_t size_in_bytes() const         NOT_PRODUCT({  return _size_in_bytes; }) PRODUCT_RETURN0;
+size_t size_in_bytes() const         {  return _size_in_bytes; };
-void set_size_in_bytes(size_t size)  NOT_PRODUCT({ _size_in_bytes = size;  }) PRODUCT_RETURN;
+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;
+set_size_in_bytes(0);
 }
 };
 // One of the following macros must be used when allocating
 // an array or object from an arena
 ResourceObj& operator=(const ResourceObj& r); // default copy assignment
 ~ResourceObj();
 #endif // ASSERT
 public:
-void* operator new(size_t size, allocation_type type);
+void* operator new(size_t size, allocation_type type, MEMFLAGS flags);
 void* operator new(size_t size, Arena *arena) {
 address res = (address)arena->Amalloc(size);
 DEBUG_ONLY(set_allocation_type(res, ARENA);)
 return res;
 }
 /* nop */
 #define NEW_RESOURCE_OBJ(type)\
 NEW_RESOURCE_ARRAY(type, 1)
-#define NEW_C_HEAP_ARRAY(type, size)\
+#define NEW_C_HEAP_ARRAY(type, size, memflags)\
-(type*) (AllocateHeap((size) * sizeof(type), XSTR(type) " in " __FILE__))
+(type*) (AllocateHeap((size) * sizeof(type), memflags))
-#define REALLOC_C_HEAP_ARRAY(type, old, size)\
+#define REALLOC_C_HEAP_ARRAY(type, old, size, memflags)\
-(type*) (ReallocateHeap((char*)old, (size) * sizeof(type), XSTR(type) " in " __FILE__))
+(type*) (ReallocateHeap((char*)old, (size) * sizeof(type), memflags))
-#define FREE_C_HEAP_ARRAY(type,old) \
+#define FREE_C_HEAP_ARRAY(type,old,memflags) \
-FreeHeap((char*)(old))
+FreeHeap((char*)(old), memflags)
-#define NEW_C_HEAP_OBJ(type)\
+#define NEW_C_HEAP_OBJ(type, memflags)\
-NEW_C_HEAP_ARRAY(type, 1)
+NEW_C_HEAP_ARRAY(type, 1, memflags)
+#define NEW_C_HEAP_ARRAY2(type, size, memflags, pc)\
+(type*) (AllocateHeap((size) * sizeof(type), memflags, pc))
+#define REALLOC_C_HEAP_ARRAY2(type, old, size, memflags, pc)\
+(type*) (ReallocateHeap((char*)old, (size) * sizeof(type), memflags, pc))
+#define NEW_C_HEAP_OBJ2(type, memflags, pc)\
+NEW_C_HEAP_ARRAY2(type, 1, memflags, pc)
 extern bool warn_new_operator;
 // for statistics
 #ifndef PRODUCT

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

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

src/share/vm/memory/allocation.hpp