From patchwork Fri Dec 7 15:56:42 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Chunming Zhou X-Patchwork-Id: 10718461 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 1C16915A6 for ; Fri, 7 Dec 2018 15:57:31 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 0A8522DADC for ; Fri, 7 Dec 2018 15:57:31 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id F2AAD2E5F6; Fri, 7 Dec 2018 15:57:30 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-5.2 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_MED autolearn=unavailable version=3.3.1 Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher DHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 4F23F2DADC for ; Fri, 7 Dec 2018 15:57:30 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 76FC76E7FE; Fri, 7 Dec 2018 15:57:28 +0000 (UTC) X-Original-To: intel-gfx@lists.freedesktop.org Delivered-To: intel-gfx@lists.freedesktop.org Received: from NAM01-BY2-obe.outbound.protection.outlook.com (mail-eopbgr810075.outbound.protection.outlook.com [40.107.81.75]) by gabe.freedesktop.org (Postfix) with ESMTPS id D3A026E7F7; Fri, 7 Dec 2018 15:57:26 +0000 (UTC) Received: from DM5PR12CA0014.namprd12.prod.outlook.com (2603:10b6:4:1::24) by BN4PR12MB0834.namprd12.prod.outlook.com (2a01:111:e400:59bd::28) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1404.22; Fri, 7 Dec 2018 15:57:24 +0000 Received: from DM3NAM03FT024.eop-NAM03.prod.protection.outlook.com (2a01:111:f400:7e49::206) by DM5PR12CA0014.outlook.office365.com (2603:10b6:4:1::24) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384) id 15.20.1404.19 via Frontend Transport; Fri, 7 Dec 2018 15:57:24 +0000 Received-SPF: None (protection.outlook.com: amd.com does not designate permitted sender hosts) Received: from SATLEXCHOV02.amd.com (165.204.84.17) by DM3NAM03FT024.mail.protection.outlook.com (10.152.82.182) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384) id 15.20.1404.17 via Frontend Transport; Fri, 7 Dec 2018 15:57:23 +0000 Received: from zhoucm1.amd.com (10.34.1.3) by SATLEXCHOV02.amd.com (10.181.40.72) with Microsoft SMTP Server id 14.3.389.1; Fri, 7 Dec 2018 09:57:22 -0600 From: Chunming Zhou To: , , , Date: Fri, 7 Dec 2018 23:56:42 +0800 Message-ID: <20181207155642.16063-7-david1.zhou@amd.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20181207155642.16063-1-david1.zhou@amd.com> References: <20181207155642.16063-1-david1.zhou@amd.com> MIME-Version: 1.0 X-EOPAttributedMessage: 0 X-MS-Office365-Filtering-HT: Tenant X-Forefront-Antispam-Report: CIP:165.204.84.17; IPV:NLI; CTRY:US; EFV:NLI; SFV:NSPM; SFS:(10009020)(396003)(39860400002)(346002)(376002)(136003)(2980300002)(428003)(189003)(199004)(104016004)(575784001)(86362001)(110136005)(54906003)(8676002)(81166006)(77096007)(6666004)(356004)(26005)(50226002)(66574011)(14444005)(8936002)(2201001)(446003)(336012)(11346002)(186003)(486006)(2616005)(476003)(126002)(81156014)(426003)(4744004)(72206003)(450100002)(53416004)(478600001)(2906002)(50466002)(4326008)(76176011)(305945005)(5660300001)(23676004)(36756003)(7696005)(316002)(53936002)(68736007)(106466001)(5820100001)(2870700001)(97736004)(1076002)(105586002)(47776003); DIR:OUT; SFP:1101; SCL:1; SRVR:BN4PR12MB0834; H:SATLEXCHOV02.amd.com; FPR:; SPF:None; LANG:en; PTR:InfoDomainNonexistent; MX:1; A:1; X-Microsoft-Exchange-Diagnostics: 1; DM3NAM03FT024; 1:TY4rN93cZUEXwsQ2BiSLGoM0Joc7ioFAY+/tQyGIbkF1KU8XTr2R9Wi7SY+sZYIWBCt+hLarCQ5rhijPaJcFqDOBWFaymQavONUVxtIVIcl6LJ4BHKYaeQwjIxqnZagM X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: cd4e0169-2c4c-4c0c-577c-08d65c5cada6 X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(2390098)(7020095)(4652040)(8989299)(4534185)(4627221)(201703031133081)(201702281549075)(8990200)(5600074)(711020)(2017052603328)(7153060); SRVR:BN4PR12MB0834; X-Microsoft-Exchange-Diagnostics: 1; BN4PR12MB0834; 3:7QLhZIQNhJABphddwf9vn9wKRTcFBqMBHiAgNNrNxH8I6OM3FQCZSSrUkJeTznN0xTZT4cpOFpJ/EgRMEuckLmO7URpYQHudi8ldghvCXIEGbC3pKhWUbQLjPwXbXQltCIn8zMUWm06z93FgBESMX1Y0w69RjT6ChQVpTLctmasVGio/qdzw5yaaQsOzJay98tTzTwxP9FypMXJJfxzo+6JCncDgsVGHllYdHAKabKvfBv3lQOPuB5HMPPr2O934wToY65pO3FqMeMeM96ItCn5w7nJ4x0SlJwQlcCIeemCl+L7v+pXt4gZ77xYWyD/WVzJWjdydmqZ5rE1orp5TrthSooCSozsIQfIEzdf4nVw=; 25:nEGGH/6fCZFEXE2GvCNMneZdKvK9sFAVNFqYCRNfkP8BsoH20NeLMiK9bTNMuqYO08rLgEgXPW+HwCC6l9ZybR+76oOZw0vn4DmHEEgU3EVXc0Cbf4kylCOQu/DxCl3GlazE7puE6Qr9iFG3KfS9UrcQ48KtMQUQoJEe8pXLFUFG3P0CE0halgFeLDN2SOqwGfKLfU/a1CfAYhRJShu8y886LTOrvimTQuahuzC3d1EMVJHPpuKloBeSy/D7uA12nAaPWg6PID6eKbBKdRhj2mdaN6S6eRHNMuHGJrwjKGkP3J6pQ6tKNooFuYuN8O2hA8ttFLyGiajSzEWs5hrOcA== X-MS-TrafficTypeDiagnostic: BN4PR12MB0834: X-Microsoft-Exchange-Diagnostics: 1; BN4PR12MB0834; 31:ZHI71E1qz+1faH5AceDj5+c3NYd6ABuYuRpIkbua74gt8wJc+RxL5evqYfP4NLkDBzonl/H7PDh1pEYU2MsljFCgEHm8jpTvEE1IrFEJ58W7X7y11oq+nFQgfK2aBN6zYiaKSPdUl42wUW/92V/0gz1Gtjej+UaZfM3nExQM5hB68dKDdSTjQKBInDgIkdbg+qJyhD9FwGxyx1MiUz7E1f/mjz80u69fCBwGx61bk7U=; 20:shWv0ZfxE50uF1nSfAPIdQkRurQaA2ZUKUeRGL1JYLDODWsuEFMcU9EK2Y4G3WnB3JTDRYCi2/Uu5wmL8sGsZ2mS4RwQTDRvBIjatWbAG0y5G++ZVUOIURWtiZaIg0/kZfCHTAHu4j3n7GcPy9I8f4X6IyjDVXR8ZCzYG55Z7vJD/iwtryhqQ+wG8oNirGlNJqfe5r/t9L8XMpeqdZtBlxUPu/GxdHsdPHud+TX31WtBPO+4gD7KPkI19xx1yFstaeEZsMW4wDuJA9GjeoeHjiEWTZGElKv/DoeDisW1b3+1FCN4S1ufFrHaaow03APWAIV5/N80r4QNj0Ac20iydDuKDOqullUjLJ33HWL6aDkwuxYzmXflrXz4PURIgFg4ySgxnkqlVz40OmEEK7IbIblBv1ckv2wm4vSQYh4wdjThbTKCDI6gcBHz6/SOBa7SRWTeRtvgZdaoyibxQr1bOS7FmhZwNCnIDMxHjZOBbca1OyDTDwle3TVURD/7BLQk X-Microsoft-Antispam-PRVS: X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(3231455)(999002)(944501520)(52105112)(93006095)(93003095)(3002001)(10201501046)(6055026)(148016)(149066)(150057)(6041310)(20161123564045)(20161123560045)(20161123558120)(20161123562045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(201708071742011)(7699051)(76991095); SRVR:BN4PR12MB0834; BCL:0; PCL:0; RULEID:; SRVR:BN4PR12MB0834; X-Microsoft-Exchange-Diagnostics: 1; BN4PR12MB0834; 4:v91sSshCEboWKUq8PJFfuAJQLGeCcbe9y0gmrjtvCnz38v64YsK5nA97DS/DYaYXZTMqb0m2Ba+Dc0c52wks20cKz4/eUtDJgUiwBgjkPQLwpxLRy6yP5KtJjIHYw/7DV6LGyMLJAQAyt4R1c8qnCu9HX6C5o97owqR91uVpgb2+ekCMMKlCgxM2FIhBKBare/39Dqe4PmZ5BpE0llAK3UdejHkHNc/SqO8GcycYek5GIH3PWSLiLE9vPfyJ/v0UZnsFt/paDn7C6YyYppe6tw== X-Forefront-PRVS: 0879599414 X-Microsoft-Exchange-Diagnostics: =?utf-8?q?1=3BBN4PR12MB0834=3B23=3AUKn60E6?= =?utf-8?q?plemuS0Xxxn3R3CUC2bh98pxjrvBMFdsX2iek+0GmY+VZs9NdEbSFzXxzMBgeUK4Q?= =?utf-8?q?7rWblbeYWRhehFE4UC8F+/V/qFXxeezCmeZypIeTl0U3pI62vZDdemhxNc4ygzRDb?= =?utf-8?q?ChQELZn2r0+KTHkNaVWy0FdGB6tjPtRSEMaurzzUTyp9/0JEqwTCBRA2MjBwYXIUS?= =?utf-8?q?vhZcd+4Cpm6ppiVPF9L4Lg4ckNv7RGDsE6q8J7JzfrNW5H6KP4TT5eAd34r70+A9m?= =?utf-8?q?XKfL3iuVvwOhGGsZ67bcLQNhTWwBtIC1GzW+pcblMF+aI41UdNhquMC9JsT4Tywjb?= =?utf-8?q?KBKLL+luSZFmiFLKujD8hecc4FcVyJHWb4OJboa0ERM2vqajotl0DctkX/UTRfsn1?= =?utf-8?q?6SBhyFRvwUsL5o7locttgPqQX8r5fAicXJt7I6ZdkQsSBmi4PI5dQmaUCfMHWvSMV?= =?utf-8?q?JQQ/pZnWK/Y5MtRUti755EWB7RW76vWAw5o9lOH6IcCk0nM5PU4Q+GIJP4ua5TEyy?= =?utf-8?q?VP0PUjQQRXkkzELI+2jvfpniBKi2JNb+PsiWslppWVHmsz6f1CKkx+PRdBIAPJjL7?= =?utf-8?q?h4DylDhU5D+wvxxZKvw7gZW+eaZ0oSVbCEGg3WOV0Ua4Sl4pXic1ARiszYBy6A3dD?= =?utf-8?q?OsYWTg7nlvgJ1cBHn9V/g8/v2s2J8QhUEqT82W/IFu4XvMzroXP5+N5v6ebEIvoFY?= =?utf-8?q?NhwGw/VeHqdFnslCkzjYGIhbF6EaVp9Ki/UkBTmBIoJPQLY8yFAM7Bx7/KeuRytsa?= =?utf-8?q?MLgm0WRlOoWlEF4wuYALILwdJIXW6pFve+qEhp23O8F92t0Q8DZH6Vq2VwJ1rcXXi?= =?utf-8?q?TgCn3cdKmKCE3FRcJ50B2NRAgGd4a9Hf70mUGEKUWBcfp9NEEyxLscJObnICuMF79?= =?utf-8?q?BVvjtpGkMYZAyl8qNDj+Oz8jQqyeZkl74DADJaYACGzqHy5v97i6iyYLiPBETet6k?= =?utf-8?q?e4FqZJ7+zK9oLCsP7vsaQ1xGopv0fpqFYdbeLEg0L8NkDJLW5xHubBlOkEW/5n/Px?= =?utf-8?q?HEca/Gb1LKcnzG53SWQBWNnAF4Bbj5LRlwx+BE9xxNQ5an89QGwsHSJgN2bSYR2gD?= =?utf-8?q?d7xAahpg6AiaqmDZdBWHdPYPfq+YkyFr8y3Tu0cJyojRc1y6mFeOD7xNXnNry7pNv?= =?utf-8?q?3QxMkRQaoCgAeOmsBi73kDpATPSk8WI4SIp71hkuVmg7oDQ/JqKHVPuxbn1vEa5p/?= =?utf-8?q?0nkHVfBmXlgIeN2RbJ9LqpUIm98Q6qixDVg5ZzI3wLcScZpeVENBIwgi26r/cTphP?= =?utf-8?q?PiejnBLdvnHuT38o=3D?= X-Microsoft-Antispam-Message-Info: DJEvBVHS3hSD1siv1mLo0NT1cIrGmxBu1XzLXvX53IhcjvNnb55qO2jSu1vRpj1MD0WCQj9Ban1uX+ARFeCiMk1Y6g9LQkDLI8J9gTfCGdYFSqvih92Lbe5E3xGsVtljj0SI59Ytp9f3KlIGCzSrhAXtlr77ewZW+qtzFwqL+nUCSKX+E5TIwMY80NpuZTXGOwxjlepqm+9E05gk07iFdw/O/qqarjaxYdmmJNYtTJsM4cQ4UnJYcP/+xHe7Wc2dXEjBZknh0tFJumuZf/KfwtWZjxxzEecmqnDyxx+H7XmY0SmM4QbLmf5x/MhpcgRVCvEGm+kZbwUs6cFQ9/C4+Kt0wvuIvY9VSqo7C2eCCcM= X-Microsoft-Exchange-Diagnostics: 1; BN4PR12MB0834; 6:sschyxKihyO2EbRsA5zxg9PW5SXcJBXxydYU43Unf7GhwO02dSp3iHJHKHrysiS58dWROu/9tgNLdl4UglO/A/PItTJfRBFf+C0Ae/6cAEn3YiX45hv94xor8EvVyWD8XdfGSJ/GfpdMtgRazu/bSgU8YggO8DOAVkCQ0cERUvnc1SrnRWU8z1foRS0jHZ4qv3oODD6Oz5ESBPi63IXIJ79q25doyq7Qx7J+lF2McEVhWedzrhUD2lMasnP+BKj7dKGXl7B+TsYAeKjBO+yz5pxhcFjx7uDkjbd9R51dadBoZi5CiSKv8ujzNVegNqBh2C/Z1od8fvXqlV+B0bydJj8pF9G3Ylp0Sz7qiKCocZXDe8e6dSrw/Cmo1TkH4wYSzCDoDESqu2eJJ4jeKEE2uZXJpjjmEG29fW630z05SUBujnuIIaS6Mnr+7VrIub7Z2gj4DVvyFZnpgujF4OPrww==; 5:NQ0ev3NpK9NlldWLu7CSCF+3slqMetk0tIbaTST2IMkG2cyw5D76lLYBsTCDwBUaHtk3r+WjNp7Ylia8RedfZ4C2SKi70yEruyBXzQ99gKs3CPf22prLVWE7Tt4MZy+G11nZ1ugWWtSG6zqxLUivG6HduNyqZkfco3nwz1cLoLw=; 7:XT87A+M7bX4wnzasngukrHXN9oz9zDbqQ0iCaS4gzExmmBvzmknGq1ualoGRgCD+n8MFhMBwrSTvB0G2sTIhLRwmlIpjk4EZpG0uk/Bww+xRf+y5itLIRxce1XzUJMYwJRxNe6svVOIOA3bfgi6LQQ== SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; BN4PR12MB0834; 20:3+SUAF+18VQmV2k0tSs/ma3s2Xp4cloyA2NhqBi+T7fIcdK1GI1MZBvp5gaNXdd0Jw+Miw6BwdIxdokz3X3PFOwuQII8+SshB3sxb9eVGsdBFvZWcFVeERDNbJEdx18XiL/CJ48uaOqT5okmCN3bXYyr6K4t40Sj1OYbS7brVTh0uO+fIklH8pVl95sUDkCRJBaLwwki2WJxUPrRHgGXQOq6CoOwU2rGFqQ4cRTzq2OlS0/Eu40GrkQV3Rqt/pFc X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 07 Dec 2018 15:57:23.6172 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: cd4e0169-2c4c-4c0c-577c-08d65c5cada6 X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=3dd8961f-e488-4e60-8e11-a82d994e183d; Ip=[165.204.84.17]; Helo=[SATLEXCHOV02.amd.com] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BN4PR12MB0834 Subject: [Intel-gfx] [PATCH libdrm 7/7] add syncobj timeline tests v3 X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Chunming Zhou , =?utf-8?q?Christian_K=C3=B6nig?= Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" X-Virus-Scanned: ClamAV using ClamSMTP v2: drop DRM_SYNCOBJ_CREATE_TYPE_TIMELINE, fix timeout calculation, fix some warnings v3: add export/import and cpu signal testing cases Signed-off-by: Chunming Zhou Signed-off-by: Christian König --- tests/amdgpu/Makefile.am | 3 +- tests/amdgpu/amdgpu_test.c | 12 ++ tests/amdgpu/amdgpu_test.h | 21 +++ tests/amdgpu/meson.build | 2 +- tests/amdgpu/syncobj_tests.c | 290 +++++++++++++++++++++++++++++++++++ 5 files changed, 326 insertions(+), 2 deletions(-) create mode 100644 tests/amdgpu/syncobj_tests.c diff --git a/tests/amdgpu/Makefile.am b/tests/amdgpu/Makefile.am index 447ff217..d3fbe2bb 100644 --- a/tests/amdgpu/Makefile.am +++ b/tests/amdgpu/Makefile.am @@ -33,4 +33,5 @@ amdgpu_test_SOURCES = \ vcn_tests.c \ uve_ib.h \ deadlock_tests.c \ - vm_tests.c + vm_tests.c \ + syncobj_tests.c diff --git a/tests/amdgpu/amdgpu_test.c b/tests/amdgpu/amdgpu_test.c index ebf44098..ff1448f3 100644 --- a/tests/amdgpu/amdgpu_test.c +++ b/tests/amdgpu/amdgpu_test.c @@ -56,6 +56,7 @@ #define UVD_ENC_TESTS_STR "UVD ENC Tests" #define DEADLOCK_TESTS_STR "Deadlock Tests" #define VM_TESTS_STR "VM Tests" +#define SYNCOBJ_TIMELINE_TESTS_STR "SYNCOBJ TIMELINE Tests" /** * Open handles for amdgpu devices @@ -116,6 +117,12 @@ static CU_SuiteInfo suites[] = { .pCleanupFunc = suite_vm_tests_clean, .pTests = vm_tests, }, + { + .pName = SYNCOBJ_TIMELINE_TESTS_STR, + .pInitFunc = suite_syncobj_timeline_tests_init, + .pCleanupFunc = suite_syncobj_timeline_tests_clean, + .pTests = syncobj_timeline_tests, + }, CU_SUITE_INFO_NULL, }; @@ -165,6 +172,11 @@ static Suites_Active_Status suites_active_stat[] = { .pName = VM_TESTS_STR, .pActive = suite_vm_tests_enable, }, + { + .pName = SYNCOBJ_TIMELINE_TESTS_STR, + .pActive = suite_syncobj_timeline_tests_enable, + }, + }; diff --git a/tests/amdgpu/amdgpu_test.h b/tests/amdgpu/amdgpu_test.h index af81eea8..24d64b64 100644 --- a/tests/amdgpu/amdgpu_test.h +++ b/tests/amdgpu/amdgpu_test.h @@ -194,6 +194,27 @@ CU_BOOL suite_vm_tests_enable(void); */ extern CU_TestInfo vm_tests[]; +/** + * Initialize syncobj timeline test suite + */ +int suite_syncobj_timeline_tests_init(); + +/** + * Deinitialize syncobj timeline test suite + */ +int suite_syncobj_timeline_tests_clean(); + +/** + * Decide if the suite is enabled by default or not. + */ +CU_BOOL suite_syncobj_timeline_tests_enable(void); + +/** + * Tests in syncobj timeline test suite + */ +extern CU_TestInfo syncobj_timeline_tests[]; + + /** * Helper functions */ diff --git a/tests/amdgpu/meson.build b/tests/amdgpu/meson.build index 4c1237c6..3ceec715 100644 --- a/tests/amdgpu/meson.build +++ b/tests/amdgpu/meson.build @@ -24,7 +24,7 @@ if dep_cunit.found() files( 'amdgpu_test.c', 'basic_tests.c', 'bo_tests.c', 'cs_tests.c', 'vce_tests.c', 'uvd_enc_tests.c', 'vcn_tests.c', 'deadlock_tests.c', - 'vm_tests.c', + 'vm_tests.c', 'syncobj_tests.c', ), dependencies : [dep_cunit, dep_threads], include_directories : [inc_root, inc_drm, include_directories('../../amdgpu')], diff --git a/tests/amdgpu/syncobj_tests.c b/tests/amdgpu/syncobj_tests.c new file mode 100644 index 00000000..a0c627d7 --- /dev/null +++ b/tests/amdgpu/syncobj_tests.c @@ -0,0 +1,290 @@ +/* + * Copyright 2017 Advanced Micro Devices, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * +*/ + +#include "CUnit/Basic.h" + +#include "amdgpu_test.h" +#include "amdgpu_drm.h" +#include "amdgpu_internal.h" +#include + +static amdgpu_device_handle device_handle; +static uint32_t major_version; +static uint32_t minor_version; + +static void amdgpu_syncobj_timeline_test(void); + +CU_BOOL suite_syncobj_timeline_tests_enable(void) +{ + return CU_TRUE; +} + +int suite_syncobj_timeline_tests_init(void) +{ + int r; + + r = amdgpu_device_initialize(drm_amdgpu[0], &major_version, + &minor_version, &device_handle); + + if (r) { + if ((r == -EACCES) && (errno == EACCES)) + printf("\n\nError:%s. " + "Hint:Try to run this test program as root.", + strerror(errno)); + return CUE_SINIT_FAILED; + } + + return CUE_SUCCESS; +} + +int suite_syncobj_timeline_tests_clean(void) +{ + int r = amdgpu_device_deinitialize(device_handle); + + if (r == 0) + return CUE_SUCCESS; + else + return CUE_SCLEAN_FAILED; +} + + +CU_TestInfo syncobj_timeline_tests[] = { + { "syncobj timeline test", amdgpu_syncobj_timeline_test }, + CU_TEST_INFO_NULL, +}; + +#define GFX_COMPUTE_NOP 0xffff1000 +#define SDMA_NOP 0x0 +static int syncobj_command_submission_helper(uint32_t syncobj_handle, bool + wait_or_signal, uint64_t point) +{ + amdgpu_context_handle context_handle; + amdgpu_bo_handle ib_result_handle; + void *ib_result_cpu; + uint64_t ib_result_mc_address; + struct drm_amdgpu_cs_chunk chunks[2]; + struct drm_amdgpu_cs_chunk_data chunk_data; + struct drm_amdgpu_cs_chunk_syncobj syncobj_data; + struct amdgpu_cs_fence fence_status; + amdgpu_bo_list_handle bo_list; + amdgpu_va_handle va_handle; + uint32_t expired, flags; + int i, r; + uint64_t seq_no; + static uint32_t *ptr; + + r = amdgpu_cs_ctx_create(device_handle, &context_handle); + CU_ASSERT_EQUAL(r, 0); + + r = amdgpu_bo_alloc_and_map(device_handle, 4096, 4096, + AMDGPU_GEM_DOMAIN_GTT, 0, + &ib_result_handle, &ib_result_cpu, + &ib_result_mc_address, &va_handle); + CU_ASSERT_EQUAL(r, 0); + + r = amdgpu_get_bo_list(device_handle, ib_result_handle, NULL, + &bo_list); + CU_ASSERT_EQUAL(r, 0); + + ptr = ib_result_cpu; + + for (i = 0; i < 16; ++i) + ptr[i] = wait_or_signal ? GFX_COMPUTE_NOP: SDMA_NOP; + + chunks[0].chunk_id = AMDGPU_CHUNK_ID_IB; + chunks[0].length_dw = sizeof(struct drm_amdgpu_cs_chunk_ib) / 4; + chunks[0].chunk_data = (uint64_t)(uintptr_t)&chunk_data; + chunk_data.ib_data._pad = 0; + chunk_data.ib_data.va_start = ib_result_mc_address; + chunk_data.ib_data.ib_bytes = 16 * 4; + chunk_data.ib_data.ip_type = wait_or_signal ? AMDGPU_HW_IP_GFX : + AMDGPU_HW_IP_DMA; + chunk_data.ib_data.ip_instance = 0; + chunk_data.ib_data.ring = 0; + chunk_data.ib_data.flags = 0; + + chunks[1].chunk_id = wait_or_signal ? + AMDGPU_CHUNK_ID_SYNCOBJ_TIMELINE_WAIT : + AMDGPU_CHUNK_ID_SYNCOBJ_TIMELINE_SIGNAL; + chunks[1].length_dw = sizeof(struct drm_amdgpu_cs_chunk_syncobj) / 4; + chunks[1].chunk_data = (uint64_t)(uintptr_t)&syncobj_data; + syncobj_data.handle = syncobj_handle; + syncobj_data.point = point; + syncobj_data.flags = DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT; + + r = amdgpu_cs_submit_raw(device_handle, + context_handle, + bo_list, + 2, + chunks, + &seq_no); + CU_ASSERT_EQUAL(r, 0); + + + memset(&fence_status, 0, sizeof(struct amdgpu_cs_fence)); + fence_status.context = context_handle; + fence_status.ip_type = wait_or_signal ? AMDGPU_HW_IP_GFX: + AMDGPU_HW_IP_DMA; + fence_status.ip_instance = 0; + fence_status.ring = 0; + fence_status.fence = seq_no; + + r = amdgpu_cs_query_fence_status(&fence_status, + AMDGPU_TIMEOUT_INFINITE,0, &expired); + CU_ASSERT_EQUAL(r, 0); + + r = amdgpu_bo_list_destroy(bo_list); + CU_ASSERT_EQUAL(r, 0); + + r = amdgpu_bo_unmap_and_free(ib_result_handle, va_handle, + ib_result_mc_address, 4096); + CU_ASSERT_EQUAL(r, 0); + + r = amdgpu_cs_ctx_free(context_handle); + CU_ASSERT_EQUAL(r, 0); + + return r; +} + +struct syncobj_point { + uint32_t syncobj_handle; + uint64_t point; +}; + +static void *syncobj_wait(void *data) +{ + struct syncobj_point *sp = (struct syncobj_point *)data; + int r; + + r = syncobj_command_submission_helper(sp->syncobj_handle, true, + sp->point); + CU_ASSERT_EQUAL(r, 0); + + return (void *)(long)r; +} + +static void *syncobj_signal(void *data) +{ + struct syncobj_point *sp = (struct syncobj_point *)data; + int r; + + r = syncobj_command_submission_helper(sp->syncobj_handle, false, + sp->point); + CU_ASSERT_EQUAL(r, 0); + + return (void *)(long)r; +} + +static void amdgpu_syncobj_timeline_test(void) +{ + static pthread_t wait_thread; + static pthread_t signal_thread; + static pthread_t c_thread; + struct syncobj_point sp1, sp2, sp3; + uint32_t syncobj_handle; + uint64_t payload; + uint64_t wait_point, signal_point; + uint64_t timeout; + struct timespec tp; + int r, sync_fd; + void *tmp; + + r = amdgpu_cs_create_syncobj2(device_handle, 0, &syncobj_handle); + CU_ASSERT_EQUAL(r, 0); + + // wait on point 5 + sp1.syncobj_handle = syncobj_handle; + sp1.point = 5; + r = pthread_create(&wait_thread, NULL, syncobj_wait, &sp1); + CU_ASSERT_EQUAL(r, 0); + + // signal on point 10 + sp2.syncobj_handle = syncobj_handle; + sp2.point = 10; + r = pthread_create(&signal_thread, NULL, syncobj_signal, &sp2); + CU_ASSERT_EQUAL(r, 0); + + r = pthread_join(wait_thread, &tmp); + CU_ASSERT_EQUAL(r, 0); + CU_ASSERT_EQUAL(tmp, 0); + + r = pthread_join(signal_thread, &tmp); + CU_ASSERT_EQUAL(r, 0); + CU_ASSERT_EQUAL(tmp, 0); + + //query timeline payload + r = amdgpu_cs_syncobj_query(device_handle, &syncobj_handle, + &payload, 1); + CU_ASSERT_EQUAL(r, 0); + CU_ASSERT_EQUAL(payload, 10); + + //signal on point 16 + sp3.syncobj_handle = syncobj_handle; + sp3.point = 16; + r = pthread_create(&c_thread, NULL, syncobj_signal, &sp3); + CU_ASSERT_EQUAL(r, 0); + //CPU wait on point 16 + wait_point = 16; + timeout = 0; + clock_gettime(CLOCK_MONOTONIC, &tp); + timeout = tp.tv_sec * 1000000000ULL + tp.tv_nsec; + timeout += 0x10000000000; //10s + r = amdgpu_cs_syncobj_timeline_wait(device_handle, &syncobj_handle, + &wait_point, 1, timeout, + DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL | + DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT, + NULL); + + CU_ASSERT_EQUAL(r, 0); + r = pthread_join(c_thread, &tmp); + CU_ASSERT_EQUAL(r, 0); + CU_ASSERT_EQUAL(tmp, 0); + + // export point 16 and import to point 18 + r = amdgpu_cs_syncobj_export_sync_file2(device_handle, syncobj_handle, + 16, + DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT, + &sync_fd); + CU_ASSERT_EQUAL(r, 0); + r = amdgpu_cs_syncobj_import_sync_file2(device_handle, syncobj_handle, + 18, sync_fd); + CU_ASSERT_EQUAL(r, 0); + r = amdgpu_cs_syncobj_query(device_handle, &syncobj_handle, + &payload, 1); + CU_ASSERT_EQUAL(r, 0); + CU_ASSERT_EQUAL(payload, 18); + + // CPU signal on point 20 + signal_point = 20; + r = amdgpu_cs_syncobj_timeline_signal(device_handle, &syncobj_handle, + &signal_point, 1); + CU_ASSERT_EQUAL(r, 0); + r = amdgpu_cs_syncobj_query(device_handle, &syncobj_handle, + &payload, 1); + CU_ASSERT_EQUAL(r, 0); + CU_ASSERT_EQUAL(payload, 20); + + r = amdgpu_cs_destroy_syncobj(device_handle, syncobj_handle); + CU_ASSERT_EQUAL(r, 0); + +}