implement a fixed size cache in mod_mem_cache using a priority queue (91dc469c) · Commits · CYBER - Cyber Security / TS 103 523 MSP / TLMSP / TLMSP Apache Httpd

CHANGES

+3 −0

Original line number	Diff line number	Diff line
		Changes with Apache 2.0.37

		*) Implement a fixed size memory cache using a priority queue
		[Ian Holsman]

		*) Fix apxs to allow "apxs -q installbuilddir" and to allow
		querying certain other variables from config_vars.mk. PR 9316
		[Jeff Trawick]

modules/experimental/cache_cache.c

0 → 100644

+155 −0

Original line number	Diff line number	Diff line
		/* cache.c */
		#include "apr_general.h"

		#include "mod_cache.h"
		#include "cache_hash.h"
		#include "cache_pqueue.h"
		#include "cache_cache.h"

		#if APR_HAVE_STDLIB_H
		#include <stdlib.h>
		#endif
		#if APR_HAVE_STRING_H
		#include <string.h>
		#endif

		struct cache_cache_t {
		int max_entries;
		apr_size_t max_size;
		apr_size_t current_size;
		int total_purges;
		long queue_clock;
		cache_hash_t *ht;
		cache_pqueue_t *pq;
		cache_pqueue_set_priority* set_pri;
		cache_pqueue_get_priority* get_pri;
		cache_cache_inc_frequency *inc_entry;
		cache_cache_get_size *size_entry;
		cache_cache_get_key *key_entry;
		cache_cache_free *free_entry;
		};

		CACHE_DECLARE(cache_cache_t *)cache_init(int max_entries,
		apr_size_t max_size,
		cache_pqueue_get_priority *get_pri,
		cache_pqueue_set_priority *set_pri,
		cache_pqueue_getpos get_pos,
		cache_pqueue_setpos set_pos,
		cache_cache_inc_frequency *inc_entry,
		cache_cache_get_size *size_entry,
		cache_cache_get_key* key_entry,
		cache_cache_free *free_entry)
		{
		cache_cache_t *tmp;
		tmp = malloc(sizeof(cache_cache_t));
		tmp->max_entries = max_entries;
		tmp->max_size = max_size;
		tmp->current_size = 0;
		tmp->total_purges = 0;
		tmp->queue_clock = 0;
		tmp->get_pri = get_pri;
		tmp->set_pri = set_pri;
		tmp->inc_entry = inc_entry;
		tmp->size_entry = size_entry;
		tmp->key_entry = key_entry;
		tmp->free_entry = free_entry;

		tmp->ht = cache_hash_make(max_entries);
		tmp->pq = cache_pq_init(max_entries, get_pri, get_pos, set_pos);

		return tmp;
		}

		CACHE_DECLARE(void) cache_free(cache_cache_t *c)
		{
		cache_pq_free(c->pq);
		cache_hash_free(c->ht);
		free(c);
		}


		CACHE_DECLARE(void) cache_find(cache_cache_t c, const char *key)
		{
		void *e;

		e = cache_hash_get(c->ht, key, CACHE_HASH_KEY_STRING);
		if (!e)
		return NULL;

		return e;
		}

		CACHE_DECLARE(void) cache_update(cache_cache_t* c, void *entry)
		{
		long old_priority;
		long new_priority;

		old_priority = c->set_pri(c->queue_clock, entry);
		c->inc_entry(entry);
		new_priority = c->set_pri(c->queue_clock, entry);
		cache_pq_change_priority(c->pq, old_priority, new_priority, entry);
		}

		CACHE_DECLARE(void) cache_insert(cache_cache_t* c, void *entry)
		{
		void *ejected = NULL;
		long priority;

		c->set_pri(c->queue_clock, entry);
		/* FIX: check if priority of bottom item is greater than inserted one */
		while ((cache_pq_size(c->pq) >= c->max_entries) \|\|
		((c->current_size + c->size_entry(entry)) > c->max_size)) {

		ejected = cache_pq_pop(c->pq);
		priority = c->get_pri(ejected);

		if (c->queue_clock < priority)
		c->queue_clock = priority;

		cache_hash_set(c->ht,
		c->key_entry(ejected),
		CACHE_HASH_KEY_STRING,
		NULL);

		ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL, "Cache Purge of %s",c->key_entry(ejected));
		c->current_size -= c->size_entry(ejected);
		c->free_entry(ejected);
		c->total_purges++;
		}
		c->current_size += c->size_entry(entry);

		cache_pq_insert(c->pq, entry);
		cache_hash_set(c->ht, c->key_entry(entry), CACHE_HASH_KEY_STRING, entry);
		}

		CACHE_DECLARE(void ) cache_pop(cache_cache_t c)
		{
		void *entry;

		if (!c)
		return NULL;

		entry = cache_pq_pop(c->pq);

		if (!entry)
		return NULL;

		c->current_size -= c->size_entry(entry);
		cache_hash_set(c->ht, c->key_entry(entry), CACHE_HASH_KEY_STRING, NULL);

		return entry;
		}

		CACHE_DECLARE(apr_status_t) cache_remove(cache_cache_t c, void entry)
		{
		apr_size_t entry_size = c->size_entry(entry);
		apr_status_t rc;
		rc = cache_pq_remove(c->pq, entry);
		if (rc != APR_SUCCESS)
		return rc;

		cache_hash_set(c->ht, c->key_entry(entry), CACHE_HASH_KEY_STRING, NULL);
		c->current_size -= entry_size;

		return APR_SUCCESS;
		}

