X-Git-Url: https://git.street.me.uk/andy/viking.git/blobdiff_plain/50a14534a51f892500ee82f867e8ab2f85b936ae..9e90c3a511d4ea403d07522fb41d9f44328ecaa0:/src/mapcache.c diff --git a/src/mapcache.c b/src/mapcache.c index 5ae0fc89..55b6f1b7 100644 --- a/src/mapcache.c +++ b/src/mapcache.c @@ -18,12 +18,19 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif -#include +#include +#include #include +#include "globals.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; @@ -35,18 +42,75 @@ typedef struct _List { 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; -#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 () { - 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. */ @@ -64,6 +128,7 @@ static gchar *list_shift () List *oldhead = queue_tail->next; queue_tail->next = queue_tail->next->next; g_free ( oldhead ); + queue_count--; return oldheadkey; } @@ -80,86 +145,153 @@ static void list_add_entry ( gchar *key ) 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 ) { - 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 */ } + 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; - 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; - 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; - else + else { loop->next = tmp->next; + if ( tmp == queue_tail ) + queue_tail = tmp->next; + } g_free ( tmp ); tmp = NULL; + queue_count--; } else loop = tmp; - + } else + loop = NULL; } while ( loop && (loop != queue_tail || tmp == NULL) ); - /* 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 () @@ -167,6 +299,17 @@ void a_mapcache_uninit () 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 ); +}