![[BACK]](/icons/back.gif){kind=icon}
Return to rf_freelist.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe|
Return to rf_freelist.h CVS log | Up to [local] / sys / dev / raidframe |
1.1 ! nbrk 1: /* $OpenBSD: rf_freelist.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $ */
! 2: /* $NetBSD: rf_freelist.h,v 1.3 1999/02/05 00:06:11 oster Exp $ */
! 3:
! 4: /*
! 5: * rf_freelist.h
! 6: */
! 7: /*
! 8: * Copyright (c) 1995 Carnegie-Mellon University.
! 9: * All rights reserved.
! 10: *
! 11: * Author: Jim Zelenka
! 12: *
! 13: * Permission to use, copy, modify and distribute this software and
! 14: * its documentation is hereby granted, provided that both the copyright
! 15: * notice and this permission notice appear in all copies of the
! 16: * software, derivative works or modified versions, and any portions
! 17: * thereof, and that both notices appear in supporting documentation.
! 18: *
! 19: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
! 20: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
! 21: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
! 22: *
! 23: * Carnegie Mellon requests users of this software to return to
! 24: *
! 25: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
! 26: * School of Computer Science
! 27: * Carnegie Mellon University
! 28: * Pittsburgh PA 15213-3890
! 29: *
! 30: * any improvements or extensions that they make and grant Carnegie the
! 31: * rights to redistribute these changes.
! 32: */
! 33:
! 34: /*
! 35: * rf_freelist.h -- Code to manage counted freelists.
! 36: *
! 37: * Keep an arena of fixed-size objects. When a new object is needed,
! 38: * allocate it as necessary. When an object is freed, either put it
! 39: * in the arena, or really free it, depending on the maximum arena
! 40: * size.
! 41: */
! 42:
! 43: #ifndef _RF__RF_FREELIST_H_
! 44: #define _RF__RF_FREELIST_H_
! 45:
! 46: #include "rf_types.h"
! 47: #include "rf_debugMem.h"
! 48: #include "rf_general.h"
! 49: #include "rf_threadstuff.h"
! 50:
! 51: #define RF_FREELIST_STATS 0
! 52:
! 53: #if RF_FREELIST_STATS > 0
! 54: typedef struct RF_FreeListStats_s {
! 55: char *file;
! 56: int line;
! 57: int allocations;
! 58: int frees;
! 59: int max_free;
! 60: int grows;
! 61: int outstanding;
! 62: int max_outstanding;
! 63: } RF_FreeListStats_t;
! 64:
! 65: #define RF_FREELIST_STAT_INIT(_fl_) \
! 66: do { \
! 67: bzero((char *)&((_fl_)->stats), sizeof(RF_FreeListStats_t)); \
! 68: (_fl_)->stats.file = __FILE__; \
! 69: (_fl_)->stats.line = __LINE__; \
! 70: } while (0)
! 71:
! 72: #define RF_FREELIST_STAT_ALLOC(_fl_) \
! 73: do { \
! 74: (_fl_)->stats.allocations++; \
! 75: (_fl_)->stats.outstanding++; \
! 76: if ((_fl_)->stats.outstanding > (_fl_)->stats.max_outstanding) \
! 77: (_fl_)->stats.max_outstanding = \
! 78: (_fl_)->stats.outstanding; \
! 79: } while (0)
! 80:
! 81: #define RF_FREELIST_STAT_FREE_UPDATE(_fl_) \
! 82: do { \
! 83: if ((_fl_)->free_cnt > (_fl_)->stats.max_free) \
! 84: (_fl_)->stats.max_free = (_fl_)->free_cnt; \
! 85: } while (0)
! 86:
! 87: #define RF_FREELIST_STAT_FREE(_fl_) \
! 88: do { \
! 89: (_fl_)->stats.frees++; \
! 90: (_fl_)->stats.outstanding--; \
! 91: RF_FREELIST_STAT_FREE_UPDATE(_fl_); \
! 92: } while (0)
! 93:
! 94: #define RF_FREELIST_STAT_GROW(_fl_) \
! 95: do { \
! 96: (_fl_)->stats.grows++; \
! 97: RF_FREELIST_STAT_FREE_UPDATE(_fl_); \
! 98: } while (0)
! 99:
! 100: #define RF_FREELIST_STAT_REPORT(_fl_) \
! 101: do { \
! 102: printf("Freelist at %s %d (%s)\n", (_fl_)->stats.file, \
! 103: (_fl_)->stats.line, RF_STRING(_fl_)); \
! 104: printf(" %d allocations, %d frees\n", \
! 105: (_fl_)->stats.allocations, (_fl_)->stats.frees); \
! 106: printf(" %d grows\n", (_fl_)->stats.grows); \
! 107: printf(" %d outstanding\n", (_fl_)->stats.outstanding); \
! 108: printf(" %d free (max)\n", (_fl_)->stats.max_free); \
! 109: printf(" %d outstanding (max)\n", \
! 110: (_fl_)->stats.max_outstanding); \
! 111: } while (0)
! 112:
! 113: #else /* RF_FREELIST_STATS > 0 */
! 114:
! 115: #define RF_FREELIST_STAT_INIT(_fl_)
! 116: #define RF_FREELIST_STAT_ALLOC(_fl_)
! 117: #define RF_FREELIST_STAT_FREE_UPDATE(_fl_)
! 118: #define RF_FREELIST_STAT_FREE(_fl_)
! 119: #define RF_FREELIST_STAT_GROW(_fl_)
! 120: #define RF_FREELIST_STAT_REPORT(_fl_)
! 121:
! 122: #endif /* RF_FREELIST_STATS > 0 */
! 123:
! 124: struct RF_FreeList_s {
! 125: void *objlist; /* List of free obj. */
! 126: int free_cnt; /* How many free obj. */
! 127: int max_free_cnt; /* Max free arena size. */
! 128: int obj_inc; /* How many to allocate at a time. */
! 129: int obj_size; /* Size of objects. */
! 130: RF_DECLARE_MUTEX(lock);
! 131: #if RF_FREELIST_STATS > 0
! 132: RF_FreeListStats_t stats; /* Statistics. */
! 133: #endif /* RF_FREELIST_STATS > 0 */
! 134: };
! 135:
! 136: /*
! 137: * fl = FreeList.
! 138: * maxcnt = Max number of items in arena.
! 139: * inc = How many to allocate at a time.
! 140: * size = Size of object.
! 141: */
! 142: #define RF_FREELIST_CREATE(_fl_,_maxcnt_,_inc_,_size_) \
! 143: do { \
! 144: int rc; \
! 145: RF_ASSERT((_inc_) > 0); \
! 146: RF_Malloc(_fl_, sizeof(RF_FreeList_t), (RF_FreeList_t *)); \
! 147: (_fl_)->objlist = NULL; \
! 148: (_fl_)->free_cnt = 0; \
! 149: (_fl_)->max_free_cnt = _maxcnt_; \
! 150: (_fl_)->obj_inc = _inc_; \
! 151: (_fl_)->obj_size = _size_; \
! 152: rc = rf_mutex_init(&(_fl_)->lock); \
! 153: if (rc) { \
! 154: RF_Free(_fl_, sizeof(RF_FreeList_t)); \
! 155: _fl_ = NULL; \
! 156: } \
! 157: RF_FREELIST_STAT_INIT(_fl_); \
! 158: } while (0)
! 159:
! 160: /*
! 161: * fl = FreeList.
! 162: * cnt = Number to prime with.
! 163: * nextp = Name of "next" pointer in obj.
! 164: * cast = Object cast.
! 165: */
! 166: #define RF_FREELIST_PRIME(_fl_,_cnt_,_nextp_,_cast_) \
! 167: do { \
! 168: void *_p; \
! 169: int _i; \
! 170: RF_LOCK_MUTEX((_fl_)->lock); \
! 171: for (_i = 0; _i < (_cnt_); _i++) { \
! 172: RF_Calloc(_p, 1, (_fl_)->obj_size, (void *)); \
! 173: if (_p) { \
! 174: (_cast_(_p))->_nextp_ = (_fl_)->objlist; \
! 175: (_fl_)->objlist = _p; \
! 176: (_fl_)->free_cnt++; \
! 177: } \
! 178: else { \
! 179: break; \
! 180: } \
! 181: } \
! 182: RF_FREELIST_STAT_FREE_UPDATE(_fl_); \
! 183: RF_UNLOCK_MUTEX((_fl_)->lock); \
! 184: } while (0)
! 185:
! 186: #define RF_FREELIST_MUTEX_OF(_fl_) ((_fl_)->lock)
! 187:
! 188: #define RF_FREELIST_DO_UNLOCK(_fl_) RF_UNLOCK_MUTEX((_fl_)->lock)
! 189:
! 190: #define RF_FREELIST_DO_LOCK(_fl_) RF_LOCK_MUTEX((_fl_)->lock)
! 191:
! 192: /*
! 193: * fl = FreeList.
! 194: * cnt = Number to prime with.
! 195: * nextp = Name of "next" pointer in obj.
! 196: * cast = Object cast.
! 197: * init = Func to call to init obj.
! 198: */
! 199: #define RF_FREELIST_PRIME_INIT(_fl_,_cnt_,_nextp_,_cast_,_init_) \
! 200: do { \
! 201: void *_p; \
! 202: int _i; \
! 203: RF_LOCK_MUTEX((_fl_)->lock); \
! 204: for (_i = 0; _i < (_cnt_); _i++) { \
! 205: RF_Calloc(_p, 1, (_fl_)->obj_size, (void *)); \
! 206: if (_init_(_cast_ _p)) { \
! 207: RF_Free(_p, (_fl_)->obj_size); \
! 208: _p = NULL; \
! 209: } \
! 210: if (_p) { \
! 211: (_cast_(_p))->_nextp_ = (_fl_)->objlist; \
! 212: (_fl_)->objlist = _p; \
! 213: (_fl_)->free_cnt++; \
! 214: } \
! 215: else { \
! 216: break; \
! 217: } \
! 218: } \
! 219: RF_FREELIST_STAT_FREE_UPDATE(_fl_); \
! 220: RF_UNLOCK_MUTEX((_fl_)->lock); \
! 221: } while (0)
! 222:
! 223: /*
! 224: * fl = FreeList.
! 225: * cnt = Number to prime with.
! 226: * nextp = Name of "next" pointer in obj.
! 227: * cast = Object cast.
! 228: * init = Func to call to init obj.
! 229: * arg = Arg to init obj func.
! 230: */
! 231: #define RF_FREELIST_PRIME_INIT_ARG(_fl_,_cnt_,_nextp_,_cast_,_init_,_arg_) \
! 232: do { \
! 233: void *_p; \
! 234: int _i; \
! 235: RF_LOCK_MUTEX((_fl_)->lock); \
! 236: for (_i = 0; _i < (_cnt_); _i++) { \
! 237: RF_Calloc(_p, 1, (_fl_)->obj_size, (void *)); \
! 238: if (_init_(_cast_ _p, _arg_)) { \
! 239: RF_Free(_p, (_fl_)->obj_size); \
! 240: _p = NULL; \
! 241: } \
! 242: if (_p) { \
! 243: (_cast_(_p))->_nextp_ = (_fl_)->objlist; \
! 244: (_fl_)->objlist = _p; \
! 245: (_fl_)->free_cnt++; \
! 246: } \
! 247: else { \
! 248: break; \
! 249: } \
! 250: } \
! 251: RF_FREELIST_STAT_FREE_UPDATE(_fl_); \
! 252: RF_UNLOCK_MUTEX((_fl_)->lock); \
! 253: } while (0)
! 254:
! 255: /*
! 256: * fl = FreeList.
! 257: * obj = Object to allocate.
! 258: * nextp = Name of "next" pointer in obj.
! 259: * cast = Cast of obj assignment.
! 260: * init = Init obj func.
! 261: */
! 262: #define RF_FREELIST_GET_INIT(_fl_,_obj_,_nextp_,_cast_,_init_) \
! 263: do { \
! 264: void *_p; \
! 265: int _i; \
! 266: RF_LOCK_MUTEX((_fl_)->lock); \
! 267: RF_ASSERT(sizeof(*(_obj_)) == ((_fl_)->obj_size)); \
! 268: if (_fl_->objlist) { \
! 269: _obj_ = _cast_((_fl_)->objlist); \
! 270: (_fl_)->objlist = (void *)((_obj_)->_nextp_); \
! 271: (_fl_)->free_cnt--; \
! 272: } \
! 273: else { \
! 274: /* \
! 275: * Allocate one at a time so we can free \
! 276: * one at a time without cleverness when arena \
! 277: * is full. \
! 278: */ \
! 279: RF_Calloc(_obj_, 1, (_fl_)->obj_size, _cast_); \
! 280: if (_obj_) { \
! 281: if (_init_(_obj_)) { \
! 282: RF_Free(_obj_, (_fl_)->obj_size); \
! 283: _obj_ = NULL; \
! 284: } \
! 285: else { \
! 286: for (_i = 1; _i < (_fl_)->obj_inc; \
! 287: _i++) { \
! 288: RF_Calloc(_p, 1, \
! 289: (_fl_)->obj_size, \
! 290: (void *)); \
! 291: if (_p) { \
! 292: if (_init_(_p)) { \
! 293: RF_Free(_p, \
! 294: (_fl_)->obj_size); \
! 295: _p = NULL; \
! 296: break; \
! 297: } \
! 298: (_cast_(_p))->_nextp_ = \
! 299: (_fl_)->objlist; \
! 300: (_fl_)->objlist = _p; \
! 301: } \
! 302: else { \
! 303: break; \
! 304: } \
! 305: } \
! 306: } \
! 307: } \
! 308: RF_FREELIST_STAT_GROW(_fl_); \
! 309: } \
! 310: RF_FREELIST_STAT_ALLOC(_fl_); \
! 311: RF_UNLOCK_MUTEX((_fl_)->lock); \
! 312: } while (0)
! 313:
! 314: /*
! 315: * fl = FreeList.
! 316: * obj = Object to allocate.
! 317: * nextp = Name of "next" pointer in obj.
! 318: * cast = Cast of obj assignment.
! 319: * init = Init obj func.
! 320: * arg = Arg to init obj func.
! 321: */
! 322: #define RF_FREELIST_GET_INIT_ARG(_fl_,_obj_,_nextp_,_cast_,_init_,_arg_) \
! 323: do { \
! 324: void *_p; \
! 325: int _i; \
! 326: RF_LOCK_MUTEX((_fl_)->lock); \
! 327: RF_ASSERT(sizeof(*(_obj_)) == ((_fl_)->obj_size)); \
! 328: if (_fl_->objlist) { \
! 329: _obj_ = _cast_((_fl_)->objlist); \
! 330: (_fl_)->objlist = (void *)((_obj_)->_nextp_); \
! 331: (_fl_)->free_cnt--; \
! 332: } \
! 333: else { \
! 334: /* \
! 335: * Allocate one at a time so we can free \
! 336: * one at a time without cleverness when arena \
! 337: * is full. \
! 338: */ \
! 339: RF_Calloc(_obj_, 1, (_fl_)->obj_size, _cast_); \
! 340: if (_obj_) { \
! 341: if (_init_(_obj_, _arg_)) { \
! 342: RF_Free(_obj_, (_fl_)->obj_size); \
! 343: _obj_ = NULL; \
! 344: } \
! 345: else { \
! 346: for (_i = 1; _i < (_fl_)->obj_inc; \
! 347: _i++) { \
! 348: RF_Calloc(_p, 1, \
! 349: (_fl_)->obj_size, (void *)); \
! 350: if (_p) { \
! 351: if (_init_(_p, _arg_)) \
! 352: { \
! 353: RF_Free(_p, \
! 354: (_fl_)->obj_size); \
! 355: _p = NULL; \
! 356: break; \
! 357: } \
! 358: (_cast_(_p))->_nextp_ = \
! 359: (_fl_)->objlist; \
! 360: (_fl_)->objlist = _p; \
! 361: } \
! 362: else { \
! 363: break; \
! 364: } \
! 365: } \
! 366: } \
! 367: } \
! 368: RF_FREELIST_STAT_GROW(_fl_); \
! 369: } \
! 370: RF_FREELIST_STAT_ALLOC(_fl_); \
! 371: RF_UNLOCK_MUTEX((_fl_)->lock); \
! 372: } while (0)
! 373:
! 374: /*
! 375: * fl = FreeList.
! 376: * obj = Object to allocate.
! 377: * nextp = Name of "next" pointer in obj.
! 378: * cast = Cast of obj assignment.
! 379: * init = Init obj func.
! 380: */
! 381: #define RF_FREELIST_GET_INIT_NOUNLOCK(_fl_,_obj_,_nextp_,_cast_,_init_) \
! 382: do { \
! 383: void *_p; \
! 384: int _i; \
! 385: RF_LOCK_MUTEX((_fl_)->lock); \
! 386: RF_ASSERT(sizeof(*(_obj_)) == ((_fl_)->obj_size)); \
! 387: if (_fl_->objlist) { \
! 388: _obj_ = _cast_((_fl_)->objlist); \
! 389: (_fl_)->objlist = (void *)((_obj_)->_nextp_); \
! 390: (_fl_)->free_cnt--; \
! 391: } \
! 392: else { \
! 393: /* \
! 394: * Allocate one at a time so we can free \
! 395: * one at a time without cleverness when arena \
! 396: * is full. \
! 397: */ \
! 398: RF_Calloc(_obj_, 1, (_fl_)->obj_size, _cast_); \
! 399: if (_obj_) { \
! 400: if (_init_(_obj_)) { \
! 401: RF_Free(_obj_, (_fl_)->obj_size); \
! 402: _obj_ = NULL; \
! 403: } \
! 404: else { \
! 405: for (_i = 1; _i < (_fl_)->obj_inc; \
! 406: _i++) { \
! 407: RF_Calloc(_p, 1, \
! 408: (_fl_)->obj_size, \
! 409: (void *)); \
! 410: if (_p) { \
! 411: if (_init_(_p)) { \
! 412: RF_Free(_p, \
! 413: (_fl_)->obj_size); \
! 414: _p = NULL; \
! 415: break; \
! 416: } \
! 417: (_cast_(_p))->_nextp_ = \
! 418: (_fl_)->objlist; \
! 419: (_fl_)->objlist = _p; \
! 420: } \
! 421: else { \
! 422: break; \
! 423: } \
! 424: } \
! 425: } \
! 426: } \
! 427: RF_FREELIST_STAT_GROW(_fl_); \
! 428: } \
! 429: RF_FREELIST_STAT_ALLOC(_fl_); \
! 430: } while (0)
! 431:
! 432: /*
! 433: * fl = FreeList.
! 434: * obj = Object to allocate.
! 435: * nextp = Name of "next" pointer in obj.
! 436: * cast = Cast of obj assignment.
! 437: */
! 438: #define RF_FREELIST_GET(_fl_,_obj_,_nextp_,_cast_) \
! 439: do { \
! 440: void *_p; \
! 441: int _i; \
! 442: RF_LOCK_MUTEX((_fl_)->lock); \
! 443: RF_ASSERT(sizeof(*(_obj_)) == ((_fl_)->obj_size)); \
! 444: if (_fl_->objlist) { \
! 445: _obj_ = _cast_((_fl_)->objlist); \
! 446: (_fl_)->objlist = (void *)((_obj_)->_nextp_); \
! 447: (_fl_)->free_cnt--; \
! 448: } \
! 449: else { \
! 450: /* \
! 451: * Allocate one at a time so we can free \
! 452: * one at a time without cleverness when arena \
! 453: * is full. \
! 454: */ \
! 455: RF_Calloc(_obj_, 1, (_fl_)->obj_size, _cast_); \
! 456: if (_obj_) { \
! 457: for (_i = 1; _i < (_fl_)->obj_inc; _i++) { \
! 458: RF_Calloc(_p, 1, (_fl_)->obj_size, \
! 459: (void *)); \
! 460: if (_p) { \
! 461: (_cast_(_p))->_nextp_ = \
! 462: (_fl_)->objlist; \
! 463: (_fl_)->objlist = _p; \
! 464: } \
! 465: else { \
! 466: break; \
! 467: } \
! 468: } \
! 469: } \
! 470: RF_FREELIST_STAT_GROW(_fl_); \
! 471: } \
! 472: RF_FREELIST_STAT_ALLOC(_fl_); \
! 473: RF_UNLOCK_MUTEX((_fl_)->lock); \
! 474: } while (0)
! 475:
! 476: /*
! 477: * fl = FreeList.
! 478: * obj = Object to allocate.
! 479: * nextp = Name of "next" pointer in obj.
! 480: * cast = Cast of obj assignment.
! 481: * num = Num objs to return.
! 482: */
! 483: #define RF_FREELIST_GET_N(_fl_,_obj_,_nextp_,_cast_,_num_) \
! 484: do { \
! 485: void *_p, *_l, *_f; \
! 486: int _i, _n; \
! 487: _l = _f = NULL; \
! 488: _n = 0; \
! 489: RF_LOCK_MUTEX((_fl_)->lock); \
! 490: RF_ASSERT(sizeof(*(_obj_)) == ((_fl_)->obj_size)); \
! 491: for (_n = 0; _n < _num_; _n++) { \
! 492: if (_fl_->objlist) { \
! 493: _obj_ = _cast_((_fl_)->objlist); \
! 494: (_fl_)->objlist = (void *)((_obj_)->_nextp_); \
! 495: (_fl_)->free_cnt--; \
! 496: } \
! 497: else { \
! 498: /* \
! 499: * Allocate one at a time so we can free \
! 500: * one at a time without cleverness when arena \
! 501: * is full. \
! 502: */ \
! 503: RF_Calloc(_obj_, 1, (_fl_)->obj_size, _cast_); \
! 504: if (_obj_) { \
! 505: for (_i = 1; _i < (_fl_)->obj_inc; \
! 506: _i++) { \
! 507: RF_Calloc(_p, 1, \
! 508: (_fl_)->obj_size, \
! 509: (void *)); \
! 510: if (_p) { \
! 511: (_cast_(_p))->_nextp_ = \
! 512: (_fl_)->objlist; \
! 513: (_fl_)->objlist = _p; \
! 514: } \
! 515: else { \
! 516: break; \
! 517: } \
! 518: } \
! 519: } \
! 520: RF_FREELIST_STAT_GROW(_fl_); \
! 521: } \
! 522: if (_f == NULL) \
! 523: _f = _obj_; \
! 524: if (_obj_) { \
! 525: (_cast_(_obj_))->_nextp_ = _l; \
! 526: _l = _obj_; \
! 527: RF_FREELIST_STAT_ALLOC(_fl_); \
! 528: } \
! 529: else { \
! 530: (_cast_(_f))->_nextp_ = (_fl_)->objlist; \
! 531: (_fl_)->objlist = _l; \
! 532: _n = _num_; \
! 533: } \
! 534: } \
! 535: RF_UNLOCK_MUTEX((_fl_)->lock); \
! 536: } while (0)
! 537:
! 538: /*
! 539: * fl = FreeList.
! 540: * obj = Object to free.
! 541: * nextp = Name of "next" pointer in obj.
! 542: */
! 543: #define RF_FREELIST_FREE(_fl_,_obj_,_nextp_) \
! 544: do { \
! 545: RF_LOCK_MUTEX((_fl_)->lock); \
! 546: if ((_fl_)->free_cnt == (_fl_)->max_free_cnt) { \
! 547: RF_Free(_obj_, (_fl_)->obj_size); \
! 548: } \
! 549: else { \
! 550: RF_ASSERT((_fl_)->free_cnt < (_fl_)->max_free_cnt); \
! 551: (_obj_)->_nextp_ = (_fl_)->objlist; \
! 552: (_fl_)->objlist = (void *)(_obj_); \
! 553: (_fl_)->free_cnt++; \
! 554: } \
! 555: RF_FREELIST_STAT_FREE(_fl_); \
! 556: RF_UNLOCK_MUTEX((_fl_)->lock); \
! 557: } while (0)
! 558:
! 559: /*
! 560: * fl = FreeList.
! 561: * obj = Object to free.
! 562: * nextp = Name of "next" pointer in obj.
! 563: * num = Num to free (debugging).
! 564: */
! 565: #define RF_FREELIST_FREE_N(_fl_,_obj_,_nextp_,_cast_,_num_) \
! 566: do { \
! 567: void *_no; \
! 568: int _n; \
! 569: _n = 0; \
! 570: RF_LOCK_MUTEX((_fl_)->lock); \
! 571: while(_obj_) { \
! 572: _no = (_cast_(_obj_))->_nextp_; \
! 573: if ((_fl_)->free_cnt == (_fl_)->max_free_cnt) { \
! 574: RF_Free(_obj_, (_fl_)->obj_size); \
! 575: } \
! 576: else { \
! 577: RF_ASSERT((_fl_)->free_cnt < \
! 578: (_fl_)->max_free_cnt); \
! 579: (_obj_)->_nextp_ = (_fl_)->objlist; \
! 580: (_fl_)->objlist = (void *)(_obj_); \
! 581: (_fl_)->free_cnt++; \
! 582: } \
! 583: _n++; \
! 584: _obj_ = _no; \
! 585: RF_FREELIST_STAT_FREE(_fl_); \
! 586: } \
! 587: RF_ASSERT(_n==(_num_)); \
! 588: RF_UNLOCK_MUTEX((_fl_)->lock); \
! 589: } while (0)
! 590:
! 591: /*
! 592: * fl = FreeList.
! 593: * obj = Object to free.
! 594: * nextp = Name of "next" pointer in obj.
! 595: * clean = Undo for init.
! 596: */
! 597: #define RF_FREELIST_FREE_CLEAN(_fl_,_obj_,_nextp_,_clean_) \
! 598: do { \
! 599: RF_LOCK_MUTEX((_fl_)->lock); \
! 600: if ((_fl_)->free_cnt == (_fl_)->max_free_cnt) { \
! 601: _clean_(_obj_); \
! 602: RF_Free(_obj_, (_fl_)->obj_size); \
! 603: } \
! 604: else { \
! 605: RF_ASSERT((_fl_)->free_cnt < (_fl_)->max_free_cnt); \
! 606: (_obj_)->_nextp_ = (_fl_)->objlist; \
! 607: (_fl_)->objlist = (void *)(_obj_); \
! 608: (_fl_)->free_cnt++; \
! 609: } \
! 610: RF_FREELIST_STAT_FREE(_fl_); \
! 611: RF_UNLOCK_MUTEX((_fl_)->lock); \
! 612: } while (0)
! 613:
! 614: /*
! 615: * fl = FreeList.
! 616: * obj = Object to free.
! 617: * nextp = Name of "next" pointer in obj.
! 618: * clean = Undo for init.
! 619: * arg = Arg for undo func.
! 620: */
! 621: #define RF_FREELIST_FREE_CLEAN_ARG(_fl_,_obj_,_nextp_,_clean_,_arg_) \
! 622: do { \
! 623: RF_LOCK_MUTEX((_fl_)->lock); \
! 624: if ((_fl_)->free_cnt == (_fl_)->max_free_cnt) { \
! 625: _clean_(_obj_, _arg_); \
! 626: RF_Free(_obj_, (_fl_)->obj_size); \
! 627: } \
! 628: else { \
! 629: RF_ASSERT((_fl_)->free_cnt < (_fl_)->max_free_cnt); \
! 630: (_obj_)->_nextp_ = (_fl_)->objlist; \
! 631: (_fl_)->objlist = (void *)(_obj_); \
! 632: (_fl_)->free_cnt++; \
! 633: } \
! 634: RF_FREELIST_STAT_FREE(_fl_); \
! 635: RF_UNLOCK_MUTEX((_fl_)->lock); \
! 636: } while (0)
! 637:
! 638: /*
! 639: * fl = FreeList.
! 640: * obj = Object to free.
! 641: * nextp = Name of "next" pointer in obj.
! 642: * clean = Undo for init.
! 643: */
! 644: #define RF_FREELIST_FREE_CLEAN_NOUNLOCK(_fl_,_obj_,_nextp_,_clean_) \
! 645: do { \
! 646: RF_LOCK_MUTEX((_fl_)->lock); \
! 647: if ((_fl_)->free_cnt == (_fl_)->max_free_cnt) { \
! 648: _clean_(_obj_); \
! 649: RF_Free(_obj_, (_fl_)->obj_size); \
! 650: } \
! 651: else { \
! 652: RF_ASSERT((_fl_)->free_cnt < (_fl_)->max_free_cnt); \
! 653: (_obj_)->_nextp_ = (_fl_)->objlist; \
! 654: (_fl_)->objlist = (void *)(_obj_); \
! 655: (_fl_)->free_cnt++; \
! 656: } \
! 657: RF_FREELIST_STAT_FREE(_fl_); \
! 658: } while (0)
! 659:
! 660: /*
! 661: * fl = FreeList.
! 662: * nextp = Name of "next" pointer in obj.
! 663: * cast = Cast to object type.
! 664: */
! 665: #define RF_FREELIST_DESTROY(_fl_,_nextp_,_cast_) \
! 666: do { \
! 667: void *_cur, *_next; \
! 668: RF_FREELIST_STAT_REPORT(_fl_); \
! 669: rf_mutex_destroy(&((_fl_)->lock)); \
! 670: for (_cur = (_fl_)->objlist; _cur; _cur = _next) { \
! 671: _next = (_cast_ _cur)->_nextp_; \
! 672: RF_Free(_cur, (_fl_)->obj_size); \
! 673: } \
! 674: RF_Free(_fl_, sizeof(RF_FreeList_t)); \
! 675: } while (0)
! 676:
! 677: /*
! 678: * fl = FreeList.
! 679: * nextp = Name of "next" pointer in obj.
! 680: * cast = Cast to object type.
! 681: * clean = Func to undo obj init.
! 682: */
! 683: #define RF_FREELIST_DESTROY_CLEAN(_fl_,_nextp_,_cast_,_clean_) \
! 684: do { \
! 685: void *_cur, *_next; \
! 686: RF_FREELIST_STAT_REPORT(_fl_); \
! 687: rf_mutex_destroy(&((_fl_)->lock)); \
! 688: for (_cur = (_fl_)->objlist; _cur; _cur = _next) { \
! 689: _next = (_cast_ _cur)->_nextp_; \
! 690: _clean_(_cur); \
! 691: RF_Free(_cur, (_fl_)->obj_size); \
! 692: } \
! 693: RF_Free(_fl_, sizeof(RF_FreeList_t)); \
! 694: } while (0)
! 695:
! 696: /*
! 697: * fl = FreeList.
! 698: * nextp = Name of "next" pointer in obj.
! 699: * cast = Cast to object type.
! 700: * clean = Func to undo obj init.
! 701: * arg = Arg for undo func.
! 702: */
! 703: #define RF_FREELIST_DESTROY_CLEAN_ARG(_fl_,_nextp_,_cast_,_clean_,_arg_) \
! 704: do { \
! 705: void *_cur, *_next; \
! 706: RF_FREELIST_STAT_REPORT(_fl_); \
! 707: rf_mutex_destroy(&((_fl_)->lock)); \
! 708: for (_cur = (_fl_)->objlist; _cur; _cur = _next) { \
! 709: _next = (_cast_ _cur)->_nextp_; \
! 710: _clean_(_cur, _arg_); \
! 711: RF_Free(_cur, (_fl_)->obj_size); \
! 712: } \
! 713: RF_Free(_fl_, sizeof(RF_FreeList_t)); \
! 714: } while (0)
! 715:
! 716: #endif /* !_RF__RF_FREELIST_H_ */