mirror of
https://github.com/openvswitch/ovs
synced 2025-10-25 15:07:05 +00:00
52a524eb20
Batching the cmap find improves the memory behavior with large cmaps and can make searches twice as fast: $ tests/ovstest test-cmap benchmark 2000000 8 0.1 16 Benchmarking with n=2000000, 8 threads, 0.10% mutations, batch size 16: cmap insert: 533 ms cmap iterate: 57 ms batch search: 146 ms cmap destroy: 233 ms cmap insert: 552 ms cmap iterate: 56 ms cmap search: 299 ms cmap destroy: 229 ms hmap insert: 222 ms hmap iterate: 198 ms hmap search: 2061 ms hmap destroy: 209 ms Batch size 1 has small performance penalty, but all other batch sizes are faster than non-batched cmap_find(). The batch size 16 was experimentally found better than 8 or 32, so now classifier_lookup_miniflow_batch() performs the cmap find operations in batches of 16. Signed-off-by: Jarno Rajahalme <jrajahalme@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
127 lines
3.5 KiB
C
127 lines
3.5 KiB
C
/*
|
|
* Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#ifndef BITMAP_H
|
|
#define BITMAP_H 1
|
|
|
|
#include <limits.h>
|
|
#include <stdlib.h>
|
|
#include "util.h"
|
|
|
|
#define BITMAP_ULONG_BITS (sizeof(unsigned long) * CHAR_BIT)
|
|
|
|
static inline unsigned long *
|
|
bitmap_unit__(const unsigned long *bitmap, size_t offset)
|
|
{
|
|
return CONST_CAST(unsigned long *, &bitmap[offset / BITMAP_ULONG_BITS]);
|
|
}
|
|
|
|
static inline unsigned long
|
|
bitmap_bit__(size_t offset)
|
|
{
|
|
return 1UL << (offset % BITMAP_ULONG_BITS);
|
|
}
|
|
|
|
#define BITMAP_N_LONGS(N_BITS) DIV_ROUND_UP(N_BITS, BITMAP_ULONG_BITS)
|
|
|
|
static inline size_t
|
|
bitmap_n_longs(size_t n_bits)
|
|
{
|
|
return BITMAP_N_LONGS(n_bits);
|
|
}
|
|
|
|
static inline size_t
|
|
bitmap_n_bytes(size_t n_bits)
|
|
{
|
|
return bitmap_n_longs(n_bits) * sizeof(unsigned long int);
|
|
}
|
|
|
|
static inline unsigned long *
|
|
bitmap_allocate(size_t n_bits)
|
|
{
|
|
return xzalloc(bitmap_n_bytes(n_bits));
|
|
}
|
|
|
|
unsigned long *bitmap_allocate1(size_t n_bits);
|
|
|
|
static inline unsigned long *
|
|
bitmap_clone(const unsigned long *bitmap, size_t n_bits)
|
|
{
|
|
return xmemdup(bitmap, bitmap_n_bytes(n_bits));
|
|
}
|
|
|
|
static inline void
|
|
bitmap_free(unsigned long *bitmap)
|
|
{
|
|
free(bitmap);
|
|
}
|
|
|
|
static inline bool
|
|
bitmap_is_set(const unsigned long *bitmap, size_t offset)
|
|
{
|
|
return (*bitmap_unit__(bitmap, offset) & bitmap_bit__(offset)) != 0;
|
|
}
|
|
|
|
static inline void
|
|
bitmap_set1(unsigned long *bitmap, size_t offset)
|
|
{
|
|
*bitmap_unit__(bitmap, offset) |= bitmap_bit__(offset);
|
|
}
|
|
|
|
static inline void
|
|
bitmap_set0(unsigned long *bitmap, size_t offset)
|
|
{
|
|
*bitmap_unit__(bitmap, offset) &= ~bitmap_bit__(offset);
|
|
}
|
|
|
|
static inline void
|
|
bitmap_set(unsigned long *bitmap, size_t offset, bool value)
|
|
{
|
|
if (value) {
|
|
bitmap_set1(bitmap, offset);
|
|
} else {
|
|
bitmap_set0(bitmap, offset);
|
|
}
|
|
}
|
|
|
|
void bitmap_set_multiple(unsigned long *, size_t start, size_t count,
|
|
bool value);
|
|
bool bitmap_equal(const unsigned long *, const unsigned long *, size_t n);
|
|
size_t bitmap_scan(const unsigned long int *, bool target,
|
|
size_t start, size_t end);
|
|
size_t bitmap_count1(const unsigned long *, size_t n);
|
|
|
|
void bitmap_and(unsigned long *dst, const unsigned long *arg, size_t n);
|
|
void bitmap_or(unsigned long *dst, const unsigned long *arg, size_t n);
|
|
void bitmap_not(unsigned long *dst, size_t n);
|
|
|
|
bool bitmap_is_all_zeros(const unsigned long *, size_t n);
|
|
|
|
#define BITMAP_FOR_EACH_1(IDX, SIZE, BITMAP) \
|
|
for ((IDX) = bitmap_scan(BITMAP, 1, 0, SIZE); (IDX) < (SIZE); \
|
|
(IDX) = bitmap_scan(BITMAP, 1, (IDX) + 1, SIZE))
|
|
|
|
/* More efficient access to a map of single ulong. */
|
|
#define ULONG_FOR_EACH_1(IDX, MAP) \
|
|
for (unsigned long map__ = (MAP); \
|
|
map__ && (((IDX) = raw_ctz(map__)), true); \
|
|
map__ = zero_rightmost_1bit(map__))
|
|
|
|
#define ULONG_SET0(MAP, OFFSET) ((MAP) &= ~(1UL << (OFFSET)))
|
|
#define ULONG_SET1(MAP, OFFSET) ((MAP) |= 1UL << (OFFSET))
|
|
|
|
#endif /* bitmap.h */
|