From patchwork Sat Apr 18 19:43:09 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ravi Kerur X-Patchwork-Id: 4357 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 840FBC41C; Sat, 18 Apr 2015 21:43:22 +0200 (CEST) Received: from mail-pd0-f181.google.com (mail-pd0-f181.google.com [209.85.192.181]) by dpdk.org (Postfix) with ESMTP id 6DF3BC406 for ; Sat, 18 Apr 2015 21:43:19 +0200 (CEST) Received: by pdbnk13 with SMTP id nk13so163298940pdb.0 for ; Sat, 18 Apr 2015 12:43:18 -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=sTHzPLcslUMgTn1desEhEkQyWw2i2D1cAYURsdSQ3r8=; b=M1RzSRkDLK5685JFivCBwqHOYm3rz1kfP6dxIq2m+8G/D26FgFg7pMHoeH9ZzTCe7R K9j55alp76y+U1KuksfBjQwH6bqrSKGpIDqScUar1qOLz4xLg82wGgZACX3vyxCLrGE3 5cossm6VLk1XjDXVaXX1MhGh/m6CAtuGxPyA2/W/2xcv/xROHYlYbA7TB6CA5RXw3Av9 gX4n+/8eLXK2ExweokJUdxzh/9OoJL8Ul+fdm2mR9OL6QqyddKIfqgnFNoTAy426UyJv 7pwMX9lzLzqiL1mO2e+VQb5nMuL+H20xpQ+sXWZflKBm4YwPvZ8lcsp1OmjT+S05yAfq gRYg== X-Received: by 10.70.40.164 with SMTP id y4mr10970512pdk.25.1429386198805; Sat, 18 Apr 2015 12:43:18 -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 ji6sm13729469pac.30.2015.04.18.12.43.17 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sat, 18 Apr 2015 12:43:17 -0700 (PDT) From: Ravi Kerur To: dev@dpdk.org Date: Sat, 18 Apr 2015 12:43:09 -0700 Message-Id: <1429386191-12537-4-git-send-email-rkerur@gmail.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1429386191-12537-1-git-send-email-rkerur@gmail.com> References: <1429386161-12490-1-git-send-email-rkerur@gmail.com> <1429386191-12537-1-git-send-email-rkerur@gmail.com> Subject: [dpdk-dev] [PATCH v6 4/6] 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 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 1da0410..d8e6ced 100644 --- a/lib/librte_eal/bsdapp/eal/Makefile +++ b/lib/librte_eal/bsdapp/eal/Makefile @@ -83,6 +83,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_common_mem_cfg.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_common_proc_type.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_common_app_usage.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..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 3cc677b..0311638 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 c8d2d54..89180e8 100644 --- a/lib/librte_eal/linuxapp/eal/Makefile +++ b/lib/librte_eal/linuxapp/eal/Makefile @@ -95,6 +95,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_mem_cfg.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_proc_type.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_app_usage.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 b19b18e..26e148a 100644 --- a/lib/librte_eal/linuxapp/eal/eal_timer.c +++ b/lib/librte_eal/linuxapp/eal/eal_timer.c @@ -58,9 +58,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" @@ -161,23 +158,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 @@ -288,7 +268,7 @@ check_tsc_flags(void) fclose(stream); } -static int +int set_tsc_freq_from_clock(void) { #ifdef CLOCK_MONOTONIC_RAW @@ -297,6 +277,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(); @@ -307,42 +288,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) {