< prev index next >

src/java.desktop/share/classes/sun/java2d/marlin/MarlinRenderingEngine.java

Print this page


   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 }
< prev index next >