modules/experimental/cache_cache.h

0 → 100644

+154 −0

Original line number	Diff line number	Diff line
		/* ====================================================================
		* The Apache Software License, Version 1.1
		*
		* Copyright (c) 2000-2002 The Apache Software Foundation. All rights
		* reserved.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions
		* are met:
		*
		* 1. Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		*
		* 2. Redistributions in binary form must reproduce the above copyright
		* notice, this list of conditions and the following disclaimer in
		* the documentation and/or other materials provided with the
		* distribution.
		*
		* 3. The end-user documentation included with the redistribution,
		* if any, must include the following acknowledgment:
		* "This product includes software developed by the
		* Apache Software Foundation (http://www.apache.org/)."
		* Alternately, this acknowledgment may appear in the software itself,
		* if and wherever such third-party acknowledgments normally appear.
		*
		* 4. The names "Apache" and "Apache Software Foundation" must
		* not be used to endorse or promote products derived from this
		* software without prior written permission. For written
		* permission, please contact apache@apache.org.
		*
		* 5. Products derived from this software may not be called "Apache",
		* nor may "Apache" appear in their name, without prior written
		* permission of the Apache Software Foundation.
		*
		* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
		* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
		* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
		* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
		* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
		* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
		* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
		* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
		* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
		* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
		* SUCH DAMAGE.
		* ====================================================================
		*
		* This software consists of voluntary contributions made by many
		* individuals on behalf of the Apache Software Foundation. For more
		* information on the Apache Software Foundation, please see
		* <http://www.apache.org/>.
		*
		* Portions of this software are based upon public domain software
		* originally written at the National Center for Supercomputing Applications,
		* University of Illinois, Urbana-Champaign.
		*/

		#ifndef CACHE_CACHE_H
		#define CACHE_CACHE_H

		#ifdef __cplusplus
		extern "C" {
		#endif

		#include "mod_cache.h"

		/**
		* @file cache_hash.h
		* @brief Cache Cache Functions
		*/

		/**
		* @defgroup Cache_cache Cache Functions
		* @ingroup CACHE
		* @{
		*/
		/** ADT for the cache */
		typedef struct cache_cache_t cache_cache_t;

		/** callback to increment the frequency of a item */
		typedef void cache_cache_inc_frequency(void*a);
		/** callback to get the size of a item */
		typedef apr_size_t cache_cache_get_size(void*a);
		/** callback to get the key of a item */
		typedef const char* cache_cache_get_key(void *a);
		/** callback to free an entry */
		typedef void cache_cache_free(void *a);

		/**
		* initialize the cache ADT
		* @param max_entries the number of entries in the cache
		* @param max_size the size of the cache
		* @param get_pri callback to get a priority of a entry
		* @param set_pri callback to set a priority of a entry
		* @param get_pos callback to get the position of a entry in the cache
		* @param set_pos callback to set the position of a entry in the cache
		* @param inc_entry callback to increment the frequency of a entry
		* @param size_entry callback to get the size of a entry
		* @param key_entry callback to get the key of a entry
		* @param free_entry callback to free an entry
		*/
		CACHE_DECLARE(cache_cache_t *)cache_init(int max_entries,
		apr_size_t max_size,
		cache_pqueue_get_priority *get_pri,
		cache_pqueue_set_priority *set_pri,
		cache_pqueue_getpos get_pos,
		cache_pqueue_setpos set_pos,
		cache_cache_inc_frequency *inc_entry,
		cache_cache_get_size *size_entry,
		cache_cache_get_key *key_entry,
		cache_cache_free *free_entry);

		/**
		* free up the cache
		* @param c the cache
		*/
		CACHE_DECLARE(void) cache_free(cache_cache_t *c);
		/**
		* find a entry in the cache, incrementing the frequency if found
		* @param c the cache
		* @param key the key
		*/
		CACHE_DECLARE(void) cache_find(cache_cache_t c, const char *key);
		/**
		* insert a entry into the cache
		* @param c the cache
		* @param entry the entry
		*/
		CACHE_DECLARE(void) cache_update(cache_cache_t* c, void *entry);
		/**
		* insert a entry into the cache
		* @param c the cache
		* @param entry the entry
		*/
		CACHE_DECLARE(void) cache_insert(cache_cache_t* c, void *entry);
		/**
		* pop the lowest priority item off
		* @param c the cache
		* @returns the entry or NULL
		*/
		CACHE_DECLARE(void )cache_pop(cache_cache_t c);
		/**
		* remove an item from the cache
		* @param c the cache
		* @param entry the actual entry (from a find)
		*/
		CACHE_DECLARE(apr_status_t) cache_remove(cache_cache_t* c, void *entry);
		/** @} */
		#ifdef __cplusplus
		}
		#endif

		#endif /* !CACHE_CACHE_H */

