/xseg/xtypes/xcache.c - Diff - Archipelago - Greek Research and Technology Network's projects

Revision 246214a1 xseg/xtypes/xcache.c

     static void __update_access_time(struct xcache *cache, xqindex idx)
+    {
     	cache->times[idx] = __sync_add_and_fetch(&cache->time, 1);
     	XSEGLOG("cache->times[%llu] = %llu", idx, cache->times[idx]);
     //	cache->times[idx] = __sync_add_and_fetch(&cache->time, 1);
     	cache->times[idx] = cache->time++;
     	//XSEGLOG("cache->times[%llu] = %llu", idx, cache->times[idx]);
+    }
     /*
      * Proper precautions should be taken, when getting a cache entry.
      * There is a race with removal and finding lru cache entry.
      */
     static void xcache_entry_get(struct xcache *cache, xqindex idx)
+    {
     	struct xcache_entry *ce = &cache->nodes[idx];
     	ce->ref++;
     	__sync_add_and_fetch(&ce->ref, 1);
     	__update_access_time(cache, idx);
+    }
     /* put should be called with no locking */
     static void xcache_entry_put(struct xcache *cache, xqindex idx)
+    {
     	struct xcache_entry *ce = &cache->nodes[idx];
     	ce->ref--;
     	if (!ce->ref){
     	unsigned long ref = __sync_sub_and_fetch(&ce->ref, 1);
     	if (!ref){
     		if (cache->ops.on_put)
     			cache->ops.on_put(cache->priv, ce->priv);
     		free_cache_entry(cache, idx);
-...
     	uint64_t min = -2;
     	xqindex i, lru = Noneidx;
     	for (i = 0; i < cache->nr_nodes; i++) {
     		XSEGLOG("cache->times[%llu] = %llu", i, cache->times[i]);
     		//XSEGLOG("cache->times[%llu] = %llu", i, cache->times[i]);
     		if (min > cache->times[i]){
     			min = cache->times[i];
     			lru = i;
+    		}
+    	}
     	XSEGLOG("Found lru cache->times[%llu] = %llu", lru, cache->times[lru]);
     	//XSEGLOG("Found lru cache->times[%llu] = %llu", lru, cache->times[lru]);
     	return lru;
+    }
-...
     	return xqi;
+    }
     /* after a succesfull call, the handler must be put */
     static int __xcache_remove(struct xcache *cache, xcache_handler h)
+    {
     	int r;
-...
     	r = xhash_delete(cache->entries, (xhashidx)ce->name);
     	if (r < 0){
     		XSEGLOG("Couldn't delete cache entry(h: %llu, cache->nodes[h].priv: %p",
     				h, cache->nodes[idx].priv);
     		//XSEGLOG("Couldn't delete cache entry(h: %llu, cache->nodes[h].priv: %p",
     		//		h, cache->nodes[idx].priv);
     		return r;
+    	}
     	//put here, so the last one holding a ref to the entry will
     	//free the node
     	cache->times[idx] = -1;
     	XSEGLOG("cache->times[%llu] = %llu", idx, cache->times[idx]);
     	xcache_entry_put(cache, idx);
     	//XSEGLOG("cache->times[%llu] = %llu", idx, cache->times[idx]);
     	return 0;
+    }
     static int __xcache_insert(struct xcache *cache, xcache_handler h)
     /*
      * Inserts a new entry to cache or returns a diffrent entry with the same key
      * (name).
      * In either case, ref count on the returned entry, gets increased
+     *
      */
     static xcache_handler __xcache_insert(struct xcache *cache, xcache_handler h)
+    {
     	int r;
     	struct xcache_entry *ce;
     	xqindex lru, idx;
     	xqindex lru, idx, xqi;
     	idx = (xqindex)h;
     	ce = &cache->nodes[idx];
     	//TODO lookup first to ensure we don't overwrite entries
     	/* lookup first to ensure we don't overwrite entries */
     	if (xhash_lookup(cache->entries, (xhashidx)ce->name, &xqi) >= 0){
     		xcache_entry_get(cache, xqi);
     		return xqi;
+    	}
     	/* insert new entry to cache */
     retry:
     	r = xhash_insert(cache->entries, (xhashidx)ce->name, idx);
     	if (r == -XHASH_ENOSPC){
-...
     		//assert lru != Noneidx
     		//validate lru
     		if (__xcache_remove(cache, lru) < 0)
     			return -1;
     			return NoEntry;
     		xcache_entry_put(cache, lru);
     		goto retry;
+    	}
     	if (r == -XHASH_ERESIZE){
     		XSEGLOG("Rebuilding internal hash table");
     		xhash_t *new = xhash_resize(cache->entries,
     				cache->entries->size_shift,
     				cache->entries->limit, NULL);
     		if (!new)
     			return -1;
     			return NoEntry;
     		cache->entries = new;
     		goto retry;
+    	}
     	if (r >= 0){
     		//get cache entry here.
     		//will be put by xcache_remove
     		xcache_entry_get(cache, idx);
+    	}
     	return r;
     	return ((r < 0) ? NoEntry : h);
+    }
     xcache_handler xcache_lookup(struct xcache *cache, char *name)
-...
     	 * It must be able to contain at least xcache_size elements, before
     	 * returns an -EXHASH_RESIZE.
     	 * Thus it must be at least 3/2 * xcache_size (OK, the minimum power of
     	 * two that meats this requirement to be exact).
     	 * two that meets this requirement to be exact).
