@based/db 0.2.5 → 0.2.7

package/dist/lib/linux_aarch64/include/selva/bitmap.h

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2021, 2023, 2025 SAULX
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+#include "selva/_export.h"
+
+#if __SIZEOF_INT128__ != 16
+#error The compiler and architecture must have Tetra-Integer support
+#endif
+
+typedef unsigned __int128 bitmap_t;
+
+/**
+ * A flexible bitmap.
+ */
+struct bitmap {
+    size_t nbits;
+    bitmap_t d[];
+};
+
+#define BITMAP_CEILING(x, y) \
+    (((x) + (y) - (size_t)1) / (y))
+
+/*
+ * We use this instead of max() to avoid GCC compound statements that don't work
+ * outside of functions. C23 constexpr might make compound statements available
+ * for initialization but compound statements are currently only supported in
+ * GCC 13 and there is no support in Clang.
+ */
+#define BITMAP_MAX(a, b) \
+    ((a) > (b) ? (a) : (b))
+
+#define BITMAP_D_SIZE(nbits) \
+    (BITMAP_CEILING(BITMAP_MAX((size_t)(nbits), (size_t)8) / (size_t)8, sizeof(bitmap_t)) * sizeof(bitmap_t))
+
+/**
+ * Byte size of a bitmap struct passable to a malloc()-like function.
+ * nbits must be a literal or variable.
+ */
+#define BITMAP_ALLOC_SIZE(nbits) \
+    (sizeof(struct bitmap) + BITMAP_D_SIZE(nbits))
+
+/**
+ * Get the status of a bit in a bitmap pointed by bitmap.
+ * @param bitmap            is a pointer to a bitmap.
+ * @param pos               is the bit position to be checked.
+ * @return  Boolean value or -1.
+ */
+SELVA_EXPORT
+int bitmap_get(const struct bitmap *bitmap, size_t pos)
+    __attribute__((pure, access(read_only, 1)));
+
+/**
+ * Set a bit in a bitmap pointed by bitmap.
+ * @param bitmap            is a pointer to a bitmap.
+ * @param pos               is the bit position to be set.
+ * @return  0 or -1.
+ */
+SELVA_EXPORT
+int bitmap_set(struct bitmap *bitmap, size_t pos)
+    __attribute__((access(read_write, 1)));
+
+/**
+ * Clear a bit in a bitmap pointed by bitmap.
+ * @param bitmap            is a pointer to a bitmap.
+ * @param pos               is the bit position to be cleared.
+ * @return  0 or -1.
+ */
+SELVA_EXPORT
+int bitmap_clear(struct bitmap *bitmap, size_t pos)
+    __attribute__((access(read_write, 1)));
+
+/**
+ * Erase the whole bitmap.
+ * @param bitmap            is a pointer to a bitmap.
+ */
+SELVA_EXPORT
+void bitmap_erase(struct bitmap *bitmap)
+    __attribute__((access(read_write, 1)));
+
+SELVA_EXPORT
+long long bitmap_popcount(const struct bitmap *bitmap)
+    __attribute__((pure, access(read_only, 1)));
+
+/**
+ * Find first set.
+ */
+SELVA_EXPORT
+int bitmap_ffs(const struct bitmap *bitmap)
+    __attribute__((pure, access(read_only, 1)));

package/dist/lib/linux_aarch64/include/selva/colvec.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2025 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+#include "selva/types.h"
+#include "selva/selva_hash128.h"
+#include "selva/_export.h"
+
+struct SelvaColvec {
+    field_t field;
+    uint16_t vec_size;
+    size_t slab_size; /* Size of each slab in v. */
+
+    /**
+     * Array of pointers to vector slabs.
+     * te->blocks->len number of pointers to vector blocks each containing
+     * te->blocks->block_capacity vectors.
+     */
+    void **v;
+};
+
+/**
+ * Initialize colvec record keeping under te->col_fields.
+ */
+void colvec_init_te(struct SelvaTypeEntry *te);
+
+/**
+ * Deinitialize colvec record keeping and col slabs under te->col_fields.
+ */
+void colvec_deinit_te(struct SelvaTypeEntry *te);
+
+/**
+ * Initialize a slab at block_i if not already Initialized.
+ */
+void *colvec_init_slab(struct SelvaColvec *colvec, block_id_t block_i);
+
+/**
+ * Initialize all columnar fields of node.
+ * This function will also initialize the slab(s) if it's not allocated.
+ */
+void colvec_init_node(struct SelvaTypeEntry *te, struct SelvaNode *node);
+
+/**
+ * Compute the hash for a node_id in colvec.
+ */
+void colvec_hash_update(struct SelvaTypeEntry *te, node_id_t node_id, struct SelvaColvec *colvec, selva_hash_state_t *hash_state);
+
+/**
+ * Get the whole column for fs.
+ */
+SELVA_EXPORT
+struct SelvaColvec *colvec_get(struct SelvaTypeEntry *te, const struct SelvaFieldSchema *fs);
+
+/**
+ * Get a single vector in a colvec field by node_id.
+ */
+SELVA_EXPORT
+void *colvec_get_vec(struct SelvaTypeEntry *te, node_id_t node_id, const struct SelvaFieldSchema *fs);
+
+/**
+ * Set a single vector in a colvec field.
+ */
+SELVA_EXPORT
+void colvec_set_vec(struct SelvaTypeEntry *te, node_id_t node_id, const struct SelvaFieldSchema *fs, const void *vec);
+
+SELVA_EXPORT
+int colvec_foreach(struct SelvaTypeEntry *te, const struct SelvaFieldSchema *fs, node_id_t start, uint32_t len, void (*cb)(node_id_t node_id, void *vec, void *arg), void *arg);