modules/experimental/cache_pqueue.c

0 → 100644

+287 −0

Original line number	Diff line number	Diff line
		#include "apr_general.h"

		#if APR_HAVE_STDLIB_H
		#include <stdlib.h>
		#endif
		#if APR_HAVE_STDIO_H
		#include <stdio.h>
		#endif

		#if APR_HAVE_STRING_H
		#include <string.h>
		#endif

		#include "cache_pqueue.h"
		#define left(i) (2*(i))
		#define right(i) ((2*i)+1)
		#define parent(i) (i/2)
		/*
		* Priority queue structure
		*/
		struct cache_pqueue_t
		{
		apr_ssize_t size;
		apr_ssize_t avail;
		apr_ssize_t step;
		cache_pqueue_get_priority* pri;
		cache_pqueue_getpos* get;
		cache_pqueue_setpos* set;
		void **d;
		};

		cache_pqueue_t *cache_pq_init(apr_ssize_t n,
		cache_pqueue_get_priority* pri,
		cache_pqueue_getpos get,
		cache_pqueue_setpos set)
		{
		cache_pqueue_t *q;

		if (!(q = malloc(sizeof(cache_pqueue_t)))) {
		return NULL;
		}

		if (!(q->d = malloc(sizeof(void) n))) {
		free(q);
		return NULL;
		}
		q->avail = q->step = n;
		q->pri = pri;
		q->size = 1;
		q->get = get;
		q->set = set;
		return q;
		}
		/*
		* cleanup
		*/
		void cache_pq_free(cache_pqueue_t *q)
		{
		free(q->d);
		free(q);
		}
		/*
		* pqsize: size of the queue.
		*/
		apr_ssize_t cache_pq_size(cache_pqueue_t *q)
		{
		return q->size;
		}

		static void cache_pq_bubble_up(cache_pqueue_t*q, apr_ssize_t i)
		{
		apr_ssize_t parent_node;
		parent_node = parent(i);

		while (i > 1 && q->pri(q->d[parent_node]) < q->pri(q->d[i])) {
		void *tmp;
		tmp = q->d[i];

		q->d[i] = q->d[parent_node];
		q->d[parent_node] = tmp;
		q->set(q->d[i], i);
		q->set(q->d[parent_node], parent_node);
		i = parent_node;
		parent_node = parent(i);
		}
		}

		static apr_ssize_t minchild(cache_pqueue_t *q, apr_ssize_t i)
		{
		apr_ssize_t y, minc;
		minc = left(i);
		if (minc >= q->size)
		return -1;

		for (y = minc + 1; y <= right(i) && y < q->size; y++) {
		if (q->pri(q->d[y]) > q->pri(q->d[minc]))
		minc = y;
		}
		return minc;
		}

		static void cache_pq_percolate_down(cache_pqueue_t*q, apr_ssize_t i)
		{
		apr_ssize_t cx = minchild(q, i);
		while ((cx != -1) && (q->pri(q->d[cx]) > q->pri(q->d[i])))
		{
		void *tmp;

		tmp = q->d[i];
		q->d[i] = q->d[cx];
		q->d[cx] = tmp;
		q->set(q->d[i], i);
		q->set(q->d[cx], cx);
		i = cx;
		cx = minchild(q, i);
		}
		}

		apr_status_t cache_pq_insert(cache_pqueue_t q, void d)
		{
		void *tmp;
		apr_ssize_t i;
		apr_ssize_t parent_node;
		apr_ssize_t newsize;

		if (!q) return APR_EGENERAL;

		/* allocate more memory if necessary */
		if (q->size >= q->avail) {
		newsize = q->size + q->step;
		if (!(tmp = realloc(q->d, sizeof(void) newsize))) {
		return APR_EGENERAL;
		};
		q->d = tmp;
		q->avail = newsize;
		}

		/* insert item */
		i = q->size++;
		parent_node = parent(i);
		/*
		* this is an optimization of the bubble-up as it doesn't
		* have to swap the member around
		*/
		while ((i > 1) && q->pri(q->d[parent_node]) < q->pri(d)) {
		q->d[i] = q->d[parent_node];
		q->set(q->d[i], i);
		i = parent_node;
		parent_node = parent(i);
		}
		q->d[i] = d;
		q->set(q->d[i], i);
		return APR_SUCCESS;
		}

		/*
		* move a existing entry to a new priority
		*/
		void cache_pq_change_priority(cache_pqueue_t*q,
		long old_priority,
		long new_priority,
		void *d)
		{
		apr_ssize_t posn;

		posn = q->get(d);
		if (new_priority > old_priority)
		cache_pq_bubble_up(q, posn);
		else
		cache_pq_percolate_down(q, posn);
		}

		apr_status_t cache_pq_remove(cache_pqueue_t q, void d)
		{
		apr_ssize_t posn;
		void *popped = NULL;
		long pri_popped;
		long pri_removed;

		posn = q->get(d);
		popped = cache_pq_pop(q);

		if (!popped)
		return APR_EGENERAL;

		if (d == popped) {
		return APR_SUCCESS;
		}
		pri_popped = q->pri(popped);
		pri_removed = q->pri(d);

		q->d[posn] = popped;
		q->set(popped,posn);
		if (pri_popped > pri_removed)
		cache_pq_bubble_up(q, posn);
		else
		cache_pq_percolate_down(q, posn);

		return APR_SUCCESS;
		}

		void cache_pq_pop(cache_pqueue_t q)
		{
		void *tmp;
		void *d;
		int i = 1;
		int j;

		if (!q \|\| q->size == 1)
		return NULL;

		d = q->d[1];
		tmp = q->d[--q->size];
		while (i <= q->size / 2) {
		j = 2 * i;
		if (j < q->size && q->pri(q->d[j]) < q->pri(q->d[j + 1])) {
		j++;
		}
		if (q->pri(q->d[j]) <= q->pri(tmp)) {
		break;
		}
		q->d[i] = q->d[j];
		q->set(d, i);
		i = j;
		}
		q->d[i] = tmp;
		q->set(d, i);
		return d;
		}

		void cache_pq_peek(cache_pqueue_t q)
		{
		void *d;
		if (!q \|\| q->size == 1)
		return NULL;
		d = q->d[1];
		return d;
		}

		static void cache_pq_set_null( void*d, int val)
		{
		/* do nothing */
		}
		/*
		* this is a debug function.. so it's EASY not fast
		*/
		void cache_pq_dump(cache_pqueue_t *q,
		FILE*out,
		cache_pqueue_print_entry print)
		{
		int i;

		fprintf(stdout,"posn\tleft\tright\tparent\tminchild\t...\n");
		for (i = 1; i < q->size ;i++) {
		fprintf(stdout,
		"%d\t%d\t%d\t%d\t%d\t",
		i,
		left(i), right(i), parent(i),
		minchild(q, i));
		print(out, q->d[i]);
		}
		}
		/*
		* this is a debug function.. so it's EASY not fast
		*/
		void cache_pq_print(cache_pqueue_t *q,
		FILE*out,
		cache_pqueue_print_entry print)
		{
		cache_pqueue_t *dup;
		dup = cache_pq_init(q->size, q->pri, q->get, cache_pq_set_null);
		dup->size = q->size;
		dup->avail = q->avail;
		dup->step = q->step;

		memcpy(dup->d, q->d, q->sizesizeof(void));

		while (cache_pq_size(dup) > 1) {
		void *e = NULL;
		e = cache_pq_pop(dup);
		if (e)
		print(out, e);
		else
		break;
		}
		cache_pq_free(dup);
		}

