UCQs now use mcs_pdr_locks (XCC)
[akaros.git] / kern / include / ros / common.h
index d9138a6..b286202 100644 (file)
@@ -32,7 +32,7 @@ typedef size_t uintreg_t;
        for (int _var = 0, var = (next); _var < (size); _var++, var = (var + 1) % (size))
 
 // Efficient min and max operations
-//#ifdef ROS_KERNEL
+#ifdef ROS_KERNEL /* Glibc has their own */
 #define MIN(_a, _b)                                            \
 ({                                                             \
        typeof(_a) __a = (_a);                                  \
@@ -45,58 +45,66 @@ typedef size_t uintreg_t;
        typeof(_b) __b = (_b);                                  \
        __a >= __b ? __a : __b;                                 \
 })
-//#endif
+#endif
 
 // Rounding operations (efficient when n is a power of 2)
 // Round down to the nearest multiple of n
 #define ROUNDDOWN(a, n)                                                \
 ({                                                             \
-       uint32_t __a = (uint32_t) (a);                          \
+       uintptr_t __a = (uintptr_t) (a);                                \
        (typeof(a)) (__a - __a % (n));                          \
 })
 // Round up to the nearest multiple of n
 #define ROUNDUP(a, n)                                          \
 ({                                                             \
-       uint32_t __n = (uint32_t) (n);                          \
-       (typeof(a)) (ROUNDDOWN((uint32_t) (a) + __n - 1, __n)); \
+       uintptr_t __n = (uintptr_t) (n);                                \
+       (typeof(a)) (ROUNDDOWN((uintptr_t) (a) + __n - 1, __n));        \
 })
 
 // Round down to the nearest multiple of n
 #define PTRROUNDDOWN(a, n)                                             \
 ({                                                             \
        char * __a = (char *) (a);                              \
-       (typeof(a)) (__a - (uint32_t)__a % (n));                                \
+       (typeof(a)) (__a - (uintptr_t)__a % (n));                               \
 })
 // Round pointer up to the nearest multiple of n
 #define PTRROUNDUP(a, n)                                               \
 ({                                                             \
-       uint32_t __n = (uint32_t) (n);                          \
+       uintptr_t __n = (uintptr_t) (n);                                \
        (typeof(a)) (PTRROUNDDOWN((char *) (a) + __n - 1, __n));        \
 })
 
 // Return the integer logarithm of the value provided rounded down
-static inline uint32_t LOG2_DOWN(uint32_t value)
+static inline uintptr_t LOG2_DOWN(uintptr_t value)
 {
-       uint32_t l = 0;
+       uintptr_t l = 0;
        while( (value >> l) > 1 ) ++l;
        return l;
 }
 
 // Return the integer logarithm of the value provided rounded up
-static inline uint32_t LOG2_UP(uint32_t value)
+static inline uintptr_t LOG2_UP(uintptr_t value)
 {
-       uint32_t _v = LOG2_DOWN(value);
+       uintptr_t _v = LOG2_DOWN(value);
        if (value ^ (1 << _v))
                return _v + 1;
        else
                return _v;
 }
 
-static inline uint32_t ROUNDUPPWR2(uint32_t value)
+static inline uintptr_t ROUNDUPPWR2(uintptr_t value)
 {
        return 1 << LOG2_UP(value);
 }
 
+/* We wraparound if UINT_MAX < a * b, which is also UINT_MAX / a < b. */
+static inline bool mult_will_overflow_u64(uint64_t a, uint64_t b)
+{
+       if (!a)
+               return FALSE;
+       return (uint64_t)(-1) / a < b;
+}
+
 // Return the offset of 'member' relative to the beginning of a struct type
 #ifndef offsetof
 #define offsetof(type, member)  ((size_t) (&((type*)0)->member))