cache-node.c

/*
 * cache-node.c
 *
 * Used in diskomd.
 */

#include <stdio.h>
#include <kom-types.h>
#include "exp.h"
#include "cache-node.h"
#include <server/smalloc.h>
#include "lyskomd.h"

EXPORT const Cache_node EMPTY_CACHE_NODE =
    ((Cache_node){{ 0, 0, 0}, NULL, NULL, 0, 0, 0, 0, NULL, NULL, 0});

EXPORT const Cache_node_block EMPTY_CACHE_NODE_BLOCK =
    ((Cache_node_block){ 0, NULL, NULL});

EXPORT const Cache_node_mcb EMPTY_CACHE_NODE_MCB =
    ((Cache_node_mcb){ 0, NULL, 0, 0, NULL, NULL, 0, NULL });


EXPORT  void
unlink_lru(Cache_node *node,
	   Cache_node **lru,
	   Cache_node **mru)
{
    Cache_node *link;
    
    link = node->next;

    if ( node->next != NULL )
	node->next->prev = node->prev;
    else if (*lru == node)
	*lru = node->prev;

    if ( node->prev != NULL )
	node->prev->next = link;
    else if (*mru == node)
	*mru = link;

    node->next = NULL;
    node->prev = NULL;
}

EXPORT  void
insert_mru(Cache_node *node,
	   Cache_node **lru,
	   Cache_node **mru)
{
    node->prev = NULL;
    node->next = *mru;
    *mru = node;
    if ( *lru == NULL )
	*lru = node;

    if ( node->next != NULL )
	node->next->prev = node;
}

static Cache_node_mcb *
alloc_cache_node_mcb(void)
{
    Cache_node_mcb *t;

    t = smalloc(sizeof(Cache_node_mcb));
    *t = EMPTY_CACHE_NODE_MCB;
    return t;
}

static Cache_node_block *
alloc_cache_node_block(int table_size)
{
    Cache_node_block *t;

    t = smalloc(sizeof(Cache_node_block));
    *t = EMPTY_CACHE_NODE_BLOCK;
    t->nodes = smalloc (table_size * sizeof (Cache_node));
    t->next_free = 0;
    t->link = NULL;

    return t;
}


EXPORT Cache_node_mcb *
create_cache_node_mcb(int mcb_size, 
		      int table_size)
{
    Cache_node_mcb *tmp;

    tmp = alloc_cache_node_mcb();
    *tmp = EMPTY_CACHE_NODE_MCB;
    tmp->lookup_table = smalloc(sizeof(Cache_node *) * table_size);
    tmp->lookup_table_size = table_size;
    tmp->mcb_size = mcb_size;
    tmp->last_block = NULL;

    return tmp;
}

/* +++ No check is done that it is initialized. */
EXPORT Cache_node *
get_cache_node (Cache_node_mcb *control,
		u_long          key)
{
    if ( key >= control->lookup_table_size )
	return NULL;

    return control->lookup_table[ key ];
}

static Cache_node *
alloc_cache_node (Cache_node_mcb *control)
{
    Cache_node *c;

    if ( control->last_block == NULL
	|| control->last_block->next_free >= control->mcb_size )
    {
	Cache_node_block *new_block;

	new_block = alloc_cache_node_block (control->mcb_size);
	new_block->link = control->last_block;
	control->last_block = new_block;
    }

    c = &control->last_block->nodes[ control->last_block->next_free++ ];

    *c = EMPTY_CACHE_NODE;
    return c;
}

EXPORT void
destruct_cache_node(Cache_node_mcb  *control,
		    u_long           key)
{
    if ( key >= control->lookup_table_size )
	return;

    control->lookup_table[ key ] = NULL;
}

EXPORT  void
create_cache_node (Cache_node_mcb *control,
		   u_long          key)
{
    if ( key >= control->lookup_table_size )
	restart_kom("ERROR: set_cache_node(%lu, %lu, value): "
		    "lookup_table_size = %lu\n",
		    control->lookup_table_size);

    control->lookup_table[ key ] = alloc_cache_node(control);
}

EXPORT  void
zero_init_cache_node (Cache_node_mcb *control,
		      u_long          key)
{
    if ( key >= control->lookup_table_size )
	restart_kom("ERROR: set_cache_node(%lu, %lu, value): "
		    "lookup_table_size = %lu\n",
		    control->lookup_table_size);

    control->lookup_table[ key ] = NULL;
}



EXPORT void
set_mru(Cache_node_mcb *mcb,
	u_long         key)
{
    Cache_node *node;

    node = get_cache_node(mcb, key);

    if (node == NULL)
	restart_kom("set_mru(%d): nonexistent.\n", key);

    unlink_lru(node, &mcb->lru, &mcb->mru);
    insert_mru(node, &mcb->lru, &mcb->mru);
}
static void
free_cache_node_block (Cache_node_block *block)
{
    sfree(block->nodes);
    sfree(block);
}

extern void
free_cache_node_mcb(Cache_node_mcb *control)
{
    Cache_node_block *block;

    while ( control->last_block != NULL )
    {
	block = control->last_block;
	control->last_block = block->link;
	free_cache_node_block (block);
    }

    sfree(control->lookup_table);
    sfree(control);
}