modules/experimental/cache_pqueue.h

0 → 100644

+187 −0

Original line number	Diff line number	Diff line
		/* ====================================================================
		* The Apache Software License, Version 1.1
		*
		* Copyright (c) 2000-2002 The Apache Software Foundation. All rights
		* reserved.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions
		* are met:
		*
		* 1. Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		*
		* 2. Redistributions in binary form must reproduce the above copyright
		* notice, this list of conditions and the following disclaimer in
		* the documentation and/or other materials provided with the
		* distribution.
		*
		* 3. The end-user documentation included with the redistribution,
		* if any, must include the following acknowledgment:
		* "This product includes software developed by the
		* Apache Software Foundation (http://www.apache.org/)."
		* Alternately, this acknowledgment may appear in the software itself,
		* if and wherever such third-party acknowledgments normally appear.
		*
		* 4. The names "Apache" and "Apache Software Foundation" must
		* not be used to endorse or promote products derived from this
		* software without prior written permission. For written
		* permission, please contact apache@apache.org.
		*
		* 5. Products derived from this software may not be called "Apache",
		* nor may "Apache" appear in their name, without prior written
		* permission of the Apache Software Foundation.
		*
		* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
		* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
		* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
		* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
		* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
		* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
		* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
		* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
		* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
		* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
		* SUCH DAMAGE.
		* ====================================================================
		*
		* This software consists of voluntary contributions made by many
		* individuals on behalf of the Apache Software Foundation. For more
		* information on the Apache Software Foundation, please see
		* <http://www.apache.org/>.
		*
		* Portions of this software are based upon public domain software
		* originally written at the National Center for Supercomputing Applications,
		* University of Illinois, Urbana-Champaign.
		*/

		#ifndef CACHE_PQUEUE_H
		#define CACHE_PQUEUE_H

		#ifdef __cplusplus
		extern "C" {
		#endif

		/** the cache priority queue handle */
		typedef struct cache_pqueue_t cache_pqueue_t;

		/**
		* callback function to assign a priority for a element
		* @param a the element
		* @return the score (the lower the score the longer it is kept int the queue)
		*/
		typedef long cache_pqueue_set_priority(long queue_clock, void*a);
		typedef long cache_pqueue_get_priority(void*a);

		/** callback function to get a position of a element */
		typedef apr_ssize_t cache_pqueue_getpos(void *a);

		/**
		* callback function to set a position of a element
		* @param a the element
		* @param pos the position to set it to
		*/
		typedef void cache_pqueue_setpos(void *a, apr_ssize_t pos);

		/** debug callback function to print a entry */
		typedef void cache_pqueue_print_entry(FILE out, void a);

		/**
		* initialize the queue
		*
		* @param n the intial estimate of the number of queue items for which memory
		* should be preallocated
		* @param pri the callback function to run to assign a score to a element
		* @param get the callback function to get the current element's position
		* @param set the callback function to set the current element's position
		*
		* @Return the handle or NULL for insufficent memory
		*/
		cache_pqueue_t *cache_pq_init(apr_ssize_t n,
		cache_pqueue_get_priority* pri,
		cache_pqueue_getpos get,
		cache_pqueue_setpos set);
		/**
		* free all memory used by the queue
		* @param q the queue
		*/
		void cache_pq_free(cache_pqueue_t *q);
		/**
		* return the size of the queue.
		* @param q the queue
		*/
		apr_ssize_t cache_pq_size(cache_pqueue_t *q);

		/**
		* insert an item into the queue.
		* @param q the queue
		* @param d the item
		* @return APR_SUCCESS on success
		*/
		apr_status_t cache_pq_insert(cache_pqueue_t q, void d);

		/*
		* move a existing entry to a different priority
		* @param q the queue
		* @param old the old priority
		* @param d the entry
		*/
		void cache_pq_change_priority(cache_pqueue_t *q,
		long old_priority,
		long new_priority,
		void *d);

		/**
		* pop the highest-ranking item from the queue.
		* @param p the queue
		* @param d where to copy the entry to
		* @return NULL on error, otherwise the entry
		*/
		void cache_pq_pop(cache_pqueue_t q);

		/**
		* remove an item from the queue.
		* @param p the queue
		* @param d the entry
		* @return APR_SUCCESS on success
		*/
		apr_status_t cache_pq_remove(cache_pqueue_t q, void d);

		/**
		* access highest-ranking item without removing it.
		* @param q the queue
		* @param d the entry
		* @return NULL on error, otherwise the entry
		*/
		void cache_pq_peek(cache_pqueue_t q);

		/**
		* print the queue
		* @internal
		* DEBUG function only
		* @param q the queue
		* @param out the output handle
		* @param the callback function to print the entry
		*/
		void cache_pq_print(cache_pqueue_t *q,
		FILE *out,
		cache_pqueue_print_entry print);

		/**
		* dump the queue and it's internal structure
		* @internal
		* debug function only
		* @param q the queue
		* @param out the output handle
		* @param the callback function to print the entry
		*/
		void cache_pq_dump(cache_pqueue_t *q,
		FILE *out,
		cache_pqueue_print_entry print);

		#ifdef __cplusplus
		}
		#endif

		#endif /* !CACHE_PQUEUE_H */