From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-pd0-f172.google.com (mail-pd0-f172.google.com [209.85.192.172]) by dpdk.org (Postfix) with ESMTP id 875BCC482 for ; Sat, 25 Jul 2015 21:36:38 +0200 (CEST) Received: by pdbbh15 with SMTP id bh15so29864591pdb.1 for ; Sat, 25 Jul 2015 12:36:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=0PnxiL64h9Smeja2QufttYnKSCE60HjLqUWou+NZfu8=; b=dBKnyQSslz1joBu8GB8SkH60jY6/sxN6LXR73mdh9LhThrTgc7xVn4oK47Teix/78w 0YIUpo1D6sXuhb6xcCO6jPhvaoRxcozR+P5BQnvZ8DcvBVpgwJoWDh8kEReNNKiyES3u A5qJDaJv1L8j147aG7pUzEhYoCqP8Sq3sKWR5TjP3X3ldW87eJ4p8BKWxvKA6J8wjQ7z n3vZynafOF/Xw5WJ1E6hUELoZNNMiqEQwia1CShhG794KgXa15HRkl4ORh433065AgOk Wvol4SEvIlrXfZWuj1rbw3jwd9/kVsTWhPArM/rOI4FEKqLmiAvyy8We5SH/LRpR7xPH 4v8w== X-Received: by 10.70.7.162 with SMTP id k2mr46586059pda.128.1437852997703; Sat, 25 Jul 2015 12:36:37 -0700 (PDT) Received: from user-PC.hsd1.ca.comcast.net (c-98-234-176-9.hsd1.ca.comcast.net. [98.234.176.9]) by smtp.gmail.com with ESMTPSA id u16sm10325066pdl.71.2015.07.25.12.36.36 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sat, 25 Jul 2015 12:36:36 -0700 (PDT) From: Ravi Kerur To: dev@dpdk.org Date: Sat, 25 Jul 2015 12:36:28 -0700 Message-Id: <1437852990-6096-2-git-send-email-rkerur@gmail.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1437852990-6096-1-git-send-email-rkerur@gmail.com> References: <1437852868-6031-1-git-send-email-rkerur@gmail.com> <1437852990-6096-1-git-send-email-rkerur@gmail.com> Subject: [dpdk-dev] [PATCH v9 2/3] Move common functions in eal_timer.c X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: patches and discussions about DPDK List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sat, 25 Jul 2015 19:36:38 -0000 Changes in v9 Rebase to latest code. Changes in v8 Reorder eal_common_timer.c compilation. Changes in v7 None Changes in v6 Added new line between Copyright and header file inclusion in eal_common_timer.c. Changes in v5 Rebase to latest code. Changes in v4 Removed extern declaration of eal_tsc_resolution_hz, instead provided _set_ API. Make set_tsc_freq_from_clock as wrapper function for BSD. Changes in v3 Changed subject to be more explicit on file name inclusion. Changes in v2 Use common function name set_tsc_freq_from_sysctl for BSD and Linux. Update comments about its actuality in function declaration. Changes in v1 Move common functions in eal_timer.c to librte_eal/common/ eal_common_timer.c file. Following functions are moved to eal_common_timer.c file void rte_delay_us(unsigned us); uint64_t rte_get_tsc_hz(void); static void set_tsc_freq_fallback(void); void set_tsc_freq(void); Makefile changes to reflect new file added. Fix checkpatch warnings and errors. Signed-off-by: Ravi Kerur --- lib/librte_eal/bsdapp/eal/Makefile | 1 + lib/librte_eal/bsdapp/eal/eal_timer.c | 52 +++------------- lib/librte_eal/common/eal_common_timer.c | 102 +++++++++++++++++++++++++++++++ lib/librte_eal/common/eal_private.h | 24 ++++++++ lib/librte_eal/linuxapp/eal/Makefile | 1 + lib/librte_eal/linuxapp/eal/eal_timer.c | 55 ++--------------- 6 files changed, 140 insertions(+), 95 deletions(-) create mode 100644 lib/librte_eal/common/eal_common_timer.c diff --git a/lib/librte_eal/bsdapp/eal/Makefile b/lib/librte_eal/bsdapp/eal/Makefile index d5e4f4a..102f310 100644 --- a/lib/librte_eal/bsdapp/eal/Makefile +++ b/lib/librte_eal/bsdapp/eal/Makefile @@ -60,6 +60,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_debug.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_lcore.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_common_lcore.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_timer.c +SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_common_timer.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_interrupts.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_alarm.c diff --git a/lib/librte_eal/bsdapp/eal/eal_timer.c b/lib/librte_eal/bsdapp/eal/eal_timer.c index 7147abe..ee7a5ac 100644 --- a/lib/librte_eal/bsdapp/eal/eal_timer.c +++ b/lib/librte_eal/bsdapp/eal/eal_timer.c @@ -55,29 +55,12 @@ enum timer_source eal_timer_source = EAL_TIMER_TSC; -/* The frequency of the RDTSC timer resolution */ -static uint64_t eal_tsc_resolution_hz = 0; - -void -rte_delay_us(unsigned us) -{ - const uint64_t start = rte_get_timer_cycles(); - const uint64_t ticks = (uint64_t)us * rte_get_timer_hz() / 1E6; - while ((rte_get_timer_cycles() - start) < ticks) - rte_pause(); -} - -uint64_t -rte_get_tsc_hz(void) -{ - return eal_tsc_resolution_hz; -} - static int set_tsc_freq_from_sysctl(void) { size_t sz; int tmp; + uint64_t tsc_hz; sz = sizeof(tmp); tmp = 0; @@ -94,42 +77,23 @@ set_tsc_freq_from_sysctl(void) else if (tmp != 1) RTE_LOG(WARNING, EAL, "TSC is not invariant\n"); - sz = sizeof(eal_tsc_resolution_hz); - if (sysctlbyname("machdep.tsc_freq", &eal_tsc_resolution_hz, &sz, NULL, 0)) { + sz = sizeof(tsc_hz); + if (sysctlbyname("machdep.tsc_freq", &tsc_hz, &sz, NULL, 0)) { RTE_LOG(WARNING, EAL, "%s\n", strerror(errno)); return -1; } + rte_set_tsc_hz(tsc_hz); return 0; } -static void -set_tsc_freq_fallback(void) -{ - RTE_LOG(WARNING, EAL, "WARNING: clock_gettime cannot use " - "CLOCK_MONOTONIC_RAW and HPET is not available" - " - clock timings may be less accurate.\n"); - /* assume that the sleep(1) will sleep for 1 second */ - uint64_t start = rte_rdtsc(); - sleep(1); - eal_tsc_resolution_hz = rte_rdtsc() - start; -} - /* - * This function measures the TSC frequency. It uses a variety of approaches. - * - * 1. Read the TSC frequency value provided by the kernel - * 2. If above does not work, just sleep for 1 second and tune off that, - * printing a warning about inaccuracy of timing + * Wrapper function to get TSC frequency from sysctl. */ -static void -set_tsc_freq(void) +int +set_tsc_freq_from_clock(void) { - if (set_tsc_freq_from_sysctl() < 0) - set_tsc_freq_fallback(); - - RTE_LOG(INFO, EAL, "TSC frequency is ~%"PRIu64" KHz\n", - eal_tsc_resolution_hz/1000); + return set_tsc_freq_from_sysctl(); } int diff --git a/lib/librte_eal/common/eal_common_timer.c b/lib/librte_eal/common/eal_common_timer.c new file mode 100644 index 0000000..5fddd6e --- /dev/null +++ b/lib/librte_eal/common/eal_common_timer.c @@ -0,0 +1,102 @@ +/*- + * BSD LICENSE + * + * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "eal_private.h" +#include "eal_internal_cfg.h" + +/* The frequency of the RDTSC timer resolution */ +uint64_t eal_tsc_resolution_hz = 0; + +void +rte_delay_us(unsigned us) +{ + const uint64_t start = rte_get_timer_cycles(); + const uint64_t ticks = (uint64_t)us * rte_get_timer_hz() / 1E6; + + while ((rte_get_timer_cycles() - start) < ticks) + rte_pause(); +} + +uint64_t +rte_get_tsc_hz(void) +{ + return eal_tsc_resolution_hz; +} + +void +rte_set_tsc_hz(uint64_t tsc_hz) +{ + eal_tsc_resolution_hz = tsc_hz; +} + +static void +set_tsc_freq_fallback(void) +{ + RTE_LOG(WARNING, EAL, "WARNING: clock_gettime cannot use " + "CLOCK_MONOTONIC_RAW and HPET is not available" + " - clock timings may be less accurate.\n"); + /* assume that the sleep(1) will sleep for 1 second */ + uint64_t start = rte_rdtsc(); + + sleep(1); + eal_tsc_resolution_hz = rte_rdtsc() - start; +} + +/* + * This function measures the TSC frequency. It uses a variety of approaches. + * + * 1. Read the TSC frequency value provided by the kernel + * 2. If above does not work, just sleep for 1 second and tune off that, + * printing a warning about inaccuracy of timing + */ +void +set_tsc_freq(void) +{ + if (set_tsc_freq_from_clock() < 0) + set_tsc_freq_fallback(); + + RTE_LOG(INFO, EAL, "TSC frequency is ~%"PRIu64" KHz\n", + eal_tsc_resolution_hz/1000); +} diff --git a/lib/librte_eal/common/eal_private.h b/lib/librte_eal/common/eal_private.h index f80a9c4..b33b701 100644 --- a/lib/librte_eal/common/eal_private.h +++ b/lib/librte_eal/common/eal_private.h @@ -314,4 +314,28 @@ unsigned eal_cpu_core_id(unsigned lcore_id); */ int eal_cpu_detected(unsigned lcore_id); +/** + * This function measures TSC frequency + * + * This function is private to the EAL. + */ +void set_tsc_freq(void); + +/** + * This function sets TSC frequency from sysctl + * for BSD and from clock for Linux. + * Is a wrapper function for BSD which will + * internally call set_tsc_freq_from_sysctl. + * + * This function is private to the EAL. + */ +int set_tsc_freq_from_clock(void); + +/** + * This function sets TSC frequency + * + * This function is private to the EAL. + */ +void rte_set_tsc_hz(uint64_t tsc_hz); + #endif /* _EAL_PRIVATE_H_ */ diff --git a/lib/librte_eal/linuxapp/eal/Makefile b/lib/librte_eal/linuxapp/eal/Makefile index b80a333..f001ca6 100644 --- a/lib/librte_eal/linuxapp/eal/Makefile +++ b/lib/librte_eal/linuxapp/eal/Makefile @@ -69,6 +69,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_debug.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_lcore.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_lcore.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_timer.c +SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_timer.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_interrupts.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_alarm.c ifeq ($(CONFIG_RTE_LIBRTE_IVSHMEM),y) diff --git a/lib/librte_eal/linuxapp/eal/eal_timer.c b/lib/librte_eal/linuxapp/eal/eal_timer.c index 94909ed..ef70682 100644 --- a/lib/librte_eal/linuxapp/eal/eal_timer.c +++ b/lib/librte_eal/linuxapp/eal/eal_timer.c @@ -57,9 +57,6 @@ enum timer_source eal_timer_source = EAL_TIMER_HPET; -/* The frequency of the RDTSC timer resolution */ -static uint64_t eal_tsc_resolution_hz = 0; - #ifdef RTE_LIBEAL_USE_HPET #define DEV_HPET "/dev/hpet" @@ -160,23 +157,6 @@ rte_get_hpet_cycles(void) #endif - -void -rte_delay_us(unsigned us) -{ - const uint64_t start = rte_get_timer_cycles(); - const uint64_t ticks = (uint64_t)us * rte_get_timer_hz() / 1E6; - while ((rte_get_timer_cycles() - start) < ticks) - rte_pause(); -} - -uint64_t -rte_get_tsc_hz(void) -{ - return eal_tsc_resolution_hz; -} - - #ifdef RTE_LIBEAL_USE_HPET /* * Open and mmap /dev/hpet (high precision event timer) that will @@ -275,7 +255,7 @@ check_tsc_flags(void) fclose(stream); } -static int +int set_tsc_freq_from_clock(void) { #ifdef CLOCK_MONOTONIC_RAW @@ -284,6 +264,7 @@ set_tsc_freq_from_clock(void) struct timespec sleeptime = {.tv_nsec = 5E8 }; /* 1/2 second */ struct timespec t_start, t_end; + uint64_t tsc_hz; if (clock_gettime(CLOCK_MONOTONIC_RAW, &t_start) == 0) { uint64_t ns, end, start = rte_rdtsc(); @@ -294,42 +275,14 @@ set_tsc_freq_from_clock(void) ns += (t_end.tv_nsec - t_start.tv_nsec); double secs = (double)ns/NS_PER_SEC; - eal_tsc_resolution_hz = (uint64_t)((end - start)/secs); + tsc_hz = (uint64_t)((end - start)/secs); + rte_set_tsc_hz(tsc_hz); return 0; } #endif return -1; } -static void -set_tsc_freq_fallback(void) -{ - RTE_LOG(WARNING, EAL, "WARNING: clock_gettime cannot use " - "CLOCK_MONOTONIC_RAW and HPET is not available" - " - clock timings may be less accurate.\n"); - /* assume that the sleep(1) will sleep for 1 second */ - uint64_t start = rte_rdtsc(); - sleep(1); - eal_tsc_resolution_hz = rte_rdtsc() - start; -} -/* - * This function measures the TSC frequency. It uses a variety of approaches. - * - * 1. If kernel provides CLOCK_MONOTONIC_RAW we use that to tune the TSC value - * 2. If kernel does not provide that, and we have HPET support, tune using HPET - * 3. Lastly, if neither of the above can be used, just sleep for 1 second and - * tune off that, printing a warning about inaccuracy of timing - */ -static void -set_tsc_freq(void) -{ - if (set_tsc_freq_from_clock() < 0) - set_tsc_freq_fallback(); - - RTE_LOG(INFO, EAL, "TSC frequency is ~%"PRIu64" KHz\n", - eal_tsc_resolution_hz/1000); -} - int rte_eal_timer_init(void) { -- 1.9.1