FWD » Core Development » User Interface

** Copyright (c) 2014-2022, Golden Code Development Corporation.

**     TJD 20220527 Support for text-metrics cache controlled by server

    * Retrieve the Most Frequently Used items out of cache.

    * Order of result is unimportant.

    * 

    * @param   maxEntries - maximum number of entries to return

    * @return  Most Frequently Used items out of cache

    */

   public Map<K, V> getMFUEntries(int maxEntries)

   {

      Map<K, V> result = new HashMap<K, V>();

      // reverse order to get MFU elements

      Iterator<Entry<K, V>> mfuElementsIterator = sorted.descendingIterator();

      while (mfuElementsIterator.hasNext())

      {

         if (--maxEntries < 0)

         {

            break;

         }

         Entry<K, V> entry = mfuElementsIterator.next();

         result.put(entry.getKey(), entry.getValue());

      }

      return result;

   }

   /**

**     TJD 20220527 Support for text-metrics cache controlled by server

      cmd.add("client:text-metrics:cache-size=" + options.get("clientTextMetricsCacheSize"));

** Copyright (c) 2014-2022, Golden Code Development Corporation.

**     TJD 20220527 Support for text-metrics cache controlled by server

import com.goldencode.p2j.ui.*;

      // Get client font metrics cache size from configuration

      int clientTextMetricsCacheSize = cbo.getNode(FontTable.FONT_METRICS_NODE_ID, "client-cache-size", 0);

      options.put("clientTextMetricsCacheSize", String.valueOf(clientTextMetricsCacheSize));

** 037 TJD 20220525 Support for text-metrics cache controlled by server

import java.util.concurrent.locks.*;

   /** The name of the node containing the font metrics management configuration */

   public static final String FONT_METRICS_NODE_ID = "font-metrics";

   /** Runtime cache for legacy text/font keys and legacy font width and height dimensions

    * Cache entries are metrics of legacy font stored as int[2]

    * Invalid entries are stored as int[0], so client dont need to query server for these

    */

   private static LFUAgingCache<String, int[]> sharedLegacyTextMetricsCache = new LFUAgingCache<>(100000);

   /** Size of a runtime cache for legacy text/font keys and legacy font width and height dimensions */

   private static int sharedLegacyTextMetricsCacheSize = 0;

   /** Lock for synchronizing parallel operations on sharedLegacyTextMetricsCache variables */

   private static Lock sharedLegacyTextMetricsLock = new ReentrantLock(); 

      String cacheKey = buildTextMetricsKey(key, text);

      int[] textMetrics = null;

      // map based operations are fast, so lock is only at beginning

      sharedLegacyTextMetricsLock.lock();

      try

      {

         textMetrics = sharedLegacyTextMetricsCache.get(cacheKey);

         if (textMetrics != null)

         {

            return textMetrics;

         }

         LegacyTextMetrics ltm = legacyTextMetrics.get(text);

         if (ltm == null)

         {

            if (LOG.isLoggable(Level.FINE))

            {

               LOG.fine("Text [" + text + "] has no legacy metrics with font [" + key + "].");

            }

            // Store invalid metrics value, so client knows it should not query server for this

            sharedLegacyTextMetricsCache.putIfAbsent(cacheKey, new int[0]);

            return null;

         }

         LegacyFontMetrics lfm = ltm.legacyMetrics.get(key);

         if (lfm == null)

         {

            if (LOG.isLoggable(Level.FINE))

            {

               LOG.fine("Text [" + text + "] has no legacy metrics with font [" + key + "].");

            }

            // Store invalid metrics value, so client knows it should not query server for this

            sharedLegacyTextMetricsCache.putIfAbsent(cacheKey, new int[0]);

            return null;

         }

         textMetrics = new int[] {lfm.width, lfm.height };

         sharedLegacyTextMetricsCache.putIfAbsent(cacheKey, textMetrics);

      }

      finally

      {

         sharedLegacyTextMetricsLock.unlock();

      }

      return textMetrics;

   }

   /**

    * buildTextMetricsKey - a helper method to unify TextMetrics keys creation

    * @param key - font key

    * @param text - text

    * @return textMetrics key

    */

   private static String buildTextMetricsKey(String key, String text)

   {

      return key + "#" + text;

      int currentServerCacheSize = Utils.getDirectoryNodeInt(null,

                                                             FONT_METRICS_NODE_ID +

                                                                "/" +

                                                                "server-cache-size",

                                                             -1,

                                                             false);

      Map<String, int[]> trimmedTextDimensions = sharedLegacyTextDimensions;

      // return full legacy metrics if server cache size is undefined or set to -1

      if (currentServerCacheSize == -1)

      {

         return sharedLegacyTextDimensions;

      }

      else

      {

         int clientCacheSize = Utils.getDirectoryNodeInt(null,

                                                         FONT_METRICS_NODE_ID +

                                                            "/" +

                                                            "client-cache-size",

                                                         100,

                                                         false);

         sharedLegacyTextMetricsLock.lock();

         try

         {

            // reinitialize cache only if cache size configuration has changed in runtime

            if (currentServerCacheSize != sharedLegacyTextMetricsCacheSize ||

                sharedLegacyTextMetricsCache == null)

            {

               sharedLegacyTextMetricsCache = new LFUAgingCache<>(currentServerCacheSize);

               sharedLegacyTextMetricsCacheSize = currentServerCacheSize;

            }

            // send to client the most frequently used elements

            trimmedTextDimensions = sharedLegacyTextMetricsCache.getMFUEntries(clientCacheSize);

         }

         finally

         {

            sharedLegacyTextMetricsLock.unlock();

         }

      }

      // send configured cache size to client

      return trimmedTextDimensions;

            String textKey = buildTextMetricsKey(fontKey, text);

**     TJD 20220527          Support for text-metrics cache controlled by server

      // read cache size from configuration

      // 0 means - use the same size server sends to client

      String textMetricsCacheSize = cfg.getString("client", "text-metrics", "cache-size", "0");

      int requestedTextMetricsCacheSize = 0;

      if (textMetricsCacheSize != null)

      {

         try

         {

            requestedTextMetricsCacheSize = Integer.valueOf(textMetricsCacheSize);

         }

         catch (NumberFormatException e)

         {

         }

      }

      FontManager.init(tc.server, requestedTextMetricsCacheSize);

** Copyright (c) 2011-2022, Golden Code Development Corporation.

** 037 TJD 20220525 Support for text-metrics cache controlled by server

import com.goldencode.cache.*;

   public static void init(ServerExports server, int textMetricsCacheSize)

      wa.initialize(server, textMetricsCacheSize);

      wa.textMetricsCache.put(tkey, metrics);

    * {@link WorkArea#textMetricsCache cache} or {@link WorkArea#textMetrics metrics}.

    * {@link WorkArea#textMetricsCache cache} or {@link WorkArea#textMetrics metrics}.

    * {@link WorkArea#textMetricsCache cache} or {@link WorkArea#textMetrics metrics}.

      String cacheKey = getTextKey(key, text);

      int[] metrics = null;

      synchronized (wa.textMetricsCache)

      {

         metrics = wa.textMetricsCache.get(cacheKey);

      }

      // metrics.length is 0 for server miss entries

      if (metrics != null && metrics.length > 0)

      // check legacy text metrics initialized from server, it never has metrics.length == 0

      if (wa.textMetrics != null)

      {

         metrics = wa.textMetrics.get(cacheKey);

      }

      // check server-side only if not in cache and not in text metrics from server

         metrics = wa.server.getLegacyTextMetrics(text, key);

      }

      if (metrics == null || metrics.length == 0)

      {

      // put result into cache

      synchronized (wa.textMetricsCache)

      {

         wa.textMetricsCache.put(cacheKey, metrics);

      }

      /** A full text metrics from server. Only used if client cache metrics is not configured*/

      private Map<String, int[]> textMetrics = null;

      /** A cache of text metrics.  0-index is the width, 1-index is the height.

       *  Default size will help in case server will not send anything at startup

       */

      private LRUCache<String, int[]> textMetricsCache = new LRUCache<String, int[]>(10000);

       * @param    configured TextMetrics cache size

      public void initialize(ServerExports server, int textMetricsCacheSize)

            // initialized if client cache size is not defined by configuration option client-cache-size

            if (textMetricsCacheSize == 0)

            {

               // if server sends a very small set of items set it to a minimal value

               if (legacyTextMetrics == null || legacyTextMetrics.size() < 10000)

               {

                  textMetricsCache = new LRUCache<String, int[]>(10000);

               }

               else

               {

                  // if client cache is not defined in config use size of data from server

                  textMetrics = legacyTextMetrics;

               }

            }

            else

            {

               // if client cache size is defined in config - use it

               textMetricsCache = new LRUCache<String, int[]>(textMetricsCacheSize);

            }

            // copy text metrics received from server into local cache

            // only if client cache size is defined

            if (legacyTextMetrics != null && textMetrics == null)

            {

               for (String key:legacyTextMetrics.keySet())

               {

                  textMetricsCache.put(key, legacyTextMetrics.get(key));

               }

            }