ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
acd2cc94e7
Spdk/test/unit/lib/util/cpuset.c/cpuset_ut.c

244 lines
7.2 KiB
C
Raw Normal View History

Replace most BSD 3-clause license text with SPDX identifier. Many open source projects have moved to using SPDX identifiers to specify license information, reducing the amount of boilerplate code in every source file. This patch replaces the bulk of SPDK .c, .cpp and Makefiles with the BSD-3-Clause identifier. Almost all of these files share the exact same license text, and this patch only modifies the files that contain the most common license text. There can be slight variations because the third clause contains company names - most say "Intel Corporation", but there are instances for Nvidia, Samsung, Eideticom and even "the copyright holder". Used a bash script to automate replacement of the license text with SPDX identifier which is checked into scripts/spdx.sh. Signed-off-by: Jim Harris <james.r.harris@intel.com> Change-Id: Iaa88ab5e92ea471691dc298cfe41ebfb5d169780 Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/12904 Community-CI: Broadcom CI <spdk-ci.pdl@broadcom.com> Community-CI: Mellanox Build Bot Tested-by: SPDK CI Jenkins <sys_sgci@intel.com> Reviewed-by: Aleksey Marchuk <alexeymar@nvidia.com> Reviewed-by: Changpeng Liu <changpeng.liu@intel.com> Reviewed-by: Dong Yi <dongx.yi@intel.com> Reviewed-by: Konrad Sztyber <konrad.sztyber@intel.com> Reviewed-by: Paul Luse <paul.e.luse@intel.com> Reviewed-by: <qun.wan@intel.com>
2022-06-03 19:15:11 +00:00
/* SPDX-License-Identifier: BSD-3-Clause
update Intel copyright notices per Intel policy to include file commit date using git cmd below. The policy does not apply to non-Intel (C) notices. git log --follow -C90% --format=%ad --date default <file> | tail -1 and then pull just the 4 digit year from the result. Intel copyrights were not added to files where Intel either had no contribution ot the contribution lacked substance (ie license header updates, formatting changes, etc). Contribution date used "--follow -C95%" to get the most accurate date. Note that several files in this patch didn't end the license/(c) block with a blank comment line so these were added as the vast majority of files do have this last blank line. Simply there for consistency. Signed-off-by: paul luse <paul.e.luse@intel.com> Change-Id: Id5b7ce4f658fe87132f14139ead58d6e285c04d4 Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/15192 Tested-by: SPDK CI Jenkins <sys_sgci@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com> Reviewed-by: Ben Walker <benjamin.walker@intel.com> Community-CI: Mellanox Build Bot
2022-11-01 20:26:26 +00:00
* Copyright (C) 2017 Intel Corporation.
util: extend cpumask to hold more than 64 cpus Fixes github issue #218. This patch introduces spdk_cpuset object to store and manipulate the set of individual CPUs. The main objective of this object is to replace cpumask declared as uint64_t and extend the limitation of supported CPUs (lcores) above 64 CPUs. spdk_cpuset is always allocated dynamically and accessed by opaque pointer, what makes it easier to extend in the future without breaking API/ABI. This patch also extends parsing function allowing to set cpumask using a list of cpus e.g. "[0-4,10,12]" sets mask of 0,1,2,3,4,10,12 as well as hexadecimal string with and without "0x" prefix. Change-Id: I475c3ba7fab629021a22e03176e57e400dd24a49 Signed-off-by: Tomasz Kulasek <tomaszx.kulasek@intel.com> Reviewed-on: https://review.gerrithub.io/390794 Tested-by: SPDK Automated Test System <sys_sgsw@intel.com> Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com>
2017-12-21 16:48:31 +00:00
* All rights reserved.
*/
#include "spdk/stdinc.h"
#include "spdk/cpuset.h"
#include "spdk_cunit.h"
#include "util/cpuset.c"
static int
cpuset_check_range(struct spdk_cpuset *core_mask, uint32_t min, uint32_t max, bool isset)
{
uint32_t core;
for (core = min; core <= max; core++) {
if (isset != spdk_cpuset_get_cpu(core_mask, core)) {
return -1;
}
}
return 0;
}
static void
test_cpuset(void)
{
uint32_t cpu;
struct spdk_cpuset *set = spdk_cpuset_alloc();
SPDK_CU_ASSERT_FATAL(set != NULL);
CU_ASSERT(spdk_cpuset_count(set) == 0);
/* Set cpu 0 */
spdk_cpuset_set_cpu(set, 0, true);
CU_ASSERT(spdk_cpuset_get_cpu(set, 0) == true);
CU_ASSERT(cpuset_check_range(set, 1, SPDK_CPUSET_SIZE - 1, false) == 0);
CU_ASSERT(spdk_cpuset_count(set) == 1);
/* Set last cpu (cpu 0 already set) */
spdk_cpuset_set_cpu(set, SPDK_CPUSET_SIZE - 1, true);
CU_ASSERT(spdk_cpuset_get_cpu(set, 0) == true);
CU_ASSERT(spdk_cpuset_get_cpu(set, SPDK_CPUSET_SIZE - 1) == true);
CU_ASSERT(cpuset_check_range(set, 1, SPDK_CPUSET_SIZE - 2, false) == 0);
CU_ASSERT(spdk_cpuset_count(set) == 2);
/* Clear cpu 0 (last cpu already set) */
spdk_cpuset_set_cpu(set, 0, false);
CU_ASSERT(spdk_cpuset_get_cpu(set, 0) == false);
CU_ASSERT(cpuset_check_range(set, 1, SPDK_CPUSET_SIZE - 2, false) == 0);
CU_ASSERT(spdk_cpuset_get_cpu(set, SPDK_CPUSET_SIZE - 1) == true);
CU_ASSERT(spdk_cpuset_count(set) == 1);
/* Set middle cpu (last cpu already set) */
cpu = (SPDK_CPUSET_SIZE - 1) / 2;
spdk_cpuset_set_cpu(set, cpu, true);
CU_ASSERT(spdk_cpuset_get_cpu(set, cpu) == true);
CU_ASSERT(spdk_cpuset_get_cpu(set, SPDK_CPUSET_SIZE - 1) == true);
CU_ASSERT(cpuset_check_range(set, 1, cpu - 1, false) == 0);
CU_ASSERT(cpuset_check_range(set, cpu + 1, SPDK_CPUSET_SIZE - 2, false) == 0);
CU_ASSERT(spdk_cpuset_count(set) == 2);
/* Set all cpus */
for (cpu = 0; cpu < SPDK_CPUSET_SIZE; cpu++) {
spdk_cpuset_set_cpu(set, cpu, true);
}
CU_ASSERT(cpuset_check_range(set, 0, SPDK_CPUSET_SIZE - 1, true) == 0);
CU_ASSERT(spdk_cpuset_count(set) == SPDK_CPUSET_SIZE);
/* Clear all cpus */
spdk_cpuset_zero(set);
CU_ASSERT(cpuset_check_range(set, 0, SPDK_CPUSET_SIZE - 1, false) == 0);
CU_ASSERT(spdk_cpuset_count(set) == 0);
spdk_cpuset_free(set);
}
static void
test_cpuset_parse(void)
{
int rc;
struct spdk_cpuset *core_mask;
char buf[1024];
core_mask = spdk_cpuset_alloc();
SPDK_CU_ASSERT_FATAL(core_mask != NULL);
/* Only core 0 should be set */
rc = spdk_cpuset_parse(core_mask, "0x1");
CU_ASSERT(rc >= 0);
CU_ASSERT(cpuset_check_range(core_mask, 0, 0, true) == 0);
CU_ASSERT(cpuset_check_range(core_mask, 1, SPDK_CPUSET_SIZE - 1, false) == 0);
/* Only core 1 should be set */
rc = spdk_cpuset_parse(core_mask, "[1]");
CU_ASSERT(rc >= 0);
CU_ASSERT(cpuset_check_range(core_mask, 0, 0, false) == 0);
CU_ASSERT(cpuset_check_range(core_mask, 1, 1, true) == 0);
CU_ASSERT(cpuset_check_range(core_mask, 2, SPDK_CPUSET_SIZE - 1, false) == 0);
/* Set cores 0-10,12,128-254 */
rc = spdk_cpuset_parse(core_mask, "[0-10,12,128-254]");
CU_ASSERT(rc >= 0);
CU_ASSERT(cpuset_check_range(core_mask, 0, 10, true) == 0);
CU_ASSERT(cpuset_check_range(core_mask, 11, 11, false) == 0);
CU_ASSERT(cpuset_check_range(core_mask, 12, 12, true) == 0);
CU_ASSERT(cpuset_check_range(core_mask, 13, 127, false) == 0);
CU_ASSERT(cpuset_check_range(core_mask, 128, 254, true) == 0);
CU_ASSERT(cpuset_check_range(core_mask, 255, SPDK_CPUSET_SIZE - 1, false) == 0);
/* Set all cores */
snprintf(buf, sizeof(buf), "[0-%d]", SPDK_CPUSET_SIZE - 1);
rc = spdk_cpuset_parse(core_mask, buf);
CU_ASSERT(rc >= 0);
CU_ASSERT(cpuset_check_range(core_mask, 0, SPDK_CPUSET_SIZE - 1, true) == 0);
/* Null parameters not allowed */
rc = spdk_cpuset_parse(core_mask, NULL);
CU_ASSERT(rc < 0);
rc = spdk_cpuset_parse(NULL, "[1]");
CU_ASSERT(rc < 0);
/* Wrong formated core lists */
rc = spdk_cpuset_parse(core_mask, "");
CU_ASSERT(rc < 0);
rc = spdk_cpuset_parse(core_mask, "[");
CU_ASSERT(rc < 0);
rc = spdk_cpuset_parse(core_mask, "[]");
CU_ASSERT(rc < 0);
rc = spdk_cpuset_parse(core_mask, "[10--11]");
CU_ASSERT(rc < 0);
rc = spdk_cpuset_parse(core_mask, "[11-10]");
CU_ASSERT(rc < 0);
rc = spdk_cpuset_parse(core_mask, "[10-11,]");
CU_ASSERT(rc < 0);
rc = spdk_cpuset_parse(core_mask, "[,10-11]");
CU_ASSERT(rc < 0);
/* Out of range value */
snprintf(buf, sizeof(buf), "[%d]", SPDK_CPUSET_SIZE + 1);
rc = spdk_cpuset_parse(core_mask, buf);
CU_ASSERT(rc < 0);
/* Overflow value (UINT64_MAX * 10) */
rc = spdk_cpuset_parse(core_mask, "[184467440737095516150]");
CU_ASSERT(rc < 0);
cpuset: fix parse_mask The loop here was counting the bytes in the cpus array, but the lcores are represented by bits. While here, add a unit test that exposes this bug and demonstrates it is now fixed with this patch. Fixes #1570. Signed-off-by: Jim Harris <james.r.harris@intel.com> Change-Id: I3a1fc48a8085254f41587e3b3d5d732154b90134 Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/3931 Community-CI: Mellanox Build Bot Reviewed-by: Paul Luse <paul.e.luse@intel.com> Reviewed-by: Ben Walker <benjamin.walker@intel.com> Reviewed-by: Ziye Yang <ziye.yang@intel.com> Reviewed-by: Aleksey Marchuk <alexeymar@mellanox.com> Reviewed-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com> Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
2020-08-25 17:00:48 +00:00
/* Test mask with cores 4-7 and 168-171 set. */
rc = spdk_cpuset_parse(core_mask, "0xF0000000000000000000000000000000000000000F0");
CU_ASSERT(rc == 0);
CU_ASSERT(cpuset_check_range(core_mask, 0, 3, false) == 0);
CU_ASSERT(cpuset_check_range(core_mask, 4, 7, true) == 0);
CU_ASSERT(cpuset_check_range(core_mask, 8, 167, false) == 0);
CU_ASSERT(cpuset_check_range(core_mask, 168, 171, true) == 0);
CU_ASSERT(cpuset_check_range(core_mask, 172, SPDK_CPUSET_SIZE - 1, false) == 0);
util: extend cpumask to hold more than 64 cpus Fixes github issue #218. This patch introduces spdk_cpuset object to store and manipulate the set of individual CPUs. The main objective of this object is to replace cpumask declared as uint64_t and extend the limitation of supported CPUs (lcores) above 64 CPUs. spdk_cpuset is always allocated dynamically and accessed by opaque pointer, what makes it easier to extend in the future without breaking API/ABI. This patch also extends parsing function allowing to set cpumask using a list of cpus e.g. "[0-4,10,12]" sets mask of 0,1,2,3,4,10,12 as well as hexadecimal string with and without "0x" prefix. Change-Id: I475c3ba7fab629021a22e03176e57e400dd24a49 Signed-off-by: Tomasz Kulasek <tomaszx.kulasek@intel.com> Reviewed-on: https://review.gerrithub.io/390794 Tested-by: SPDK Automated Test System <sys_sgsw@intel.com> Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com>
2017-12-21 16:48:31 +00:00
spdk_cpuset_free(core_mask);
}
static void
test_cpuset_fmt(void)
{
int i;
uint32_t lcore;
struct spdk_cpuset *core_mask = spdk_cpuset_alloc();
lib/util: return const pointer from spdk_cpuset_fmt Change-Id: Iab5f9703ae9235fd3820228127d72e85af9826bc Signed-off-by: Pawel Wodkowski <pawelx.wodkowski@intel.com> Reviewed-on: https://review.gerrithub.io/400601 Tested-by: SPDK Automated Test System <sys_sgsw@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com> Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com>
2018-02-15 17:58:21 +00:00
const char *hex_mask;
util: extend cpumask to hold more than 64 cpus Fixes github issue #218. This patch introduces spdk_cpuset object to store and manipulate the set of individual CPUs. The main objective of this object is to replace cpumask declared as uint64_t and extend the limitation of supported CPUs (lcores) above 64 CPUs. spdk_cpuset is always allocated dynamically and accessed by opaque pointer, what makes it easier to extend in the future without breaking API/ABI. This patch also extends parsing function allowing to set cpumask using a list of cpus e.g. "[0-4,10,12]" sets mask of 0,1,2,3,4,10,12 as well as hexadecimal string with and without "0x" prefix. Change-Id: I475c3ba7fab629021a22e03176e57e400dd24a49 Signed-off-by: Tomasz Kulasek <tomaszx.kulasek@intel.com> Reviewed-on: https://review.gerrithub.io/390794 Tested-by: SPDK Automated Test System <sys_sgsw@intel.com> Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com>
2017-12-21 16:48:31 +00:00
char hex_mask_ref[SPDK_CPUSET_SIZE / 4 + 1];
/* Clear coremask. hex_mask should be "0" */
spdk_cpuset_zero(core_mask);
hex_mask = spdk_cpuset_fmt(core_mask);
SPDK_CU_ASSERT_FATAL(hex_mask != NULL);
CU_ASSERT(strcmp("0", hex_mask) == 0);
/* Set coremask 0x51234. Result should be "51234" */
spdk_cpuset_zero(core_mask);
spdk_cpuset_set_cpu(core_mask, 2, true);
spdk_cpuset_set_cpu(core_mask, 4, true);
spdk_cpuset_set_cpu(core_mask, 5, true);
spdk_cpuset_set_cpu(core_mask, 9, true);
spdk_cpuset_set_cpu(core_mask, 12, true);
spdk_cpuset_set_cpu(core_mask, 16, true);
spdk_cpuset_set_cpu(core_mask, 18, true);
hex_mask = spdk_cpuset_fmt(core_mask);
SPDK_CU_ASSERT_FATAL(hex_mask != NULL);
CU_ASSERT(strcmp("51234", hex_mask) == 0);
/* Set all cores */
spdk_cpuset_zero(core_mask);
util/cpuset: fix internal string buffer size When all CPUs are set, formatted string overflows str buffer in the spdk_cpuset structure with '\0'. It may destroy CPUs bitmap when formatting is used, so additional integrity checks are performed in UT. Change-Id: I92ac790b2c215428cbe0ae89ab4b28570ddb9a0d Signed-off-by: Tomasz Kulasek <tomaszx.kulasek@intel.com> Reviewed-on: https://review.gerrithub.io/c/440021 Tested-by: SPDK CI Jenkins <sys_sgci@intel.com> Reviewed-by: Darek Stojaczyk <dariusz.stojaczyk@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com>
2019-01-08 10:23:01 +00:00
CU_ASSERT(cpuset_check_range(core_mask, 0, SPDK_CPUSET_SIZE - 1, false) == 0);
util: extend cpumask to hold more than 64 cpus Fixes github issue #218. This patch introduces spdk_cpuset object to store and manipulate the set of individual CPUs. The main objective of this object is to replace cpumask declared as uint64_t and extend the limitation of supported CPUs (lcores) above 64 CPUs. spdk_cpuset is always allocated dynamically and accessed by opaque pointer, what makes it easier to extend in the future without breaking API/ABI. This patch also extends parsing function allowing to set cpumask using a list of cpus e.g. "[0-4,10,12]" sets mask of 0,1,2,3,4,10,12 as well as hexadecimal string with and without "0x" prefix. Change-Id: I475c3ba7fab629021a22e03176e57e400dd24a49 Signed-off-by: Tomasz Kulasek <tomaszx.kulasek@intel.com> Reviewed-on: https://review.gerrithub.io/390794 Tested-by: SPDK Automated Test System <sys_sgsw@intel.com> Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com>
2017-12-21 16:48:31 +00:00
for (lcore = 0; lcore < SPDK_CPUSET_SIZE; lcore++) {
spdk_cpuset_set_cpu(core_mask, lcore, true);
}
util/cpuset: fix and enable ut One of bugs wasn't catched because unit tests for util/cpuset wasn't enabled. This patch fixes bug and enables unit test. Change-Id: I5a2d7ad76256439e3a13efc8ca51dd4b21a20e0a Signed-off-by: Tomasz Kulasek <tomaszx.kulasek@intel.com> Reviewed-on: https://review.gerrithub.io/c/440020 Tested-by: SPDK CI Jenkins <sys_sgci@intel.com> Reviewed-by: Darek Stojaczyk <dariusz.stojaczyk@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com> Chandler-Test-Pool: SPDK Automated Test System <sys_sgsw@intel.com>
2019-01-08 11:10:50 +00:00
for (i = 0; i < SPDK_CPUSET_SIZE / 4; i++) {
util: extend cpumask to hold more than 64 cpus Fixes github issue #218. This patch introduces spdk_cpuset object to store and manipulate the set of individual CPUs. The main objective of this object is to replace cpumask declared as uint64_t and extend the limitation of supported CPUs (lcores) above 64 CPUs. spdk_cpuset is always allocated dynamically and accessed by opaque pointer, what makes it easier to extend in the future without breaking API/ABI. This patch also extends parsing function allowing to set cpumask using a list of cpus e.g. "[0-4,10,12]" sets mask of 0,1,2,3,4,10,12 as well as hexadecimal string with and without "0x" prefix. Change-Id: I475c3ba7fab629021a22e03176e57e400dd24a49 Signed-off-by: Tomasz Kulasek <tomaszx.kulasek@intel.com> Reviewed-on: https://review.gerrithub.io/390794 Tested-by: SPDK Automated Test System <sys_sgsw@intel.com> Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com>
2017-12-21 16:48:31 +00:00
hex_mask_ref[i] = 'f';
}
util/cpuset: fix and enable ut One of bugs wasn't catched because unit tests for util/cpuset wasn't enabled. This patch fixes bug and enables unit test. Change-Id: I5a2d7ad76256439e3a13efc8ca51dd4b21a20e0a Signed-off-by: Tomasz Kulasek <tomaszx.kulasek@intel.com> Reviewed-on: https://review.gerrithub.io/c/440020 Tested-by: SPDK CI Jenkins <sys_sgci@intel.com> Reviewed-by: Darek Stojaczyk <dariusz.stojaczyk@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com> Chandler-Test-Pool: SPDK Automated Test System <sys_sgsw@intel.com>
2019-01-08 11:10:50 +00:00
hex_mask_ref[SPDK_CPUSET_SIZE / 4] = '\0';
util: extend cpumask to hold more than 64 cpus Fixes github issue #218. This patch introduces spdk_cpuset object to store and manipulate the set of individual CPUs. The main objective of this object is to replace cpumask declared as uint64_t and extend the limitation of supported CPUs (lcores) above 64 CPUs. spdk_cpuset is always allocated dynamically and accessed by opaque pointer, what makes it easier to extend in the future without breaking API/ABI. This patch also extends parsing function allowing to set cpumask using a list of cpus e.g. "[0-4,10,12]" sets mask of 0,1,2,3,4,10,12 as well as hexadecimal string with and without "0x" prefix. Change-Id: I475c3ba7fab629021a22e03176e57e400dd24a49 Signed-off-by: Tomasz Kulasek <tomaszx.kulasek@intel.com> Reviewed-on: https://review.gerrithub.io/390794 Tested-by: SPDK Automated Test System <sys_sgsw@intel.com> Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com>
2017-12-21 16:48:31 +00:00
util/cpuset: fix internal string buffer size When all CPUs are set, formatted string overflows str buffer in the spdk_cpuset structure with '\0'. It may destroy CPUs bitmap when formatting is used, so additional integrity checks are performed in UT. Change-Id: I92ac790b2c215428cbe0ae89ab4b28570ddb9a0d Signed-off-by: Tomasz Kulasek <tomaszx.kulasek@intel.com> Reviewed-on: https://review.gerrithub.io/c/440021 Tested-by: SPDK CI Jenkins <sys_sgci@intel.com> Reviewed-by: Darek Stojaczyk <dariusz.stojaczyk@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com>
2019-01-08 10:23:01 +00:00
/* Check data before format */
CU_ASSERT(cpuset_check_range(core_mask, 0, SPDK_CPUSET_SIZE - 1, true) == 0);
util: extend cpumask to hold more than 64 cpus Fixes github issue #218. This patch introduces spdk_cpuset object to store and manipulate the set of individual CPUs. The main objective of this object is to replace cpumask declared as uint64_t and extend the limitation of supported CPUs (lcores) above 64 CPUs. spdk_cpuset is always allocated dynamically and accessed by opaque pointer, what makes it easier to extend in the future without breaking API/ABI. This patch also extends parsing function allowing to set cpumask using a list of cpus e.g. "[0-4,10,12]" sets mask of 0,1,2,3,4,10,12 as well as hexadecimal string with and without "0x" prefix. Change-Id: I475c3ba7fab629021a22e03176e57e400dd24a49 Signed-off-by: Tomasz Kulasek <tomaszx.kulasek@intel.com> Reviewed-on: https://review.gerrithub.io/390794 Tested-by: SPDK Automated Test System <sys_sgsw@intel.com> Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com>
2017-12-21 16:48:31 +00:00
hex_mask = spdk_cpuset_fmt(core_mask);
util/cpuset: fix internal string buffer size When all CPUs are set, formatted string overflows str buffer in the spdk_cpuset structure with '\0'. It may destroy CPUs bitmap when formatting is used, so additional integrity checks are performed in UT. Change-Id: I92ac790b2c215428cbe0ae89ab4b28570ddb9a0d Signed-off-by: Tomasz Kulasek <tomaszx.kulasek@intel.com> Reviewed-on: https://review.gerrithub.io/c/440021 Tested-by: SPDK CI Jenkins <sys_sgci@intel.com> Reviewed-by: Darek Stojaczyk <dariusz.stojaczyk@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com>
2019-01-08 10:23:01 +00:00
SPDK_CU_ASSERT_FATAL(hex_mask != NULL);
CU_ASSERT(strcmp(hex_mask_ref, hex_mask) == 0);
/* Check data integrity after format */
CU_ASSERT(cpuset_check_range(core_mask, 0, SPDK_CPUSET_SIZE - 1, true) == 0);
util: extend cpumask to hold more than 64 cpus Fixes github issue #218. This patch introduces spdk_cpuset object to store and manipulate the set of individual CPUs. The main objective of this object is to replace cpumask declared as uint64_t and extend the limitation of supported CPUs (lcores) above 64 CPUs. spdk_cpuset is always allocated dynamically and accessed by opaque pointer, what makes it easier to extend in the future without breaking API/ABI. This patch also extends parsing function allowing to set cpumask using a list of cpus e.g. "[0-4,10,12]" sets mask of 0,1,2,3,4,10,12 as well as hexadecimal string with and without "0x" prefix. Change-Id: I475c3ba7fab629021a22e03176e57e400dd24a49 Signed-off-by: Tomasz Kulasek <tomaszx.kulasek@intel.com> Reviewed-on: https://review.gerrithub.io/390794 Tested-by: SPDK Automated Test System <sys_sgsw@intel.com> Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com>
2017-12-21 16:48:31 +00:00
spdk_cpuset_free(core_mask);
}
int
main(int argc, char **argv)
{
CU_pSuite suite = NULL;
unsigned int num_failures;
ut: simplify error handling at initialization This patch changes the way that unittests initialize. The new way is shorter and simpler. It assumes that error during initialization is a fatal error, but in our cases it always is. This patch is a followp up to https://review.spdk.io/gerrit/c/spdk/spdk/+/930 lvol_ut.c is the only test that skipped because it runs same tests multiple times which is not allowed by new method. Change-Id: I0baf7ad09a35d5fca2dc4a03b4453c12c14f38a7 Signed-off-by: Vitaliy Mysak <vitaliy.mysak@intel.com> Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/1238 Tested-by: SPDK CI Jenkins <sys_sgci@intel.com> Reviewed-by: Ben Walker <benjamin.walker@intel.com> Reviewed-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
2020-03-11 17:59:24 +00:00
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
util: extend cpumask to hold more than 64 cpus Fixes github issue #218. This patch introduces spdk_cpuset object to store and manipulate the set of individual CPUs. The main objective of this object is to replace cpumask declared as uint64_t and extend the limitation of supported CPUs (lcores) above 64 CPUs. spdk_cpuset is always allocated dynamically and accessed by opaque pointer, what makes it easier to extend in the future without breaking API/ABI. This patch also extends parsing function allowing to set cpumask using a list of cpus e.g. "[0-4,10,12]" sets mask of 0,1,2,3,4,10,12 as well as hexadecimal string with and without "0x" prefix. Change-Id: I475c3ba7fab629021a22e03176e57e400dd24a49 Signed-off-by: Tomasz Kulasek <tomaszx.kulasek@intel.com> Reviewed-on: https://review.gerrithub.io/390794 Tested-by: SPDK Automated Test System <sys_sgsw@intel.com> Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com>
2017-12-21 16:48:31 +00:00
suite = CU_add_suite("cpuset", NULL, NULL);
ut: make use of CUnit macro to reduce duplications CUnit provides a helper macro CU_ADD_TEST() that simplifies usage of CU_add_test() function. Test name no longer needs to be provided, as it will be inherited from function name. This is a follow up to https://review.spdk.io/gerrit/c/spdk/spdk/+/931 Change-Id: I8078f02e08b14f12328ae022d7090ba13fbd64e4 Signed-off-by: Vitaliy Mysak <vitaliy.mysak@intel.com> Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/1239 Tested-by: SPDK CI Jenkins <sys_sgci@intel.com> Reviewed-by: Ben Walker <benjamin.walker@intel.com> Reviewed-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
2020-03-11 19:15:39 +00:00
CU_ADD_TEST(suite, test_cpuset);
CU_ADD_TEST(suite, test_cpuset_parse);
CU_ADD_TEST(suite, test_cpuset_fmt);
util: extend cpumask to hold more than 64 cpus Fixes github issue #218. This patch introduces spdk_cpuset object to store and manipulate the set of individual CPUs. The main objective of this object is to replace cpumask declared as uint64_t and extend the limitation of supported CPUs (lcores) above 64 CPUs. spdk_cpuset is always allocated dynamically and accessed by opaque pointer, what makes it easier to extend in the future without breaking API/ABI. This patch also extends parsing function allowing to set cpumask using a list of cpus e.g. "[0-4,10,12]" sets mask of 0,1,2,3,4,10,12 as well as hexadecimal string with and without "0x" prefix. Change-Id: I475c3ba7fab629021a22e03176e57e400dd24a49 Signed-off-by: Tomasz Kulasek <tomaszx.kulasek@intel.com> Reviewed-on: https://review.gerrithub.io/390794 Tested-by: SPDK Automated Test System <sys_sgsw@intel.com> Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com>
2017-12-21 16:48:31 +00:00
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
num_failures = CU_get_number_of_failures();
CU_cleanup_registry();
return num_failures;
}
Reference in New Issue Copy Permalink