mirrors
/
memtest86plus
mirror of https://github.com/memtest86plus/memtest86plus
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
memtest86plus/tests/test_helper.c

97 lines
3.2 KiB
C
Raw Normal View History

Initial commit.
2020-05-24 23:30:55 +03:00
// SPDX-License-Identifier: GPL-2.0
Remove distinction between physical and virtual CPUs. This is no longer needed, now we can display as many CPUs as we can physically handle.
2022-02-01 01:59:14 +03:00
// Copyright (C) 2020-2022 Martin Whitaker.
Initial commit.
2020-05-24 23:30:55 +03:00
//
// Partly derived from an extract of memtest86+ test.c:
//
// MemTest86+ V5 Specific code (GPL V2.0)
// By Samuel DEMEULEMEESTER, sdemeule@memtest.org
// http://www.canardpc.com - http://www.memtest.org
// Thanks to Passmark for calculate_chunk() and various comments !
// ----------------------------------------------------
// test.c - MemTest-86 Version 3.4
//
// Released under version 2 of the Gnu Public License.
// By Chris Brady
#include <stdint.h>
Flush caches between writing and verifying test data. Mostly we write and read large chunks of data which will make it likely that the data is no longer in the cache when we come to verify it. But this is not always true, and in any case, we shouldn't rely on it.
2021-12-23 14:00:10 +03:00
#include "cache.h"
Remove distinction between physical and virtual CPUs. This is no longer needed, now we can display as many CPUs as we can physically handle.
2022-02-01 01:59:14 +03:00
#include "smp.h"
Flush caches between writing and verifying test data. Mostly we write and read large chunks of data which will make it likely that the data is no longer in the cache when we come to verify it. But this is not always true, and in any case, we shouldn't rely on it.
2021-12-23 14:00:10 +03:00
#include "barrier.h"
Initial commit.
2020-05-24 23:30:55 +03:00
#include "config.h"
#include "display.h"
#include "test_helper.h"
//------------------------------------------------------------------------------
// Public Functions
//------------------------------------------------------------------------------
Remove distinction between physical and virtual CPUs. This is no longer needed, now we can display as many CPUs as we can physically handle.
2022-02-01 01:59:14 +03:00
void calculate_chunk(testword_t **start, testword_t **end, int my_cpu, int segment, size_t chunk_align)
Initial commit.
2020-05-24 23:30:55 +03:00
{
Remove distinction between physical and virtual CPUs. This is no longer needed, now we can display as many CPUs as we can physically handle.
2022-02-01 01:59:14 +03:00
if (my_cpu < 0) {
my_cpu = 0;
Initial commit.
2020-05-24 23:30:55 +03:00
}
// If we are only running 1 CPU then test the whole segment.
Remove distinction between physical and virtual CPUs. This is no longer needed, now we can display as many CPUs as we can physically handle.
2022-02-01 01:59:14 +03:00
if (num_active_cpus == 1) {
Initial commit.
2020-05-24 23:30:55 +03:00
*start = vm_map[segment].start;
*end = vm_map[segment].end;
} else {
Add initial NUMA awareness support (#378) * Add a file containing useful macro definitions, currently a single top-level macro for obtaining the size of an array; use it to replace a sizeof(x) / sizeof(x[0]) construct in system/smbus.c . This requires switching the GCC build mode from C11 to C11 with GCC extensions. * Initial NUMA awareness (#12) support: parse the ACPI SRAT to build up new internal structures related to proximity domains and affinity; use these structures in setup_vm_map() and calculate_chunk() to skip the work on the processors which don't belong to the proximity domain currently being tested. Tested on a number of 1S single-domain, 2S multi-domain and 4S multi-domain platforms. SKIP_RANGE(iterations) trick by Martin Whitaker.
2024-03-13 03:43:26 +03:00
if (enable_numa) {
uint32_t proximity_domain_idx = smp_get_proximity_domain_idx(my_cpu);
Initial commit.
2020-05-24 23:30:55 +03:00
Add initial NUMA awareness support (#378) * Add a file containing useful macro definitions, currently a single top-level macro for obtaining the size of an array; use it to replace a sizeof(x) / sizeof(x[0]) construct in system/smbus.c . This requires switching the GCC build mode from C11 to C11 with GCC extensions. * Initial NUMA awareness (#12) support: parse the ACPI SRAT to build up new internal structures related to proximity domains and affinity; use these structures in setup_vm_map() and calculate_chunk() to skip the work on the processors which don't belong to the proximity domain currently being tested. Tested on a number of 1S single-domain, 2S multi-domain and 4S multi-domain platforms. SKIP_RANGE(iterations) trick by Martin Whitaker.
2024-03-13 03:43:26 +03:00
// Is this CPU in the same proximity domain as the current segment ?
if (proximity_domain_idx == vm_map[segment].proximity_domain_idx) {
uintptr_t segment_size = (vm_map[segment].end - vm_map[segment].start + 1) * sizeof(testword_t);
uintptr_t chunk_size = round_down(segment_size / used_cpus_in_proximity_domain[proximity_domain_idx], chunk_align);
Initial commit.
2020-05-24 23:30:55 +03:00
Add initial NUMA awareness support (#378) * Add a file containing useful macro definitions, currently a single top-level macro for obtaining the size of an array; use it to replace a sizeof(x) / sizeof(x[0]) construct in system/smbus.c . This requires switching the GCC build mode from C11 to C11 with GCC extensions. * Initial NUMA awareness (#12) support: parse the ACPI SRAT to build up new internal structures related to proximity domains and affinity; use these structures in setup_vm_map() and calculate_chunk() to skip the work on the processors which don't belong to the proximity domain currently being tested. Tested on a number of 1S single-domain, 2S multi-domain and 4S multi-domain platforms. SKIP_RANGE(iterations) trick by Martin Whitaker.
2024-03-13 03:43:26 +03:00
// Calculate chunk boundaries.
*start = (testword_t *)((uintptr_t)vm_map[segment].start + chunk_size * chunk_index[my_cpu]);
*end = (testword_t *)((uintptr_t)(*start) + chunk_size) - 1;
if (*end > vm_map[segment].end) {
*end = vm_map[segment].end;
}
} else {
// Nope.
*start = (testword_t *)1;
*end = (testword_t *)0;
}
} else {
uintptr_t segment_size = (vm_map[segment].end - vm_map[segment].start + 1) * sizeof(testword_t);
uintptr_t chunk_size = round_down(segment_size / num_active_cpus, chunk_align);
// Calculate chunk boundaries.
*start = (testword_t *)((uintptr_t)vm_map[segment].start + chunk_size * chunk_index[my_cpu]);
*end = (testword_t *)((uintptr_t)(*start) + chunk_size) - 1;
if (*end > vm_map[segment].end) {
*end = vm_map[segment].end;
}
Initial commit.
2020-05-24 23:30:55 +03:00
}
}
}
Flush caches between writing and verifying test data. Mostly we write and read large chunks of data which will make it likely that the data is no longer in the cache when we come to verify it. But this is not always true, and in any case, we shouldn't rely on it.
2021-12-23 14:00:10 +03:00
Remove distinction between physical and virtual CPUs. This is no longer needed, now we can display as many CPUs as we can physically handle.
2022-02-01 01:59:14 +03:00
void flush_caches(int my_cpu)
Flush caches between writing and verifying test data. Mostly we write and read large chunks of data which will make it likely that the data is no longer in the cache when we come to verify it. But this is not always true, and in any case, we shouldn't rely on it.
2021-12-23 14:00:10 +03:00
{
Remove distinction between physical and virtual CPUs. This is no longer needed, now we can display as many CPUs as we can physically handle.
2022-02-01 01:59:14 +03:00
if (my_cpu >= 0) {
Faster barrier implementation. The old barrier implementation was very slow when running on a multi-socket machine (pcmemtest issue 16). The new implementation provides two options: - when blocked, spin on a thread-local flag - when blocked, execute a HLT instruction and wait for a NMI The first option might be faster, but we need to measure it to find out. A new boot command line option is provided to select between the two, with a third setting that uses a mixture of the two.
2022-02-28 23:21:50 +03:00
bool use_spin_wait = (power_save < POWER_SAVE_HIGH);
if (use_spin_wait) {
barrier_spin_wait(run_barrier);
} else {
barrier_halt_wait(run_barrier);
}
Remove distinction between physical and virtual CPUs. This is no longer needed, now we can display as many CPUs as we can physically handle.
2022-02-01 01:59:14 +03:00
if (my_cpu == master_cpu) {
Flush caches between writing and verifying test data. Mostly we write and read large chunks of data which will make it likely that the data is no longer in the cache when we come to verify it. But this is not always true, and in any case, we shouldn't rely on it.
2021-12-23 14:00:10 +03:00
cache_flush();
}
Faster barrier implementation. The old barrier implementation was very slow when running on a multi-socket machine (pcmemtest issue 16). The new implementation provides two options: - when blocked, spin on a thread-local flag - when blocked, execute a HLT instruction and wait for a NMI The first option might be faster, but we need to measure it to find out. A new boot command line option is provided to select between the two, with a third setting that uses a mixture of the two.
2022-02-28 23:21:50 +03:00
if (use_spin_wait) {
barrier_spin_wait(run_barrier);
} else {
barrier_halt_wait(run_barrier);
}
Flush caches between writing and verifying test data. Mostly we write and read large chunks of data which will make it likely that the data is no longer in the cache when we come to verify it. But this is not always true, and in any case, we shouldn't rely on it.
2021-12-23 14:00:10 +03:00
}
}