From patchwork Thu Oct 26 14:19:36 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Thomas Monjalon X-Patchwork-Id: 133431 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id F0CE243209; Thu, 26 Oct 2023 16:28:00 +0200 (CEST) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id C96F8402B5; Thu, 26 Oct 2023 16:27:57 +0200 (CEST) Received: from out5-smtp.messagingengine.com (out5-smtp.messagingengine.com [66.111.4.29]) by mails.dpdk.org (Postfix) with ESMTP id CE60C42DE9 for ; Thu, 26 Oct 2023 16:27:56 +0200 (CEST) Received: from compute5.internal (compute5.nyi.internal [10.202.2.45]) by mailout.nyi.internal (Postfix) with ESMTP id 763875C011A; Thu, 26 Oct 2023 10:27:56 -0400 (EDT) Received: from mailfrontend2 ([10.202.2.163]) by compute5.internal (MEProxy); Thu, 26 Oct 2023 10:27:56 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=monjalon.net; h= cc:cc:content-transfer-encoding:content-type:date:date:from:from :in-reply-to:in-reply-to:message-id:mime-version:references :reply-to:sender:subject:subject:to:to; s=fm3; t=1698330476; x= 1698416876; bh=3eup8/dMvX2jlj9mkuIghKYFnKATsplc8kPYcpStj/E=; b=m 4PERNgWBSJousPXx5bHn1LzGL+IostKu4ru7jHWkow+i7IAsOCVqROCEU089S4PW 2Ebd1c7CVuK9Dojk1DTxHLeB/RwikNEsjpiWVTfa2w+s1qlicddgEXYzlPTETggo eF3eQyuVLjcUrOkydvV+E9Rf4DsiKwInh3f695ORUfgHktBrr21MXoxhEfIjfBKW l0/f+jJG3/mzMsxppdwefDMIQz37hj7kwoBRM/y29Qihiy2LGUx2HZN/MaTPoj07 L1Ae6WficEt87RRhtD/1Q2KSzX7SxzrMMdgoeuOkt8177QFvkdOaRy5ITQigL48B avDfS4Ypl2BtKLIdRAJjg== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding :content-type:date:date:feedback-id:feedback-id:from:from :in-reply-to:in-reply-to:message-id:mime-version:references :reply-to:sender:subject:subject:to:to:x-me-proxy:x-me-proxy :x-me-sender:x-me-sender:x-sasl-enc; s=fm3; t=1698330476; x= 1698416876; bh=3eup8/dMvX2jlj9mkuIghKYFnKATsplc8kPYcpStj/E=; b=m Gr3LpVzmI39Etq8zMRfX2ORMH2i4AnV9PLNdu+63GuPp74r5MkM7lp+OcSOx7JTC efBW521j0vhVqKJIvwAeZnFp69/CyTl8GNKH17tvHQvuBUQlBRBUj0cNV1vdW9jQ Edxruxyw79MXIg3IPvxnPYqhSQmltJEyg7FoKvxbivfTBez0GBPAD8RdMXeGW8TY 3THSato8ErZtt4yGjrTA3SwE7bL9WQipVqWjkL8RkV0Z8BygO/mVmcEFqznrPIxz DknxwXKKSpsnXxZY3Di3HBR8vh1ZztUeiqSxSuU053FPXmQP4l31IvTV8YTRHGfD 8ptkUxzIHPMOPn31iRevA== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvkedrledvgdejjecutefuodetggdotefrodftvf curfhrohhfihhlvgemucfhrghsthforghilhdpqfgfvfdpuffrtefokffrpgfnqfghnecu uegrihhlohhuthemuceftddtnecusecvtfgvtghiphhivghnthhsucdlqddutddtmdenuc fjughrpefhvfevufffkffojghfggfgsedtkeertdertddtnecuhfhrohhmpefvhhhomhgr shcuofhonhhjrghlohhnuceothhhohhmrghssehmohhnjhgrlhhonhdrnhgvtheqnecugg ftrfgrthhtvghrnhepvdejhfdugeehvddtieejieegteeuudfgjeeukeeiledthfetveek hefhieelhfdtnecuvehluhhsthgvrhfuihiivgeptdenucfrrghrrghmpehmrghilhhfrh homhepthhhohhmrghssehmohhnjhgrlhhonhdrnhgvth X-ME-Proxy: Feedback-ID: i47234305:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Thu, 26 Oct 2023 10:27:54 -0400 (EDT) From: Thomas Monjalon To: dev@dpdk.org Cc: David Marchand , Dmitry Kozlyuk , Narcisa Ana Maria Vasile , Dmitry Malloy , Pallavi Kadam Subject: [PATCH v5 1/2] eal: add thread yield functions Date: Thu, 26 Oct 2023 16:19:36 +0200 Message-ID: <20231026142749.1174372-2-thomas@monjalon.net> X-Mailer: git-send-email 2.42.0 In-Reply-To: <20231026142749.1174372-1-thomas@monjalon.net> References: <20231024125416.798897-1-thomas@monjalon.net> <20231026142749.1174372-1-thomas@monjalon.net> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org When running real-time threads, we may need to force scheduling kernel threads or other real-time threads. New functions are added to address these cases. The yield functions should not have any interest for normal threads. Note: other purposes may be addressed with rte_pause() or rte_delay_*(). Signed-off-by: Thomas Monjalon --- lib/eal/include/rte_thread.h | 25 +++++++++++++++++++++++++ lib/eal/unix/rte_thread.c | 16 ++++++++++++++++ lib/eal/version.map | 4 ++++ lib/eal/windows/rte_thread.c | 15 +++++++++++++++ 4 files changed, 60 insertions(+) diff --git a/lib/eal/include/rte_thread.h b/lib/eal/include/rte_thread.h index 8da9d4d3fb..f2581fe152 100644 --- a/lib/eal/include/rte_thread.h +++ b/lib/eal/include/rte_thread.h @@ -183,6 +183,31 @@ int rte_thread_join(rte_thread_t thread_id, uint32_t *value_ptr); */ int rte_thread_detach(rte_thread_t thread_id); +/** + * Allow another thread to run on the same CPU core. + * + * This is a scheduler request, with minimum latency. + * Lower priority threads may not be scheduled. + * + * Especially useful in real-time thread priority + * to schedule other real-time threads. + * @see RTE_THREAD_PRIORITY_REALTIME_CRITICAL + */ +__rte_experimental +void rte_thread_yield(void); + +/** + * Unblock a CPU core running busy in a real-time thread. + * + * This is a sleep call, giving priority to all other threads. + * + * Especially useful in real-time thread priority + * to avoid a busy loop blocking vital threads on a core. + * @see RTE_THREAD_PRIORITY_REALTIME_CRITICAL + */ +__rte_experimental +void rte_thread_yield_realtime(void); + /** * Get the id of the calling thread. * diff --git a/lib/eal/unix/rte_thread.c b/lib/eal/unix/rte_thread.c index 36a21ab2f9..278d8d342d 100644 --- a/lib/eal/unix/rte_thread.c +++ b/lib/eal/unix/rte_thread.c @@ -5,9 +5,11 @@ #include #include +#include #include #include #include +#include #include #include @@ -227,6 +229,20 @@ rte_thread_detach(rte_thread_t thread_id) return pthread_detach((pthread_t)thread_id.opaque_id); } +void +rte_thread_yield(void) +{ + sched_yield(); +} + +void +rte_thread_yield_realtime(void) +{ + /* A simple yield may not be enough to schedule kernel threads. */ + struct timespec wait = {.tv_nsec = 1000000}; /* 1 ms */ + nanosleep(&wait, NULL); +} + int rte_thread_equal(rte_thread_t t1, rte_thread_t t2) { diff --git a/lib/eal/version.map b/lib/eal/version.map index e00a844805..b81ac3e3af 100644 --- a/lib/eal/version.map +++ b/lib/eal/version.map @@ -413,6 +413,10 @@ EXPERIMENTAL { # added in 23.07 rte_memzone_max_get; rte_memzone_max_set; + + # added in 23.11 + rte_thread_yield; + rte_thread_yield_realtime; }; INTERNAL { diff --git a/lib/eal/windows/rte_thread.c b/lib/eal/windows/rte_thread.c index acf648456c..ea17b5de3d 100644 --- a/lib/eal/windows/rte_thread.c +++ b/lib/eal/windows/rte_thread.c @@ -304,6 +304,21 @@ rte_thread_detach(rte_thread_t thread_id) return 0; } +void +rte_thread_yield(void) +{ + SwitchToThread(); +} + +void +rte_thread_yield_realtime(void) +{ + /* Real-time threads are not causing problems on Windows. + * A simple sleep should be more than enough. + */ + Sleep(0); +} + int rte_thread_equal(rte_thread_t t1, rte_thread_t t2) { From patchwork Thu Oct 26 14:19:37 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Thomas Monjalon X-Patchwork-Id: 133432 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 2C5A743209; Thu, 26 Oct 2023 16:28:08 +0200 (CEST) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id F29A842E19; Thu, 26 Oct 2023 16:28:02 +0200 (CEST) Received: from out5-smtp.messagingengine.com (out5-smtp.messagingengine.com [66.111.4.29]) by mails.dpdk.org (Postfix) with ESMTP id D760342E16; Thu, 26 Oct 2023 16:28:00 +0200 (CEST) Received: from compute6.internal (compute6.nyi.internal [10.202.2.47]) by mailout.nyi.internal (Postfix) with ESMTP id 80C765C0180; Thu, 26 Oct 2023 10:28:00 -0400 (EDT) Received: from mailfrontend2 ([10.202.2.163]) by compute6.internal (MEProxy); Thu, 26 Oct 2023 10:28:00 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=monjalon.net; h= cc:cc:content-transfer-encoding:content-type:content-type:date :date:from:from:in-reply-to:in-reply-to:message-id:mime-version :references:reply-to:sender:subject:subject:to:to; s=fm3; t= 1698330480; x=1698416880; bh=4KhtcSQtGJFP1ctiaKCe4VpVl+ML2FRg/oO JdbA3/dc=; b=tWw/Yv+hSpQyao52qUw9XCFY5/6pvTMua0wuI5TPt2veBajYPz+ Da0uCJqsL3NQ3DuAF2nhN1jETjV/DiVVywax8HSbn1nXeckZ3GQ1ohapCJ9CtWxa 46wSo9HqWHx3k3C6i57oNlRclBau5+19bnPCMLmKGTfEr2nuhGEml64pwSN+1jOW 95Yr7NG9/pAlgKBxgafKTrnBeEMowy9Qd3EXzkqS+Q4tBM4xLgN6ljSXtVLqXFrG Yc76hbZzU1aH8N5CxLccW/Sk2TQdOSnaU8s4i1tTCkYXGcWkEW+Qgt8TFy16lWen i5WGYOdAHQbY7KKKWn53qrLmAJC5tIPxB1w== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding :content-type:content-type:date:date:feedback-id:feedback-id :from:from:in-reply-to:in-reply-to:message-id:mime-version :references:reply-to:sender:subject:subject:to:to:x-me-proxy :x-me-proxy:x-me-sender:x-me-sender:x-sasl-enc; s=fm3; t= 1698330480; x=1698416880; bh=4KhtcSQtGJFP1ctiaKCe4VpVl+ML2FRg/oO JdbA3/dc=; b=hM7UZchOANl1oxfhYPDs3SfqNaLUN/SQ2FMxT3Z0/BHT40y+mpL bCtcRO8X8+P9s6B+euwlEYzEnB06Tf+GgeI99U1NUbZjo+kdznTA5avW/ocH8ro5 2WZN05uvy2s8Qyx1uJxqdxDbvvG3pwsD4ojmZ3eZahr052TxAipAJFzCw2g98uY1 WdPrUntq+ByCVcquGEDfLHqx41SZUxCv/p/oVtdh0wzdNAK+Yei26PaefRL4tyhX mqHQxrXvQlIsYlhititxD2kdV0gFp2Qy+6K/56mfkJH3CDUNJ9HYf1WVhnWCxmy+ N7hQv5D9bKOWWq65/2jChJkH99/hOt1cK7w== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvkedrledvgdejjecutefuodetggdotefrodftvf curfhrohhfihhlvgemucfhrghsthforghilhdpqfgfvfdpuffrtefokffrpgfnqfghnecu uegrihhlohhuthemuceftddtnecusecvtfgvtghiphhivghnthhsucdlqddutddtmdenuc fjughrpefhvfevufffkffojghfgggtgfesthekredtredtjeenucfhrhhomhepvfhhohhm rghsucfoohhnjhgrlhhonhcuoehthhhomhgrshesmhhonhhjrghlohhnrdhnvghtqeenuc ggtffrrghtthgvrhhnpedtieffffegfeetlefhkeeuteeuudffjefgleevtdeijedukefg veehteehheegjeenucevlhhushhtvghrufhiiigvpedtnecurfgrrhgrmhepmhgrihhlfh hrohhmpehthhhomhgrshesmhhonhhjrghlohhnrdhnvght X-ME-Proxy: Feedback-ID: i47234305:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Thu, 26 Oct 2023 10:27:57 -0400 (EDT) From: Thomas Monjalon To: dev@dpdk.org Cc: David Marchand , stable@dpdk.org, =?utf-8?q?M?= =?utf-8?q?orten_Br=C3=B8rup?= , Anatoly Burakov , Narcisa Vasile , Tyler Retzlaff , Stephen Hemminger , Dmitry Kozlyuk , Konstantin Ananyev , Andrew Rybchenko Subject: [PATCH v5 2/2] eal/unix: allow creating thread with real-time priority Date: Thu, 26 Oct 2023 16:19:37 +0200 Message-ID: <20231026142749.1174372-3-thomas@monjalon.net> X-Mailer: git-send-email 2.42.0 In-Reply-To: <20231026142749.1174372-1-thomas@monjalon.net> References: <20231024125416.798897-1-thomas@monjalon.net> <20231026142749.1174372-1-thomas@monjalon.net> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org When adding an API for creating threads, the real-time priority has been forbidden on Unix. There is a known issue with ring behaviour, but it should not be completely forbidden. Real-time thread can block some kernel threads on the same core, making the system unstable. That's why a sleep is added in the test thread, and a warning is logged when using real-time priority. Fixes: ca04c78b6262 ("eal: get/set thread priority per thread identifier") Fixes: ce6e911d20f6 ("eal: add thread lifetime API") Fixes: a7ba40b2b1bf ("drivers: convert to internal control threads") Cc: stable@dpdk.org Signed-off-by: Thomas Monjalon Acked-by: Morten Brørup --- app/test/test_threads.c | 11 +--------- .../prog_guide/env_abstraction_layer.rst | 4 +++- lib/eal/include/rte_thread.h | 8 +++++-- lib/eal/unix/rte_thread.c | 22 +++++++++++-------- 4 files changed, 23 insertions(+), 22 deletions(-) diff --git a/app/test/test_threads.c b/app/test/test_threads.c index 4ac3f2671a..c14d39fc83 100644 --- a/app/test/test_threads.c +++ b/app/test/test_threads.c @@ -22,7 +22,7 @@ thread_main(void *arg) __atomic_store_n(&thread_id_ready, 1, __ATOMIC_RELEASE); while (__atomic_load_n(&thread_id_ready, __ATOMIC_ACQUIRE) == 1) - ; + rte_thread_yield_realtime(); /* required for RT priority */ return 0; } @@ -97,21 +97,12 @@ test_thread_priority(void) "Priority set mismatches priority get"); priority = RTE_THREAD_PRIORITY_REALTIME_CRITICAL; -#ifndef RTE_EXEC_ENV_WINDOWS - RTE_TEST_ASSERT(rte_thread_set_priority(thread_id, priority) == ENOTSUP, - "Priority set to critical should fail"); - RTE_TEST_ASSERT(rte_thread_get_priority(thread_id, &priority) == 0, - "Failed to get thread priority"); - RTE_TEST_ASSERT(priority == RTE_THREAD_PRIORITY_NORMAL, - "Failed set to critical should have retained normal"); -#else RTE_TEST_ASSERT(rte_thread_set_priority(thread_id, priority) == 0, "Priority set to critical should succeed"); RTE_TEST_ASSERT(rte_thread_get_priority(thread_id, &priority) == 0, "Failed to get thread priority"); RTE_TEST_ASSERT(priority == RTE_THREAD_PRIORITY_REALTIME_CRITICAL, "Priority set mismatches priority get"); -#endif priority = RTE_THREAD_PRIORITY_NORMAL; RTE_TEST_ASSERT(rte_thread_set_priority(thread_id, priority) == 0, diff --git a/doc/guides/prog_guide/env_abstraction_layer.rst b/doc/guides/prog_guide/env_abstraction_layer.rst index 6debf54efb..d1f7cae7cd 100644 --- a/doc/guides/prog_guide/env_abstraction_layer.rst +++ b/doc/guides/prog_guide/env_abstraction_layer.rst @@ -815,7 +815,9 @@ Known Issues 4. It MAY be used by preemptible multi-producer and/or preemptible multi-consumer pthreads whose scheduling policy are all SCHED_OTHER(cfs), SCHED_IDLE or SCHED_BATCH. User SHOULD be aware of the performance penalty before using it. - 5. It MUST not be used by multi-producer/consumer pthreads, whose scheduling policies are SCHED_FIFO or SCHED_RR. + 5. It MUST not be used by multi-producer/consumer pthreads + whose scheduling policies are ``SCHED_FIFO`` + or ``SCHED_RR`` (``RTE_THREAD_PRIORITY_REALTIME_CRITICAL``). Alternatively, applications can use the lock-free stack mempool handler. When considering this handler, note that: diff --git a/lib/eal/include/rte_thread.h b/lib/eal/include/rte_thread.h index f2581fe152..7ff031e1b2 100644 --- a/lib/eal/include/rte_thread.h +++ b/lib/eal/include/rte_thread.h @@ -56,10 +56,14 @@ typedef uint32_t (*rte_thread_func) (void *arg); * Thread priority values. */ enum rte_thread_priority { + /** Normal thread priority, the default. */ RTE_THREAD_PRIORITY_NORMAL = 0, - /**< normal thread priority, the default */ + /** + * Highest thread priority, use with caution. + * WARNING: System may be unstable because of a real-time busy loop. + * @see rte_thread_yield_realtime(). + */ RTE_THREAD_PRIORITY_REALTIME_CRITICAL = 1, - /**< highest thread priority allowed */ }; /** diff --git a/lib/eal/unix/rte_thread.c b/lib/eal/unix/rte_thread.c index 278d8d342d..17ffb86c17 100644 --- a/lib/eal/unix/rte_thread.c +++ b/lib/eal/unix/rte_thread.c @@ -33,6 +33,8 @@ static int thread_map_priority_to_os_value(enum rte_thread_priority eal_pri, int *os_pri, int *pol) { + static bool warned; + /* Clear the output parameters. */ *os_pri = sched_get_priority_min(SCHED_OTHER) - 1; *pol = -1; @@ -51,6 +53,17 @@ thread_map_priority_to_os_value(enum rte_thread_priority eal_pri, int *os_pri, sched_get_priority_max(SCHED_OTHER)) / 2; break; case RTE_THREAD_PRIORITY_REALTIME_CRITICAL: + /* + * WARNING: Real-time busy loop takes priority on kernel threads, + * making the system unstable. + * There is also a known issue when using rte_ring. + */ + if (!warned) { + RTE_LOG(NOTICE, EAL, + "Real-time thread is unstable if polling without sleep.\n"); + warned = true; + } + *pol = SCHED_RR; *os_pri = sched_get_priority_max(SCHED_RR); break; @@ -155,11 +168,6 @@ rte_thread_create(rte_thread_t *thread_id, goto cleanup; } - if (thread_attr->priority == - RTE_THREAD_PRIORITY_REALTIME_CRITICAL) { - ret = ENOTSUP; - goto cleanup; - } ret = thread_map_priority_to_os_value(thread_attr->priority, ¶m.sched_priority, &policy); if (ret != 0) @@ -291,10 +299,6 @@ rte_thread_set_priority(rte_thread_t thread_id, int policy; int ret; - /* Realtime priority can cause crashes on non-Windows platforms. */ - if (priority == RTE_THREAD_PRIORITY_REALTIME_CRITICAL) - return ENOTSUP; - ret = thread_map_priority_to_os_value(priority, ¶m.sched_priority, &policy); if (ret != 0)