|
1 # |
|
2 # Copyright (c) 2011, 2012, 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. Oracle designates this |
|
8 # particular file as subject to the "Classpath" exception as provided |
|
9 # by Oracle in the LICENSE file that accompanied this code. |
|
10 # |
|
11 # This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 # version 2 for more details (a copy is included in the LICENSE file that |
|
15 # accompanied this code). |
|
16 # |
|
17 # You should have received a copy of the GNU General Public License version |
|
18 # 2 along with this work; if not, write to the Free Software Foundation, |
|
19 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 # |
|
21 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
22 # or visit www.oracle.com if you need additional information or have any |
|
23 # questions. |
|
24 # |
|
25 |
|
26 AC_DEFUN([BPERF_CHECK_CORES], |
|
27 [ |
|
28 AC_MSG_CHECKING([for number of cores]) |
|
29 NUM_CORES=1 |
|
30 FOUND_CORES=no |
|
31 |
|
32 if test -f /proc/cpuinfo; then |
|
33 # Looks like a Linux system |
|
34 NUM_CORES=`cat /proc/cpuinfo | grep -c processor` |
|
35 FOUND_CORES=yes |
|
36 fi |
|
37 |
|
38 if test -x /usr/sbin/psrinfo; then |
|
39 # Looks like a Solaris system |
|
40 NUM_CORES=`LC_MESSAGES=C /usr/sbin/psrinfo -v | grep -c on-line` |
|
41 FOUND_CORES=yes |
|
42 fi |
|
43 |
|
44 if test -x /usr/sbin/system_profiler; then |
|
45 # Looks like a MacOSX system |
|
46 NUM_CORES=`/usr/sbin/system_profiler -detailLevel full SPHardwareDataType | grep 'Cores' | awk '{print [$]5}'` |
|
47 FOUND_CORES=yes |
|
48 fi |
|
49 |
|
50 if test "x$build_os" = xwindows; then |
|
51 NUM_CORES=4 |
|
52 fi |
|
53 |
|
54 # For c/c++ code we run twice as many concurrent build |
|
55 # jobs than we have cores, otherwise we will stall on io. |
|
56 CONCURRENT_BUILD_JOBS=`expr $NUM_CORES \* 2` |
|
57 |
|
58 if test "x$FOUND_CORES" = xyes; then |
|
59 AC_MSG_RESULT([$NUM_CORES]) |
|
60 else |
|
61 AC_MSG_RESULT([could not detect number of cores, defaulting to 1!]) |
|
62 fi |
|
63 |
|
64 ]) |
|
65 |
|
66 AC_DEFUN([BPERF_CHECK_MEMORY_SIZE], |
|
67 [ |
|
68 AC_MSG_CHECKING([for memory size]) |
|
69 # Default to 1024MB |
|
70 MEMORY_SIZE=1024 |
|
71 FOUND_MEM=no |
|
72 |
|
73 if test -f /proc/cpuinfo; then |
|
74 # Looks like a Linux system |
|
75 MEMORY_SIZE=`cat /proc/meminfo | grep MemTotal | awk '{print [$]2}'` |
|
76 MEMORY_SIZE=`expr $MEMORY_SIZE / 1024` |
|
77 FOUND_MEM=yes |
|
78 fi |
|
79 |
|
80 if test -x /usr/sbin/prtconf; then |
|
81 # Looks like a Solaris system |
|
82 MEMORY_SIZE=`/usr/sbin/prtconf | grep "Memory size" | awk '{ print [$]3 }'` |
|
83 FOUND_MEM=yes |
|
84 fi |
|
85 |
|
86 if test -x /usr/sbin/system_profiler; then |
|
87 # Looks like a MacOSX system |
|
88 MEMORY_SIZE=`/usr/sbin/system_profiler -detailLevel full SPHardwareDataType | grep 'Memory' | awk '{print [$]2}'` |
|
89 MEMORY_SIZE=`expr $MEMORY_SIZE \* 1024` |
|
90 FOUND_MEM=yes |
|
91 fi |
|
92 |
|
93 if test "x$build_os" = xwindows; then |
|
94 MEMORY_SIZE=`systeminfo | grep 'Total Physical Memory:' | awk '{ print [$]4 }' | sed 's/,//'` |
|
95 FOUND_MEM=yes |
|
96 fi |
|
97 |
|
98 if test "x$FOUND_MEM" = xyes; then |
|
99 AC_MSG_RESULT([$MEMORY_SIZE MB]) |
|
100 else |
|
101 AC_MSG_RESULT([could not detect memory size defaulting to 1024MB!]) |
|
102 fi |
|
103 ]) |
|
104 |
|
105 AC_DEFUN_ONCE([BPERF_SETUP_BUILD_CORES], |
|
106 [ |
|
107 # How many cores do we have on this build system? |
|
108 AC_ARG_WITH(num-cores, [AS_HELP_STRING([--with-num-cores], |
|
109 [number of cores in the build system, e.g. --with-num-cores=8 @<:@probed@:>@])]) |
|
110 if test "x$with_num_cores" = x; then |
|
111 # The number of cores were not specified, try to probe them. |
|
112 BPERF_CHECK_CORES |
|
113 else |
|
114 NUM_CORES=$with_num_cores |
|
115 CONCURRENT_BUILD_JOBS=`expr $NUM_CORES \* 2` |
|
116 fi |
|
117 AC_SUBST(NUM_CORES) |
|
118 AC_SUBST(CONCURRENT_BUILD_JOBS) |
|
119 ]) |
|
120 |
|
121 AC_DEFUN_ONCE([BPERF_SETUP_BUILD_MEMORY], |
|
122 [ |
|
123 # How much memory do we have on this build system? |
|
124 AC_ARG_WITH(memory-size, [AS_HELP_STRING([--with-memory-size], |
|
125 [memory (in MB) available in the build system, e.g. --with-memory-size=1024 @<:@probed@:>@])]) |
|
126 if test "x$with_memory_size" = x; then |
|
127 # The memory size was not specified, try to probe it. |
|
128 BPERF_CHECK_MEMORY_SIZE |
|
129 else |
|
130 MEMORY_SIZE=$with_memory_size |
|
131 fi |
|
132 AC_SUBST(MEMORY_SIZE) |
|
133 ]) |
|
134 |
|
135 AC_DEFUN([BPERF_SETUP_CCACHE], |
|
136 [ |
|
137 AC_ARG_ENABLE([ccache], |
|
138 [AS_HELP_STRING([--disable-ccache], |
|
139 [use ccache to speed up recompilations @<:@enabled@:>@])], |
|
140 [ENABLE_CCACHE=${enable_ccache}], [ENABLE_CCACHE=yes]) |
|
141 if test "x$ENABLE_CCACHE" = xyes; then |
|
142 AC_PATH_PROG(CCACHE, ccache) |
|
143 else |
|
144 AC_MSG_CHECKING([for ccache]) |
|
145 AC_MSG_RESULT([explicitly disabled]) |
|
146 CCACHE= |
|
147 fi |
|
148 AC_SUBST(CCACHE) |
|
149 |
|
150 AC_ARG_WITH([ccache-dir], |
|
151 [AS_HELP_STRING([--with-ccache-dir], |
|
152 [where to store ccache files @<:@~/.ccache@:>@])]) |
|
153 |
|
154 if test "x$with_ccache_dir" != x; then |
|
155 # When using a non home ccache directory, assume the use is to share ccache files |
|
156 # with other users. Thus change the umask. |
|
157 SET_CCACHE_DIR="CCACHE_DIR=$with_ccache_dir CCACHE_UMASK=002" |
|
158 fi |
|
159 CCACHE_FOUND="" |
|
160 if test "x$CCACHE" != x; then |
|
161 BPERF_SETUP_CCACHE_USAGE |
|
162 fi |
|
163 ]) |
|
164 |
|
165 AC_DEFUN([BPERF_SETUP_CCACHE_USAGE], |
|
166 [ |
|
167 if test "x$CCACHE" != x; then |
|
168 CCACHE_FOUND="true" |
|
169 # Only use ccache if it is 3.1.4 or later, which supports |
|
170 # precompiled headers. |
|
171 AC_MSG_CHECKING([if ccache supports precompiled headers]) |
|
172 HAS_GOOD_CCACHE=`($CCACHE --version | head -n 1 | grep -E 3.1.@<:@456789@:>@) 2> /dev/null` |
|
173 if test "x$HAS_GOOD_CCACHE" = x; then |
|
174 AC_MSG_RESULT([no, disabling ccache]) |
|
175 CCACHE= |
|
176 else |
|
177 AC_MSG_RESULT([yes]) |
|
178 AC_MSG_CHECKING([if C-compiler supports ccache precompiled headers]) |
|
179 PUSHED_FLAGS="$CXXFLAGS" |
|
180 CXXFLAGS="-fpch-preprocess $CXXFLAGS" |
|
181 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [CC_KNOWS_CCACHE_TRICK=yes], [CC_KNOWS_CCACHE_TRICK=no]) |
|
182 CXXFLAGS="$PUSHED_FLAGS" |
|
183 if test "x$CC_KNOWS_CCACHE_TRICK" = xyes; then |
|
184 AC_MSG_RESULT([yes]) |
|
185 else |
|
186 AC_MSG_RESULT([no, disabling ccaching of precompiled headers]) |
|
187 CCACHE= |
|
188 fi |
|
189 fi |
|
190 fi |
|
191 |
|
192 if test "x$CCACHE" != x; then |
|
193 CCACHE_SLOPPINESS=time_macros |
|
194 CCACHE="CCACHE_COMPRESS=1 $SET_CCACHE_DIR CCACHE_SLOPPINESS=$CCACHE_SLOPPINESS $CCACHE" |
|
195 CCACHE_FLAGS=-fpch-preprocess |
|
196 |
|
197 if test "x$SET_CCACHE_DIR" != x; then |
|
198 mkdir -p $CCACHE_DIR > /dev/null 2>&1 |
|
199 chmod a+rwxs $CCACHE_DIR > /dev/null 2>&1 |
|
200 fi |
|
201 fi |
|
202 ]) |
|
203 |
|
204 AC_DEFUN_ONCE([BPERF_SETUP_PRECOMPILED_HEADERS], |
|
205 [ |
|
206 |
|
207 ############################################################################### |
|
208 # |
|
209 # Can the C/C++ compiler use precompiled headers? |
|
210 # |
|
211 AC_ARG_ENABLE([precompiled-headers], [AS_HELP_STRING([--disable-precompiled-headers], |
|
212 [use precompiled headers when compiling C++ @<:@enabled@:>@])], |
|
213 [ENABLE_PRECOMPH=${enable_precompiled-headers}], [ENABLE_PRECOMPH=yes]) |
|
214 |
|
215 USE_PRECOMPILED_HEADER=1 |
|
216 if test "x$ENABLE_PRECOMPH" = xno; then |
|
217 USE_PRECOMPILED_HEADER=0 |
|
218 fi |
|
219 |
|
220 if test "x$ENABLE_PRECOMPH" = xyes; then |
|
221 # Check that the compiler actually supports precomp headers. |
|
222 if test "x$GCC" = xyes; then |
|
223 AC_MSG_CHECKING([that precompiled headers work]) |
|
224 echo "int alfa();" > conftest.h |
|
225 $CXX -x c++-header conftest.h -o conftest.hpp.gch |
|
226 if test ! -f conftest.hpp.gch; then |
|
227 echo Precompiled header is not working! |
|
228 USE_PRECOMPILED_HEADER=0 |
|
229 AC_MSG_RESULT([no]) |
|
230 else |
|
231 AC_MSG_RESULT([yes]) |
|
232 fi |
|
233 rm -f conftest.h |
|
234 fi |
|
235 fi |
|
236 |
|
237 AC_SUBST(USE_PRECOMPILED_HEADER) |
|
238 ]) |
|
239 |
|
240 |
|
241 AC_DEFUN_ONCE([BPERF_SETUP_SMART_JAVAC], |
|
242 [ |
|
243 AC_ARG_WITH(server-java, [AS_HELP_STRING([--with-server-java], |
|
244 [use this java binary for running the javac background server and other long running java tasks in the build process, |
|
245 e.g. ---with-server-java="/opt/jrockit/bin/java -server"])]) |
|
246 |
|
247 if test "x$with_server_java" != x; then |
|
248 SERVER_JAVA="$with_server_java" |
|
249 FOUND_VERSION=`$SERVER_JAVA -version 2>&1 | grep " version \""` |
|
250 if test "x$FOUND_VERSION" = x; then |
|
251 AC_MSG_ERROR([Could not execute server java: $SERVER_JAVA]) |
|
252 fi |
|
253 else |
|
254 SERVER_JAVA="" |
|
255 # Hotspot specific options. |
|
256 ADD_JVM_ARG_IF_OK([-XX:+UseParallelOldGC],SERVER_JAVA,[$JAVA]) |
|
257 ADD_JVM_ARG_IF_OK([-verbosegc],SERVER_JAVA,[$JAVA]) |
|
258 # JRockit specific options. |
|
259 ADD_JVM_ARG_IF_OK([-Xverbose:gc],SERVER_JAVA,[$JAVA]) |
|
260 SERVER_JAVA="$JAVA $SERVER_JAVA" |
|
261 fi |
|
262 AC_SUBST(SERVER_JAVA) |
|
263 |
|
264 AC_MSG_CHECKING([whether to use shared server for javac]) |
|
265 AC_ARG_ENABLE([javac-server], [AS_HELP_STRING([--enable-javac-server], |
|
266 [enable the shared javac server during the build process @<:@disabled@:>@])], |
|
267 [ENABLE_JAVAC_SERVER="${enableval}"], [ENABLE_JAVAC_SERVER='no']) |
|
268 AC_MSG_RESULT([$ENABLE_JAVAC_SERVER]) |
|
269 if test "x$ENABLE_JAVAC_SERVER" = xyes; then |
|
270 JAVAC_USE_REMOTE=true |
|
271 JAVAC_SERVERS="$OUTPUT_ROOT/javacservers" |
|
272 else |
|
273 JAVAC_USE_REMOTE=false |
|
274 JAVAC_SERVERS= |
|
275 fi |
|
276 AC_SUBST(JAVAC_USE_REMOTE) |
|
277 AC_SUBST(JAVAC_SERVERS) |
|
278 |
|
279 AC_ARG_WITH(javac-server-cores, [AS_HELP_STRING([--with-javac-server-cores], |
|
280 [use at most this number of concurrent threads on the javac server @<:@probed@:>@])]) |
|
281 if test "x$with_javac_server_cores" != x; then |
|
282 JAVAC_SERVER_CORES="$with_javac_server_cores" |
|
283 else |
|
284 if test "$NUM_CORES" -gt 16; then |
|
285 # We set this arbitrary limit because we want to limit the heap |
|
286 # size of the javac server. |
|
287 # In the future we will make the javac compilers in the server |
|
288 # share more and more state, thus enabling us to use more and |
|
289 # more concurrent threads in the server. |
|
290 JAVAC_SERVER_CORES="16" |
|
291 else |
|
292 JAVAC_SERVER_CORES="$NUM_CORES" |
|
293 fi |
|
294 |
|
295 if test "$MEMORY_SIZE" -gt "17000"; then |
|
296 MAX_HEAP_MEM=10000 |
|
297 ADD_JVM_ARG_IF_OK([-d64],SERVER_JAVA,[$SERVER_JAVA]) |
|
298 ADD_JVM_ARG_IF_OK([-Xms10G -Xmx10G],SERVER_JAVA,[$SERVER_JAVA]) |
|
299 ADD_JVM_ARG_IF_OK([-Xmn2G],SERVER_JAVA,[$SERVER_JAVA]) |
|
300 elif test "$MEMORY_SIZE" -gt "10000"; then |
|
301 MAX_HEAP_MEM=6000 |
|
302 ADD_JVM_ARG_IF_OK([-d64],SERVER_JAVA,[$SERVER_JAVA]) |
|
303 ADD_JVM_ARG_IF_OK([-Xms6G -Xmx6G],SERVER_JAVA,[$SERVER_JAVA]) |
|
304 ADD_JVM_ARG_IF_OK([-Xmn1G],SERVER_JAVA,[$SERVER_JAVA]) |
|
305 elif test "$MEMORY_SIZE" -gt "5000"; then |
|
306 MAX_HEAP_MEM=3000 |
|
307 ADD_JVM_ARG_IF_OK([-d64],SERVER_JAVA,[$SERVER_JAVA]) |
|
308 ADD_JVM_ARG_IF_OK([-Xms1G -Xmx3G],SERVER_JAVA,[$SERVER_JAVA]) |
|
309 ADD_JVM_ARG_IF_OK([-Xmn256M],SERVER_JAVA,[$SERVER_JAVA]) |
|
310 elif test "$MEMORY_SIZE" -gt "3800"; then |
|
311 MAX_HEAP_MEM=2500 |
|
312 ADD_JVM_ARG_IF_OK([-Xms1G -Xmx2500M],SERVER_JAVA,[$SERVER_JAVA]) |
|
313 ADD_JVM_ARG_IF_OK([-Xmn256M],SERVER_JAVA,[$SERVER_JAVA]) |
|
314 elif test "$MEMORY_SIZE" -gt "1900"; then |
|
315 MAX_HEAP_MEM=1200 |
|
316 ADD_JVM_ARG_IF_OK([-Xms700M -Xmx1200M],SERVER_JAVA,[$SERVER_JAVA]) |
|
317 ADD_JVM_ARG_IF_OK([-Xmn256M],SERVER_JAVA,[$SERVER_JAVA]) |
|
318 elif test "$MEMORY_SIZE" -gt "1000"; then |
|
319 MAX_HEAP_MEM=900 |
|
320 ADD_JVM_ARG_IF_OK([-Xms400M -Xmx900M],SERVER_JAVA,[$SERVER_JAVA]) |
|
321 ADD_JVM_ARG_IF_OK([-Xmn128M],SERVER_JAVA,[$SERVER_JAVA]) |
|
322 else |
|
323 MAX_HEAP_MEM=512 |
|
324 ADD_JVM_ARG_IF_OK([-Xms256M -Xmx512M],SERVER_JAVA,[$SERVER_JAVA]) |
|
325 ADD_JVM_ARG_IF_OK([-Xmn128M],SERVER_JAVA,[$SERVER_JAVA]) |
|
326 fi |
|
327 |
|
328 MAX_COMPILERS_IN_HEAP=`expr $MAX_HEAP_MEM / 501` |
|
329 if test "$JAVAC_SERVER_CORES" -gt "$MAX_COMPILERS_IN_HEAP"; then |
|
330 AC_MSG_CHECKING([if number of server cores must be reduced]) |
|
331 JAVAC_SERVER_CORES="$MAX_COMPILERS_IN_HEAP" |
|
332 AC_MSG_RESULT([yes, to $JAVAC_SERVER_CORES with max heap size $MAX_HEAP_MEM MB]) |
|
333 fi |
|
334 fi |
|
335 AC_SUBST(JAVAC_SERVER_CORES) |
|
336 |
|
337 AC_MSG_CHECKING([whether to track dependencies between Java packages]) |
|
338 AC_ARG_ENABLE([javac-deps], [AS_HELP_STRING([--enable-javac-deps], |
|
339 [enable the dependency tracking between Java packages @<:@disabled@:>@])], |
|
340 [ENABLE_JAVAC_DEPS="${enableval}"], [ENABLE_JAVAC_DEPS='no']) |
|
341 AC_MSG_RESULT([$ENABLE_JAVAC_DEPS]) |
|
342 if test "x$ENABLE_JAVAC_DEPS" = xyes; then |
|
343 JAVAC_USE_DEPS=true |
|
344 else |
|
345 JAVAC_USE_DEPS=false |
|
346 fi |
|
347 AC_SUBST(JAVAC_USE_DEPS) |
|
348 |
|
349 AC_MSG_CHECKING([whether to use multiple cores for javac compilation]) |
|
350 AC_ARG_ENABLE([javac-multi-core], [AS_HELP_STRING([--enable-javac-multi-core], |
|
351 [compile Java packages concurrently @<:@disabled@:>@])], |
|
352 [ENABLE_JAVAC_MULTICORE="${enableval}"], [ENABLE_JAVAC_MULTICORE='no']) |
|
353 AC_MSG_RESULT([$ENABLE_JAVAC_MULTICORE]) |
|
354 if test "x$ENABLE_JAVAC_MULTICORE" = xyes; then |
|
355 JAVAC_USE_MODE=MULTI_CORE_CONCURRENT |
|
356 else |
|
357 JAVAC_USE_MODE=SINGLE_THREADED_BATCH |
|
358 if test "x$ENABLE_JAVAC_DEPS" = xyes; then |
|
359 AC_MSG_WARN([Dependency tracking is not supported with single threaded batch compiles of Java source roots. Please add --disable-javac-deps to your configure options.]) |
|
360 AC_MSG_WARN([Disabling dependency tracking for you now.]) |
|
361 JAVAC_USE_DEPS=false |
|
362 fi |
|
363 if test "x$ENABLE_JAVAC_SERVER" = xyes; then |
|
364 AC_MSG_WARN([The javac server will not be used since single threaded batch compiles are run within their own JVM. Please add --disable-javac-server to your configure options.]) |
|
365 AC_MSG_WARN([Disabling javac server for you now.]) |
|
366 JAVAC_USE_REMOTE=false |
|
367 fi |
|
368 fi |
|
369 AC_SUBST(JAVAC_USE_MODE) |
|
370 |
|
371 AC_MSG_CHECKING([whether to use sjavac]) |
|
372 AC_ARG_ENABLE([sjavac], [AS_HELP_STRING([--enable-sjavac], |
|
373 [use sjavac to do fast incremental compiles @<:@disabled@:>@])], |
|
374 [ENABLE_SJAVAC="${enableval}"], [ENABLE_SJAVAC='no']) |
|
375 AC_MSG_RESULT([$ENABLE_SJAVAC]) |
|
376 AC_SUBST(ENABLE_SJAVAC) |
|
377 |
|
378 ]) |