FD.io VPP  v20.05.1-6-gf53edbc3b
Vector Packet Processing
fifo_segment.h
Go to the documentation of this file.
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 #ifndef __included_fifo_segment_h__
16 #define __included_fifo_segment_h__
17 
18 #include <svm/ssvm.h>
19 #include <svm/fifo_types.h>
20 #include <svm/svm_fifo.h>
21 
22 typedef enum
23 {
29 
30 #define FIFO_SEGMENT_MIN_LOG2_FIFO_SIZE 12 /**< 4kB min fifo size */
31 #define FIFO_SEGMENT_MIN_FIFO_SIZE 4096 /**< 4kB min fifo size */
32 #define FIFO_SEGMENT_MAX_FIFO_SIZE (2 << 30) /**< 2GB max fifo size */
33 #define FIFO_SEGMENT_ALLOC_BATCH_SIZE 32 /* Allocation quantum */
34 
35 typedef enum fifo_segment_flags_
36 {
41 
42 #define foreach_segment_mem_status \
43 _(NO_PRESSURE, "No pressure") \
44 _(LOW_PRESSURE, "Low pressure") \
45 _(HIGH_PRESSURE, "High pressure") \
46 _(NO_MEMORY, "No memory")
47 
48 typedef enum
49 {
50 #define _(sym,str) MEMORY_PRESSURE_##sym,
52 #undef _
55 
56 #if 0
57 typedef enum fifo_segment_mem_status_
58 {
59  MEMORY_PRESSURE_NO_PRESSURE,
60  MEMORY_PRESSURE_LOW_PRESSURE,
61  MEMORY_PRESSURE_HIGH_PRESSURE,
62  MEMORY_PRESSURE_NO_MEMORY,
64 #endif
65 
66 typedef struct
67 {
68  ssvm_private_t ssvm; /**< ssvm segment data */
69  fifo_segment_header_t *h; /**< fifo segment data */
70  u8 n_slices; /**< number of fifo segment slices */
72 
73 typedef struct
74 {
75  fifo_segment_t *segments; /**< pool of fifo segments */
76  uword next_baseva; /**< Where to put the next one */
77  u32 timeout_in_seconds; /**< Time to wait during attach */
79 
80 typedef struct
81 {
82  ssvm_segment_type_t segment_type; /**< type of segment requested */
83  u32 segment_size; /**< size of the segment */
84  int memfd_fd; /**< fd for memfd segments */
85  char *segment_name; /**< segment name */
86  u32 *new_segment_indices; /**< return vec of new seg indices */
88 
89 #define fifo_segment_flags(_fs) _fs->h->flags
90 
98  u32 fs_index);
100 void fifo_segment_info (fifo_segment_t * seg, char **address, size_t * size);
101 
102 /**
103  * Allocate fifo in fifo segment
104  *
105  * @param fs fifo segment for fifo
106  * @param data_bytes size of default fifo chunk in bytes
107  * @param ftype fifo type @ref fifo_segment_ftype_t
108  * @return new fifo or 0 if alloc failed
109  */
111  u32 slice_index,
112  u32 data_bytes,
113  fifo_segment_ftype_t ftype);
114 
115 /**
116  * Free fifo allocated in fifo segment
117  *
118  * @param fs fifo segment for fifo
119  * @param f fifo to be freed
120  */
122 
125  u32 slice_index);
126 
127 /**
128  * Try to preallocate fifo headers
129  *
130  * Tries to preallocate fifo headers and adds them to freelist.
131  *
132  * @param fs fifo segment
133  * @param batch_size number of chunks to be allocated
134  * @return 0 on success, negative number otherwise
135  */
136 int fifo_segment_prealloc_fifo_hdrs (fifo_segment_t * fs, u32 slice_index,
137  u32 batch_size);
138 
139 /**
140  * Try to preallocate fifo chunks on segment
141  *
142  * Tries to preallocate chunks of requested size on segment and adds them
143  * to chunk freelist.
144  *
145  * @param fs fifo segment
146  * @param chunk_size size of chunks to be allocated in bytes
147  * @param batch_size number of chunks to be allocated
148  * @return 0 on success, negative number otherwise
149  */
151  u32 chunk_size, u32 batch_size);
152 /**
153  * Pre-allocates fifo pairs in fifo segment
154  *
155  * The number of fifos pre-allocated is the minimum of the requested number
156  * of pairs and the maximum number that fit within the segment. If the maximum
157  * is hit, the number of fifo pairs requested is updated by subtracting the
158  * number of fifos that have been successfully allocated.
159  *
160  * @param fs fifo segment for fifo
161  * @param rx_fifo_size data size of rx fifos
162  * @param tx_fifo_size data size of tx fifos
163  * @param n_fifo_pairs number of pairs requested. Prior to returning, this
164  * is decremented by the the number of pairs allocated.
165  */
167  u32 rx_fifo_size,
168  u32 tx_fifo_size,
169  u32 * n_fifo_pairs);
170 
171 /**
172  * Allocate chunks in fifo segment
173  *
174  * @param fsh fifo segment header
175  * @param slice_index slice where chunks should be alocated
176  * @param chunk_size chunk size needed
177  * @return chunk (or chunks) that cover at least chunk_size bytes
178  * on success, 0 on failure.
179  */
181  u32 slice_index, u32 chunk_size);
182 
183 /**
184  * Return chunks to fifo segment
185  *
186  * @param fsh fifo segment header
187  * @param slice_index slice where chunks should be returned
188  * @param c pointer to first chunk in 0 terminated linked list
189  */
190 void fsh_collect_chunks (fifo_segment_header_t * fsh, u32 slice_index,
191  svm_fifo_chunk_t * c);
192 
193 /**
194  * Fifo segment has reached mem limit
195  *
196  * @param fsh fifo segment header
197  * @return 1 (if reached) or 0 (otherwise)
198  */
200 
201 /**
202  * Fifo segment reset mem limit flag
203  *
204  * @param fs fifo segment
205  */
207 
208 /**
209  * Fifo segment allocated size
210  *
211  * Returns fifo segment's allocated size
212  *
213  * @param fs fifo segment
214  * @return allocated size in bytes
215  */
217 
218 /**
219  * Fifo segment estimate of number of free bytes
220  *
221  * Returns fifo segment's internal estimate of the number of free bytes.
222  * To force a synchronization between the segment and the underlying
223  * memory allocator, call @ref fifo_segment_update_free_bytes
224  *
225  * @param fs fifo segment
226  * @return free bytes estimate
227  */
229 
230 /**
231  * Update fifo segment free bytes estimate
232  *
233  * Forces fifo segment free bytes estimate synchronization with underlying
234  * memory allocator.
235  *
236  * @param fs fifo segment
237  */
239 
240 /**
241  * Fifo segment number of cached bytes
242  *
243  * Returns fifo segment's number of cached bytes.
244  *
245  * @param fs fifo segment
246  * @return cached bytes
247  */
249 
251 
252 /**
253  * Number of bytes on chunk free lists
254  *
255  * @param fs fifo segment
256  * @return free bytes on chunk free lists
257  */
261  u32 slice_index);
264 /**
265  * Find number of free chunks of given size
266  *
267  * @param fs fifo segment
268  * @param size chunk size of interest or ~0 if all should be counted
269  * @return number of chunks of given size
270  */
272 
275  (fifo_segment_header_t * fsh, u8 usage);
277 
279  u32 timeout_in_seconds);
280 
283 
284 #endif /* __included_fifo_segment_h__ */
285 
286 /*
287  * fd.io coding-style-patch-verification: ON
288  *
289  * Local Variables:
290  * eval: (c-set-style "gnu")
291  * End:
292  */
fifo_segment_header_t * h
fifo segment data
Definition: fifo_segment.h:69
a
Definition: bitmap.h:538
unsigned long u64
Definition: types.h:89
fifo_segment_mem_status_t
Definition: fifo_segment.h:48
#define foreach_segment_mem_status
Definition: fifo_segment.h:42
int fifo_segment_attach(fifo_segment_main_t *sm, fifo_segment_create_args_t *a)
Attach as slave to a fifo segment.
Definition: fifo_segment.c:235
int fifo_segment_prealloc_fifo_chunks(fifo_segment_t *fs, u32 slice_index, u32 chunk_size, u32 batch_size)
Try to preallocate fifo chunks on segment.
fifo_segment_mem_status_t fifo_segment_determine_status(fifo_segment_header_t *fsh, u8 usage)
static void usage(void)
Definition: health_check.c:14
u32 fifo_segment_num_fifos(fifo_segment_t *fs)
Get number of active fifos.
unsigned char u8
Definition: types.h:56
enum fifo_segment_flags_ fifo_segment_flags_t
uword next_baseva
Where to put the next one.
Definition: fifo_segment.h:76
void fifo_segment_update_free_bytes(fifo_segment_t *fs)
Update fifo segment free bytes estimate.
u8 *() format_function_t(u8 *s, va_list *args)
Definition: format.h:48
u8 fsh_has_reached_mem_limit(fifo_segment_header_t *fsh)
Fifo segment has reached mem limit.
u8 fifo_segment_has_fifos(fifo_segment_t *fs)
enum ssvm_segment_type_ ssvm_segment_type_t
int fifo_segment_create(fifo_segment_main_t *sm, fifo_segment_create_args_t *a)
Create a fifo segment and initialize as master.
Definition: fifo_segment.c:201
fifo_segment_flags_
Definition: fifo_segment.h:35
void fifo_segment_delete(fifo_segment_main_t *sm, fifo_segment_t *fs)
Definition: fifo_segment.c:265
unsigned int u32
Definition: types.h:88
uword fifo_segment_free_bytes(fifo_segment_t *fs)
Fifo segment estimate of number of free bytes.
char * segment_name
segment name
Definition: fifo_segment.h:85
u64 size
Definition: vhost_user.h:150
u32 fifo_segment_num_free_fifos(fifo_segment_t *fs)
u32 fifo_segment_index(fifo_segment_main_t *sm, fifo_segment_t *fs)
Definition: fifo_segment.c:273
void fifo_segment_attach_fifo(fifo_segment_t *fs, svm_fifo_t *f, u32 slice_index)
Definition: fifo_segment.c:958
int fifo_segment_init(fifo_segment_t *fs)
Initialize fifo segment shared header.
Definition: fifo_segment.c:143
uword fifo_segment_size(fifo_segment_t *fs)
Fifo segment allocated size.
u32 segment_size
size of the segment
Definition: fifo_segment.h:83
ssvm_private_t ssvm
ssvm segment data
Definition: fifo_segment.h:68
svmdb_client_t * c
format_function_t format_fifo_segment_type
Definition: fifo_segment.h:282
int fifo_segment_prealloc_fifo_hdrs(fifo_segment_t *fs, u32 slice_index, u32 batch_size)
Try to preallocate fifo headers.
Definition: fifo_segment.c:981
fifo_segment_mem_status_t fifo_segment_get_mem_status(fifo_segment_t *fs)
int memfd_fd
fd for memfd segments
Definition: fifo_segment.h:84
u8 n_slices
number of fifo segment slices
Definition: fifo_segment.h:70
manual_print typedef address
Definition: ip_types.api:85
uword fifo_segment_available_bytes(fifo_segment_t *fs)
fifo_segment_t * fifo_segment_get_segment(fifo_segment_main_t *sm, u32 fs_index)
Definition: fifo_segment.c:279
fifo_segment_t * segments
pool of fifo segments
Definition: fifo_segment.h:75
fifo_segment_ftype_t
Definition: fifo_segment.h:22
void fifo_segment_detach_fifo(fifo_segment_t *fs, svm_fifo_t *f)
Definition: fifo_segment.c:935
svm_fifo_chunk_t * fsh_alloc_chunk(fifo_segment_header_t *fsh, u32 slice_index, u32 chunk_size)
Allocate chunks in fifo segment.
Definition: fifo_segment.c:695
ssvm_segment_type_t segment_type
type of segment requested
Definition: fifo_segment.h:82
void fifo_segment_info(fifo_segment_t *seg, char **address, size_t *size)
Definition: fifo_segment.c:285
u64 uword
Definition: types.h:112
void fifo_segment_main_init(fifo_segment_main_t *sm, u64 baseva, u32 timeout_in_seconds)
Definition: fifo_segment.c:292
uword fifo_segment_fl_chunk_bytes(fifo_segment_t *fs)
Number of bytes on chunk free lists.
u32 fifo_segment_num_free_chunks(fifo_segment_t *fs, u32 size)
Find number of free chunks of given size.
svm_fifo_t * fifo_segment_get_slice_fifo_list(fifo_segment_t *fs, u32 slice_index)
void fsh_collect_chunks(fifo_segment_header_t *fsh, u32 slice_index, svm_fifo_chunk_t *c)
Return chunks to fifo segment.
Definition: fifo_segment.c:804
void fsh_reset_mem_limit(fifo_segment_header_t *fsh)
Fifo segment reset mem limit flag.
uword fifo_segment_cached_bytes(fifo_segment_t *fs)
Fifo segment number of cached bytes.
svm_fifo_t * fifo_segment_alloc_fifo_w_slice(fifo_segment_t *fs, u32 slice_index, u32 data_bytes, fifo_segment_ftype_t ftype)
Allocate fifo in fifo segment.
Definition: fifo_segment.c:841
u8 fifo_segment_get_mem_usage(fifo_segment_t *fs)
u32 timeout_in_seconds
Time to wait during attach.
Definition: fifo_segment.h:77
void fifo_segment_free_fifo(fifo_segment_t *fs, svm_fifo_t *f)
Free fifo allocated in fifo segment.
Definition: fifo_segment.c:889
format_function_t format_fifo_segment
Definition: fifo_segment.h:281
struct _svm_fifo svm_fifo_t
u32 * new_segment_indices
return vec of new seg indices
Definition: fifo_segment.h:86
void fifo_segment_preallocate_fifo_pairs(fifo_segment_t *fs, u32 rx_fifo_size, u32 tx_fifo_size, u32 *n_fifo_pairs)
Pre-allocates fifo pairs in fifo segment.