From patchwork Wed Mar 23 21:57:14 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Noah Goldstein X-Patchwork-Id: 52269 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id E8ABB388882E for ; Wed, 23 Mar 2022 21:59:06 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org E8ABB388882E DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1648072746; bh=nKwF6+giynb132uRRJsnRXYSjDIYsf1yHfO0zLvnKQA=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To: From; b=NofYGOplAuT7Fv9bRVJA2HmrcU1AuRgD9mXgEAL0DbeQ8ZBraL6q55FLYgj+oCz0B ELKOVelsZLAinpOBXmpR5uD2NeyWPjcbcPKbc5TYVDi6b26fsyln96k8eUh1pEXXem lrEIESLZEg/QuwMmphRM2DXOhuSISoRn/Kna3Ml8= X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from mail-il1-x12a.google.com (mail-il1-x12a.google.com [IPv6:2607:f8b0:4864:20::12a]) by sourceware.org (Postfix) with ESMTPS id 71EEB3840C32 for ; Wed, 23 Mar 2022 21:58:06 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 71EEB3840C32 Received: by mail-il1-x12a.google.com with SMTP id y7so1986488ilv.6 for ; Wed, 23 Mar 2022 14:58:06 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=nKwF6+giynb132uRRJsnRXYSjDIYsf1yHfO0zLvnKQA=; b=hxnopECCzxVpODWI/zDlw9eIaMllOiZIkE+6IL5YzunOTTPqXYz/ls1JHEqA/AIk5e OwArJv3Q1NMmPTgyzHNFqLH8Vtb/zww21gUqjHo6ehT1hcKy/JmTyhMLYLOhtnK9rn1E vp91LT0Z5tDSs1w/W2s6e3m0HDS5ZKWqA7U6bqSKSqlya8VCRXurmcC63z2/fGn3wdbn tT8Lv9WpovMcwlnnuVn3MdHdpj0uPgwwoD8ueYxKEA27fNyPAgsMNi+AnmdCzmbNBcs8 kI4WKJI4zRNyEXyEzn+r0116WN+uaPjEDJJzMOa6+4lc/lBwfIei7B8wLoanoPRVpcmt okdQ== X-Gm-Message-State: AOAM532v0oOeOXpynv2PDqC/dFdsywd4Ob+jQf1wLJVOuYVcXKchfctf Ds5DZn/BcQkv/66hka6IRIZLi92lMo8= X-Google-Smtp-Source: ABdhPJxe/qWA9X99Jj7ezBoGtRrIwLM911yo6wxt2ypSYZj42dl7q2WUsJjxQ3ToCyOdWxNKTG1SYA== X-Received: by 2002:a05:6e02:1bcc:b0:2c8:19b1:b523 with SMTP id x12-20020a056e021bcc00b002c819b1b523mr1041477ilv.255.1648072685475; Wed, 23 Mar 2022 14:58:05 -0700 (PDT) Received: from localhost.localdomain (node-17-161.flex.volo.net. [76.191.17.161]) by smtp.googlemail.com with ESMTPSA id c22-20020a5ea816000000b00649d360663asm529227ioa.40.2022.03.23.14.58.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 23 Mar 2022 14:58:05 -0700 (PDT) To: libc-alpha@sourceware.org Subject: [PATCH v1 02/23] benchtests: Add random benchmark in bench-strchr.c Date: Wed, 23 Mar 2022 16:57:14 -0500 Message-Id: <20220323215734.3927131-2-goldstein.w.n@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220323215734.3927131-1-goldstein.w.n@gmail.com> References: <20220323215734.3927131-1-goldstein.w.n@gmail.com> MIME-Version: 1.0 X-Spam-Status: No, score=-12.5 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Noah Goldstein via Libc-alpha From: Noah Goldstein Reply-To: Noah Goldstein Errors-To: libc-alpha-bounces+patchwork=sourceware.org@sourceware.org Sender: "Libc-alpha" Add benchmark that randomizes whether return should be NULL or pointer to CHAR. The rationale is on many architectures there is a choice between a predicate execution option (i.e cmovcc on x86) or a branch. On x86 the results for cmovcc vs branch are something along the lines of the following: perc-zero, Br On Result, Time Br / Time cmov 0.10, 1, ,0.983 0.10, 0, ,1.246 0.25, 1, ,1.035 0.25, 0, ,1.49 0.33, 1, ,1.016 0.33, 0, ,1.579 0.50, 1, ,1.228 0.50, 0, ,1.739 0.66, 1, ,1.039 0.66, 0, ,1.764 0.75, 1, ,0.996 0.75, 0, ,1.642 0.90, 1, ,1.071 0.90, 0, ,1.409 1.00, 1, ,0.937 1.00, 0, ,0.999 Reviewed-by: H.J. Lu --- benchtests/bench-strchr.c | 143 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 143 insertions(+) diff --git a/benchtests/bench-strchr.c b/benchtests/bench-strchr.c index 203900d4ad..54640bde7e 100644 --- a/benchtests/bench-strchr.c +++ b/benchtests/bench-strchr.c @@ -53,6 +53,11 @@ # define SMALL_CHAR 851 #endif /* WIDE */ +#ifdef USE_FOR_STRCHRNUL +# define DO_RAND_TEST(...) +#else +# define DO_RAND_TEST(...) do_rand_test(__VA_ARGS__) +#endif #ifdef USE_FOR_STRCHRNUL # define NULLRET(endptr) endptr #else @@ -74,6 +79,133 @@ simple_STRCHR (const CHAR *s, int c) IMPL (simple_STRCHR, 0) IMPL (STRCHR, 1) +#ifndef USE_FOR_STRCHRNUL +/* Random benchmarks for strchr (if return is CHAR or NULL). The + rational for the benchmark is returning null/char can be done with + predicate execution (i.e cmovcc on x86) or a branch. */ + + +/* Large enough that full history can't be stored in BHT. */ +#define NUM_SEARCH_CHARS 2048 + +/* Expectation is usecases of strchr check the return. Otherwise + strchrnul would almost always be better. Since there is another + branch coming we want to test the case where a potential branch in + strchr can be used to skip a later mispredict because of the + relationship between the two branches. */ +static void __attribute__ ((noinline, noclone)) +do_one_rand_plus_branch_test (json_ctx_t *json_ctx, impl_t *impl, + const CHAR *s, const CHAR *c) +{ + size_t i, iters = INNER_LOOP_ITERS_LARGE; + int must_execute = 0; + timing_t start, stop, cur; + TIMING_NOW (start); + for (i = 0; i < iters; ++i) + { + if (CALL (impl, s, c[i % NUM_SEARCH_CHARS])) + { + /* We just need something that will force compiler to emit + a branch instead of conditional execution. */ + ++must_execute; + asm volatile("" : : :); + } + } + TIMING_NOW (stop); + + TIMING_DIFF (cur, start, stop); + + json_element_double (json_ctx, (double)cur / (double)iters); +} + +static void __attribute__ ((noinline, noclone)) +do_one_rand_test (json_ctx_t *json_ctx, impl_t *impl, const CHAR *s, + const CHAR *c) +{ + size_t i, iters = INNER_LOOP_ITERS_LARGE; + timing_t start, stop, cur; + TIMING_NOW (start); + for (i = 0; i < iters; ++i) + { + CALL (impl, s, c[i % NUM_SEARCH_CHARS]); + } + TIMING_NOW (stop); + + TIMING_DIFF (cur, start, stop); + + json_element_double (json_ctx, (double)cur / (double)iters); +} + +static void +do_rand_test (json_ctx_t *json_ctx, size_t align, size_t pos, size_t len, + float perc_zero) +{ + size_t i; + int perc_zero_int; + CHAR *buf = (CHAR *)buf1; + CHAR *c = (CHAR *)buf2; + align &= 127; + if ((align + len) * sizeof (CHAR) >= page_size) + return; + + /* Test is only interesting if we can hit both cases. */ + if (pos >= len) + return; + + /* Segfault if we run the test. */ + if (NUM_SEARCH_CHARS * sizeof (CHAR) > page_size) + return; + + for (i = 0; i < len; ++i) + { + buf[align + i] = 2; + } + buf[align + len] = 0; + buf[align + pos] = 1; + + perc_zero_int = perc_zero * RAND_MAX; + for (i = 0; i < NUM_SEARCH_CHARS; ++i) + { + if (rand () > perc_zero_int) + c[i] = 0; + else + c[i] = 1; + } + { + json_element_object_begin (json_ctx); + json_attr_uint (json_ctx, "rand", 1); + json_attr_uint (json_ctx, "branch", 1); + json_attr_double (json_ctx, "perc-zero", perc_zero); + json_attr_uint (json_ctx, "length", len); + json_attr_uint (json_ctx, "pos", pos); + json_attr_uint (json_ctx, "alignment", align); + json_array_begin (json_ctx, "timings"); + + FOR_EACH_IMPL (impl, 0) + do_one_rand_plus_branch_test (json_ctx, impl, buf + align, c); + + json_array_end (json_ctx); + json_element_object_end (json_ctx); + } + { + json_element_object_begin (json_ctx); + json_attr_uint (json_ctx, "rand", 1); + json_attr_uint (json_ctx, "branch", 0); + json_attr_double (json_ctx, "perc-zero", perc_zero); + json_attr_uint (json_ctx, "length", len); + json_attr_uint (json_ctx, "pos", pos); + json_attr_uint (json_ctx, "alignment", align); + json_array_begin (json_ctx, "timings"); + + FOR_EACH_IMPL (impl, 0) + do_one_rand_test (json_ctx, impl, buf + align, c); + + json_array_end (json_ctx); + json_element_object_end (json_ctx); + } +} +#endif + static void do_one_test (json_ctx_t *json_ctx, impl_t *impl, const CHAR *s, int c, const CHAR *exp_res) @@ -136,6 +268,7 @@ do_test (json_ctx_t *json_ctx, size_t align, size_t pos, size_t len, result = NULLRET (buf + align + len); json_element_object_begin (json_ctx); + json_attr_uint (json_ctx, "rand", 0); json_attr_uint (json_ctx, "length", len); json_attr_uint (json_ctx, "pos", pos); json_attr_uint (json_ctx, "seek_char", seek_char); @@ -234,6 +367,16 @@ test_main (void) do_test (&json_ctx, 0, i, i + 1, 0, BIG_CHAR); } + DO_RAND_TEST(&json_ctx, 0, 15, 16, 0.0); + DO_RAND_TEST(&json_ctx, 0, 15, 16, 0.1); + DO_RAND_TEST(&json_ctx, 0, 15, 16, 0.25); + DO_RAND_TEST(&json_ctx, 0, 15, 16, 0.33); + DO_RAND_TEST(&json_ctx, 0, 15, 16, 0.5); + DO_RAND_TEST(&json_ctx, 0, 15, 16, 0.66); + DO_RAND_TEST(&json_ctx, 0, 15, 16, 0.75); + DO_RAND_TEST(&json_ctx, 0, 15, 16, 0.9); + DO_RAND_TEST(&json_ctx, 0, 15, 16, 1.0); + json_array_end (&json_ctx); json_attr_object_end (&json_ctx); json_attr_object_end (&json_ctx);