Function algorithm_swap

algorithm/algorithm.c:1489–1535

* @brief Swaps the values of two elements. * * @param a Pointer to the first element. * @param b Pointer to the second element. * @param size Size of each element in bytes. */

 * @param size Size of each element in bytes.
 */
void algorithm_swap(void *a, void *b, size_t size) {
    ALGORITHM_LOG("[algorithm_swap] Info: Swapping two elements of size %zu.", size);

    if (!a || !b || a == b || size == 0) {
        return;
    }

    // Fast path: small elements swap byte-by-byte on the stack 
    enum { STACK_BUF = 256 };
    if (size <= STACK_BUF) {
        unsigned char temp[STACK_BUF];
        memcpy(temp, a, size);
        memcpy(a, b, size);
        memcpy(b, temp, size);

        ALGORITHM_LOG("[algorithm_swap] Success: Stack swap completed.");
        return;
    }

    // Large elements: try heap, fall back to chunked byte swap on OOM so
    void *temp = malloc(size);
    if (temp) {
        memcpy(temp, a, size);
        memcpy(a, b, size);
        memcpy(b, temp, size);
        free(temp);

        ALGORITHM_LOG("[algorithm_swap] Success: Heap swap completed.");
        return;
    }

    // OOM fallback: swap in STACK_BUF-sized chunks (correctness-preserving,
    // no allocation, never fails).
    ALGORITHM_LOG("[algorithm_swap] Warning: malloc failed; using chunked stack swap.");
    unsigned char *pa = (unsigned char*)a;
    unsigned char *pb = (unsigned char*)b;
    unsigned char chunk[STACK_BUF];
    size_t remaining = size;

    while (remaining > 0) {
        size_t n = remaining > STACK_BUF ? STACK_BUF : remaining;
        memcpy(chunk, pa, n);
        memcpy(pa, pb, n);
        memcpy(pb, chunk, n);
        pa += n; pb += n; remaining -= n;
    }
}


/**