[QA] Use labs() instead of abs() in comparison of timestamps to avoid truncation...

[andy/viking.git] / src / mapcache.c

diff --git a/src/mapcache.c b/src/mapcache.c
index 02074e3e56095332aff351473aeb1390f1e7a54f..55b6f1b72f07b816cf76a10f6e05d19f26a48245 100644 (file)
--- a/src/mapcache.c
+++ b/src/mapcache.c
@@ -18,12 +18,19 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  */
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  */

+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif

 
 

-#include <gtk/gtk.h>
+#include <glib.h>
+#include <glib/gi18n.h>

 #include <string.h>
 #include <string.h>

+#include "globals.h"

 #include "mapcache.h"
 #include "mapcache.h"

+#include "preferences.h"
+#include "vik_compat.h"

 
 

-#include "config.h"
+#define MC_KEY_SIZE 64

 
 typedef struct _List {
   struct _List *next;
 
 typedef struct _List {
   struct _List *next;


@@ -35,18 +42,75 @@ typedef struct _List {
 static List *queue_tail = NULL;
 static int queue_count = 0;
 
 static List *queue_tail = NULL;
 static int queue_count = 0;
 

-#define VIK_CONFIG_MAPCACHE_MAX_SIZE 50331648 /* 48 meggerbytes */
-static guint32 queue_size = 0;
-
+static guint32 cache_size = 0;
+static guint32 max_cache_size = VIK_CONFIG_MAPCACHE_SIZE * 1024 * 1024;

 
 static GHashTable *cache = NULL;
 
 
 static GHashTable *cache = NULL;
 

-#define HASHKEY_FORMAT_STRING "%d-%d-%d-%d-%d-%d-%.3f-%.3f"
-#define HASHKEY_FORMAT_STRING_NOSHRINK "%d-%d-%d-%d-%d-%d-"
+typedef struct {
+  GdkPixbuf *pixbuf;
+  mapcache_extra_t extra;
+} cache_item_t;
+
+static GMutex *mc_mutex = NULL;
+
+#define HASHKEY_FORMAT_STRING "%d-%d-%d-%d-%d-%d-%d-%.3f-%.3f"
+#define HASHKEY_FORMAT_STRING_NOSHRINK_NOR_ALPHA "%d-%d-%d-%d-%d-%d-"
+#define HASHKEY_FORMAT_STRING_TYPE "%d-"
+
+static VikLayerParamScale params_scales[] = {
+  /* min, max, step, digits (decimal places) */
+ { 1, 1024, 1, 0 },
+};
+
+static VikLayerParam prefs[] = {
+  { 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 },
+};
+
+static void cache_item_free (cache_item_t *ci)
+{
+  g_object_unref ( ci->pixbuf );
+  g_free ( ci );
+}

 
 void a_mapcache_init ()
 {
 
 void a_mapcache_init ()
 {

-  cache = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, g_object_unref );
+  VikLayerParamData tmp;
+  tmp.u = VIK_CONFIG_MAPCACHE_SIZE;
+  a_preferences_register(prefs, tmp, VIKING_PREFERENCES_GROUP_KEY);
+
+  mc_mutex = vik_mutex_new ();
+  cache = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, (GDestroyNotify) cache_item_free );
+}
+
+static void cache_add(gchar *key, GdkPixbuf *pixbuf, mapcache_extra_t extra)
+{
+  cache_item_t *ci = g_malloc ( sizeof(cache_item_t) );
+  ci->pixbuf = pixbuf;
+  ci->extra = extra;
+#if !GLIB_CHECK_VERSION(2,26,0)
+  // Only later versions of GLib actually return a value for this function
+  // Annoyingly the documentation doesn't say anything about this interface change :(
+  if ( g_hash_table_insert ( cache, key, ci ) )
+#else
+  g_hash_table_insert ( cache, key, ci );
+#endif
+  {
+    cache_size += gdk_pixbuf_get_rowstride(pixbuf) * gdk_pixbuf_get_height(pixbuf);
+    // ATM size of 'extra' data hardly worth trying to count (compared to pixbuf sizes)
+    // Not sure what this 100 represents anyway - probably a guess at an average pixbuf metadata size
+    cache_size += 100;
+  }
+}
+
+static void cache_remove(const gchar *key)
+{
+  cache_item_t *ci = g_hash_table_lookup ( cache, key );
+  if (ci && ci->pixbuf) {
+    cache_size -= gdk_pixbuf_get_rowstride(ci->pixbuf) * gdk_pixbuf_get_height(ci->pixbuf);
+    cache_size -= 100;
+    g_hash_table_remove ( cache, key );
+  }

 }
 
 /* returns key from head, adds on newtailkey to tail. */
 }
 
 /* returns key from head, adds on newtailkey to tail. */


@@ -64,6 +128,7 @@ static gchar *list_shift ()
   List *oldhead = queue_tail->next;
   queue_tail->next = queue_tail->next->next;
   g_free ( oldhead );
   List *oldhead = queue_tail->next;
   queue_tail->next = queue_tail->next->next;
   g_free ( oldhead );

+  queue_count--;

   return oldheadkey;
 }
 
   return oldheadkey;
 }
 


