Archipelago

#ifndef __XCACHE_H

#define __XCACHE_H

#include <xtypes/domain.h>

#include <xtypes/xlock.h>

#include <xtypes/xq.h>

#include <xtypes/xhash.h>

#include <xseg/xseg.h>

#include <xseg/protocol.h>

#include <sys/util.h>

/*

 * on_init:          called on cache entry initialization.

 *                  Should return negative on error to abort cache entry initialization.

 * on_put:         called when the last reference to the cache entry is put

 *

 * on_node_init: called on initial node preparation.

 *                  Must return NULL on error, to abort cache initialization.

 */

struct xcache_ops {

        int (*on_init)(void *cache_data, void *user_data);

        void (*on_put)(void *cache_data, void *user_data);

        void *(*on_node_init)(void *cache_data);

};

struct xcache_entry {

        struct xlock lock;

        uint32_t ref;

        char name[XSEG_MAX_TARGETLEN + 1];

        void *priv;

};

struct xcache {

        struct xlock lock;

        uint32_t size;

        uint32_t nr_nodes;

        struct xq free_nodes;

        xhash_t *entries;

        struct xcache_entry *nodes;

        uint64_t time;

        uint64_t *times;

        struct xcache_ops ops;

        void *priv;

};

typedef xqindex xcache_handler;

#define NoEntry (xcache_handler)Noneidx

static int __validate_idx(struct xcache *cache, xqindex idx)

{

        return (idx < cache->nr_nodes);

}

static void * get_cache_entry(struct xcache *cache, xcache_handler h)

{

        xqindex idx = (xqindex)h;

        //validate idx

        if (!__validate_idx(cache, idx))

                return NULL;

        return cache->nodes[idx].priv;

}

int xcache_init(struct xcache *cache, uint32_t xcache_size,

                struct xcache_ops *ops, void *priv);

void xcache_close(struct xcache *cache);

xcache_handler xcache_lookup(struct xcache *cache, char *name);

xcache_handler xcache_alloc_init(struct xcache *cache, char *name);

int xcache_insert(struct xcache *cache, xcache_handler h);

int xcache_remove(struct xcache *cache, xcache_handler h);

int xcache_invalidate(struct xcache *cache, char *name);

void xcache_put(struct xcache *cache, xcache_handler h);

#endif /* __XCACHE_H */