diff --git a/c/Makefile b/c/Makefile index 56e4580..623fa85 100644 --- a/c/Makefile +++ b/c/Makefile @@ -1,6 +1,6 @@ # Tools Makefile # -# Copyright (C) 2022 Bruno Raoult ("br") +# Copyright (C) 2023 Bruno Raoult ("br") # Licensed under the GNU General Public License v3.0 or later. # Some rights reserved. See COPYING. # @@ -10,81 +10,50 @@ # SPDX-License-Identifier: GPL-3.0-or-later # -SHELL := /bin/bash -CC := gcc - -CFLAGS += -std=gnu11 -CFLAGS += -O2 -CFLAGS += -g -CFLAGS += -Wall -CFLAGS += -Wextra -CFLAGS += -march=native -CFLAGS += -Wmissing-declarations -CFLAGS += -Wno-unused-result +SHELL := /bin/bash +CC := gcc +BEAR := bear +CFLAGS += -std=gnu11 +CFLAGS += -O2 +CFLAGS += -g +CFLAGS += -Wall +CFLAGS += -Wextra +CFLAGS += -march=native +CFLAGS += -Wmissing-declarations +CFLAGS += -Wno-unused-result # for gprof -#CFLAGS += -pg - +#CFLAGS += -pg # Next one may be useful for valgrind (some invalid instructions) -# CFLAGS += -mno-tbm +#CFLAGS += -mno-tbm -CFLAGS += -DDEBUG_DEBUG # activate general debug (debug.c) -CFLAGS += -DDEBUG_POOL # memory pools management +CPPFLAGS += -DDEBUG_DEBUG # activate general debug (debug.c) +CPPFLAGS += -DDEBUG_POOL # memory pools management INCDIR := ./include LIBDIR := ./lib OBJDIR := ./obj +BRLIBDIR := ./brlib LIBNAME := br_$(shell uname -m) -LIB := lib$(LIBNAME) -SLIB := $(LIBDIR)/$(LIB).a -DLIB := $(LIBDIR)/$(LIB).so -LIBSRC := $(wildcard *.c) -LIBOBJ := $(addprefix $(OBJDIR)/,$(patsubst %.c,%.o,$(LIBSRC))) -LDFLAGS := -L$(LIBDIR) -LDLIB := -l$(LIB) +#LIB := lib$(LIBNAME) -export LD_LIBRARY_PATH = $(LIBDIR) -.PHONY: all libs clean dirs bear +all: brlib -all: libs +#export LD_LIBRARY_PATH = $(LIBDIR) -libs: dirs $(DLIB) $(SLIB) +.PHONY: all brlib clean -dirs: $(LIBDIR) $(OBJDIR) +all: brlib -$(LIBDIR) $(OBJDIR): - @echo creating $@ directory. - @mkdir $@ +brlib: + $(MAKE) -C $(BRLIBDIR) + +bear ccls: + @echo building ccls language server compilation database + $(MAKE) -C $(BRLIBDIR) ccls clean: - @echo deleting $(OBJDIR) and $(LIBDIR) directories. - @$(RM) -rf $(LIBDIR) $(OBJDIR) - -$(SLIB): $(LIBOBJ) - @echo building $@ static library. - @$(AR) $(ARFLAGS) -o $@ $^ - -$(DLIB): CFLAGS += -fPIC -$(DLIB): LDFLAGS += -shared -$(DLIB): $(LIBOBJ) - @echo building $@ shared library. - @$(CC) $(LDFLAGS) $^ -o $@ - -.c: - @echo compiling $< - @$(CC) $(CFLAGS) $(LDFLAGS) -I $(INCDIR) $< $(LDLIB) -o $@ - -#.c.o: -$(OBJDIR)/%.o: %.c - @echo compiling $<. - @$(CC) -c $(CFLAGS) $(LDFLAGS) -I $(INCDIR) -o $@ $< - -.c.s: - @echo generating $@ - @$(CC) -S -fverbose-asm $(CFLAGS) -I $(INCDIR) $< -o $@ - -bear: clean - @echo building ccls language server compilation database - @bear -- make + @echo cleaning brlib. + @$(MAKE) -C $(BRLIBDIR) clean diff --git a/c/bits.c b/c/bits.c deleted file mode 100644 index bd4282e..0000000 --- a/c/bits.c +++ /dev/null @@ -1,91 +0,0 @@ -/* bits.c - information about bitops implementation. - * - * Copyright (C) 2021-2022 Bruno Raoult ("br") - * Licensed under the GNU General Public License v3.0 or later. - * Some rights reserved. See COPYING. - * - * You should have received a copy of the GNU General Public License along with this - * program. If not, see . - * - * SPDX-License-Identifier: GPL-3.0-or-later - * - */ - -#include "bits.h" -#include "debug.h" - -/** - * bits_implementation - display bitops implementation. - * - * For basic bitops (popcount, ctz, etc...), print the implementation - * (builtin, emulated). - */ -void bits_implementation(void) -{ - log(0, "bitops implementation: "); - - log(0, "popcount64: "); -# if __has_builtin(__builtin_popcountl) - log(0, "builtin, "); -# else - log(0, "emulated, "); -# endif - - log(0, "popcount32: "); -# if __has_builtin(__builtin_popcount) - log(0, "builtin, "); -# else - log(0, "emulated, "); -# endif - - log(0, "ctz64: "); -# if __has_builtin(__builtin_ctzl) - log(0, "builtin, "); -# elif __has_builtin(__builtin_clzl) - log(0, "builtin (clzl), "); -# else - log(0, "emulated, "); -# endif - - log(0, "ctz32: "); -# if __has_builtin(__builtin_ctz) - log(0, "builtin, "); -# elif __has_builtin(__builtin_clz) - log(0, "builtin (clz), "); -# else - log(0, "emulated, "); -# endif - - log(0, "clz64: "); -# if __has_builtin(__builtin_clzl) - log(0, "builtin, "); -# else - log(0, "emulated, "); -# endif - - log(0, "clz32: "); -# if __has_builtin(__builtin_clz) - log(0, "builtin, "); -# else - log(0, "emulated, "); -# endif - - log(0, "ffs64: "); -# if __has_builtin(__builtin_ffsl) - log(0, "builtin, "); -# elif __has_builtin(__builtin_ctzl) - log(0, "builtin (ctzl), "); -# else - log(0, "emulated, "); -# endif - - log(0, "ffs32: "); -# if __has_builtin(__builtin_ffs) - log(0, "builtin, "); -# elif __has_builtin(__builtin_ctz) - log(0, "builtin (ctzl), "); -# else - log(0, "emulated, "); -# endif - log(0, "\n"); -} diff --git a/c/brlib/include/debug.h b/c/brlib/include/debug.h index 3619f24..60c6447 100644 --- a/c/brlib/include/debug.h +++ b/c/brlib/include/debug.h @@ -1,6 +1,6 @@ /* debug.h - debug/log management. * - * Copyright (C) 2021-2022 Bruno Raoult ("br") + * Copyright (C) 2021-2023 Bruno Raoult ("br") * Licensed under the GNU General Public License v3.0 or later. * Some rights reserved. See COPYING. * @@ -14,29 +14,45 @@ #ifndef DEBUG_H #define DEBUG_H +#include #include #include -#include +#include + +#define NANOSEC 1000000000 /* nano sec in sec */ +#define MILLISEC 1000000 /* milli sec in sec */ -#define _unused __attribute__((__unused__)) #define _printf __attribute__ ((format (printf, 6, 7))) #ifdef DEBUG_DEBUG -void debug_init(u32 level); -void debug_level_set(u32 level); -u32 debug_level_get(void); -void _printf debug(u32 level, bool timestamp, - u32 indent, const char *src, - u32 line, const char *fmt, ...); + +void debug_init(int level, FILE *stream, bool flush); +void debug_level_set(int level); +int debug_level_get(void); +void debug_stream_set(FILE *stream); +long long debug_timer_elapsed(void); +void debug_flush_set(bool flush); +void _printf debug(int level, bool timestamp, + int indent, const char *src, + int line, const char *fmt, ...); + #else /* DEBUG_DEBUG */ -static inline void debug_init(_unused u32 level) {} -static inline void debug_level_set(_unused u32 level) {} -static inline void _printf debug(_unused u32 level, _unused bool timestamp, - _unused u32 indent, _unused const char *src, - _unused u32 line, _unused const char *fmt, ...) {} + +static inline void debug_init(__unused int level, + __unused FILE *stream, + __unused bool flush) {} +static inline void debug_level_set(__unused int level) {} +static inline int debug_level_get(void) {return 0;} +static inline void debug_stream_set(__unused FILE *stream) {} +static inline long long debug_timer_elapsed(void) {return 0LL;} +static inline void debug_flush_set(__unused bool level) {} +static inline void _printf debug(__unused int level, __unused bool timestamp, + __unused int indent, __unused const char *src, + __unused int line, __unused const char *fmt, ...) {} + #endif /* DEBUG_DEBUG */ -#undef _unused + #undef _printf /** diff --git a/c/brlib/src/debug.c b/c/brlib/src/debug.c index ac1d2a6..ad7d665 100644 --- a/c/brlib/src/debug.c +++ b/c/brlib/src/debug.c @@ -1,6 +1,6 @@ /* debug.c - debug/log management * - * Copyright (C) 2021-2022 Bruno Raoult ("br") + * Copyright (C) 2021-2023 Bruno Raoult ("br") * Licensed under the GNU General Public License v3.0 or later. * Some rights reserved. See COPYING. * @@ -19,27 +19,57 @@ #define DEBUG_DEBUG #endif -#include "bits.h" #include "debug.h" -#define NANOSEC 1000000000 /* nano sec in sec */ -#define MILLISEC 1000000 /* milli sec in sec */ - static long long timer_start; /* in nanosecond */ -static u32 debug_level=0; +static int level = 0; /* output log when < level */ +static int flush = false; /* force flush after logs */ +static FILE *stream = NULL; /* stream to use */ -void debug_level_set(u32 level) +/** + * debug_level_set() - set debug level. + * @_level: debug level (integer). + */ +void debug_level_set(int _level) { - debug_level = level; - - log(1, "debug level set to %u\n", level); + level = _level; +# ifdef DEBUG_DEBUG_C + log(0, "debug level set to %u\n", level); +# endif } -void debug_init(u32 level) +/** + * debug_level_get() - get debug level. + * @return: current level debug (integer). + */ +int debug_level_get(void) +{ + return level; +} + +void debug_stream_set(FILE *_stream) +{ + stream = _stream; +# ifdef DEBUG_DEBUG_C + log(0, "stream set to %d\n", stream? fileno(stream): -1); +# endif +} + +void debug_flush_set(bool _flush) +{ + flush = _flush; +# ifdef DEBUG_DEBUG_C + log(0, "debug flush %s.\n", flush? "set": "unset"); +# endif +} + +void debug_init(int _level, FILE *_stream, bool _flush) { struct timespec timer; - debug_level_set(level); + debug_stream_set(_stream); + debug_level_set(_level); + debug_flush_set(_flush); if (!clock_gettime(CLOCK_MONOTONIC, &timer)) { timer_start = timer.tv_sec * NANOSEC + timer.tv_nsec; } @@ -49,7 +79,7 @@ void debug_init(u32 level) log(0, "timer started.\n"); } -inline static long long timer_elapsed() +long long debug_timer_elapsed(void) { struct timespec timer; @@ -57,38 +87,42 @@ inline static long long timer_elapsed() return (timer.tv_sec * NANOSEC + timer.tv_nsec) - timer_start; } -/* void debug - log function - * @timestamp : boolean - * @indent : indent level (2 spaces each) - * @src : source file/func name (or NULL) - * @line : line number +/** + * debug() - log function + * @lev: log level + * @timestamp: boolean, print timestamp if true + * @indent: indent level (2 spaces each) + * @src: source file/func name (or NULL) + * @line: line number */ -void debug(u32 level, bool timestamp, u32 indent, const char *src, - u32 line, const char *fmt, ...) +void debug(int lev, bool timestamp, int indent, const char *src, + int line, const char *fmt, ...) { - if (level > debug_level) + if (!stream || lev > level) return; va_list ap; if (indent) - printf("%*s", 2*(indent-1), ""); + fprintf(stream, "%*s", 2*(indent-1), ""); if (timestamp) { - long long diff = timer_elapsed(); - printf("%lld.%03lld ", diff/NANOSEC, (diff/1000000)%1000); - printf("%010lld ", diff); + long long diff = debug_timer_elapsed(); + fprintf(stream, "%lld.%03lld ", diff/NANOSEC, (diff/1000000)%1000); + fprintf(stream, "%010lld ", diff); } if (src) { if (line) - printf("[%s:%u] ", src, line); + fprintf(stream, "[%s:%u] ", src, line); else - printf("[%s] ", src); + fprintf(stream, "[%s] ", src); } va_start(ap, fmt); - vprintf(fmt, ap); + vfprintf(stream, fmt, ap); va_end(ap); + if (flush) + fflush(stream); } #ifdef BIN_debug diff --git a/c/brlib/todo/list_sort.c b/c/brlib/todo/list_sort.c new file mode 100644 index 0000000..79180ea --- /dev/null +++ b/c/brlib/todo/list_sort.c @@ -0,0 +1,253 @@ +// SPDX-License-Identifier: GPL-2.0 + +/* + * Taken from linux kernel: lib/list_sort.c + */ +#include "list_sort.h" +#include "list.h" +#include "bits.h" +#include "likely.h" + +/* + * Returns a list organized in an intermediate format suited + * to chaining of merge() calls: null-terminated, no reserved or + * sentinel head node, "prev" links not maintained. + */ +__attribute__((nonnull(2,3,4))) +static struct list_head *merge(void *priv, list_cmp_func_t cmp, + struct list_head *a, struct list_head *b) +{ + struct list_head *head, **tail = &head; + + for (;;) { + /* if equal, take 'a' -- important for sort stability */ + if (cmp(priv, a, b) <= 0) { + *tail = a; + tail = &a->next; + a = a->next; + if (!a) { + *tail = b; + break; + } + } else { + *tail = b; + tail = &b->next; + b = b->next; + if (!b) { + *tail = a; + break; + } + } + } + return head; +} + +/* + * Combine final list merge with restoration of standard doubly-linked + * list structure. This approach duplicates code from merge(), but + * runs faster than the tidier alternatives of either a separate final + * prev-link restoration pass, or maintaining the prev links + * throughout. + */ +__attribute__((nonnull(2,3,4,5))) +static void merge_final(void *priv, list_cmp_func_t cmp, struct list_head *head, + struct list_head *a, struct list_head *b) +{ + struct list_head *tail = head; + u8 count = 0; + + for (;;) { + /* if equal, take 'a' -- important for sort stability */ + if (cmp(priv, a, b) <= 0) { + tail->next = a; + a->prev = tail; + tail = a; + a = a->next; + if (!a) + break; + } else { + tail->next = b; + b->prev = tail; + tail = b; + b = b->next; + if (!b) { + b = a; + break; + } + } + } + + /* Finish linking remainder of list b on to tail */ + tail->next = b; + do { + /* + * If the merge is highly unbalanced (e.g. the input is + * already sorted), this loop may run many iterations. + * Continue callbacks to the client even though no + * element comparison is needed, so the client's cmp() + * routine can invoke cond_resched() periodically. + */ + if (unlikely(!++count)) + cmp(priv, b, b); + b->prev = tail; + tail = b; + b = b->next; + } while (b); + + /* And the final links to make a circular doubly-linked list */ + tail->next = head; + head->prev = tail; +} + +/** + * list_sort - sort a list + * @priv: private data, opaque to list_sort(), passed to @cmp + * @head: the list to sort + * @cmp: the elements comparison function + * + * The comparison function @cmp must return > 0 if @a should sort after + * @b ("@a > @b" if you want an ascending sort), and <= 0 if @a should + * sort before @b *or* their original order should be preserved. It is + * always called with the element that came first in the input in @a, + * and list_sort is a stable sort, so it is not necessary to distinguish + * the @a < @b and @a == @b cases. + * + * This is compatible with two styles of @cmp function: + * - The traditional style which returns <0 / =0 / >0, or + * - Returning a boolean 0/1. + * The latter offers a chance to save a few cycles in the comparison + * (which is used by e.g. plug_ctx_cmp() in block/blk-mq.c). + * + * A good way to write a multi-word comparison is:: + * + * if (a->high != b->high) + * return a->high > b->high; + * if (a->middle != b->middle) + * return a->middle > b->middle; + * return a->low > b->low; + * + * + * This mergesort is as eager as possible while always performing at least + * 2:1 balanced merges. Given two pending sublists of size 2^k, they are + * merged to a size-2^(k+1) list as soon as we have 2^k following elements. + * + * Thus, it will avoid cache thrashing as long as 3*2^k elements can + * fit into the cache. Not quite as good as a fully-eager bottom-up + * mergesort, but it does use 0.2*n fewer comparisons, so is faster in + * the common case that everything fits into L1. + * + * + * The merging is controlled by "count", the number of elements in the + * pending lists. This is beautifully simple code, but rather subtle. + * + * Each time we increment "count", we set one bit (bit k) and clear + * bits k-1 .. 0. Each time this happens (except the very first time + * for each bit, when count increments to 2^k), we merge two lists of + * size 2^k into one list of size 2^(k+1). + * + * This merge happens exactly when the count reaches an odd multiple of + * 2^k, which is when we have 2^k elements pending in smaller lists, + * so it's safe to merge away two lists of size 2^k. + * + * After this happens twice, we have created two lists of size 2^(k+1), + * which will be merged into a list of size 2^(k+2) before we create + * a third list of size 2^(k+1), so there are never more than two pending. + * + * The number of pending lists of size 2^k is determined by the + * state of bit k of "count" plus two extra pieces of information: + * + * - The state of bit k-1 (when k == 0, consider bit -1 always set), and + * - Whether the higher-order bits are zero or non-zero (i.e. + * is count >= 2^(k+1)). + * + * There are six states we distinguish. "x" represents some arbitrary + * bits, and "y" represents some arbitrary non-zero bits: + * 0: 00x: 0 pending of size 2^k; x pending of sizes < 2^k + * 1: 01x: 0 pending of size 2^k; 2^(k-1) + x pending of sizes < 2^k + * 2: x10x: 0 pending of size 2^k; 2^k + x pending of sizes < 2^k + * 3: x11x: 1 pending of size 2^k; 2^(k-1) + x pending of sizes < 2^k + * 4: y00x: 1 pending of size 2^k; 2^k + x pending of sizes < 2^k + * 5: y01x: 2 pending of size 2^k; 2^(k-1) + x pending of sizes < 2^k + * (merge and loop back to state 2) + * + * We gain lists of size 2^k in the 2->3 and 4->5 transitions (because + * bit k-1 is set while the more significant bits are non-zero) and + * merge them away in the 5->2 transition. Note in particular that just + * before the 5->2 transition, all lower-order bits are 11 (state 3), + * so there is one list of each smaller size. + * + * When we reach the end of the input, we merge all the pending + * lists, from smallest to largest. If you work through cases 2 to + * 5 above, you can see that the number of elements we merge with a list + * of size 2^k varies from 2^(k-1) (cases 3 and 5 when x == 0) to + * 2^(k+1) - 1 (second merge of case 5 when x == 2^(k-1) - 1). + */ +__attribute__((nonnull(2,3))) +void list_sort(void *priv, struct list_head *head, list_cmp_func_t cmp) +{ + struct list_head *list = head->next, *pending = NULL; + size_t count = 0; /* Count of pending */ + + if (list == head->prev) /* Zero or one elements */ + return; + + /* Convert to a null-terminated singly-linked list. */ + head->prev->next = NULL; + + /* + * Data structure invariants: + * - All lists are singly linked and null-terminated; prev + * pointers are not maintained. + * - pending is a prev-linked "list of lists" of sorted + * sublists awaiting further merging. + * - Each of the sorted sublists is power-of-two in size. + * - Sublists are sorted by size and age, smallest & newest at front. + * - There are zero to two sublists of each size. + * - A pair of pending sublists are merged as soon as the number + * of following pending elements equals their size (i.e. + * each time count reaches an odd multiple of that size). + * That ensures each later final merge will be at worst 2:1. + * - Each round consists of: + * - Merging the two sublists selected by the highest bit + * which flips when count is incremented, and + * - Adding an element from the input as a size-1 sublist. + */ + do { + size_t bits; + struct list_head **tail = &pending; + + /* Find the least-significant clear bit in count */ + for (bits = count; bits & 1; bits >>= 1) + tail = &(*tail)->prev; + /* Do the indicated merge */ + if (likely(bits)) { + struct list_head *a = *tail, *b = a->prev; + + a = merge(priv, cmp, b, a); + /* Install the merged result in place of the inputs */ + a->prev = b->prev; + *tail = a; + } + + /* Move one element from input list to pending */ + list->prev = pending; + pending = list; + list = list->next; + pending->next = NULL; + count++; + } while (list); + + /* End of input; merge together all the pending lists. */ + list = pending; + pending = pending->prev; + for (;;) { + struct list_head *next = pending->prev; + + if (!next) + break; + list = merge(priv, cmp, pending, list); + pending = next; + } + /* The final merge, rebuilding prev links */ + merge_final(priv, cmp, head, pending, list); +} diff --git a/c/brlib/todo/list_sort.h b/c/brlib/todo/list_sort.h new file mode 100644 index 0000000..6d67cbe --- /dev/null +++ b/c/brlib/todo/list_sort.h @@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +/* + * Taken from linux kernel: lib/list_sort.c + */ + +#ifndef _BR_LIST_SORT_H +#define _BR_LIST_SORT_H + +//#include + +struct list_head; + +typedef int __attribute__((nonnull(2,3))) (*list_cmp_func_t)(void *, + const struct list_head *, const struct list_head *); + +__attribute__((nonnull(2,3))) +void list_sort(void *priv, struct list_head *head, list_cmp_func_t cmp); + +#endif /* _BR_LIST_SORT */