@@ -80,88 +145,153 @@ static void list_add_entry ( gchar *key )
     newlist->next = newlist;
     queue_tail = newlist;
   }
     newlist->next = newlist;
     queue_tail = newlist;
   }

+  queue_count++;

 }
 
 }
 

-void a_mapcache_add ( GdkPixbuf *pixbuf, gint x, gint y, gint z, guint8 type, guint zoom, guint8 alpha, gdouble xshrinkfactor, gdouble yshrinkfactor )
+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 )

 {
 {

-  gchar *key = g_strdup_printf ( HASHKEY_FORMAT_STRING, x, y, z, type, zoom, alpha, xshrinkfactor, yshrinkfactor );
-  static int tmp = 0;
+  guint nn = name ? g_str_hash ( name ) : 0;
+  gchar *key = g_strdup_printf ( HASHKEY_FORMAT_STRING, type, x, y, z, zoom, nn, alpha, xshrinkfactor, yshrinkfactor );

 
 

-  /* FIXME: what if already exists? problem! */
-  g_hash_table_insert ( cache, key, pixbuf );
+  g_mutex_lock(mc_mutex);
+  cache_add(key, pixbuf, extra);

 
 

-  queue_size += gdk_pixbuf_get_rowstride(pixbuf) * gdk_pixbuf_get_height(pixbuf);
-  queue_size += 100;
-  queue_count++;
+  // TODO: that should be done on preference change only...
+  max_cache_size = a_preferences_get(VIKING_PREFERENCES_NAMESPACE "mapcache_size")->u * 1024 * 1024;

 
 

-  if ( queue_size > VIK_CONFIG_MAPCACHE_SIZE ) {
-    gchar *oldkey = list_shift_add_entry ( key );
-    GdkPixbuf *oldbuf = g_hash_table_lookup ( cache, oldkey );
-    queue_size -= gdk_pixbuf_get_rowstride(oldbuf) * gdk_pixbuf_get_height(oldbuf);
-    queue_size -= 100;
-    queue_count --;
-    g_hash_table_remove ( cache, oldkey );
-
-    while ( queue_size > VIK_CONFIG_MAPCACHE_SIZE &&
-        (queue_tail->next != queue_tail) ) { /* make sure there's more than one thing to delete */
-      oldkey = list_shift ();
-      oldbuf = g_hash_table_lookup ( cache, oldkey );
-      queue_size -= gdk_pixbuf_get_rowstride(oldbuf) * gdk_pixbuf_get_height(oldbuf);
-      queue_size -= 100;
-      queue_count --;
-      g_hash_table_remove ( cache, oldkey );
-    }
+  if ( cache_size > max_cache_size ) {
+    if ( queue_tail ) {
+      gchar *oldkey = list_shift_add_entry ( key );
+      cache_remove(oldkey);

 
 

+      while ( cache_size > max_cache_size &&
+             (queue_tail->next != queue_tail) ) { /* make sure there's more than one thing to delete */
+        oldkey = list_shift ();
+        cache_remove(oldkey);
+      }
+    }

     /* chop off 'start' etc */
   } else {
     list_add_entry ( key );
     /* business as usual */
   }
     /* chop off 'start' etc */
   } else {
     list_add_entry ( key );
     /* business as usual */
   }

+  g_mutex_unlock(mc_mutex);

 
 

-  if ( (++tmp == 100 ))  { g_print("DEBUG: queue count=%d %ld\n", queue_count, queue_size ); tmp=0; }
+  static int tmp = 0;
+  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; }

 }
 
 }
 

-GdkPixbuf *a_mapcache_get ( gint x, gint y, gint z, guint8 type, guint zoom, guint8 alpha, gdouble xshrinkfactor, gdouble yshrinkfactor )
+GdkPixbuf *a_mapcache_get ( gint x, gint y, gint z, guint16 type, gint zoom, guint8 alpha, gdouble xshrinkfactor, gdouble yshrinkfactor, const gchar* name )

 {
 {

-  static char key[48];
-  g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING, x, y, z, type, zoom, alpha, xshrinkfactor, yshrinkfactor );
-  return g_hash_table_lookup ( cache, key );
+  static char key[MC_KEY_SIZE];
+  guint nn = name ? g_str_hash ( name ) : 0;
+  g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING, type, x, y, z, zoom, nn, alpha, xshrinkfactor, yshrinkfactor );
+  cache_item_t *ci = g_hash_table_lookup ( cache, key );
+  if ( ci )
+    return ci->pixbuf;
+  else
+    return NULL;

 }
 
 }
 

