From patchwork Thu Apr 9 19:40:10 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ravi Kerur X-Patchwork-Id: 4278 Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [IPv6:::1]) by dpdk.org (Postfix) with ESMTP id F0E15C300; Thu, 9 Apr 2015 21:40:37 +0200 (CEST) Received: from mail-pd0-f179.google.com (mail-pd0-f179.google.com [209.85.192.179]) by dpdk.org (Postfix) with ESMTP id 72DE65FEB for ; Thu, 9 Apr 2015 21:40:34 +0200 (CEST) Received: by pddn5 with SMTP id n5so163279011pdd.2 for ; Thu, 09 Apr 2015 12:40:33 -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=FgH8QRkzFFmOuGBkp1Sq9nEEhyBXvGnJxSw3D5H/XzE=; b=QkeRKFvANjZusbS+CJnA9apZZkFX4ydD8ckRxRQMd62oTZ+YWfUAcb2Ho0+AJxHbJB JJEixoUtFoxsY2CXuIMPADvDNhWbxQseNGT9sH7/X9+6sWMhlqOQuKCMHWj3r947V3Bn z4+A2rx7shpVN0lWxSOr8RxsaSCCsgMR8DovUu3blGYjY5qBFMuuboHnjUwmf1RAplrn 4VCx1Rbdap1MEH+ICBHaFHX2W0KxozeN/wv6pIvBk2+vg1/ki7J5zUcut5XT7NEPy4zO QLuaHlqTvitECgHbs+PcvoS//UPlUibwyOWeoZLpgQL2rDiSG4PCeTMrKKsPzjgeo/Wg nFKQ== X-Received: by 10.68.172.131 with SMTP id bc3mr538472pbc.107.1428608433863; Thu, 09 Apr 2015 12:40:33 -0700 (PDT) Received: from user-PC.hsd1.ca.comcast.net (c-98-234-176-9.hsd1.ca.comcast.net. [98.234.176.9]) by mx.google.com with ESMTPSA id xv9sm15149298pbc.2.2015.04.09.12.40.32 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 09 Apr 2015 12:40:33 -0700 (PDT) From: Ravi Kerur To: dev@dpdk.org Date: Thu, 9 Apr 2015 12:40:10 -0700 Message-Id: <1428608412-31191-5-git-send-email-rkerur@gmail.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1428608412-31191-1-git-send-email-rkerur@gmail.com> References: <1428608301-31033-1-git-send-email-rkerur@gmail.com> <1428608412-31191-1-git-send-email-rkerur@gmail.com> Subject: [dpdk-dev] [PATCH v5 4/8] 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: , Errors-To: dev-bounces@dpdk.org Sender: "dev" 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 Acked-by: Thomas Monjalon --- lib/librte_eal/bsdapp/eal/Makefile | 1 + lib/librte_eal/bsdapp/eal/eal_timer.c | 52 +++------------- lib/librte_eal/common/eal_common_timer.c | 101 +++++++++++++++++++++++++++++++ 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, 139 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 a28ead3..48ba39a 100644 --- a/lib/librte_eal/bsdapp/eal/Makefile +++ b/lib/librte_eal/bsdapp/eal/Makefile @@ -81,6 +81,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_common_thread.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_common_system.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_common_runtime.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_common_lcore.c +SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_common_timer.c CFLAGS_eal.o := -D_GNU_SOURCE #CFLAGS_eal_thread.o := -D_GNU_SOURCE 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..2a511d0 --- /dev/null +++ b/lib/librte_eal/common/eal_common_timer.c @@ -0,0 +1,101 @@ +/*- + * 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 458e8c1..7ee1eb2 100644 --- a/lib/librte_eal/common/eal_private.h +++ b/lib/librte_eal/common/eal_private.h @@ -324,4 +324,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 8ae23a0..2c18eee 100644 --- a/lib/librte_eal/linuxapp/eal/Makefile +++ b/lib/librte_eal/linuxapp/eal/Makefile @@ -93,6 +93,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_thread.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_system.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_runtime.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_lcore.c +SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_timer.c CFLAGS_eal.o := -D_GNU_SOURCE CFLAGS_eal_interrupts.o := -D_GNU_SOURCE diff --git a/lib/librte_eal/linuxapp/eal/eal_timer.c b/lib/librte_eal/linuxapp/eal/eal_timer.c index 169c6e1..b7484f3 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) {