|
1 /* |
|
2 * Copyright 1997-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
|
20 * CA 95054 USA or visit www.sun.com if you need additional information or |
|
21 * have any questions. |
|
22 * |
|
23 */ |
|
24 |
|
25 # include "incls/_precompiled.incl" |
|
26 # include "incls/_os.cpp.incl" |
|
27 |
|
28 # include <signal.h> |
|
29 |
|
30 OSThread* os::_starting_thread = NULL; |
|
31 address os::_polling_page = NULL; |
|
32 volatile int32_t* os::_mem_serialize_page = NULL; |
|
33 uintptr_t os::_serialize_page_mask = 0; |
|
34 long os::_rand_seed = 1; |
|
35 int os::_processor_count = 0; |
|
36 volatile jlong os::_global_time = 0; |
|
37 volatile int os::_global_time_lock = 0; |
|
38 bool os::_use_global_time = false; |
|
39 size_t os::_page_sizes[os::page_sizes_max]; |
|
40 |
|
41 #ifndef PRODUCT |
|
42 int os::num_mallocs = 0; // # of calls to malloc/realloc |
|
43 size_t os::alloc_bytes = 0; // # of bytes allocated |
|
44 int os::num_frees = 0; // # of calls to free |
|
45 #endif |
|
46 |
|
47 // Atomic read of a jlong is assured by a seqlock; see update_global_time() |
|
48 jlong os::read_global_time() { |
|
49 #ifdef _LP64 |
|
50 return _global_time; |
|
51 #else |
|
52 volatile int lock; |
|
53 volatile jlong current_time; |
|
54 int ctr = 0; |
|
55 |
|
56 for (;;) { |
|
57 lock = _global_time_lock; |
|
58 |
|
59 // spin while locked |
|
60 while ((lock & 0x1) != 0) { |
|
61 ++ctr; |
|
62 if ((ctr & 0xFFF) == 0) { |
|
63 // Guarantee writer progress. Can't use yield; yield is advisory |
|
64 // and has almost no effect on some platforms. Don't need a state |
|
65 // transition - the park call will return promptly. |
|
66 assert(Thread::current() != NULL, "TLS not initialized"); |
|
67 assert(Thread::current()->_ParkEvent != NULL, "sync not initialized"); |
|
68 Thread::current()->_ParkEvent->park(1); |
|
69 } |
|
70 lock = _global_time_lock; |
|
71 } |
|
72 |
|
73 OrderAccess::loadload(); |
|
74 current_time = _global_time; |
|
75 OrderAccess::loadload(); |
|
76 |
|
77 // ratify seqlock value |
|
78 if (lock == _global_time_lock) { |
|
79 return current_time; |
|
80 } |
|
81 } |
|
82 #endif |
|
83 } |
|
84 |
|
85 // |
|
86 // NOTE - Assumes only one writer thread! |
|
87 // |
|
88 // We use a seqlock to guarantee that jlong _global_time is updated |
|
89 // atomically on 32-bit platforms. A locked value is indicated by |
|
90 // the lock variable LSB == 1. Readers will initially read the lock |
|
91 // value, spinning until the LSB == 0. They then speculatively read |
|
92 // the global time value, then re-read the lock value to ensure that |
|
93 // it hasn't changed. If the lock value has changed, the entire read |
|
94 // sequence is retried. |
|
95 // |
|
96 // Writers simply set the LSB = 1 (i.e. increment the variable), |
|
97 // update the global time, then release the lock and bump the version |
|
98 // number (i.e. increment the variable again.) In this case we don't |
|
99 // even need a CAS since we ensure there's only one writer. |
|
100 // |
|
101 void os::update_global_time() { |
|
102 #ifdef _LP64 |
|
103 _global_time = timeofday(); |
|
104 #else |
|
105 assert((_global_time_lock & 0x1) == 0, "multiple writers?"); |
|
106 jlong current_time = timeofday(); |
|
107 _global_time_lock++; // lock |
|
108 OrderAccess::storestore(); |
|
109 _global_time = current_time; |
|
110 OrderAccess::storestore(); |
|
111 _global_time_lock++; // unlock |
|
112 #endif |
|
113 } |
|
114 |
|
115 // Fill in buffer with current local time as an ISO-8601 string. |
|
116 // E.g., yyyy-mm-ddThh:mm:ss-zzzz. |
|
117 // Returns buffer, or NULL if it failed. |
|
118 // This would mostly be a call to |
|
119 // strftime(...., "%Y-%m-%d" "T" "%H:%M:%S" "%z", ....) |
|
120 // except that on Windows the %z behaves badly, so we do it ourselves. |
|
121 // Also, people wanted milliseconds on there, |
|
122 // and strftime doesn't do milliseconds. |
|
123 char* os::iso8601_time(char* buffer, size_t buffer_length) { |
|
124 // Output will be of the form "YYYY-MM-DDThh:mm:ss.mmm+zzzz\0" |
|
125 // 1 2 |
|
126 // 12345678901234567890123456789 |
|
127 static const char* iso8601_format = |
|
128 "%04d-%02d-%02dT%02d:%02d:%02d.%03d%c%02d%02d"; |
|
129 static const size_t needed_buffer = 29; |
|
130 |
|
131 // Sanity check the arguments |
|
132 if (buffer == NULL) { |
|
133 assert(false, "NULL buffer"); |
|
134 return NULL; |
|
135 } |
|
136 if (buffer_length < needed_buffer) { |
|
137 assert(false, "buffer_length too small"); |
|
138 return NULL; |
|
139 } |
|
140 // Get the current time |
|
141 jlong milliseconds_since_19700101 = timeofday(); |
|
142 const int milliseconds_per_microsecond = 1000; |
|
143 const time_t seconds_since_19700101 = |
|
144 milliseconds_since_19700101 / milliseconds_per_microsecond; |
|
145 const int milliseconds_after_second = |
|
146 milliseconds_since_19700101 % milliseconds_per_microsecond; |
|
147 // Convert the time value to a tm and timezone variable |
|
148 const struct tm *time_struct_temp = localtime(&seconds_since_19700101); |
|
149 if (time_struct_temp == NULL) { |
|
150 assert(false, "Failed localtime"); |
|
151 return NULL; |
|
152 } |
|
153 // Save the results of localtime |
|
154 const struct tm time_struct = *time_struct_temp; |
|
155 const time_t zone = timezone; |
|
156 |
|
157 // If daylight savings time is in effect, |
|
158 // we are 1 hour East of our time zone |
|
159 const time_t seconds_per_minute = 60; |
|
160 const time_t minutes_per_hour = 60; |
|
161 const time_t seconds_per_hour = seconds_per_minute * minutes_per_hour; |
|
162 time_t UTC_to_local = zone; |
|
163 if (time_struct.tm_isdst > 0) { |
|
164 UTC_to_local = UTC_to_local - seconds_per_hour; |
|
165 } |
|
166 // Compute the time zone offset. |
|
167 // localtime(3C) sets timezone to the difference (in seconds) |
|
168 // between UTC and and local time. |
|
169 // ISO 8601 says we need the difference between local time and UTC, |
|
170 // we change the sign of the localtime(3C) result. |
|
171 const time_t local_to_UTC = -(UTC_to_local); |
|
172 // Then we have to figure out if if we are ahead (+) or behind (-) UTC. |
|
173 char sign_local_to_UTC = '+'; |
|
174 time_t abs_local_to_UTC = local_to_UTC; |
|
175 if (local_to_UTC < 0) { |
|
176 sign_local_to_UTC = '-'; |
|
177 abs_local_to_UTC = -(abs_local_to_UTC); |
|
178 } |
|
179 // Convert time zone offset seconds to hours and minutes. |
|
180 const time_t zone_hours = (abs_local_to_UTC / seconds_per_hour); |
|
181 const time_t zone_min = |
|
182 ((abs_local_to_UTC % seconds_per_hour) / seconds_per_minute); |
|
183 |
|
184 // Print an ISO 8601 date and time stamp into the buffer |
|
185 const int year = 1900 + time_struct.tm_year; |
|
186 const int month = 1 + time_struct.tm_mon; |
|
187 const int printed = jio_snprintf(buffer, buffer_length, iso8601_format, |
|
188 year, |
|
189 month, |
|
190 time_struct.tm_mday, |
|
191 time_struct.tm_hour, |
|
192 time_struct.tm_min, |
|
193 time_struct.tm_sec, |
|
194 milliseconds_after_second, |
|
195 sign_local_to_UTC, |
|
196 zone_hours, |
|
197 zone_min); |
|
198 if (printed == 0) { |
|
199 assert(false, "Failed jio_printf"); |
|
200 return NULL; |
|
201 } |
|
202 return buffer; |
|
203 } |
|
204 |
|
205 OSReturn os::set_priority(Thread* thread, ThreadPriority p) { |
|
206 #ifdef ASSERT |
|
207 if (!(!thread->is_Java_thread() || |
|
208 Thread::current() == thread || |
|
209 Threads_lock->owned_by_self() |
|
210 || thread->is_Compiler_thread() |
|
211 )) { |
|
212 assert(false, "possibility of dangling Thread pointer"); |
|
213 } |
|
214 #endif |
|
215 |
|
216 if (p >= MinPriority && p <= MaxPriority) { |
|
217 int priority = java_to_os_priority[p]; |
|
218 return set_native_priority(thread, priority); |
|
219 } else { |
|
220 assert(false, "Should not happen"); |
|
221 return OS_ERR; |
|
222 } |
|
223 } |
|
224 |
|
225 |
|
226 OSReturn os::get_priority(const Thread* const thread, ThreadPriority& priority) { |
|
227 int p; |
|
228 int os_prio; |
|
229 OSReturn ret = get_native_priority(thread, &os_prio); |
|
230 if (ret != OS_OK) return ret; |
|
231 |
|
232 for (p = MaxPriority; p > MinPriority && java_to_os_priority[p] > os_prio; p--) ; |
|
233 priority = (ThreadPriority)p; |
|
234 return OS_OK; |
|
235 } |
|
236 |
|
237 |
|
238 // --------------------- sun.misc.Signal (optional) --------------------- |
|
239 |
|
240 |
|
241 // SIGBREAK is sent by the keyboard to query the VM state |
|
242 #ifndef SIGBREAK |
|
243 #define SIGBREAK SIGQUIT |
|
244 #endif |
|
245 |
|
246 // sigexitnum_pd is a platform-specific special signal used for terminating the Signal thread. |
|
247 |
|
248 |
|
249 static void signal_thread_entry(JavaThread* thread, TRAPS) { |
|
250 os::set_priority(thread, NearMaxPriority); |
|
251 while (true) { |
|
252 int sig; |
|
253 { |
|
254 // FIXME : Currently we have not decieded what should be the status |
|
255 // for this java thread blocked here. Once we decide about |
|
256 // that we should fix this. |
|
257 sig = os::signal_wait(); |
|
258 } |
|
259 if (sig == os::sigexitnum_pd()) { |
|
260 // Terminate the signal thread |
|
261 return; |
|
262 } |
|
263 |
|
264 switch (sig) { |
|
265 case SIGBREAK: { |
|
266 // Check if the signal is a trigger to start the Attach Listener - in that |
|
267 // case don't print stack traces. |
|
268 if (!DisableAttachMechanism && AttachListener::is_init_trigger()) { |
|
269 continue; |
|
270 } |
|
271 // Print stack traces |
|
272 // Any SIGBREAK operations added here should make sure to flush |
|
273 // the output stream (e.g. tty->flush()) after output. See 4803766. |
|
274 // Each module also prints an extra carriage return after its output. |
|
275 VM_PrintThreads op; |
|
276 VMThread::execute(&op); |
|
277 VM_PrintJNI jni_op; |
|
278 VMThread::execute(&jni_op); |
|
279 VM_FindDeadlocks op1(tty); |
|
280 VMThread::execute(&op1); |
|
281 Universe::print_heap_at_SIGBREAK(); |
|
282 if (PrintClassHistogram) { |
|
283 VM_GC_HeapInspection op1(gclog_or_tty, true /* force full GC before heap inspection */); |
|
284 VMThread::execute(&op1); |
|
285 } |
|
286 if (JvmtiExport::should_post_data_dump()) { |
|
287 JvmtiExport::post_data_dump(); |
|
288 } |
|
289 break; |
|
290 } |
|
291 default: { |
|
292 // Dispatch the signal to java |
|
293 HandleMark hm(THREAD); |
|
294 klassOop k = SystemDictionary::resolve_or_null(vmSymbolHandles::sun_misc_Signal(), THREAD); |
|
295 KlassHandle klass (THREAD, k); |
|
296 if (klass.not_null()) { |
|
297 JavaValue result(T_VOID); |
|
298 JavaCallArguments args; |
|
299 args.push_int(sig); |
|
300 JavaCalls::call_static( |
|
301 &result, |
|
302 klass, |
|
303 vmSymbolHandles::dispatch_name(), |
|
304 vmSymbolHandles::int_void_signature(), |
|
305 &args, |
|
306 THREAD |
|
307 ); |
|
308 } |
|
309 if (HAS_PENDING_EXCEPTION) { |
|
310 // tty is initialized early so we don't expect it to be null, but |
|
311 // if it is we can't risk doing an initialization that might |
|
312 // trigger additional out-of-memory conditions |
|
313 if (tty != NULL) { |
|
314 char klass_name[256]; |
|
315 char tmp_sig_name[16]; |
|
316 const char* sig_name = "UNKNOWN"; |
|
317 instanceKlass::cast(PENDING_EXCEPTION->klass())-> |
|
318 name()->as_klass_external_name(klass_name, 256); |
|
319 if (os::exception_name(sig, tmp_sig_name, 16) != NULL) |
|
320 sig_name = tmp_sig_name; |
|
321 warning("Exception %s occurred dispatching signal %s to handler" |
|
322 "- the VM may need to be forcibly terminated", |
|
323 klass_name, sig_name ); |
|
324 } |
|
325 CLEAR_PENDING_EXCEPTION; |
|
326 } |
|
327 } |
|
328 } |
|
329 } |
|
330 } |
|
331 |
|
332 |
|
333 void os::signal_init() { |
|
334 if (!ReduceSignalUsage) { |
|
335 // Setup JavaThread for processing signals |
|
336 EXCEPTION_MARK; |
|
337 klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(), true, CHECK); |
|
338 instanceKlassHandle klass (THREAD, k); |
|
339 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK); |
|
340 |
|
341 const char thread_name[] = "Signal Dispatcher"; |
|
342 Handle string = java_lang_String::create_from_str(thread_name, CHECK); |
|
343 |
|
344 // Initialize thread_oop to put it into the system threadGroup |
|
345 Handle thread_group (THREAD, Universe::system_thread_group()); |
|
346 JavaValue result(T_VOID); |
|
347 JavaCalls::call_special(&result, thread_oop, |
|
348 klass, |
|
349 vmSymbolHandles::object_initializer_name(), |
|
350 vmSymbolHandles::threadgroup_string_void_signature(), |
|
351 thread_group, |
|
352 string, |
|
353 CHECK); |
|
354 |
|
355 KlassHandle group(THREAD, SystemDictionary::threadGroup_klass()); |
|
356 JavaCalls::call_special(&result, |
|
357 thread_group, |
|
358 group, |
|
359 vmSymbolHandles::add_method_name(), |
|
360 vmSymbolHandles::thread_void_signature(), |
|
361 thread_oop, // ARG 1 |
|
362 CHECK); |
|
363 |
|
364 os::signal_init_pd(); |
|
365 |
|
366 { MutexLocker mu(Threads_lock); |
|
367 JavaThread* signal_thread = new JavaThread(&signal_thread_entry); |
|
368 |
|
369 // At this point it may be possible that no osthread was created for the |
|
370 // JavaThread due to lack of memory. We would have to throw an exception |
|
371 // in that case. However, since this must work and we do not allow |
|
372 // exceptions anyway, check and abort if this fails. |
|
373 if (signal_thread == NULL || signal_thread->osthread() == NULL) { |
|
374 vm_exit_during_initialization("java.lang.OutOfMemoryError", |
|
375 "unable to create new native thread"); |
|
376 } |
|
377 |
|
378 java_lang_Thread::set_thread(thread_oop(), signal_thread); |
|
379 java_lang_Thread::set_priority(thread_oop(), NearMaxPriority); |
|
380 java_lang_Thread::set_daemon(thread_oop()); |
|
381 |
|
382 signal_thread->set_threadObj(thread_oop()); |
|
383 Threads::add(signal_thread); |
|
384 Thread::start(signal_thread); |
|
385 } |
|
386 // Handle ^BREAK |
|
387 os::signal(SIGBREAK, os::user_handler()); |
|
388 } |
|
389 } |
|
390 |
|
391 |
|
392 void os::terminate_signal_thread() { |
|
393 if (!ReduceSignalUsage) |
|
394 signal_notify(sigexitnum_pd()); |
|
395 } |
|
396 |
|
397 |
|
398 // --------------------- loading libraries --------------------- |
|
399 |
|
400 typedef jint (JNICALL *JNI_OnLoad_t)(JavaVM *, void *); |
|
401 extern struct JavaVM_ main_vm; |
|
402 |
|
403 static void* _native_java_library = NULL; |
|
404 |
|
405 void* os::native_java_library() { |
|
406 if (_native_java_library == NULL) { |
|
407 char buffer[JVM_MAXPATHLEN]; |
|
408 char ebuf[1024]; |
|
409 |
|
410 // Try to load verify dll first. In 1.3 java dll depends on it and is not always |
|
411 // able to find it when the loading executable is outside the JDK. |
|
412 // In order to keep working with 1.2 we ignore any loading errors. |
|
413 hpi::dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(), "verify"); |
|
414 hpi::dll_load(buffer, ebuf, sizeof(ebuf)); |
|
415 |
|
416 // Load java dll |
|
417 hpi::dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(), "java"); |
|
418 _native_java_library = hpi::dll_load(buffer, ebuf, sizeof(ebuf)); |
|
419 if (_native_java_library == NULL) { |
|
420 vm_exit_during_initialization("Unable to load native library", ebuf); |
|
421 } |
|
422 // The JNI_OnLoad handling is normally done by method load in java.lang.ClassLoader$NativeLibrary, |
|
423 // but the VM loads the base library explicitly so we have to check for JNI_OnLoad as well |
|
424 const char *onLoadSymbols[] = JNI_ONLOAD_SYMBOLS; |
|
425 JNI_OnLoad_t JNI_OnLoad = CAST_TO_FN_PTR(JNI_OnLoad_t, hpi::dll_lookup(_native_java_library, onLoadSymbols[0])); |
|
426 if (JNI_OnLoad != NULL) { |
|
427 JavaThread* thread = JavaThread::current(); |
|
428 ThreadToNativeFromVM ttn(thread); |
|
429 HandleMark hm(thread); |
|
430 jint ver = (*JNI_OnLoad)(&main_vm, NULL); |
|
431 if (!Threads::is_supported_jni_version_including_1_1(ver)) { |
|
432 vm_exit_during_initialization("Unsupported JNI version"); |
|
433 } |
|
434 } |
|
435 } |
|
436 return _native_java_library; |
|
437 } |
|
438 |
|
439 // --------------------- heap allocation utilities --------------------- |
|
440 |
|
441 char *os::strdup(const char *str) { |
|
442 size_t size = strlen(str); |
|
443 char *dup_str = (char *)malloc(size + 1); |
|
444 if (dup_str == NULL) return NULL; |
|
445 strcpy(dup_str, str); |
|
446 return dup_str; |
|
447 } |
|
448 |
|
449 |
|
450 |
|
451 #ifdef ASSERT |
|
452 #define space_before (MallocCushion + sizeof(double)) |
|
453 #define space_after MallocCushion |
|
454 #define size_addr_from_base(p) (size_t*)(p + space_before - sizeof(size_t)) |
|
455 #define size_addr_from_obj(p) ((size_t*)p - 1) |
|
456 // MallocCushion: size of extra cushion allocated around objects with +UseMallocOnly |
|
457 // NB: cannot be debug variable, because these aren't set from the command line until |
|
458 // *after* the first few allocs already happened |
|
459 #define MallocCushion 16 |
|
460 #else |
|
461 #define space_before 0 |
|
462 #define space_after 0 |
|
463 #define size_addr_from_base(p) should not use w/o ASSERT |
|
464 #define size_addr_from_obj(p) should not use w/o ASSERT |
|
465 #define MallocCushion 0 |
|
466 #endif |
|
467 #define paranoid 0 /* only set to 1 if you suspect checking code has bug */ |
|
468 |
|
469 #ifdef ASSERT |
|
470 inline size_t get_size(void* obj) { |
|
471 size_t size = *size_addr_from_obj(obj); |
|
472 if (size < 0 ) |
|
473 fatal2("free: size field of object #%p was overwritten (%lu)", obj, size); |
|
474 return size; |
|
475 } |
|
476 |
|
477 u_char* find_cushion_backwards(u_char* start) { |
|
478 u_char* p = start; |
|
479 while (p[ 0] != badResourceValue || p[-1] != badResourceValue || |
|
480 p[-2] != badResourceValue || p[-3] != badResourceValue) p--; |
|
481 // ok, we have four consecutive marker bytes; find start |
|
482 u_char* q = p - 4; |
|
483 while (*q == badResourceValue) q--; |
|
484 return q + 1; |
|
485 } |
|
486 |
|
487 u_char* find_cushion_forwards(u_char* start) { |
|
488 u_char* p = start; |
|
489 while (p[0] != badResourceValue || p[1] != badResourceValue || |
|
490 p[2] != badResourceValue || p[3] != badResourceValue) p++; |
|
491 // ok, we have four consecutive marker bytes; find end of cushion |
|
492 u_char* q = p + 4; |
|
493 while (*q == badResourceValue) q++; |
|
494 return q - MallocCushion; |
|
495 } |
|
496 |
|
497 void print_neighbor_blocks(void* ptr) { |
|
498 // find block allocated before ptr (not entirely crash-proof) |
|
499 if (MallocCushion < 4) { |
|
500 tty->print_cr("### cannot find previous block (MallocCushion < 4)"); |
|
501 return; |
|
502 } |
|
503 u_char* start_of_this_block = (u_char*)ptr - space_before; |
|
504 u_char* end_of_prev_block_data = start_of_this_block - space_after -1; |
|
505 // look for cushion in front of prev. block |
|
506 u_char* start_of_prev_block = find_cushion_backwards(end_of_prev_block_data); |
|
507 ptrdiff_t size = *size_addr_from_base(start_of_prev_block); |
|
508 u_char* obj = start_of_prev_block + space_before; |
|
509 if (size <= 0 ) { |
|
510 // start is bad; mayhave been confused by OS data inbetween objects |
|
511 // search one more backwards |
|
512 start_of_prev_block = find_cushion_backwards(start_of_prev_block); |
|
513 size = *size_addr_from_base(start_of_prev_block); |
|
514 obj = start_of_prev_block + space_before; |
|
515 } |
|
516 |
|
517 if (start_of_prev_block + space_before + size + space_after == start_of_this_block) { |
|
518 tty->print_cr("### previous object: %p (%ld bytes)", obj, size); |
|
519 } else { |
|
520 tty->print_cr("### previous object (not sure if correct): %p (%ld bytes)", obj, size); |
|
521 } |
|
522 |
|
523 // now find successor block |
|
524 u_char* start_of_next_block = (u_char*)ptr + *size_addr_from_obj(ptr) + space_after; |
|
525 start_of_next_block = find_cushion_forwards(start_of_next_block); |
|
526 u_char* next_obj = start_of_next_block + space_before; |
|
527 ptrdiff_t next_size = *size_addr_from_base(start_of_next_block); |
|
528 if (start_of_next_block[0] == badResourceValue && |
|
529 start_of_next_block[1] == badResourceValue && |
|
530 start_of_next_block[2] == badResourceValue && |
|
531 start_of_next_block[3] == badResourceValue) { |
|
532 tty->print_cr("### next object: %p (%ld bytes)", next_obj, next_size); |
|
533 } else { |
|
534 tty->print_cr("### next object (not sure if correct): %p (%ld bytes)", next_obj, next_size); |
|
535 } |
|
536 } |
|
537 |
|
538 |
|
539 void report_heap_error(void* memblock, void* bad, const char* where) { |
|
540 tty->print_cr("## nof_mallocs = %d, nof_frees = %d", os::num_mallocs, os::num_frees); |
|
541 tty->print_cr("## memory stomp: byte at %p %s object %p", bad, where, memblock); |
|
542 print_neighbor_blocks(memblock); |
|
543 fatal("memory stomping error"); |
|
544 } |
|
545 |
|
546 void verify_block(void* memblock) { |
|
547 size_t size = get_size(memblock); |
|
548 if (MallocCushion) { |
|
549 u_char* ptr = (u_char*)memblock - space_before; |
|
550 for (int i = 0; i < MallocCushion; i++) { |
|
551 if (ptr[i] != badResourceValue) { |
|
552 report_heap_error(memblock, ptr+i, "in front of"); |
|
553 } |
|
554 } |
|
555 u_char* end = (u_char*)memblock + size + space_after; |
|
556 for (int j = -MallocCushion; j < 0; j++) { |
|
557 if (end[j] != badResourceValue) { |
|
558 report_heap_error(memblock, end+j, "after"); |
|
559 } |
|
560 } |
|
561 } |
|
562 } |
|
563 #endif |
|
564 |
|
565 void* os::malloc(size_t size) { |
|
566 NOT_PRODUCT(num_mallocs++); |
|
567 NOT_PRODUCT(alloc_bytes += size); |
|
568 |
|
569 if (size == 0) { |
|
570 // return a valid pointer if size is zero |
|
571 // if NULL is returned the calling functions assume out of memory. |
|
572 size = 1; |
|
573 } |
|
574 |
|
575 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap()); |
|
576 u_char* ptr = (u_char*)::malloc(size + space_before + space_after); |
|
577 #ifdef ASSERT |
|
578 if (ptr == NULL) return NULL; |
|
579 if (MallocCushion) { |
|
580 for (u_char* p = ptr; p < ptr + MallocCushion; p++) *p = (u_char)badResourceValue; |
|
581 u_char* end = ptr + space_before + size; |
|
582 for (u_char* pq = ptr+MallocCushion; pq < end; pq++) *pq = (u_char)uninitBlockPad; |
|
583 for (u_char* q = end; q < end + MallocCushion; q++) *q = (u_char)badResourceValue; |
|
584 } |
|
585 // put size just before data |
|
586 *size_addr_from_base(ptr) = size; |
|
587 #endif |
|
588 u_char* memblock = ptr + space_before; |
|
589 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) { |
|
590 tty->print_cr("os::malloc caught, %lu bytes --> %p", size, memblock); |
|
591 breakpoint(); |
|
592 } |
|
593 debug_only(if (paranoid) verify_block(memblock)); |
|
594 if (PrintMalloc && tty != NULL) tty->print_cr("os::malloc %lu bytes --> %p", size, memblock); |
|
595 return memblock; |
|
596 } |
|
597 |
|
598 |
|
599 void* os::realloc(void *memblock, size_t size) { |
|
600 NOT_PRODUCT(num_mallocs++); |
|
601 NOT_PRODUCT(alloc_bytes += size); |
|
602 #ifndef ASSERT |
|
603 return ::realloc(memblock, size); |
|
604 #else |
|
605 if (memblock == NULL) { |
|
606 return os::malloc(size); |
|
607 } |
|
608 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) { |
|
609 tty->print_cr("os::realloc caught %p", memblock); |
|
610 breakpoint(); |
|
611 } |
|
612 verify_block(memblock); |
|
613 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap()); |
|
614 if (size == 0) return NULL; |
|
615 // always move the block |
|
616 void* ptr = malloc(size); |
|
617 if (PrintMalloc) tty->print_cr("os::remalloc %lu bytes, %p --> %p", size, memblock, ptr); |
|
618 // Copy to new memory if malloc didn't fail |
|
619 if ( ptr != NULL ) { |
|
620 memcpy(ptr, memblock, MIN2(size, get_size(memblock))); |
|
621 if (paranoid) verify_block(ptr); |
|
622 if ((intptr_t)ptr == (intptr_t)MallocCatchPtr) { |
|
623 tty->print_cr("os::realloc caught, %lu bytes --> %p", size, ptr); |
|
624 breakpoint(); |
|
625 } |
|
626 free(memblock); |
|
627 } |
|
628 return ptr; |
|
629 #endif |
|
630 } |
|
631 |
|
632 |
|
633 void os::free(void *memblock) { |
|
634 NOT_PRODUCT(num_frees++); |
|
635 #ifdef ASSERT |
|
636 if (memblock == NULL) return; |
|
637 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) { |
|
638 if (tty != NULL) tty->print_cr("os::free caught %p", memblock); |
|
639 breakpoint(); |
|
640 } |
|
641 verify_block(memblock); |
|
642 if (PrintMalloc && tty != NULL) |
|
643 // tty->print_cr("os::free %p", memblock); |
|
644 fprintf(stderr, "os::free %p\n", memblock); |
|
645 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap()); |
|
646 // Added by detlefs. |
|
647 if (MallocCushion) { |
|
648 u_char* ptr = (u_char*)memblock - space_before; |
|
649 for (u_char* p = ptr; p < ptr + MallocCushion; p++) { |
|
650 guarantee(*p == badResourceValue, |
|
651 "Thing freed should be malloc result."); |
|
652 *p = (u_char)freeBlockPad; |
|
653 } |
|
654 size_t size = get_size(memblock); |
|
655 u_char* end = ptr + space_before + size; |
|
656 for (u_char* q = end; q < end + MallocCushion; q++) { |
|
657 guarantee(*q == badResourceValue, |
|
658 "Thing freed should be malloc result."); |
|
659 *q = (u_char)freeBlockPad; |
|
660 } |
|
661 } |
|
662 #endif |
|
663 ::free((char*)memblock - space_before); |
|
664 } |
|
665 |
|
666 void os::init_random(long initval) { |
|
667 _rand_seed = initval; |
|
668 } |
|
669 |
|
670 |
|
671 long os::random() { |
|
672 /* standard, well-known linear congruential random generator with |
|
673 * next_rand = (16807*seed) mod (2**31-1) |
|
674 * see |
|
675 * (1) "Random Number Generators: Good Ones Are Hard to Find", |
|
676 * S.K. Park and K.W. Miller, Communications of the ACM 31:10 (Oct 1988), |
|
677 * (2) "Two Fast Implementations of the 'Minimal Standard' Random |
|
678 * Number Generator", David G. Carta, Comm. ACM 33, 1 (Jan 1990), pp. 87-88. |
|
679 */ |
|
680 const long a = 16807; |
|
681 const unsigned long m = 2147483647; |
|
682 const long q = m / a; assert(q == 127773, "weird math"); |
|
683 const long r = m % a; assert(r == 2836, "weird math"); |
|
684 |
|
685 // compute az=2^31p+q |
|
686 unsigned long lo = a * (long)(_rand_seed & 0xFFFF); |
|
687 unsigned long hi = a * (long)((unsigned long)_rand_seed >> 16); |
|
688 lo += (hi & 0x7FFF) << 16; |
|
689 |
|
690 // if q overflowed, ignore the overflow and increment q |
|
691 if (lo > m) { |
|
692 lo &= m; |
|
693 ++lo; |
|
694 } |
|
695 lo += hi >> 15; |
|
696 |
|
697 // if (p+q) overflowed, ignore the overflow and increment (p+q) |
|
698 if (lo > m) { |
|
699 lo &= m; |
|
700 ++lo; |
|
701 } |
|
702 return (_rand_seed = lo); |
|
703 } |
|
704 |
|
705 // The INITIALIZED state is distinguished from the SUSPENDED state because the |
|
706 // conditions in which a thread is first started are different from those in which |
|
707 // a suspension is resumed. These differences make it hard for us to apply the |
|
708 // tougher checks when starting threads that we want to do when resuming them. |
|
709 // However, when start_thread is called as a result of Thread.start, on a Java |
|
710 // thread, the operation is synchronized on the Java Thread object. So there |
|
711 // cannot be a race to start the thread and hence for the thread to exit while |
|
712 // we are working on it. Non-Java threads that start Java threads either have |
|
713 // to do so in a context in which races are impossible, or should do appropriate |
|
714 // locking. |
|
715 |
|
716 void os::start_thread(Thread* thread) { |
|
717 // guard suspend/resume |
|
718 MutexLockerEx ml(thread->SR_lock(), Mutex::_no_safepoint_check_flag); |
|
719 OSThread* osthread = thread->osthread(); |
|
720 osthread->set_state(RUNNABLE); |
|
721 pd_start_thread(thread); |
|
722 } |
|
723 |
|
724 //--------------------------------------------------------------------------- |
|
725 // Helper functions for fatal error handler |
|
726 |
|
727 void os::print_hex_dump(outputStream* st, address start, address end, int unitsize) { |
|
728 assert(unitsize == 1 || unitsize == 2 || unitsize == 4 || unitsize == 8, "just checking"); |
|
729 |
|
730 int cols = 0; |
|
731 int cols_per_line = 0; |
|
732 switch (unitsize) { |
|
733 case 1: cols_per_line = 16; break; |
|
734 case 2: cols_per_line = 8; break; |
|
735 case 4: cols_per_line = 4; break; |
|
736 case 8: cols_per_line = 2; break; |
|
737 default: return; |
|
738 } |
|
739 |
|
740 address p = start; |
|
741 st->print(PTR_FORMAT ": ", start); |
|
742 while (p < end) { |
|
743 switch (unitsize) { |
|
744 case 1: st->print("%02x", *(u1*)p); break; |
|
745 case 2: st->print("%04x", *(u2*)p); break; |
|
746 case 4: st->print("%08x", *(u4*)p); break; |
|
747 case 8: st->print("%016" FORMAT64_MODIFIER "x", *(u8*)p); break; |
|
748 } |
|
749 p += unitsize; |
|
750 cols++; |
|
751 if (cols >= cols_per_line && p < end) { |
|
752 cols = 0; |
|
753 st->cr(); |
|
754 st->print(PTR_FORMAT ": ", p); |
|
755 } else { |
|
756 st->print(" "); |
|
757 } |
|
758 } |
|
759 st->cr(); |
|
760 } |
|
761 |
|
762 void os::print_environment_variables(outputStream* st, const char** env_list, |
|
763 char* buffer, int len) { |
|
764 if (env_list) { |
|
765 st->print_cr("Environment Variables:"); |
|
766 |
|
767 for (int i = 0; env_list[i] != NULL; i++) { |
|
768 if (getenv(env_list[i], buffer, len)) { |
|
769 st->print(env_list[i]); |
|
770 st->print("="); |
|
771 st->print_cr(buffer); |
|
772 } |
|
773 } |
|
774 } |
|
775 } |
|
776 |
|
777 void os::print_cpu_info(outputStream* st) { |
|
778 // cpu |
|
779 st->print("CPU:"); |
|
780 st->print("total %d", os::processor_count()); |
|
781 // It's not safe to query number of active processors after crash |
|
782 // st->print("(active %d)", os::active_processor_count()); |
|
783 st->print(" %s", VM_Version::cpu_features()); |
|
784 st->cr(); |
|
785 } |
|
786 |
|
787 void os::print_date_and_time(outputStream *st) { |
|
788 time_t tloc; |
|
789 (void)time(&tloc); |
|
790 st->print("time: %s", ctime(&tloc)); // ctime adds newline. |
|
791 |
|
792 double t = os::elapsedTime(); |
|
793 // NOTE: It tends to crash after a SEGV if we want to printf("%f",...) in |
|
794 // Linux. Must be a bug in glibc ? Workaround is to round "t" to int |
|
795 // before printf. We lost some precision, but who cares? |
|
796 st->print_cr("elapsed time: %d seconds", (int)t); |
|
797 } |
|
798 |
|
799 |
|
800 // Looks like all platforms except IA64 can use the same function to check |
|
801 // if C stack is walkable beyond current frame. The check for fp() is not |
|
802 // necessary on Sparc, but it's harmless. |
|
803 bool os::is_first_C_frame(frame* fr) { |
|
804 #ifdef IA64 |
|
805 // In order to walk native frames on Itanium, we need to access the unwind |
|
806 // table, which is inside ELF. We don't want to parse ELF after fatal error, |
|
807 // so return true for IA64. If we need to support C stack walking on IA64, |
|
808 // this function needs to be moved to CPU specific files, as fp() on IA64 |
|
809 // is register stack, which grows towards higher memory address. |
|
810 return true; |
|
811 #endif |
|
812 |
|
813 // Load up sp, fp, sender sp and sender fp, check for reasonable values. |
|
814 // Check usp first, because if that's bad the other accessors may fault |
|
815 // on some architectures. Ditto ufp second, etc. |
|
816 uintptr_t fp_align_mask = (uintptr_t)(sizeof(address)-1); |
|
817 // sp on amd can be 32 bit aligned. |
|
818 uintptr_t sp_align_mask = (uintptr_t)(sizeof(int)-1); |
|
819 |
|
820 uintptr_t usp = (uintptr_t)fr->sp(); |
|
821 if ((usp & sp_align_mask) != 0) return true; |
|
822 |
|
823 uintptr_t ufp = (uintptr_t)fr->fp(); |
|
824 if ((ufp & fp_align_mask) != 0) return true; |
|
825 |
|
826 uintptr_t old_sp = (uintptr_t)fr->sender_sp(); |
|
827 if ((old_sp & sp_align_mask) != 0) return true; |
|
828 if (old_sp == 0 || old_sp == (uintptr_t)-1) return true; |
|
829 |
|
830 uintptr_t old_fp = (uintptr_t)fr->link(); |
|
831 if ((old_fp & fp_align_mask) != 0) return true; |
|
832 if (old_fp == 0 || old_fp == (uintptr_t)-1 || old_fp == ufp) return true; |
|
833 |
|
834 // stack grows downwards; if old_fp is below current fp or if the stack |
|
835 // frame is too large, either the stack is corrupted or fp is not saved |
|
836 // on stack (i.e. on x86, ebp may be used as general register). The stack |
|
837 // is not walkable beyond current frame. |
|
838 if (old_fp < ufp) return true; |
|
839 if (old_fp - ufp > 64 * K) return true; |
|
840 |
|
841 return false; |
|
842 } |
|
843 |
|
844 #ifdef ASSERT |
|
845 extern "C" void test_random() { |
|
846 const double m = 2147483647; |
|
847 double mean = 0.0, variance = 0.0, t; |
|
848 long reps = 10000; |
|
849 unsigned long seed = 1; |
|
850 |
|
851 tty->print_cr("seed %ld for %ld repeats...", seed, reps); |
|
852 os::init_random(seed); |
|
853 long num; |
|
854 for (int k = 0; k < reps; k++) { |
|
855 num = os::random(); |
|
856 double u = (double)num / m; |
|
857 assert(u >= 0.0 && u <= 1.0, "bad random number!"); |
|
858 |
|
859 // calculate mean and variance of the random sequence |
|
860 mean += u; |
|
861 variance += (u*u); |
|
862 } |
|
863 mean /= reps; |
|
864 variance /= (reps - 1); |
|
865 |
|
866 assert(num == 1043618065, "bad seed"); |
|
867 tty->print_cr("mean of the 1st 10000 numbers: %f", mean); |
|
868 tty->print_cr("variance of the 1st 10000 numbers: %f", variance); |
|
869 const double eps = 0.0001; |
|
870 t = fabsd(mean - 0.5018); |
|
871 assert(t < eps, "bad mean"); |
|
872 t = (variance - 0.3355) < 0.0 ? -(variance - 0.3355) : variance - 0.3355; |
|
873 assert(t < eps, "bad variance"); |
|
874 } |
|
875 #endif |
|
876 |
|
877 |
|
878 // Set up the boot classpath. |
|
879 |
|
880 char* os::format_boot_path(const char* format_string, |
|
881 const char* home, |
|
882 int home_len, |
|
883 char fileSep, |
|
884 char pathSep) { |
|
885 assert((fileSep == '/' && pathSep == ':') || |
|
886 (fileSep == '\\' && pathSep == ';'), "unexpected seperator chars"); |
|
887 |
|
888 // Scan the format string to determine the length of the actual |
|
889 // boot classpath, and handle platform dependencies as well. |
|
890 int formatted_path_len = 0; |
|
891 const char* p; |
|
892 for (p = format_string; *p != 0; ++p) { |
|
893 if (*p == '%') formatted_path_len += home_len - 1; |
|
894 ++formatted_path_len; |
|
895 } |
|
896 |
|
897 char* formatted_path = NEW_C_HEAP_ARRAY(char, formatted_path_len + 1); |
|
898 if (formatted_path == NULL) { |
|
899 return NULL; |
|
900 } |
|
901 |
|
902 // Create boot classpath from format, substituting separator chars and |
|
903 // java home directory. |
|
904 char* q = formatted_path; |
|
905 for (p = format_string; *p != 0; ++p) { |
|
906 switch (*p) { |
|
907 case '%': |
|
908 strcpy(q, home); |
|
909 q += home_len; |
|
910 break; |
|
911 case '/': |
|
912 *q++ = fileSep; |
|
913 break; |
|
914 case ':': |
|
915 *q++ = pathSep; |
|
916 break; |
|
917 default: |
|
918 *q++ = *p; |
|
919 } |
|
920 } |
|
921 *q = '\0'; |
|
922 |
|
923 assert((q - formatted_path) == formatted_path_len, "formatted_path size botched"); |
|
924 return formatted_path; |
|
925 } |
|
926 |
|
927 |
|
928 bool os::set_boot_path(char fileSep, char pathSep) { |
|
929 |
|
930 const char* home = Arguments::get_java_home(); |
|
931 int home_len = (int)strlen(home); |
|
932 |
|
933 static const char* meta_index_dir_format = "%/lib/"; |
|
934 static const char* meta_index_format = "%/lib/meta-index"; |
|
935 char* meta_index = format_boot_path(meta_index_format, home, home_len, fileSep, pathSep); |
|
936 if (meta_index == NULL) return false; |
|
937 char* meta_index_dir = format_boot_path(meta_index_dir_format, home, home_len, fileSep, pathSep); |
|
938 if (meta_index_dir == NULL) return false; |
|
939 Arguments::set_meta_index_path(meta_index, meta_index_dir); |
|
940 |
|
941 // Any modification to the JAR-file list, for the boot classpath must be |
|
942 // aligned with install/install/make/common/Pack.gmk. Note: boot class |
|
943 // path class JARs, are stripped for StackMapTable to reduce download size. |
|
944 static const char classpath_format[] = |
|
945 "%/lib/resources.jar:" |
|
946 "%/lib/rt.jar:" |
|
947 "%/lib/sunrsasign.jar:" |
|
948 "%/lib/jsse.jar:" |
|
949 "%/lib/jce.jar:" |
|
950 "%/lib/charsets.jar:" |
|
951 "%/classes"; |
|
952 char* sysclasspath = format_boot_path(classpath_format, home, home_len, fileSep, pathSep); |
|
953 if (sysclasspath == NULL) return false; |
|
954 Arguments::set_sysclasspath(sysclasspath); |
|
955 |
|
956 return true; |
|
957 } |
|
958 |
|
959 |
|
960 void os::set_memory_serialize_page(address page) { |
|
961 int count = log2_intptr(sizeof(class JavaThread)) - log2_intptr(64); |
|
962 _mem_serialize_page = (volatile int32_t *)page; |
|
963 // We initialize the serialization page shift count here |
|
964 // We assume a cache line size of 64 bytes |
|
965 assert(SerializePageShiftCount == count, |
|
966 "thread size changed, fix SerializePageShiftCount constant"); |
|
967 set_serialize_page_mask((uintptr_t)(vm_page_size() - sizeof(int32_t))); |
|
968 } |
|
969 |
|
970 // This method is called from signal handler when SIGSEGV occurs while the current |
|
971 // thread tries to store to the "read-only" memory serialize page during state |
|
972 // transition. |
|
973 void os::block_on_serialize_page_trap() { |
|
974 if (TraceSafepoint) { |
|
975 tty->print_cr("Block until the serialize page permission restored"); |
|
976 } |
|
977 // When VMThread is holding the SerializePage_lock during modifying the |
|
978 // access permission of the memory serialize page, the following call |
|
979 // will block until the permission of that page is restored to rw. |
|
980 // Generally, it is unsafe to manipulate locks in signal handlers, but in |
|
981 // this case, it's OK as the signal is synchronous and we know precisely when |
|
982 // it can occur. SerializePage_lock is a transiently-held leaf lock, so |
|
983 // lock_without_safepoint_check should be safe. |
|
984 SerializePage_lock->lock_without_safepoint_check(); |
|
985 SerializePage_lock->unlock(); |
|
986 } |
|
987 |
|
988 // Serialize all thread state variables |
|
989 void os::serialize_thread_states() { |
|
990 // On some platforms such as Solaris & Linux, the time duration of the page |
|
991 // permission restoration is observed to be much longer than expected due to |
|
992 // scheduler starvation problem etc. To avoid the long synchronization |
|
993 // time and expensive page trap spinning, 'SerializePage_lock' is used to block |
|
994 // the mutator thread if such case is encountered. Since this method is always |
|
995 // called by VMThread during safepoint, lock_without_safepoint_check is used |
|
996 // instead. See bug 6546278. |
|
997 SerializePage_lock->lock_without_safepoint_check(); |
|
998 os::protect_memory( (char *)os::get_memory_serialize_page(), os::vm_page_size() ); |
|
999 os::unguard_memory( (char *)os::get_memory_serialize_page(), os::vm_page_size() ); |
|
1000 SerializePage_lock->unlock(); |
|
1001 } |
|
1002 |
|
1003 // Returns true if the current stack pointer is above the stack shadow |
|
1004 // pages, false otherwise. |
|
1005 |
|
1006 bool os::stack_shadow_pages_available(Thread *thread, methodHandle method) { |
|
1007 assert(StackRedPages > 0 && StackYellowPages > 0,"Sanity check"); |
|
1008 address sp = current_stack_pointer(); |
|
1009 // Check if we have StackShadowPages above the yellow zone. This parameter |
|
1010 // is dependant on the depth of the maximum VM call stack possible from |
|
1011 // the handler for stack overflow. 'instanceof' in the stack overflow |
|
1012 // handler or a println uses at least 8k stack of VM and native code |
|
1013 // respectively. |
|
1014 const int framesize_in_bytes = |
|
1015 Interpreter::size_top_interpreter_activation(method()) * wordSize; |
|
1016 int reserved_area = ((StackShadowPages + StackRedPages + StackYellowPages) |
|
1017 * vm_page_size()) + framesize_in_bytes; |
|
1018 // The very lower end of the stack |
|
1019 address stack_limit = thread->stack_base() - thread->stack_size(); |
|
1020 return (sp > (stack_limit + reserved_area)); |
|
1021 } |
|
1022 |
|
1023 size_t os::page_size_for_region(size_t region_min_size, size_t region_max_size, |
|
1024 uint min_pages) |
|
1025 { |
|
1026 assert(min_pages > 0, "sanity"); |
|
1027 if (UseLargePages) { |
|
1028 const size_t max_page_size = region_max_size / min_pages; |
|
1029 |
|
1030 for (unsigned int i = 0; _page_sizes[i] != 0; ++i) { |
|
1031 const size_t sz = _page_sizes[i]; |
|
1032 const size_t mask = sz - 1; |
|
1033 if ((region_min_size & mask) == 0 && (region_max_size & mask) == 0) { |
|
1034 // The largest page size with no fragmentation. |
|
1035 return sz; |
|
1036 } |
|
1037 |
|
1038 if (sz <= max_page_size) { |
|
1039 // The largest page size that satisfies the min_pages requirement. |
|
1040 return sz; |
|
1041 } |
|
1042 } |
|
1043 } |
|
1044 |
|
1045 return vm_page_size(); |
|
1046 } |
|
1047 |
|
1048 #ifndef PRODUCT |
|
1049 void os::trace_page_sizes(const char* str, const size_t region_min_size, |
|
1050 const size_t region_max_size, const size_t page_size, |
|
1051 const char* base, const size_t size) |
|
1052 { |
|
1053 if (TracePageSizes) { |
|
1054 tty->print_cr("%s: min=" SIZE_FORMAT " max=" SIZE_FORMAT |
|
1055 " pg_sz=" SIZE_FORMAT " base=" PTR_FORMAT |
|
1056 " size=" SIZE_FORMAT, |
|
1057 str, region_min_size, region_max_size, |
|
1058 page_size, base, size); |
|
1059 } |
|
1060 } |
|
1061 #endif // #ifndef PRODUCT |
|
1062 |
|
1063 // This is the working definition of a server class machine: |
|
1064 // >= 2 physical CPU's and >=2GB of memory, with some fuzz |
|
1065 // because the graphics memory (?) sometimes masks physical memory. |
|
1066 // If you want to change the definition of a server class machine |
|
1067 // on some OS or platform, e.g., >=4GB on Windohs platforms, |
|
1068 // then you'll have to parameterize this method based on that state, |
|
1069 // as was done for logical processors here, or replicate and |
|
1070 // specialize this method for each platform. (Or fix os to have |
|
1071 // some inheritance structure and use subclassing. Sigh.) |
|
1072 // If you want some platform to always or never behave as a server |
|
1073 // class machine, change the setting of AlwaysActAsServerClassMachine |
|
1074 // and NeverActAsServerClassMachine in globals*.hpp. |
|
1075 bool os::is_server_class_machine() { |
|
1076 // First check for the early returns |
|
1077 if (NeverActAsServerClassMachine) { |
|
1078 return false; |
|
1079 } |
|
1080 if (AlwaysActAsServerClassMachine) { |
|
1081 return true; |
|
1082 } |
|
1083 // Then actually look at the machine |
|
1084 bool result = false; |
|
1085 const unsigned int server_processors = 2; |
|
1086 const julong server_memory = 2UL * G; |
|
1087 // We seem not to get our full complement of memory. |
|
1088 // We allow some part (1/8?) of the memory to be "missing", |
|
1089 // based on the sizes of DIMMs, and maybe graphics cards. |
|
1090 const julong missing_memory = 256UL * M; |
|
1091 |
|
1092 /* Is this a server class machine? */ |
|
1093 if ((os::active_processor_count() >= (int)server_processors) && |
|
1094 (os::physical_memory() >= (server_memory - missing_memory))) { |
|
1095 const unsigned int logical_processors = |
|
1096 VM_Version::logical_processors_per_package(); |
|
1097 if (logical_processors > 1) { |
|
1098 const unsigned int physical_packages = |
|
1099 os::active_processor_count() / logical_processors; |
|
1100 if (physical_packages > server_processors) { |
|
1101 result = true; |
|
1102 } |
|
1103 } else { |
|
1104 result = true; |
|
1105 } |
|
1106 } |
|
1107 return result; |
|
1108 } |