diff options
| -rw-r--r-- | src/plugins/unittest/svm_fifo_test.c | 115 | ||||
| -rw-r--r-- | src/svm/fifo_segment.c | 483 | ||||
| -rw-r--r-- | src/svm/fifo_segment.h | 58 | ||||
| -rw-r--r-- | src/svm/ssvm.c | 4 | ||||
| -rw-r--r-- | src/vnet/session/segment_manager.c | 11 |
5 files changed, 471 insertions, 200 deletions
diff --git a/src/plugins/unittest/svm_fifo_test.c b/src/plugins/unittest/svm_fifo_test.c index afd803b15b8..acf862a1790 100644 --- a/src/plugins/unittest/svm_fifo_test.c +++ b/src/plugins/unittest/svm_fifo_test.c @@ -1908,7 +1908,6 @@ sfifo_test_fifo_segment_hello_world (int verbose) a->segment_size = 256 << 10; rv = fifo_segment_create (sm, a); - SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv); fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]); @@ -2275,10 +2274,116 @@ sfifo_test_fifo_segment_mempig (int verbose) } static int +sfifo_test_fifo_segment_prealloc (int verbose) +{ + fifo_segment_create_args_t _a, *a = &_a; + fifo_segment_main_t *sm = &segment_main; + u32 max_pairs, pairs_req, free_space, pair_mem; + svm_fifo_t *f, *old; + fifo_segment_t *fs; + int rv; + + clib_memset (a, 0, sizeof (*a)); + + a->segment_name = "fifo-test-prealloc"; + a->segment_size = 256 << 10; + a->segment_type = SSVM_SEGMENT_MEMFD; + + rv = fifo_segment_create (sm, a); + SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv); + fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]); + + /* + * Prealloc chunks and headers + */ + free_space = fifo_segment_free_bytes (fs); + SFIFO_TEST (free_space <= 256 << 10, "free space expected %u is %u", + 256 << 10, free_space); + rv = fifo_segment_prealloc_fifo_chunks (fs, 4096, 50); + SFIFO_TEST (rv == 0, "chunk prealloc should work"); + rv = fifo_segment_num_free_chunks (fs, 4096); + SFIFO_TEST (rv == 50, "prealloc chunks expected %u is %u", 50, rv); + rv = fifo_segment_free_bytes (fs); + free_space -= (sizeof (svm_fifo_chunk_t) + 4096) * 50; + SFIFO_TEST (rv == free_space, "free space expected %u is %u", free_space, + rv); + rv = fifo_segment_chunk_prealloc_bytes (fs); + SFIFO_TEST (rv == 4096 * 50, "chunk free space expected %u is %u", + 4096 * 50, rv); + + rv = fifo_segment_prealloc_fifo_hdrs (fs, 50); + SFIFO_TEST (rv == 0, "fifo hdr prealloc should work"); + rv = fifo_segment_num_free_fifos (fs); + SFIFO_TEST (rv == 50, "prealloc fifo hdrs expected %u is %u", 50, rv); + rv = fifo_segment_free_bytes (fs); + free_space -= sizeof (svm_fifo_t) * 50; + SFIFO_TEST (rv == free_space, "free space expected %u is %u", free_space, + rv); + + fifo_segment_update_free_bytes (fs); + rv = fifo_segment_free_bytes (fs); + SFIFO_TEST (clib_abs (rv - (int) free_space) < 512, + "free space expected %u is %u", free_space, rv); + + f = fifo_segment_alloc_fifo (fs, 200 << 10, FIFO_SEGMENT_RX_FIFO); + SFIFO_TEST (f != 0, "fifo allocated"); + rv = fifo_segment_num_free_chunks (fs, 4096); + SFIFO_TEST (rv == 0, "prealloc chunks expected %u is %u", 0, rv); + rv = fifo_segment_chunk_prealloc_bytes (fs); + SFIFO_TEST (rv == 0, "chunk free space expected %u is %u", 0, rv); + + /* + * Multiple preallocs that consume the remaining space + */ + pair_mem = 2 * (4096 + sizeof (*f) + sizeof (svm_fifo_chunk_t)); + max_pairs = pairs_req = free_space / pair_mem - 1; + fifo_segment_preallocate_fifo_pairs (fs, 4096, 4096, &pairs_req); + SFIFO_TEST (pairs_req == 0, "prealloc pairs should work"); + rv = fifo_segment_num_free_chunks (fs, 4096); + SFIFO_TEST (rv == max_pairs * 2, "prealloc chunks expected %u is %u", + max_pairs * 2, rv); + + rv = fifo_segment_prealloc_fifo_chunks (fs, 4096, 2); + SFIFO_TEST (rv == 0, "chunk prealloc should work"); + rv = fifo_segment_num_free_chunks (fs, 4096); + SFIFO_TEST (rv == (max_pairs + 1) * 2, "prealloc chunks expected %u is %u", + (max_pairs + 1) * 2, rv); + + free_space = fifo_segment_free_bytes (fs); + SFIFO_TEST (rv < 8192, "free bytes expected less than %u is %u", 8192, rv); + + /* + * Test negative prealloc cases + */ + pairs_req = 1; + fifo_segment_preallocate_fifo_pairs (fs, 4096, 4096, &pairs_req); + SFIFO_TEST (pairs_req == 1, "prealloc pairs should not work"); + + old = f; + f = fifo_segment_alloc_fifo (fs, 200 << 10, FIFO_SEGMENT_RX_FIFO); + SFIFO_TEST (f == 0, "fifo alloc should fail"); + + rv = fifo_segment_prealloc_fifo_chunks (fs, 4096, 50); + SFIFO_TEST (rv == -1, "chunk prealloc should fail"); + + rv = fifo_segment_prealloc_fifo_hdrs (fs, 50); + SFIFO_TEST (rv == -1, "fifo hdr prealloc should fail"); + + /* + * Cleanup + */ + fifo_segment_free_fifo (fs, old); + close (fs->ssvm.fd); + fifo_segment_delete (sm, fs); + return 0; +} + +static int sfifo_test_fifo_segment (vlib_main_t * vm, unformat_input_t * input) { int rv, verbose = 0; + fifo_segment_main_init (&segment_main, 3ULL << 30, 5); while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { if (unformat (input, "verbose")) @@ -2308,6 +2413,11 @@ sfifo_test_fifo_segment (vlib_main_t * vm, unformat_input_t * input) if ((rv = sfifo_test_fifo_segment_fifo_shrink (verbose))) return -1; } + else if (unformat (input, "prealloc")) + { + if ((rv = sfifo_test_fifo_segment_prealloc (verbose))) + return -1; + } else if (unformat (input, "all")) { if ((rv = sfifo_test_fifo_segment_hello_world (verbose))) @@ -2318,6 +2428,8 @@ sfifo_test_fifo_segment (vlib_main_t * vm, unformat_input_t * input) return -1; if ((rv = sfifo_test_fifo_segment_fifo_shrink (verbose))) return -1; + if ((rv = sfifo_test_fifo_segment_prealloc (verbose))) + return -1; /* Pretty slow so avoid running it always if ((rv = sfifo_test_fifo_segment_master_slave (verbose))) return -1; @@ -2340,6 +2452,7 @@ svm_fifo_test (vlib_main_t * vm, unformat_input_t * input, int res = 0; char *str; + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { if (unformat (input, "fifo1")) diff --git a/src/svm/fifo_segment.c b/src/svm/fifo_segment.c index fdbc8102587..04b3f5aadbe 100644 --- a/src/svm/fifo_segment.c +++ b/src/svm/fifo_segment.c @@ -16,6 +16,25 @@ #include <svm/fifo_segment.h> /** + * Fifo segment free space + * + * Queries the underlying memory manager, dlmalloc, for free space. Since this + * ends up walking the internal data structures, it should not be called + * indiscriminately. + * + * @param fs fifo segment + * @return number of free bytes + */ +static u32 +fs_free_space (fifo_segment_t * fs) +{ + struct dlmallinfo dlminfo; + + dlminfo = mspace_mallinfo (fs->ssvm.sh->heap); + return dlminfo.fordblks; +} + +/** * Initialize fifo segment shared header */ int @@ -34,97 +53,42 @@ fifo_segment_init (fifo_segment_t * fs) ssvm_pop_heap (oldheap); + fsh->n_free_bytes = fs_free_space (fs); sh->ready = 1; return (0); } /** - * Create a fifo segment in process-private memory - */ -static int -fifo_segment_create_process_private (fifo_segment_main_t * sm, - fifo_segment_create_args_t * a) -{ - u32 pagesize = clib_mem_get_page_size (); - ssvm_shared_header_t *sh; - fifo_segment_t *s; - u32 rnd_size = 0; - u8 *heap; - - pool_get (sm->segments, s); - clib_memset (s, 0, sizeof (*s)); - - rnd_size = (a->segment_size + (pagesize - 1)) & ~pagesize; - -#if USE_DLMALLOC == 0 - heap = mheap_alloc (0, rnd_size); - if (heap == 0) - { - clib_unix_warning ("mheap alloc"); - pool_put (sm->segments, s); - return -1; - } - { - mheap_t *heap_header; - heap_header = mheap_header (heap); - heap_header->flags |= MHEAP_FLAG_THREAD_SAFE; - } -#else - heap = create_mspace (rnd_size, 1 /* locked */ ); -#endif - - s->ssvm.ssvm_size = rnd_size; - s->ssvm.i_am_master = 1; - s->ssvm.my_pid = getpid (); - s->ssvm.name = format (0, "%s%c", a->segment_name, 0); - s->ssvm.requested_va = ~0; - - /* Allocate a [sic] shared memory header, in process memory... */ - sh = clib_mem_alloc_aligned (sizeof (*sh), CLIB_CACHE_LINE_BYTES); - s->ssvm.sh = sh; - - clib_memset (sh, 0, sizeof (*sh)); - sh->heap = heap; - - fifo_segment_init (s); - vec_add1 (a->new_segment_indices, s - sm->segments); - - return (0); -} - -/** * Create a fifo segment and initialize as master */ int fifo_segment_create (fifo_segment_main_t * sm, fifo_segment_create_args_t * a) { - fifo_segment_t *s; + fifo_segment_t *fs; + uword baseva; int rv; - if (a->segment_type == SSVM_SEGMENT_PRIVATE) - return fifo_segment_create_process_private (sm, a); - /* Allocate a fresh segment */ - pool_get (sm->segments, s); - clib_memset (s, 0, sizeof (*s)); + pool_get_zero (sm->segments, fs); - s->ssvm.ssvm_size = a->segment_size; - s->ssvm.i_am_master = 1; - s->ssvm.my_pid = getpid (); - s->ssvm.name = format (0, "%s%c", a->segment_name, 0); - s->ssvm.requested_va = sm->next_baseva; + baseva = a->segment_type == SSVM_SEGMENT_PRIVATE ? ~0ULL : sm->next_baseva; + fs->ssvm.ssvm_size = a->segment_size; + fs->ssvm.i_am_master = 1; + fs->ssvm.my_pid = getpid (); + fs->ssvm.name = format (0, "%s%c", a->segment_name, 0); + fs->ssvm.requested_va = baseva; - if ((rv = ssvm_master_init (&s->ssvm, a->segment_type))) + if ((rv = ssvm_master_init (&fs->ssvm, a->segment_type))) { - pool_put (sm->segments, s); + pool_put (sm->segments, fs); return (rv); } /* Note: requested_va updated due to seg base addr randomization */ - sm->next_baseva = s->ssvm.sh->ssvm_va + a->segment_size; + sm->next_baseva = fs->ssvm.sh->ssvm_va + fs->ssvm.ssvm_size; - fifo_segment_init (s); - vec_add1 (a->new_segment_indices, s - sm->segments); + fifo_segment_init (fs); + vec_add1 (a->new_segment_indices, fs - sm->segments); return (0); } @@ -202,25 +166,16 @@ fifo_segment_main_init (fifo_segment_main_t * sm, u64 baseva, sm->timeout_in_seconds = timeout_in_seconds; } -static void -fifo_init_for_segment (svm_fifo_t * f, svm_fifo_chunk_t * c) -{ - f->start_chunk = f->end_chunk = c->next = c; - f->head_chunk = f->tail_chunk = f->ooo_enq = f->ooo_deq = f->start_chunk; -} - -static void -fifo_init_chunk_for_segment (svm_fifo_chunk_t * c, u32 size) +static inline u32 +fs_freelist_for_size (u32 size) { - c->start_byte = 0; - c->length = size; - c->next = 0; + return max_log2 (size) - max_log2 (FIFO_SEGMENT_MIN_FIFO_SIZE); } -static inline int -fs_free_list_for_size (u32 size) +static inline u32 +fs_freelist_index_to_size (u32 fl_index) { - return max_log2 (size) - max_log2 (FIFO_SEGMENT_MIN_FIFO_SIZE); + return 1 << (fl_index + max_log2 (FIFO_SEGMENT_MIN_FIFO_SIZE)); } static inline int @@ -235,15 +190,13 @@ fs_chunk_size_is_valid (u32 size) } static svm_fifo_t * -fs_try_alloc_fifo_from_freelist (fifo_segment_header_t * fsh, u32 data_bytes) +fs_try_alloc_fifo_freelist (fifo_segment_t * fs, u32 fl_index, u32 data_bytes) { + fifo_segment_header_t *fsh = fs->h; svm_fifo_chunk_t *c; svm_fifo_t *f; - u32 fl_index; f = fsh->free_fifos; - fl_index = fs_free_list_for_size (data_bytes); - vec_validate_init_empty (fsh->free_chunks, fl_index, 0); c = fsh->free_chunks[fl_index]; if (!f || !c) @@ -257,28 +210,79 @@ fs_try_alloc_fifo_from_freelist (fifo_segment_header_t * fsh, u32 data_bytes) memset (f, 0, sizeof (*f)); f->start_chunk = c; f->end_chunk = c; + + fsh->n_fl_chunk_bytes -= fs_freelist_index_to_size (fl_index); return f; } static svm_fifo_t * -fs_try_allocate_fifo_batch (ssvm_shared_header_t * sh, - fifo_segment_header_t * fsh, u32 data_bytes) +fs_try_alloc_fifo_freelist_multi_chunk (fifo_segment_t * fs, u32 data_bytes) { - u32 size, rounded_data_size; + svm_fifo_chunk_t *c, *first = 0, *last = 0; + fifo_segment_header_t *fsh = fs->h; + u32 fl_index, fl_size, n_alloc = 0; + svm_fifo_t *f; + + f = fsh->free_fifos; + if (!f) + { + void *oldheap = ssvm_push_heap (fs->ssvm.sh); + f = clib_mem_alloc_aligned (sizeof (*f), CLIB_CACHE_LINE_BYTES); + ssvm_pop_heap (oldheap); + if (!f) + return 0; + memset (f, 0, sizeof (*f)); + } + + fl_index = fs_freelist_for_size (data_bytes) - 1; + vec_validate_init_empty (fsh->free_chunks, fl_index, 0); + fl_size = fs_freelist_index_to_size (fl_index); + + while (data_bytes) + { + c = fsh->free_chunks[fl_index]; + if (c) + { + fsh->free_chunks[fl_index] = c->next; + if (!last) + last = c; + c->next = first; + first = c; + n_alloc += c->length; + c->length = clib_min (fl_size, data_bytes); + data_bytes -= c->length; + } + else + { + ASSERT (fl_index > 0); + fl_index -= 1; + fl_size = fl_size >> 1; + } + } + f->start_chunk = first; + f->end_chunk = last; + last->next = first; + fsh->n_fl_chunk_bytes -= n_alloc; + return f; +} + +static int +fs_try_alloc_fifo_batch (fifo_segment_t * fs, u32 fl_index, u32 batch_size) +{ + fifo_segment_header_t *fsh = fs->h; + u32 size, hdrs, rounded_data_size; svm_fifo_chunk_t *c; - u32 fl_index, hdrs; svm_fifo_t *f; void *oldheap; u8 *fmem; int i; - rounded_data_size = (1 << (max_log2 (data_bytes))); - fl_index = fs_free_list_for_size (data_bytes); vec_validate_init_empty (fsh->free_chunks, fl_index, 0); - - oldheap = ssvm_push_heap (sh); + rounded_data_size = fs_freelist_index_to_size (fl_index); hdrs = sizeof (*f) + sizeof (*c); - size = (hdrs + rounded_data_size) * FIFO_SEGMENT_ALLOC_BATCH_SIZE; + size = (hdrs + rounded_data_size) * batch_size; + + oldheap = ssvm_push_heap (fs->ssvm.sh); fmem = clib_mem_alloc_aligned_at_offset (size, CLIB_CACHE_LINE_BYTES, 0 /* align_offset */ , 0 /* os_out_of_memory */ ); @@ -286,10 +290,10 @@ fs_try_allocate_fifo_batch (ssvm_shared_header_t * sh, /* Out of space.. */ if (fmem == 0) - return 0; + return -1; /* Carve fifo + chunk space */ - for (i = 0; i < FIFO_SEGMENT_ALLOC_BATCH_SIZE; i++) + for (i = 0; i < batch_size; i++) { f = (svm_fifo_t *) fmem; memset (f, 0, sizeof (*f)); @@ -303,7 +307,65 @@ fs_try_allocate_fifo_batch (ssvm_shared_header_t * sh, fmem += hdrs + rounded_data_size; } - return fs_try_alloc_fifo_from_freelist (fsh, data_bytes); + fsh->n_fl_chunk_bytes += batch_size * rounded_data_size; + fsh->n_free_bytes -= size; + + return 0; +} + +/** + * Try to allocate new fifo + * + * Tries the following steps in order: + * - grab fifo and chunk from freelists + * - batch fifo and chunk allocation + * - single fifo allocation + * - grab multiple fifo chunks from freelists + */ +static svm_fifo_t * +fs_try_alloc_fifo (fifo_segment_t * fs, u32 data_bytes) +{ + fifo_segment_header_t *fsh = fs->h; + u32 fifo_sz, fl_index; + svm_fifo_t *f = 0; + + fl_index = fs_freelist_for_size (data_bytes); + vec_validate_init_empty (fsh->free_chunks, fl_index, 0); + fifo_sz = sizeof (svm_fifo_t) + sizeof (svm_fifo_chunk_t); + fifo_sz += 1 << max_log2 (data_bytes); + + if (fsh->free_fifos && fsh->free_chunks[fl_index]) + { + f = fs_try_alloc_fifo_freelist (fs, fl_index, data_bytes); + if (f) + goto done; + } + if (fifo_sz * FIFO_SEGMENT_ALLOC_BATCH_SIZE < fsh->n_free_bytes) + { + if (fs_try_alloc_fifo_batch (fs, fl_index, + FIFO_SEGMENT_ALLOC_BATCH_SIZE)) + goto done; + + f = fs_try_alloc_fifo_freelist (fs, fl_index, data_bytes); + goto done; + } + if (fifo_sz <= fsh->n_free_bytes) + { + void *oldheap = ssvm_push_heap (fs->ssvm.sh); + f = svm_fifo_create (data_bytes); + ssvm_pop_heap (oldheap); + if (f) + { + fsh->n_free_bytes -= fifo_sz; + goto done; + } + } + if (data_bytes <= fsh->n_fl_chunk_bytes) + f = fs_try_alloc_fifo_freelist_multi_chunk (fs, data_bytes); + +done: + + return f; } /** @@ -314,7 +376,6 @@ fifo_segment_alloc_fifo (fifo_segment_t * fs, u32 data_bytes, fifo_segment_ftype_t ftype) { fifo_segment_header_t *fsh; - ssvm_shared_header_t *sh; svm_fifo_t *f = 0; if (!fs_chunk_size_is_valid (data_bytes)) @@ -323,26 +384,12 @@ fifo_segment_alloc_fifo (fifo_segment_t * fs, u32 data_bytes, return 0; } - sh = fs->ssvm.sh; - ssvm_lock_non_recursive (sh, 1); fsh = fs->h; + ssvm_lock_non_recursive (fs->ssvm.sh, 1); - /* Try the following steps in order: - * - grab fifo and chunk from freelists - * - batch fifo and chunk allocation - * - single fifo allocation - */ - f = fs_try_alloc_fifo_from_freelist (fsh, data_bytes); + f = fs_try_alloc_fifo (fs, data_bytes); if (!f) - f = fs_try_allocate_fifo_batch (sh, fsh, data_bytes); - if (!f) - { - void *oldheap = ssvm_push_heap (sh); - f = svm_fifo_create (data_bytes); - ssvm_pop_heap (oldheap); - if (!f) - goto done; - } + goto done; /* (re)initialize the fifo, as in svm_fifo_create */ svm_fifo_init (f, data_bytes); @@ -364,7 +411,7 @@ fifo_segment_alloc_fifo (fifo_segment_t * fs, u32 data_bytes, fsh->n_active_fifos++; done: - ssvm_unlock_non_recursive (sh); + ssvm_unlock_non_recursive (fs->ssvm.sh); return (f); } @@ -412,10 +459,11 @@ fifo_segment_free_fifo (fifo_segment_t * fs, svm_fifo_t * f) do { next = cur->next; - fl_index = fs_free_list_for_size (cur->length); + fl_index = fs_freelist_for_size (cur->length); ASSERT (fl_index < vec_len (fsh->free_chunks)); cur->next = fsh->free_chunks[fl_index]; fsh->free_chunks[fl_index] = cur; + fsh->n_fl_chunk_bytes += fs_freelist_index_to_size (fl_index); cur = next; } while (cur != f->start_chunk); @@ -437,6 +485,92 @@ fifo_segment_free_fifo (fifo_segment_t * fs, svm_fifo_t * f) ssvm_unlock_non_recursive (sh); } +int +fifo_segment_prealloc_fifo_hdrs (fifo_segment_t * fs, u32 batch_size) +{ + fifo_segment_header_t *fsh = fs->h; + svm_fifo_t *f; + void *oldheap; + u32 size; + u8 *fmem; + int i; + + size = (sizeof (*f)) * batch_size; + + oldheap = ssvm_push_heap (fs->ssvm.sh); + fmem = clib_mem_alloc_aligned_at_offset (size, CLIB_CACHE_LINE_BYTES, + 0 /* align_offset */ , + 0 /* os_out_of_memory */ ); + ssvm_pop_heap (oldheap); + + /* Out of space.. */ + if (fmem == 0) + return -1; + + /* Carve fifo + chunk space */ + for (i = 0; i < batch_size; i++) + { + f = (svm_fifo_t *) fmem; + memset (f, 0, sizeof (*f)); + f->next = fsh->free_fifos; + fsh->free_fifos = f; + fmem += sizeof (*f); + } + + fsh->n_free_bytes -= size; + + return 0; +} + +int +fifo_segment_prealloc_fifo_chunks (fifo_segment_t * fs, u32 chunk_size, + u32 batch_size) +{ + fifo_segment_header_t *fsh = fs->h; + u32 size, rounded_data_size, fl_index; + svm_fifo_chunk_t *c; + void *oldheap; + u8 *cmem; + int i; + + if (!fs_chunk_size_is_valid (chunk_size)) + { + clib_warning ("chunk size out of range %d", chunk_size); + return -1; + } + + fl_index = fs_freelist_for_size (chunk_size); + vec_validate_init_empty (fsh->free_chunks, fl_index, 0); + rounded_data_size = fs_freelist_index_to_size (fl_index); + size = (sizeof (*c) + rounded_data_size) * batch_size; + + oldheap = ssvm_push_heap (fs->ssvm.sh); + cmem = clib_mem_alloc_aligned_at_offset (size, CLIB_CACHE_LINE_BYTES, + 0 /* align_offset */ , + 0 /* os_out_of_memory */ ); + ssvm_pop_heap (oldheap); + + /* Out of space.. */ + if (cmem == 0) + return -1; + + /* Carve fifo + chunk space */ + for (i = 0; i < batch_size; i++) + { + c = (svm_fifo_chunk_t *) cmem; + c->start_byte = 0; + c->length = rounded_data_size; + c->next = fsh->free_chunks[fl_index]; + fsh->free_chunks[fl_index] = c; + cmem += sizeof (*c) + rounded_data_size; + } + + fsh->n_fl_chunk_bytes += batch_size * rounded_data_size; + fsh->n_free_bytes -= size; + + return 0; +} + /** * Pre-allocates fifo pairs in fifo segment */ @@ -445,16 +579,9 @@ fifo_segment_preallocate_fifo_pairs (fifo_segment_t * fs, u32 rx_fifo_size, u32 tx_fifo_size, u32 * n_fifo_pairs) { - u32 rx_rounded_data_size, tx_rounded_data_size, pair_size; - u32 rx_fifos_size, tx_fifos_size, pairs_to_allocate; - ssvm_shared_header_t *sh = fs->ssvm.sh; - fifo_segment_header_t *fsh = fs->h; - int i, rx_fl_index, tx_fl_index; - u8 *rx_fifo_mem, *tx_fifo_mem; + u32 rx_rounded_data_size, tx_rounded_data_size, pair_size, pairs_to_alloc; + int rx_fl_index, tx_fl_index; uword space_available; - svm_fifo_chunk_t *c; - void *oldheap; - svm_fifo_t *f; u32 hdrs; /* Parameter check */ @@ -474,68 +601,24 @@ fifo_segment_preallocate_fifo_pairs (fifo_segment_t * fs, } rx_rounded_data_size = (1 << (max_log2 (rx_fifo_size))); - rx_fl_index = fs_free_list_for_size (rx_fifo_size); + rx_fl_index = fs_freelist_for_size (rx_fifo_size); tx_rounded_data_size = (1 << (max_log2 (tx_fifo_size))); - tx_fl_index = fs_free_list_for_size (tx_fifo_size); + tx_fl_index = fs_freelist_for_size (tx_fifo_size); - hdrs = sizeof (*f) + sizeof (*c); + hdrs = sizeof (svm_fifo_t) + sizeof (svm_fifo_chunk_t); /* Calculate space requirements */ pair_size = 2 * hdrs + rx_rounded_data_size + tx_rounded_data_size; -#if USE_DLMALLOC == 0 - space_available = fs->ssvm.ssvm_size - mheap_bytes (sh->heap); -#else - space_available = fs->ssvm.ssvm_size - mspace_usable_size (sh->heap); -#endif - - pairs_to_allocate = clib_min (space_available / pair_size, *n_fifo_pairs); - rx_fifos_size = (hdrs + rx_rounded_data_size) * pairs_to_allocate; - tx_fifos_size = (hdrs + tx_rounded_data_size) * pairs_to_allocate; + space_available = fs_free_space (fs); + pairs_to_alloc = clib_min (space_available / pair_size, *n_fifo_pairs); - vec_validate_init_empty (fsh->free_chunks, - clib_max (rx_fl_index, tx_fl_index), 0); - - oldheap = ssvm_push_heap (sh); - - /* Allocate rx and tx fifo memory. May fail. */ - rx_fifo_mem = clib_mem_alloc_aligned_at_offset (rx_fifos_size, - CLIB_CACHE_LINE_BYTES, - 0 /* align_offset */ , - 0 /* os_out_of_memory */ ); - tx_fifo_mem = clib_mem_alloc_aligned_at_offset (tx_fifos_size, - CLIB_CACHE_LINE_BYTES, - 0 /* align_offset */ , - 0 /* os_out_of_memory */ ); - - /* Make sure it worked. Clean up if it didn't... */ - if (rx_fifo_mem == 0 || tx_fifo_mem == 0) - { - rx_fifo_mem ? clib_mem_free (rx_fifo_mem) : clib_mem_free (tx_fifo_mem); - clib_warning ("fifo preallocation failure: rx size %d tx size %u " - "npairs %d", rx_fifo_size, tx_fifo_size, *n_fifo_pairs); - ssvm_pop_heap (oldheap); - return; - } - - /* Carve rx and tx fifo memory */ - for (i = 0; i < pairs_to_allocate; i++) - { - f = (svm_fifo_t *) rx_fifo_mem; - c = (svm_fifo_chunk_t *) (rx_fifo_mem + sizeof (*f)); - fifo_init_chunk_for_segment (c, rx_rounded_data_size); - fifo_init_for_segment (f, c); - rx_fifo_mem += hdrs + rx_rounded_data_size; - - f = (svm_fifo_t *) tx_fifo_mem; - c = (svm_fifo_chunk_t *) (tx_fifo_mem + sizeof (*f)); - fifo_init_chunk_for_segment (c, tx_rounded_data_size); - fifo_init_for_segment (f, c); - tx_fifo_mem += hdrs + tx_rounded_data_size; - } + if (fs_try_alloc_fifo_batch (fs, rx_fl_index, pairs_to_alloc)) + clib_warning ("rx prealloc failed"); + if (fs_try_alloc_fifo_batch (fs, tx_fl_index, pairs_to_alloc)) + clib_warning ("tx prealloc failed"); /* Account for the pairs allocated */ - *n_fifo_pairs -= pairs_to_allocate; - ssvm_pop_heap (oldheap); + *n_fifo_pairs -= pairs_to_alloc; } int @@ -552,7 +635,7 @@ fifo_segment_grow_fifo (fifo_segment_t * fs, svm_fifo_t * f, u32 chunk_size) return 0; } - fl_index = fs_free_list_for_size (chunk_size); + fl_index = fs_freelist_for_size (chunk_size); sh = fs->ssvm.sh; ssvm_lock_non_recursive (sh, 1); @@ -601,7 +684,7 @@ fifo_segment_collect_fifo_chunks (fifo_segment_t * fs, svm_fifo_t * f) while (cur) { next = cur->next; - fl_index = fs_free_list_for_size (cur->length); + fl_index = fs_freelist_for_size (cur->length); cur->next = fs->h->free_chunks[fl_index]; fs->h->free_chunks[fl_index] = cur; cur = next; @@ -623,16 +706,12 @@ fifo_segment_num_fifos (fifo_segment_t * fs) } u32 -fifo_segment_num_free_fifos (fifo_segment_t * fs, u32 fifo_size_in_bytes) +fifo_segment_num_free_fifos (fifo_segment_t * fs) { - fifo_segment_header_t *fsh; - ssvm_shared_header_t *sh; + fifo_segment_header_t *fsh = fs->h; svm_fifo_t *f; u32 count = 0; - sh = fs->ssvm.sh; - fsh = (fifo_segment_header_t *) sh->opaque[0]; - f = fsh->free_fifos; if (f == 0) return 0; @@ -674,7 +753,7 @@ fifo_segment_num_free_chunks (fifo_segment_t * fs, u32 size) } rounded_size = (1 << (max_log2 (size))); - fl_index = fs_free_list_for_size (rounded_size); + fl_index = fs_freelist_for_size (rounded_size); if (fl_index >= vec_len (fsh->free_chunks)) return 0; @@ -691,6 +770,24 @@ fifo_segment_num_free_chunks (fifo_segment_t * fs, u32 size) return count; } +void +fifo_segment_update_free_bytes (fifo_segment_t * fs) +{ + fs->h->n_free_bytes = fs_free_space (fs); +} + +u32 +fifo_segment_free_bytes (fifo_segment_t * fs) +{ + return fs->h->n_free_bytes; +} + +u32 +fifo_segment_chunk_prealloc_bytes (fifo_segment_t * fs) +{ + return fs->h->n_fl_chunk_bytes; +} + u8 fifo_segment_has_fifos (fifo_segment_t * fs) { diff --git a/src/svm/fifo_segment.h b/src/svm/fifo_segment.h index 182ab408737..89d4ef9c8c7 100644 --- a/src/svm/fifo_segment.h +++ b/src/svm/fifo_segment.h @@ -43,6 +43,8 @@ typedef struct svm_fifo_chunk_t **free_chunks; /**< Freelists by chunk size */ u32 n_active_fifos; /**< Number of active fifos */ u8 flags; /**< Segment flags */ + u32 n_free_bytes; /**< Bytes usable for new allocs */ + u32 n_fl_chunk_bytes; /**< Chunk bytes on freelist */ } fifo_segment_header_t; typedef struct @@ -101,6 +103,30 @@ svm_fifo_t *fifo_segment_alloc_fifo (fifo_segment_t * fs, void fifo_segment_free_fifo (fifo_segment_t * fs, svm_fifo_t * f); /** + * Try to preallocate fifo headers + * + * Tries to preallocate fifo headers and adds them to freelist. + * + * @param fs fifo segment + * @param batch_size number of chunks to be allocated + * @return 0 on success, negative number otherwise + */ +int fifo_segment_prealloc_fifo_hdrs (fifo_segment_t * fs, u32 batch_size); + +/** + * Try to preallocate fifo chunks on segment + * + * Tries to preallocate chunks of requested size on segment and adds them + * to chunk freelist. + * + * @param fs fifo segment + * @param chunk_size size of chunks to be allocated in bytes + * @param batch_size number of chunks to be allocated + * @return 0 on success, negative number otherwise + */ +int fifo_segment_prealloc_fifo_chunks (fifo_segment_t * fs, u32 chunk_size, + u32 batch_size); +/** * Pre-allocates fifo pairs in fifo segment * * The number of fifos pre-allocated is the minimum of the requested number @@ -137,10 +163,40 @@ int fifo_segment_grow_fifo (fifo_segment_t * fs, svm_fifo_t * f, * @return 0 on success, error otherwise */ int fifo_segment_collect_fifo_chunks (fifo_segment_t * fs, svm_fifo_t * f); + +/** + * Fifo segment estimate of number of free bytes + * + * Returns fifo segment's internal estimate of the number of free bytes. + * To force a synchronization between the segment and the underlying + * memory allocator, call @ref fifo_segment_update_free_bytes + * + * @param fs fifo segment + * @return free bytes estimate + */ +u32 fifo_segment_free_bytes (fifo_segment_t * fs); + +/** + * Update fifo segment free bytes estimate + * + * Forces fifo segment free bytes estimate synchronization with underlying + * memory allocator. + * + * @param fs fifo segment + */ +void fifo_segment_update_free_bytes (fifo_segment_t * fs); + +/** + * Number of bytes on chunk free lists + * + * @param fs fifo segment + * @return free bytes on chunk free lists + */ +u32 fifo_segment_chunk_prealloc_bytes (fifo_segment_t * fs); u8 fifo_segment_has_fifos (fifo_segment_t * fs); svm_fifo_t *fifo_segment_get_fifo_list (fifo_segment_t * fs); u32 fifo_segment_num_fifos (fifo_segment_t * fs); -u32 fifo_segment_num_free_fifos (fifo_segment_t * fs, u32 fifo_size_in_bytes); +u32 fifo_segment_num_free_fifos (fifo_segment_t * fs); /** * Find number of free chunks of given size * diff --git a/src/svm/ssvm.c b/src/svm/ssvm.c index 3e45175da0e..2a6e6bf78da 100644 --- a/src/svm/ssvm.c +++ b/src/svm/ssvm.c @@ -352,8 +352,8 @@ ssvm_master_init_private (ssvm_private_t * ssvm) u32 rnd_size = 0; u8 *heap; - rnd_size = (ssvm->ssvm_size + (pagesize - 1)) & ~(pagesize - 1); - rnd_size = clib_min (rnd_size, ((u64) 1 << 32) - pagesize); + rnd_size = clib_max (ssvm->ssvm_size + (pagesize - 1), ssvm->ssvm_size); + rnd_size &= ~(pagesize - 1); #if USE_DLMALLOC == 0 { diff --git a/src/vnet/session/segment_manager.c b/src/vnet/session/segment_manager.c index cbec493e55f..f53026c8778 100644 --- a/src/vnet/session/segment_manager.c +++ b/src/vnet/session/segment_manager.c @@ -102,7 +102,7 @@ segment_manager_add_segment (segment_manager_t * sm, u32 segment_size) } /* - * Allocate fifo segment and lock if needed + * Allocate fifo segment and grab lock if needed */ if (vlib_num_workers ()) clib_rwlock_writer_lock (&sm->segments_rwlock); @@ -110,13 +110,14 @@ segment_manager_add_segment (segment_manager_t * sm, u32 segment_size) pool_get_zero (sm->segments, fs); /* - * Initialize ssvm segment and svm fifo private header + * Allocate ssvm segment */ segment_size = segment_size ? segment_size : props->add_segment_size; page_size = clib_mem_get_page_size (); /* Protect against segment size u32 wrap */ segment_size = clib_max (segment_size + page_size - 1, segment_size); segment_size = segment_size & ~(page_size - 1); + if (props->segment_type != SSVM_SEGMENT_PRIVATE) { seg_name = format (0, "%d-%d%c", getpid (), smm->seg_name_counter++, 0); @@ -147,6 +148,9 @@ segment_manager_add_segment (segment_manager_t * sm, u32 segment_size) goto done; } + /* + * Initialize fifo segment + */ fifo_segment_init (fs); /* @@ -761,6 +765,7 @@ segment_manager_alloc_queue (fifo_segment_t * segment, oldheap = ssvm_push_heap (segment->ssvm.sh); q = svm_msg_q_alloc (cfg); + fifo_segment_update_free_bytes (segment); ssvm_pop_heap (oldheap); if (props->use_mq_eventfd) @@ -865,7 +870,7 @@ segment_manager_show_fn (vlib_main_t * vm, unformat_input_t * input, segment_manager_foreach_segment_w_lock (seg, sm, ({ fifo_segment_info (seg, &address, &size); active_fifos = fifo_segment_num_fifos (seg); - free_fifos = fifo_segment_num_free_fifos (seg, ~0 /* size */); + free_fifos = fifo_segment_num_free_fifos (seg); vlib_cli_output (vm, "%-15v%15U%15llu%15u%15u%15llx", ssvm_name (&seg->ssvm), format_fifo_segment_type, seg, size >> 20ULL, active_fifos, free_fifos, |