package/dist/lib/linux_aarch64/include/selva/crc32c.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2025 SAULX
+ * Copyright (C) 2013, 2021 Mark Adler <madler@alumni.caltech.edu>
+ * SPDX-License-Identifier: Zlib
+ */
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+#include "selva/_export.h"
+
+/**
+ * Compute CRC-32C.
+ */
+SELVA_EXPORT
+uint32_t crc32c(uint32_t crc, void const *buf, size_t len)
+    __attribute__((pure, access(read_only, 2, 3)));

package/dist/lib/linux_aarch64/include/selva/ctime.h

@@ -0,0 +1,135 @@
+/**
+ *******************************************************************************
+ * @file    ctime.h
+ * @author  Olli Vanhoja
+ * @brief   time types.
+ * @section LICENSE
+ * Copyright (c) 2022-2025 Saulx
+ * Copyright (c) 2020 Olli Vanhoja <olli.vanhoja@alumni.helsinki.fi>
+ * Copyright (c) 2014 - 2016 Olli Vanhoja <olli.vanhoja@cs.helsinki.fi>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * SPDX-License-Identifier: BSD-2-Clause
+ *******************************************************************************
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <time.h>
+#include "selva/_export.h"
+
+/**
+ * Conver an msec value to a timespec struct.
+ * @param[out]  ts      is a pointer to the destination struct.
+ * @param[in]   nsec    is the value in milliseconds.
+ */
+SELVA_EXPORT
+struct timespec *msec2timespec(struct timespec * ts, int64_t msec);
+
+#define MSEC2TIMESPEC(msec) \
+    ({ struct timespec _ts; (void)msec2timespec(&_ts, msec); _ts; })
+
+/**
+ * Convert a nsec value to a timespec struct.
+ * @param[out]  ts      is a pointer to the destination struct.
+ * @param[in]   nsec    is the value in nanoseconds.
+ */
+SELVA_EXPORT
+struct timespec *nsec2timespec(struct timespec * ts, int64_t nsec);
+
+#define NSEC2TIMESPEC(nsec) \
+    ({ struct timespec _ts; (void)NSEC2TIMESPEC(&_ts, nsec); _ts; })
+
+/**
+ * Compare two timespec structs.
+ * @param[in]   left    is a pointer to the left value.
+ * @param[in]   right   is a pointer to the right value.
+ * @param[in]   cmp     is the operator (<, >, ==, <=, or >=).
+ * @returns a boolean value.
+ */
+#define timespec_cmp(left_tsp, right_tsp, cmp) ({       \
+    (((left_tsp)->tv_sec == (right_tsp)->tv_sec)        \
+     ? ((left_tsp)->tv_nsec cmp (right_tsp)->tv_nsec)   \
+     : ((left_tsp)->tv_sec cmp (right_tsp)->tv_sec));   \
+    })
+
+/**
+ * Calculate the sum of two timespec structs.
+ * @param[out]  sum     is a pointer to the destination struct.
+ * @param[in]   left    is a pointer to the left value.
+ * @param[in]   right   is a pointer to the right value.
+ */
+SELVA_EXPORT
+void timespec_add(struct timespec * sum, const struct timespec * left,
+                  const struct timespec * right)
+    __attribute__((access(write_only, 1), access(read_only, 2), access(read_only, 3)));
+
+/**
+ * Calculate the difference of two timespec structs.
+ * @param[out]  sum     is a pointer to the destination struct.
+ * @param[in]   left    is a pointer to the left value.
+ * @param[in]   right   is a pointer to the right value.
+ */
+SELVA_EXPORT
+void timespec_sub(struct timespec * diff, const struct timespec * left,
+                  const struct timespec * right)
+    __attribute__((access(write_only, 1), access(read_only, 2), access(read_only, 3)));
+
+/**
+ * Calculate the product of two timespec structs.
+ * @param[out]  sum     is a pointer to the destination struct.
+ * @param[in]   left    is a pointer to the left value.
+ * @param[in]   right   is a pointer to the right value.
+ */
+SELVA_EXPORT
+void timespec_mul(struct timespec * prod, const struct timespec * left,
+                 const struct timespec * right)
+    __attribute__((access(write_only, 1), access(read_only, 2), access(read_only, 3)));
+
+/**
+ * Calculate the quotient of two timespec structs.
+ * @param[out]  sum     is a pointer to the destination struct.
+ * @param[in]   left    is a pointer to the left value.
+ * @param[in]   right   is a pointer to the right value.
+ */
+SELVA_EXPORT
+void timespec_div(struct timespec * quot, const struct timespec * left,
+                  const struct timespec * right)
+    __attribute__((access(write_only, 1), access(read_only, 2), access(read_only, 3)));
+
+/**
+ * Calculate the modulo of two timespec structs.
+ * @param[out]  sum     is a pointer to the destination struct.
+ * @param[in]   left    is a pointer to the left value.
+ * @param[in]   right   is a pointer to the right value.
+ */
+void timespec_mod(struct timespec * rem, const struct timespec * left,
+                  const struct timespec * right)
+    __attribute__((access(write_only, 1), access(read_only, 2), access(read_only, 3)));
+
+static inline double timespec2ms(const struct timespec *ts)
+{
+    return (double)ts->tv_sec * 1000.0 + (double)ts->tv_nsec / 1.0e6;
+}
+