+    	 *
     	 * By choosing a xhash size 8 times the minimum required, we drastically
     	 * decrease the number or xhash rebuilts required by xhash for
-...
     	return 0;
+    }
     int xcache_insert(struct xcache *cache, xcache_handler h)
     xcache_handler xcache_insert(struct xcache *cache, xcache_handler h)
+    {
     	int r;
     	xcache_handler ret;
     	xlock_acquire(&cache->lock, 1);
     	r = __xcache_insert(cache, h);
     	ret = __xcache_insert(cache, h);
     	xlock_release(&cache->lock);
     	return r;
     	return ret;
+    }
     int xcache_remove(struct xcache *cache, xcache_handler h)
-...
     	xlock_acquire(&cache->lock, 1);
     	r = __xcache_remove(cache, h);
     	xlock_release(&cache->lock);
     	if (r >= 0)
     		xcache_entry_put(cache, h);
     	return r;
+    }
-...
     	if (xhash_lookup(cache->entries, (xhashidx)name, &xqi) >= 0){
     		//validate xqi
     		r =__xcache_remove(cache, xqi);
     		xlock_release(&cache->lock);
     		if (r >= 0)
     			xcache_entry_put(cache, xqi);
     	} else {
     		xlock_release(&cache->lock);
+    	}
     	xlock_release(&cache->lock);
     	return r;
+    }
     void xcache_put(struct xcache *cache, xcache_handler h)
+    {
     	xqindex idx = (xqindex)h;
     	xlock_acquire(&cache->lock, 1);
     	//xlock_acquire(&cache->lock, 1);
     	xcache_entry_put(cache, h);
     	xlock_release(&cache->lock);
     	//xlock_release(&cache->lock);
+    }
     /*
      * Put all cache entries.
      * Does not free cache resources.
      * xcache_free should be implemented for this purpose, to be called by the
      * client when all entries are put.
      */
     void xcache_close(struct xcache *cache)
+    {
     	return;
     	unsigned long i;
     	xlock_acquire(&cache->lock, 1);
     	for (i = 0; i < cache->nr_nodes; i++) {
     		if (cache->times[i] == -1)
     			continue;
     		xcache_entry_put(cache, (xqindex)i);
+    	}
     	xlock_release(&cache->lock);
+    }
     #ifdef __KERNEL__

Also available in: Unified diff