/src/unit/src/nxt_nncq.h

Source (jump to first uncovered line)

/*
 * Copyright (C) NGINX, Inc.
 */

#ifndef _NXT_NNCQ_H_INCLUDED_
#define _NXT_NNCQ_H_INCLUDED_


/* Numeric Naive Circular Queue */

#define NXT_NNCQ_SIZE  16384

typedef uint32_t nxt_nncq_atomic_t;
typedef uint16_t nxt_nncq_cycle_t;

typedef struct {
    nxt_nncq_atomic_t  head;
    nxt_nncq_atomic_t  entries[NXT_NNCQ_SIZE];
    nxt_nncq_atomic_t  tail;
} nxt_nncq_t;


static inline nxt_nncq_atomic_t
nxt_nncq_head(nxt_nncq_t const volatile *q)
{
    return q->head;
}


static inline nxt_nncq_atomic_t
nxt_nncq_tail(nxt_nncq_t const volatile *q)
{
    return q->tail;
}


static inline void
nxt_nncq_tail_cmp_inc(nxt_nncq_t volatile *q, nxt_nncq_atomic_t t)
{
    nxt_atomic_cmp_set(&q->tail, t, t + 1);
}


static inline nxt_nncq_atomic_t
nxt_nncq_index(nxt_nncq_t const volatile *q, nxt_nncq_atomic_t i)
{
    return i % NXT_NNCQ_SIZE;
}


static inline nxt_nncq_atomic_t
nxt_nncq_map(nxt_nncq_t const volatile *q, nxt_nncq_atomic_t i)
{
    return i % NXT_NNCQ_SIZE;
}


static inline nxt_nncq_cycle_t
nxt_nncq_cycle(nxt_nncq_t const volatile *q, nxt_nncq_atomic_t i)
{
    return i / NXT_NNCQ_SIZE;
}


static inline nxt_nncq_cycle_t
nxt_nncq_next_cycle(nxt_nncq_t const volatile *q, nxt_nncq_cycle_t i)
{
    return i + 1;
}


static inline nxt_nncq_atomic_t
nxt_nncq_new_entry(nxt_nncq_t const volatile *q, nxt_nncq_cycle_t cycle,
    nxt_nncq_atomic_t i)
{
    return cycle * NXT_NNCQ_SIZE + (i % NXT_NNCQ_SIZE);
}


static inline nxt_nncq_atomic_t
nxt_nncq_empty(nxt_nncq_t const volatile *q)
{
    return NXT_NNCQ_SIZE;
}


static inline void
nxt_nncq_init(nxt_nncq_t volatile *q)
{
    q->head = NXT_NNCQ_SIZE;
    nxt_memzero((void *) q->entries, NXT_NNCQ_SIZE * sizeof(nxt_nncq_atomic_t));
    q->tail = NXT_NNCQ_SIZE;
}


static inline void
nxt_nncq_enqueue(nxt_nncq_t volatile *q, nxt_nncq_atomic_t val)
{
    nxt_nncq_cycle_t   e_cycle, t_cycle;
    nxt_nncq_atomic_t  n, t, e, j;

    for ( ;; ) {
        t = nxt_nncq_tail(q);
        j = nxt_nncq_map(q, t);
        e = q->entries[j];

        e_cycle = nxt_nncq_cycle(q, e);
        t_cycle = nxt_nncq_cycle(q, t);

        if (e_cycle == t_cycle) {
            nxt_nncq_tail_cmp_inc(q, t);
            continue;
        }

        if (nxt_nncq_next_cycle(q, e_cycle) != t_cycle) {
            continue;
        }

        n = nxt_nncq_new_entry(q, t_cycle, val);

        if (nxt_atomic_cmp_set(&q->entries[j], e, n)) {
            break;
        }
    }

    nxt_nncq_tail_cmp_inc(q, t);
}


static inline nxt_nncq_atomic_t
nxt_nncq_dequeue(nxt_nncq_t volatile *q)
{
    nxt_nncq_cycle_t   e_cycle, h_cycle;
    nxt_nncq_atomic_t  h, j, e;

    for ( ;; ) {
        h = nxt_nncq_head(q);
        j = nxt_nncq_map(q, h);
        e = q->entries[j];

        e_cycle = nxt_nncq_cycle(q, e);
        h_cycle = nxt_nncq_cycle(q, h);

        if (e_cycle != h_cycle) {
            if (nxt_nncq_next_cycle(q, e_cycle) == h_cycle) {
                return nxt_nncq_empty(q);
            }

            continue;
        }

        if (nxt_atomic_cmp_set(&q->head, h, h + 1)) {
            break;
        }
    }

    return nxt_nncq_index(q, e);
}


#endif /* _NXT_NNCQ_H_INCLUDED_ */

