/*	$OpenBSD: rf_memchunk.c,v 1.2 1999/02/16 00:02:57 niklas Exp $	*/
/*	$NetBSD: rf_memchunk.c,v 1.3 1999/02/05 00:06:13 oster Exp $	*/
/*
 * Copyright (c) 1995 Carnegie-Mellon University.
 * All rights reserved.
 *
 * Author: Mark Holland
 *
 * Permission to use, copy, modify and distribute this software and
 * its documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 *
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 *
 * Carnegie Mellon requests users of this software to return to
 *
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 *
 * any improvements or extensions that they make and grant Carnegie the
 * rights to redistribute these changes.
 */

/*********************************************************************************
 * rf_memchunk.c
 *
 * experimental code.  I've found that the malloc and free calls in the DAG
 * creation code are very expensive.  Since for any given workload the DAGs
 * created for different accesses are likely to be similar to each other, the
 * amount of memory used for any given DAG data structure is likely to be one
 * of a small number of values.  For example, in UNIX, all reads and writes will
 * be less than 8k and will not span stripe unit boundaries.  Thus in the absence
 * of failure, the only DAGs that will ever get created are single-node reads
 * and single-stripe-unit atomic read-modify-writes.  So, I'm very likely to
 * be continually asking for chunks of memory equal to the sizes of these two
 * DAGs.
 *
 * This leads to the idea of holding on to these chunks of memory when the DAG is
 * freed and then, when a new DAG is created, trying to find such a chunk before
 * calling malloc.
 *
 * the "chunk list" is a list of lists.  Each header node contains a size value
 * and a pointer to a list of chunk descriptors, each of which holds a pointer
 * to a chunk of memory of the indicated size.
 *
 * There is currently no way to purge memory out of the chunk list.  My
 * initial thought on this is to have a low-priority thread that wakes up every
 * 1 or 2 seconds, purges all the chunks with low reuse counts, and sets all
 * the reuse counts to zero.
 *
 * This whole idea may be bad, since malloc may be able to do this more efficiently.
 * It's worth a try, though, and it can be turned off by setting useMemChunks to 0.
 *
 ********************************************************************************/

#include "rf_types.h"
#include "rf_threadstuff.h"
#include "rf_debugMem.h"
#include "rf_memchunk.h"
#include "rf_general.h"
#include "rf_options.h"
#include "rf_shutdown.h"
#include "rf_sys.h"

typedef struct RF_ChunkHdr_s RF_ChunkHdr_t;
struct RF_ChunkHdr_s {
	int     size;
	RF_ChunkDesc_t *list;
	RF_ChunkHdr_t *next;
};

static RF_ChunkHdr_t *chunklist, *chunk_hdr_free_list;
static RF_ChunkDesc_t *chunk_desc_free_list;
RF_DECLARE_STATIC_MUTEX(chunkmutex)
	static void rf_ShutdownMemChunk(void *);
	static RF_ChunkDesc_t *NewMemChunk(int, char *);


	static void rf_ShutdownMemChunk(ignored)
	void   *ignored;
{
	RF_ChunkDesc_t *pt, *p;
	RF_ChunkHdr_t *hdr, *ht;

	if (rf_memChunkDebug)
		printf("Chunklist:\n");
	for (hdr = chunklist; hdr;) {
		for (p = hdr->list; p;) {
			if (rf_memChunkDebug)
				printf("Size %d reuse count %d\n", p->size, p->reuse_count);
			pt = p;
			p = p->next;
			RF_Free(pt->buf, pt->size);
			RF_Free(pt, sizeof(*pt));
		}
		ht = hdr;
		hdr = hdr->next;
		RF_Free(ht, sizeof(*ht));
	}

	rf_mutex_destroy(&chunkmutex);
}

int 
rf_ConfigureMemChunk(listp)
	RF_ShutdownList_t **listp;
{
	int     rc;

	chunklist = NULL;
	chunk_hdr_free_list = NULL;
	chunk_desc_free_list = NULL;
	rc = rf_mutex_init(&chunkmutex);
	if (rc) {
		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__,
		    __LINE__, rc);
	}
	rc = rf_ShutdownCreate(listp, rf_ShutdownMemChunk, NULL);
	if (rc) {
		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n", __FILE__,
		    __LINE__, rc);
		rf_mutex_destroy(&chunkmutex);
	}
	return (rc);
}
/* called to get a chunk descriptor for a newly-allocated chunk of memory
 * MUTEX MUST BE LOCKED
 *
 * free list is not currently used
 */
static RF_ChunkDesc_t *
NewMemChunk(size, buf)
	int     size;
	char   *buf;
{
	RF_ChunkDesc_t *p;

	if (chunk_desc_free_list) {
		p = chunk_desc_free_list;
		chunk_desc_free_list = p->next;
	} else
		RF_Malloc(p, sizeof(RF_ChunkDesc_t), (RF_ChunkDesc_t *));
	p->size = size;
	p->buf = buf;
	p->next = NULL;
	p->reuse_count = 0;
	return (p);
}
/* looks for a chunk of memory of acceptable size.  If none, allocates one and returns
 * a chunk descriptor for it, but does not install anything in the list.  This is done
 * when the chunk is released.
 */
RF_ChunkDesc_t *
rf_GetMemChunk(size)
	int     size;
{
	RF_ChunkHdr_t *hdr = chunklist;
	RF_ChunkDesc_t *p = NULL;
	char   *buf;

	RF_LOCK_MUTEX(chunkmutex);
	for (hdr = chunklist; hdr; hdr = hdr->next)
		if (hdr->size >= size) {
			p = hdr->list;
			if (p) {
				hdr->list = p->next;
				p->next = NULL;
				p->reuse_count++;
			}
			break;
		}
	if (!p) {
		RF_Malloc(buf, size, (char *));
		p = NewMemChunk(size, buf);
	}
	RF_UNLOCK_MUTEX(chunkmutex);
	(void) bzero(p->buf, size);
	return (p);
}

void 
rf_ReleaseMemChunk(chunk)
	RF_ChunkDesc_t *chunk;
{
	RF_ChunkHdr_t *hdr, *ht = NULL, *new;

	RF_LOCK_MUTEX(chunkmutex);
	for (hdr = chunklist; hdr && hdr->size < chunk->size; ht = hdr, hdr = hdr->next);
	if (hdr && hdr->size == chunk->size) {
		chunk->next = hdr->list;
		hdr->list = chunk;
	} else {
		RF_Malloc(new, sizeof(RF_ChunkHdr_t), (RF_ChunkHdr_t *));
		new->size = chunk->size;
		new->list = chunk;
		chunk->next = NULL;
		if (ht) {
			new->next = ht->next;
			ht->next = new;
		} else {
			new->next = hdr;
			chunklist = new;
		}
	}
	RF_UNLOCK_MUTEX(chunkmutex);
}