src/mapcache.c

   1 /*
   2  * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
   3  *
   4  * Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include <glib.h>
  26 #include <glib/gi18n.h>
  27 #include <string.h>
  28 #include "globals.h"
  29 #include "mapcache.h"
  30 #include "preferences.h"
  31 #include "vik_compat.h"
  32
  33 #define MC_KEY_SIZE 64
  34
  35 typedef struct _List {
  36   struct _List *next;
  37   gchar *key;
  38 } List;
  39
  40 /* a circular linked list, a pointer to the tail, and the tail points to the head */
  41 /* this is so we can free the last */
  42 static List *queue_tail = NULL;
  43 static int queue_count = 0;
  44
  45 static guint32 cache_size = 0;
  46 static guint32 max_cache_size = VIK_CONFIG_MAPCACHE_SIZE * 1024 * 1024;
  47
  48 static GHashTable *cache = NULL;
  49
  50 typedef struct {
  51   GdkPixbuf *pixbuf;
  52   mapcache_extra_t extra;
  53 } cache_item_t;
  54
  55 static GMutex *mc_mutex = NULL;
  56
  57 #define HASHKEY_FORMAT_STRING "%d-%d-%d-%d-%d-%d-%d-%.3f-%.3f"
  58 #define HASHKEY_FORMAT_STRING_NOSHRINK_NOR_ALPHA "%d-%d-%d-%d-%d-%d-"
  59 #define HASHKEY_FORMAT_STRING_TYPE "%d-"
  60
  61 static VikLayerParamScale params_scales[] = {
  62   /* min, max, step, digits (decimal places) */
  63  { 1, 1024, 1, 0 },
  64 };
  65
  66 static VikLayerParam prefs[] = {
  67   { VIK_LAYER_NUM_TYPES, VIKING_PREFERENCES_NAMESPACE "mapcache_size", VIK_LAYER_PARAM_UINT, VIK_LAYER_GROUP_NONE, N_("Map cache memory size (MB):"), VIK_LAYER_WIDGET_HSCALE, params_scales, NULL, NULL, NULL, NULL, NULL },
  68 };
  69
  70 static void cache_item_free (cache_item_t *ci)
  71 {
  72   g_object_unref ( ci->pixbuf );
  73   g_free ( ci );
  74 }
  75
  76 void a_mapcache_init ()
  77 {
  78   VikLayerParamData tmp;
  79   tmp.u = VIK_CONFIG_MAPCACHE_SIZE;
  80   a_preferences_register(prefs, tmp, VIKING_PREFERENCES_GROUP_KEY);
  81
  82   mc_mutex = vik_mutex_new ();
  83   cache = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, (GDestroyNotify) cache_item_free );
  84 }
  85
  86 static void cache_add(gchar *key, GdkPixbuf *pixbuf, mapcache_extra_t extra)
  87 {
  88   cache_item_t *ci = g_malloc ( sizeof(cache_item_t) );
  89   ci->pixbuf = pixbuf;
  90   ci->extra = extra;
  91 #if !GLIB_CHECK_VERSION(2,26,0)
  92   // Only later versions of GLib actually return a value for this function
  93   // Annoyingly the documentation doesn't say anything about this interface change :(
  94   if ( g_hash_table_insert ( cache, key, ci ) )
  95 #else
  96   g_hash_table_insert ( cache, key, ci );
  97 #endif
  98   {
  99     cache_size += gdk_pixbuf_get_rowstride(pixbuf) * gdk_pixbuf_get_height(pixbuf);
 100     // ATM size of 'extra' data hardly worth trying to count (compared to pixbuf sizes)
 101     // Not sure what this 100 represents anyway - probably a guess at an average pixbuf metadata size
 102     cache_size += 100;
 103   }
 104 }
 105
 106 static void cache_remove(const gchar *key)
 107 {
 108   cache_item_t *ci = g_hash_table_lookup ( cache, key );
 109   if (ci && ci->pixbuf) {
 110     cache_size -= gdk_pixbuf_get_rowstride(ci->pixbuf) * gdk_pixbuf_get_height(ci->pixbuf);
 111     cache_size -= 100;
 112     g_hash_table_remove ( cache, key );
 113   }
 114 }
 115
 116 /* returns key from head, adds on newtailkey to tail. */
 117 static gchar *list_shift_add_entry ( gchar *newtailkey )
 118 {
 119   gchar *oldheadkey = queue_tail->next->key;
 120   queue_tail->next->key = newtailkey;
 121   queue_tail = queue_tail->next;
 122   return oldheadkey;
 123 }
 124
 125 static gchar *list_shift ()
 126 {
 127   gchar *oldheadkey = queue_tail->next->key;
 128   List *oldhead = queue_tail->next;
 129   queue_tail->next = queue_tail->next->next;
 130   g_free ( oldhead );
 131   queue_count--;
 132   return oldheadkey;
 133 }
 134
 135 /* adds key to tail */
 136 static void list_add_entry ( gchar *key )
 137 {
 138   List *newlist = g_malloc ( sizeof ( List ) );
 139   newlist->key = key;
 140   if ( queue_tail ) {
 141     newlist->next = queue_tail->next;
 142     queue_tail->next = newlist;
 143     queue_tail = newlist;
 144   } else {
 145     newlist->next = newlist;
 146     queue_tail = newlist;
 147   }
 148   queue_count++;
 149 }
 150
 151 /**
 152  * Function increments reference counter of pixbuf.
 153  * Caller may (and should) decrease it's reference.
 154  */
 155 void a_mapcache_add ( GdkPixbuf *pixbuf, mapcache_extra_t extra, gint x, gint y, gint z, guint16 type, gint zoom, guint8 alpha, gdouble xshrinkfactor, gdouble yshrinkfactor, const gchar* name )
 156 {
 157   if ( ! GDK_IS_PIXBUF(pixbuf) ) {
 158     g_debug ( "Not caching corrupt pixbuf for maptype %d at %d %d %d %d", type, x, y, z, zoom );
 159     return;
 160   }
 161
 162   guint nn = name ? g_str_hash ( name ) : 0;
 163   gchar *key = g_strdup_printf ( HASHKEY_FORMAT_STRING, type, x, y, z, zoom, nn, alpha, xshrinkfactor, yshrinkfactor );
 164
 165   g_mutex_lock(mc_mutex);
 166   g_object_ref(pixbuf);
 167   cache_add(key, pixbuf, extra);
 168
 169   // TODO: that should be done on preference change only...
 170   max_cache_size = a_preferences_get(VIKING_PREFERENCES_NAMESPACE "mapcache_size")->u * 1024 * 1024;
 171
 172   if ( cache_size > max_cache_size ) {
 173     if ( queue_tail ) {
 174       gchar *oldkey = list_shift_add_entry ( key );
 175       cache_remove(oldkey);
 176
 177       while ( cache_size > max_cache_size &&
 178              (queue_tail->next != queue_tail) ) { /* make sure there's more than one thing to delete */
 179         oldkey = list_shift ();
 180         cache_remove(oldkey);
 181       }
 182     }
 183     /* chop off 'start' etc */
 184   } else {
 185     list_add_entry ( key );
 186     /* business as usual */
 187   }
 188   g_mutex_unlock(mc_mutex);
 189
 190   static int tmp = 0;
 191   if ( (++tmp == 100 )) { g_debug("DEBUG: cache count=%d size=%u list count=%d\n", g_hash_table_size(cache), cache_size, queue_count ); tmp=0; }
 192 }
 193
 194 /**
 195  * Function increases reference counter of pixels buffer in behalf of caller.
 196  * Caller have to decrease references counter, when buffer is no longer needed.
 197  */
 198 GdkPixbuf *a_mapcache_get ( gint x, gint y, gint z, guint16 type, gint zoom, guint8 alpha, gdouble xshrinkfactor, gdouble yshrinkfactor, const gchar* name )
 199 {
 200   static char key[MC_KEY_SIZE];
 201   guint nn = name ? g_str_hash ( name ) : 0;
 202   g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING, type, x, y, z, zoom, nn, alpha, xshrinkfactor, yshrinkfactor );
 203   g_mutex_lock(mc_mutex); /* prevent returning pixbuf when cache is being cleared */
 204   cache_item_t *ci = g_hash_table_lookup ( cache, key );
 205   if ( ci ) {
 206     g_object_ref(ci->pixbuf);
 207     g_mutex_unlock(mc_mutex);
 208     return ci->pixbuf;
 209   } else {
 210     g_mutex_unlock(mc_mutex);
 211     return NULL;
 212   }
 213 }
 214
 215 mapcache_extra_t a_mapcache_get_extra ( gint x, gint y, gint z, guint16 type, gint zoom, guint8 alpha, gdouble xshrinkfactor, gdouble yshrinkfactor, const gchar* name )
 216 {
 217   static char key[MC_KEY_SIZE];
 218   guint nn = name ? g_str_hash ( name ) : 0;
 219   g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING, type, x, y, z, zoom, nn, alpha, xshrinkfactor, yshrinkfactor );
 220   cache_item_t *ci = g_hash_table_lookup ( cache, key );
 221   if ( ci )
 222     return ci->extra;
 223   else
 224     return (mapcache_extra_t) { 0.0 };
 225 }
 226
 227 /**
 228  * Common function to remove cache items for keys starting with the specified string
 229  */
 230 static void flush_matching ( gchar *str )
 231 {
 232   g_mutex_lock(mc_mutex);
 233
 234   if ( queue_tail == NULL ) {
 235     g_mutex_unlock(mc_mutex);
 236     return;
 237   }
 238
 239   // The 'loop' variable must be assigned within the mutex lock section,
 240   //  otherwise where it points to might not be valid anymore when the actual processing occurs
 241   List *loop = queue_tail;
 242   List *tmp;
 243   gint len = strlen(str);
 244
 245   do {
 246     tmp = loop->next;
 247     if ( tmp ) {
 248     if ( strncmp(tmp->key, str, len) == 0 )
 249     {
 250       cache_remove(tmp->key);
 251       if ( tmp == loop ) /* we deleted the last thing in the queue! */
 252         loop = queue_tail = NULL;
 253       else {
 254         loop->next = tmp->next;
 255         if ( tmp == queue_tail )
 256           queue_tail = tmp->next;
 257       }
 258       g_free ( tmp );
 259       tmp = NULL;
 260       queue_count--;
 261     }
 262     else
 263       loop = tmp;
 264     } else
 265       loop = NULL;
 266   } while ( loop && (loop != queue_tail || tmp == NULL) );
 267   /* loop thru list, looking for the one, compare first whatever chars */
 268
 269   cache_remove(str);
 270   g_mutex_unlock(mc_mutex);
 271 }
 272
 273 /**
 274  * Appears this is only used when redownloading tiles (i.e. to invalidate old images)
 275  */
 276 void a_mapcache_remove_all_shrinkfactors ( gint x, gint y, gint z, guint16 type, gint zoom, const gchar* name )
 277 {
 278   char key[MC_KEY_SIZE];
 279   guint nn = name ? g_str_hash ( name ) : 0;
 280   g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING_NOSHRINK_NOR_ALPHA, type, x, y, z, zoom, nn );
 281   flush_matching ( key );
 282 }
 283
 284 void a_mapcache_flush ()
 285 {
 286   // Everything happens within the mutex lock section
 287   g_mutex_lock(mc_mutex);
 288
 289   List *loop = queue_tail;
 290   List *tmp;
 291
 292   while ( loop ) {
 293     tmp = loop->next;
 294     cache_remove(tmp->key);
 295     if ( tmp == queue_tail ) /* we deleted the last thing in the queue */
 296       loop = queue_tail = NULL;
 297     else
 298       loop->next = tmp->next;
 299     g_free ( tmp );
 300     tmp = NULL;
 301   }
 302
 303   g_mutex_unlock(mc_mutex);
 304 }
 305
 306 /**
 307  * a_mapcache_flush_type:
 308  *  @type: Specified map type
 309  *
 310  * Just remove cache items for the specified map type
 311  *  i.e. all related xyz+zoom+alpha+etc...
 312  */
 313 void a_mapcache_flush_type ( guint16 type )
 314 {
 315   char key[MC_KEY_SIZE];
 316   g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING_TYPE, type );
 317   flush_matching ( key );
 318 }
 319
 320 void a_mapcache_uninit ()
 321 {
 322   g_hash_table_destroy ( cache );
 323   /* free list */
 324   cache = NULL;
 325   vik_mutex_free (mc_mutex);
 326 }
 327
 328 // Size of mapcache in memory
 329 gint a_mapcache_get_size ()
 330 {
 331   return cache_size;
 332 }
 333
 334 // Count of items in the mapcache
 335 gint a_mapcache_get_count ()
 336 {
 337   return g_hash_table_size ( cache );
 338 }