aboutsummaryrefslogtreecommitdiffstats
path: root/resources
AgeCommit message (Expand)AuthorFilesLines
2016-05-06Add Honeycomb interface management tests (ipv4, ipv6, ethernet, routing)selias5-33/+332
2016-05-06Honeycomb API keywords - interface, bridge domainTibor Frank5-673/+1186
2016-05-06Add "show error" output into vpp statsPeter Mikus3-0/+12
2016-05-04Update T-rex version to v2.00pmikus3-95/+143
2016-05-03Patch to reset default VPP configuration in perf.pmikus1-1/+5
2016-05-02Topo installation script fixMiroslav Miklus2-14/+40
2016-05-02Add vpp_create_loopbackMatus Fabian2-0/+17
2016-04-26Add qinq through xconnect tests.Patrik Hrnciar5-0/+211
2016-04-26Add BD vpp-vm-vpp testsMatus Fabian1-0/+54
2016-04-26Extend host topology with NIC type filteringMiroslav Miklus5-8/+98
2016-04-26Honeycomb interface state management testselias4-58/+125
2016-04-26Add optional args to traffic script arg parserMatus Fabian1-2/+10
2016-04-26Add IPsec utilities python libraryMatus Fabian6-0/+367
2016-04-25Honeycomb API keywordsTibor Frank9-26/+625
2016-04-22Reformat python libraries.Matej Klotton33-683/+722
2016-04-22Bridge domain tests and user keywords refactor.Jan Gelety2-10/+170
2016-04-22VatExecutor updateMatus Fabian2-0/+38
2016-04-21Topology schemaTibor Frank1-2/+4
2016-04-20Remove horizontal whitespace (a line) before [Command_start_exec] tag.mkonstan1-1/+0
2016-04-19Make dut_setup.sh verbose; add sleep after vpp restart.Stefan Kobza1-40/+31
2016-04-17Multicore VPP setup for performance testingpmikus2-3/+98
2016-04-15Update Qemu libraryMatus Fabian2-12/+61
2016-04-15Change the performance result messagepmikus1-6/+21
2016-04-13VXLAN test with dot1q tagging.Matej Klotton6-59/+165
2016-04-13Move methods from topology.py to more appropriate place.Matej Klotton8-423/+345
2016-04-13Honeycomb setup and utilsTibor4-242/+390
2016-04-13Add keywords for Honeycomb testsselias4-20/+80
2016-04-12Bootstrap verify performance fixpmikus1-1/+1
2016-04-12Bootstrap verify performance fixpmikus1-10/+24
2016-04-12Update of topo_installation filepmikus1-1/+1
2016-04-11Fix cosmetic issues in VIRL topologiesCarsten Koester3-22/+17
2016-04-11Add VIRL double-ring (load-balancing) topology with nested VM supportCarsten Koester2-0/+393
2016-04-11Combined DropRateSearchpmikus2-82/+179
2016-04-08Add Vagrantfile for local testing.Stefan Kobza5-17/+364
2016-04-05Add tag support to boostrap-verify-perfpmikus1-3/+6
2016-04-05Add "Stop and Clear QEMU" KWMatus Fabian1-1/+14
2016-04-05Setup and check honeycomb on all DUTsselias10-2/+769
2016-04-05Add VIRL topology files and template for nested virtualisationCarsten Koester2-0/+359
2016-04-04Change send_ip_icmp recv timeout to 2secMatus Fabian1-1/+1
2016-04-01Add get_vhost_user_if_name_by_sockMatus Fabian1-0/+16
2016-04-01Long perf testspmikus2-0/+80
2016-04-01Bootstrap to test perf of proposed patch vpp-csit-hw-perfpmikus1-0/+57
2016-03-30Add linux_add/del_bridge and modify vpp_add_l2fib_entryMatus Fabian1-4/+39
2016-03-30BestN/WorstN DropRateSearchpmikus1-29/+132
2016-03-29Bootstrap to test csit-master against VPP release.Jan Gelety1-4/+11
2016-03-24Setup and run QEMU VMMatus Fabian1-2/+358
2016-03-24Add node type VM to set_interface_stateMatus Fabian1-1/+1
2016-03-24Binary DropRateSearchpmikus1-4/+69
2016-03-21Lab reservation toolMiroslav Miklus1-0/+65
2016-03-18Remove apt-get call to install dependencies.Carsten Koester1-15/+0
ndom.h> #include <vppinfra/error.h> #include <vppinfra/bitops.h> /* for count_set_bits */ typedef uword clib_bitmap_t; /** predicate function; is an entire bitmap empty? @param ai - pointer to a bitmap @returns 1 if the entire bitmap is zero, 0 otherwise */ always_inline uword clib_bitmap_is_zero (uword * ai) { uword i; for (i = 0; i < vec_len (ai); i++) if (ai[i] != 0) return 0; return 1; } /** predicate function; are two bitmaps equal? @param a - pointer to a bitmap @param b - pointer to a bitmap @returns 1 if the bitmaps are equal, 0 otherwise */ always_inline uword clib_bitmap_is_equal (uword * a, uword * b) { uword i; if (vec_len (a) != vec_len (b)) return 0; for (i = 0; i < vec_len (a); i++) if (a[i] != b[i]) return 0; return 1; } /** Duplicate a bitmap @param v - pointer to a bitmap @returns a duplicate of the bitmap */ #define clib_bitmap_dup(v) vec_dup(v) /** Free a bitmap @param v - pointer to the bitmap to free */ #define clib_bitmap_free(v) vec_free(v) /** Number of bytes in a bitmap @param v - pointer to the bitmap */ #define clib_bitmap_bytes(v) vec_bytes(v) /** Clear a bitmap @param v - pointer to the bitmap to clear */ #define clib_bitmap_zero(v) vec_zero(v) /** Allocate a bitmap with the supplied number of bits @param [out] v - the resulting bitmap @param n_bits - the required number of bits */ #define clib_bitmap_alloc(v,n_bits) \ v = vec_new (uword, ((n_bits) + BITS (uword) - 1) / BITS (uword)) #define clib_bitmap_vec_validate(v,i) vec_validate_aligned((v),(i),sizeof(uword)) /* Make sure that a bitmap is at least n_bits in size */ #define clib_bitmap_validate(v,n_bits) \ clib_bitmap_vec_validate ((v), ((n_bits) - 1) / BITS (uword)) /* low-level routine to remove trailing zeros from a bitmap */ always_inline uword * _clib_bitmap_remove_trailing_zeros (uword * a) { word i; if (a) { for (i = _vec_len (a) - 1; i >= 0; i--) if (a[i] != 0) break; _vec_len (a) = i + 1; } return a; } /** Sets the ith bit of a bitmap to new_value. No sanity checking. Be careful. @param a - pointer to the bitmap @param i - the bit position to interrogate @param new_value - new value for the bit @returns the old value of the bit */ always_inline uword clib_bitmap_set_no_check (uword * a, uword i, uword new_value) { uword i0 = i / BITS (a[0]); uword i1 = i % BITS (a[0]); uword bit = (uword) 1 << i1; uword ai, old_value; /* Removed ASSERT since uword * a may not be a vector. */ /* ASSERT (i0 < vec_len (a)); */ ai = a[i0]; old_value = (ai & bit) != 0; ai &= ~bit; ai |= ((uword) (new_value != 0)) << i1; a[i0] = ai; return old_value; } /** Sets the ith bit of a bitmap to new_value Removes trailing zeros from the bitmap @param ai - pointer to the bitmap @param i - the bit position to interrogate @param value - new value for the bit @returns the old value of the bit */ always_inline uword * clib_bitmap_set (uword * ai, uword i, uword value) { uword i0 = i / BITS (ai[0]); uword i1 = i % BITS (ai[0]); uword a; /* Check for writing a zero to beyond end of bitmap. */ if (value == 0 && i0 >= vec_len (ai)) return ai; /* Implied trailing zeros. */ clib_bitmap_vec_validate (ai, i0); a = ai[i0]; a &= ~((uword) 1 << i1); a |= ((uword) (value != 0)) << i1; ai[i0] = a; /* If bits have been cleared, test for zero. */ if (a == 0) ai = _clib_bitmap_remove_trailing_zeros (ai); return ai; } /** Gets the ith bit value from a bitmap @param ai - pointer to the bitmap @param i - the bit position to interrogate @returns the indicated bit value */ always_inline uword clib_bitmap_get (uword * ai, uword i) { uword i0 = i / BITS (ai[0]); uword i1 = i % BITS (ai[0]); return i0 < vec_len (ai) && 0 != ((ai[i0] >> i1) & 1); } /** Gets the ith bit value from a bitmap Does not sanity-check the bit position. Be careful. @param ai - pointer to the bitmap @param i - the bit position to interrogate @returns the indicated bit value, or garbage if the bit position is out of range. */ always_inline uword clib_bitmap_get_no_check (uword * ai, uword i) { uword i0 = i / BITS (ai[0]); uword i1 = i % BITS (ai[0]); return 0 != ((ai[i0] >> i1) & 1); } always_inline uword clib_bitmap_get_multiple_no_check (uword * ai, uword i, uword n_bits) { uword i0 = i / BITS (ai[0]); uword i1 = i % BITS (ai[0]); ASSERT (i1 + n_bits <= BITS (uword)); return 0 != ((ai[i0] >> i1) & pow2_mask (n_bits)); } /** Gets the ith through ith + n_bits bit values from a bitmap @param bitmap - pointer to the bitmap @param i - the first bit position to retrieve @param n_bits - the number of bit positions to retrieve @returns the indicated range of bits */ always_inline uword clib_bitmap_get_multiple (uword * bitmap, uword i, uword n_bits) { uword i0, i1, result; uword l = vec_len (bitmap); ASSERT (n_bits <= BITS (result)); i0 = i / BITS (bitmap[0]); i1 = i % BITS (bitmap[0]); /* Check first word. */ result = 0; if (i0 < l) { result |= (bitmap[i0] >> i1); if (n_bits < BITS (bitmap[0])) result &= (((uword) 1 << n_bits) - 1); } /* Check for overlap into next word. */ i0++; if (i1 + n_bits > BITS (bitmap[0]) && i0 < l) { n_bits -= BITS (bitmap[0]) - i1; result |= (bitmap[i0] & (((uword) 1 << n_bits) - 1)) << (BITS (bitmap[0]) - i1); } return result; } /** sets the ith through ith + n_bits bits in a bitmap @param bitmap - pointer to the bitmap @param i - the first bit position to retrieve @param value - the values to set @param n_bits - the number of bit positions to set @returns a pointer to the updated bitmap, which may expand and move */ always_inline uword * clib_bitmap_set_multiple (uword * bitmap, uword i, uword value, uword n_bits) { uword i0, i1, l, t, m; ASSERT (n_bits <= BITS (value)); i0 = i / BITS (bitmap[0]); i1 = i % BITS (bitmap[0]); /* Allocate bitmap. */ clib_bitmap_vec_validate (bitmap, (i + n_bits) / BITS (bitmap[0])); l = vec_len (bitmap); m = ~0; if (n_bits < BITS (value)) m = (((uword) 1 << n_bits) - 1); value &= m; /* Insert into first word. */ t = bitmap[i0]; t &= ~(m << i1); t |= value << i1; bitmap[i0] = t; /* Insert into second word. */ i0++; if (i1 + n_bits > BITS (bitmap[0]) && i0 < l) { t = BITS (bitmap[0]) - i1; value >>= t; n_bits -= t; t = bitmap[i0]; m = ((uword) 1 << n_bits) - 1; t &= ~m; t |= value; bitmap[i0] = t; } return bitmap; } always_inline uword * clfib_bitmap_set_region (uword * bitmap, uword i, uword value, uword n_bits) { uword a0, a1, b0; uword i_end, mask; a0 = i / BITS (bitmap[0]); a1 = i % BITS (bitmap[0]); i_end = i + n_bits; b0 = i_end / BITS (bitmap[0]); clib_bitmap_vec_validate (bitmap, b0); /* First word. */ mask = n_bits < BITS (bitmap[0]) ? pow2_mask (n_bits) : ~0; mask <<= a1; if (value) bitmap[a0] |= mask; else bitmap[a0] &= ~mask; for (a0++; a0 < b0; a0++) bitmap[a0] = value ? ~0 : 0; if (a0 == b0) { word n_bits_left = n_bits - (BITS (bitmap[0]) - a1); mask = pow2_mask (n_bits_left); if (value) bitmap[a0] |= mask; else bitmap[a0] &= ~mask; } return bitmap; } /** Macro to iterate across set bits in a bitmap @param i - the current set bit @param ai - the bitmap @param body - the expression to evaluate for each set bit */ #define clib_bitmap_foreach(i,ai,body) \ do { \ uword __bitmap_i, __bitmap_ai, __bitmap_len, __bitmap_first_set; \ __bitmap_len = vec_len ((ai)); \ for (__bitmap_i = 0; __bitmap_i < __bitmap_len; __bitmap_i++) \ { \ __bitmap_ai = (ai)[__bitmap_i]; \ while (__bitmap_ai != 0) \ { \ __bitmap_first_set = first_set (__bitmap_ai); \ (i) = (__bitmap_i * BITS ((ai)[0]) \ + min_log2 (__bitmap_first_set)); \ do { body; } while (0); \ __bitmap_ai ^= __bitmap_first_set; \ } \ } \ } while (0) /** Return the lowest numbered set bit in a bitmap @param ai - pointer to the bitmap @returns lowest numbered set bit, or ~0 if the entire bitmap is zero */ always_inline uword clib_bitmap_first_set (uword * ai) { uword i; for (i = 0; i < vec_len (ai); i++) { uword x = ai[i]; if (x != 0) return i * BITS (ai[0]) + log2_first_set (x); } return ~0; } /** Return the higest numbered set bit in a bitmap @param ai - pointer to the bitmap @returns lowest numbered set bit, or ~0 if the entire bitmap is zero */ always_inline uword clib_bitmap_last_set (uword * ai) { uword i; for (i = vec_len (ai); i > 0; i--) { uword x = ai[i - 1]; if (x != 0) { uword first_bit; count_leading_zeros (first_bit, x); return (i) * BITS (ai[0]) - first_bit - 1; } } return ~0; } /** Return the lowest numbered clear bit in a bitmap @param ai - pointer to the bitmap @returns lowest numbered clear bit */ always_inline uword clib_bitmap_first_clear (uword * ai) { uword i; for (i = 0; i < vec_len (ai); i++) { uword x = ~ai[i]; if (x != 0) return i * BITS (ai[0]) + log2_first_set (x); } return i * BITS (ai[0]); } /** Return the number of set bits in a bitmap @param ai - pointer to the bitmap @returns the number of set bits in the bitmap */ always_inline uword clib_bitmap_count_set_bits (uword * ai) { uword i; uword n_set = 0; for (i = 0; i < vec_len (ai); i++) n_set += count_set_bits (ai[i]); return n_set; } /** Logical operator across two bitmaps @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns ai = ai and bi. ai is modified, bi is not modified */ always_inline uword *clib_bitmap_and (uword * ai, uword * bi); /** Logical operator across two bitmaps @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns ai = ai & ~bi. ai is modified, bi is not modified */ always_inline uword *clib_bitmap_andnot (uword * ai, uword * bi); /** Logical operator across two bitmaps @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns ai = ai & ~bi. ai is modified, bi is not modified */ always_inline uword *clib_bitmap_or (uword * ai, uword * bi); /** Logical operator across two bitmaps @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns ai = ai or bi. ai is modified, bi is not modified */ always_inline uword *clib_bitmap_or (uword * ai, uword * bi); /** Logical operator across two bitmaps @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns ai = ai xor bi. ai is modified, bi is not modified */ always_inline uword *clib_bitmap_xor (uword * ai, uword * bi); /* ALU function definition macro for functions taking two bitmaps. */ #define _(name, body, check_zero) \ always_inline uword * \ clib_bitmap_##name (uword * ai, uword * bi) \ { \ uword i, a, b, bi_len, n_trailing_zeros; \ \ n_trailing_zeros = 0; \ bi_len = vec_len (bi); \ if (bi_len > 0) \ clib_bitmap_vec_validate (ai, bi_len - 1); \ for (i = 0; i < vec_len (ai); i++) \ { \ a = ai[i]; \ b = i < bi_len ? bi[i] : 0; \ do { body; } while (0); \ ai[i] = a; \ if (check_zero) \ n_trailing_zeros = a ? 0 : (n_trailing_zeros + 1); \ } \ if (check_zero) \ _vec_len (ai) -= n_trailing_zeros; \ return ai; \ } /* ALU functions: */ _(and, a = a & b, 1) _(andnot, a = a & ~b, 1) _(or, a = a | b, 0) _(xor, a = a ^ b, 1) #undef _ /** Logical operator across two bitmaps which duplicates the first bitmap @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns aiDup = ai and bi. Neither ai nor bi are modified */ always_inline uword * clib_bitmap_dup_and (uword * ai, uword * bi); /** Logical operator across two bitmaps which duplicates the first bitmap @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns aiDup = ai & ~bi. Neither ai nor bi are modified */ always_inline uword * clib_bitmap_dup_andnot (uword * ai, uword * bi); /** Logical operator across two bitmaps which duplicates the first bitmap @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns aiDup = ai or bi. Neither ai nor bi are modified */ always_inline uword * clib_bitmap_dup_or (uword * ai, uword * bi); /** Logical operator across two bitmaps which duplicates the first bitmap @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns aiDup = ai xor bi. Neither ai nor bi are modified */ always_inline uword * clib_bitmap_dup_xor (uword * ai, uword * bi); #define _(name) \ always_inline uword * \ clib_bitmap_dup_##name (uword * ai, uword * bi) \ { return clib_bitmap_##name (clib_bitmap_dup (ai), bi); } _(and); _(andnot); _(or); _(xor); #undef _ /* ALU function definition macro for functions taking one bitmap and an immediate. */ #define _(name, body, check_zero) \ always_inline uword * \ clib_bitmap_##name (uword * ai, uword i) \ { \ uword i0 = i / BITS (ai[0]); \ uword i1 = i % BITS (ai[0]); \ uword a, b; \ clib_bitmap_vec_validate (ai, i0); \ a = ai[i0]; \ b = (uword) 1 << i1; \ do { body; } while (0); \ ai[i0] = a; \ if (check_zero && a == 0) \ ai = _clib_bitmap_remove_trailing_zeros (ai); \ return ai; \ } /* ALU functions immediate: */ _(andi, a = a & b, 1) _(andnoti, a = a & ~b, 1) _(ori, a = a | b, 0) _(xori, a = a ^ b, 1) #undef _ /** Return a random bitmap of the requested length @param ai - pointer to the destination bitmap @param n_bits - number of bits to allocate @param [in,out] seed - pointer to the random number seed @returns a reasonably random bitmap based. See random.h. */ always_inline uword * clib_bitmap_random (uword * ai, uword n_bits, u32 * seed) { vec_reset_length (ai); if (n_bits > 0) { uword i = n_bits - 1; uword i0, i1; uword log2_rand_max; log2_rand_max = min_log2 (random_u32_max ()); i0 = i / BITS (ai[0]); i1 = i % BITS (ai[0]); clib_bitmap_vec_validate (ai, i0); for (i = 0; i <= i0; i++) { uword n; for (n = 0; n < BITS (ai[i]); n += log2_rand_max) ai[i] |= random_u32 (seed) << n; } if (i1 + 1 < BITS (ai[0])) ai[i0] &= (((uword) 1 << (i1 + 1)) - 1); } return ai; } /** Return the next set bit in a bitmap starting at bit i @param ai - pointer to the bitmap @param i - first bit position to test @returns first set bit position at or after i, ~0 if no further set bits are found */ always_inline uword clib_bitmap_next_set (uword * ai, uword i) { uword i0 = i / BITS (ai[0]); uword i1 = i % BITS (ai[0]); uword t; if (i0 < vec_len (ai)) { t = (ai[i0] >> i1) << i1; if (t) return log2_first_set (t) + i0 * BITS (ai[0]); for (i0++; i0 < vec_len (ai); i0++) { t = ai[i0]; if (t) return log2_first_set (t) + i0 * BITS (ai[0]); } } return ~0; } /** Return the next clear bit in a bitmap starting at bit i @param ai - pointer to the bitmap @param i - first bit position to test @returns first clear bit position at or after i */ always_inline uword clib_bitmap_next_clear (uword * ai, uword i) { uword i0 = i / BITS (ai[0]); uword i1 = i % BITS (ai[0]); uword t; if (i0 < vec_len (ai)) { t = (~ai[i0] >> i1) << i1; if (t) return log2_first_set (t) + i0 * BITS (ai[0]); for (i0++; i0 < vec_len (ai); i0++) { t = ~ai[i0]; if (t) return log2_first_set (t) + i0 * BITS (ai[0]); } } return i; } /** unformat a list of bit ranges into a bitmap (eg "0-3,5-7,11" ) uword * bitmap; rv = unformat ("%U", unformat_bitmap_list, &bitmap); Standard unformat_function_t arguments @param input - pointer an unformat_input_t @param va - varargs list comprising a single uword ** @returns 1 on success, 0 on failure */ static inline uword unformat_bitmap_list (unformat_input_t * input, va_list * va) { uword **bitmap_return = va_arg (*va, uword **); uword *bitmap = 0; u32 a, b; while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { int i; if (unformat (input, "%u-%u,", &a, &b)) ; else if (unformat (input, "%u,", &a)) b = a; else if (unformat (input, "%u-%u", &a, &b)) ; else if (unformat (input, "%u", &a)) b = a; else if (bitmap) { unformat_put_input (input); break; } else goto error; if (b < a) goto error; for (i = a; i <= b; i++) bitmap = clib_bitmap_set (bitmap, i, 1); } *bitmap_return = bitmap; return 1; error: clib_bitmap_free (bitmap); return 0; } /** Format a bitmap as a string of hex bytes uword * bitmap; s = format ("%U", format_bitmap_hex, bitmap); Standard format_function_t arguments @param s - string under construction @param args - varargs list comprising a single uword * @returns string under construction */ static inline u8 * format_bitmap_hex (u8 * s, va_list * args) { uword *bitmap = va_arg (*args, uword *); int i, is_trailing_zero = 1; if (!bitmap) return format (s, "0"); i = vec_bytes (bitmap) * 2; while (i > 0) { u8 x = clib_bitmap_get_multiple (bitmap, --i * 4, 4); if (x && is_trailing_zero) is_trailing_zero = 0; if (x || !is_trailing_zero) s = format (s, "%x", x); } return s; } #endif /* included_clib_bitmap_h */ /* * fd.io coding-style-patch-verification: ON * * Local Variables: * eval: (c-set-style "gnu") * End: */