[src/trunk]: src/sys/dev/raidframe Bye-bye to the memchunk files.

[oster <oster%NetBSD.org@localhost>]

details:   https://anonhg.NetBSD.org/src/rev/a57242e10000
branches:  trunk
changeset: 534723:a57242e10000
user:      oster <oster%NetBSD.org@localhost>
date:      Fri Aug 02 03:48:14 2002 +0000

description:
Bye-bye to the memchunk files.

diffstat:

 sys/dev/raidframe/rf_memchunk.c |  213 ----------------------------------------
 sys/dev/raidframe/rf_memchunk.h |   47 --------
 2 files changed, 0 insertions(+), 260 deletions(-)

diffs (268 lines):

diff -r c0bd91ae14a6 -r a57242e10000 sys/dev/raidframe/rf_memchunk.c
--- a/sys/dev/raidframe/rf_memchunk.c   Fri Aug 02 03:47:48 2002 +0000
+++ /dev/null   Thu Jan 01 00:00:00 1970 +0000
@@ -1,213 +0,0 @@
-/*     $NetBSD: rf_memchunk.c,v 1.8 2002/07/14 03:16:06 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@localhost
- *  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 <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_memchunk.c,v 1.8 2002/07/14 03:16:06 oster Exp $");
-
-#include <dev/raidframe/raidframevar.h>
-
-#include "rf_debugMem.h"
-#include "rf_memchunk.h"
-#include "rf_general.h"
-#include "rf_options.h"
-#include "rf_shutdown.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) memset(p->buf, 0, 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);
-}
diff -r c0bd91ae14a6 -r a57242e10000 sys/dev/raidframe/rf_memchunk.h
--- a/sys/dev/raidframe/rf_memchunk.h   Fri Aug 02 03:47:48 2002 +0000
+++ /dev/null   Thu Jan 01 00:00:00 1970 +0000
@@ -1,47 +0,0 @@
-/*     $NetBSD: rf_memchunk.h,v 1.4 2001/10/04 15:58:54 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@localhost
- *  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.
- */
-
-/* header file for rf_memchunk.c.  See comments there */
-
-#ifndef _RF__RF_MEMCHUNK_H_
-#define _RF__RF_MEMCHUNK_H_
-
-#include <dev/raidframe/raidframevar.h>
-
-struct RF_ChunkDesc_s {
-       int     size;
-       int     reuse_count;
-       char   *buf;
-       RF_ChunkDesc_t *next;
-};
-
-int     rf_ConfigureMemChunk(RF_ShutdownList_t ** listp);
-RF_ChunkDesc_t *rf_GetMemChunk(int size);
-void    rf_ReleaseMemChunk(RF_ChunkDesc_t * chunk);
-
-#endif                         /* !_RF__RF_MEMCHUNK_H_ */