vppinfra: remove the historical mheap memory allocator

[vpp.git] / src / svm / fifo_segment.c

diff --git a/src/svm/fifo_segment.c b/src/svm/fifo_segment.c
index 6193963..58c1138 100644 (file)
--- a/src/svm/fifo_segment.c
+++ b/src/svm/fifo_segment.c
@@ -314,7 +314,10 @@ fs_try_alloc_fifo_freelist_multi_chunk (fifo_segment_header_t * fsh,
       fss->free_fifos = f->next;
     }
 
-  fl_index = fs_freelist_for_size (data_bytes) - 1;
+  fl_index = fs_freelist_for_size (data_bytes);
+  if (fl_index > 0)
+    fl_index -= 1;
+
   fl_size = fs_freelist_index_to_size (fl_index);
 
   while (data_bytes)
@@ -333,11 +336,38 @@ fs_try_alloc_fifo_freelist_multi_chunk (fifo_segment_header_t * fsh,
        }
       else
        {
-         ASSERT (fl_index > 0);
+         /* Failed to allocate with smaller chunks */
+         if (fl_index == 0)
+           {
+             /* free all chunks if any allocated */
+             c = first;
+             while (c)
+               {
+                 fl_index = fs_freelist_for_size (c->length);
+                 fl_size = fs_freelist_index_to_size (fl_index);
+                 c->next = fss->free_chunks[fl_index];
+                 fss->free_chunks[fl_index] = c;
+                 fss->n_fl_chunk_bytes += fl_size;
+                 data_bytes += fl_size;
+               }
+             first = last = 0;
+             fl_index = fs_freelist_for_size (data_bytes);
+             if (fss->free_chunks[fl_index + 1])
+               {
+                 fl_index += 1;
+                 fl_size = fs_freelist_index_to_size (fl_index);
+                 continue;
+               }
+
+             f->next = fss->free_fifos;
+             fss->free_fifos = f;
+             return 0;
+           }
          fl_index -= 1;
          fl_size = fl_size >> 1;
        }
     }
+
   f->start_chunk = first;
   f->end_chunk = last;
   last->next = first;
