From ed9a9aae3db7c6512095fee2996083b0199b830e Mon Sep 17 00:00:00 2001 From: kanoi Date: Thu, 29 Sep 2016 22:31:04 +1000 Subject: [PATCH] ckdb - handle culling in the klist code --- pool/page_ckp.php | 12 +++-- src/ckdb.c | 54 +++++++++-------------- src/ckdb.h | 16 ++++--- src/ckdb_cmd.c | 7 +-- src/ckdb_data.c | 7 +-- src/klist.c | 109 +++++++++++++++++++++++++++++----------------- src/klist.h | 16 +++---- 7 files changed, 120 insertions(+), 101 deletions(-) diff --git a/pool/page_ckp.php b/pool/page_ckp.php index 07fb370c..57c0f34f 100644 --- a/pool/page_ckp.php +++ b/pool/page_ckp.php @@ -16,7 +16,7 @@ function stnum($num) # function dockp($data, $user) { - $pg = '

CKPool

'; + $pg = '

CKDB

'; $msg = msgEncode('stats', 'stats', array(), $user); $rep = sendsockreply('stats', $msg); @@ -33,10 +33,11 @@ function dockp($data, $user) $pg .= "Name:<$r id=srtname data-sf=s0>"; $pg .= 'Initial'; $pg .= 'Allocated'; - $pg .= "<$r id=srtname data-sf=r3>:In Store"; - $pg .= "<$r id=srtname data-sf=r4>:RAM"; - $pg .= "<$r id=srtname data-sf=r5>:RAM2"; + $pg .= "<$r id=srtstore data-sf=r3>:In Store"; + $pg .= "<$r id=srtram data-sf=r4>:RAM"; + $pg .= "<$r id=srtram2 data-sf=r5>:RAM2"; $pg .= 'Cull'; + $pg .= 'Limit'; $pg .= "\n"; if ($ans['STATUS'] == 'ok') { @@ -57,11 +58,14 @@ function dockp($data, $user) $pg .= "".stnum($ans['ram:'.$i]).''; $pg .= "".stnum($ans['ram2:'.$i]).''; $pg .= ''.stnum($ans['cull:'.$i]).''; + $pg .= ''.stnum($ans['cull_limit:'.$i]).''; $pg .= "\n"; } $pg .= ''; } $pg .= "\n"; + $pg .= "\n"; return $pg; } diff --git a/src/ckdb.c b/src/ckdb.c index 78934f9f..778cb140 100644 --- a/src/ckdb.c +++ b/src/ckdb.c @@ -1962,8 +1962,9 @@ static void alloc_storage() ALLOC_LOGQUEUE, LIMIT_LOGQUEUE, true); logqueue_store = k_new_store(logqueue_free); - breakqueue_free = k_new_list("BreakQueue", sizeof(BREAKQUEUE), - ALLOC_BREAKQUEUE, LIMIT_BREAKQUEUE, true); + breakqueue_free = k_new_list_cull("BreakQueue", sizeof(BREAKQUEUE), + ALLOC_BREAKQUEUE, LIMIT_BREAKQUEUE, + true, CULL_BREAKQUEUE); reload_breakqueue_store = k_new_store(breakqueue_free); reload_done_breakqueue_store = k_new_store(breakqueue_free); cmd_breakqueue_store = k_new_store(breakqueue_free); @@ -2017,16 +2018,19 @@ static void alloc_storage() } } - seqtrans_free = k_new_list("SeqTrans", sizeof(SEQTRANS), - ALLOC_SEQTRANS, LIMIT_SEQTRANS, true); + seqtrans_free = k_new_list_cull("SeqTrans", sizeof(SEQTRANS), + ALLOC_SEQTRANS, LIMIT_SEQTRANS, true, + CULL_SEQTRANS); - msgline_free = k_new_list("MsgLine", sizeof(MSGLINE), - ALLOC_MSGLINE, LIMIT_MSGLINE, true); + msgline_free = k_new_list_cull("MsgLine", sizeof(MSGLINE), + ALLOC_MSGLINE, LIMIT_MSGLINE, true, + CULL_MSGLINE); msgline_store = k_new_store(msgline_free); msgline_free->dsp_func = dsp_msgline; - workqueue_free = k_new_list("WorkQueue", sizeof(WORKQUEUE), - ALLOC_WORKQUEUE, LIMIT_WORKQUEUE, true); + workqueue_free = k_new_list_cull("WorkQueue", sizeof(WORKQUEUE), + ALLOC_WORKQUEUE, LIMIT_WORKQUEUE, + true, CULL_WORKQUEUE); pool0_workqueue_store = k_new_store(workqueue_free); pool_workqueue_store = k_new_store(workqueue_free); cmd_workqueue_store = k_new_store(workqueue_free); @@ -2045,8 +2049,9 @@ static void alloc_storage() LIMIT_HEARTBEATQUEUE, true); heartbeatqueue_store = k_new_store(heartbeatqueue_free); - transfer_free = k_new_list(Transfer, sizeof(TRANSFER), - ALLOC_TRANSFER, LIMIT_TRANSFER, true); + transfer_free = k_new_list_cull(Transfer, sizeof(TRANSFER), + ALLOC_TRANSFER, LIMIT_TRANSFER, true, + CULL_TRANSFER); transfer_free->dsp_func = dsp_transfer; users_free = k_new_list("Users", sizeof(USERS), @@ -3097,9 +3102,6 @@ static void trans_seq(tv_t *now) if (store->count) { K_WLOCK(seqtrans_free); k_list_transfer_to_head(store, seqtrans_free); - if (seqtrans_free->count == seqtrans_free->total && - seqtrans_free->total >= ALLOC_SEQTRANS * CULL_SEQTRANS) - k_cull_list(seqtrans_free); K_WUNLOCK(seqtrans_free); } } @@ -3878,9 +3880,6 @@ setitemdata: } K_WLOCK(seqtrans_free); k_list_transfer_to_head(lost, seqtrans_free); - if (seqtrans_free->count == seqtrans_free->total && - seqtrans_free->total >= ALLOC_SEQTRANS * CULL_SEQTRANS) - k_cull_list(seqtrans_free); K_WUNLOCK(seqtrans_free); } @@ -4772,10 +4771,6 @@ static void *breaker(void *arg) pthread_cond_signal(&process_socket_waitcond); mutex_unlock(&process_socket_waitlock); } - - if (breakqueue_free->count == breakqueue_free->total && - breakqueue_free->total >= ALLOC_BREAKQUEUE * CULL_BREAKQUEUE) - k_cull_list(breakqueue_free); K_WUNLOCK(breakqueue_free); } @@ -6083,7 +6078,7 @@ static void process_sockd(PGconn *conn, K_ITEM *wq_item, enum reply_type reply_t K_WUNLOCK(breakqueue_free); FREENULL(ans); - free_msgline_data(ml_item, true, true); + free_msgline_data(ml_item, true); K_WLOCK(msgline_free); msgline_free->ram -= msgline->msgsiz; k_add_head(msgline_free, ml_item); @@ -6091,9 +6086,6 @@ static void process_sockd(PGconn *conn, K_ITEM *wq_item, enum reply_type reply_t K_WLOCK(workqueue_free); k_add_head(workqueue_free, wq_item); - if (workqueue_free->count == workqueue_free->total && - workqueue_free->total >= ALLOC_WORKQUEUE * CULL_WORKQUEUE) - k_cull_list(workqueue_free); K_WUNLOCK(workqueue_free); tick(); @@ -6755,7 +6747,7 @@ static void *process_socket(__maybe_unused void *arg) K_ITEM *ml_item = wq->msgline_item; MSGLINE *ml; DATA_MSGLINE(ml, ml_item); - free_msgline_data(ml_item, true, false); + free_msgline_data(ml_item, true); K_WLOCK(msgline_free); msgline_free->ram -= ml->msgsiz; k_add_head(msgline_free, ml_item); @@ -6798,7 +6790,7 @@ skippy: if (bq->ml_item) { MSGLINE *ml; DATA_MSGLINE(ml, bq->ml_item); - free_msgline_data(bq->ml_item, true, true); + free_msgline_data(bq->ml_item, true); K_WLOCK(msgline_free); msgline_free->ram -= ml->msgsiz; k_add_head(msgline_free, bq->ml_item); @@ -7158,7 +7150,7 @@ static void process_reload_item(PGconn *conn, K_ITEM *bq_item) if (bq->ml_item) { DATA_MSGLINE(msgline, bq->ml_item); - free_msgline_data(bq->ml_item, true, true); + free_msgline_data(bq->ml_item, true); K_WLOCK(msgline_free); msgline_free->ram -= msgline->msgsiz; k_add_head(msgline_free, bq->ml_item); @@ -7797,7 +7789,7 @@ static void process_queued(PGconn *conn, K_ITEM *wq_item) break; } - free_msgline_data(ml_item, true, true); + free_msgline_data(ml_item, true); K_WLOCK(msgline_free); msgline_free->ram -= msgline->msgsiz; k_add_head(msgline_free, ml_item); @@ -7805,9 +7797,6 @@ static void process_queued(PGconn *conn, K_ITEM *wq_item) K_WLOCK(workqueue_free); k_add_head(workqueue_free, wq_item); - if (workqueue_free->count == workqueue_free->total && - workqueue_free->total >= ALLOC_WORKQUEUE * CULL_WORKQUEUE) - k_cull_list(workqueue_free); K_WUNLOCK(workqueue_free); } @@ -7816,9 +7805,6 @@ static void free_lost(SEQDATA *seqdata) if (seqdata->reload_lost) { K_WLOCK(seqtrans_free); k_list_transfer_to_head(seqdata->reload_lost, seqtrans_free); - if (seqtrans_free->count == seqtrans_free->total && - seqtrans_free->total >= ALLOC_SEQTRANS * CULL_SEQTRANS) - k_cull_list(seqtrans_free); K_WUNLOCK(seqtrans_free); seqdata->reload_lost = NULL; } diff --git a/src/ckdb.h b/src/ckdb.h index eeb759f8..c22a4334 100644 --- a/src/ckdb.h +++ b/src/ckdb.h @@ -58,7 +58,7 @@ #define DB_VLOCK "1" #define DB_VERSION "1.0.7" -#define CKDB_VERSION DB_VERSION"-2.513" +#define CKDB_VERSION DB_VERSION"-2.514" #define WHERE_FFL " - from %s %s() line %d" #define WHERE_FFL_HERE __FILE__, __func__, __LINE__ @@ -1370,7 +1370,7 @@ typedef struct msgline { #define ALLOC_MSGLINE 8192 #define LIMIT_MSGLINE 0 -#define CULL_MSGLINE 8 +#define CULL_MSGLINE (8 * ALLOC_MSGLINE) #define INIT_MSGLINE(_item) INIT_GENERIC(_item, msgline) #define DATA_MSGLINE(_var, _item) DATA_GENERIC(_var, _item, msgline, true) #define DATA_MSGLINE_NULL(_var, _item) DATA_GENERIC(_var, _item, msgline, false) @@ -1396,7 +1396,7 @@ typedef struct breakqueue { #define ALLOC_BREAKQUEUE 16384 #define LIMIT_BREAKQUEUE 0 -#define CULL_BREAKQUEUE 4 +#define CULL_BREAKQUEUE (4 * ALLOC_BREAKQUEUE) #define INIT_BREAKQUEUE(_item) INIT_GENERIC(_item, breakqueue) #define DATA_BREAKQUEUE(_var, _item) DATA_GENERIC(_var, _item, breakqueue, true) @@ -1463,7 +1463,7 @@ typedef struct workqueue { #define ALLOC_WORKQUEUE 1024 #define LIMIT_WORKQUEUE 0 -#define CULL_WORKQUEUE 32 +#define CULL_WORKQUEUE (32 * ALLOC_WORKQUEUE) #define INIT_WORKQUEUE(_item) INIT_GENERIC(_item, workqueue) #define DATA_WORKQUEUE(_var, _item) DATA_GENERIC(_var, _item, workqueue, true) @@ -1563,7 +1563,9 @@ typedef struct transfer { // Suggest malloc use MMAP = largest under 2MB #define ALLOC_TRANSFER ((int)(2*1024*1024/sizeof(TRANSFER))) #define LIMIT_TRANSFER 0 -#define CULL_TRANSFER 16 +/* ALLOC_TRANSFER is ~14k, but it should only ever get this big during a reload + * so set it a bit above that */ +#define CULL_TRANSFER 32768 #define INIT_TRANSFER(_item) INIT_GENERIC(_item, transfer) #define DATA_TRANSFER(_var, _item) DATA_GENERIC(_var, _item, transfer, true) @@ -1787,7 +1789,7 @@ extern K_LIST *seqtrans_free; #define ALLOC_SEQTRANS 1024 #define LIMIT_SEQTRANS 0 -#define CULL_SEQTRANS 64 +#define CULL_SEQTRANS (16 * ALLOC_SEQTRANS) #define INIT_SEQTRANS(_item) INIT_GENERIC(_item, seqtrans) #define DATA_SEQTRANS(_var, _item) DATA_GENERIC(_var, _item, seqtrans, true) #define DATA_SEQTRANS_NULL(_var, _item) DATA_GENERIC(_var, _item, seqtrans, false) @@ -3227,7 +3229,7 @@ extern void sequence_report(bool lock); #define FREE_ITEM(item) do { } while(0) // TODO: make a macro for all other to use above macro extern void free_transfer_data(TRANSFER *transfer); -extern void free_msgline_data(K_ITEM *item, bool t_lock, bool t_cull); +extern void free_msgline_data(K_ITEM *item, bool t_lock); extern void free_users_data(K_ITEM *item); extern void free_workinfo_data(K_ITEM *item); #define free_sharesummary_data(_i) FREE_ITEM(_i) diff --git a/src/ckdb_cmd.c b/src/ckdb_cmd.c index ae6c436f..e536802d 100644 --- a/src/ckdb_cmd.c +++ b/src/ckdb_cmd.c @@ -6032,7 +6032,7 @@ static char *cmd_stats(__maybe_unused PGconn *conn, char *cmd, char *id, snprintf(tmp, sizeof(tmp), "name:%d=%s%s%s%cinitial:%d=%d%callocated:%d=%d%c" "instore:%d=%d%cram:%d=%"PRIu64"%c" - "ram2:%d=%"PRIu64"%ccull:%d=%d%c", + "ram2:%d=%"PRIu64"%ccull:%d=%d%ccull_limit:%d=%d%c", rows, name, istree ? " (tree)" : "", klist->is_lock_only ? " (lock)" : "", FLDSEP, rows, klist->allocate, FLDSEP, @@ -6040,7 +6040,8 @@ static char *cmd_stats(__maybe_unused PGconn *conn, char *cmd, char *id, rows, klist->total - klist->count, FLDSEP, rows, ram, FLDSEP, rows, ram2, FLDSEP, - rows, klist->cull_count, FLDSEP); + rows, klist->cull_count, FLDSEP, + rows, klist->cull_limit, FLDSEP); APPEND_REALLOC(buf, off, len, tmp); tot += ram + ram2; @@ -6056,7 +6057,7 @@ static char *cmd_stats(__maybe_unused PGconn *conn, char *cmd, char *id, snprintf(tmp, sizeof(tmp), "rows=%d%cflds=%s%c", rows, FLDSEP, - "name,initial,allocated,instore,ram,cull", FLDSEP); + "name,initial,allocated,instore,ram,cull,cull_limit", FLDSEP); APPEND_REALLOC(buf, off, len, tmp); snprintf(tmp, sizeof(tmp), "arn=%s%carp=%s", "Stats", FLDSEP, ""); diff --git a/src/ckdb_data.c b/src/ckdb_data.c index 4b2d3280..905cf5bb 100644 --- a/src/ckdb_data.c +++ b/src/ckdb_data.c @@ -18,7 +18,7 @@ void free_transfer_data(TRANSFER *transfer) FREENULL(transfer->mvalue); } -void free_msgline_data(K_ITEM *item, bool t_lock, bool t_cull) +void free_msgline_data(K_ITEM *item, bool t_lock) { K_ITEM *t_item = NULL; TRANSFER *transfer; @@ -40,11 +40,6 @@ void free_msgline_data(K_ITEM *item, bool t_lock, bool t_cull) K_WLOCK(transfer_free); transfer_free->ram -= ram2; k_list_transfer_to_head(msgline->trf_store, transfer_free); - if (t_cull) { - if (transfer_free->count == transfer_free->total && - transfer_free->total >= ALLOC_TRANSFER * CULL_TRANSFER) - k_cull_list(transfer_free); - } if (t_lock) K_WUNLOCK(transfer_free); msgline->trf_store = k_free_store(msgline->trf_store); diff --git a/src/klist.c b/src/klist.c index d1f65ae0..a33a7e9c 100644 --- a/src/klist.c +++ b/src/klist.c @@ -213,7 +213,8 @@ K_STORE *_k_new_store(K_LIST *list, KLIST_FFL_ARGS) K_LIST *_k_new_list(const char *name, size_t siz, int allocate, int limit, bool do_tail, bool lock_only, bool without_lock, - bool local_list, const char *name2, KLIST_FFL_ARGS) + bool local_list, const char *name2, int cull_limit, + KLIST_FFL_ARGS) { K_LIST *list; @@ -223,6 +224,11 @@ K_LIST *_k_new_list(const char *name, size_t siz, int allocate, int limit, if (limit < 0) quithere(1, "Invalid new list %s with limit %d must be >= 0", name, limit); + /* after culling, the first block of items are again allocated, + * so there's no point culling a single block of items */ + if (cull_limit > 0 && cull_limit <= allocate) + quithere(1, "Invalid new list %s with cull_limit %d must be > allocate (%d)", name, cull_limit, allocate); + list = calloc(1, sizeof(*list)); if (!list) quithere(1, "Failed to calloc list %s", name); @@ -248,6 +254,7 @@ K_LIST *_k_new_list(const char *name, size_t siz, int allocate, int limit, list->allocate = allocate; list->limit = limit; list->do_tail = do_tail; + list->cull_limit = cull_limit; if (!(list->is_lock_only)) k_alloc_items(list, KLIST_FFL_PASS); @@ -360,6 +367,58 @@ K_ITEM *_k_unlink_tail(K_LIST *list, LOCK_MAYBE bool chklock, KLIST_FFL_ARGS) return item; } +#define CHKCULL(_list) \ + do { \ + if (!((_list)->is_store) && !((_list)->is_lock_only) && \ + (_list)->cull_limit > 0 && \ + (_list)->count == (_list)->total && \ + (_list)->total >= (_list)->cull_limit) { \ + k_cull_list(_list, file, func, line); \ + } \ + } while(0); + +static void k_cull_list(K_LIST *list, KLIST_FFL_ARGS) +{ + int i; + + CHKLIST(list); + _LIST_WRITE(list, true, file, func, line); + + if (list->is_store) { + quithere(1, "List %s can't %s() a store" KLIST_FFL, + list->name, __func__, KLIST_FFL_PASS); + } + + if (list->is_lock_only) { + quithere(1, "List %s can't %s() a lock_only" KLIST_FFL, + list->name, __func__, KLIST_FFL_PASS); + } + + if (list->count != list->total) { + quithere(1, "List %s can't %s() a list in use" KLIST_FFL, + list->name, __func__, KLIST_FFL_PASS); + } + + for (i = 0; i < list->item_mem_count; i++) + free(list->item_memory[i]); + free(list->item_memory); + list->item_memory = NULL; + list->item_mem_count = 0; + + for (i = 0; i < list->data_mem_count; i++) + free(list->data_memory[i]); + free(list->data_memory); + list->data_memory = NULL; + list->data_mem_count = 0; + + list->total = list->count = list->count_up = 0; + list->head = list->tail = NULL; + + list->cull_count++; + + k_alloc_items(list, KLIST_FFL_PASS); +} + void _k_add_head(K_LIST *list, K_ITEM *item, LOCK_MAYBE bool chklock, KLIST_FFL_ARGS) { CHKLS(list); @@ -390,6 +449,8 @@ void _k_add_head(K_LIST *list, K_ITEM *item, LOCK_MAYBE bool chklock, KLIST_FFL_ list->count++; list->count_up++; + + CHKCULL(list); } /* slows it down (of course) - only for debugging @@ -437,6 +498,8 @@ void _k_add_tail(K_LIST *list, K_ITEM *item, LOCK_MAYBE bool chklock, KLIST_FFL_ list->count++; list->count_up++; + + CHKCULL(list); } // Insert item into the list next after 'after' @@ -475,6 +538,8 @@ void _k_insert_after(K_LIST *list, K_ITEM *item, K_ITEM *after, LOCK_MAYBE bool list->count++; list->count_up++; + + // no point checking cull since this wouldn't be an _free list } void _k_unlink_item(K_LIST *list, K_ITEM *item, LOCK_MAYBE bool chklock, KLIST_FFL_ARGS) @@ -541,6 +606,8 @@ void _k_list_transfer_to_head(K_LIST *from, K_LIST *to, LOCK_MAYBE bool chklock, from->count = 0; to->count_up += from->count_up; from->count_up = 0; + + CHKCULL(to); } void _k_list_transfer_to_tail(K_LIST *from, K_LIST *to, LOCK_MAYBE bool chklock, KLIST_FFL_ARGS) @@ -577,6 +644,8 @@ void _k_list_transfer_to_tail(K_LIST *from, K_LIST *to, LOCK_MAYBE bool chklock, from->count = 0; to->count_up += from->count_up; from->count_up = 0; + + CHKCULL(to); } K_LIST *_k_free_list(K_LIST *list, KLIST_FFL_ARGS) @@ -655,41 +724,3 @@ K_STORE *_k_free_store(K_STORE *store, KLIST_FFL_ARGS) return NULL; } - -// Must be locked and none in use and/or unlinked -void _k_cull_list(K_LIST *list, LOCK_MAYBE bool chklock, KLIST_FFL_ARGS) -{ - int i; - - CHKLIST(list); - _LIST_WRITE(list, chklock, file, func, line); - - if (list->is_store) { - quithere(1, "List %s can't %s() a store" KLIST_FFL, - list->name, __func__, KLIST_FFL_PASS); - } - - if (list->count != list->total) { - quithere(1, "List %s can't %s() a list in use" KLIST_FFL, - list->name, __func__, KLIST_FFL_PASS); - } - - for (i = 0; i < list->item_mem_count; i++) - free(list->item_memory[i]); - free(list->item_memory); - list->item_memory = NULL; - list->item_mem_count = 0; - - for (i = 0; i < list->data_mem_count; i++) - free(list->data_memory[i]); - free(list->data_memory); - list->data_memory = NULL; - list->data_mem_count = 0; - - list->total = list->count = list->count_up = 0; - list->head = list->tail = NULL; - - list->cull_count++; - - k_alloc_items(list, KLIST_FFL_PASS); -} diff --git a/src/klist.h b/src/klist.h index eb9e6dc7..ee8a021f 100644 --- a/src/klist.h +++ b/src/klist.h @@ -151,7 +151,8 @@ typedef struct k_list { int data_mem_count; // how many item data memory buffers have been allocated void **data_memory; // allocated item data memory buffers void (*dsp_func)(K_ITEM *, FILE *); // optional data display to a file - int cull_count; + int cull_limit; // <1 means don't cull, otherwise total to cull at + int cull_count; // number of times culled uint64_t ram; // ram allocated for data pointers - code must manage it int stores; // how many stores it currently has #if LOCK_CHECK @@ -670,13 +671,15 @@ extern K_STORE *_k_new_store(K_LIST *list, KLIST_FFL_ARGS); extern K_LIST *_k_new_list(const char *name, size_t siz, int allocate, int limit, bool do_tail, bool lock_only, bool without_lock, bool local_list, - const char *name2, KLIST_FFL_ARGS); + const char *name2, int cull_limit, KLIST_FFL_ARGS); #define k_new_list(_name, _siz, _allocate, _limit, _do_tail) \ - _k_new_list(_name, _siz, _allocate, _limit, _do_tail, false, false, false, NULL, KLIST_FFL_HERE) + _k_new_list(_name, _siz, _allocate, _limit, _do_tail, false, false, false, NULL, 0, KLIST_FFL_HERE) #define k_lock_only_list(_name) \ - _k_new_list(_name, 1, 1, 1, true, true, false, false, NULL, KLIST_FFL_HERE) + _k_new_list(_name, 1, 1, 1, true, true, false, false, NULL, 0, KLIST_FFL_HERE) #define k_new_tree_list(_name, _siz, _allocate, _limit, _do_tail, _local_tree, _name2) \ - _k_new_list(_name, _siz, _allocate, _limit, _do_tail, false, true, _local_tree, _name2, KLIST_FFL_HERE) + _k_new_list(_name, _siz, _allocate, _limit, _do_tail, false, true, _local_tree, _name2, 0, KLIST_FFL_HERE) +#define k_new_list_cull(_name, _siz, _allocate, _limit, _do_tail, _cull) \ + _k_new_list(_name, _siz, _allocate, _limit, _do_tail, false, false, false, NULL, _cull, KLIST_FFL_HERE) extern K_ITEM *_k_unlink_head(K_LIST *list, LOCK_MAYBE bool chklock, KLIST_FFL_ARGS); #define k_unlink_head(_list) _k_unlink_head(_list, true, KLIST_FFL_HERE) #define k_unlink_head_nolock(_list) _k_unlink_head(_list, false, KLIST_FFL_HERE) @@ -711,8 +714,5 @@ extern K_LIST *_k_free_list(K_LIST *list, KLIST_FFL_ARGS); #define k_free_list(_list) _k_free_list(_list, KLIST_FFL_HERE) extern K_STORE *_k_free_store(K_STORE *store, KLIST_FFL_ARGS); #define k_free_store(_store) _k_free_store(_store, KLIST_FFL_HERE) -extern void _k_cull_list(K_LIST *list, LOCK_MAYBE bool chklock, KLIST_FFL_ARGS); -#define k_cull_list(_list) _k_cull_list(_list, true, KLIST_FFL_HERE) -//#define k_cull_list_nolock(_list) _k_cull_list(_list, false, KLIST_FFL_HERE) #endif