#define included_vlib_node_funcs_h
#include <vppinfra/fifo.h>
+#include <vppinfra/tw_timer_1t_3w_1024sl_ov.h>
/** \brief Get vlib node by index.
@warning This function will ASSERT if @c i is out of range.
STRUCT_OFFSET_OF (vlib_node_runtime_t, runtime_data));
if (vec_len (n->runtime_data) > 0)
- clib_memcpy (r->runtime_data, n->runtime_data, vec_len (n->runtime_data));
+ clib_memcpy_fast (r->runtime_data, n->runtime_data,
+ vec_len (n->runtime_data));
}
/** \brief Set node dispatch state.
return vec_elt (nm->processes, node->runtime_index);
}
-/* Fetches frame with given handle. */
always_inline vlib_frame_t *
-vlib_get_frame_no_check (vlib_main_t * vm, uword frame_index)
+vlib_get_frame (vlib_main_t * vm, vlib_frame_t * f)
{
- vlib_frame_t *f;
- u32 thread_index = frame_index & VLIB_CPU_MASK;
- u32 offset = frame_index & VLIB_OFFSET_MASK;
- vm = vlib_mains[thread_index];
- f = vm->heap_base + offset;
+ ASSERT (f != NULL);
+ ASSERT (f->frame_flags & VLIB_FRAME_IS_ALLOCATED);
return f;
}
-always_inline u32
-vlib_frame_index_no_check (vlib_main_t * vm, vlib_frame_t * f)
-{
- u32 i;
-
- ASSERT (((uword) f & VLIB_CPU_MASK) == 0);
-
- vm = vlib_mains[f->thread_index];
-
- i = ((u8 *) f - (u8 *) vm->heap_base);
- return i | f->thread_index;
-}
-
-always_inline vlib_frame_t *
-vlib_get_frame (vlib_main_t * vm, uword frame_index)
-{
- vlib_frame_t *f = vlib_get_frame_no_check (vm, frame_index);
- ASSERT (f->flags & VLIB_FRAME_IS_ALLOCATED);
- return f;
-}
-
-always_inline u32
-vlib_frame_index (vlib_main_t * vm, vlib_frame_t * f)
+always_inline void
+vlib_frame_no_append (vlib_frame_t * f)
{
- uword i = vlib_frame_index_no_check (vm, f);
- ASSERT (vlib_get_frame (vm, i) == f);
- return i;
+ f->frame_flags |= VLIB_FRAME_NO_APPEND;
}
/* Byte alignment for vector arguments. */
/** \brief Get pointer to frame scalar data.
- @warning This is almost certainly not the function you wish to call.
- See @ref vlib_frame_vector_args instead.
-
@param f vlib_frame_t pointer
@return arbitrary node scalar data
@sa vlib_frame_vector_args
*/
always_inline void *
-vlib_frame_args (vlib_frame_t * f)
+vlib_frame_scalar_args (vlib_frame_t * f)
{
return vlib_frame_vector_args (f) - f->scalar_size;
}
void vlib_put_frame_to_node (vlib_main_t * vm, u32 to_node_index,
vlib_frame_t * f);
-always_inline vlib_process_t *
-vlib_get_current_process (vlib_main_t * vm)
-{
- vlib_node_main_t *nm = &vm->node_main;
- return vec_elt (nm->processes, nm->current_process_index);
-}
-
always_inline uword
vlib_in_process_context (vlib_main_t * vm)
{
return vm->node_main.current_process_index != ~0;
}
+always_inline vlib_process_t *
+vlib_get_current_process (vlib_main_t * vm)
+{
+ vlib_node_main_t *nm = &vm->node_main;
+ if (vlib_in_process_context (vm))
+ return vec_elt (nm->processes, nm->current_process_index);
+ return 0;
+}
+
always_inline uword
vlib_current_process (vlib_main_t * vm)
{
return vlib_get_current_process (vm)->node_runtime.node_index;
}
-/** Returns TRUE if a process suspend time is less than 1us
+/** Returns TRUE if a process suspend time is less than 10us
@param dt - remaining poll time in seconds
- @returns 1 if dt < 1e-6, 0 otherwise
+ @returns 1 if dt < 10e-6, 0 otherwise
*/
always_inline uword
vlib_process_suspend_time_is_zero (f64 dt)
{
- return dt < 1e-6;
+ return dt < 10e-6;
}
/** Suspend a vlib cooperative multi-tasking thread for a period of time
uword r;
vlib_node_main_t *nm = &vm->node_main;
vlib_process_t *p = vec_elt (nm->processes, nm->current_process_index);
- u64 dt_cpu = dt * vm->clib_time.clocks_per_second;
if (vlib_process_suspend_time_is_zero (dt))
return VLIB_PROCESS_RESUME_LONGJMP_RESUME;
r = clib_setjmp (&p->resume_longjmp, VLIB_PROCESS_RESUME_LONGJMP_SUSPEND);
if (r == VLIB_PROCESS_RESUME_LONGJMP_SUSPEND)
{
- p->resume_cpu_time = clib_cpu_time_now () + dt_cpu;
+ /* expiration time in 10us ticks */
+ p->resume_clock_interval = dt * 1e5;
clib_longjmp (&p->return_longjmp, VLIB_PROCESS_RETURN_LONGJMP_SUSPEND);
}
r = clib_setjmp (&p->resume_longjmp, VLIB_PROCESS_RESUME_LONGJMP_SUSPEND);
if (r == VLIB_PROCESS_RESUME_LONGJMP_SUSPEND)
{
- p->resume_cpu_time = (clib_cpu_time_now ()
- + (dt * vm->clib_time.clocks_per_second));
+ p->resume_clock_interval = dt * 1e5;
clib_longjmp (&p->return_longjmp, VLIB_PROCESS_RETURN_LONGJMP_SUSPEND);
}
uword p_flags, add_to_pending, delete_from_wheel;
void *data_to_be_written_by_caller;
+ ASSERT (n->type == VLIB_NODE_TYPE_PROCESS);
+
ASSERT (!pool_is_free_index (p->event_type_pool, t));
vec_validate (p->pending_event_data_by_type_index, t);
{
/* Waiting for both event and clock? */
if (p_flags & VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT)
- delete_from_wheel = 1;
+ {
+ if (!TW (tw_timer_handle_is_free)
+ ((TWT (tw_timer_wheel) *) nm->timing_wheel,
+ p->stop_timer_handle))
+ delete_from_wheel = 1;
+ else
+ /* timer just popped so process should already be on the list */
+ add_to_pending = 0;
+ }
else
/* Waiting only for clock. Event will be queue and may be
handled when timer expires. */
p->flags = p_flags | VLIB_PROCESS_RESUME_PENDING;
vec_add1 (nm->data_from_advancing_timing_wheel, x);
if (delete_from_wheel)
- timing_wheel_delete (&nm->timing_wheel, x);
+ TW (tw_timer_stop) ((TWT (tw_timer_wheel) *) nm->timing_wheel,
+ p->stop_timer_handle);
}
return data_to_be_written_by_caller;
vlib_process_t *p = vec_elt (nm->processes, n->runtime_index);
uword *h, t;
+ /* Must be in main thread */
+ ASSERT (vlib_get_thread_index () == 0);
+
h = hash_get (p->event_type_index_by_type_opaque, type_opaque);
if (!h)
{
else
{
vlib_signal_timed_event_data_t *te;
- u64 dt_cpu = dt * vm->clib_time.clocks_per_second;
pool_get_aligned (nm->signal_timed_event_data_pool, te, sizeof (te[0]));
te->process_node_index = n->runtime_index;
te->event_type_index = t;
- timing_wheel_insert (&nm->timing_wheel, clib_cpu_time_now () + dt_cpu,
- vlib_timing_wheel_data_set_timed_event (te -
- nm->
- signal_timed_event_data_pool));
+ p->stop_timer_handle =
+ TW (tw_timer_start) ((TWT (tw_timer_wheel) *) nm->timing_wheel,
+ vlib_timing_wheel_data_set_timed_event
+ (te - nm->signal_timed_event_data_pool),
+ 0 /* timer_id */ ,
+ (vlib_time_now (vm) + dt) * 1e5);
/* Inline data big enough to hold event? */
if (te->n_data_bytes < sizeof (te->inline_event_data))
d[0] = data;
}
+/**
+ * Signal event to process from any thread.
+ *
+ * When in doubt, use this.
+ */
+always_inline void
+vlib_process_signal_event_mt (vlib_main_t * vm,
+ uword node_index, uword type_opaque, uword data)
+{
+ if (vlib_get_thread_index () != 0)
+ {
+ vlib_process_signal_event_mt_args_t args = {
+ .node_index = node_index,
+ .type_opaque = type_opaque,
+ .data = data,
+ };
+ vlib_rpc_call_main_thread (vlib_process_signal_event_mt_helper,
+ (u8 *) & args, sizeof (args));
+ }
+ else
+ vlib_process_signal_event (vm, node_index, type_opaque, data);
+}
+
always_inline void
vlib_process_signal_one_time_event (vlib_main_t * vm,
uword node_index,
{
vlib_process_signal_one_time_event (vm, p->node_index, p->one_time_event,
/* data */ ~0);
- memset (p, ~0, sizeof (p[0]));
+ clib_memset (p, ~0, sizeof (p[0]));
}
always_inline void
void
vlib_frame_free (vlib_main_t * vm, vlib_node_runtime_t * r, vlib_frame_t * f);
+/* Return the edge index if present, ~0 otherwise */
+uword vlib_node_get_next (vlib_main_t * vm, uword node, uword next_node);
+
/* Add next node to given node in given slot. */
uword
vlib_node_add_next_with_slot (vlib_main_t * vm,
return vlib_node_add_named_next_with_slot (vm, node, name, ~0);
}
+/**
+ * Get list of nodes
+ */
+void
+vlib_node_get_nodes (vlib_main_t * vm, u32 max_threads, int include_stats,
+ int barrier_sync, vlib_node_t **** node_dupsp,
+ vlib_main_t *** stat_vmsp);
+
/* Query node given name. */
vlib_node_t *vlib_get_node_by_name (vlib_main_t * vm, u8 * name);
em->counters[node_counter_base_index + counter_index] += increment;
}
+/** @brief Create a vlib process
+ * @param vm &vlib_global_main
+ * @param f the process node function
+ * @param log2_n_stack_bytes size of the process stack, defaults to 16K
+ * @return newly-create node index
+ * @warning call only on the main thread. Barrier sync required
+ */
+u32 vlib_process_create (vlib_main_t * vm, char *name,
+ vlib_node_function_t * f, u32 log2_n_stack_bytes);
+
#endif /* included_vlib_node_funcs_h */
/*