-void a_mapcache_remove_all_shrinkfactors ( guint16 x, guint16 y, guint16 z, guint8 type, guint zoom, guint8 alpha )
+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 )

 {
 {

-  char key[40];
-  List *loop = queue_tail;
-  List *tmp;
-  gint len;
+  static char key[MC_KEY_SIZE];
+  guint nn = name ? g_str_hash ( name ) : 0;
+  g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING, type, x, y, z, zoom, nn, alpha, xshrinkfactor, yshrinkfactor );
+  cache_item_t *ci = g_hash_table_lookup ( cache, key );
+  if ( ci )
+    return ci->extra;
+  else
+    return (mapcache_extra_t) { 0.0 };
+}

 
 

+/**
+ * Common function to remove cache items for keys starting with the specified string
+ */
+static void flush_matching ( gchar *str )
+{

   if ( queue_tail == NULL )
     return;
 
   if ( queue_tail == NULL )
     return;
 

-  g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING_NOSHRINK, x, y, z, type, zoom, alpha );
-  len = strlen(key);
+  List *loop = queue_tail;
+  List *tmp;
+  gint len = strlen(str);

 
 

-  /* TODO: check logic here */
+  g_mutex_lock(mc_mutex);

   do {
     tmp = loop->next;
   do {
     tmp = loop->next;

-    if ( strncmp(tmp->key, key, len) == 0 )
+    if ( tmp ) {
+    if ( strncmp(tmp->key, str, len) == 0 )

     {
     {

-      g_hash_table_remove ( cache, tmp->key );
-      if ( tmp == loop )
+      cache_remove(tmp->key);
+      if ( tmp == loop ) /* we deleted the last thing in the queue! */

         loop = queue_tail = NULL;
         loop = queue_tail = NULL;

-      else
+      else {

         loop->next = tmp->next;
         loop->next = tmp->next;

+        if ( tmp == queue_tail )
+          queue_tail = tmp->next;
+      }

       g_free ( tmp );
       tmp = NULL;
       g_free ( tmp );
       tmp = NULL;

+      queue_count--;

     }
     else
       loop = tmp;
     }
     else
       loop = tmp;

-
+    } else
+      loop = NULL;

   } while ( loop && (loop != queue_tail || tmp == NULL) );
   } while ( loop && (loop != queue_tail || tmp == NULL) );

-

   /* loop thru list, looking for the one, compare first whatever chars */
 
   /* loop thru list, looking for the one, compare first whatever chars */
 

-  g_hash_table_remove ( cache, key );
+  cache_remove(str);
+  g_mutex_unlock(mc_mutex);
+}
+
+/**
+ * Appears this is only used when redownloading tiles (i.e. to invalidate old images)
+ */
+void a_mapcache_remove_all_shrinkfactors ( gint x, gint y, gint z, guint16 type, gint zoom, const gchar* name )
+{
+  char key[MC_KEY_SIZE];
+  guint nn = name ? g_str_hash ( name ) : 0;
+  g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING_NOSHRINK_NOR_ALPHA, type, x, y, z, zoom, nn );
+  flush_matching ( key );
+}
+
+void a_mapcache_flush ()
+{
+  List *loop = queue_tail;
+  List *tmp;
+
+  if ( queue_tail == NULL )
+    return;
+
+  g_mutex_lock(mc_mutex);
+  do {
+    tmp = loop->next;
+    cache_remove(tmp->key);
+    if ( tmp == queue_tail ) /* we deleted the last thing in the queue */
+      loop = queue_tail = NULL;
+    else
+      loop->next = tmp->next;
+    g_free ( tmp );
+    tmp = NULL;
+  } while ( loop );
+
+  g_mutex_unlock(mc_mutex);
+}
+
+/**
+ * a_mapcache_flush_type:
+ *  @type: Specified map type
+ *
+ * Just remove cache items for the specified map type
+ *  i.e. all related xyz+zoom+alpha+etc...
+ */
+void a_mapcache_flush_type ( guint16 type )
+{
+  char key[MC_KEY_SIZE];
+  g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING_TYPE, type );
+  flush_matching ( key );

 }
 
 void a_mapcache_uninit ()
 }
 
 void a_mapcache_uninit ()


@@ -169,6 +299,17 @@ void a_mapcache_uninit ()
   g_hash_table_destroy ( cache );
   /* free list */
   cache = NULL;
   g_hash_table_destroy ( cache );
   /* free list */
   cache = NULL;

+  vik_mutex_free (mc_mutex);

 }
 
 }
 

+// Size of mapcache in memory
+gint a_mapcache_get_size ()
+{
+  return cache_size;
+}

 
 

+// Count of items in the mapcache
+gint a_mapcache_get_count ()
+{
+  return g_hash_table_size ( cache );
+}