From 810c5daa27272923fa1df786f5835077a60fcd74 Mon Sep 17 00:00:00 2001 From: Wang Jingjin Date: Mon, 21 Nov 2022 16:59:57 +0800 Subject: [PATCH] Add unitest for sched rtg Signed-off-by: Wang Jingjin Change-Id: Iec10385ca685cc5016d7d9c9016d5323b75b0243 --- test/unittest/rtg/rtg_test.cpp | 507 ++++++++++++++++++++++++++++++++- 1 file changed, 504 insertions(+), 3 deletions(-) diff --git a/test/unittest/rtg/rtg_test.cpp b/test/unittest/rtg/rtg_test.cpp index ad78f1e..4fda2e9 100644 --- a/test/unittest/rtg/rtg_test.cpp +++ b/test/unittest/rtg/rtg_test.cpp @@ -35,8 +35,8 @@ using namespace testing::ext; using namespace std; -// constexpr size_t MAX_LENGTH = 100; -// constexpr size_t MAX_STR_LEN = 100; +constexpr size_t MAX_LENGTH = 100; +constexpr size_t MAX_STR_LEN = 100; const char RTG_SCHED_IPC_MAGIC = 0xAB; const int RTG_ERR = -1; const int RTG_SUCC = 0; @@ -49,6 +49,23 @@ const int MULTI_FRAME_NUM = 5; _IOWR(RTG_SCHED_IPC_MAGIC, SET_RTG, struct rtg_str_data) #define CMD_ID_BEGIN_FRAME_FREQ \ _IOWR(RTG_SCHED_IPC_MAGIC, BEGIN_FRAME_FREQ, struct proc_state_data) +#define CMD_ID_END_FRAME_FREQ \ + _IOWR(RTG_SCHED_IPC_MAGIC, END_FRAME_FREQ, struct proc_state_data) +#define CMD_ID_END_SCENE \ + _IOWR(RTG_SCHED_IPC_MAGIC, END_SCENE, struct proc_state_data) +#define CMD_ID_SET_MIN_UTIL \ + _IOWR(RTG_SCHED_IPC_MAGIC, SET_MIN_UTIL, struct proc_state_data) +#define CMD_ID_SET_MARGIN \ + _IOWR(RTG_SCHED_IPC_MAGIC, SET_MARGIN, struct proc_state_data) +#define CMD_ID_LIST_RTG_THREAD \ + _IOWR(RTG_SCHED_IPC_MAGIC, LIST_RTG_THREAD, struct rtg_grp_data) +#define CMD_ID_LIST_RTG \ + _IOWR(RTG_SCHED_IPC_MAGIC, LIST_RTG, struct rtg_info) +#define CMD_ID_SET_RTG_ATTR \ + _IOWR(RTG_SCHED_IPC_MAGIC, SET_RTG_ATTR, struct rtg_str_data) +#define CMD_ID_SET_CONFIG \ + _IOWR(RTG_SCHED_IPC_MAGIC, SET_CONFIG, struct rtg_str_data) + struct rtg_enable_data { int enable; int len; @@ -230,7 +247,6 @@ static int BeginFrameFreq(int grpId, int stateParam) struct proc_state_data state_data; state_data.grp_id = grpId; state_data.state_param = stateParam; - int fd = BasicOpenRtgNode(); if (fd < 0) { return fd; @@ -241,6 +257,177 @@ static int BeginFrameFreq(int grpId, int stateParam) return ret; } +static int EndFrameFreq(int grpId) +{ + int ret = 0; + struct proc_state_data state_data; + state_data.grp_id = grpId; + state_data.state_param = 0; + int fd = BasicOpenRtgNode(); + if (fd < 0) { + return fd; + } + ret = ioctl(fd, CMD_ID_END_FRAME_FREQ, &state_data); + + close(fd); + return ret; +} + +static int EndScene(int grpId) +{ + int ret = 0; + struct proc_state_data state_data; + state_data.grp_id = grpId; + + int fd = BasicOpenRtgNode(); + if (fd < 0) { + return fd; + } + ret = ioctl(fd, CMD_ID_END_SCENE, &state_data); + + close(fd); + return ret; +} + +static int SetStateParam(unsigned int cmd, int grpId, int stateParam) +{ + int ret = 0; + struct proc_state_data state_data; + state_data.grp_id = grpId; + state_data.state_param = stateParam; + + int fd = BasicOpenRtgNode(); + if (fd < 0) { + return fd; + } + ret = ioctl(fd, cmd, &state_data); + + close(fd); + return ret; +} + + +static int ListRtgThread(int grpId, vector *rs) +{ + int ret = 0; + struct rtg_grp_data grp_data; + int fd = BasicOpenRtgNode(); + if (fd < 0) { + return fd; + } + if (!rs) { + return RTG_ERR; + } + (void)memset_s(&grp_data, sizeof(struct rtg_grp_data), 0, sizeof(struct rtg_grp_data)); + grp_data.grp_id = grpId; + ret = ioctl(fd, CMD_ID_LIST_RTG_THREAD, &grp_data); + if (ret < 0) { + return ret; + } else { + rs->clear(); + for (int i = 0; i < grp_data.tid_num; i++) { + rs->push_back(grp_data.tids[i]); + } + } + + close(fd); + return ret; +} + +static int ListRtgGroup(vector *rs) +{ + int ret = 0; + struct rtg_info rtg_info; + int fd = BasicOpenRtgNode(); + if (fd < 0) { + return fd; + } + if (!rs) { + return RTG_ERR; + } + (void)memset_s(&rtg_info, sizeof(struct rtg_info), 0, sizeof(struct rtg_info)); + ret = ioctl(fd, CMD_ID_LIST_RTG, &rtg_info); + if (ret < 0) { + return ret; + } else { + rs->clear(); + for (int i = 0; i < rtg_info.rtg_num; i++) { + rs->push_back(rtg_info.rtgs[i]); + } + } + + close(fd); + return ret; +} + +static int SetFrameRateAndPrioType(int rtgId, int rate, int rtgType) +{ + int ret = 0; + char str_data[MAX_LENGTH] = {}; + (void)sprintf_s(str_data, sizeof(str_data), "rtgId:%d;rate:%d;type:%d", rtgId, rate, rtgType); + struct rtg_str_data strData; + strData.len = strlen(str_data); + strData.data = str_data; + + int fd = BasicOpenRtgNode(); + if (fd < 0) { + return fd; + } + ret = ioctl(fd, CMD_ID_SET_RTG_ATTR, &strData); + + close(fd); + return ret; +} + +static int SetMaxVipRtgs(int rtframe) +{ + int ret = 0; + char str_data[MAX_STR_LEN] = {}; + (void)sprintf_s(str_data, sizeof(str_data), "rtframe:%d", rtframe); + struct rtg_str_data strData; + strData.len = strlen(str_data); + strData.data = str_data; + + int fd = BasicOpenRtgNode(); + if (fd < 0) { + return fd; + } + ret = ioctl(fd, CMD_ID_SET_CONFIG, &strData); + + close(fd); + return ret; +} + +static int AddThreadsToRtg(vector tids, int grpId, int prioType) +{ + struct rtg_grp_data grp_data; + int ret; + int fd = BasicOpenRtgNode(); + + if (fd < 0) { + return fd; + } + (void)memset_s(&grp_data, sizeof(struct rtg_grp_data), 0, sizeof(struct rtg_grp_data)); + int num = static_cast(tids.size()); + if (num > MAX_TID_NUM) { + return -1; + } + grp_data.tid_num = num; + grp_data.grp_id = grpId; + grp_data.rtg_cmd = CMD_ADD_RTG_THREAD; + grp_data.prio_type = prioType; + for (int i = 0; i < num; i++) { + if (tids[i] < 0) { + return -1; + } + grp_data.tids[i] = tids[i]; + } + ret = ioctl(fd, CMD_ID_SET_RTG, &grp_data); + + close(fd); + return ret; +} + void RtgTest::SetUp() { // must enable rtg before use the interface int ret = EnableRtg(true); @@ -410,3 +597,317 @@ HWTEST_F(RtgTest, begainFrameFreqFail, Function | MediumTest | Level1) ret = BeginFrameFreq(-1, 0); ASSERT_NE(ret, RTG_SUCC); } + +/** + * @tc.name: endFrameFreqSucc + * @tc.desc: Verify rtg frame end function. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, endFrameFreqSucc, Function | MediumTest | Level1) +{ + int ret; + int grpId; + + grpId = CreateNewRtgGrp(VIP, 0); + ASSERT_GT(grpId, 0); + ret = EndFrameFreq(grpId); + ASSERT_EQ(ret, RTG_SUCC); + ret = DestroyRtgGrp(grpId); + ASSERT_EQ(ret, RTG_SUCC); +} + +/** + * @tc.name: endFrameFreqFail + * @tc.desc: Verify rtg frame end function with error param. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, endFrameFreqFail, Function | MediumTest | Level1) +{ + int ret; + ret = EndFrameFreq(-1); + ASSERT_NE(ret, RTG_SUCC); +} + +/** + * @tc.name: endSceneSucc + * @tc.desc: Verify scene end function. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, endSceneSucc, Function | MediumTest | Level1) +{ + int ret; + int grpId; + + grpId = CreateNewRtgGrp(VIP, 0); + ASSERT_GT(grpId, 0); + ret = EndScene(grpId); + ASSERT_EQ(ret, RTG_SUCC); + ret = DestroyRtgGrp(grpId); + ASSERT_EQ(ret, RTG_SUCC); +} + +/** + * @tc.name: endSceneFail + * @tc.desc: Verify scene end function. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, endSceneFail, Function | MediumTest | Level1) +{ + int ret; + + ret = EndScene(-1); + ASSERT_NE(ret, RTG_SUCC); +} + +/** + * @tc.name: setMinUtilSucc + * @tc.desc: Verify set min util function. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, setMinUtilSucc, Function | MediumTest | Level1) +{ + int ret; + int grpId; + + grpId = CreateNewRtgGrp(VIP, 0); + ASSERT_GT(grpId, 0); + ret = SetStateParam(CMD_ID_SET_MIN_UTIL, grpId, 0); + ASSERT_EQ(ret, RTG_SUCC); + ret = DestroyRtgGrp(grpId); + ASSERT_EQ(ret, RTG_SUCC); +} + +/** + * @tc.name: setMinUtilFail + * @tc.desc: Verify set min util function with Error Param. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, setMinUtilFail, Function | MediumTest | Level1) +{ + int ret; + + ret = SetStateParam(CMD_ID_SET_MIN_UTIL, -1, 0); + ASSERT_NE(ret, RTG_SUCC); +} + +/** + * @tc.name: setMarginSucc + * @tc.desc: Verify set min margin function. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, setMarginSucc, Function | MediumTest | Level1) +{ + int ret; + int grpId; + + grpId = CreateNewRtgGrp(VIP, 0); + ASSERT_GT(grpId, 0); + ret = SetStateParam(CMD_ID_SET_MARGIN, grpId, 0); + ASSERT_EQ(ret, RTG_SUCC); + ret = DestroyRtgGrp(grpId); + ASSERT_EQ(ret, RTG_SUCC); +} + +/** + * @tc.name: setMarginFail + * @tc.desc: Verify set min margin function with error param. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, setMarginFail, Function | MediumTest | Level1) +{ + int ret; + + ret = SetStateParam(CMD_ID_SET_MARGIN, -1, 0); + ASSERT_NE(ret, RTG_SUCC); +} + +/** + * @tc.name: listRtgThreadSucc + * @tc.desc: Verify list rtg thread function. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, ListRtgThreadSucc, Function | MediumTest | Level1) +{ + int ret; + int grpId; + vector rs; + + grpId = CreateNewRtgGrp(VIP, 0); + ASSERT_GT(grpId, 0); + ret = ListRtgThread(grpId, &rs); + ASSERT_EQ(ret, 0); + ret = DestroyRtgGrp(grpId); + ASSERT_EQ(ret, 0); +} + +/** + * @tc.name: listRtgThreadFail + * @tc.desc: Verify list rtg thread function with null vector input. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, ListRtgThreadFail, Function | MediumTest | Level1) +{ + int ret; + int grpId; + vector rs; + + grpId = CreateNewRtgGrp(VIP, 0); + ASSERT_GT(grpId, 0); + ret = ListRtgThread(grpId, nullptr); + ASSERT_NE(ret, RTG_SUCC); + ret = ListRtgThread(-1, &rs); + ASSERT_NE(ret, RTG_SUCC); + ret = DestroyRtgGrp(grpId); + ASSERT_EQ(ret, RTG_SUCC); +} + +/** + * @tc.name: listRtgSucc + * @tc.desc: Verify list rtg function. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, ListRtgSucc, Function | MediumTest | Level1) +{ + int ret; + vector rs; + + ret = ListRtgGroup(&rs); + ASSERT_EQ(ret, RTG_SUCC); +} + +/** + * @tc.name: listRtgFail + * @tc.desc: Verify list rtg function with error param. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, ListRtgFail, Function | MediumTest | Level1) +{ + int ret; + + ret = ListRtgGroup(nullptr); + ASSERT_NE(ret, RTG_SUCC); +} + +/** + * @tc.name: SetRtgAttrSucc + * @tc.desc: Verify rtg attr set function. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, SetRtgAttrSucc, Function | MediumTest | Level1) +{ + int ret; + int grpId; + + grpId = CreateNewRtgGrp(VIP, 0); + ASSERT_GT(grpId, 0); + ret = SetFrameRateAndPrioType(grpId, 60, VIP); + ASSERT_EQ(ret, RTG_SUCC); + ret = DestroyRtgGrp(grpId); + ASSERT_EQ(ret, RTG_SUCC); +} + +/** + * @tc.name: SetRtgAttrFail + * @tc.desc: Verify rtg attr set function with error param. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, SetRtgAttrFail, Function | MediumTest | Level1) +{ + int ret; + int grpId; + grpId = CreateNewRtgGrp(VIP, 0); + ASSERT_GT(grpId, 0); + ret = SetFrameRateAndPrioType(grpId, 90, -1); + ASSERT_NE(ret, RTG_SUCC); + ret = DestroyRtgGrp(grpId); + ASSERT_EQ(ret, RTG_SUCC); +} + +/** + * @tc.name: SetMaxVipRtgSucc + * @tc.desc: Verify rtg max vip num set function. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, SetMaxVipRtgSucc, Function | MediumTest | Level1) +{ + int ret; + + ret = SetMaxVipRtgs(2); + ASSERT_EQ(ret, RTG_SUCC); +} + +/** + * @tc.name: SetMaxVipRtgFail + * @tc.desc: Verify rtg max vip num set function with error param. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, SetMaxVipRtgFail, Function | MediumTest | Level1) +{ + int ret; + + // set 0 vip num + ret = SetMaxVipRtgs(0); + ASSERT_NE(ret, RTG_SUCC); + + // set large vip num + ret = SetMaxVipRtgs(50000); + ASSERT_NE(ret, RTG_SUCC); +} + +/** + * @tc.name: RtgAddMutipleThreadsSucc + * @tc.desc: Verify rtg multiple add function. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, RtgAddMutipleThreadsSucc, Function | MediumTest | Level1) +{ + int ret; + int pid[3]; + vector threads; + int grpId; + + for (int i = 0; i < 3; i++) { + pid[i] = fork(); + ASSERT_TRUE(pid[i] >= 0) << "> parent: fork errno = " << errno; + if (pid[i] == 0) { + usleep(50000); + _Exit(0); + } + threads.push_back(pid[i]); + } + grpId = CreateNewRtgGrp(NORMAL_TASK, 0); + ASSERT_GT(grpId, 0); + ret = AddThreadsToRtg(threads, grpId, NORMAL_TASK); + ASSERT_EQ(ret, RTG_SUCC); + ret = DestroyRtgGrp(grpId); + ASSERT_EQ(ret, RTG_SUCC); +} + +/** + * @tc.name: RtgAddMutipleThreadsOutOfLimit + * @tc.desc: Verify rtg multiple add function with out of limit threads. + * @tc.type: FUNC + */ +HWTEST_F(RtgTest, RtgAddMutipleThreadsOutOfLimit, Function | MediumTest | Level1) +{ + int ret; + int pid[8]; + vector threads; + int grpId; + + for (int i = 0; i < 8; i++) { + pid[i] = fork(); + ASSERT_TRUE(pid[i] >= 0) << "> parent: fork errno = " << errno; + if (pid[i] == 0) { + usleep(50000); + _Exit(0); + } + threads.push_back(pid[i]); + } + grpId = CreateNewRtgGrp(NORMAL_TASK, 0); + ASSERT_GT(grpId, 0); + ret = AddThreadsToRtg(threads, grpId, NORMAL_TASK); + ASSERT_NE(ret, RTG_SUCC); + ret = DestroyRtgGrp(grpId); + ASSERT_EQ(ret, RTG_SUCC); +} -- Gitee