1 /* 2 * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "memory/allocation.inline.hpp" 27 #include "runtime/arguments.hpp" 28 #include "runtime/java.hpp" 29 #include "runtime/mutex.hpp" 30 #include "runtime/mutexLocker.hpp" 31 #include "runtime/os.hpp" 32 #include "runtime/perfData.hpp" 33 #include "runtime/perfMemory.hpp" 34 #include "runtime/statSampler.hpp" 35 #include "utilities/globalDefinitions.hpp" 36 37 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC 38 39 // Prefix of performance data file. 40 const char PERFDATA_NAME[] = "hsperfdata"; 41 42 // Add 1 for the '_' character between PERFDATA_NAME and pid. The '\0' terminating 43 // character will be included in the sizeof(PERFDATA_NAME) operation. 44 static const size_t PERFDATA_FILENAME_LEN = sizeof(PERFDATA_NAME) + 45 UINT_CHARS + 1; 46 47 char* PerfMemory::_start = NULL; 48 char* PerfMemory::_end = NULL; 49 char* PerfMemory::_top = NULL; 50 size_t PerfMemory::_capacity = 0; 51 jint PerfMemory::_initialized = false; 52 PerfDataPrologue* PerfMemory::_prologue = NULL; 53 54 void perfMemory_init() { 55 56 if (!UsePerfData) return; 57 58 PerfMemory::initialize(); 59 } 60 61 void perfMemory_exit() { 62 63 if (!UsePerfData) return; 64 if (!PerfMemory::is_initialized()) return; 65 66 // if the StatSampler is active, then we don't want to remove 67 // resources it may be dependent on. Typically, the StatSampler 68 // is disengaged from the watcher thread when this method is called, 69 // but it is not disengaged if this method is invoked during a 70 // VM abort. 71 // 72 if (!StatSampler::is_active()) 73 PerfDataManager::destroy(); 74 75 // remove the persistent external resources, if any. this method 76 // does not unmap or invalidate any virtual memory allocated during 77 // initialization. 78 // 79 PerfMemory::destroy(); 80 } 81 82 void PerfMemory::initialize() { 83 84 if (_prologue != NULL) 85 // initialization already performed 86 return; 87 88 size_t capacity = align_size_up(PerfDataMemorySize, 89 os::vm_allocation_granularity()); 90 91 if (PerfTraceMemOps) { 92 tty->print("PerfDataMemorySize = " SIZE_FORMAT "," 93 " os::vm_allocation_granularity = " SIZE_FORMAT "," 94 " adjusted size = " SIZE_FORMAT "\n", 95 PerfDataMemorySize, 96 os::vm_allocation_granularity(), 97 capacity); 98 } 99 100 // allocate PerfData memory region 101 create_memory_region(capacity); 102 103 if (_start == NULL) { 104 105 // the PerfMemory region could not be created as desired. Rather 106 // than terminating the JVM, we revert to creating the instrumentation 107 // on the C heap. When running in this mode, external monitoring 108 // clients cannot attach to and monitor this JVM. 109 // 110 // the warning is issued only in debug mode in order to avoid 111 // additional output to the stdout or stderr output streams. 112 // 113 if (PrintMiscellaneous && Verbose) { 114 warning("Could not create PerfData Memory region, reverting to malloc"); 115 } 116 117 _prologue = NEW_C_HEAP_OBJ(PerfDataPrologue, mtInternal); 118 } 119 else { 120 121 // the PerfMemory region was created as expected. 122 123 if (PerfTraceMemOps) { 124 tty->print("PerfMemory created: address = " INTPTR_FORMAT "," 125 " size = " SIZE_FORMAT "\n", 126 (void*)_start, 127 _capacity); 128 } 129 130 _prologue = (PerfDataPrologue *)_start; 131 _end = _start + _capacity; 132 _top = _start + sizeof(PerfDataPrologue); 133 } 134 135 assert(_prologue != NULL, "prologue pointer must be initialized"); 136 137 #ifdef VM_LITTLE_ENDIAN 138 _prologue->magic = (jint)0xc0c0feca; 139 _prologue->byte_order = PERFDATA_LITTLE_ENDIAN; 140 #else 141 _prologue->magic = (jint)0xcafec0c0; 142 _prologue->byte_order = PERFDATA_BIG_ENDIAN; 143 #endif 144 145 _prologue->major_version = PERFDATA_MAJOR_VERSION; 146 _prologue->minor_version = PERFDATA_MINOR_VERSION; 147 _prologue->accessible = 0; 148 149 _prologue->entry_offset = sizeof(PerfDataPrologue); 150 _prologue->num_entries = 0; 151 _prologue->used = 0; 152 _prologue->overflow = 0; 153 _prologue->mod_time_stamp = 0; 154 155 OrderAccess::release_store(&_initialized, 1); 156 } 157 158 void PerfMemory::destroy() { 159 160 if (_prologue == NULL) return; 161 162 if (_start != NULL && _prologue->overflow != 0) { 163 164 // This state indicates that the contiguous memory region exists and 165 // that it wasn't large enough to hold all the counters. In this case, 166 // we output a warning message to the user on exit if the -XX:+Verbose 167 // flag is set (a debug only flag). External monitoring tools can detect 168 // this condition by monitoring the _prologue->overflow word. 169 // 170 // There are two tunables that can help resolve this issue: 171 // - increase the size of the PerfMemory with -XX:PerfDataMemorySize=<n> 172 // - decrease the maximum string constant length with 173 // -XX:PerfMaxStringConstLength=<n> 174 // 175 if (PrintMiscellaneous && Verbose) { 176 warning("PerfMemory Overflow Occurred.\n" 177 "\tCapacity = " SIZE_FORMAT " bytes" 178 " Used = " SIZE_FORMAT " bytes" 179 " Overflow = " INT32_FORMAT " bytes" 180 "\n\tUse -XX:PerfDataMemorySize=<size> to specify larger size.", 181 PerfMemory::capacity(), 182 PerfMemory::used(), 183 _prologue->overflow); 184 } 185 } 186 187 if (_start != NULL) { 188 189 // this state indicates that the contiguous memory region was successfully 190 // and that persistent resources may need to be cleaned up. This is 191 // expected to be the typical condition. 192 // 193 delete_memory_region(); 194 } 195 196 _start = NULL; 197 _end = NULL; 198 _top = NULL; 199 _prologue = NULL; 200 _capacity = 0; 201 } 202 203 // allocate an aligned block of memory from the PerfData memory 204 // region. This method assumes that the PerfData memory region 205 // was aligned on a double word boundary when created. 206 // 207 char* PerfMemory::alloc(size_t size) { 208 209 if (!UsePerfData) return NULL; 210 211 MutexLocker ml(PerfDataMemAlloc_lock); 212 213 assert(_prologue != NULL, "called before initialization"); 214 215 // check that there is enough memory for this request 216 if ((_top + size) >= _end) { 217 218 _prologue->overflow += (jint)size; 219 220 return NULL; 221 } 222 223 char* result = _top; 224 225 _top += size; 226 227 assert(contains(result), "PerfData memory pointer out of range"); 228 229 _prologue->used = (jint)used(); 230 _prologue->num_entries = _prologue->num_entries + 1; 231 232 return result; 233 } 234 235 void PerfMemory::mark_updated() { 236 if (!UsePerfData) return; 237 238 _prologue->mod_time_stamp = os::elapsed_counter(); 239 } 240 241 // Returns the complete path including the file name of performance data file. 242 // Caller is expected to release the allocated memory. 243 char* PerfMemory::get_perfdata_file_path() { 244 char* dest_file = NULL; 245 246 if (PerfDataSaveFile != NULL) { 247 // dest_file_name stores the validated file name if file_name 248 // contains %p which will be replaced by pid. 249 dest_file = NEW_C_HEAP_ARRAY(char, JVM_MAXPATHLEN, mtInternal); 250 if(!Arguments::copy_expand_pid(PerfDataSaveFile, strlen(PerfDataSaveFile), 251 dest_file, JVM_MAXPATHLEN)) { 252 FREE_C_HEAP_ARRAY(char, dest_file, mtInternal); 253 if (PrintMiscellaneous && Verbose) { 254 warning("Invalid performance data file path name specified, "\ 255 "fall back to a default name"); 256 } 257 } else { 258 return dest_file; 259 } 260 } 261 // create the name of the file for retaining the instrumentation memory. 262 dest_file = NEW_C_HEAP_ARRAY(char, PERFDATA_FILENAME_LEN, mtInternal); 263 jio_snprintf(dest_file, PERFDATA_FILENAME_LEN, 264 "%s_%d", PERFDATA_NAME, os::current_process_id()); 265 266 return dest_file; 267 }