1 /*
2 * Copyright (c) 2007, 2015, 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
877 throw new InternalError("mismatched renderer constants");
878 }
879 }
880
881 // --- RendererContext handling ---
882 // use ThreadLocal or ConcurrentLinkedQueue to get one RendererContext
883 private static final boolean useThreadLocal;
884
885 // hard reference
886 static final int REF_HARD = 0;
887 // soft reference
888 static final int REF_SOFT = 1;
889 // weak reference
890 static final int REF_WEAK = 2;
891
892 // reference type stored in either TL or CLQ
893 static final int REF_TYPE;
894
895 // Per-thread RendererContext
896 private static final ThreadLocal<Object> rdrCtxThreadLocal;
897 // RendererContext queue when ThreadLocal is disabled
898 private static final ConcurrentLinkedQueue<Object> rdrCtxQueue;
899
900 // Static initializer to use TL or CLQ mode
901 static {
902 // CLQ mode by default:
903 useThreadLocal = MarlinProperties.isUseThreadLocal();
904 rdrCtxThreadLocal = (useThreadLocal) ? new ThreadLocal<Object>()
905 : null;
906 rdrCtxQueue = (!useThreadLocal) ? new ConcurrentLinkedQueue<Object>()
907 : null;
908
909 // Soft reference by default:
910 String refType = AccessController.doPrivileged(
911 new GetPropertyAction("sun.java2d.renderer.useRef",
912 "soft"));
913 switch (refType) {
914 default:
915 case "soft":
916 REF_TYPE = REF_SOFT;
917 break;
918 case "weak":
919 REF_TYPE = REF_WEAK;
920 break;
921 case "hard":
922 REF_TYPE = REF_HARD;
923 break;
924 }
925 }
926
927 private static boolean settingsLogged = !enableLogs;
1009 + MarlinConst.logUnsafeMalloc);
1010
1011 // quality settings
1012 logInfo("Renderer settings:");
1013 logInfo("CUB_COUNT_LG = " + Renderer.CUB_COUNT_LG);
1014 logInfo("CUB_DEC_BND = " + Renderer.CUB_DEC_BND);
1015 logInfo("CUB_INC_BND = " + Renderer.CUB_INC_BND);
1016 logInfo("QUAD_DEC_BND = " + Renderer.QUAD_DEC_BND);
1017
1018 logInfo("=========================================================="
1019 + "=====================");
1020 }
1021
1022 /**
1023 * Get the RendererContext instance dedicated to the current thread
1024 * @return RendererContext instance
1025 */
1026 @SuppressWarnings({"unchecked"})
1027 static RendererContext getRendererContext() {
1028 RendererContext rdrCtx = null;
1029 final Object ref = (useThreadLocal) ? rdrCtxThreadLocal.get()
1030 : rdrCtxQueue.poll();
1031 if (ref != null) {
1032 // resolve reference:
1033 rdrCtx = (REF_TYPE == REF_HARD) ? ((RendererContext) ref)
1034 : ((Reference<RendererContext>) ref).get();
1035 }
1036 // create a new RendererContext if none is available
1037 if (rdrCtx == null) {
1038 rdrCtx = RendererContext.createContext();
1039 if (useThreadLocal) {
1040 // update thread local reference:
1041 rdrCtxThreadLocal.set(rdrCtx.reference);
1042 }
1043 }
1044 if (doMonitors) {
1045 RendererContext.stats.mon_pre_getAATileGenerator.start();
1046 }
1047 return rdrCtx;
1048 }
1049
1050 /**
1051 * Reset and return the given RendererContext instance for reuse
1052 * @param rdrCtx RendererContext instance
1053 */
1054 static void returnRendererContext(final RendererContext rdrCtx) {
1055 rdrCtx.dispose();
1056
1057 if (doMonitors) {
1058 RendererContext.stats.mon_pre_getAATileGenerator.stop();
1059 }
1060 if (!useThreadLocal) {
1061 rdrCtxQueue.offer(rdrCtx.reference);
1062 }
1063 }
1064 }
|
1 /*
2 * Copyright (c) 2007, 2016, 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
877 throw new InternalError("mismatched renderer constants");
878 }
879 }
880
881 // --- RendererContext handling ---
882 // use ThreadLocal or ConcurrentLinkedQueue to get one RendererContext
883 private static final boolean useThreadLocal;
884
885 // hard reference
886 static final int REF_HARD = 0;
887 // soft reference
888 static final int REF_SOFT = 1;
889 // weak reference
890 static final int REF_WEAK = 2;
891
892 // reference type stored in either TL or CLQ
893 static final int REF_TYPE;
894
895 // Per-thread RendererContext
896 private static final ThreadLocal<Object> rdrCtxThreadLocal;
897 // RendererContext queue when
898 // ThreadLocal is disabled or for child contexts (reentrance)
899 private static final ConcurrentLinkedQueue<Object> rdrCtxQueue
900 = new ConcurrentLinkedQueue<Object>();
901
902 // Static initializer to use TL or CLQ mode
903 static {
904 useThreadLocal = MarlinProperties.isUseThreadLocal();
905 rdrCtxThreadLocal = (useThreadLocal) ? new ThreadLocal<Object>()
906 : null;
907
908 // Soft reference by default:
909 String refType = AccessController.doPrivileged(
910 new GetPropertyAction("sun.java2d.renderer.useRef",
911 "soft"));
912 switch (refType) {
913 default:
914 case "soft":
915 REF_TYPE = REF_SOFT;
916 break;
917 case "weak":
918 REF_TYPE = REF_WEAK;
919 break;
920 case "hard":
921 REF_TYPE = REF_HARD;
922 break;
923 }
924 }
925
926 private static boolean settingsLogged = !enableLogs;
1008 + MarlinConst.logUnsafeMalloc);
1009
1010 // quality settings
1011 logInfo("Renderer settings:");
1012 logInfo("CUB_COUNT_LG = " + Renderer.CUB_COUNT_LG);
1013 logInfo("CUB_DEC_BND = " + Renderer.CUB_DEC_BND);
1014 logInfo("CUB_INC_BND = " + Renderer.CUB_INC_BND);
1015 logInfo("QUAD_DEC_BND = " + Renderer.QUAD_DEC_BND);
1016
1017 logInfo("=========================================================="
1018 + "=====================");
1019 }
1020
1021 /**
1022 * Get the RendererContext instance dedicated to the current thread
1023 * @return RendererContext instance
1024 */
1025 @SuppressWarnings({"unchecked"})
1026 static RendererContext getRendererContext() {
1027 RendererContext rdrCtx = null;
1028 if (useThreadLocal) {
1029 final Object ref = rdrCtxThreadLocal.get();
1030 if (ref != null) {
1031 rdrCtx = (REF_TYPE == REF_HARD) ? ((RendererContext) ref)
1032 : ((Reference<RendererContext>) ref).get();
1033 }
1034 if (rdrCtx == null) {
1035 // create a new RendererContext (TL) if none is available
1036 rdrCtx = RendererContext.createContext(false);
1037 // update thread local reference:
1038 rdrCtxThreadLocal.set(rdrCtx.reference);
1039 }
1040 // Check reentrance:
1041 if (rdrCtx.usedTL) {
1042 // get or create another RendererContext:
1043 rdrCtx = getOrCreateContextFromQueue();
1044 } else {
1045 // TL mode: set used flag:
1046 rdrCtx.usedTL = true;
1047 }
1048 } else {
1049 rdrCtx = getOrCreateContextFromQueue();
1050 }
1051 if (doMonitors) {
1052 RendererContext.stats.mon_pre_getAATileGenerator.start();
1053 }
1054 return rdrCtx;
1055 }
1056
1057 @SuppressWarnings({"unchecked"})
1058 private static RendererContext getOrCreateContextFromQueue() {
1059 RendererContext rdrCtx = null;
1060 final Object ref = rdrCtxQueue.poll();
1061 if (ref != null) {
1062 rdrCtx = (REF_TYPE == REF_HARD) ? ((RendererContext) ref)
1063 : ((Reference<RendererContext>) ref).get();
1064 }
1065 if (rdrCtx == null) {
1066 // create a new RendererContext (QUEUE) if none is available
1067 rdrCtx = RendererContext.createContext(true);
1068 }
1069 return rdrCtx;
1070 }
1071
1072 /**
1073 * Reset and return the given RendererContext instance for reuse
1074 * @param rdrCtx RendererContext instance
1075 */
1076 static void returnRendererContext(final RendererContext rdrCtx) {
1077 rdrCtx.dispose();
1078
1079 if (doMonitors) {
1080 RendererContext.stats.mon_pre_getAATileGenerator.stop();
1081 }
1082 if (!useThreadLocal || rdrCtx.storageQueue) {
1083 rdrCtxQueue.offer(rdrCtx.reference);
1084 } else {
1085 // TL mode: unset used flag:
1086 rdrCtx.usedTL = false;
1087 }
1088 }
1089 }
|