session: update fifo slice on session migration

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

diff --git a/src/svm/fifo_segment.h b/src/svm/fifo_segment.h
index 8554806..ee5c24d 100644 (file)
--- a/src/svm/fifo_segment.h
+++ b/src/svm/fifo_segment.h
@@ -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 */
@@ -96,6 +120,10 @@ svm_fifo_t *fifo_segment_alloc_fifo_w_slice (fifo_segment_t * fs,
  */
 void fifo_segment_free_fifo (fifo_segment_t * fs, svm_fifo_t * f);
 
+void fifo_segment_detach_fifo (fifo_segment_t * fs, svm_fifo_t * f);
+void fifo_segment_attach_fifo (fifo_segment_t * fs, svm_fifo_t * f,
+                              u32 slice_index);
+
 /**
  * Try to preallocate fifo headers
  *
@@ -140,11 +168,52 @@ void fifo_segment_preallocate_fifo_pairs (fifo_segment_t * fs,
                                          u32 tx_fifo_size,
                                          u32 * n_fifo_pairs);
 
+/**
+ * Allocate chunks in fifo segment
+ *
+ * @param fsh          fifo segment header
+ * @param slice_index  slice where chunks should be alocated
+ * @param chunk_size   chunk size needed
+ * @return             chunk (or chunks) that cover at least chunk_size bytes
+ *                     on success, 0 on failure.
+ */
 svm_fifo_chunk_t *fsh_alloc_chunk (fifo_segment_header_t * fsh,
                                   u32 slice_index, u32 chunk_size);
 
+/**
+ * Return chunks to fifo segment
+ *
+ * @param fsh          fifo segment header
+ * @param slice_index  slice where chunks should be returned
+ * @param c            pointer to first chunk in 0 terminated linked list
+ */
 void fsh_collect_chunks (fifo_segment_header_t * fsh, u32 slice_index,
-                        svm_fifo_chunk_t * cur);
+                        svm_fifo_chunk_t * c);
+
+/**
+ * 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 +237,18 @@ 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);
+
+uword fifo_segment_available_bytes (fifo_segment_t * fs);
+
 /**
  * Number of bytes on chunk free lists
  *
@@ -189,6 +270,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);