Line	Count	Source (jump to first uncovered line)
1
2		/*
3		* Copyright (C) NGINX, Inc.
4		*/
5
6		#ifndef _NXT_NNCQ_H_INCLUDED_
7		#define _NXT_NNCQ_H_INCLUDED_
8
9
10		/* Numeric Naive Circular Queue */
11
12	0	#define NXT_NNCQ_SIZE 16384
13
14		typedef uint32_t nxt_nncq_atomic_t;
15		typedef uint16_t nxt_nncq_cycle_t;
16
17		typedef struct {
18		nxt_nncq_atomic_t head;
19		nxt_nncq_atomic_t entries[NXT_NNCQ_SIZE];
20		nxt_nncq_atomic_t tail;
21		} nxt_nncq_t;
22
23
24		static inline nxt_nncq_atomic_t
25		nxt_nncq_head(nxt_nncq_t const volatile *q)
26	0	{
27	0	return q->head;
28	0	} Unexecuted instantiation: nxt_port_socket.c:nxt_nncq_head Unexecuted instantiation: nxt_port.c:nxt_nncq_head Unexecuted instantiation: nxt_main_process.c:nxt_nncq_head Unexecuted instantiation: nxt_router.c:nxt_nncq_head
29
30
31		static inline nxt_nncq_atomic_t
32		nxt_nncq_tail(nxt_nncq_t const volatile *q)
33	0	{
34	0	return q->tail;
35	0	} Unexecuted instantiation: nxt_port_socket.c:nxt_nncq_tail Unexecuted instantiation: nxt_port.c:nxt_nncq_tail Unexecuted instantiation: nxt_main_process.c:nxt_nncq_tail Unexecuted instantiation: nxt_router.c:nxt_nncq_tail
36
37
38		static inline void
39		nxt_nncq_tail_cmp_inc(nxt_nncq_t volatile *q, nxt_nncq_atomic_t t)
40	0	{
41	0	nxt_atomic_cmp_set(&q->tail, t, t + 1);
42	0	} Unexecuted instantiation: nxt_port_socket.c:nxt_nncq_tail_cmp_inc Unexecuted instantiation: nxt_port.c:nxt_nncq_tail_cmp_inc Unexecuted instantiation: nxt_main_process.c:nxt_nncq_tail_cmp_inc Unexecuted instantiation: nxt_router.c:nxt_nncq_tail_cmp_inc
43
44
45		static inline nxt_nncq_atomic_t
46		nxt_nncq_index(nxt_nncq_t const volatile *q, nxt_nncq_atomic_t i)
47	0	{
48	0	return i % NXT_NNCQ_SIZE;
49	0	} Unexecuted instantiation: nxt_port_socket.c:nxt_nncq_index Unexecuted instantiation: nxt_port.c:nxt_nncq_index Unexecuted instantiation: nxt_main_process.c:nxt_nncq_index Unexecuted instantiation: nxt_router.c:nxt_nncq_index
50
51
52		static inline nxt_nncq_atomic_t
53		nxt_nncq_map(nxt_nncq_t const volatile *q, nxt_nncq_atomic_t i)
54	0	{
55	0	return i % NXT_NNCQ_SIZE;
56	0	} Unexecuted instantiation: nxt_port_socket.c:nxt_nncq_map Unexecuted instantiation: nxt_port.c:nxt_nncq_map Unexecuted instantiation: nxt_main_process.c:nxt_nncq_map Unexecuted instantiation: nxt_router.c:nxt_nncq_map
57
58
59		static inline nxt_nncq_cycle_t
60		nxt_nncq_cycle(nxt_nncq_t const volatile *q, nxt_nncq_atomic_t i)
61	0	{
62	0	return i / NXT_NNCQ_SIZE;
63	0	} Unexecuted instantiation: nxt_port_socket.c:nxt_nncq_cycle Unexecuted instantiation: nxt_port.c:nxt_nncq_cycle Unexecuted instantiation: nxt_main_process.c:nxt_nncq_cycle Unexecuted instantiation: nxt_router.c:nxt_nncq_cycle
64
65
66		static inline nxt_nncq_cycle_t
67		nxt_nncq_next_cycle(nxt_nncq_t const volatile *q, nxt_nncq_cycle_t i)
68	0	{
69	0	return i + 1;
70	0	} Unexecuted instantiation: nxt_port_socket.c:nxt_nncq_next_cycle Unexecuted instantiation: nxt_port.c:nxt_nncq_next_cycle Unexecuted instantiation: nxt_main_process.c:nxt_nncq_next_cycle Unexecuted instantiation: nxt_router.c:nxt_nncq_next_cycle
71
72
73		static inline nxt_nncq_atomic_t
74		nxt_nncq_new_entry(nxt_nncq_t const volatile *q, nxt_nncq_cycle_t cycle,
75		nxt_nncq_atomic_t i)
76	0	{
77	0	return cycle * NXT_NNCQ_SIZE + (i % NXT_NNCQ_SIZE);
78	0	} Unexecuted instantiation: nxt_port_socket.c:nxt_nncq_new_entry Unexecuted instantiation: nxt_port.c:nxt_nncq_new_entry Unexecuted instantiation: nxt_main_process.c:nxt_nncq_new_entry Unexecuted instantiation: nxt_router.c:nxt_nncq_new_entry
79
80
81		static inline nxt_nncq_atomic_t
82		nxt_nncq_empty(nxt_nncq_t const volatile *q)
83	0	{
84	0	return NXT_NNCQ_SIZE;
85	0	} Unexecuted instantiation: nxt_port_socket.c:nxt_nncq_empty Unexecuted instantiation: nxt_port.c:nxt_nncq_empty Unexecuted instantiation: nxt_main_process.c:nxt_nncq_empty Unexecuted instantiation: nxt_router.c:nxt_nncq_empty
86
87
88		static inline void
89		nxt_nncq_init(nxt_nncq_t volatile *q)
90	0	{
91	0	q->head = NXT_NNCQ_SIZE;
92	0	nxt_memzero((void ) q->entries, NXT_NNCQ_SIZE sizeof(nxt_nncq_atomic_t));
93	0	q->tail = NXT_NNCQ_SIZE;
94	0	} Unexecuted instantiation: nxt_port_socket.c:nxt_nncq_init Unexecuted instantiation: nxt_port.c:nxt_nncq_init Unexecuted instantiation: nxt_main_process.c:nxt_nncq_init Unexecuted instantiation: nxt_router.c:nxt_nncq_init
95
96
97		static inline void
98		nxt_nncq_enqueue(nxt_nncq_t volatile *q, nxt_nncq_atomic_t val)
99	0	{
100	0	nxt_nncq_cycle_t e_cycle, t_cycle;
101	0	nxt_nncq_atomic_t n, t, e, j;
102
103	0	for ( ;; ) {
104	0	t = nxt_nncq_tail(q);
105	0	j = nxt_nncq_map(q, t);
106	0	e = q->entries[j];
107
108	0	e_cycle = nxt_nncq_cycle(q, e);
109	0	t_cycle = nxt_nncq_cycle(q, t);
110
111	0	if (e_cycle == t_cycle) {
112	0	nxt_nncq_tail_cmp_inc(q, t);
113	0	continue;
114	0	}
115
116	0	if (nxt_nncq_next_cycle(q, e_cycle) != t_cycle) {
117	0	continue;
118	0	}
119
120	0	n = nxt_nncq_new_entry(q, t_cycle, val);
121
122	0	if (nxt_atomic_cmp_set(&q->entries[j], e, n)) {
123	0	break;
124	0	}
125	0	}
126
127	0	nxt_nncq_tail_cmp_inc(q, t);
128	0	} Unexecuted instantiation: nxt_port_socket.c:nxt_nncq_enqueue Unexecuted instantiation: nxt_port.c:nxt_nncq_enqueue Unexecuted instantiation: nxt_main_process.c:nxt_nncq_enqueue Unexecuted instantiation: nxt_router.c:nxt_nncq_enqueue
129
130
131		static inline nxt_nncq_atomic_t
132		nxt_nncq_dequeue(nxt_nncq_t volatile *q)
133	0	{
134	0	nxt_nncq_cycle_t e_cycle, h_cycle;
135	0	nxt_nncq_atomic_t h, j, e;
136
137	0	for ( ;; ) {
138	0	h = nxt_nncq_head(q);
139	0	j = nxt_nncq_map(q, h);
140	0	e = q->entries[j];
141
142	0	e_cycle = nxt_nncq_cycle(q, e);
143	0	h_cycle = nxt_nncq_cycle(q, h);
144
145	0	if (e_cycle != h_cycle) {
146	0	if (nxt_nncq_next_cycle(q, e_cycle) == h_cycle) {
147	0	return nxt_nncq_empty(q);
148	0	}
149
150	0	continue;
151	0	}
152
153	0	if (nxt_atomic_cmp_set(&q->head, h, h + 1)) {
154	0	break;
155	0	}
156	0	}
157
158	0	return nxt_nncq_index(q, e);
159	0	} Unexecuted instantiation: nxt_port_socket.c:nxt_nncq_dequeue Unexecuted instantiation: nxt_port.c:nxt_nncq_dequeue Unexecuted instantiation: nxt_main_process.c:nxt_nncq_dequeue Unexecuted instantiation: nxt_router.c:nxt_nncq_dequeue
160
161
162		#endif /* _NXT_NNCQ_H_INCLUDED_ */

Coverage Report

Created: 2023-11-07 06:43