comparison src/hotspot/cpu/x86/rdtsc_x86.cpp @ 54526:ee29b516a36a

revert changes
author jlaskey
date Wed, 23 Jan 2019 16:09:20 -0400
parents
children 81becad91321
comparison
equal deleted inserted replaced
-1:000000000000 0:e6d6bd8eebda
1 /*
2 * Copyright (c) 2013, 2018, 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 "rdtsc_x86.hpp"
27 #include "runtime/thread.inline.hpp"
28 #include "vm_version_ext_x86.hpp"
29
30 // The following header contains the implementations of rdtsc()
31 #include OS_CPU_HEADER_INLINE(os)
32
33 static jlong _epoch = 0;
34 static bool rdtsc_elapsed_counter_enabled = false;
35 static jlong tsc_frequency = 0;
36
37 static jlong set_epoch() {
38 assert(0 == _epoch, "invariant");
39 _epoch = os::rdtsc();
40 return _epoch;
41 }
42
43 // Base loop to estimate ticks frequency for tsc counter from user mode.
44 // Volatiles and sleep() are used to prevent compiler from applying optimizations.
45 static void do_time_measurements(volatile jlong& time_base,
46 volatile jlong& time_fast,
47 volatile jlong& time_base_elapsed,
48 volatile jlong& time_fast_elapsed) {
49 static const unsigned int FT_SLEEP_MILLISECS = 1;
50 const unsigned int loopcount = 3;
51
52 volatile jlong start = 0;
53 volatile jlong fstart = 0;
54 volatile jlong end = 0;
55 volatile jlong fend = 0;
56
57 // Figure out the difference between rdtsc and os provided timer.
58 // base algorithm adopted from JRockit.
59 for (unsigned int times = 0; times < loopcount; times++) {
60 start = os::elapsed_counter();
61 OrderAccess::fence();
62 fstart = os::rdtsc();
63
64 // use sleep to prevent compiler from optimizing
65 os::sleep(Thread::current(), FT_SLEEP_MILLISECS, true);
66
67 end = os::elapsed_counter();
68 OrderAccess::fence();
69 fend = os::rdtsc();
70
71 time_base += end - start;
72 time_fast += fend - fstart;
73
74 // basis for calculating the os tick start
75 // to fast time tick start offset
76 time_base_elapsed += end;
77 time_fast_elapsed += (fend - _epoch);
78 }
79
80 time_base /= loopcount;
81 time_fast /= loopcount;
82 time_base_elapsed /= loopcount;
83 time_fast_elapsed /= loopcount;
84 }
85
86 static jlong initialize_frequency() {
87 assert(0 == tsc_frequency, "invariant");
88 assert(0 == _epoch, "invariant");
89 const jlong initial_counter = set_epoch();
90 if (initial_counter == 0) {
91 return 0;
92 }
93 // os time frequency
94 static double os_freq = (double)os::elapsed_frequency();
95 assert(os_freq > 0, "os_elapsed frequency corruption!");
96
97 double tsc_freq = .0;
98 double os_to_tsc_conv_factor = 1.0;
99
100 // if platform supports invariant tsc,
101 // apply higher resolution and granularity for conversion calculations
102 if (VM_Version_Ext::supports_tscinv_ext()) {
103 // for invariant tsc platforms, take the maximum qualified cpu frequency
104 tsc_freq = (double)VM_Version_Ext::maximum_qualified_cpu_frequency();
105 os_to_tsc_conv_factor = tsc_freq / os_freq;
106 } else {
107 // use measurements to estimate
108 // a conversion factor and the tsc frequency
109
110 volatile jlong time_base = 0;
111 volatile jlong time_fast = 0;
112 volatile jlong time_base_elapsed = 0;
113 volatile jlong time_fast_elapsed = 0;
114
115 // do measurements to get base data
116 // on os timer and fast ticks tsc time relation.
117 do_time_measurements(time_base, time_fast, time_base_elapsed, time_fast_elapsed);
118
119 // if invalid measurements, cannot proceed
120 if (time_fast == 0 || time_base == 0) {
121 return 0;
122 }
123
124 os_to_tsc_conv_factor = (double)time_fast / (double)time_base;
125 if (os_to_tsc_conv_factor > 1) {
126 // estimate on tsc counter frequency
127 tsc_freq = os_to_tsc_conv_factor * os_freq;
128 }
129 }
130
131 if ((tsc_freq < 0) || (tsc_freq > 0 && tsc_freq <= os_freq) || (os_to_tsc_conv_factor <= 1)) {
132 // safer to run with normal os time
133 tsc_freq = .0;
134 }
135
136 // frequency of the tsc_counter
137 return (jlong)tsc_freq;
138 }
139
140 static bool initialize_elapsed_counter() {
141 tsc_frequency = initialize_frequency();
142 return tsc_frequency != 0 && _epoch != 0;
143 }
144
145 static bool ergonomics() {
146 const bool invtsc_support = Rdtsc::is_supported();
147 if (FLAG_IS_DEFAULT(UseFastUnorderedTimeStamps) && invtsc_support) {
148 FLAG_SET_ERGO(bool, UseFastUnorderedTimeStamps, true);
149 }
150
151 bool ft_enabled = UseFastUnorderedTimeStamps && invtsc_support;
152
153 if (!ft_enabled) {
154 if (UseFastUnorderedTimeStamps && VM_Version::supports_tsc()) {
155 warning("\nThe hardware does not support invariant tsc (INVTSC) register and/or cannot guarantee tsc synchronization between sockets at startup.\n"\
156 "Values returned via rdtsc() are not guaranteed to be accurate, esp. when comparing values from cross sockets reads. Enabling UseFastUnorderedTimeStamps on non-invariant tsc hardware should be considered experimental.\n");
157 ft_enabled = true;
158 }
159 }
160
161 if (!ft_enabled) {
162 // Warn if unable to support command-line flag
163 if (UseFastUnorderedTimeStamps && !VM_Version::supports_tsc()) {
164 warning("Ignoring UseFastUnorderedTimeStamps, hardware does not support normal tsc");
165 }
166 }
167
168 return ft_enabled;
169 }
170
171 bool Rdtsc::is_supported() {
172 return VM_Version_Ext::supports_tscinv_ext();
173 }
174
175 bool Rdtsc::is_elapsed_counter_enabled() {
176 return rdtsc_elapsed_counter_enabled;
177 }
178
179 jlong Rdtsc::frequency() {
180 return tsc_frequency;
181 }
182
183 jlong Rdtsc::elapsed_counter() {
184 return os::rdtsc() - _epoch;
185 }
186
187 jlong Rdtsc::epoch() {
188 return _epoch;
189 }
190
191 jlong Rdtsc::raw() {
192 return os::rdtsc();
193 }
194
195 bool Rdtsc::initialize() {
196 static bool initialized = false;
197 if (!initialized) {
198 assert(!rdtsc_elapsed_counter_enabled, "invariant");
199 VM_Version_Ext::initialize();
200 assert(0 == tsc_frequency, "invariant");
201 assert(0 == _epoch, "invariant");
202 bool result = initialize_elapsed_counter(); // init hw
203 if (result) {
204 result = ergonomics(); // check logical state
205 }
206 rdtsc_elapsed_counter_enabled = result;
207 initialized = true;
208 }
209 return rdtsc_elapsed_counter_enabled;
210 }