mir/openvswitch
2
0
Fork 0
mirror of https://github.com/openvswitch/ovs synced 2025-10-25 15:07:05 +00:00
Code Issues Releases Wiki Activity
6,929 Commits 50 Branches 229 Tags
7c0180333bc13b8d5897f9a1448ac70a37f892be
Commit Graph

15 Commits

Author SHA1 Message Date
Ben Pfaff
e93ab5531c util: New macros ROUND_UP_POW2, ROUND_DOWN_POW2. 
Signed-off-by: Ben Pfaff <blp@nicira.com>
 2013-07-17 13:32:36 -07:00
Ben Pfaff
b028db44ca Use random_*() instead of rand(), for thread safety. 
None of these test programs are threaded, but has little cost and means
that "grep" doesn't turn up any instances of these thread-unsafe functions
in our tree.

Signed-off-by: Ben Pfaff <blp@nicira.com>
 2013-06-28 16:09:39 -07:00
Ben Pfaff
07fc4ed341 Make most "struct option" instances "const". 
Reducing non-const static data makes code more obviously thread-safe.
Although option parsing does not normally need to be thread-safe, I
don't know of a drawback to making its data const.

Signed-off-by: Ben Pfaff <blp@nicira.com>
 2013-05-03 13:29:46 -07:00
Ben Pfaff
4749f73d12 util: Introduce ovs_assert macro. 
An occasionally significant problem with the standard "assert" macro is
that it writes the failure message to stderr.  In our daemons, stderr is
generally redirected to /dev/null.  It's more useful to write the failure
message to the log, which is what the new ovs_assert macro introduced in
this patch does.

Signed-off-by: Ben Pfaff <blp@nicira.com>
Acked-by: Ethan Jackson <ethan@nicira.com>
 2013-01-16 16:03:03 -08:00
Ben Pfaff
a656cb7736 util: New function popcount(). 
This is the fastest portable implementation among the ones below, as
measured with GCC 4.4 on a Xeon X3430.  The measeured times were, in
seconds:

popcount1    25.6
popcount2     6.9 (but is not portable)
popcount3    31.4
popcount4    25.6
popcount5    61.6 (and is buggy)
popcount6    64.6
popcount7    32.3
popcount8    11.2

int
popcount1(unsigned int x)
{
    return __builtin_popcount(x);
}

int
popcount2(unsigned int x)
{
    unsigned int y;
    asm("popcnt %1, %0" : "=r" (y) : "g" (x));
    return y;
}

int
popcount3(unsigned int x)
{
    unsigned int n;

    n = (x >> 1) & 033333333333;
    x -= n;
    n = (n >> 1) & 033333333333;
    x -= n;
    x = (x + (x >> 3)) & 030707070707;
    return x % 63;
}

int
popcount4(unsigned int x)
{
    x -= (x >> 1) & 0x55555555;
    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
    x = (x + (x >> 4)) & 0x0f0f0f0f;
    x += x >> 8;
    x += x >> 16;
    return x & 0x3f;
}

int
popcount5(unsigned int x)
{
    int n;

    n = 0;
    while (x) {
        if (x & 0xf) {
            n += ((0xe9949440 >> (x & 0xf)) & 3) + 1;
        }
        x >>= 4;
    }
    return n;
}

int
popcount6(unsigned int x)
{
    int n;

    n = 0;
    while (x) {
        n += (0xe994 >> (x & 7)) & 3;
        x >>= 3;
    }
    return n;
}

int
popcount7(unsigned int x)
{
    static const int table[16] = {
        0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4
    };

    return (table[x & 0xf]
            + table[(x >> 4) & 0xf]
            + table[(x >> 8) & 0xf]
            + table[(x >> 12) & 0xf]
            + table[(x >> 16) & 0xf]
            + table[(x >> 20) & 0xf]
            + table[(x >> 24) & 0xf]
            + table[x >> 28]);
}

static int
popcount8(unsigned int x)
{
    ((((X) & (1 << 0)) != 0) +                  \
     (((X) & (1 << 1)) != 0) +                  \
     (((X) & (1 << 2)) != 0) +                  \
     (((X) & (1 << 3)) != 0) +                  \
     (((X) & (1 << 4)) != 0) +                  \
     (((X) & (1 << 5)) != 0) +                  \
     (((X) & (1 << 6)) != 0) +                  \
     (((X) & (1 << 7)) != 0))

    static const uint8_t popcount8[256] = {
        INIT64(0), INIT64(64), INIT64(128), INIT64(192)
    };

    return (popcount8[x & 0xff] +
            popcount8[(x >> 8) & 0xff] +
            popcount8[(x >> 16) & 0xff] +
            popcount8[x >> 24]);
}

int
main(void)
{
    unsigned long long int x;
    int n;

    n = 0;
    for (x = 0; x <= UINT32_MAX; x++) {
        n += popcount8(x);
    }
    printf("%d\n", n);

    return 0;
}

Signed-off-by: Ben Pfaff <blp@nicira.com>
 2012-09-04 11:19:17 -07:00
Ben Pfaff
fee0c96314 util: New function follow_symlinks(). 
It will acquire its first user in an upcoming commit.

Signed-off-by: Ben Pfaff <blp@nicira.com>
 2012-08-01 10:55:57 -07:00
Ben Pfaff
8c2296a6d9 tests: Slightly generalize utility function tests. 
This will allow passing arguments in for an upcoming test.

Signed-off-by: Ben Pfaff <blp@nicira.com>
 2012-08-01 10:55:57 -07:00
Ben Pfaff
d7127d44be Avoid assigning the same value to a variable back-to-back. 
Found by clang.

Signed-off-by: Ben Pfaff <blp@nicira.com>
 2012-05-14 09:37:18 -07:00
Raju Subramanian
e0edde6fee Global replace of Nicira Networks. 
Replaced all instances of Nicira Networks(, Inc) to Nicira, Inc.

Feature #10593
Signed-off-by: Raju Subramanian <rsubramanian@nicira.com>
Signed-off-by: Ben Pfaff <blp@nicira.com>
 2012-05-02 17:08:02 -07:00
Ben Pfaff
79a010aa80 util: New function bitwise_is_all_zeros(). 
Signed-off-by: Ben Pfaff <blp@nicira.com>
 2012-04-13 21:12:48 -07:00
Ben Pfaff
c2dd49322f util: New function bitwise_one(). 
It's the obvious counterpart to bitwise_zero().

Signed-off-by: Ben Pfaff <blp@nicira.com>
 2012-04-13 20:43:37 -07:00
Ben Pfaff
6cc7ea5ea0 util: New function bitwise_zero(). 
Signed-off-by: Ben Pfaff <blp@nicira.com>
 2012-02-01 14:15:11 -08:00
Ben Pfaff
ddc4f8e27f util: Move bitwise_copy() here, add new bitwise functions, add a test. 
bitwise_copy() is generally useful so make it a general utility function.
Also add a comment.

Upcoming commits will introduce users for the new functions.

Signed-off-by: Ben Pfaff <blp@nicira.com>
 2012-02-01 14:15:07 -08:00
Ben Pfaff
aad29cd1a1 packets: Add more utility functions for IPv4 and IPv6 addresses. 
We had these functions scattered around the source tree anyway.  packets.h
is a good place to centralize them.

I do plan to introduce some additional callers.
 2011-09-13 11:46:08 -07:00
Ben Pfaff
711e0157cf util: New function log_2_floor(). 
Calculates the position of the most significant bit in a 32 bit
word.
 2011-07-22 17:46:48 -07:00