EM-ODP  3.7.0
Event Machine on ODP
All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
event_machine_queue.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015-2023, Nokia Solutions and Networks
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  * * Redistributions in binary form must reproduce the above copyright
12  * notice, this list of conditions and the following disclaimer in the
13  * documentation and/or other materials provided with the distribution.
14  * * Neither the name of the copyright holder nor the names of its
15  * contributors may be used to endorse or promote products derived
16  * from this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30 
31 #ifndef EVENT_MACHINE_QUEUE_H_
32 #define EVENT_MACHINE_QUEUE_H_
33 
34 #pragma GCC visibility push(default)
35 
36 /**
37  * @file
38  * @defgroup em_queue Queues
39  * Operations on queues
40  * @{
41  *
42  * Queues are the communication mechanism used by EM. Each queue is associated
43  * with one Execution Object (EO) (or HW functionality), but each EO can have
44  * multiple queues.
45  *
46  * A queue can have one of six (6) different scheduling modes / queue types:
47  *
48  * -# EM_QUEUE_TYPE_ATOMIC
49  * - The atomic queue type limits event scheduling to one event at a time from
50  * the queue. The next event from the same queue can only be scheduled after
51  * the EO returns from processing the earlier event or calls
52  * em_atomic_processing_end() to signal end of atomic processing.
53  * This type is useful to avoid multicore race conditions as only one core
54  * at a time can be working on an event from an atomic queue.
55  * Additionally, the ingress-egress event order is maintained.
56  *
57  * -# EM_QUEUE_TYPE_PARALLEL
58  * - Parallel queues have no restriction for scheduling, which means that any
59  * amount of events (up to the number of cores in the queue group of the
60  * queue) can be processed simultaneously. This provides the best scaling,
61  * but race conditions need to be avoided and handled by the application.
62  *
63  * -# EM_QUEUE_TYPE_PARALLEL_ORDERED
64  * - Parallel-Ordered queues have no scheduling restrictions (scheduled like
65  * parallel queues i.e. multiple events can be under work concurrently),
66  * but events coming from an ordered queue and sent forward will be in
67  * original order (as observed at the target queue) even if cores do the
68  * processing out of order. Events can be sent to multiple target queues of
69  * any queue type and still maintain ordering (the order of events in each
70  * target queue, not between different target queues). Note however that if
71  * the target queue type is not atomic and the EO can run on more than one
72  * thread (set by queue group) then it is possible that the target EO may
73  * process the events out of order as it is not limited by atomic
74  * scheduling. A chain of ordered (or atomic) queues will still maintain
75  * the original order.
76  *
77  * Conceptually an ordering context is created when the scheduler
78  * dequeues an event from an ordered queue and it represents the sequence
79  * number of that event within that queue. The ordering context is valid
80  * within the EO receive function and ends implicitly when the EO returns
81  * (can be terminated early, see em_ordered_processing_end()). Any number of
82  * events can be sent under that context and all those will maintain order
83  * relative to the current event. The first one sent will take the order
84  * position of the current (just received) event. Other events sent during
85  * the same ordered context will take consecutive positions (before the
86  * next event in the original input queue when it gets scheduled and
87  * processed). The original event does not need to be sent forward to
88  * maintain order, any event sent will inherit the location of the current
89  * ordered context.
90  *
91  * If no event is sent during the EO receive function with ordered context
92  * it indicates an implicit skip of that event position in the ordered
93  * sequence.
94  *
95  * Atomic queues also maintain ordering, but an ordered queue can increase
96  * the performance as multiple cores can concurrently process the events.
97  *
98  * -# EM_QUEUE_TYPE_UNSCHEDULED
99  * - Unscheduled queues are not connected to the scheduler but instead the
100  * application needs to dequeue events directly using em_queue_dequeue().
101  * The API function em_send() is used to enqueue events into an unscheduled
102  * queue. All queue types look the same to the sender with the exception
103  * that em_send_group() is not supported for unscheduled queues.
104  * Unscheduled queues cannot be added to an EO.
105  *
106  * -# EM_QUEUE_TYPE_LOCAL
107  * - Local queues are special virtual queues bypassing the scheduler for
108  * fast core-local pipelining without load balancing or atomic processing.
109  * A local queue is connected (added) to an EO in the same way scheduled
110  * queues are. Events sent to a local queue are added to a per core (local)
111  * storage maintained by the EM dispatcher. This core local event storage is
112  * emptied by the dispatcher after the sending EO returns from the receive
113  * function. The local events are now immediately dispatched on the current
114  * core, i.e. handed to the receive function of the EO that owns the
115  * targeted local queue. Only when all local events have been handled is the
116  * scheduler allowed to schedule new events for the core.
117  * Local queues do not have an explicit ordered or atomic processing
118  * context, instead they inherit the context of the EO under which the event
119  * was sent (i.e. ordering could still be maintained with careful design).
120  * The sending EO's processing context is only released after the local
121  * queue is empty, unless the application explicitly ends the context
122  * earlier, thus effectively making local processing similar to handling
123  * the same function within the sending EO's receive.
124  * A local queue is not associated with a queue group and exists on all
125  * cores of the EM instance - the application must be able to handle
126  * events on all cores (unless sending to the local queue is controlled).
127  *
128  * The local queue concept is a performance optimization and a way to
129  * logically split processing into separate EO's but due to the side
130  * effects (may delay context release of the sending EO) and limitations
131  * should not be used without a valid reason. Local queues are mainly
132  * suitable for stateless processing that does not need EM scheduling.
133  *
134  * -# EM_QUEUE_TYPE_OUTPUT
135  * - An output queue is a system specific implementation of a SW-HW interface.
136  * It provides a queue interface for sending events out of EM to a HW
137  * device. It could e.g. be used for packet output or towards HW
138  * accelerators. The application uses em_send() to transmit an event for
139  * output. Typically the needed information to bind a queue to an interface
140  * is provided via the optional conf-argument given during queue creation
141  * (the content of 'conf' is system specific).
142  *
143  * Currently EM does not define the exact queue behavior except that queues
144  * work like FIFOs. This means, e.g. that the maximum length of a queue is
145  * system specific (the conf parameter of queue create can be used to provide
146  * options)
147  *
148  * Special queues towards asynchronous HW functions, e.g. a crypto accelerator,
149  * should look like any regular queue from the sender's point of view, i.e.
150  * em_send() and related functions work.
151  */
152 
153 #ifdef __cplusplus
154 extern "C" {
155 #endif
156 
159 
160 /**
161  * Create a new queue with a dynamic queue handle (i.e. handle given by EM)
162  *
163  * The given name string is copied into an EM internal data structure. The
164  * maximum string length is EM_QUEUE_NAME_LEN.
165  *
166  * Create scheduled atomic, parallel or parallel-ordered queues by using the
167  * types EM_QUEUE_TYPE_ATOMIC, EM_QUEUE_TYPE_PARALLEL or
168  * EM_QUEUE_TYPE_PARALLEL_ORDERED, respectively.
169  *
170  * To create an unscheduled queue, use the type EM_QUEUE_TYPE_UNSCHEDULED.
171  * The prio and queue group are not relevant, but need to be set to
172  * EM_QUEUE_PRIO_UNDEF and EM_QUEUE_GROUP_UNDEF. Unscheduled queues can't be
173  * associated with an EO (em_eo_add_queue() fails).
174  *
175  * To create a local queue, use type EM_QUEUE_TYPE_LOCAL. The queue group is not
176  * relevant and must be set to EM_QUEUE_GROUP_UNDEF. The virtual local queue
177  * is created for all cores in this EM instance. Note also that the
178  * implementation may not implement priorities for local queues.
179  *
180  * To create an output queue, use the type EM_QUEUE_TYPE_OUTPUT.
181  * Pass the needed information to bind a queue with an interface via the
182  * conf-argument (content is system and output-type specific).
183  * The queue group is not relevant and must be set to EM_QUEUE_GROUP_UNDEF.
184  * Note also that the implementation may not implement priorities for output
185  * queues.
186  *
187  * The 'conf' argument is optional and can be used to pass extra attributes
188  * (e.g. require non-blocking behaviour, if supported) to the system specific
189  * implementation.
190  *
191  * @param name Queue name (optional, NULL ok)
192  * @param type Queue type
193  * @param prio Queue priority class
194  * @param group Queue group for this queue
195  * @param conf Optional configuration data, NULL for defaults
196  *
197  * @return New queue handle or EM_QUEUE_UNDEF on an error.
198  *
199  * @see em_queue_group_create(), em_queue_delete(), em_queue_conf_t
200  */
201 em_queue_t
202 em_queue_create(const char *name, em_queue_type_t type, em_queue_prio_t prio,
203  em_queue_group_t group, const em_queue_conf_t *conf);
204 
205 /**
206  * Create a new queue with a static queue handle (i.e. given by the user).
207  *
208  * Note, that the system may have a limited amount of static handles available,
209  * so prefer the use of dynamic queues, unless static handles are really needed.
210  * The range of static identifiers/handles is system dependent, but macros
211  * EM_QUEUE_STATIC_MIN and EM_QUEUE_STATIC_MAX can be used to abstract actual
212  * values, e.g. use EM_QUEUE_STATIC_MIN+x for the application.
213  *
214  * Otherwise like em_queue_create().
215  *
216  * @param name Queue name (optional, NULL ok)
217  * @param type Queue scheduling type
218  * @param prio Queue priority
219  * @param group Queue group for this queue
220  * @param queue Requested queue handle from the static range
221  * @param conf Optional configuration data, NULL for defaults
222  *
223  * @return EM_OK if successful.
224  *
225  * @see em_queue_create()
226  */
228 em_queue_create_static(const char *name, em_queue_type_t type,
229  em_queue_prio_t prio, em_queue_group_t group,
230  em_queue_t queue, const em_queue_conf_t *conf);
231 
232 /**
233  * Delete a queue.
234  *
235  * Unallocates the queue handle. This is an immediate deletion and can only
236  * be done after the queue has been removed from scheduling using
237  * em_eo_remove_queue().
238  *
239  * @param queue Queue handle to delete
240  *
241  * @return EM_OK if successful.
242  *
243  * @see em_eo_remove_queue(), em_queue_create(), em_queue_create_static()
244  */
246 em_queue_delete(em_queue_t queue);
247 
248 /**
249  * Set queue specific (application) context.
250  *
251  * This is a single pointer associated with a queue. The application can use it
252  * to access some context data quickly (without a lookup). The context is given
253  * as an argument to the EO receive function. EM does not dereference it.
254  *
255  * @param queue Queue to which associate the context
256  * @param context Context pointer
257  *
258  * @return EM_OK if successful.
259  *
260  * @see em_receive_func_t(), em_queue_get_context()
261  */
263 em_queue_set_context(em_queue_t queue, const void *context);
264 
265 /**
266  * Get queue specific (application) context.
267  *
268  * Returns the value application has earlier set with em_queue_set_context().
269  *
270  * @param queue Queue for which the context is requested
271  *
272  * @return Queue specific context pointer or NULL on error.
273  *
274  * @see em_queue_set_context()
275  */
276 void *
277 em_queue_get_context(em_queue_t queue);
278 
279 /**
280  * Get the queue name.
281  *
282  * Returns the name given to a queue when it was created.
283  * A copy of the queue name string (up to 'maxlen' characters) is written to the
284  * user given buffer.
285  * The string is always null terminated even if the given buffer length is less
286  * than the name length.
287  *
288  * The function returns '0' and writes an empty string if the queue has no name.
289  *
290  * @param queue Queue handle
291  * @param[out] name Destination buffer
292  * @param maxlen Maximum length (including the terminating '0')
293  *
294  * @return Number of characters written (excludes the terminating '0').
295  *
296  * @see em_queue_create()
297  */
298 size_t
299 em_queue_get_name(em_queue_t queue, char *name, size_t maxlen);
300 
301 /**
302  * Find a queue by name.
303  *
304  * Finds a queue by the given name (exact match). An empty string will not match
305  * anything. The search is case sensitive. The function will return the first
306  * match only if there are duplicate names,
307  * Be aware of that the search may take a long time if there are many queues.
308  *
309  * @param name name to look for
310  *
311  * @return queue handle or EM_QUEUE_UNDEF if not found
312  *
313  * @see em_queue_create()
314  */
315 em_queue_t
316 em_queue_find(const char *name);
317 
318 /**
319  * Get the queue priority.
320  *
321  * @param queue Queue handle
322  *
323  * @return Priority class or EM_QUEUE_PRIO_UNDEF on an error.
324  *
325  * @see em_queue_create()
326  */
328 em_queue_get_priority(em_queue_t queue);
329 
330 /**
331  * Get the queue type.
332  *
333  * @param queue Queue handle
334  *
335  * @return Queue type or EM_QUEUE_TYPE_UNDEF on an error.
336  *
337  * @see em_queue_create()
338  */
340 em_queue_get_type(em_queue_t queue);
341 
342 /**
343  * Get the queue's queue group
344  *
345  * @param queue Queue handle
346  *
347  * @return Queue group or EM_QUEUE_GROUP_UNDEF on error.
348  *
349  * @see em_queue_create(), em_queue_group_create(), em_queue_group_modify()
350  */
351 em_queue_group_t
352 em_queue_get_group(em_queue_t queue);
353 
354 /**
355  * Dequeue an event from an unscheduled queue
356  *
357  * This can only be used with unscheduled queues created with the type
358  * EM_QUEUE_TYPE_UNSCHEDULED. Events are added to these queues with em_send(),
359  * similar to queues of other types, but applications needs to explicitly
360  * dequeue the event(s). Unscheduled queues are general purpose FIFOs, i.e.
361  * send(enqueue) to tail and dequeue from head. The maximum length of an
362  * unscheduled queue is system specific.
363  *
364  * An unscheduled queue can also have a context, but if used it needs to be
365  * asked separately using em_queue_get_context().
366  *
367  * @param queue Unscheduled queue handle
368  *
369  * @return Event from head of queue or EM_EVENT_UNDEF if there was no events
370  * or an error occurred.
371  */
372 em_event_t em_queue_dequeue(em_queue_t queue);
373 
374 /**
375  * Dequeue multiple events from an unscheduled queue
376  *
377  * This can only be used with unscheduled queues created with the type
378  * EM_QUEUE_TYPE_UNSCHEDULED. Events are added to these queues with em_send(),
379  * similar to queues of other types, but applications needs to explicitly
380  * dequeue the event(s). Unscheduled queues are general purpose FIFOs, i.e.
381  * send(enqueue) to tail and dequeue from head. The maximum length of an
382  * unscheduled queue is system specific.
383  *
384  * An unscheduled queue can also have a context, but needs to be
385  * asked separately using em_queue_get_context().
386  *
387  * @param queue Unscheduled queue handle
388  * @param[out] events Array of event handles for output
389  * @param num Maximum number of events to dequeue
390  *
391  * @return Number of successfully dequeued events (0 to num)
392  */
393 int em_queue_dequeue_multi(em_queue_t queue,
394  em_event_t events[/*out*/], int num);
395 
396 /**
397  * Returns the current active queue
398  *
399  * The 'current active queue' is the queue that delivered the input event to
400  * the EO-receive that is currently being run.
401  *
402  * Only valid if called within an EO-receive context, will return EM_QUEUE_UNDEF
403  * otherwise, i.e. can be called from the EO-receive functions or subfunctions
404  * thereof.
405  * Note that calling em_queue_current() from an EO-start/stop function that was
406  * launched from within an EO's receive function will return EM_QUEUE_UNDEF.
407  *
408  * @return The current queue or EM_QUEUE_UNDEF if no current queue (or error)
409  */
410 em_queue_t
411 em_queue_current(void);
412 
413 /**
414  * Initialize queue iteration and return the first queue handle.
415  *
416  * Can be used to initialize the iteration to retrieve all created queues for
417  * debugging or management purposes. Use em_queue_get_next() after this call
418  * until it returns EM_QUEUE_UNDEF. A new call to em_queue_get_first() resets
419  * the iteration, which is maintained per core (thread). The operation should be
420  * completed in one go before returning from the EO's event receive function (or
421  * start/stop).
422  *
423  * The number of queues (output arg 'num') may not match the amount of queues
424  * actually returned by iterating using em_queue_get_next() if queues are added
425  * or removed in parallel by another core. The order of the returned queue
426  * handles is undefined.
427  *
428  * @code
429  * unsigned int num;
430  * em_queue_t q = em_queue_get_first(&num);
431  * while (q != EM_QUEUE_UNDEF) {
432  * q = em_queue_get_next();
433  * }
434  * @endcode
435  *
436  * @param[out] num Pointer to an unsigned int to store the amount of queues
437  * into
438  *
439  * @return The first queue handle or EM_QUEUE_UNDEF if none exist
440  *
441  * @see em_queue_get_next()
442  */
443 em_queue_t
444 em_queue_get_first(unsigned int *num);
445 
446 /**
447  * Return the next queue handle.
448  *
449  * Continues the queue iteration started by em_queue_get_first() and returns the
450  * next queue handle.
451  *
452  * @return The next queue handle or EM_QUEUE_UNDEF if the queue iteration is
453  * completed (i.e. no more queues available).
454  *
455  * @see em_queue_get_first()
456  */
457 em_queue_t
458 em_queue_get_next(void);
459 
460 /**
461  * Get a unique index corresponding to the given EM queue handle.
462  *
463  * Returns a unique index in the range 0 to em_queue_get_max_num() - 1.
464  * The same EM queue handle will always map to the same index.
465  *
466  * Only meaningful for queues created within the current EM instance.
467  *
468  * @param queue EM queue handle
469  * @return Index in the range 0 to em_queue_get_max_num() - 1
470  */
471 int em_queue_get_index(em_queue_t queue);
472 
473 /**
474  * Returns the number of queue priorities available.
475  *
476  * Optionally the amount of actual runtime priorities can be inquired.
477  * Valid queue priority range is from 0 (lowest priority) to
478  * em_queue_get_num_prio() - 1.
479  *
480  * Runtime environment may provide different amount of levels. In that case EM
481  * priorities are mapped to the runtime values depending on mapping mode
482  * selected in the runtime configuration file.
483  *
484  * @param[out] num_runtime Pointer to an int to receive the number of
485  * actual runtime priorities. Set to NULL if
486  * not needed.
487  *
488  * @return number of queue priorities
489  *
490  * @see em-odp.conf
491  */
492 int em_queue_get_num_prio(int *num_runtime);
493 
494 /**
495  * Returns the maximum number of queues that EM can support.
496  *
497  * The max number of EM queues can be configured via EM config file.
498  * This contains the number of internal EM ctrl queues and all EM queues
499  * (static/dynamic) created by application.
500  *
501  * @return the max number of EM queues that can be supported
502  */
503 int em_queue_get_max_num(void);
504 
505 /**
506  * Returns the device-id extracted from the given queue handle
507  *
508  * An EM queue handle consists of a device-id and a queue-id. This function
509  * extracts the device-id from an EM queue handle and returns it.
510  *
511  * @param queue EM queue handle
512  * @return the device-id extracted from the queue handle
513  */
514 uint16_t em_queue_get_device_id(em_queue_t queue);
515 
516 /**
517  * Returns the queue-id extracted from the given queue handle
518  *
519  * An EM queue handle consists of a device-id and a queue-id. This function
520  * extracts the queue-id from an EM queue handle and returns it.
521  *
522  * @param queue EM queue handle
523  * @return the queue-id extracted from the queue handle
524  */
525 uint16_t em_queue_get_qid(em_queue_t queue);
526 
527 /**
528  * Extract and output both the device-id and the queue-id from the given
529  * queue handle.
530  *
531  * An EM queue handle consists of a device-id and a queue-id. This function
532  * extracts both the device-id and the queue-id from an EM queue handle and
533  * returns them to the caller via the output arguments 'device_id' and 'qid'.
534  *
535  * @param queue EM queue handle
536  * @param[out] device_id device-id
537  * @param[out] qid queue-id
538  */
539 void em_queue_get_ids(em_queue_t queue, uint16_t *device_id /*out*/, uint16_t *qid /*out*/);
540 
541 /**
542  * Construct a raw EM queue handle from the provided device-id and queue-id.
543  *
544  * An EM queue handle consists of a device-id and a queue-id. This function
545  * constructs an EM queue handle by combining the device-id and queue-id
546  * together into an EM queue handle.
547  *
548  * @note No checks for the validity of the provided device-id or queue-id are
549  * done. Thus the constructed EM queue handle is a raw value that may not refer
550  * to any existing queue on this EM instance or on another. Be careful.
551  *
552  * @param device_id
553  * @param qid
554  * @return raw EM queue handle created from the given arguments
555  */
556 em_queue_t em_queue_handle_raw(uint16_t device_id, uint16_t qid);
557 
558 /**
559  * Convert an queue handle to an unsigned integer
560  *
561  * @param queue queue handle to be converted
562  * @return uint32_t value that can be used to print/display the handle
563  *
564  * @note This routine is intended to be used for diagnostic purposes
565  * to enable applications to e.g. generate a printable value that represents
566  * an em_queue_t handle.
567  *
568  * @note Unlike other "EM handle to unsigned integer" conversion functions,
569  * the queue handle is converted to a uint32_t (instead of a uint64_t) since
570  * the handle consists of a 16-bit device-id and a 16-bit queue-id.
571  */
572 uint32_t em_queue_to_u32(em_queue_t queue);
573 
574 /**
575  * @}
576  */
577 #ifdef __cplusplus
578 }
579 #endif
580 
581 #pragma GCC visibility pop
582 #endif /* EVENT_MACHINE_QUEUE_H_ */
em_queue_conf_t
Definition: event_machine_types.h:212
em_queue_get_ids
void em_queue_get_ids(em_queue_t queue, uint16_t *device_id, uint16_t *qid)
Definition: event_machine_queue.c:416
em_queue_dequeue_multi
int em_queue_dequeue_multi(em_queue_t queue, em_event_t events[], int num)
Definition: event_machine_queue.c:260
em_queue_get_index
int em_queue_get_index(em_queue_t queue)
Definition: event_machine_queue.c:354
em_queue_dequeue
em_event_t em_queue_dequeue(em_queue_t queue)
Definition: event_machine_queue.c:232
em_queue_type_t
uint32_t em_queue_type_t
Definition: event_machine_types.h:168
em_queue_get_first
em_queue_t em_queue_get_first(unsigned int *num)
Definition: event_machine_queue.c:307
em_queue_create
em_queue_t em_queue_create(const char *name, em_queue_type_t type, em_queue_prio_t prio, em_queue_group_t group, const em_queue_conf_t *conf)
Definition: event_machine_queue.c:41
em_queue_get_priority
em_queue_prio_t em_queue_get_priority(em_queue_t queue)
Definition: event_machine_queue.c:187
em_queue_current
em_queue_t em_queue_current(void)
Definition: event_machine_queue.c:302
em_queue_delete
em_status_t em_queue_delete(em_queue_t queue)
Definition: event_machine_queue.c:95
em_queue_get_group
em_queue_group_t em_queue_get_group(em_queue_t queue)
Definition: event_machine_queue.c:215
em_queue_get_max_num
int em_queue_get_max_num(void)
Definition: event_machine_queue.c:397
em_queue_get_name
size_t em_queue_get_name(em_queue_t queue, char *name, size_t maxlen)
Definition: event_machine_queue.c:145
em_status_t
uint32_t em_status_t
Definition: event_machine_types.h:321
event_machine_hw_types.h
em_queue_set_context
em_status_t em_queue_set_context(em_queue_t queue, const void *context)
Definition: event_machine_queue.c:112
em_queue_to_u32
uint32_t em_queue_to_u32(em_queue_t queue)
Definition: event_machine_queue.c:433
em_queue_get_qid
uint16_t em_queue_get_qid(em_queue_t queue)
Definition: event_machine_queue.c:409
em_queue_get_context
void * em_queue_get_context(em_queue_t queue)
Definition: event_machine_queue.c:126
em_queue_get_type
em_queue_type_t em_queue_get_type(em_queue_t queue)
Definition: event_machine_queue.c:201
em_queue_prio_t
uint32_t em_queue_prio_t
Definition: event_machine_types.h:186
em_queue_handle_raw
em_queue_t em_queue_handle_raw(uint16_t device_id, uint16_t qid)
Definition: event_machine_queue.c:426
event_machine_types.h
em_queue_get_next
em_queue_t em_queue_get_next(void)
Definition: event_machine_queue.c:333
em_queue_get_device_id
uint16_t em_queue_get_device_id(em_queue_t queue)
Definition: event_machine_queue.c:402
em_queue_create_static
em_status_t em_queue_create_static(const char *name, em_queue_type_t type, em_queue_prio_t prio, em_queue_group_t group, em_queue_t queue, const em_queue_conf_t *conf)
Definition: event_machine_queue.c:58
em_queue_get_num_prio
int em_queue_get_num_prio(int *num_runtime)
Definition: event_machine_queue.c:383
em_queue_find
em_queue_t em_queue_find(const char *name)
Definition: event_machine_queue.c:169