ligang/vpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

session svm: tracking segment memory usage

Browse Source 
1. segment manager would attempt to balance the usages across
   the segments, when it allocate fifos
2. the memory presure level is determined per fifo-segment
3. updated unit test
4. updated cli output for segments

Type: feature

Signed-off-by: Ryujiro Shibuya <ryujiro.shibuya@owmobility.com>
Change-Id: I2923f3e0a43dd919196a0cb2cd55e098fde6cf66
This commit is contained in:
Ryujiro Shibuya
2019-12-25 07:40:54 +00:00
committed by Dave Barach
parent f22f4e562e
commit 234fe894d8
9 changed files with 1056 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/plugins/unittest/CMakeLists.txt
View File

@ -36,6 +36,7 @@ add_vpp_plugin(unittest
sparse_vec_test.c
string_test.c
svm_fifo_test.c
segment_manager_test.c
tcp_test.c
test_buffer.c
unittest.c

757
src/plugins/unittest/segment_manager_test.c Normal file
View File

File diff suppressed because it is too large Load Diff

154
src/svm/fifo_segment.c
View File

@ -15,6 +15,12 @@
#include <svm/fifo_segment.h>
static char *fifo_segment_mem_status_strings[] = {
#define _(sym,str) str,
foreach_segment_mem_status
#undef _
};
/**
* Fifo segment free space
*
@ -53,6 +59,26 @@ fsh_update_free_bytes (fifo_segment_header_t * fsh)
clib_atomic_store_rel_n (&fsh->n_free_bytes, fsh_free_space (fsh));
}
static inline void
fsh_cached_bytes_add (fifo_segment_header_t * fsh, int size)
{
clib_atomic_fetch_add_rel (&fsh->n_cached_bytes, size);
}
static inline void
fsh_cached_bytes_sub (fifo_segment_header_t * fsh, int size)
{
clib_atomic_fetch_sub_rel (&fsh->n_cached_bytes, size);
}
static inline uword
fsh_n_cached_bytes (fifo_segment_header_t * fsh)
{
uword n_cached = clib_atomic_load_relax_n (&fsh->n_cached_bytes);
ASSERT (n_cached >= 0);
return n_cached;
}
static void
fsh_check_mem (fifo_segment_header_t * fsh)
{
@ -133,6 +159,7 @@ fifo_segment_init (fifo_segment_t * fs)
ssvm_pop_heap (oldheap);
fsh->n_free_bytes = fsh_free_space (fsh);
fsh->n_cached_bytes = 0;
max_chunks = fsh->n_free_bytes / FIFO_SEGMENT_MIN_FIFO_SIZE;
fsh->n_reserved_bytes = (max_chunks / 4) * sizeof (rb_node_t);
sh->ready = 1;
@ -349,6 +376,7 @@ fs_try_alloc_fifo_freelist_multi_chunk (fifo_segment_header_t * fsh,
c->next = fss->free_chunks[fl_index];
fss->free_chunks[fl_index] = c;
fss->n_fl_chunk_bytes += fl_size;
n_alloc -= fl_size;
data_bytes += fl_size;
}
first = last = 0;
@ -372,6 +400,7 @@ fs_try_alloc_fifo_freelist_multi_chunk (fifo_segment_header_t * fsh,
f->start_chunk = first;
f->end_chunk = last;
fss->n_fl_chunk_bytes -= n_alloc;
fsh_cached_bytes_sub (fsh, n_alloc);
return f;
}
@ -420,6 +449,7 @@ fs_try_alloc_fifo_batch (fifo_segment_header_t * fsh,
}
fss->n_fl_chunk_bytes += batch_size * rounded_data_size;
fsh_cached_bytes_add (fsh, batch_size * rounded_data_size);
fsh_free_bytes_sub (fsh, size);
return 0;
@ -450,7 +480,10 @@ fs_try_alloc_fifo (fifo_segment_header_t * fsh, fifo_segment_slice_t * fss,
{
f = fs_try_alloc_fifo_freelist (fss, fl_index, data_bytes);
if (f)
goto done;
{
fsh_cached_bytes_sub (fsh, fs_freelist_index_to_size (fl_index));
goto done;
}
}
fsh_check_mem (fsh);
@ -462,6 +495,8 @@ fs_try_alloc_fifo (fifo_segment_header_t * fsh, fifo_segment_slice_t * fss,
goto done;
f = fs_try_alloc_fifo_freelist (fss, fl_index, data_bytes);
if (f)
fsh_cached_bytes_sub (fsh, fs_freelist_index_to_size (fl_index));
goto done;
}
if (fifo_sz <= n_free_bytes)
@ -520,6 +555,7 @@ fsh_alloc_chunk (fifo_segment_header_t * fsh, u32 slice_index, u32 chunk_size)
fss->free_chunks[fl_index] = c->next;
c->next = 0;
fss->n_fl_chunk_bytes -= fs_freelist_index_to_size (fl_index);
fsh_cached_bytes_sub (fsh, fs_freelist_index_to_size (fl_index));
}
done:
@ -530,10 +566,12 @@ done:
}
static void
fsh_slice_collect_chunks (fifo_segment_slice_t * fss, svm_fifo_chunk_t * cur)
fsh_slice_collect_chunks (fifo_segment_header_t * fsh,
fifo_segment_slice_t * fss, svm_fifo_chunk_t * cur)
{
svm_fifo_chunk_t *next;
int fl_index;
u32 n_collect = 0;
clib_spinlock_lock (&fss->chunk_lock);
@ -545,10 +583,13 @@ fsh_slice_collect_chunks (fifo_segment_slice_t * fss, svm_fifo_chunk_t * cur)
cur->enq_rb_index = RBTREE_TNIL_INDEX;
cur->deq_rb_index = RBTREE_TNIL_INDEX;
fss->free_chunks[fl_index] = cur;
fss->n_fl_chunk_bytes += fs_freelist_index_to_size (fl_index);
n_collect += fs_freelist_index_to_size (fl_index);
cur = next;
}
fss->n_fl_chunk_bytes += n_collect;
fsh_cached_bytes_add (fsh, n_collect);
clib_spinlock_unlock (&fss->chunk_lock);
}
@ -558,7 +599,7 @@ fsh_collect_chunks (fifo_segment_header_t * fsh, u32 slice_index,
{
fifo_segment_slice_t *fss;
fss = fsh_slice_get (fsh, slice_index);
fsh_slice_collect_chunks (fss, cur);
fsh_slice_collect_chunks (fsh, fss, cur);
}
/**
@ -644,7 +685,7 @@ fifo_segment_free_fifo (fifo_segment_t * fs, svm_fifo_t * f)
fss->free_fifos = f;
/* Free fifo chunks */
fsh_slice_collect_chunks (fss, f->start_chunk);
fsh_slice_collect_chunks (fsh, fss, f->start_chunk);
f->start_chunk = f->end_chunk = 0;
f->head_chunk = f->tail_chunk = f->ooo_enq = f->ooo_deq = 0;
@ -746,6 +787,7 @@ fifo_segment_prealloc_fifo_chunks (fifo_segment_t * fs, u32 slice_index,
c->next = fss->free_chunks[fl_index];
fss->free_chunks[fl_index] = c;
cmem += sizeof (*c) + rounded_data_size;
fsh_cached_bytes_add (fsh, rounded_data_size);
}
fss->n_fl_chunk_bytes += batch_size * rounded_data_size;
@ -925,12 +967,36 @@ fifo_segment_update_free_bytes (fifo_segment_t * fs)
fsh_update_free_bytes (fs->h);
}
uword
fifo_segment_size (fifo_segment_t * fs)
{
return fs->ssvm.ssvm_size;
}
u8
fsh_has_reached_mem_limit (fifo_segment_header_t * fsh)
{
return (fsh->flags & FIFO_SEGMENT_F_MEM_LIMIT) ? 1 : 0;
}
void
fsh_reset_mem_limit (fifo_segment_header_t * fsh)
{
fsh->flags &= ~FIFO_SEGMENT_F_MEM_LIMIT;
}
uword
fifo_segment_free_bytes (fifo_segment_t * fs)
{
return fsh_n_free_bytes (fs->h);
}
uword
fifo_segment_cached_bytes (fifo_segment_t * fs)
{
return fsh_n_cached_bytes (fs->h);
}
uword
fifo_segment_fl_chunk_bytes (fifo_segment_t * fs)
{
@ -974,6 +1040,52 @@ fifo_segment_get_slice_fifo_list (fifo_segment_t * fs, u32 slice_index)
return fss->fifos;
}
u8
fifo_segment_get_mem_usage (fifo_segment_t * fs)
{
uword size, in_use;
size = fifo_segment_size (fs);
in_use =
size - fifo_segment_free_bytes (fs) - fifo_segment_cached_bytes (fs);
return (in_use * 100) / size;
}
fifo_segment_mem_status_t
fifo_segment_determine_status (fifo_segment_header_t * fsh, u8 usage)
{
if (!fsh->high_watermark || !fsh->low_watermark)
return MEMORY_PRESSURE_NO_PRESSURE;
/* once the no-memory is detected, the status continues
* until memory usage gets below the high watermark
*/
if (fsh_has_reached_mem_limit (fsh))
{
if (usage >= fsh->high_watermark)
return MEMORY_PRESSURE_NO_MEMORY;
else
fsh_reset_mem_limit (fsh);
}
if (usage >= fsh->high_watermark)
return MEMORY_PRESSURE_HIGH_PRESSURE;
else if (usage >= fsh->low_watermark)
return MEMORY_PRESSURE_LOW_PRESSURE;
return MEMORY_PRESSURE_NO_PRESSURE;
}
fifo_segment_mem_status_t
fifo_segment_get_mem_status (fifo_segment_t * fs)
{
fifo_segment_header_t *fsh = fs->h;
u8 usage = fifo_segment_get_mem_usage (fs);
return fifo_segment_determine_status (fsh, usage);
}
u8 *
format_fifo_segment_type (u8 * s, va_list * args)
{
@ -1003,6 +1115,7 @@ format_fifo_segment (u8 * s, va_list * args)
int verbose __attribute__ ((unused)) = va_arg (*args, int);
uword est_chunk_bytes, est_free_seg_bytes, free_chunks;
uword chunk_bytes = 0, free_seg_bytes, chunk_size;
uword tracked_cached_bytes;
fifo_segment_header_t *fsh;
fifo_segment_slice_t *fss;
svm_fifo_chunk_t *c;
@ -1010,6 +1123,9 @@ format_fifo_segment (u8 * s, va_list * args)
char *address;
size_t size;
int i;
uword allocated, in_use;
f64 usage;
fifo_segment_mem_status_t mem_st;
indent = format_get_indent (s) + 2;
@ -1068,19 +1184,31 @@ format_fifo_segment (u8 * s, va_list * args)
est_free_seg_bytes = fifo_segment_free_bytes (fs);
fifo_segment_update_free_bytes (fs);
free_seg_bytes = fifo_segment_free_bytes (fs);
tracked_cached_bytes = fifo_segment_cached_bytes (fs);
allocated = fifo_segment_size (fs);
in_use = fifo_segment_size (fs) - est_free_seg_bytes - tracked_cached_bytes;
usage = (100.0 * in_use) / allocated;
mem_st = fifo_segment_get_mem_status (fs);
s = format (s, "\n%Useg free bytes: %U (%lu) estimated: %U (%lu)\n",
format_white_space, indent + 2, format_memory_size,
free_seg_bytes, free_seg_bytes, format_memory_size,
est_free_seg_bytes, est_free_seg_bytes);
s = format (s, "%Uchunk free bytes: %U (%lu) estimated: %U (%lu)\n",
format_white_space, indent + 2, format_memory_size, chunk_bytes,
chunk_bytes, format_memory_size, est_chunk_bytes,
est_chunk_bytes);
s = format (s, "%Ufifo hdr free bytes: %U (%u) reserved %U (%lu)\n",
format_white_space, indent + 2, format_memory_size, fifo_hdr,
fifo_hdr, format_memory_size, fsh->n_reserved_bytes,
fsh->n_reserved_bytes);
s =
format (s,
"%Uchunk free bytes: %U (%lu) estimated: %U (%lu) tracked: %U (%lu)\n",
format_white_space, indent + 2, format_memory_size, chunk_bytes,
chunk_bytes, format_memory_size, est_chunk_bytes, est_chunk_bytes,
format_memory_size, tracked_cached_bytes, tracked_cached_bytes);
s =
format (s, "%Ufifo hdr free bytes: %U (%u) reserved %U (%lu)\n",
format_white_space, indent + 2, format_memory_size, fifo_hdr,
fifo_hdr, format_memory_size, fsh->n_reserved_bytes,
fsh->n_reserved_bytes);
s =
format (s, "%Usegment usage: %.2f%% (%U / %U) %s\n", format_white_space,
indent + 2, usage, format_memory_size, in_use, format_memory_size,
allocated, fifo_segment_mem_status_strings[mem_st]);
s = format (s, "\n");
return s;

64
src/svm/fifo_segment.h
View File

@ -39,6 +39,30 @@ typedef enum fifo_segment_flags_
FIFO_SEGMENT_F_MEM_LIMIT = 1 << 2,
} fifo_segment_flags_t;
#define foreach_segment_mem_status \
_(NO_PRESSURE, "No pressure") \
_(LOW_PRESSURE, "Low pressure") \
_(HIGH_PRESSURE, "High pressure") \
_(NO_MEMORY, "No memory")
typedef enum
{
#define _(sym,str) MEMORY_PRESSURE_##sym,
foreach_segment_mem_status
#undef _
MEMORY_N_PRESSURE,
} fifo_segment_mem_status_t;
#if 0
typedef enum fifo_segment_mem_status_
{
MEMORY_PRESSURE_NO_PRESSURE,
MEMORY_PRESSURE_LOW_PRESSURE,
MEMORY_PRESSURE_HIGH_PRESSURE,
MEMORY_PRESSURE_NO_MEMORY,
} fifo_segment_mem_status_t;
#endif
typedef struct
{
ssvm_private_t ssvm; /**< ssvm segment data */
@ -146,6 +170,31 @@ svm_fifo_chunk_t *fsh_alloc_chunk (fifo_segment_header_t * fsh,
void fsh_collect_chunks (fifo_segment_header_t * fsh, u32 slice_index,
svm_fifo_chunk_t * cur);
/**
* Fifo segment has reached mem limit
*
* @param fsh fifo segment header
* @return 1 (if reached) or 0 (otherwise)
*/
u8 fsh_has_reached_mem_limit (fifo_segment_header_t * fsh);
/**
* Fifo segment reset mem limit flag
*
* @param fs fifo segment
*/
void fsh_reset_mem_limit (fifo_segment_header_t * fsh);
/**
* Fifo segment allocated size
*
* Returns fifo segment's allocated size
*
* @param fs fifo segment
* @return allocated size in bytes
*/
uword fifo_segment_size (fifo_segment_t * fs);
/**
* Fifo segment estimate of number of free bytes
*
@ -168,6 +217,16 @@ uword fifo_segment_free_bytes (fifo_segment_t * fs);
*/
void fifo_segment_update_free_bytes (fifo_segment_t * fs);
/**
* Fifo segment number of cached bytes
*
* Returns fifo segment's number of cached bytes.
*
* @param fs fifo segment
* @return cached bytes
*/
uword fifo_segment_cached_bytes (fifo_segment_t * fs);
/**
* Number of bytes on chunk free lists
*
@ -189,6 +248,11 @@ u32 fifo_segment_num_free_fifos (fifo_segment_t * fs);
*/
u32 fifo_segment_num_free_chunks (fifo_segment_t * fs, u32 size);
u8 fifo_segment_get_mem_usage (fifo_segment_t * fs);
fifo_segment_mem_status_t fifo_segment_determine_status
(fifo_segment_header_t * fsh, u8 usage);
fifo_segment_mem_status_t fifo_segment_get_mem_status (fifo_segment_t * fs);
void fifo_segment_main_init (fifo_segment_main_t * sm, u64 baseva,
u32 timeout_in_seconds);

3
src/svm/fifo_types.h
View File

@ -112,11 +112,14 @@ struct fifo_segment_header_
fifo_segment_slice_t *slices; /** Fixed array of slices */
ssvm_shared_header_t *ssvm_sh; /**< Pointer to fs ssvm shared hdr */
uword n_free_bytes; /**< Segment free bytes */
uword n_cached_bytes; /**< Cached bytes */
u32 n_active_fifos; /**< Number of active fifos */
u32 n_reserved_bytes; /**< Bytes not to be allocated */
u32 max_log2_chunk_size; /**< Max log2(chunk size) for fs */
u8 flags; /**< Segment flags */
u8 n_slices; /**< Number of slices */
u8 high_watermark; /**< Memory pressure watermark high */
u8 low_watermark; /**< Memory pressure watermark low */
};
#endif /* SRC_SVM_FIFO_TYPES_H_ */

7
src/vnet/session/application.c
View File

@ -550,6 +550,10 @@ application_alloc_and_init (app_init_args_t * a)
props->use_mq_eventfd = 1;
if (options[APP_OPTIONS_TLS_ENGINE])
app->tls_engine = options[APP_OPTIONS_TLS_ENGINE];
if (options[APP_OPTIONS_HIGH_WATERMARK])
props->high_watermark = options[APP_OPTIONS_HIGH_WATERMARK];
if (options[APP_OPTIONS_LOW_WATERMARK])
props->low_watermark = options[APP_OPTIONS_LOW_WATERMARK];
props->segment_type = seg_type;
/* Add app to lookup by api_client_index table */
@ -698,8 +702,7 @@ application_alloc_worker_and_init (application_t * app, app_worker_t ** wrk)
sm = segment_manager_alloc ();
sm->app_wrk_index = app_wrk->wrk_index;
if ((rv = segment_manager_init (sm, app->sm_properties.segment_size,
app->sm_properties.prealloc_fifos)))
if ((rv = segment_manager_init (sm)))
{
app_worker_free (app_wrk);
return rv;

2
src/vnet/session/application_interface.h
View File

@ -201,6 +201,8 @@ typedef enum
APP_OPTIONS_PROXY_TRANSPORT,
APP_OPTIONS_ACCEPT_COOKIE,
APP_OPTIONS_TLS_ENGINE,
APP_OPTIONS_HIGH_WATERMARK,
APP_OPTIONS_LOW_WATERMARK,
APP_OPTIONS_N_OPTIONS
} app_attach_options_index_t;

89
src/vnet/session/segment_manager.c
View File

@ -29,6 +29,8 @@ typedef struct segment_manager_main_
u32 default_fifo_size; /**< default rx/tx fifo size */
u32 default_segment_size; /**< default fifo segment size */
u32 default_app_mq_size; /**< default app msg q size */
u8 default_high_watermark; /**< default high watermark % */
u8 default_low_watermark; /**< default low watermark % */
} segment_manager_main_t;
static segment_manager_main_t sm_main;
@ -54,6 +56,8 @@ segment_manager_props_init (segment_manager_props_t * props)
props->rx_fifo_size = sm_main.default_fifo_size;
props->tx_fifo_size = sm_main.default_fifo_size;
props->evt_q_size = sm_main.default_app_mq_size;
props->high_watermark = sm_main.default_high_watermark;
props->low_watermark = sm_main.default_low_watermark;
props->n_slices = vlib_num_workers () + 1;
return props;
}
@ -160,6 +164,13 @@ segment_manager_add_segment (segment_manager_t * sm, uword segment_size)
*/
fs_index = fs - sm->segments;
/*
* Set watermarks in segment
*/
fs->h->high_watermark = sm->high_watermark;
fs->h->low_watermark = sm->low_watermark;
fs->h->flags &= ~FIFO_SEGMENT_F_MEM_LIMIT;
done:
if (vlib_num_workers ())
@ -307,11 +318,12 @@ segment_manager_alloc (void)
* Returns error if ssvm segment(s) allocation fails.
*/
int
segment_manager_init (segment_manager_t * sm, uword first_seg_size,
u32 prealloc_fifo_pairs)
segment_manager_init (segment_manager_t * sm)
{
u32 rx_fifo_size, tx_fifo_size, pair_size;
u32 rx_rounded_data_size, tx_rounded_data_size;
uword first_seg_size;
u32 prealloc_fifo_pairs;
u64 approx_total_size, max_seg_size = ((u64) 1 << 32) - (128 << 10);
segment_manager_props_t *props;
fifo_segment_t *segment;
@ -319,7 +331,13 @@ segment_manager_init (segment_manager_t * sm, uword first_seg_size,
int seg_index, i;
props = segment_manager_properties_get (sm);
first_seg_size = clib_max (first_seg_size, sm_main.default_segment_size);
first_seg_size = clib_max (props->segment_size,
sm_main.default_segment_size);
prealloc_fifo_pairs = props->prealloc_fifos;
segment_manager_set_watermarks (sm,
props->high_watermark,
props->low_watermark);
if (prealloc_fifo_pairs)
{
@ -434,6 +452,27 @@ segment_manager_get_if_valid (u32 index)
return pool_elt_at_index (sm_main.segment_managers, index);
}
static fifo_segment_t *
find_max_free_segment (segment_manager_t * sm, u32 thread_index)
{
fifo_segment_t *cur, *fs = 0;
uword free_bytes, max_free_bytes = 0;
clib_rwlock_reader_lock (&sm->segments_rwlock);
/* *INDENT-OFF* */
pool_foreach (cur, sm->segments, ({
if ((free_bytes = fifo_segment_free_bytes (cur)) > max_free_bytes)
{
max_free_bytes = free_bytes;
fs = cur;
}
}));
/* *INDENT-ON* */
clib_rwlock_reader_unlock (&sm->segments_rwlock);
return fs;
}
u32
segment_manager_index (segment_manager_t * sm)
{
@ -569,19 +608,25 @@ segment_manager_alloc_session_fifos (segment_manager_t * sm,
/*
* Find the first free segment to allocate the fifos in
*/
fs = find_max_free_segment (sm, thread_index);
/* *INDENT-OFF* */
segment_manager_foreach_segment_w_lock (fs, sm, ({
alloc_fail = segment_manager_try_alloc_fifos (fs,
thread_index,
props->rx_fifo_size,
props->tx_fifo_size,
rx_fifo, tx_fifo);
/* Exit with lock held, drop it after notifying app */
if (!alloc_fail)
goto alloc_success;
}));
/* *INDENT-ON* */
if (fs)
{
clib_rwlock_reader_lock (&sm->segments_rwlock);
alloc_fail = segment_manager_try_alloc_fifos (fs, thread_index,
props->rx_fifo_size,
props->tx_fifo_size,
rx_fifo, tx_fifo);
/* On success, keep lock until fifos are initialized */
if (!alloc_fail)
goto alloc_success;
segment_manager_segment_reader_unlock (sm);
}
else
{
alloc_fail = 1;
}
alloc_check:
@ -787,6 +832,8 @@ segment_manager_main_init (segment_manager_main_init_args_t * a)
sm->default_fifo_size = 1 << 12;
sm->default_segment_size = 1 << 20;
sm->default_app_mq_size = 128;
sm->default_high_watermark = 80;
sm->default_low_watermark = 50;
}
static clib_error_t *
@ -910,6 +957,18 @@ segment_manager_format_sessions (segment_manager_t * sm, int verbose)
clib_rwlock_reader_unlock (&sm->segments_rwlock);
}
void
segment_manager_set_watermarks (segment_manager_t * sm,
u8 high_watermark, u8 low_watermark)
{
ASSERT (high_watermark >= 0 && high_watermark <= 100 &&
low_watermark >= 0 && low_watermark <= 100 &&
low_watermark <= high_watermark);
sm->high_watermark = high_watermark;
sm->low_watermark = low_watermark;
}
/*
* fd.io coding-style-patch-verification: ON
*

11
src/vnet/session/segment_manager.h
View File

@ -34,6 +34,8 @@ typedef struct _segment_manager_props
u8 n_slices; /**< number of fs slices/threads */
ssvm_segment_type_t segment_type; /**< seg type: if set to SSVM_N_TYPES,
private segments are used */
u8 high_watermark; /**< memory usage high watermark % */
u8 low_watermark; /**< memory usage low watermark % */
} segment_manager_props_t;
typedef struct _segment_manager
@ -58,6 +60,9 @@ typedef struct _segment_manager
* App event queue allocated in first segment
*/
svm_msg_q_t *event_queue;
u8 high_watermark;
u8 low_watermark;
} segment_manager_t;
typedef struct segment_manager_main_init_args_
@ -69,8 +74,7 @@ typedef struct segment_manager_main_init_args_
#define SEGMENT_MANAGER_INVALID_APP_INDEX ((u32) ~0)
segment_manager_t *segment_manager_alloc (void);
int segment_manager_init (segment_manager_t * sm, uword first_seg_size,
u32 prealloc_fifo_pairs);
int segment_manager_init (segment_manager_t * sm);
/**
* Cleanup segment manager
@ -118,6 +122,9 @@ int segment_manager_try_alloc_fifos (fifo_segment_t * fs,
void segment_manager_dealloc_fifos (svm_fifo_t * rx_fifo,
svm_fifo_t * tx_fifo);
void segment_manager_set_watermarks (segment_manager_t * sm,
u8 high_watermark, u8 low_watermark);
u8 segment_manager_has_fifos (segment_manager_t * sm);
svm_msg_q_t *segment_manager_alloc_queue (fifo_segment_t * fs,