Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2016-2019 Cisco and/or its affiliates. |
| 3 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | * you may not use this file except in compliance with the License. |
| 5 | * You may obtain a copy of the License at: |
| 6 | * |
| 7 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | * |
| 9 | * Unless required by applicable law or agreed to in writing, software |
| 10 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | * See the License for the specific language governing permissions and |
| 13 | * limitations under the License. |
| 14 | */ |
| 15 | |
| 16 | #include <svm/fifo_segment.h> |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 17 | #include <vppinfra/mem.h> |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 18 | |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 19 | static inline void * |
| 20 | fsh_alloc_aligned (fifo_segment_header_t *fsh, uword size, uword align) |
| 21 | { |
| 22 | uword cur_pos, cur_pos_align, new_pos; |
| 23 | |
| 24 | cur_pos = clib_atomic_load_relax_n (&fsh->byte_index); |
| 25 | cur_pos_align = round_pow2_u64 (cur_pos, align); |
| 26 | size = round_pow2_u64 (size, align); |
| 27 | new_pos = cur_pos_align + size; |
| 28 | |
| 29 | if (new_pos >= fsh->max_byte_index) |
| 30 | return 0; |
| 31 | |
| 32 | while (!clib_atomic_cmp_and_swap_acq_relax (&fsh->byte_index, &cur_pos, |
| 33 | &new_pos, 1 /* weak */)) |
| 34 | { |
| 35 | cur_pos_align = round_pow2_u64 (cur_pos, align); |
| 36 | new_pos = cur_pos_align + size; |
| 37 | if (new_pos >= fsh->max_byte_index) |
| 38 | return 0; |
| 39 | } |
| 40 | return uword_to_pointer ((u8 *) fsh + cur_pos_align, void *); |
| 41 | } |
| 42 | |
| 43 | static inline void * |
| 44 | fsh_alloc (fifo_segment_header_t *fsh, uword size) |
| 45 | { |
| 46 | return fsh_alloc_aligned (fsh, size, 8); |
| 47 | } |
| 48 | |
Florin Coras | 06d4775 | 2020-03-06 02:23:58 +0000 | [diff] [blame] | 49 | static inline fifo_segment_slice_t * |
| 50 | fsh_slice_get (fifo_segment_header_t * fsh, u32 slice_index) |
| 51 | { |
| 52 | return &fsh->slices[slice_index]; |
| 53 | } |
| 54 | |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 55 | static inline fifo_slice_private_t * |
| 56 | fs_slice_private_get (fifo_segment_t *fs, u32 slice_index) |
| 57 | { |
| 58 | ASSERT (slice_index < fs->n_slices); |
| 59 | return &fs->slices[slice_index]; |
| 60 | } |
| 61 | |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 62 | static char *fifo_segment_mem_status_strings[] = { |
| 63 | #define _(sym,str) str, |
| 64 | foreach_segment_mem_status |
| 65 | #undef _ |
| 66 | }; |
| 67 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 68 | static inline uword |
| 69 | fsh_n_free_bytes (fifo_segment_header_t * fsh) |
| 70 | { |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 71 | uword cur_pos = clib_atomic_load_relax_n (&fsh->byte_index); |
| 72 | ASSERT (fsh->max_byte_index > cur_pos); |
| 73 | return fsh->max_byte_index - cur_pos; |
Florin Coras | 8122cc2 | 2019-12-18 13:06:41 -0800 | [diff] [blame] | 74 | } |
| 75 | |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 76 | static inline void |
Florin Coras | 79b3f8c | 2020-11-20 07:34:53 -0800 | [diff] [blame] | 77 | fsh_cached_bytes_add (fifo_segment_header_t * fsh, uword size) |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 78 | { |
| 79 | clib_atomic_fetch_add_rel (&fsh->n_cached_bytes, size); |
| 80 | } |
| 81 | |
| 82 | static inline void |
Florin Coras | 79b3f8c | 2020-11-20 07:34:53 -0800 | [diff] [blame] | 83 | fsh_cached_bytes_sub (fifo_segment_header_t * fsh, uword size) |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 84 | { |
| 85 | clib_atomic_fetch_sub_rel (&fsh->n_cached_bytes, size); |
| 86 | } |
| 87 | |
| 88 | static inline uword |
| 89 | fsh_n_cached_bytes (fifo_segment_header_t * fsh) |
| 90 | { |
| 91 | uword n_cached = clib_atomic_load_relax_n (&fsh->n_cached_bytes); |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 92 | return n_cached; |
| 93 | } |
| 94 | |
Florin Coras | 06d4775 | 2020-03-06 02:23:58 +0000 | [diff] [blame] | 95 | static inline void |
| 96 | fsh_active_fifos_update (fifo_segment_header_t * fsh, int inc) |
| 97 | { |
| 98 | clib_atomic_fetch_add_rel (&fsh->n_active_fifos, inc); |
| 99 | } |
| 100 | |
Florin Coras | 7a90e50 | 2020-04-09 04:46:14 +0000 | [diff] [blame] | 101 | static inline u32 |
| 102 | fsh_n_active_fifos (fifo_segment_header_t * fsh) |
| 103 | { |
| 104 | return clib_atomic_load_relax_n (&fsh->n_active_fifos); |
| 105 | } |
| 106 | |
Florin Coras | 06d4775 | 2020-03-06 02:23:58 +0000 | [diff] [blame] | 107 | static inline uword |
| 108 | fsh_virtual_mem (fifo_segment_header_t * fsh) |
| 109 | { |
| 110 | fifo_segment_slice_t *fss; |
| 111 | uword total_vm = 0; |
| 112 | int i; |
| 113 | |
| 114 | for (i = 0; i < fsh->n_slices; i++) |
| 115 | { |
| 116 | fss = fsh_slice_get (fsh, i); |
| 117 | total_vm += clib_atomic_load_relax_n (&fss->virtual_mem); |
| 118 | } |
| 119 | return total_vm; |
| 120 | } |
| 121 | |
| 122 | void |
| 123 | fsh_virtual_mem_update (fifo_segment_header_t * fsh, u32 slice_index, |
| 124 | int n_bytes) |
| 125 | { |
| 126 | fifo_segment_slice_t *fss = fsh_slice_get (fsh, slice_index); |
| 127 | fss->virtual_mem += n_bytes; |
| 128 | } |
| 129 | |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 130 | static inline void |
| 131 | fss_chunk_freelist_lock (fifo_segment_slice_t *fss) |
Florin Coras | 8122cc2 | 2019-12-18 13:06:41 -0800 | [diff] [blame] | 132 | { |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 133 | u32 free = 0; |
| 134 | while (!clib_atomic_cmp_and_swap_acq_relax_n (&fss->chunk_lock, &free, 1, 0)) |
| 135 | { |
| 136 | /* atomic load limits number of compare_exchange executions */ |
| 137 | while (clib_atomic_load_relax_n (&fss->chunk_lock)) |
| 138 | CLIB_PAUSE (); |
| 139 | /* on failure, compare_exchange writes (*p)->lock into free */ |
| 140 | free = 0; |
| 141 | } |
| 142 | } |
Florin Coras | 8122cc2 | 2019-12-18 13:06:41 -0800 | [diff] [blame] | 143 | |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 144 | static inline void |
| 145 | fss_chunk_freelist_unlock (fifo_segment_slice_t *fss) |
| 146 | { |
| 147 | /* Make sure all reads/writes are complete before releasing the lock */ |
| 148 | clib_atomic_release (&fss->chunk_lock); |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 149 | } |
| 150 | |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 151 | static inline int |
| 152 | fss_chunk_fl_index_is_valid (fifo_segment_slice_t * fss, u32 fl_index) |
| 153 | { |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 154 | return (fl_index < FS_CHUNK_VEC_LEN); |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 155 | } |
| 156 | |
| 157 | static void |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 158 | fss_chunk_free_list_push (fifo_segment_header_t *fsh, |
| 159 | fifo_segment_slice_t *fss, u32 fl_index, |
| 160 | svm_fifo_chunk_t *c) |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 161 | { |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 162 | fss_chunk_freelist_lock (fss); |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 163 | c->next = fss->free_chunks[fl_index]; |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 164 | fss->free_chunks[fl_index] = fs_chunk_sptr (fsh, c); |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 165 | fss_chunk_freelist_unlock (fss); |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 166 | } |
| 167 | |
| 168 | static void |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 169 | fss_chunk_free_list_push_list (fifo_segment_header_t *fsh, |
| 170 | fifo_segment_slice_t *fss, u32 fl_index, |
| 171 | svm_fifo_chunk_t *head, svm_fifo_chunk_t *tail) |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 172 | { |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 173 | fss_chunk_freelist_lock (fss); |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 174 | tail->next = fss->free_chunks[fl_index]; |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 175 | fss->free_chunks[fl_index] = fs_chunk_sptr (fsh, head); |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 176 | fss_chunk_freelist_unlock (fss); |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 177 | } |
| 178 | |
| 179 | static svm_fifo_chunk_t * |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 180 | fss_chunk_free_list_pop (fifo_segment_header_t *fsh, fifo_segment_slice_t *fss, |
| 181 | u32 fl_index) |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 182 | { |
| 183 | svm_fifo_chunk_t *c; |
| 184 | |
| 185 | ASSERT (fss_chunk_fl_index_is_valid (fss, fl_index)); |
| 186 | |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 187 | fss_chunk_freelist_lock (fss); |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 188 | |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 189 | if (!fss->free_chunks[fl_index]) |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 190 | { |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 191 | fss_chunk_freelist_unlock (fss); |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 192 | return 0; |
| 193 | } |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 194 | |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 195 | c = fs_chunk_ptr (fsh, fss->free_chunks[fl_index]); |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 196 | fss->free_chunks[fl_index] = c->next; |
| 197 | |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 198 | fss_chunk_freelist_unlock (fss); |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 199 | |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 200 | return c; |
| 201 | } |
| 202 | |
Florin Coras | 17672aa | 2020-12-29 16:55:32 -0800 | [diff] [blame] | 203 | static void |
| 204 | fss_fifo_free_list_push (fifo_segment_header_t *fsh, fifo_segment_slice_t *fss, |
| 205 | svm_fifo_shared_t *sf) |
| 206 | { |
| 207 | sf->next = fss->free_fifos; |
| 208 | fss->free_fifos = fs_sptr (fsh, sf); |
| 209 | } |
| 210 | |
| 211 | static void |
| 212 | fss_fifo_free_list_push_list (fifo_segment_header_t *fsh, |
| 213 | fifo_segment_slice_t *fss, |
| 214 | svm_fifo_shared_t *head, svm_fifo_shared_t *tail) |
| 215 | { |
| 216 | tail->next = fss->free_fifos; |
| 217 | fss->free_fifos = fs_sptr (fsh, head); |
| 218 | } |
| 219 | |
| 220 | svm_fifo_shared_t * |
| 221 | fss_fifo_free_list_pop (fifo_segment_header_t *fsh, fifo_segment_slice_t *fss) |
| 222 | { |
| 223 | svm_fifo_shared_t *sf; |
| 224 | sf = fs_ptr (fsh, fss->free_fifos); |
| 225 | fss->free_fifos = sf->next; |
| 226 | return sf; |
| 227 | } |
| 228 | |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 229 | static inline void |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 230 | pfss_fifo_add_active_list (fifo_slice_private_t *pfss, svm_fifo_t *f) |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 231 | { |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 232 | if (pfss->active_fifos) |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 233 | { |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 234 | pfss->active_fifos->prev = f; |
| 235 | f->next = pfss->active_fifos; |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 236 | } |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 237 | pfss->active_fifos = f; |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 238 | } |
| 239 | |
| 240 | static inline void |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 241 | pfss_fifo_del_active_list (fifo_slice_private_t *pfss, svm_fifo_t *f) |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 242 | { |
| 243 | if (f->flags & SVM_FIFO_F_LL_TRACKED) |
| 244 | { |
| 245 | if (f->prev) |
| 246 | f->prev->next = f->next; |
| 247 | else |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 248 | pfss->active_fifos = f->next; |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 249 | if (f->next) |
| 250 | f->next->prev = f->prev; |
| 251 | } |
| 252 | } |
| 253 | |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 254 | static inline uword |
| 255 | fss_fl_chunk_bytes (fifo_segment_slice_t * fss) |
| 256 | { |
| 257 | return clib_atomic_load_relax_n (&fss->n_fl_chunk_bytes); |
| 258 | } |
| 259 | |
| 260 | static inline void |
| 261 | fss_fl_chunk_bytes_add (fifo_segment_slice_t * fss, uword size) |
| 262 | { |
| 263 | clib_atomic_fetch_add_relax (&fss->n_fl_chunk_bytes, size); |
| 264 | } |
| 265 | |
| 266 | static inline void |
| 267 | fss_fl_chunk_bytes_sub (fifo_segment_slice_t * fss, uword size) |
| 268 | { |
| 269 | clib_atomic_fetch_sub_relax (&fss->n_fl_chunk_bytes, size); |
| 270 | } |
| 271 | |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 272 | /** |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 273 | * Initialize fifo segment shared header |
| 274 | */ |
| 275 | int |
| 276 | fifo_segment_init (fifo_segment_t * fs) |
| 277 | { |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 278 | u32 align = 8, offset = 2 * 4096, slices_sz, i; |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 279 | uword max_fifo, seg_start, seg_sz; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 280 | fifo_segment_header_t *fsh; |
| 281 | ssvm_shared_header_t *sh; |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 282 | void *seg_data; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 283 | |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 284 | /* TODO remove ssvm heap entirely */ |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 285 | sh = fs->ssvm.sh; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 286 | |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 287 | seg_data = (u8 *) sh + offset; |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 288 | seg_sz = sh->ssvm_size - offset; |
| 289 | |
| 290 | fs->n_slices = clib_max (fs->n_slices, 1); |
| 291 | slices_sz = sizeof (fifo_segment_slice_t) * fs->n_slices; |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 292 | |
| 293 | seg_start = round_pow2_u64 (pointer_to_uword (seg_data), align); |
| 294 | fsh = uword_to_pointer (seg_start, void *); |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 295 | memset (fsh, 0, sizeof (*fsh) + slices_sz); |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 296 | |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 297 | fsh->byte_index = sizeof (*fsh) + slices_sz; |
| 298 | fsh->max_byte_index = seg_sz; |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 299 | fsh->n_slices = fs->n_slices; |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 300 | max_fifo = clib_min ((seg_sz - slices_sz) / 2, FIFO_SEGMENT_MAX_FIFO_SIZE); |
| 301 | fsh->max_log2_fifo_size = min_log2 (max_fifo); |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 302 | fsh->n_cached_bytes = 0; |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 303 | fsh->n_reserved_bytes = fsh->byte_index; |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 304 | ASSERT (fsh->max_byte_index <= sh->ssvm_size - offset); |
| 305 | |
| 306 | fs->max_byte_index = fsh->max_byte_index; |
Florin Coras | 14f066e | 2020-12-10 18:52:40 -0800 | [diff] [blame] | 307 | fs->h = fsh; |
| 308 | sh->opaque[0] = (void *) ((u8 *) fsh - (u8 *) fs->ssvm.sh); |
| 309 | |
| 310 | /* Allow random offsets */ |
| 311 | fs->ssvm.sh->ssvm_va = 0; |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 312 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 313 | vec_validate (fs->slices, fs->n_slices - 1); |
| 314 | for (i = 0; i < fs->n_slices; i++) |
| 315 | fs->slices[i].fifos = |
| 316 | clib_mem_bulk_init (sizeof (svm_fifo_t), CLIB_CACHE_LINE_BYTES, 32); |
| 317 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 318 | sh->ready = 1; |
| 319 | return (0); |
| 320 | } |
| 321 | |
| 322 | /** |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 323 | * Create a fifo segment and initialize as master |
| 324 | */ |
| 325 | int |
| 326 | fifo_segment_create (fifo_segment_main_t * sm, fifo_segment_create_args_t * a) |
| 327 | { |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 328 | fifo_segment_t *fs; |
| 329 | uword baseva; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 330 | int rv; |
| 331 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 332 | /* Allocate a fresh segment */ |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 333 | pool_get_zero (sm->segments, fs); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 334 | |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 335 | baseva = a->segment_type == SSVM_SEGMENT_PRIVATE ? ~0ULL : sm->next_baseva; |
| 336 | fs->ssvm.ssvm_size = a->segment_size; |
Florin Coras | 5220a26 | 2020-09-29 18:11:24 -0700 | [diff] [blame] | 337 | fs->ssvm.is_server = 1; |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 338 | fs->ssvm.my_pid = getpid (); |
| 339 | fs->ssvm.name = format (0, "%s%c", a->segment_name, 0); |
| 340 | fs->ssvm.requested_va = baseva; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 341 | |
Florin Coras | 5220a26 | 2020-09-29 18:11:24 -0700 | [diff] [blame] | 342 | if ((rv = ssvm_server_init (&fs->ssvm, a->segment_type))) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 343 | { |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 344 | pool_put (sm->segments, fs); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 345 | return (rv); |
| 346 | } |
| 347 | |
| 348 | /* Note: requested_va updated due to seg base addr randomization */ |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 349 | sm->next_baseva = fs->ssvm.sh->ssvm_va + fs->ssvm.ssvm_size; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 350 | |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 351 | fifo_segment_init (fs); |
| 352 | vec_add1 (a->new_segment_indices, fs - sm->segments); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 353 | return (0); |
| 354 | } |
| 355 | |
| 356 | /** |
| 357 | * Attach as slave to a fifo segment |
| 358 | */ |
| 359 | int |
| 360 | fifo_segment_attach (fifo_segment_main_t * sm, fifo_segment_create_args_t * a) |
| 361 | { |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 362 | fifo_segment_header_t *fsh; |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 363 | fifo_segment_t *fs; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 364 | int rv; |
| 365 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 366 | pool_get_zero (sm->segments, fs); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 367 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 368 | fs->ssvm.ssvm_size = a->segment_size; |
| 369 | fs->ssvm.my_pid = getpid (); |
| 370 | fs->ssvm.name = format (0, "%s%c", a->segment_name, 0); |
Florin Coras | 14f066e | 2020-12-10 18:52:40 -0800 | [diff] [blame] | 371 | fs->ssvm.requested_va = 0; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 372 | if (a->segment_type == SSVM_SEGMENT_MEMFD) |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 373 | fs->ssvm.fd = a->memfd_fd; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 374 | else |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 375 | fs->ssvm.attach_timeout = sm->timeout_in_seconds; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 376 | |
Florin Coras | 5220a26 | 2020-09-29 18:11:24 -0700 | [diff] [blame] | 377 | if ((rv = ssvm_client_init (&fs->ssvm, a->segment_type))) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 378 | { |
Florin Coras | 14f066e | 2020-12-10 18:52:40 -0800 | [diff] [blame] | 379 | pool_put (sm->segments, fs); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 380 | return (rv); |
| 381 | } |
| 382 | |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 383 | /* Probably a segment without fifos */ |
Florin Coras | 14f066e | 2020-12-10 18:52:40 -0800 | [diff] [blame] | 384 | if (!fs->ssvm.sh->opaque[0]) |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 385 | goto done; |
| 386 | |
Florin Coras | 14f066e | 2020-12-10 18:52:40 -0800 | [diff] [blame] | 387 | fsh = fs->h = (void *) fs->ssvm.sh + (uword) fs->ssvm.sh->opaque[0]; |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 388 | fs->max_byte_index = fsh->max_byte_index; |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 389 | vec_validate (fs->slices, 0); |
| 390 | fs->slices[0].fifos = |
| 391 | clib_mem_bulk_init (sizeof (svm_fifo_t), CLIB_CACHE_LINE_BYTES, 32); |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 392 | |
| 393 | done: |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 394 | vec_add1 (a->new_segment_indices, fs - sm->segments); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 395 | return (0); |
| 396 | } |
| 397 | |
| 398 | void |
| 399 | fifo_segment_delete (fifo_segment_main_t * sm, fifo_segment_t * s) |
| 400 | { |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 401 | fifo_segment_cleanup (s); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 402 | ssvm_delete (&s->ssvm); |
| 403 | clib_memset (s, 0xfe, sizeof (*s)); |
| 404 | pool_put (sm->segments, s); |
| 405 | } |
| 406 | |
| 407 | u32 |
| 408 | fifo_segment_index (fifo_segment_main_t * sm, fifo_segment_t * s) |
| 409 | { |
| 410 | return s - sm->segments; |
| 411 | } |
| 412 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 413 | fifo_segment_t * |
| 414 | fifo_segment_get_segment (fifo_segment_main_t * sm, u32 segment_index) |
| 415 | { |
| 416 | return pool_elt_at_index (sm->segments, segment_index); |
| 417 | } |
| 418 | |
| 419 | void |
| 420 | fifo_segment_info (fifo_segment_t * seg, char **address, size_t * size) |
| 421 | { |
Florin Coras | 404b8a3 | 2019-05-09 12:08:06 -0700 | [diff] [blame] | 422 | *address = (char *) seg->ssvm.sh->ssvm_va; |
| 423 | *size = seg->ssvm.ssvm_size; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 424 | } |
| 425 | |
| 426 | void |
| 427 | fifo_segment_main_init (fifo_segment_main_t * sm, u64 baseva, |
| 428 | u32 timeout_in_seconds) |
| 429 | { |
| 430 | sm->next_baseva = baseva; |
| 431 | sm->timeout_in_seconds = timeout_in_seconds; |
| 432 | } |
| 433 | |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 434 | static inline u32 |
| 435 | fs_freelist_for_size (u32 size) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 436 | { |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 437 | if (PREDICT_FALSE (size < FIFO_SEGMENT_MIN_FIFO_SIZE)) |
| 438 | return 0; |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 439 | return clib_min (max_log2 (size) - FIFO_SEGMENT_MIN_LOG2_FIFO_SIZE, |
| 440 | FS_CHUNK_VEC_LEN - 1); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 441 | } |
| 442 | |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 443 | static inline u32 |
| 444 | fs_freelist_index_to_size (u32 fl_index) |
| 445 | { |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 446 | return 1 << (fl_index + FIFO_SEGMENT_MIN_LOG2_FIFO_SIZE); |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 447 | } |
| 448 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 449 | static inline int |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 450 | fs_chunk_size_is_valid (fifo_segment_header_t * fsh, u32 size) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 451 | { |
| 452 | /* |
| 453 | * 4K minimum. It's not likely that anything good will happen |
| 454 | * with a smaller FIFO. |
| 455 | */ |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 456 | return size >= FIFO_SEGMENT_MIN_FIFO_SIZE && |
| 457 | size <= (1ULL << fsh->max_log2_fifo_size); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 458 | } |
| 459 | |
Florin Coras | 8e755a1 | 2020-02-06 16:59:31 +0000 | [diff] [blame] | 460 | svm_fifo_chunk_t * |
| 461 | fs_try_alloc_multi_chunk (fifo_segment_header_t * fsh, |
| 462 | fifo_segment_slice_t * fss, u32 data_bytes) |
| 463 | { |
| 464 | u32 fl_index, fl_size, n_alloc = 0, req_bytes = data_bytes; |
| 465 | svm_fifo_chunk_t *c, *first = 0, *next; |
| 466 | |
| 467 | fl_index = fs_freelist_for_size (req_bytes); |
| 468 | if (fl_index > 0) |
| 469 | fl_index -= 1; |
| 470 | |
| 471 | fl_size = fs_freelist_index_to_size (fl_index); |
| 472 | |
| 473 | while (req_bytes) |
| 474 | { |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 475 | c = fss_chunk_free_list_pop (fsh, fss, fl_index); |
Florin Coras | 8e755a1 | 2020-02-06 16:59:31 +0000 | [diff] [blame] | 476 | if (c) |
| 477 | { |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 478 | c->next = fs_chunk_sptr (fsh, first); |
Florin Coras | 8e755a1 | 2020-02-06 16:59:31 +0000 | [diff] [blame] | 479 | first = c; |
| 480 | n_alloc += fl_size; |
| 481 | req_bytes -= clib_min (fl_size, req_bytes); |
| 482 | } |
| 483 | else |
| 484 | { |
| 485 | /* Failed to allocate with smaller chunks */ |
| 486 | if (fl_index == 0) |
| 487 | { |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 488 | /* Free all chunks if any allocated */ |
Florin Coras | 8e755a1 | 2020-02-06 16:59:31 +0000 | [diff] [blame] | 489 | c = first; |
| 490 | while (c) |
| 491 | { |
| 492 | fl_index = fs_freelist_for_size (c->length); |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 493 | next = fs_chunk_ptr (fsh, c->next); |
| 494 | fss_chunk_free_list_push (fsh, fss, fl_index, c); |
Florin Coras | 8e755a1 | 2020-02-06 16:59:31 +0000 | [diff] [blame] | 495 | c = next; |
| 496 | } |
| 497 | n_alloc = 0; |
| 498 | first = 0; |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 499 | /* As last attempt, try allocating a chunk larger than |
| 500 | * the requested size, if possible */ |
| 501 | fl_index = fs_freelist_for_size (data_bytes) + 1; |
| 502 | if (!fss_chunk_fl_index_is_valid (fss, fl_index)) |
| 503 | return 0; |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 504 | first = fss_chunk_free_list_pop (fsh, fss, fl_index); |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 505 | if (first) |
Florin Coras | 8e755a1 | 2020-02-06 16:59:31 +0000 | [diff] [blame] | 506 | { |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 507 | first->next = 0; |
| 508 | n_alloc = fs_freelist_index_to_size (fl_index); |
| 509 | goto done; |
Florin Coras | 8e755a1 | 2020-02-06 16:59:31 +0000 | [diff] [blame] | 510 | } |
Florin Coras | 8e755a1 | 2020-02-06 16:59:31 +0000 | [diff] [blame] | 511 | return 0; |
| 512 | } |
| 513 | fl_index -= 1; |
| 514 | fl_size = fl_size >> 1; |
| 515 | } |
| 516 | } |
| 517 | |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 518 | done: |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 519 | fss_fl_chunk_bytes_sub (fss, n_alloc); |
Florin Coras | 8e755a1 | 2020-02-06 16:59:31 +0000 | [diff] [blame] | 520 | fsh_cached_bytes_sub (fsh, n_alloc); |
| 521 | return first; |
| 522 | } |
| 523 | |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 524 | static int |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 525 | fsh_try_alloc_fifo_hdr_batch (fifo_segment_header_t * fsh, |
| 526 | fifo_segment_slice_t * fss, u32 batch_size) |
Florin Coras | 8e755a1 | 2020-02-06 16:59:31 +0000 | [diff] [blame] | 527 | { |
Florin Coras | 17672aa | 2020-12-29 16:55:32 -0800 | [diff] [blame] | 528 | svm_fifo_shared_t *f, *head = 0, *tail; |
Florin Coras | 36a0c4d | 2020-01-31 08:28:02 -0800 | [diff] [blame] | 529 | uword size; |
Florin Coras | cefd5d8 | 2019-05-05 13:19:57 -0700 | [diff] [blame] | 530 | u8 *fmem; |
| 531 | int i; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 532 | |
Benoît Ganne | f23b151 | 2020-11-25 15:06:01 +0100 | [diff] [blame] | 533 | ASSERT (batch_size != 0); |
| 534 | |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 535 | size = (uword) sizeof (*f) * batch_size; |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 536 | |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 537 | fmem = fsh_alloc_aligned (fsh, size, CLIB_CACHE_LINE_BYTES); |
Florin Coras | cefd5d8 | 2019-05-05 13:19:57 -0700 | [diff] [blame] | 538 | if (fmem == 0) |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 539 | return -1; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 540 | |
Florin Coras | 635f506 | 2020-04-28 20:40:57 +0000 | [diff] [blame] | 541 | /* Carve fifo hdr space */ |
Florin Coras | 17672aa | 2020-12-29 16:55:32 -0800 | [diff] [blame] | 542 | tail = f = (svm_fifo_shared_t *) fmem; |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 543 | for (i = 0; i < batch_size; i++) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 544 | { |
Florin Coras | 17672aa | 2020-12-29 16:55:32 -0800 | [diff] [blame] | 545 | clib_memset (f, 0, sizeof (*f)); |
| 546 | f->next = fs_sptr (fsh, head); |
| 547 | head = f; |
Florin Coras | 635f506 | 2020-04-28 20:40:57 +0000 | [diff] [blame] | 548 | fmem += sizeof (*f); |
Florin Coras | 17672aa | 2020-12-29 16:55:32 -0800 | [diff] [blame] | 549 | f = (svm_fifo_shared_t *) fmem; |
Florin Coras | 635f506 | 2020-04-28 20:40:57 +0000 | [diff] [blame] | 550 | } |
| 551 | |
Florin Coras | 17672aa | 2020-12-29 16:55:32 -0800 | [diff] [blame] | 552 | fss_fifo_free_list_push_list (fsh, fss, head, tail); |
| 553 | |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 554 | return 0; |
| 555 | } |
| 556 | |
| 557 | static int |
| 558 | fsh_try_alloc_chunk_batch (fifo_segment_header_t * fsh, |
| 559 | fifo_segment_slice_t * fss, |
| 560 | u32 fl_index, u32 batch_size) |
| 561 | { |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 562 | svm_fifo_chunk_t *c, *head = 0, *tail; |
Florin Coras | 79b3f8c | 2020-11-20 07:34:53 -0800 | [diff] [blame] | 563 | uword size, total_chunk_bytes; |
| 564 | u32 rounded_data_size; |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 565 | u8 *cmem; |
| 566 | int i; |
| 567 | |
Benoît Ganne | f23b151 | 2020-11-25 15:06:01 +0100 | [diff] [blame] | 568 | ASSERT (batch_size != 0); |
| 569 | |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 570 | rounded_data_size = fs_freelist_index_to_size (fl_index); |
Florin Coras | 79b3f8c | 2020-11-20 07:34:53 -0800 | [diff] [blame] | 571 | total_chunk_bytes = (uword) batch_size *rounded_data_size; |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 572 | size = (uword) (sizeof (*c) + rounded_data_size) * batch_size; |
| 573 | |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 574 | cmem = fsh_alloc_aligned (fsh, size, 8 /* chunk hdr is 24B */); |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 575 | if (cmem == 0) |
| 576 | return -1; |
| 577 | |
| 578 | /* Carve fifo + chunk space */ |
| 579 | tail = c = (svm_fifo_chunk_t *) cmem; |
Florin Coras | 635f506 | 2020-04-28 20:40:57 +0000 | [diff] [blame] | 580 | for (i = 0; i < batch_size; i++) |
| 581 | { |
Florin Coras | cefd5d8 | 2019-05-05 13:19:57 -0700 | [diff] [blame] | 582 | c->start_byte = 0; |
| 583 | c->length = rounded_data_size; |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 584 | c->next = fs_chunk_sptr (fsh, head); |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 585 | head = c; |
| 586 | cmem += sizeof (*c) + rounded_data_size; |
| 587 | c = (svm_fifo_chunk_t *) cmem; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 588 | } |
Florin Coras | cefd5d8 | 2019-05-05 13:19:57 -0700 | [diff] [blame] | 589 | |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 590 | fss_chunk_free_list_push_list (fsh, fss, fl_index, head, tail); |
Ryujiro Shibuya | d358872 | 2020-03-13 12:45:06 +0000 | [diff] [blame] | 591 | fss->num_chunks[fl_index] += batch_size; |
Florin Coras | 79b3f8c | 2020-11-20 07:34:53 -0800 | [diff] [blame] | 592 | fss_fl_chunk_bytes_add (fss, total_chunk_bytes); |
| 593 | fsh_cached_bytes_add (fsh, total_chunk_bytes); |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 594 | |
| 595 | return 0; |
| 596 | } |
| 597 | |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 598 | static int |
| 599 | fs_try_alloc_fifo_batch (fifo_segment_header_t * fsh, |
| 600 | fifo_segment_slice_t * fss, |
| 601 | u32 fl_index, u32 batch_size) |
| 602 | { |
| 603 | if (fsh_try_alloc_fifo_hdr_batch (fsh, fss, batch_size)) |
| 604 | return 0; |
| 605 | return fsh_try_alloc_chunk_batch (fsh, fss, fl_index, batch_size); |
| 606 | } |
| 607 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 608 | static svm_fifo_shared_t * |
| 609 | fsh_try_alloc_fifo_hdr (fifo_segment_header_t *fsh, fifo_segment_slice_t *fss) |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 610 | { |
Florin Coras | 17672aa | 2020-12-29 16:55:32 -0800 | [diff] [blame] | 611 | svm_fifo_shared_t *sf; |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 612 | |
| 613 | if (!fss->free_fifos) |
| 614 | { |
| 615 | if (fsh_try_alloc_fifo_hdr_batch (fsh, fss, |
| 616 | FIFO_SEGMENT_ALLOC_BATCH_SIZE)) |
| 617 | return 0; |
| 618 | } |
| 619 | |
Florin Coras | 17672aa | 2020-12-29 16:55:32 -0800 | [diff] [blame] | 620 | sf = fss_fifo_free_list_pop (fsh, fss); |
| 621 | clib_memset (sf, 0, sizeof (*sf)); |
| 622 | |
| 623 | return sf; |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 624 | } |
| 625 | |
| 626 | static svm_fifo_chunk_t * |
| 627 | fsh_try_alloc_chunk (fifo_segment_header_t * fsh, |
| 628 | fifo_segment_slice_t * fss, u32 data_bytes) |
| 629 | { |
| 630 | svm_fifo_chunk_t *c; |
| 631 | u32 fl_index; |
| 632 | |
| 633 | fl_index = fs_freelist_for_size (data_bytes); |
| 634 | |
| 635 | free_list: |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 636 | c = fss_chunk_free_list_pop (fsh, fss, fl_index); |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 637 | if (c) |
| 638 | { |
| 639 | c->next = 0; |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 640 | fss_fl_chunk_bytes_sub (fss, fs_freelist_index_to_size (fl_index)); |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 641 | fsh_cached_bytes_sub (fsh, fs_freelist_index_to_size (fl_index)); |
| 642 | } |
| 643 | else |
| 644 | { |
| 645 | u32 chunk_size, batch = FIFO_SEGMENT_ALLOC_BATCH_SIZE; |
| 646 | uword n_free; |
| 647 | |
| 648 | chunk_size = fs_freelist_index_to_size (fl_index); |
| 649 | n_free = fsh_n_free_bytes (fsh); |
| 650 | |
| 651 | if (chunk_size <= n_free) |
| 652 | { |
| 653 | batch = chunk_size * batch <= n_free ? batch : 1; |
| 654 | if (!fsh_try_alloc_chunk_batch (fsh, fss, fl_index, batch)) |
| 655 | goto free_list; |
| 656 | } |
| 657 | /* Failed to allocate larger chunk, try to allocate multi-chunk |
| 658 | * that is close to what was actually requested */ |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 659 | if (data_bytes <= fss_fl_chunk_bytes (fss)) |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 660 | { |
| 661 | c = fs_try_alloc_multi_chunk (fsh, fss, data_bytes); |
| 662 | if (c) |
| 663 | goto done; |
| 664 | batch = n_free / FIFO_SEGMENT_MIN_FIFO_SIZE; |
| 665 | if (!batch || fsh_try_alloc_chunk_batch (fsh, fss, 0, batch)) |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 666 | goto done; |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 667 | } |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 668 | if (data_bytes <= fss_fl_chunk_bytes (fss) + n_free) |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 669 | { |
| 670 | u32 min_size = FIFO_SEGMENT_MIN_FIFO_SIZE; |
| 671 | |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 672 | batch = (data_bytes - fss_fl_chunk_bytes (fss)) / min_size; |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 673 | batch = clib_min (batch + 1, n_free / min_size); |
| 674 | if (fsh_try_alloc_chunk_batch (fsh, fss, 0, batch)) |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 675 | goto done; |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 676 | c = fs_try_alloc_multi_chunk (fsh, fss, data_bytes); |
| 677 | } |
| 678 | } |
| 679 | |
| 680 | done: |
| 681 | |
| 682 | return c; |
| 683 | } |
| 684 | |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 685 | /** |
| 686 | * Try to allocate new fifo |
| 687 | * |
| 688 | * Tries the following steps in order: |
| 689 | * - grab fifo and chunk from freelists |
| 690 | * - batch fifo and chunk allocation |
| 691 | * - single fifo allocation |
| 692 | * - grab multiple fifo chunks from freelists |
| 693 | */ |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 694 | static svm_fifo_shared_t * |
| 695 | fs_try_alloc_fifo (fifo_segment_header_t *fsh, u32 slice_index, u32 data_bytes) |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 696 | { |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 697 | fifo_segment_slice_t *fss; |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 698 | u32 fl_index, min_size; |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 699 | svm_fifo_chunk_t *c; |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 700 | svm_fifo_shared_t *sf = 0; |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 701 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 702 | fss = fsh_slice_get (fsh, slice_index); |
Florin Coras | 2de9c0f | 2020-02-02 19:30:39 +0000 | [diff] [blame] | 703 | min_size = clib_max ((fsh->pct_first_alloc * data_bytes) / 100, 4096); |
| 704 | fl_index = fs_freelist_for_size (min_size); |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 705 | |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 706 | if (!fss_chunk_fl_index_is_valid (fss, fl_index)) |
Florin Coras | 0e6199d | 2020-04-17 20:15:22 +0000 | [diff] [blame] | 707 | return 0; |
| 708 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 709 | sf = fsh_try_alloc_fifo_hdr (fsh, fss); |
| 710 | if (!sf) |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 711 | return 0; |
Florin Coras | 8122cc2 | 2019-12-18 13:06:41 -0800 | [diff] [blame] | 712 | |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 713 | c = fsh_try_alloc_chunk (fsh, fss, min_size); |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 714 | if (!c) |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 715 | { |
Florin Coras | 17672aa | 2020-12-29 16:55:32 -0800 | [diff] [blame] | 716 | fss_fifo_free_list_push (fsh, fss, sf); |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 717 | return 0; |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 718 | } |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 719 | |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 720 | sf->start_chunk = fs_chunk_sptr (fsh, c); |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 721 | while (c->next) |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 722 | c = fs_chunk_ptr (fsh, c->next); |
| 723 | sf->end_chunk = fs_chunk_sptr (fsh, c); |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 724 | sf->size = data_bytes; |
| 725 | sf->slice_index = slice_index; |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 726 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 727 | return sf; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 728 | } |
| 729 | |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 730 | svm_fifo_chunk_t * |
| 731 | fsh_alloc_chunk (fifo_segment_header_t * fsh, u32 slice_index, u32 chunk_size) |
| 732 | { |
| 733 | fifo_segment_slice_t *fss; |
| 734 | svm_fifo_chunk_t *c; |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 735 | |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 736 | fss = fsh_slice_get (fsh, slice_index); |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 737 | c = fsh_try_alloc_chunk (fsh, fss, chunk_size); |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 738 | |
| 739 | return c; |
| 740 | } |
| 741 | |
| 742 | static void |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 743 | fsh_slice_collect_chunks (fifo_segment_header_t * fsh, |
Florin Coras | 9e61d9a | 2020-02-05 21:13:18 +0000 | [diff] [blame] | 744 | fifo_segment_slice_t * fss, svm_fifo_chunk_t * c) |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 745 | { |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 746 | u32 n_collect = 0, fl_index; |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 747 | svm_fifo_chunk_t *next; |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 748 | |
Florin Coras | 9e61d9a | 2020-02-05 21:13:18 +0000 | [diff] [blame] | 749 | while (c) |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 750 | { |
Benoît Ganne | df601ae | 2020-10-20 14:31:55 +0200 | [diff] [blame] | 751 | CLIB_MEM_UNPOISON (c, sizeof (*c)); |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 752 | next = fs_chunk_ptr (fsh, c->next); |
Florin Coras | 9e61d9a | 2020-02-05 21:13:18 +0000 | [diff] [blame] | 753 | fl_index = fs_freelist_for_size (c->length); |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 754 | fss_chunk_free_list_push (fsh, fss, fl_index, c); |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 755 | n_collect += fs_freelist_index_to_size (fl_index); |
Florin Coras | 9e61d9a | 2020-02-05 21:13:18 +0000 | [diff] [blame] | 756 | c = next; |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 757 | } |
| 758 | |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 759 | fss_fl_chunk_bytes_add (fss, n_collect); |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 760 | fsh_cached_bytes_add (fsh, n_collect); |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 761 | } |
| 762 | |
| 763 | void |
| 764 | fsh_collect_chunks (fifo_segment_header_t * fsh, u32 slice_index, |
Florin Coras | 9e61d9a | 2020-02-05 21:13:18 +0000 | [diff] [blame] | 765 | svm_fifo_chunk_t * c) |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 766 | { |
| 767 | fifo_segment_slice_t *fss; |
| 768 | fss = fsh_slice_get (fsh, slice_index); |
Florin Coras | 9e61d9a | 2020-02-05 21:13:18 +0000 | [diff] [blame] | 769 | fsh_slice_collect_chunks (fsh, fss, c); |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 770 | } |
| 771 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 772 | svm_fifo_t * |
| 773 | fs_fifo_alloc (fifo_segment_t *fs, u32 slice_index) |
| 774 | { |
| 775 | fifo_slice_private_t *pfss = &fs->slices[slice_index]; |
| 776 | svm_fifo_t *f; |
| 777 | |
| 778 | f = clib_mem_bulk_alloc (pfss->fifos); |
| 779 | clib_memset (f, 0, sizeof (*f)); |
| 780 | return f; |
| 781 | } |
| 782 | |
| 783 | void |
| 784 | fs_fifo_free (fifo_segment_t *fs, svm_fifo_t *f) |
| 785 | { |
| 786 | u32 slice_index = f->shr->slice_index; |
| 787 | fifo_slice_private_t *pfss; |
| 788 | |
| 789 | pfss = &fs->slices[slice_index]; |
| 790 | clib_mem_bulk_free (pfss->fifos, f); |
| 791 | } |
| 792 | |
| 793 | void |
| 794 | fifo_segment_cleanup (fifo_segment_t *fs) |
| 795 | { |
| 796 | int slice_index; |
Florin Coras | b462418 | 2020-12-11 13:58:12 -0800 | [diff] [blame] | 797 | svm_msg_q_t *mq = 0; |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 798 | |
| 799 | for (slice_index = 0; slice_index < fs->n_slices; slice_index++) |
| 800 | clib_mem_bulk_destroy (fs->slices[slice_index].fifos); |
Florin Coras | b462418 | 2020-12-11 13:58:12 -0800 | [diff] [blame] | 801 | |
| 802 | vec_foreach (fs->mqs, mq) |
| 803 | vec_free (mq->rings); |
| 804 | |
| 805 | vec_free (fs->mqs); |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 806 | } |
| 807 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 808 | /** |
| 809 | * Allocate fifo in fifo segment |
| 810 | */ |
| 811 | svm_fifo_t * |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 812 | fifo_segment_alloc_fifo_w_slice (fifo_segment_t * fs, u32 slice_index, |
| 813 | u32 data_bytes, fifo_segment_ftype_t ftype) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 814 | { |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 815 | fifo_segment_header_t *fsh = fs->h; |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 816 | fifo_slice_private_t *pfss; |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 817 | fifo_segment_slice_t *fss; |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 818 | svm_fifo_shared_t *sf; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 819 | svm_fifo_t *f = 0; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 820 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 821 | ASSERT (slice_index < fs->n_slices); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 822 | |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 823 | if (PREDICT_FALSE (data_bytes > 1 << fsh->max_log2_fifo_size)) |
Florin Coras | 0e6199d | 2020-04-17 20:15:22 +0000 | [diff] [blame] | 824 | return 0; |
| 825 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 826 | sf = fs_try_alloc_fifo (fsh, slice_index, data_bytes); |
| 827 | if (!sf) |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 828 | goto done; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 829 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 830 | f = fs_fifo_alloc (fs, slice_index); |
| 831 | f->fs_hdr = fsh; |
| 832 | f->shr = sf; |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 833 | |
Florin Coras | cefd5d8 | 2019-05-05 13:19:57 -0700 | [diff] [blame] | 834 | svm_fifo_init (f, data_bytes); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 835 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 836 | fss = fsh_slice_get (fsh, slice_index); |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 837 | pfss = fs_slice_private_get (fs, slice_index); |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 838 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 839 | /* If rx fifo type add to active fifos list. When cleaning up segment, |
| 840 | * we need a list of active sessions that should be disconnected. Since |
| 841 | * both rx and tx fifos keep pointers to the session, it's enough to track |
| 842 | * only one. */ |
| 843 | if (ftype == FIFO_SEGMENT_RX_FIFO) |
| 844 | { |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 845 | pfss_fifo_add_active_list (pfss, f); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 846 | f->flags |= SVM_FIFO_F_LL_TRACKED; |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 847 | } |
| 848 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 849 | fsh_active_fifos_update (fsh, 1); |
Florin Coras | 06d4775 | 2020-03-06 02:23:58 +0000 | [diff] [blame] | 850 | fss->virtual_mem += svm_fifo_size (f); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 851 | |
| 852 | done: |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 853 | return (f); |
| 854 | } |
| 855 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 856 | svm_fifo_t * |
Florin Coras | 14f066e | 2020-12-10 18:52:40 -0800 | [diff] [blame] | 857 | fifo_segment_alloc_fifo_w_offset (fifo_segment_t *fs, uword offset) |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 858 | { |
| 859 | svm_fifo_t *f = fs_fifo_alloc (fs, 0); |
Florin Coras | 14f066e | 2020-12-10 18:52:40 -0800 | [diff] [blame] | 860 | svm_fifo_shared_t *sf; |
| 861 | |
| 862 | sf = (svm_fifo_shared_t *) ((u8 *) fs->h + offset); |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 863 | f->fs_hdr = fs->h; |
| 864 | f->shr = sf; |
| 865 | |
| 866 | f->ooos_list_head = OOO_SEGMENT_INVALID_INDEX; |
| 867 | f->segment_index = SVM_FIFO_INVALID_INDEX; |
| 868 | f->refcnt = 1; |
| 869 | return f; |
| 870 | } |
| 871 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 872 | /** |
| 873 | * Free fifo allocated in fifo segment |
| 874 | */ |
| 875 | void |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 876 | fifo_segment_free_fifo (fifo_segment_t * fs, svm_fifo_t * f) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 877 | { |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 878 | fifo_segment_header_t *fsh = fs->h; |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 879 | fifo_slice_private_t *pfss; |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 880 | fifo_segment_slice_t *fss; |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 881 | svm_fifo_shared_t *sf; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 882 | |
| 883 | ASSERT (f->refcnt > 0); |
| 884 | |
| 885 | if (--f->refcnt > 0) |
| 886 | return; |
| 887 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 888 | /* |
| 889 | * Cleanup shared state |
| 890 | */ |
| 891 | |
| 892 | sf = f->shr; |
| 893 | fss = fsh_slice_get (fsh, sf->slice_index); |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 894 | pfss = fs_slice_private_get (fs, sf->slice_index); |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 895 | |
| 896 | /* Free fifo chunks */ |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 897 | fsh_slice_collect_chunks (fsh, fss, fs_chunk_ptr (fsh, f->shr->start_chunk)); |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 898 | |
| 899 | sf->start_chunk = sf->end_chunk = 0; |
| 900 | sf->head_chunk = sf->tail_chunk = 0; |
| 901 | |
| 902 | /* Add to free list */ |
Florin Coras | 17672aa | 2020-12-29 16:55:32 -0800 | [diff] [blame] | 903 | fss_fifo_free_list_push (fsh, fss, sf); |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 904 | |
| 905 | fss->virtual_mem -= svm_fifo_size (f); |
| 906 | |
| 907 | /* |
| 908 | * Cleanup private state |
| 909 | */ |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 910 | |
| 911 | /* Remove from active list. Only rx fifos are tracked */ |
| 912 | if (f->flags & SVM_FIFO_F_LL_TRACKED) |
| 913 | { |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 914 | pfss_fifo_del_active_list (pfss, f); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 915 | f->flags &= ~SVM_FIFO_F_LL_TRACKED; |
| 916 | } |
| 917 | |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 918 | svm_fifo_free_chunk_lookup (f); |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 919 | svm_fifo_free_ooo_data (f); |
| 920 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 921 | if (CLIB_DEBUG) |
| 922 | { |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 923 | sf->master_session_index = ~0; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 924 | f->master_thread_index = ~0; |
| 925 | } |
| 926 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 927 | f->ooo_enq = f->ooo_deq = 0; |
Florin Coras | 06d4775 | 2020-03-06 02:23:58 +0000 | [diff] [blame] | 928 | f->prev = 0; |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 929 | |
| 930 | fs_fifo_free (fs, f); |
Florin Coras | 06d4775 | 2020-03-06 02:23:58 +0000 | [diff] [blame] | 931 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 932 | fsh_active_fifos_update (fsh, -1); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 933 | } |
| 934 | |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 935 | void |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 936 | fifo_segment_detach_fifo (fifo_segment_t *fs, svm_fifo_t **f) |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 937 | { |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 938 | fifo_slice_private_t *pfss; |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 939 | fifo_segment_slice_t *fss; |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 940 | u32 fl_index, slice_index; |
| 941 | svm_fifo_chunk_t **c; |
| 942 | svm_fifo_t *of = *f; |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 943 | |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 944 | slice_index = of->master_thread_index; |
| 945 | fss = fsh_slice_get (fs->h, slice_index); |
| 946 | pfss = fs_slice_private_get (fs, slice_index); |
| 947 | fss->virtual_mem -= svm_fifo_size (of); |
| 948 | if (of->flags & SVM_FIFO_F_LL_TRACKED) |
| 949 | pfss_fifo_del_active_list (pfss, of); |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 950 | |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 951 | /* Update slice counts for chunks that were detached */ |
| 952 | vec_foreach (c, of->chunks_at_attach) |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 953 | { |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 954 | fl_index = fs_freelist_for_size ((*c)->length); |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 955 | clib_atomic_fetch_sub_rel (&fss->num_chunks[fl_index], 1); |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 956 | } |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 957 | vec_free (of->chunks_at_attach); |
| 958 | |
| 959 | clib_mem_bulk_free (pfss->fifos, *f); |
| 960 | *f = 0; |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 961 | } |
| 962 | |
| 963 | void |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 964 | fifo_segment_attach_fifo (fifo_segment_t *fs, svm_fifo_t **f, u32 slice_index) |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 965 | { |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 966 | fifo_slice_private_t *pfss; |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 967 | fifo_segment_slice_t *fss; |
| 968 | svm_fifo_chunk_t *c; |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 969 | svm_fifo_t *nf, *of; |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 970 | u32 fl_index; |
| 971 | |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 972 | nf = fs_fifo_alloc (fs, slice_index); |
| 973 | clib_memcpy_fast (nf, *f, sizeof (*nf)); |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 974 | |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 975 | fss = fsh_slice_get (fs->h, slice_index); |
| 976 | pfss = fs_slice_private_get (fs, slice_index); |
| 977 | fss->virtual_mem += svm_fifo_size (nf); |
| 978 | if (nf->flags & SVM_FIFO_F_LL_TRACKED) |
| 979 | pfss_fifo_add_active_list (pfss, nf); |
| 980 | |
| 981 | /* Update allocated chunks for fifo segment and build list |
| 982 | * of chunks to be freed at detach */ |
| 983 | of = *f; |
| 984 | of->chunks_at_attach = 0; |
| 985 | |
| 986 | c = fs_chunk_ptr (fs->h, nf->shr->start_chunk); |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 987 | while (c) |
| 988 | { |
| 989 | fl_index = fs_freelist_for_size (c->length); |
| 990 | clib_atomic_fetch_add_rel (&fss->num_chunks[fl_index], 1); |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 991 | vec_add1 (of->chunks_at_attach, c); |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 992 | c = fs_chunk_ptr (fs->h, c->next); |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 993 | } |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 994 | |
| 995 | nf->shr->slice_index = slice_index; |
| 996 | *f = nf; |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 997 | } |
| 998 | |
Florin Coras | 14f066e | 2020-12-10 18:52:40 -0800 | [diff] [blame] | 999 | uword |
| 1000 | fifo_segment_fifo_offset (svm_fifo_t *f) |
| 1001 | { |
| 1002 | return (u8 *) f->shr - (u8 *) f->fs_hdr; |
| 1003 | } |
| 1004 | |
Florin Coras | b462418 | 2020-12-11 13:58:12 -0800 | [diff] [blame] | 1005 | svm_msg_q_t * |
| 1006 | fifo_segment_msg_q_alloc (fifo_segment_t *fs, u32 mq_index, |
| 1007 | svm_msg_q_cfg_t *cfg) |
| 1008 | { |
| 1009 | fifo_segment_header_t *fsh = fs->h; |
| 1010 | svm_msg_q_shared_t *smq; |
| 1011 | svm_msg_q_t *mq; |
| 1012 | void *base; |
| 1013 | u32 size; |
| 1014 | |
| 1015 | if (!fs->mqs) |
| 1016 | { |
| 1017 | u32 n_mqs = clib_max (fs->h->n_mqs, 1); |
| 1018 | vec_validate (fs->mqs, n_mqs - 1); |
| 1019 | } |
| 1020 | |
| 1021 | size = svm_msg_q_size_to_alloc (cfg); |
| 1022 | base = fsh_alloc_aligned (fsh, size, 8); |
| 1023 | fsh->n_reserved_bytes += size; |
| 1024 | |
| 1025 | smq = svm_msg_q_init (base, cfg); |
| 1026 | mq = vec_elt_at_index (fs->mqs, mq_index); |
| 1027 | svm_msg_q_attach (mq, smq); |
| 1028 | |
| 1029 | return mq; |
| 1030 | } |
| 1031 | |
| 1032 | svm_msg_q_t * |
| 1033 | fifo_segment_msg_q_attach (fifo_segment_t *fs, uword offset, u32 mq_index) |
| 1034 | { |
| 1035 | svm_msg_q_t *mq; |
| 1036 | |
| 1037 | if (!fs->mqs) |
| 1038 | { |
| 1039 | u32 n_mqs = clib_max (fs->h->n_mqs, 1); |
| 1040 | vec_validate (fs->mqs, n_mqs - 1); |
| 1041 | } |
| 1042 | |
| 1043 | mq = vec_elt_at_index (fs->mqs, mq_index); |
| 1044 | |
| 1045 | if (!mq->q) |
| 1046 | { |
| 1047 | svm_msg_q_shared_t *smq; |
| 1048 | smq = (svm_msg_q_shared_t *) ((u8 *) fs->h + offset); |
| 1049 | svm_msg_q_attach (mq, smq); |
| 1050 | } |
| 1051 | |
| 1052 | ASSERT (fifo_segment_msg_q_offset (fs, mq_index) == offset); |
| 1053 | |
| 1054 | return mq; |
| 1055 | } |
| 1056 | |
| 1057 | uword |
| 1058 | fifo_segment_msg_q_offset (fifo_segment_t *fs, u32 mq_index) |
| 1059 | { |
| 1060 | svm_msg_q_t *mq = vec_elt_at_index (fs->mqs, mq_index); |
| 1061 | |
| 1062 | if (mq->q == 0) |
| 1063 | return ~0ULL; |
| 1064 | |
| 1065 | return (uword) ((u8 *) mq->q - (u8 *) fs->h) - sizeof (svm_msg_q_shared_t); |
| 1066 | } |
| 1067 | |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1068 | int |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1069 | fifo_segment_prealloc_fifo_hdrs (fifo_segment_t * fs, u32 slice_index, |
| 1070 | u32 batch_size) |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1071 | { |
| 1072 | fifo_segment_header_t *fsh = fs->h; |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1073 | fifo_segment_slice_t *fss; |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1074 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1075 | fss = fsh_slice_get (fsh, slice_index); |
Florin Coras | fe1ab7e | 2020-11-26 11:34:38 -0800 | [diff] [blame] | 1076 | return fsh_try_alloc_fifo_hdr_batch (fsh, fss, batch_size); |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1077 | } |
| 1078 | |
| 1079 | int |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1080 | fifo_segment_prealloc_fifo_chunks (fifo_segment_t * fs, u32 slice_index, |
| 1081 | u32 chunk_size, u32 batch_size) |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1082 | { |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1083 | fifo_segment_header_t *fsh = fs->h; |
| 1084 | fifo_segment_slice_t *fss; |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 1085 | u32 fl_index; |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1086 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1087 | if (!fs_chunk_size_is_valid (fsh, chunk_size)) |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1088 | { |
| 1089 | clib_warning ("chunk size out of range %d", chunk_size); |
| 1090 | return -1; |
| 1091 | } |
| 1092 | |
| 1093 | fl_index = fs_freelist_for_size (chunk_size); |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1094 | fss = fsh_slice_get (fsh, slice_index); |
| 1095 | |
Florin Coras | 473c846 | 2020-11-16 18:11:51 -0800 | [diff] [blame] | 1096 | return fsh_try_alloc_chunk_batch (fsh, fss, fl_index, batch_size); |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1097 | } |
| 1098 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1099 | /** |
| 1100 | * Pre-allocates fifo pairs in fifo segment |
| 1101 | */ |
| 1102 | void |
| 1103 | fifo_segment_preallocate_fifo_pairs (fifo_segment_t * fs, |
| 1104 | u32 rx_fifo_size, u32 tx_fifo_size, |
| 1105 | u32 * n_fifo_pairs) |
| 1106 | { |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1107 | u32 rx_rounded_data_size, tx_rounded_data_size, pair_size, pairs_to_alloc; |
Florin Coras | 8d0149d | 2020-01-02 19:22:51 +0000 | [diff] [blame] | 1108 | u32 hdrs, pairs_per_slice, alloc_now; |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1109 | fifo_segment_header_t *fsh = fs->h; |
| 1110 | int rx_fl_index, tx_fl_index, i; |
| 1111 | fifo_segment_slice_t *fss; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1112 | uword space_available; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1113 | |
| 1114 | /* Parameter check */ |
| 1115 | if (rx_fifo_size == 0 || tx_fifo_size == 0 || *n_fifo_pairs == 0) |
| 1116 | return; |
| 1117 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1118 | if (!fs_chunk_size_is_valid (fsh, rx_fifo_size)) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1119 | { |
| 1120 | clib_warning ("rx fifo_size out of range %d", rx_fifo_size); |
| 1121 | return; |
| 1122 | } |
| 1123 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1124 | if (!fs_chunk_size_is_valid (fsh, tx_fifo_size)) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1125 | { |
| 1126 | clib_warning ("tx fifo_size out of range %d", tx_fifo_size); |
| 1127 | return; |
| 1128 | } |
| 1129 | |
| 1130 | rx_rounded_data_size = (1 << (max_log2 (rx_fifo_size))); |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1131 | rx_fl_index = fs_freelist_for_size (rx_fifo_size); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1132 | tx_rounded_data_size = (1 << (max_log2 (tx_fifo_size))); |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1133 | tx_fl_index = fs_freelist_for_size (tx_fifo_size); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1134 | |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1135 | hdrs = sizeof (svm_fifo_t) + sizeof (svm_fifo_chunk_t); |
Florin Coras | cefd5d8 | 2019-05-05 13:19:57 -0700 | [diff] [blame] | 1136 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1137 | /* Calculate space requirements */ |
Florin Coras | cefd5d8 | 2019-05-05 13:19:57 -0700 | [diff] [blame] | 1138 | pair_size = 2 * hdrs + rx_rounded_data_size + tx_rounded_data_size; |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 1139 | space_available = fsh_n_free_bytes (fsh); |
Florin Coras | eaacce4 | 2019-07-02 13:07:37 -0700 | [diff] [blame] | 1140 | pairs_to_alloc = space_available / pair_size; |
| 1141 | pairs_to_alloc = clib_min (pairs_to_alloc, *n_fifo_pairs); |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1142 | pairs_per_slice = pairs_to_alloc / fs->n_slices; |
Florin Coras | 8d0149d | 2020-01-02 19:22:51 +0000 | [diff] [blame] | 1143 | pairs_per_slice += pairs_to_alloc % fs->n_slices ? 1 : 0; |
Florin Coras | eaacce4 | 2019-07-02 13:07:37 -0700 | [diff] [blame] | 1144 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1145 | if (!pairs_per_slice) |
Florin Coras | eaacce4 | 2019-07-02 13:07:37 -0700 | [diff] [blame] | 1146 | return; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1147 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1148 | for (i = 0; i < fs->n_slices; i++) |
| 1149 | { |
Florin Coras | 8d0149d | 2020-01-02 19:22:51 +0000 | [diff] [blame] | 1150 | alloc_now = clib_min (pairs_per_slice, *n_fifo_pairs); |
Benoît Ganne | f23b151 | 2020-11-25 15:06:01 +0100 | [diff] [blame] | 1151 | if (0 == alloc_now) |
| 1152 | break; |
| 1153 | |
| 1154 | fss = fsh_slice_get (fsh, i); |
Florin Coras | 8d0149d | 2020-01-02 19:22:51 +0000 | [diff] [blame] | 1155 | if (fs_try_alloc_fifo_batch (fsh, fss, rx_fl_index, alloc_now)) |
| 1156 | clib_warning ("rx prealloc failed: pairs %u", alloc_now); |
| 1157 | if (fs_try_alloc_fifo_batch (fsh, fss, tx_fl_index, alloc_now)) |
| 1158 | clib_warning ("tx prealloc failed: pairs %u", alloc_now); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1159 | |
Florin Coras | 8d0149d | 2020-01-02 19:22:51 +0000 | [diff] [blame] | 1160 | /* Account for the pairs allocated */ |
| 1161 | *n_fifo_pairs -= alloc_now; |
| 1162 | } |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1163 | } |
| 1164 | |
| 1165 | /** |
| 1166 | * Get number of active fifos |
| 1167 | */ |
| 1168 | u32 |
| 1169 | fifo_segment_num_fifos (fifo_segment_t * fs) |
| 1170 | { |
Florin Coras | 7a90e50 | 2020-04-09 04:46:14 +0000 | [diff] [blame] | 1171 | return fsh_n_active_fifos (fs->h); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1172 | } |
| 1173 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1174 | static u32 |
Florin Coras | 17672aa | 2020-12-29 16:55:32 -0800 | [diff] [blame] | 1175 | fs_slice_num_free_fifos (fifo_segment_header_t *fsh, fifo_segment_slice_t *fss) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1176 | { |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 1177 | svm_fifo_shared_t *f; |
Florin Coras | cefd5d8 | 2019-05-05 13:19:57 -0700 | [diff] [blame] | 1178 | u32 count = 0; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1179 | |
Florin Coras | 17672aa | 2020-12-29 16:55:32 -0800 | [diff] [blame] | 1180 | f = fs_ptr (fsh, fss->free_fifos); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1181 | if (f == 0) |
| 1182 | return 0; |
| 1183 | |
| 1184 | while (f) |
| 1185 | { |
Florin Coras | 17672aa | 2020-12-29 16:55:32 -0800 | [diff] [blame] | 1186 | f = fs_ptr (fsh, f->next); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1187 | count++; |
| 1188 | } |
| 1189 | return count; |
| 1190 | } |
| 1191 | |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 1192 | u32 |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1193 | fifo_segment_num_free_fifos (fifo_segment_t * fs) |
| 1194 | { |
| 1195 | fifo_segment_header_t *fsh = fs->h; |
| 1196 | fifo_segment_slice_t *fss; |
| 1197 | int slice_index; |
| 1198 | u32 count = 0; |
| 1199 | |
| 1200 | for (slice_index = 0; slice_index < fs->n_slices; slice_index++) |
| 1201 | { |
| 1202 | fss = fsh_slice_get (fsh, slice_index); |
Florin Coras | 17672aa | 2020-12-29 16:55:32 -0800 | [diff] [blame] | 1203 | count += fs_slice_num_free_fifos (fsh, fss); |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1204 | } |
| 1205 | return count; |
| 1206 | } |
| 1207 | |
| 1208 | static u32 |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 1209 | fs_slice_num_free_chunks (fifo_segment_header_t *fsh, |
| 1210 | fifo_segment_slice_t *fss, u32 size) |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 1211 | { |
| 1212 | u32 count = 0, rounded_size, fl_index; |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 1213 | svm_fifo_chunk_t *c; |
| 1214 | int i; |
| 1215 | |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 1216 | /* Count all free chunks? */ |
| 1217 | if (size == ~0) |
| 1218 | { |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 1219 | for (i = 0; i < FS_CHUNK_VEC_LEN; i++) |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 1220 | { |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 1221 | c = fs_chunk_ptr (fsh, fss->free_chunks[i]); |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 1222 | if (c == 0) |
| 1223 | continue; |
| 1224 | |
| 1225 | while (c) |
| 1226 | { |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 1227 | c = fs_chunk_ptr (fsh, c->next); |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 1228 | count++; |
| 1229 | } |
| 1230 | } |
| 1231 | return count; |
| 1232 | } |
| 1233 | |
| 1234 | rounded_size = (1 << (max_log2 (size))); |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1235 | fl_index = fs_freelist_for_size (rounded_size); |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 1236 | |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 1237 | if (fl_index >= FS_CHUNK_VEC_LEN) |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 1238 | return 0; |
| 1239 | |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 1240 | c = fs_chunk_ptr (fsh, fss->free_chunks[fl_index]); |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 1241 | if (c == 0) |
| 1242 | return 0; |
| 1243 | |
| 1244 | while (c) |
| 1245 | { |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 1246 | c = fs_chunk_ptr (fsh, c->next); |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 1247 | count++; |
| 1248 | } |
| 1249 | return count; |
| 1250 | } |
| 1251 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1252 | u32 |
| 1253 | fifo_segment_num_free_chunks (fifo_segment_t * fs, u32 size) |
| 1254 | { |
| 1255 | fifo_segment_header_t *fsh = fs->h; |
| 1256 | fifo_segment_slice_t *fss; |
| 1257 | int slice_index; |
| 1258 | u32 count = 0; |
| 1259 | |
| 1260 | for (slice_index = 0; slice_index < fs->n_slices; slice_index++) |
| 1261 | { |
| 1262 | fss = fsh_slice_get (fsh, slice_index); |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 1263 | count += fs_slice_num_free_chunks (fsh, fss, size); |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1264 | } |
| 1265 | return count; |
| 1266 | } |
| 1267 | |
Florin Coras | ef4f3e7 | 2019-12-11 14:27:53 -0800 | [diff] [blame] | 1268 | uword |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 1269 | fifo_segment_size (fifo_segment_t * fs) |
| 1270 | { |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 1271 | return fs->h->max_byte_index - fs->h->n_reserved_bytes; |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 1272 | } |
| 1273 | |
| 1274 | u8 |
| 1275 | fsh_has_reached_mem_limit (fifo_segment_header_t * fsh) |
| 1276 | { |
| 1277 | return (fsh->flags & FIFO_SEGMENT_F_MEM_LIMIT) ? 1 : 0; |
| 1278 | } |
| 1279 | |
| 1280 | void |
| 1281 | fsh_reset_mem_limit (fifo_segment_header_t * fsh) |
| 1282 | { |
| 1283 | fsh->flags &= ~FIFO_SEGMENT_F_MEM_LIMIT; |
| 1284 | } |
| 1285 | |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 1286 | void * |
| 1287 | fifo_segment_alloc (fifo_segment_t *fs, uword size) |
| 1288 | { |
| 1289 | void *rv = fsh_alloc (fs->h, size); |
| 1290 | /* Mark externally allocated bytes as reserved. This helps |
| 1291 | * @ref fifo_segment_size report bytes used only for fifos */ |
| 1292 | fs->h->n_reserved_bytes += size; |
| 1293 | return rv; |
| 1294 | } |
| 1295 | |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 1296 | uword |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1297 | fifo_segment_free_bytes (fifo_segment_t * fs) |
| 1298 | { |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1299 | return fsh_n_free_bytes (fs->h); |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1300 | } |
| 1301 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1302 | uword |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 1303 | fifo_segment_cached_bytes (fifo_segment_t * fs) |
| 1304 | { |
| 1305 | return fsh_n_cached_bytes (fs->h); |
| 1306 | } |
| 1307 | |
| 1308 | uword |
Florin Coras | 75ccf7b | 2020-03-05 19:44:02 +0000 | [diff] [blame] | 1309 | fifo_segment_available_bytes (fifo_segment_t * fs) |
| 1310 | { |
| 1311 | return fsh_n_free_bytes (fs->h) + fsh_n_cached_bytes (fs->h); |
| 1312 | } |
| 1313 | |
| 1314 | uword |
Florin Coras | 1c91c77 | 2019-06-25 18:14:13 -0700 | [diff] [blame] | 1315 | fifo_segment_fl_chunk_bytes (fifo_segment_t * fs) |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1316 | { |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1317 | fifo_segment_header_t *fsh = fs->h; |
| 1318 | fifo_segment_slice_t *fss; |
| 1319 | uword n_bytes = 0; |
| 1320 | int slice_index; |
| 1321 | |
| 1322 | for (slice_index = 0; slice_index < fs->n_slices; slice_index++) |
| 1323 | { |
| 1324 | fss = fsh_slice_get (fsh, slice_index); |
Florin Coras | d01d2ce | 2020-11-17 18:42:38 -0800 | [diff] [blame] | 1325 | n_bytes += fss_fl_chunk_bytes (fss); |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1326 | } |
| 1327 | |
| 1328 | return n_bytes; |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 1329 | } |
| 1330 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1331 | u8 |
| 1332 | fifo_segment_has_fifos (fifo_segment_t * fs) |
| 1333 | { |
Florin Coras | 7a90e50 | 2020-04-09 04:46:14 +0000 | [diff] [blame] | 1334 | return (fsh_n_active_fifos (fs->h) != 0); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1335 | } |
| 1336 | |
| 1337 | svm_fifo_t * |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1338 | fifo_segment_get_slice_fifo_list (fifo_segment_t * fs, u32 slice_index) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1339 | { |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 1340 | fifo_slice_private_t *pfss; |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1341 | |
Florin Coras | 1f952d3 | 2020-12-09 19:43:21 -0800 | [diff] [blame] | 1342 | pfss = fs_slice_private_get (fs, slice_index); |
| 1343 | return pfss->active_fifos; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1344 | } |
| 1345 | |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 1346 | u8 |
| 1347 | fifo_segment_get_mem_usage (fifo_segment_t * fs) |
| 1348 | { |
| 1349 | uword size, in_use; |
| 1350 | |
| 1351 | size = fifo_segment_size (fs); |
| 1352 | in_use = |
| 1353 | size - fifo_segment_free_bytes (fs) - fifo_segment_cached_bytes (fs); |
| 1354 | return (in_use * 100) / size; |
| 1355 | } |
| 1356 | |
| 1357 | fifo_segment_mem_status_t |
| 1358 | fifo_segment_determine_status (fifo_segment_header_t * fsh, u8 usage) |
| 1359 | { |
| 1360 | if (!fsh->high_watermark || !fsh->low_watermark) |
| 1361 | return MEMORY_PRESSURE_NO_PRESSURE; |
| 1362 | |
| 1363 | /* once the no-memory is detected, the status continues |
| 1364 | * until memory usage gets below the high watermark |
| 1365 | */ |
| 1366 | if (fsh_has_reached_mem_limit (fsh)) |
| 1367 | { |
| 1368 | if (usage >= fsh->high_watermark) |
| 1369 | return MEMORY_PRESSURE_NO_MEMORY; |
| 1370 | else |
| 1371 | fsh_reset_mem_limit (fsh); |
| 1372 | } |
| 1373 | |
| 1374 | if (usage >= fsh->high_watermark) |
| 1375 | return MEMORY_PRESSURE_HIGH_PRESSURE; |
| 1376 | |
| 1377 | else if (usage >= fsh->low_watermark) |
| 1378 | return MEMORY_PRESSURE_LOW_PRESSURE; |
| 1379 | |
| 1380 | return MEMORY_PRESSURE_NO_PRESSURE; |
| 1381 | } |
| 1382 | |
| 1383 | fifo_segment_mem_status_t |
| 1384 | fifo_segment_get_mem_status (fifo_segment_t * fs) |
| 1385 | { |
| 1386 | fifo_segment_header_t *fsh = fs->h; |
| 1387 | u8 usage = fifo_segment_get_mem_usage (fs); |
| 1388 | |
| 1389 | return fifo_segment_determine_status (fsh, usage); |
| 1390 | } |
| 1391 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1392 | u8 * |
| 1393 | format_fifo_segment_type (u8 * s, va_list * args) |
| 1394 | { |
| 1395 | fifo_segment_t *sp; |
| 1396 | sp = va_arg (*args, fifo_segment_t *); |
| 1397 | ssvm_segment_type_t st = ssvm_type (&sp->ssvm); |
| 1398 | |
| 1399 | if (st == SSVM_SEGMENT_PRIVATE) |
Florin Coras | 2a7c0b6 | 2020-09-28 23:40:28 -0700 | [diff] [blame] | 1400 | s = format (s, "%s", "private"); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1401 | else if (st == SSVM_SEGMENT_MEMFD) |
| 1402 | s = format (s, "%s", "memfd"); |
| 1403 | else if (st == SSVM_SEGMENT_SHM) |
| 1404 | s = format (s, "%s", "shm"); |
| 1405 | else |
| 1406 | s = format (s, "%s", "unknown"); |
| 1407 | return s; |
| 1408 | } |
| 1409 | |
| 1410 | /** |
| 1411 | * Segment format function |
| 1412 | */ |
| 1413 | u8 * |
| 1414 | format_fifo_segment (u8 * s, va_list * args) |
| 1415 | { |
Ryujiro Shibuya | 65c30ce | 2020-03-26 07:29:09 +0000 | [diff] [blame] | 1416 | u32 count, indent, active_fifos, free_fifos; |
Florin Coras | 5368bb0 | 2019-06-09 09:24:33 -0700 | [diff] [blame] | 1417 | fifo_segment_t *fs = va_arg (*args, fifo_segment_t *); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1418 | int verbose __attribute__ ((unused)) = va_arg (*args, int); |
Florin Coras | ef4f3e7 | 2019-12-11 14:27:53 -0800 | [diff] [blame] | 1419 | uword est_chunk_bytes, est_free_seg_bytes, free_chunks; |
| 1420 | uword chunk_bytes = 0, free_seg_bytes, chunk_size; |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 1421 | uword tracked_cached_bytes; |
Ryujiro Shibuya | 65c30ce | 2020-03-26 07:29:09 +0000 | [diff] [blame] | 1422 | uword fifo_hdr = 0, reserved; |
Florin Coras | 5368bb0 | 2019-06-09 09:24:33 -0700 | [diff] [blame] | 1423 | fifo_segment_header_t *fsh; |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1424 | fifo_segment_slice_t *fss; |
Florin Coras | cefd5d8 | 2019-05-05 13:19:57 -0700 | [diff] [blame] | 1425 | svm_fifo_chunk_t *c; |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1426 | u32 slice_index; |
Florin Coras | 5368bb0 | 2019-06-09 09:24:33 -0700 | [diff] [blame] | 1427 | char *address; |
| 1428 | size_t size; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1429 | int i; |
Florin Coras | 06d4775 | 2020-03-06 02:23:58 +0000 | [diff] [blame] | 1430 | uword allocated, in_use, virt; |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 1431 | f64 usage; |
| 1432 | fifo_segment_mem_status_t mem_st; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1433 | |
| 1434 | indent = format_get_indent (s) + 2; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1435 | |
Florin Coras | 5368bb0 | 2019-06-09 09:24:33 -0700 | [diff] [blame] | 1436 | if (fs == 0) |
| 1437 | { |
Florin Coras | 2a7c0b6 | 2020-09-28 23:40:28 -0700 | [diff] [blame] | 1438 | s = format (s, "%-20s%10s%15s%15s%15s%15s", "Name", "Type", |
Florin Coras | 5368bb0 | 2019-06-09 09:24:33 -0700 | [diff] [blame] | 1439 | "HeapSize (M)", "ActiveFifos", "FreeFifos", "Address"); |
| 1440 | return s; |
| 1441 | } |
| 1442 | |
Florin Coras | 5368bb0 | 2019-06-09 09:24:33 -0700 | [diff] [blame] | 1443 | fifo_segment_info (fs, &address, &size); |
| 1444 | active_fifos = fifo_segment_num_fifos (fs); |
| 1445 | free_fifos = fifo_segment_num_free_fifos (fs); |
| 1446 | |
Florin Coras | 2a7c0b6 | 2020-09-28 23:40:28 -0700 | [diff] [blame] | 1447 | s = format (s, "%-20v%10U%15llu%15u%15u%15llx", ssvm_name (&fs->ssvm), |
Florin Coras | 5368bb0 | 2019-06-09 09:24:33 -0700 | [diff] [blame] | 1448 | format_fifo_segment_type, fs, size >> 20ULL, active_fifos, |
| 1449 | free_fifos, address); |
| 1450 | |
| 1451 | if (!verbose) |
| 1452 | return s; |
| 1453 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1454 | fsh = fs->h; |
| 1455 | |
| 1456 | free_chunks = fifo_segment_num_free_chunks (fs, ~0); |
| 1457 | if (free_chunks) |
Ryujiro Shibuya | d358872 | 2020-03-13 12:45:06 +0000 | [diff] [blame] | 1458 | s = |
| 1459 | format (s, "\n\n%UFree/Allocated chunks by size:\n", format_white_space, |
| 1460 | indent + 2); |
Florin Coras | f8461bf | 2019-11-07 17:00:15 -0800 | [diff] [blame] | 1461 | else |
| 1462 | s = format (s, "\n"); |
| 1463 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1464 | for (slice_index = 0; slice_index < fs->n_slices; slice_index++) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1465 | { |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1466 | fss = fsh_slice_get (fsh, slice_index); |
Florin Coras | 4b8011e | 2020-12-07 19:38:23 -0800 | [diff] [blame] | 1467 | for (i = 0; i < FS_CHUNK_VEC_LEN; i++) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1468 | { |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 1469 | c = fs_chunk_ptr (fsh, fss->free_chunks[i]); |
Ryujiro Shibuya | d358872 | 2020-03-13 12:45:06 +0000 | [diff] [blame] | 1470 | if (c == 0 && fss->num_chunks[i] == 0) |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1471 | continue; |
| 1472 | count = 0; |
| 1473 | while (c) |
| 1474 | { |
Florin Coras | af58882 | 2020-12-09 12:51:13 -0800 | [diff] [blame] | 1475 | c = fs_chunk_ptr (fsh, c->next); |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1476 | count++; |
| 1477 | } |
| 1478 | |
| 1479 | chunk_size = fs_freelist_index_to_size (i); |
Ryujiro Shibuya | d358872 | 2020-03-13 12:45:06 +0000 | [diff] [blame] | 1480 | s = format (s, "%U%-5u kB: %u/%u\n", format_white_space, indent + 2, |
| 1481 | chunk_size >> 10, count, fss->num_chunks[i]); |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1482 | |
| 1483 | chunk_bytes += count * chunk_size; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1484 | } |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1485 | } |
Florin Coras | f8461bf | 2019-11-07 17:00:15 -0800 | [diff] [blame] | 1486 | |
| 1487 | fifo_hdr = free_fifos * sizeof (svm_fifo_t); |
| 1488 | est_chunk_bytes = fifo_segment_fl_chunk_bytes (fs); |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1489 | est_free_seg_bytes = fifo_segment_free_bytes (fs); |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1490 | free_seg_bytes = fifo_segment_free_bytes (fs); |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 1491 | tracked_cached_bytes = fifo_segment_cached_bytes (fs); |
| 1492 | allocated = fifo_segment_size (fs); |
| 1493 | in_use = fifo_segment_size (fs) - est_free_seg_bytes - tracked_cached_bytes; |
| 1494 | usage = (100.0 * in_use) / allocated; |
| 1495 | mem_st = fifo_segment_get_mem_status (fs); |
Florin Coras | 06d4775 | 2020-03-06 02:23:58 +0000 | [diff] [blame] | 1496 | virt = fsh_virtual_mem (fsh); |
Ryujiro Shibuya | 65c30ce | 2020-03-26 07:29:09 +0000 | [diff] [blame] | 1497 | reserved = fsh->n_reserved_bytes; |
Florin Coras | f8461bf | 2019-11-07 17:00:15 -0800 | [diff] [blame] | 1498 | |
Florin Coras | 06d4775 | 2020-03-06 02:23:58 +0000 | [diff] [blame] | 1499 | s = format (s, "\n%Useg free bytes: %U (%lu) estimated: %U (%lu) reserved:" |
| 1500 | " %U (%lu)\n", format_white_space, indent + 2, |
| 1501 | format_memory_size, free_seg_bytes, free_seg_bytes, |
| 1502 | format_memory_size, est_free_seg_bytes, est_free_seg_bytes, |
Ryujiro Shibuya | 65c30ce | 2020-03-26 07:29:09 +0000 | [diff] [blame] | 1503 | format_memory_size, reserved, reserved); |
Florin Coras | 06d4775 | 2020-03-06 02:23:58 +0000 | [diff] [blame] | 1504 | s = format (s, "%Uchunk free bytes: %U (%lu) estimated: %U (%lu) tracked:" |
| 1505 | " %U (%lu)\n", format_white_space, indent + 2, |
| 1506 | format_memory_size, chunk_bytes, chunk_bytes, |
| 1507 | format_memory_size, est_chunk_bytes, est_chunk_bytes, |
| 1508 | format_memory_size, tracked_cached_bytes, tracked_cached_bytes); |
| 1509 | s = format (s, "%Ufifo active: %u hdr free bytes: %U (%u) \n", |
| 1510 | format_white_space, indent + 2, fsh->n_active_fifos, |
| 1511 | format_memory_size, fifo_hdr, fifo_hdr); |
| 1512 | s = format (s, "%Usegment usage: %.2f%% (%U / %U) virt: %U status: %s\n", |
| 1513 | format_white_space, indent + 2, usage, format_memory_size, |
| 1514 | in_use, format_memory_size, allocated, format_memory_size, virt, |
| 1515 | fifo_segment_mem_status_strings[mem_st]); |
Florin Coras | f8461bf | 2019-11-07 17:00:15 -0800 | [diff] [blame] | 1516 | s = format (s, "\n"); |
Florin Coras | 5368bb0 | 2019-06-09 09:24:33 -0700 | [diff] [blame] | 1517 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1518 | return s; |
| 1519 | } |
| 1520 | |
| 1521 | /* |
| 1522 | * fd.io coding-style-patch-verification: ON |
| 1523 | * |
| 1524 | * Local Variables: |
| 1525 | * eval: (c-set-style "gnu") |
| 1526 | * End: |
| 1527 | */ |