From patchwork Mon Jul 13 17:53:05 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Stuart Haslam X-Patchwork-Id: 51077 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-wg0-f70.google.com (mail-wg0-f70.google.com [74.125.82.70]) by ip-10-151-82-157.ec2.internal (Postfix) with ESMTPS id 6077920319 for ; Mon, 13 Jul 2015 17:54:56 +0000 (UTC) Received: by wgwk7 with SMTP id k7sf50538130wgw.0 for ; Mon, 13 Jul 2015 10:54:55 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:delivered-to:delivered-to:from:to:date :message-id:in-reply-to:references:subject:precedence:list-id :list-unsubscribe:list-archive:list-post:list-help:list-subscribe :mime-version:content-type:content-transfer-encoding:errors-to :sender:x-original-sender:x-original-authentication-results :mailing-list; bh=z2l4ROTMTqmZm3PmB/1AkRi38K6iY/BNB4f24dByvcI=; b=dSPgokVJwBm5Gj4jHmeWNGOSLA2xJMToalxBoaAc12mLPWz09H4fnzekNJ3JC0BC2I WsyuUI86VHJnF5f5VlH0pRnJl1kUztaXy48FBpRubEb1YdgyflP2QKM3Ykw7Iw6rKS7f Qqpqv0/WoLe8w6LidVdoDhc2u58lC9HvYKvgFILZBmEqpnyZEJyN5WjCS4Hx06Byp6RI 6QO2uaqngJ8XRwxmUsKE0uVmpnmrF0Z2YvTgo2Y2ArUawfEIY4NFMrdRgsmjVkZe1uI3 Oukl6P6ZXx7da62GevDK+pXr/OYm/2mg/mYSzYAsE32aYvxFpiefN4klc0bR+7jHAp0A fneg== X-Gm-Message-State: ALoCoQlZopxgDRC0sYpkc1nQELBuBZwrEHHNR8KNnE/sohKzJcu04KA59MyWZECCKrEXYS/UWCQw X-Received: by 10.152.8.110 with SMTP id q14mr3446254laa.3.1436810095608; Mon, 13 Jul 2015 10:54:55 -0700 (PDT) X-BeenThere: patchwork-forward@linaro.org Received: by 10.152.36.169 with SMTP id r9ls1427477laj.86.gmail; Mon, 13 Jul 2015 10:54:55 -0700 (PDT) X-Received: by 10.112.77.103 with SMTP id r7mr32816339lbw.63.1436810095439; Mon, 13 Jul 2015 10:54:55 -0700 (PDT) Received: from mail-lb0-f180.google.com (mail-lb0-f180.google.com. [209.85.217.180]) by mx.google.com with ESMTPS id da2si15463489lac.117.2015.07.13.10.54.55 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 13 Jul 2015 10:54:55 -0700 (PDT) Received-SPF: pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.217.180 as permitted sender) client-ip=209.85.217.180; Received: by lblf12 with SMTP id f12so59906272lbl.2 for ; Mon, 13 Jul 2015 10:54:55 -0700 (PDT) X-Received: by 10.112.120.134 with SMTP id lc6mr6835703lbb.86.1436810095273; Mon, 13 Jul 2015 10:54:55 -0700 (PDT) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patch@linaro.org Received: by 10.112.108.230 with SMTP id hn6csp1877262lbb; Mon, 13 Jul 2015 10:54:53 -0700 (PDT) X-Received: by 10.55.48.18 with SMTP id w18mr55410983qkw.34.1436810093379; Mon, 13 Jul 2015 10:54:53 -0700 (PDT) Received: from lists.linaro.org (lists.linaro.org. [54.225.227.206]) by mx.google.com with ESMTP id r72si21035189qkr.99.2015.07.13.10.54.52; Mon, 13 Jul 2015 10:54:53 -0700 (PDT) Received-SPF: pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) client-ip=54.225.227.206; Received: by lists.linaro.org (Postfix, from userid 109) id 808E161E25; Mon, 13 Jul 2015 17:54:52 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on ip-10-142-244-252.ec2.internal X-Spam-Level: X-Spam-Status: No, score=-2.6 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, URIBL_BLOCKED autolearn=disabled version=3.4.0 Received: from ip-10-142-244-252.ec2.internal (localhost [127.0.0.1]) by lists.linaro.org (Postfix) with ESMTP id 4E8E961E27; Mon, 13 Jul 2015 17:53:51 +0000 (UTC) X-Original-To: lng-odp@lists.linaro.org Delivered-To: lng-odp@lists.linaro.org Received: by lists.linaro.org (Postfix, from userid 109) id 6ADB461E1F; Mon, 13 Jul 2015 17:53:42 +0000 (UTC) Received: from mail-wi0-f181.google.com (mail-wi0-f181.google.com [209.85.212.181]) by lists.linaro.org (Postfix) with ESMTPS id 0FEFE61E14 for ; Mon, 13 Jul 2015 17:53:30 +0000 (UTC) Received: by widic2 with SMTP id ic2so18892048wid.0 for ; Mon, 13 Jul 2015 10:53:29 -0700 (PDT) X-Received: by 10.194.142.209 with SMTP id ry17mr73403320wjb.5.1436810009171; Mon, 13 Jul 2015 10:53:29 -0700 (PDT) Received: from e106441.cambridge.arm.com ([2001:41d0:a:3cb4::abcd]) by smtp.gmail.com with ESMTPSA id fm8sm15888662wib.9.2015.07.13.10.53.27 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 13 Jul 2015 10:53:28 -0700 (PDT) From: Stuart Haslam To: lng-odp@lists.linaro.org Date: Mon, 13 Jul 2015 18:53:05 +0100 Message-Id: <1436809989-9225-3-git-send-email-stuart.haslam@linaro.org> X-Mailer: git-send-email 2.1.1 In-Reply-To: <1436809989-9225-1-git-send-email-stuart.haslam@linaro.org> References: <1436809989-9225-1-git-send-email-stuart.haslam@linaro.org> X-Topics: patch Subject: [lng-odp] [API-NEXT PATCH 2/6] validation: split out cpumask tests into separate file X-BeenThere: lng-odp@lists.linaro.org X-Mailman-Version: 2.1.16 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: , List-Help: , List-Subscribe: , MIME-Version: 1.0 Errors-To: lng-odp-bounces@lists.linaro.org Sender: "lng-odp" X-Removed-Original-Auth: Dkim didn't pass. X-Original-Sender: stuart.haslam@linaro.org X-Original-Authentication-Results: mx.google.com; spf=pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.217.180 as permitted sender) smtp.mail=patch+caf_=patchwork-forward=linaro.org@linaro.org Mailing-list: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org X-Google-Group-Id: 836684582541 Split the test cases out into a separate file in preparation for sharing them to perform thrmask tests. Signed-off-by: Stuart Haslam --- test/validation/cpumask/Makefile.am | 2 +- test/validation/cpumask/cpumask.c | 463 +-------------------------------- test/validation/cpumask/mask_common.c | 470 ++++++++++++++++++++++++++++++++++ test/validation/cpumask/mask_common.h | 28 ++ 4 files changed, 501 insertions(+), 462 deletions(-) create mode 100644 test/validation/cpumask/mask_common.c create mode 100644 test/validation/cpumask/mask_common.h diff --git a/test/validation/cpumask/Makefile.am b/test/validation/cpumask/Makefile.am index 61b65ec..da46c5e 100644 --- a/test/validation/cpumask/Makefile.am +++ b/test/validation/cpumask/Makefile.am @@ -1,7 +1,7 @@ include ../Makefile.inc noinst_LIBRARIES = libcpumask.a -libcpumask_a_SOURCES = cpumask.c +libcpumask_a_SOURCES = cpumask.c mask_common.c bin_PROGRAMS = cpumask_main$(EXEEXT) dist_cpumask_main_SOURCES = cpumask_main.c diff --git a/test/validation/cpumask/cpumask.c b/test/validation/cpumask/cpumask.c index d4daa61..c86a6ee 100644 --- a/test/validation/cpumask/cpumask.c +++ b/test/validation/cpumask/cpumask.c @@ -5,473 +5,14 @@ */ #include + #include "odp_cunit_common.h" #include "cpumask.h" - -/* - * The following string are used to build cpu masks with - * odp_cpumask_from_str(). Both 0x prefixed and non prefixed - * hex values are supported by odp_cpumask_from_str() - */ -#define TEST_MASK_NO_CPU "0x0" -#define TEST_MASK_CPU_0 "0x1" -#define TEST_MASK_CPU_1 "0x2" -#define TEST_MASK_CPU_2 "0x4" -#define TEST_MASK_CPU_0_2 "0x5" -#define TEST_MASK_CPU_0_3 "0x9" -#define TEST_MASK_CPU_1_2 "0x6" -#define TEST_MASK_CPU_1_3 "0xA" -#define TEST_MASK_CPU_0_1_2 "0x7" -#define TEST_MASK_CPU_0_2_4_6 "0x55" -#define TEST_MASK_CPU_1_2_4_6 "0x56" - -#define TEST_MASK_CPU_0_NO_PREFIX "1" - -/* padding pattern used to check buffer overflow: */ -#define FILLING_PATTERN 0x55 +#include "mask_common.h" /* default worker paramiter to get all that may be available */ #define ALL_AVAILABLE 0 -/* - * returns the length of a string, excluding terminating NULL. - * As its C lib strlen equivalent. Just rewritten here to avoid C lib - * dependency in ODP tests (for platform independent / bare metal testing) - */ -static unsigned int stringlen(const char *str) -{ - unsigned int i = 0; - - while (str[i] != 0) - i++; - return i; -} - -/* - * builds a string containing a 0x prefixed hex number - * where a single bit (corresponding to cpu) is set. - * The string is null terminated. - * cpu_to_str(0) returns "0x1". - * cpu_to_str(10) returns "0x400". - * The buffer should be at least ceil(cpu/4)+3 bytes long, - * to accommodate with 4 cpus per nibble + "0x" prefix + null. - */ -#define CPUS_PER_NIBBLE 4 -static void cpu_to_str(char *buff, int cpu) -{ - const char *hex_nibble = "1248"; - int i = 0; - - buff[i++] = '0'; - buff[i++] = 'x'; - buff[i++] = hex_nibble[cpu % CPUS_PER_NIBBLE]; - while (cpu > 3) { - buff[i++] = '0'; - cpu -= CPUS_PER_NIBBLE; - } - buff[i++] = 0; /* null */ -} - -/* - * returns the mask size to be tested... - * There is a bit of confusion right now about how to get this, - * so this is centralized here... in case of change... - */ -static unsigned int get_max_number_of_cpus_in_a_mask(void) -{ - return odp_cpu_count(); -} - -static void cpumask_test_odp_cpumask_to_from_str(void) -{ - odp_cpumask_t mask; - int32_t str_sz; - unsigned int buf_sz; /* buf size for the 2 following bufs */ - char *buf_in; - char *buf_out; - unsigned int cpu; - unsigned int i; - - /* makes sure the mask has room for at least 1 CPU...: */ - CU_ASSERT_FATAL(get_max_number_of_cpus_in_a_mask() > 0); - - /* allocate memory for the buffers containing the mask strings: - 1 char per nibble, i.e. 1 char per 4 cpus +extra for "0x" and null:*/ - buf_sz = (get_max_number_of_cpus_in_a_mask() >> 2) + 20; - buf_in = malloc(buf_sz); - buf_out = malloc(buf_sz); - CU_ASSERT_FATAL(buf_in && buf_out); - - /* test 1 CPU at a time for all possible cpu positions in the mask */ - for (cpu = 0; cpu < get_max_number_of_cpus_in_a_mask(); cpu++) { - /* init buffer for overwrite check: */ - for (i = 0; i < buf_sz; i++) - buf_out[i] = FILLING_PATTERN; - - /* generate a hex string with that cpu set: */ - cpu_to_str(buf_in, cpu); - - /* generate mask: */ - odp_cpumask_from_str(&mask, buf_in); - - /* reverse cpu mask computation to get string back: */ - str_sz = odp_cpumask_to_str(&mask, buf_out, - stringlen(buf_in) + 1); - - /* check that returned size matches original (with NULL): */ - CU_ASSERT(str_sz == (int32_t)stringlen(buf_in) + 1); - - /* check that returned string matches original (with NULL): */ - CU_ASSERT_NSTRING_EQUAL(buf_out, buf_in, stringlen(buf_in) + 1); - - /* check that no extra buffer writes occurred: */ - CU_ASSERT(buf_out[stringlen(buf_in) + 2] == FILLING_PATTERN); - } - - /* re-init buffer for overwrite check: */ - for (i = 0; i < buf_sz; i++) - buf_out[i] = FILLING_PATTERN; - - /* check for buffer overflow when too small buffer given: */ - odp_cpumask_from_str(&mask, TEST_MASK_CPU_0); - str_sz = odp_cpumask_to_str(&mask, buf_out, stringlen(TEST_MASK_CPU_0)); - - CU_ASSERT(str_sz == -1); - - for (i = 0; i < buf_sz; i++) - CU_ASSERT(buf_out[i] == FILLING_PATTERN); - - /* check for handling of missing "0x" prefix: */ - odp_cpumask_from_str(&mask, TEST_MASK_CPU_0_NO_PREFIX); - - str_sz = odp_cpumask_to_str(&mask, buf_out, - stringlen(TEST_MASK_CPU_0) + 1); - - CU_ASSERT_NSTRING_EQUAL(buf_out, TEST_MASK_CPU_0, - stringlen(TEST_MASK_CPU_0) + 1); - - free(buf_out); - free(buf_in); -} - -static void cpumask_test_odp_cpumask_equal(void) -{ - odp_cpumask_t mask1; - odp_cpumask_t mask2; - odp_cpumask_t mask3; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); - odp_cpumask_from_str(&mask3, TEST_MASK_NO_CPU); - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); - CU_ASSERT_FALSE(odp_cpumask_equal(&mask1, &mask3)); - - if (get_max_number_of_cpus_in_a_mask() < 4) - return; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2); - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0_2); - odp_cpumask_from_str(&mask3, TEST_MASK_CPU_1_2); - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); - CU_ASSERT_FALSE(odp_cpumask_equal(&mask1, &mask3)); - - if (get_max_number_of_cpus_in_a_mask() < 8) - return; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2_4_6); - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0_2_4_6); - odp_cpumask_from_str(&mask3, TEST_MASK_CPU_1_2_4_6); - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); - CU_ASSERT_FALSE(odp_cpumask_equal(&mask1, &mask3)); -} - -static void cpumask_test_odp_cpumask_zero(void) -{ - odp_cpumask_t mask1; - odp_cpumask_t mask2; - - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); - odp_cpumask_zero(&mask2); - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); -} - -static void cpumask_test_odp_cpumask_set(void) -{ - odp_cpumask_t mask1; - odp_cpumask_t mask2; - - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); - odp_cpumask_set(&mask1, 0); - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); - - if (get_max_number_of_cpus_in_a_mask() < 4) - return; - - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0_3); - odp_cpumask_set(&mask1, 3); - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); - - /* make sure that re-asserting a cpu has no impact: */ - odp_cpumask_set(&mask1, 3); - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); -} - -static void cpumask_test_odp_cpumask_clr(void) -{ - odp_cpumask_t mask1; - odp_cpumask_t mask2; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); - odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU); - odp_cpumask_clr(&mask1, 0); - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); - - if (get_max_number_of_cpus_in_a_mask() < 4) - return; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2); - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); - odp_cpumask_clr(&mask1, 2); - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); - - odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU); - odp_cpumask_clr(&mask1, 0); - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); - - /* make sure that re-clearing a cpu has no impact: */ - odp_cpumask_clr(&mask1, 0); - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); -} - -static void cpumask_test_odp_cpumask_isset(void) -{ - odp_cpumask_t mask1; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); - CU_ASSERT(odp_cpumask_isset(&mask1, 0)); - - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); - CU_ASSERT_FALSE(odp_cpumask_isset(&mask1, 0)); - - if (get_max_number_of_cpus_in_a_mask() < 4) - return; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2); - CU_ASSERT(odp_cpumask_isset(&mask1, 0)); - CU_ASSERT_FALSE(odp_cpumask_isset(&mask1, 1)); - CU_ASSERT(odp_cpumask_isset(&mask1, 2)); - CU_ASSERT_FALSE(odp_cpumask_isset(&mask1, 3)); -} - -static void cpumask_test_odp_cpumask_count(void) -{ - odp_cpumask_t mask1; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); - CU_ASSERT(odp_cpumask_count(&mask1) == 1); - - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); - CU_ASSERT(odp_cpumask_count(&mask1) == 0); - - if (get_max_number_of_cpus_in_a_mask() < 4) - return; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2); - CU_ASSERT(odp_cpumask_count(&mask1) == 2); -} - -static void cpumask_test_odp_cpumask_and(void) -{ - odp_cpumask_t mask1; - odp_cpumask_t mask2; - odp_cpumask_t mask3; - odp_cpumask_t mask4; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); - odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0); - odp_cpumask_and(&mask3, &mask1, &mask2); - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); - - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); - odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU); - odp_cpumask_and(&mask3, &mask1, &mask2); - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); - - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); - odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU); - odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU); - odp_cpumask_and(&mask3, &mask1, &mask2); - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); - - if (get_max_number_of_cpus_in_a_mask() < 4) - return; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2); - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_1_2); - odp_cpumask_from_str(&mask4, TEST_MASK_CPU_2); - odp_cpumask_and(&mask3, &mask1, &mask2); - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); -} - -static void cpumask_test_odp_cpumask_or(void) -{ - odp_cpumask_t mask1; - odp_cpumask_t mask2; - odp_cpumask_t mask3; - odp_cpumask_t mask4; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); - odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0); - odp_cpumask_or(&mask3, &mask1, &mask2); - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); - - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); - odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0); - odp_cpumask_or(&mask3, &mask1, &mask2); - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); - - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); - odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU); - odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU); - odp_cpumask_or(&mask3, &mask1, &mask2); - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); - - if (get_max_number_of_cpus_in_a_mask() < 4) - return; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2); - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_1); - odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0_1_2); - odp_cpumask_or(&mask3, &mask1, &mask2); - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); -} - -static void cpumask_test_odp_cpumask_xor(void) -{ - odp_cpumask_t mask1; - odp_cpumask_t mask2; - odp_cpumask_t mask3; - odp_cpumask_t mask4; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); - odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU); - odp_cpumask_xor(&mask3, &mask1, &mask2); - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); - - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); - odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0); - odp_cpumask_xor(&mask3, &mask1, &mask2); - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); - - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); - odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU); - odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU); - odp_cpumask_xor(&mask3, &mask1, &mask2); - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); - - if (get_max_number_of_cpus_in_a_mask() < 4) - return; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_2); - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_1_2); - odp_cpumask_from_str(&mask4, TEST_MASK_CPU_1); - odp_cpumask_xor(&mask3, &mask1, &mask2); - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); -} - -static void cpumask_test_odp_cpumask_copy(void) -{ - odp_cpumask_t mask1; - odp_cpumask_t mask2; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); - odp_cpumask_copy(&mask2, &mask1); - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); -} - -static void cpumask_test_odp_cpumask_first(void) -{ - odp_cpumask_t mask1; - - /* check when there is no first */ - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); - CU_ASSERT(odp_cpumask_first(&mask1) == -1); - - /* single CPU case: */ - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); - CU_ASSERT(odp_cpumask_first(&mask1) == 0); - - if (get_max_number_of_cpus_in_a_mask() < 4) - return; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_1_3); - CU_ASSERT(odp_cpumask_first(&mask1) == 1); -} - -static void cpumask_test_odp_cpumask_last(void) -{ - odp_cpumask_t mask1; - - /* check when there is no last: */ - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); - CU_ASSERT(odp_cpumask_last(&mask1) == -1); - - /* single CPU case: */ - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); - CU_ASSERT(odp_cpumask_last(&mask1) == 0); - - if (get_max_number_of_cpus_in_a_mask() < 4) - return; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_1_3); - CU_ASSERT(odp_cpumask_last(&mask1) == 3); -} - -static void cpumask_test_odp_cpumask_next(void) -{ - unsigned int i; - int expected[] = {1, 3, 3, -1}; - odp_cpumask_t mask1; - - /* case when the mask does not contain any CPU: */ - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); - CU_ASSERT(odp_cpumask_next(&mask1, -1) == -1); - - /* case when the mask just contain CPU 0: */ - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); - CU_ASSERT(odp_cpumask_next(&mask1, -1) == 0); - CU_ASSERT(odp_cpumask_next(&mask1, 0) == -1); - - if (get_max_number_of_cpus_in_a_mask() < 4) - return; - - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_1_3); - - for (i = 0; i < sizeof(expected) / sizeof(int); i++) - CU_ASSERT(odp_cpumask_next(&mask1, i) == expected[i]); -} - -static void cpumask_test_odp_cpumask_setall(void) -{ - int num_cpus; - int max_cpus = get_max_number_of_cpus_in_a_mask(); - odp_cpumask_t mask; - - odp_cpumask_setall(&mask); - num_cpus = odp_cpumask_count(&mask); - - CU_ASSERT(num_cpus > 0); - CU_ASSERT(num_cpus >= max_cpus); -} - static void cpumask_test_odp_cpumask_def_control(void) { int num; diff --git a/test/validation/cpumask/mask_common.c b/test/validation/cpumask/mask_common.c new file mode 100644 index 0000000..0ed38ff --- /dev/null +++ b/test/validation/cpumask/mask_common.c @@ -0,0 +1,470 @@ +/* Copyright (c) 2015, Linaro Limited + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "odp_cunit_common.h" +#include "mask_common.h" + +/* + * The following string are used to build cpu masks with + * odp_cpumask_from_str(). Both 0x prefixed and non prefixed + * hex values are supported by odp_cpumask_from_str() + */ +#define TEST_MASK_NO_CPU "0x0" +#define TEST_MASK_CPU_0 "0x1" +#define TEST_MASK_CPU_1 "0x2" +#define TEST_MASK_CPU_2 "0x4" +#define TEST_MASK_CPU_0_2 "0x5" +#define TEST_MASK_CPU_0_3 "0x9" +#define TEST_MASK_CPU_1_2 "0x6" +#define TEST_MASK_CPU_1_3 "0xA" +#define TEST_MASK_CPU_0_1_2 "0x7" +#define TEST_MASK_CPU_0_2_4_6 "0x55" +#define TEST_MASK_CPU_1_2_4_6 "0x56" + +#define TEST_MASK_CPU_0_NO_PREFIX "1" + +/* padding pattern used to check buffer overflow: */ +#define FILLING_PATTERN 0x55 + +/* + * returns the length of a string, excluding terminating NULL. + * As its C lib strlen equivalent. Just rewritten here to avoid C lib + * dependency in ODP tests (for platform independent / bare metal testing) + */ +static unsigned int stringlen(const char *str) +{ + unsigned int i = 0; + + while (str[i] != 0) + i++; + return i; +} + +/* + * builds a string containing a 0x prefixed hex number + * where a single bit (corresponding to cpu) is set. + * The string is null terminated. + * cpu_to_str(0) returns "0x1". + * cpu_to_str(10) returns "0x400". + * The buffer should be at least ceil(cpu/4)+3 bytes long, + * to accommodate with 4 cpus per nibble + "0x" prefix + null. + */ +#define CPUS_PER_NIBBLE 4 +static void cpu_to_str(char *buff, int cpu) +{ + const char *hex_nibble = "1248"; + int i = 0; + + buff[i++] = '0'; + buff[i++] = 'x'; + buff[i++] = hex_nibble[cpu % CPUS_PER_NIBBLE]; + while (cpu > 3) { + buff[i++] = '0'; + cpu -= CPUS_PER_NIBBLE; + } + buff[i++] = 0; /* null */ +} + +/* + * returns the mask size to be tested... + * There is a bit of confusion right now about how to get this, + * so this is centralized here... in case of change... + */ +unsigned int get_max_number_of_cpus_in_a_mask(void) +{ + return odp_cpu_count(); +} + +void cpumask_test_odp_cpumask_to_from_str(void) +{ + odp_cpumask_t mask; + int32_t str_sz; + unsigned int buf_sz; /* buf size for the 2 following bufs */ + char *buf_in; + char *buf_out; + unsigned int cpu; + unsigned int i; + + /* makes sure the mask has room for at least 1 CPU...: */ + CU_ASSERT_FATAL(get_max_number_of_cpus_in_a_mask() > 0); + + /* allocate memory for the buffers containing the mask strings: + 1 char per nibble, i.e. 1 char per 4 cpus +extra for "0x" and null:*/ + buf_sz = (get_max_number_of_cpus_in_a_mask() >> 2) + 20; + buf_in = malloc(buf_sz); + buf_out = malloc(buf_sz); + CU_ASSERT_FATAL(buf_in && buf_out); + + /* test 1 CPU at a time for all possible cpu positions in the mask */ + for (cpu = 0; cpu < get_max_number_of_cpus_in_a_mask(); cpu++) { + /* init buffer for overwrite check: */ + for (i = 0; i < buf_sz; i++) + buf_out[i] = FILLING_PATTERN; + + /* generate a hex string with that cpu set: */ + cpu_to_str(buf_in, cpu); + + /* generate mask: */ + odp_cpumask_from_str(&mask, buf_in); + + /* reverse cpu mask computation to get string back: */ + str_sz = odp_cpumask_to_str(&mask, buf_out, + stringlen(buf_in) + 1); + + /* check that returned size matches original (with NULL): */ + CU_ASSERT(str_sz == (int32_t)stringlen(buf_in) + 1); + + /* check that returned string matches original (with NULL): */ + CU_ASSERT_NSTRING_EQUAL(buf_out, buf_in, stringlen(buf_in) + 1); + + /* check that no extra buffer writes occurred: */ + CU_ASSERT(buf_out[stringlen(buf_in) + 2] == FILLING_PATTERN); + } + + /* re-init buffer for overwrite check: */ + for (i = 0; i < buf_sz; i++) + buf_out[i] = FILLING_PATTERN; + + /* check for buffer overflow when too small buffer given: */ + odp_cpumask_from_str(&mask, TEST_MASK_CPU_0); + str_sz = odp_cpumask_to_str(&mask, buf_out, stringlen(TEST_MASK_CPU_0)); + + CU_ASSERT(str_sz == -1); + + for (i = 0; i < buf_sz; i++) + CU_ASSERT(buf_out[i] == FILLING_PATTERN); + + /* check for handling of missing "0x" prefix: */ + odp_cpumask_from_str(&mask, TEST_MASK_CPU_0_NO_PREFIX); + + str_sz = odp_cpumask_to_str(&mask, buf_out, + stringlen(TEST_MASK_CPU_0) + 1); + + CU_ASSERT_NSTRING_EQUAL(buf_out, TEST_MASK_CPU_0, + stringlen(TEST_MASK_CPU_0) + 1); + + free(buf_out); + free(buf_in); +} + +void cpumask_test_odp_cpumask_equal(void) +{ + odp_cpumask_t mask1; + odp_cpumask_t mask2; + odp_cpumask_t mask3; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); + odp_cpumask_from_str(&mask3, TEST_MASK_NO_CPU); + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); + CU_ASSERT_FALSE(odp_cpumask_equal(&mask1, &mask3)); + + if (get_max_number_of_cpus_in_a_mask() < 4) + return; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2); + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0_2); + odp_cpumask_from_str(&mask3, TEST_MASK_CPU_1_2); + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); + CU_ASSERT_FALSE(odp_cpumask_equal(&mask1, &mask3)); + + if (get_max_number_of_cpus_in_a_mask() < 8) + return; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2_4_6); + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0_2_4_6); + odp_cpumask_from_str(&mask3, TEST_MASK_CPU_1_2_4_6); + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); + CU_ASSERT_FALSE(odp_cpumask_equal(&mask1, &mask3)); +} + +void cpumask_test_odp_cpumask_zero(void) +{ + odp_cpumask_t mask1; + odp_cpumask_t mask2; + + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); + odp_cpumask_zero(&mask2); + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); +} + +void cpumask_test_odp_cpumask_set(void) +{ + odp_cpumask_t mask1; + odp_cpumask_t mask2; + + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); + odp_cpumask_set(&mask1, 0); + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); + + if (get_max_number_of_cpus_in_a_mask() < 4) + return; + + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0_3); + odp_cpumask_set(&mask1, 3); + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); + + /* make sure that re-asserting a cpu has no impact: */ + odp_cpumask_set(&mask1, 3); + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); +} + +void cpumask_test_odp_cpumask_clr(void) +{ + odp_cpumask_t mask1; + odp_cpumask_t mask2; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); + odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU); + odp_cpumask_clr(&mask1, 0); + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); + + if (get_max_number_of_cpus_in_a_mask() < 4) + return; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2); + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); + odp_cpumask_clr(&mask1, 2); + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); + + odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU); + odp_cpumask_clr(&mask1, 0); + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); + + /* make sure that re-clearing a cpu has no impact: */ + odp_cpumask_clr(&mask1, 0); + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); +} + +void cpumask_test_odp_cpumask_isset(void) +{ + odp_cpumask_t mask1; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); + CU_ASSERT(odp_cpumask_isset(&mask1, 0)); + + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); + CU_ASSERT_FALSE(odp_cpumask_isset(&mask1, 0)); + + if (get_max_number_of_cpus_in_a_mask() < 4) + return; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2); + CU_ASSERT(odp_cpumask_isset(&mask1, 0)); + CU_ASSERT_FALSE(odp_cpumask_isset(&mask1, 1)); + CU_ASSERT(odp_cpumask_isset(&mask1, 2)); + CU_ASSERT_FALSE(odp_cpumask_isset(&mask1, 3)); +} + +void cpumask_test_odp_cpumask_count(void) +{ + odp_cpumask_t mask1; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); + CU_ASSERT(odp_cpumask_count(&mask1) == 1); + + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); + CU_ASSERT(odp_cpumask_count(&mask1) == 0); + + if (get_max_number_of_cpus_in_a_mask() < 4) + return; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2); + CU_ASSERT(odp_cpumask_count(&mask1) == 2); +} + +void cpumask_test_odp_cpumask_and(void) +{ + odp_cpumask_t mask1; + odp_cpumask_t mask2; + odp_cpumask_t mask3; + odp_cpumask_t mask4; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); + odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0); + odp_cpumask_and(&mask3, &mask1, &mask2); + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); + + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); + odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU); + odp_cpumask_and(&mask3, &mask1, &mask2); + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); + + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); + odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU); + odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU); + odp_cpumask_and(&mask3, &mask1, &mask2); + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); + + if (get_max_number_of_cpus_in_a_mask() < 4) + return; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2); + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_1_2); + odp_cpumask_from_str(&mask4, TEST_MASK_CPU_2); + odp_cpumask_and(&mask3, &mask1, &mask2); + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); +} + +void cpumask_test_odp_cpumask_or(void) +{ + odp_cpumask_t mask1; + odp_cpumask_t mask2; + odp_cpumask_t mask3; + odp_cpumask_t mask4; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); + odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0); + odp_cpumask_or(&mask3, &mask1, &mask2); + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); + + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); + odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0); + odp_cpumask_or(&mask3, &mask1, &mask2); + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); + + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); + odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU); + odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU); + odp_cpumask_or(&mask3, &mask1, &mask2); + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); + + if (get_max_number_of_cpus_in_a_mask() < 4) + return; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2); + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_1); + odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0_1_2); + odp_cpumask_or(&mask3, &mask1, &mask2); + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); +} + +void cpumask_test_odp_cpumask_xor(void) +{ + odp_cpumask_t mask1; + odp_cpumask_t mask2; + odp_cpumask_t mask3; + odp_cpumask_t mask4; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); + odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU); + odp_cpumask_xor(&mask3, &mask1, &mask2); + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); + + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0); + odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0); + odp_cpumask_xor(&mask3, &mask1, &mask2); + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); + + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); + odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU); + odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU); + odp_cpumask_xor(&mask3, &mask1, &mask2); + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); + + if (get_max_number_of_cpus_in_a_mask() < 4) + return; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_2); + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_1_2); + odp_cpumask_from_str(&mask4, TEST_MASK_CPU_1); + odp_cpumask_xor(&mask3, &mask1, &mask2); + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4)); +} + +void cpumask_test_odp_cpumask_copy(void) +{ + odp_cpumask_t mask1; + odp_cpumask_t mask2; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); + odp_cpumask_copy(&mask2, &mask1); + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); +} + +void cpumask_test_odp_cpumask_first(void) +{ + odp_cpumask_t mask1; + + /* check when there is no first */ + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); + CU_ASSERT(odp_cpumask_first(&mask1) == -1); + + /* single CPU case: */ + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); + CU_ASSERT(odp_cpumask_first(&mask1) == 0); + + if (get_max_number_of_cpus_in_a_mask() < 4) + return; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_1_3); + CU_ASSERT(odp_cpumask_first(&mask1) == 1); +} + +void cpumask_test_odp_cpumask_last(void) +{ + odp_cpumask_t mask1; + + /* check when there is no last: */ + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); + CU_ASSERT(odp_cpumask_last(&mask1) == -1); + + /* single CPU case: */ + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); + CU_ASSERT(odp_cpumask_last(&mask1) == 0); + + if (get_max_number_of_cpus_in_a_mask() < 4) + return; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_1_3); + CU_ASSERT(odp_cpumask_last(&mask1) == 3); +} + +void cpumask_test_odp_cpumask_next(void) +{ + unsigned int i; + int expected[] = {1, 3, 3, -1}; + odp_cpumask_t mask1; + + /* case when the mask does not contain any CPU: */ + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); + CU_ASSERT(odp_cpumask_next(&mask1, -1) == -1); + + /* case when the mask just contain CPU 0: */ + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); + CU_ASSERT(odp_cpumask_next(&mask1, -1) == 0); + CU_ASSERT(odp_cpumask_next(&mask1, 0) == -1); + + if (get_max_number_of_cpus_in_a_mask() < 4) + return; + + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_1_3); + + for (i = 0; i < sizeof(expected) / sizeof(int); i++) + CU_ASSERT(odp_cpumask_next(&mask1, i) == expected[i]); +} + +void cpumask_test_odp_cpumask_setall(void) +{ + int num_cpus; + int max_cpus = get_max_number_of_cpus_in_a_mask(); + odp_cpumask_t mask; + + odp_cpumask_setall(&mask); + num_cpus = odp_cpumask_count(&mask); + + CU_ASSERT(num_cpus > 0); + CU_ASSERT(num_cpus >= max_cpus); +} diff --git a/test/validation/cpumask/mask_common.h b/test/validation/cpumask/mask_common.h new file mode 100644 index 0000000..49062b5 --- /dev/null +++ b/test/validation/cpumask/mask_common.h @@ -0,0 +1,28 @@ +/* Copyright (c) 2015, Linaro Limited + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef ODP_MASK_COMMON_H_ +#define ODP_MASK_COMMON_H_ + +unsigned int get_max_number_of_cpus_in_a_mask(void); + +void cpumask_test_odp_cpumask_to_from_str(void); +void cpumask_test_odp_cpumask_equal(void); +void cpumask_test_odp_cpumask_zero(void); +void cpumask_test_odp_cpumask_set(void); +void cpumask_test_odp_cpumask_clr(void); +void cpumask_test_odp_cpumask_isset(void); +void cpumask_test_odp_cpumask_count(void); +void cpumask_test_odp_cpumask_and(void); +void cpumask_test_odp_cpumask_or(void); +void cpumask_test_odp_cpumask_xor(void); +void cpumask_test_odp_cpumask_copy(void); +void cpumask_test_odp_cpumask_first(void); +void cpumask_test_odp_cpumask_last(void); +void cpumask_test_odp_cpumask_next(void); +void cpumask_test_odp_cpumask_setall(void); + +#endif