1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2017 Intel Corporation 3 */ 4 5 #include <string.h> 6 7 #include <rte_event_ring.h> 8 9 #include "test.h" 10 11 /* 12 * Event Ring 13 * =========== 14 * 15 * Test some basic ops for the event rings. 16 * Does not fully test everything, since most code is reused from rte_ring 17 * library and tested as part of the normal ring autotests. 18 */ 19 20 #define RING_SIZE 4096 21 #define MAX_BULK 32 22 23 static struct rte_event_ring *r; 24 25 /* 26 * ensure failure to create ring with a bad ring size 27 */ 28 static int 29 test_event_ring_creation_with_wrong_size(void) 30 { 31 struct rte_event_ring *rp = NULL; 32 33 /* Test if ring size is not power of 2 */ 34 rp = rte_event_ring_create("test_bad_ring_size", RING_SIZE + 1, 35 SOCKET_ID_ANY, 0); 36 if (rp != NULL) 37 return -1; 38 39 /* Test if ring size is exceeding the limit */ 40 rp = rte_event_ring_create("test_bad_ring_size", (RTE_RING_SZ_MASK + 1), 41 SOCKET_ID_ANY, 0); 42 if (rp != NULL) 43 return -1; 44 return 0; 45 } 46 47 /* 48 * Test to check if a non-power-of-2 count causes the create 49 * function to fail correctly 50 */ 51 static int 52 test_create_count_odd(void) 53 { 54 struct rte_event_ring *r = rte_event_ring_create("test_event_ring_count", 55 4097, SOCKET_ID_ANY, 0); 56 if (r != NULL) 57 return -1; 58 return 0; 59 } 60 61 static int 62 test_lookup_null(void) 63 { 64 struct rte_event_ring *rlp = rte_event_ring_lookup("ring_not_found"); 65 if (rlp == NULL && rte_errno != ENOENT) { 66 printf("test failed to return error on null pointer\n"); 67 return -1; 68 } 69 return 0; 70 } 71 72 static int 73 test_basic_event_enqueue_dequeue(void) 74 { 75 struct rte_event_ring *sr = NULL; 76 struct rte_event evs[16]; 77 uint16_t ret, free_count, used_count; 78 79 memset(evs, 0, sizeof(evs)); 80 sr = rte_event_ring_create("spsc_ring", 32, rte_socket_id(), 81 RING_F_SP_ENQ | RING_F_SC_DEQ); 82 if (sr == NULL) { 83 printf("Failed to create sp/sc ring\n"); 84 return -1; 85 } 86 if (rte_event_ring_get_capacity(sr) != 31) { 87 printf("Error, invalid capacity\n"); 88 goto error; 89 } 90 91 /* test sp/sc ring */ 92 if (rte_event_ring_count(sr) != 0) { 93 printf("Error, ring not empty as expected\n"); 94 goto error; 95 } 96 if (rte_event_ring_free_count(sr) != rte_event_ring_get_capacity(sr)) { 97 printf("Error, ring free count not as expected\n"); 98 goto error; 99 } 100 101 ret = rte_event_ring_enqueue_burst(sr, evs, RTE_DIM(evs), &free_count); 102 if (ret != RTE_DIM(evs) || 103 free_count != rte_event_ring_get_capacity(sr) - ret) { 104 printf("Error, status after enqueue is unexpected\n"); 105 goto error; 106 } 107 108 ret = rte_event_ring_enqueue_burst(sr, evs, RTE_DIM(evs), &free_count); 109 if (ret != RTE_DIM(evs) - 1 || 110 free_count != 0) { 111 printf("Error, status after enqueue is unexpected\n"); 112 goto error; 113 } 114 115 ret = rte_event_ring_dequeue_burst(sr, evs, RTE_DIM(evs), &used_count); 116 if (ret != RTE_DIM(evs) || 117 used_count != rte_event_ring_get_capacity(sr) - ret) { 118 printf("Error, status after enqueue is unexpected\n"); 119 goto error; 120 } 121 ret = rte_event_ring_dequeue_burst(sr, evs, RTE_DIM(evs), &used_count); 122 if (ret != RTE_DIM(evs) - 1 || 123 used_count != 0) { 124 printf("Error, status after enqueue is unexpected\n"); 125 goto error; 126 } 127 128 rte_event_ring_free(sr); 129 return 0; 130 error: 131 rte_event_ring_free(sr); 132 return -1; 133 } 134 135 static int 136 test_event_ring_with_exact_size(void) 137 { 138 struct rte_event_ring *std_ring, *exact_sz_ring; 139 struct rte_event ev = { .mbuf = NULL }; 140 struct rte_event ev_array[16]; 141 static const unsigned int ring_sz = RTE_DIM(ev_array); 142 unsigned int i; 143 144 std_ring = rte_event_ring_create("std", ring_sz, rte_socket_id(), 145 RING_F_SP_ENQ | RING_F_SC_DEQ); 146 if (std_ring == NULL) { 147 printf("%s: error, can't create std ring\n", __func__); 148 return -1; 149 } 150 exact_sz_ring = rte_event_ring_create("exact sz", 151 ring_sz, rte_socket_id(), 152 RING_F_SP_ENQ | RING_F_SC_DEQ | RING_F_EXACT_SZ); 153 if (exact_sz_ring == NULL) { 154 printf("%s: error, can't create exact size ring\n", __func__); 155 return -1; 156 } 157 158 /* 159 * Check that the exact size ring is bigger than the standard ring 160 */ 161 if (rte_event_ring_get_size(std_ring) >= 162 rte_event_ring_get_size(exact_sz_ring)) { 163 printf("%s: error, std ring (size: %u) is not smaller than exact size one (size %u)\n", 164 __func__, 165 rte_event_ring_get_size(std_ring), 166 rte_event_ring_get_size(exact_sz_ring)); 167 return -1; 168 } 169 /* 170 * check that the exact_sz_ring can hold one more element than the 171 * standard ring. (16 vs 15 elements) 172 */ 173 for (i = 0; i < ring_sz - 1; i++) { 174 rte_event_ring_enqueue_burst(std_ring, &ev, 1, NULL); 175 rte_event_ring_enqueue_burst(exact_sz_ring, &ev, 1, NULL); 176 } 177 if (rte_event_ring_enqueue_burst(std_ring, &ev, 1, NULL) != 0) { 178 printf("%s: error, unexpected successful enqueue\n", __func__); 179 return -1; 180 } 181 if (rte_event_ring_enqueue_burst(exact_sz_ring, &ev, 1, NULL) != 1) { 182 printf("%s: error, enqueue failed\n", __func__); 183 return -1; 184 } 185 186 /* check that dequeue returns the expected number of elements */ 187 if (rte_event_ring_dequeue_burst(exact_sz_ring, ev_array, 188 RTE_DIM(ev_array), NULL) != ring_sz) { 189 printf("%s: error, failed to dequeue expected nb of elements\n", 190 __func__); 191 return -1; 192 } 193 194 /* check that the capacity function returns expected value */ 195 if (rte_event_ring_get_capacity(exact_sz_ring) != ring_sz) { 196 printf("%s: error, incorrect ring capacity reported\n", 197 __func__); 198 return -1; 199 } 200 201 rte_event_ring_free(std_ring); 202 rte_event_ring_free(exact_sz_ring); 203 return 0; 204 } 205 206 static int 207 test_event_ring(void) 208 { 209 if (r == NULL) 210 r = rte_event_ring_create("ev_test", RING_SIZE, 211 SOCKET_ID_ANY, 0); 212 if (r == NULL) 213 return -1; 214 215 /* retrieve the ring from its name */ 216 if (rte_event_ring_lookup("ev_test") != r) { 217 printf("Cannot lookup ring from its name\n"); 218 return -1; 219 } 220 221 /* basic operations */ 222 if (test_create_count_odd() < 0) { 223 printf("Test failed to detect odd count\n"); 224 return -1; 225 } 226 printf("Test detected odd count\n"); 227 228 if (test_lookup_null() < 0) { 229 printf("Test failed to detect NULL ring lookup\n"); 230 return -1; 231 } 232 printf("Test detected NULL ring lookup\n"); 233 234 /* test of creating ring with wrong size */ 235 if (test_event_ring_creation_with_wrong_size() < 0) 236 return -1; 237 238 if (test_basic_event_enqueue_dequeue() < 0) 239 return -1; 240 241 if (test_event_ring_with_exact_size() < 0) 242 return -1; 243 244 return 0; 245 } 246 247 REGISTER_TEST_COMMAND(event_ring_autotest, test_event_ring); 248