arith.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2012-2020 Seagate Technology LLC and/or its Affiliates
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * For any questions about this software or licensing,
 * please email opensource@seagate.com or cortx-questions@seagate.com.
 *
 */


#pragma once

#ifndef __MOTR_LIB_ARITH_H__
#define __MOTR_LIB_ARITH_H__

#include "lib/types.h"
#include "lib/assert.h"

static inline int32_t min32(int32_t a, int32_t b)
{
        return a < b ? a : b;
}

static inline int32_t max32(int32_t a, int32_t b)
{
        return a > b ? a : b;
}

static inline int64_t min64(int64_t a, int64_t b)
{
        return a < b ? a : b;
}

static inline int64_t max64(int64_t a, int64_t b)
{
        return a > b ? a : b;
}

static inline uint32_t min32u(uint32_t a, uint32_t b)
{
        return a < b ? a : b;
}

static inline uint32_t max32u(uint32_t a, uint32_t b)
{
        return a > b ? a : b;
}

static inline uint64_t min64u(uint64_t a, uint64_t b)
{
        return a < b ? a : b;
}

static inline uint64_t max64u(uint64_t a, uint64_t b)
{
        return a > b ? a : b;
}

#define min_type(t, a, b) ({                    \
        t __a = (a);                            \
        t __b = (b);                            \
        __a < __b ? __a : __b;                  \
})

#define max_type(t, a, b) ({                    \
        t __a = (a);                            \
        t __b = (b);                            \
        __a > __b ? __a : __b;                  \
})

#define min_check(a, b) ({                      \
        typeof(a) __a = (a);                    \
        typeof(b) __b = (b);                    \
        (void)(&__a == &__b);                   \
        __a < __b ? __a : __b;                  \
})

#define max_check(a, b) ({                      \
        typeof(a) __a = (a);                    \
        typeof(b) __b = (b);                    \
        (void)(&__a == &__b);                   \
        __a > __b ? __a : __b;                  \
})

#ifndef __KERNEL__
#  define min3(a, b, c) (min_check((a), min_check((b), (c))))
#  define max3(a, b, c) (max_check((a), max_check((b), (c))))
#endif

M0_INTERNAL bool m0_mod_gt(uint64_t x0, uint64_t x1);

M0_INTERNAL bool m0_mod_ge(uint64_t x0, uint64_t x1);

static inline uint64_t m0_clip64u(uint64_t lo, uint64_t hi, uint64_t x)
{
        M0_PRE(lo <= hi);
        return min64u(max64u(lo, x), hi);
}

M0_INTERNAL uint64_t m0_rnd(uint64_t max, uint64_t * seed);
M0_INTERNAL uint64_t m0_rnd64(uint64_t *seed);

M0_INTERNAL uint64_t m0_gcd64(uint64_t p, uint64_t q);

static inline bool m0_is_po2(uint64_t val)
{
        return (val & (val - 1)) == 0;
}

static inline unsigned m0_log2(uint64_t val)
{
        unsigned shift = 0;

        for (val >>= 1; val != 0; val >>= 1)
                ++shift;
        return shift;
}

static inline uint64_t m0_align(uint64_t val, uint64_t alignment)
{
        uint64_t mask;

        M0_PRE(m0_is_po2(alignment));
        mask = alignment - 1;
        return (val + mask) & ~mask;
}

static inline bool m0_is_aligned(uint64_t val, uint64_t alignment)
{
        uint64_t mask;

        M0_PRE(m0_is_po2(alignment));
        mask = alignment - 1;
        return (val & mask) == 0;
}

#define M0_IS_8ALIGNED(val) ((((uint64_t)(val)) & 07) == 0)

#define M0_3WAY(v0, v1)                         \
({                                              \
        typeof(v0) __a0 = (v0);                 \
        typeof(v1) __a1 = (v1);                 \
                                                \
        (__a0 < __a1) ? -1 : __a0 != __a1;      \
})

#define M0_SWAP(v0, v1)                                 \
({                                                      \
        typeof(v0) *__a0 = &(v0);                       \
        typeof(v1) *__a1 = &(v1);                       \
        typeof(v0) __tmp = *__a0;                       \
        (void)(__a0 == __a1);                           \
                                                        \
        *__a0 = *__a1;                                  \
        *__a1 = __tmp;                                  \
})

#define M0_CNT_DEC(cnt)                                 \
({                                                      \
        M0_ASSERT((cnt) != 0);                          \
        --cnt;                                          \
})

#define M0_CNT_INC(cnt)                                 \
({                                                      \
        ++cnt;                                          \
        M0_ASSERT((cnt) != 0);                          \
})

static inline bool m0_addu64_will_overflow(uint64_t a, uint64_t b)
{
        return a + b < a;
}

static inline uint64_t m0_enc(uint64_t width, uint64_t row, uint64_t column)
{
        M0_PRE(column < width);
        return row * width + column;
}

static inline void m0_dec(uint64_t width, uint64_t pos, uint64_t *row,
                          uint64_t *column)
{
        *row    = pos / width;
        *column = pos % width;
}

#endif /* __MOTR_LIB_ARITH_H__ */

/*
 *  Local variables:
 *  c-indentation-style: "K&R"
 *  c-basic-offset: 8
 *  tab-width: 8
 *  fill-column: 80
 *  scroll-step: 1
 *  End:
 */