@@ -350,16 +380,17 @@ fs_try_alloc_fifo_batch (fifo_segment_header_t * fsh,
                         fifo_segment_slice_t * fss,
                         u32 fl_index, u32 batch_size)
 {
-  u32 size, hdrs, rounded_data_size;
+  u32 hdrs, rounded_data_size;
   svm_fifo_chunk_t *c;
   svm_fifo_t *f;
   void *oldheap;
+  uword size;
   u8 *fmem;
   int i;
 
   rounded_data_size = fs_freelist_index_to_size (fl_index);
   hdrs = sizeof (*f) + sizeof (*c);
-  size = (hdrs + rounded_data_size) * batch_size;
+  size = (uword) (hdrs + rounded_data_size) * batch_size;
 
   oldheap = ssvm_push_heap (fsh->ssvm_sh);
   fmem = clib_mem_alloc_aligned_at_offset (size, CLIB_CACHE_LINE_BYTES,
@@ -578,12 +609,12 @@ fifo_segment_prealloc_fifo_hdrs (fifo_segment_t * fs, u32 slice_index,
   fifo_segment_slice_t *fss;
   svm_fifo_t *f;
   void *oldheap;
-  u32 size;
+  uword size;
   u8 *fmem;
   int i;
 
   fss = fsh_slice_get (fsh, slice_index);
-  size = (sizeof (*f)) * batch_size;
+  size = (uword) (sizeof (*f)) * batch_size;
 
   oldheap = ssvm_push_heap (fsh->ssvm_sh);
   fmem = clib_mem_alloc_aligned_at_offset (size, CLIB_CACHE_LINE_BYTES,
@@ -614,11 +645,12 @@ int
 fifo_segment_prealloc_fifo_chunks (fifo_segment_t * fs, u32 slice_index,
                                   u32 chunk_size, u32 batch_size)
 {
-  u32 size, rounded_data_size, fl_index;
   fifo_segment_header_t *fsh = fs->h;
+  u32 rounded_data_size, fl_index;
   fifo_segment_slice_t *fss;
   svm_fifo_chunk_t *c;
   void *oldheap;
+  uword size;
   u8 *cmem;
   int i;
 
@@ -630,7 +662,7 @@ fifo_segment_prealloc_fifo_chunks (fifo_segment_t * fs, u32 slice_index,
 
   fl_index = fs_freelist_for_size (chunk_size);
   rounded_data_size = fs_freelist_index_to_size (fl_index);
-  size = (sizeof (*c) + rounded_data_size) * batch_size;
+  size = (uword) (sizeof (*c) + rounded_data_size) * batch_size;
 
   oldheap = ssvm_push_heap (fsh->ssvm_sh);
   cmem = clib_mem_alloc_aligned_at_offset (size, CLIB_CACHE_LINE_BYTES,
@@ -670,10 +702,10 @@ fifo_segment_preallocate_fifo_pairs (fifo_segment_t * fs,
                                     u32 * n_fifo_pairs)
 {
   u32 rx_rounded_data_size, tx_rounded_data_size, pair_size, pairs_to_alloc;
+  u32 hdrs, pairs_per_slice, alloc_now;
   fifo_segment_header_t *fsh = fs->h;
   int rx_fl_index, tx_fl_index, i;
   fifo_segment_slice_t *fss;
-  u32 hdrs, pairs_per_slice;
   uword space_available;
 
   /* Parameter check */
@@ -705,6 +737,7 @@ fifo_segment_preallocate_fifo_pairs (fifo_segment_t * fs,
   pairs_to_alloc = space_available / pair_size;
   pairs_to_alloc = clib_min (pairs_to_alloc, *n_fifo_pairs);
   pairs_per_slice = pairs_to_alloc / fs->n_slices;
+  pairs_per_slice += pairs_to_alloc % fs->n_slices ? 1 : 0;
 
   if (!pairs_per_slice)
     return;
@@ -712,14 +745,15 @@ fifo_segment_preallocate_fifo_pairs (fifo_segment_t * fs,
   for (i = 0; i < fs->n_slices; i++)
     {
       fss = fsh_slice_get (fsh, i);
-      if (fs_try_alloc_fifo_batch (fsh, fss, rx_fl_index, pairs_to_alloc))
-       clib_warning ("rx prealloc failed: pairs %u", pairs_to_alloc);
-      if (fs_try_alloc_fifo_batch (fsh, fss, tx_fl_index, pairs_to_alloc))
-       clib_warning ("tx prealloc failed: pairs %u", pairs_to_alloc);
+      alloc_now = clib_min (pairs_per_slice, *n_fifo_pairs);
+      if (fs_try_alloc_fifo_batch (fsh, fss, rx_fl_index, alloc_now))
+       clib_warning ("rx prealloc failed: pairs %u", alloc_now);
+      if (fs_try_alloc_fifo_batch (fsh, fss, tx_fl_index, alloc_now))
+       clib_warning ("tx prealloc failed: pairs %u", alloc_now);
+
+      /* Account for the pairs allocated */
+      *n_fifo_pairs -= alloc_now;
     }
-
-  /* Account for the pairs allocated */
-  *n_fifo_pairs -= pairs_per_slice * fs->n_slices;
 }
 
 int
@@ -991,12 +1025,6 @@ format_fifo_segment (u8 * s, va_list * args)
   int i;
 
   indent = format_get_indent (s) + 2;
-#if USE_DLMALLOC == 0
-  s = format (s, "%U segment heap: %U\n", format_white_space, indent,
-             format_mheap, fsh->ssvm_sh->heap, verbose);
-  s = format (s, "%U segment has %u active fifos\n",
-             format_white_space, indent, fifo_segment_num_fifos (fsh));
-#endif
 
   if (fs == 0)
     {