1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <cstdlib>
18 #include <mutex>
19 #include <cmath>
20 #include <chrono>
21 #include <thread>
22 #include <fstream>
23 #include <random>
24 #include <algorithm>
25 #include <cinttypes>
26 #include "util.h"
27 #include "ffrt_inner.h"
28 #include "c/ffrt_ipc.h"
29 #include "eu/co_routine.h"
30 #define private public
31 #include "eu/io_poller.h"
32 #include "sync/timer_manager.h"
33 #define protect public
34 #include "util/ffrt_facade.h"
35 #undef private
36 #undef protect
37 #include "../common.h"
38
39 using namespace std;
40 using namespace ffrt;
41 using namespace testing;
42 #ifdef HWTEST_TESTING_EXT_ENABLE
43 using namespace testing::ext;
44 #endif
45 #ifdef APP_USE_ARM
46 #define SIZEOF_BYTES sizeof(uint32_t)
47 #else
48 #define SIZEOF_BYTES sizeof(uint64_t)
49 #endif
50
51 class ffrtIoTest : public testing::Test {
52 protected:
SetUpTestCase()53 static void SetUpTestCase()
54 {
55 }
56
TearDownTestCase()57 static void TearDownTestCase()
58 {
59 }
60
SetUp()61 void SetUp() override
62 {
63 }
64
TearDown()65 void TearDown() override
66 {
67 }
68 };
69
70 HWTEST_F(ffrtIoTest, IoPoller_1Producer_1Consumer, TestSize.Level0)
71 {
72 uint64_t expected = 0xabacadae;
73 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
__anon725558aa0102() 74 ffrt::submit([&]() {
75 ffrt::sync_io(testFd);
76 uint64_t value = 0;
77 ssize_t n = read(testFd, &value, sizeof(uint64_t));
78 EXPECT_EQ(n, sizeof(value));
79 EXPECT_EQ(value, expected);
80 close(testFd);
81 }, {}, {});
__anon725558aa0402() 82 ffrt::submit([&]() {
83 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
84 EXPECT_EQ(n, sizeof(uint64_t));
85 }, {}, {});
86
87 ffrt::wait();
88 }
89
90 /*
91 * 测试用例名称：IoPoller_1Producer_1Consumer_Legacy_Mode
92 * 测试用例描述：sync_io接口，线程阻塞模式测试
93 * 预置条件 ：无
94 * 操作步骤 ：1、提交一个读任务，一个写任务
95 2、读任务使设置legacy_mode后调用sync_io接口
96 * 预期结果 ：任务正确执行
97 */
98 HWTEST_F(ffrtIoTest, IoPoller_1Producer_1Consumer_Legacy_Mode, TestSize.Level0)
99 {
100 uint64_t expected = 0xabacadae;
101 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
__anon725558aa0702() 102 ffrt::submit([&]() {
103 ffrt_this_task_set_legacy_mode(true);
104 ffrt::sync_io(testFd);
105 uint64_t value = 0;
106 ssize_t n = read(testFd, &value, sizeof(uint64_t));
107 EXPECT_EQ(n, sizeof(value));
108 EXPECT_EQ(value, expected);
109 close(testFd);
110 }, {}, {});
__anon725558aa0a02() 111 ffrt::submit([&]() {
112 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
113 EXPECT_EQ(n, sizeof(uint64_t));
114 }, {}, {});
115 ffrt::wait();
116 }
117
118 HWTEST_F(ffrtIoTest, IoPoller_1Consumer_1Producer, TestSize.Level0)
119 {
120 uint64_t expected = 0xabacadae;
121 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
__anon725558aa0d02() 122 ffrt::submit([&]() {
123 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
124 EXPECT_EQ(n, sizeof(uint64_t));
125 }, {}, {});
126
127 stall_us(3);
128
__anon725558aa1002() 129 ffrt::submit([&]() {
130 ffrt::sync_io(testFd);
131 uint64_t value = 0;
132 ssize_t n = read(testFd, &value, sizeof(uint64_t));
133 EXPECT_EQ(n, sizeof(value));
134 EXPECT_EQ(value, expected);
135 close(testFd);
136 }, {}, {});
137
138 ffrt::wait();
139 }
140
141 uint64_t g_Ev = 0;
142
143 HWTEST_F(ffrtIoTest, IoPoller_Producer_N_Consumer_N, TestSize.Level0)
144 {
145 int count = 3;
146 uint64_t ev = 0xabacadae;
147 int testFd[count];
148 uint64_t evN = 0;
149 uint64_t i;
150 for (i = 0; i < count; i++) {
151 testFd[i] = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
152 if (testFd[i] < 0) {
153 break;
154 }
155 evN++;
156 g_Ev = evN;
157 int fd = testFd[i];
__anon725558aa1302() 158 ffrt::submit([fd, i]() {
159 ffrt::sync_io(fd);
160 uint64_t value = 0;
161 ssize_t n = read(fd, &value, sizeof(uint64_t));
162 EXPECT_EQ(n, sizeof(value));
163 close(fd);
164 }, {}, {});
165 }
166
167 for (i = 0; i < evN; i++) {
__anon725558aa1602() 168 ffrt::submit([&, i]() {
169 uint64_t expected = ev + i;
170 ssize_t n = write(testFd[i], &expected, sizeof(uint64_t));
171 EXPECT_EQ(n, sizeof(uint64_t));
172 }, {}, {});
173 }
174 printf("max eventfd:%" PRIu64 ".\n", evN);
175 ffrt::wait();
176 }
177
178 struct TestData {
179 int fd;
180 uint64_t expected;
181 std::atomic<bool> finish;
182 };
183
testCallBack(void * token,uint32_t event)184 static void testCallBack(void* token, uint32_t event)
185 {
186 struct TestData* testData = reinterpret_cast<TestData*>(token);
187 uint64_t value = 0;
188 ssize_t n = read(testData->fd, &value, sizeof(uint64_t));
189 EXPECT_EQ(n, sizeof(value));
190 EXPECT_EQ(value, testData->expected);
191 testData->finish = true;
192 printf("cb done\n");
193 }
194
testfun(void * data)195 static void testfun(void* data)
196 {
197 *(int*)data += 1;
198 printf("%d, timeout callback\n", *(int*)data);
199 }
200 void (*cb)(void*) = testfun;
201
testSleepFun(void * data)202 static void testSleepFun(void* data)
203 {
204 usleep(100000);
205 *(int*)data += 1;
206 printf("%d, timeout callback\n", *(int*)data);
207 }
208 void (*sleepCb)(void*) = testSleepFun;
209
210 HWTEST_F(ffrtIoTest, ffrt_timer_start_succ_map_null, TestSize.Level0)
211 {
212 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
213 uint64_t timeout = 20;
214 int x = 0;
215 int* xf = &x;
216 void* data = xf;
217 uint64_t expected = 0xabacadae;
218 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
219 EXPECT_EQ(0, ffrt_timer_start(qos, timeout, data, cb, false));
220
221 struct TestData testData {.fd = testFd, .expected = expected, .finish = false};
222 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
223
224 usleep(30000);
__anon725558aa1902() 225 ffrt::submit([&]() {
226 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
227 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
228 }, {}, {});
229 while (1) {
230 usleep(1000);
231 if (testData.finish) break;
232 }
233 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
234 EXPECT_EQ(1, x);
235 close(testFd);
236 }
237
238 HWTEST_F(ffrtIoTest, ffrt_timer_start_fail_cb_null, TestSize.Level0)
239 {
240 uint64_t timeout = 20;
241 void* data = nullptr;
242 void (*timeoutNullCb)(void*) = nullptr;
243
244 EXPECT_EQ(-1, ffrt_timer_start(ffrt_qos_default, timeout, data, timeoutNullCb, false));
245 }
246
247 HWTEST_F(ffrtIoTest, ffrt_timer_start_fail_flag_teardown, TestSize.Level0)
248 {
249 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
250 ffrt::FFRTFacade::GetTMInstance().teardown = true;
251 uint64_t timeout = 20;
252 void* data = nullptr;
253
254 EXPECT_EQ(-1, ffrt_timer_start(qos, timeout, data, cb, false));
255 ffrt::FFRTFacade::GetTMInstance().teardown = false;
256 }
257
258 HWTEST_F(ffrtIoTest, ffrt_timer_stop_fail, TestSize.Level0)
259 {
260 int handle = -1;
261 auto ret = ffrt_timer_stop(ffrt_qos_default, handle);
262 EXPECT_EQ(ret, -1);
263 }
264
265 HWTEST_F(ffrtIoTest, ffrt_timer_query_test, TestSize.Level0)
266 {
267 int x = 0;
268 int* xf = &x;
269 void* data = xf;
270 uint64_t timeout1 = 10;
271 uint64_t timeout2 = 20;
272 uint64_t expected = 0xabacadae;
273 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
274
275 ffrt_qos_t qos = ffrt_qos_default;
276 int handle = ffrt_timer_start(qos, timeout1, data, cb, false);
277 EXPECT_EQ(0, ffrt_timer_query(qos, handle));
278
279 struct TestData testData {.fd = testFd, .expected = expected, .finish = false};
280 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
281
282 usleep(15000);
283
__anon725558aa1c02() 284 ffrt::submit([&]() {
285 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
286 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
287 }, {}, {});
288 while (1) {
289 usleep(1000);
290 if (testData.finish) break;
291 }
292 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
293 close(testFd);
294 EXPECT_EQ(1, ffrt_timer_query(qos, handle));
295 }
296
297 HWTEST_F(ffrtIoTest, ffrt_timer_query_stop, TestSize.Level0)
298 {
299 int x = 0;
300 int* xf = &x;
301 void* data = xf;
302 uint64_t timeout1 = 10;
303 uint64_t timeout2 = 20;
304 uint64_t expected = 0xabacadae;
305 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
306
307 ffrt_qos_t qos = ffrt_qos_default;
308 int handle = ffrt_timer_start(qos, timeout1, data, sleepCb, false);
309 EXPECT_EQ(0, ffrt_timer_query(qos, handle));
310 usleep(500000);
311 EXPECT_EQ(1, ffrt_timer_query(qos, handle));
312
313 ffrt_timer_stop(qos, handle);
314 struct TestData testData {.fd = testFd, .expected = expected, .finish = false};
315 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
316
317 usleep(15000);
318
__anon725558aa1f02() 319 ffrt::submit([&]() {
320 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
321 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
322 }, {}, {});
323 while (1) {
324 usleep(1000);
325 if (testData.finish) break;
326 }
327 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
328 EXPECT_EQ(1, ffrt_timer_query(qos, handle));
329 close(testFd);
330 }
331
332 HWTEST_F(ffrtIoTest, ffrt_poller_deregister_qos_valid, TestSize.Level0)
333 {
334 uint64_t expected = 0xabacadae;
335 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
336 ffrt_qos_t qos_level = ffrt_qos_default;
337 int op = EPOLL_CTL_ADD;
338
339 struct TestData testData {.fd = testFd, .expected = expected, .finish = false};
340
341 int ret = ffrt_epoll_ctl(qos_level, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
342 EXPECT_EQ(0, ret);
343
__anon725558aa2202() 344 ffrt::submit([&]() {
345 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
346 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
347 }, {}, {});
348 while (1) {
349 usleep(1000);
350 if (testData.finish) break;
351 }
352 ret = ffrt_epoll_ctl(qos_level, EPOLL_CTL_DEL, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
353 EXPECT_EQ(0, ret);
354 close(testFd);
355 }
356
357 HWTEST_F(ffrtIoTest, ffrt_poller_deregister_qos_fd_invalid, TestSize.Level0)
358 {
359 uint64_t expected = 0xabacadae;
360 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
361 ffrt_qos_t qos_level = ffrt_qos_default;
362 int op = EPOLL_CTL_ADD;
363
364 struct TestData testData {.fd = testFd, .expected = expected, .finish = false};
365
366 int ret = ffrt_epoll_ctl(qos_level, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
367 EXPECT_EQ(0, ret);
368
__anon725558aa2502() 369 ffrt::submit([&]() {
370 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
371 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
372 }, {}, {});
373 while (1) {
374 usleep(1000);
375 if (testData.finish) break;
376 }
377 ret = ffrt_epoll_ctl(qos_level, EPOLL_CTL_DEL, -1, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
378 EXPECT_EQ(-1, ret);
379 close(testFd);
380 }
381
382 HWTEST_F(ffrtIoTest, ffrt_poller_deregister_qos_qos_invalid, TestSize.Level0)
383 {
384 uint64_t expected = 0xabacadae;
385 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
386 ffrt_qos_t qos_level = ffrt_qos_user_initiated;
387 int op = EPOLL_CTL_ADD;
388
389 struct TestData testData {.fd = testFd, .expected = expected, .finish = false};
390
391 int ret = ffrt_epoll_ctl(ffrt_qos_default, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
392 EXPECT_EQ(0, ret);
393
__anon725558aa2802() 394 ffrt::submit([&]() {
395 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
396 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
397 }, {}, {});
398 while (1) {
399 usleep(1000);
400 if (testData.finish) break;
401 }
402 ret = ffrt_epoll_ctl(qos_level, EPOLL_CTL_DEL, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
403 EXPECT_EQ(0, ret);
404 close(testFd);
405 }
406
407 HWTEST_F(ffrtIoTest, ffrt_task_attr_set_local_true, TestSize.Level0)
408 {
409 bool isLocalSet = true;
410 ffrt_task_attr_t attr;
411 ffrt_task_attr_init(&attr);
412 ffrt_task_attr_set_local(&attr, isLocalSet);
413 bool localval = ffrt_task_attr_get_local(&attr);
414 EXPECT_EQ(localval, isLocalSet);
415 }
416
417 HWTEST_F(ffrtIoTest, ffrt_task_attr_set_local_false, TestSize.Level0)
418 {
419 bool isLocalSet = false;
420 ffrt_task_attr_t attr;
421 ffrt_task_attr_init(&attr);
422 ffrt_task_attr_set_local(&attr, isLocalSet);
423 bool localval = ffrt_task_attr_get_local(&attr);
424 EXPECT_EQ(localval, isLocalSet);
425 }
426
427 HWTEST_F(ffrtIoTest, ffrt_task_attr_set_local_attr_invalid, TestSize.Level0)
428 {
429 bool isLocalSet = true;
430 ffrt_task_attr_set_local(nullptr, isLocalSet);
431 EXPECT_EQ(isLocalSet, true);
432 }
433
434 struct WakeData {
435 int fd;
436 void* data;
437 };
438
439 HWTEST_F(ffrtIoTest, ffrt_epoll_ctl_op1, TestSize.Level0)
440 {
441 int op = EPOLL_CTL_ADD;
442 ffrt_qos_t qos = ffrt_qos_default;
443 uint64_t expected = 0xabacadae;
444 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
445 struct TestData testData {.fd = testFd, .expected = expected, .finish = false};
446
447 int ret = ffrt_epoll_ctl(qos, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
448 EXPECT_EQ(0, ret);
449 }
450
451 HWTEST_F(ffrtIoTest, ffrt_epoll_ctl_op3, TestSize.Level0)
452 {
453 int op = EPOLL_CTL_MOD;
454 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
455 uint64_t expected = 0xabacadae;
456 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
457 struct TestData testData {.fd = testFd, .expected = expected, .finish = false};
458
459 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
460 int ret = ffrt_epoll_ctl(qos, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
461 EXPECT_EQ(0, ret);
462 }
463
464 HWTEST_F(ffrtIoTest, ffrt_epoll_ctl_op_invalid, TestSize.Level0)
465 {
466 int op = 0;
467 ffrt_qos_t qos = ffrt_qos_default;
468 uint64_t expected = 0xabacadae;
469 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
470 struct TestData testData {.fd = testFd, .expected = expected, .finish = false};
471
472 int ret = ffrt_epoll_ctl(qos, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
473 EXPECT_EQ(-1, ret);
474 }
475
476 HWTEST_F(ffrtIoTest, ffrt_epoll_get_count, TestSize.Level0)
477 {
478 ffrt_qos_t qos = ffrt_qos_default;
479 /* If this test is run in isolation, one can expect the poll count to be one.
480 * However, if this test is run in the same environment of preceding tests e.g., ffrt_timer_start_succ_map_null the
481 * count is expected to be larger than one. Considering both run modes, we expect a non-zero value, instead of a
482 * specific value.
483 * Note: In general, it is a better idea to make test run oblivious and function independently from
484 * each-other.
485 */
486 ffrt::FFRTFacade::GetPPInstance().PollOnce(0);
487 int ret = ffrt_epoll_get_count(qos);
488 EXPECT_NE(ret, 0);
489 }
490
491 HWTEST_F(ffrtIoTest, ffrt_epoll_get_wait_time_invalid, TestSize.Level0)
492 {
493 void* taskHandle = nullptr;
494
495 int ret = ffrt_epoll_get_wait_time(taskHandle);
496 EXPECT_EQ(ret, 0);
497 }
498
499 /*
500 * 测试用例名称：ffrt_epoll_get_wait_time_valid
501 * 测试用例描述：使用有效任务指针调用ffrt_epoll_get_wait_time
502 * 预置条件 ：无
503 * 操作步骤 ：1、提交任务
504 2、调用ffrt_epoll_get_wait_time接口
505 * 预期结果 ：结果为0
506 */
507 HWTEST_F(ffrtIoTest, ffrt_epoll_get_wait_time_valid, TestSize.Level0)
508 {
__anon725558aa2b02() 509 auto handle = ffrt::submit_h([]() {});
510
511 int ret = ffrt_epoll_get_wait_time(handle);
512 EXPECT_EQ(ret, 0);
513 ffrt::wait();
514 }
515
516 typedef struct {
517 int timerId;
518 std::atomic<int> result;
519 } TimerDataT;
520
TimerCb(void * data)521 static void TimerCb(void* data)
522 {
523 (reinterpret_cast<TimerDataT*>(data))->result++;
524 }
525
526 /*
527 * 测试用例名称：timer_repeat
528 * 测试用例描述：测试注册repeat的定时器后，进程能正确推出
529 * 预置条件 ：无
530 * 操作步骤 ：1.子进程提交若干个repeat为true的timer，sleep1秒后退出
531 2.父进程等待子进程完成
532 * 预期结果 ：子进程结束码为0（不发生crash）
533 */
534 HWTEST_F(ffrtIoTest, timer_repeat, TestSize.Level0)
535 {
536 const int timerCount = 1000;
537 static TimerDataT timerDatas[timerCount];
538 for (auto& timerData : timerDatas) {
539 timerData.result = 0;
540 timerData.timerId = ffrt_timer_start(ffrt_qos_default,
541 0, reinterpret_cast<void*>(&timerData), TimerCb, true);
542 }
543 while (timerDatas[0].result == 0) {
544 usleep(1);
545 }
546 sleep(1);
547 EXPECT_GT(timerDatas[0].result, 0);
548 }
549
550 HWTEST_F(ffrtIoTest, ffrt_epoll_wait_test, TestSize.Level0)
551 {
552 uint64_t expected = 0x3;
553 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
554 int op = EPOLL_CTL_ADD;
555 ffrt_qos_t qos = ffrt_qos_user_initiated;
556
557 struct TestData testData {.fd = testFd, .expected = expected};
__anon725558aa2d02() 558 ffrt::submit([=]() {
559 int ret = ffrt_epoll_ctl(qos, op, testFd, EPOLLIN, nullptr, nullptr);
560 EXPECT_EQ(ret, 0);
561 // sleep to wait event
562 ffrt_usleep(50000);
563 // get fds
564 struct epoll_event events[1024];
565 int nfds = ffrt_epoll_wait(qos, events, 1024, -1);
566 EXPECT_EQ(nfds, 1);
567 ret = ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
568 EXPECT_EQ(ret, 0);
569 // read vaule from fd and check
570 uint64_t value = 0;
571 ssize_t n = read(testFd, &value, sizeof(uint64_t));
572 EXPECT_EQ(n, sizeof(value));
573 EXPECT_EQ(value, expected);
574 close(testFd);
575 }, {}, {}, ffrt::task_attr().qos(ffrt_qos_user_initiated));
576
577 stall_us(200);
578 // write value to trigger poller mask
579 uint8_t startCnt = ffrt_epoll_get_count(ffrt_qos_user_initiated);
580 uint64_t u1 = 1;
581 ssize_t n = write(testFd, &u1, sizeof(uint64_t));
582 uint64_t u2 = 2;
583 n = write(testFd, &u2, sizeof(uint64_t));
584 EXPECT_EQ(n, sizeof(uint64_t));
585 ffrt::wait();
586 uint8_t endCnt = ffrt_epoll_get_count(ffrt_qos_user_initiated);
587 auto wakeCnt = endCnt - startCnt;
588 EXPECT_TRUE(wakeCnt < 10);
589 }
590
591 HWTEST_F(ffrtIoTest, ffrt_epoll_wait_test_legacy_mode, TestSize.Level0)
592 {
593 uint64_t expected = 0x3;
594 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
595 int op = EPOLL_CTL_ADD;
596 ffrt_qos_t qos = ffrt_qos_user_initiated;
597
598 struct TestData testLegacyData {.fd = testFd, .expected = expected};
__anon725558aa3002() 599 ffrt::submit([=]() {
600 ffrt_this_task_set_legacy_mode(true);
601 int ret = ffrt_epoll_ctl(qos, op, testFd, EPOLLIN, nullptr, nullptr);
602 EXPECT_EQ(ret, 0);
603 // sleep to wait event
604 ffrt_usleep(50000);
605 // get fds
606 struct epoll_event events[1024];
607 int nfds = ffrt_epoll_wait(qos, events, 1024, -1);
608 EXPECT_EQ(nfds, 1);
609 ret = ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
610 EXPECT_EQ(ret, 0);
611 // read vaule from fd and check
612 uint64_t value = 0;
613 ssize_t n = read(testFd, &value, sizeof(uint64_t));
614 EXPECT_EQ(n, sizeof(value));
615 EXPECT_EQ(value, expected);
616 close(testFd);
617 ffrt_this_task_set_legacy_mode(false);
618 }, {}, {}, ffrt::task_attr().qos(ffrt_qos_user_initiated));
619
620 stall_us(200);
621 // write value to trigger poller mask
622 uint8_t startCnt = ffrt_epoll_get_count(ffrt_qos_user_initiated);
623 uint64_t u1 = 1;
624 ssize_t n = write(testFd, &u1, sizeof(uint64_t));
625 uint64_t u2 = 2;
626 n = write(testFd, &u2, sizeof(uint64_t));
627 EXPECT_EQ(n, sizeof(uint64_t));
628 ffrt::wait();
629 uint8_t endCnt = ffrt_epoll_get_count(ffrt_qos_user_initiated);
630 auto wakeCnt = endCnt - startCnt;
631 EXPECT_TRUE(wakeCnt < 10);
632 }
633