Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/C/Linux/tools/testing/selftests/mm/ (Open Source Betriebssystem Version 6.17.9^©) Datei vom 24.10.2025 mit Größe 7 kB

Quelle migration.c Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
* The main purpose of the tests here is to exercise the migration entry code
* paths in the kernel.
*/

#include "../kselftest_harness.h"
#include "thp_settings.h"

#include <strings.h>
#include <pthread.h>
#include <numa.h>
#include <numaif.h>
#include <sys/mman.h>
#include <sys/prctl.h>
#include <sys/types.h>
#include <signal.h>
#include <time.h>
#include "vm_util.h"

#define TWOMEG  (2<<20)
#define RUNTIME  (20)
#define MAX_RETRIES 100
#define ALIGN(x, a) (((x) + (a - 1)) & (~((a) - 1)))

FIXTURE(migration)
{
pthread_t *threads;
pid_t *pids;
int nthreads;
int n1;
int n2;
};

FIXTURE_SETUP(migration)
{
int n;

ASSERT_EQ(numa_available(), 0);
self->nthreads = numa_num_task_cpus() - 1;
self->n1 = -1;
self->n2 = -1;

for (n = 0; n < numa_max_possible_node(); n++)
  if (numa_bitmask_isbitset(numa_all_nodes_ptr, n)) {
   if (self->n1 == -1) {
    self->n1 = n;
   } else {
    self->n2 = n;
    break;
   }
  }

self->threads = malloc(self->nthreads * sizeof(*self->threads));
ASSERT_NE(self->threads, NULL);
self->pids = malloc(self->nthreads * sizeof(*self->pids));
ASSERT_NE(self->pids, NULL);
};

FIXTURE_TEARDOWN(migration)
{
free(self->threads);
free(self->pids);
}

int migrate(uint64_t *ptr, int n1, int n2)
{
int ret, tmp;
int status = 0;
struct timespec ts1, ts2;
int failures = 0;

if (clock_gettime(CLOCK_MONOTONIC, &ts1))
  return -1;

while (1) {
  if (clock_gettime(CLOCK_MONOTONIC, &ts2))
   return -1;

  if (ts2.tv_sec - ts1.tv_sec >= RUNTIME)
   return 0;

  ret = move_pages(0, 1, (void **) &ptr, &n2, &status,
    MPOL_MF_MOVE_ALL);
  if (ret) {
   if (ret > 0) {
    /* Migration is best effort; try again */
    if (++failures < MAX_RETRIES)
     continue;
    printf("Didn't migrate %d pages\n", ret);
   }
   else
    perror("Couldn't migrate pages");
   return -2;
  }
  failures = 0;
  tmp = n2;
  n2 = n1;
  n1 = tmp;
}

return 0;
}

void *access_mem(void *ptr)
{
while (1) {
  pthread_testcancel();
  /* Force a read from the memory pointed to by ptr. This ensures
* the memory access actually happens and prevents the compiler
* from optimizing away this entire loop.
*/
  FORCE_READ(*(uint64_t *)ptr);
}

return NULL;
}

/*
* Basic migration entry testing. One thread will move pages back and forth
* between nodes whilst other threads try and access them triggering the
* migration entry wait paths in the kernel.
*/
TEST_F_TIMEOUT(migration, private_anon, 2*RUNTIME)
{
uint64_t *ptr;
int i;

if (self->nthreads < 2 || self->n1 < 0 || self->n2 < 0)
  SKIP(return, "Not enough threads or NUMA nodes available");

ptr = mmap(NULL, TWOMEG, PROT_READ | PROT_WRITE,
  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(ptr, MAP_FAILED);

memset(ptr, 0xde, TWOMEG);
for (i = 0; i < self->nthreads - 1; i++)
  if (pthread_create(&self->threads[i], NULL, access_mem, ptr))
   perror("Couldn't create thread");

ASSERT_EQ(migrate(ptr, self->n1, self->n2), 0);
for (i = 0; i < self->nthreads - 1; i++)
  ASSERT_EQ(pthread_cancel(self->threads[i]), 0);
}

/*
* Same as the previous test but with shared memory.
*/
TEST_F_TIMEOUT(migration, shared_anon, 2*RUNTIME)
{
pid_t pid;
uint64_t *ptr;
int i;

if (self->nthreads < 2 || self->n1 < 0 || self->n2 < 0)
  SKIP(return, "Not enough threads or NUMA nodes available");

ptr = mmap(NULL, TWOMEG, PROT_READ | PROT_WRITE,
  MAP_SHARED | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(ptr, MAP_FAILED);

memset(ptr, 0xde, TWOMEG);
for (i = 0; i < self->nthreads - 1; i++) {
  pid = fork();
  if (!pid) {
   prctl(PR_SET_PDEATHSIG, SIGHUP);
   /* Parent may have died before prctl so check now. */
   if (getppid() == 1)
    kill(getpid(), SIGHUP);
   access_mem(ptr);
  } else {
   self->pids[i] = pid;
  }
}

ASSERT_EQ(migrate(ptr, self->n1, self->n2), 0);
for (i = 0; i < self->nthreads - 1; i++)
  ASSERT_EQ(kill(self->pids[i], SIGTERM), 0);
}

/*
* Tests the pmd migration entry paths.
*/
TEST_F_TIMEOUT(migration, private_anon_thp, 2*RUNTIME)
{
uint64_t *ptr;
int i;

if (!thp_is_enabled())
  SKIP(return, "Transparent Hugepages not available");

if (self->nthreads < 2 || self->n1 < 0 || self->n2 < 0)
  SKIP(return, "Not enough threads or NUMA nodes available");

ptr = mmap(NULL, 2*TWOMEG, PROT_READ | PROT_WRITE,
  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(ptr, MAP_FAILED);

ptr = (uint64_t *) ALIGN((uintptr_t) ptr, TWOMEG);
ASSERT_EQ(madvise(ptr, TWOMEG, MADV_HUGEPAGE), 0);
memset(ptr, 0xde, TWOMEG);
for (i = 0; i < self->nthreads - 1; i++)
  if (pthread_create(&self->threads[i], NULL, access_mem, ptr))
   perror("Couldn't create thread");

ASSERT_EQ(migrate(ptr, self->n1, self->n2), 0);
for (i = 0; i < self->nthreads - 1; i++)
  ASSERT_EQ(pthread_cancel(self->threads[i]), 0);
}

/*
* migration test with shared anon THP page
*/

TEST_F_TIMEOUT(migration, shared_anon_thp, 2*RUNTIME)
{
pid_t pid;
uint64_t *ptr;
int i;

if (!thp_is_enabled())
  SKIP(return, "Transparent Hugepages not available");

if (self->nthreads < 2 || self->n1 < 0 || self->n2 < 0)
  SKIP(return, "Not enough threads or NUMA nodes available");

ptr = mmap(NULL, 2 * TWOMEG, PROT_READ | PROT_WRITE,
  MAP_SHARED | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(ptr, MAP_FAILED);

ptr = (uint64_t *) ALIGN((uintptr_t) ptr, TWOMEG);
ASSERT_EQ(madvise(ptr, TWOMEG, MADV_HUGEPAGE), 0);

memset(ptr, 0xde, TWOMEG);
for (i = 0; i < self->nthreads - 1; i++) {
  pid = fork();
  if (!pid) {
   prctl(PR_SET_PDEATHSIG, SIGHUP);
   /* Parent may have died before prctl so check now. */
   if (getppid() == 1)
    kill(getpid(), SIGHUP);
   access_mem(ptr);
  } else {
   self->pids[i] = pid;
  }
}

ASSERT_EQ(migrate(ptr, self->n1, self->n2), 0);
for (i = 0; i < self->nthreads - 1; i++)
  ASSERT_EQ(kill(self->pids[i], SIGTERM), 0);
}

/*
* migration test with private anon hugetlb page
*/
TEST_F_TIMEOUT(migration, private_anon_htlb, 2*RUNTIME)
{
uint64_t *ptr;
int i;

if (self->nthreads < 2 || self->n1 < 0 || self->n2 < 0)
  SKIP(return, "Not enough threads or NUMA nodes available");

ptr = mmap(NULL, TWOMEG, PROT_READ | PROT_WRITE,
  MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0);
ASSERT_NE(ptr, MAP_FAILED);

memset(ptr, 0xde, TWOMEG);
for (i = 0; i < self->nthreads - 1; i++)
  if (pthread_create(&self->threads[i], NULL, access_mem, ptr))
   perror("Couldn't create thread");

ASSERT_EQ(migrate(ptr, self->n1, self->n2), 0);
for (i = 0; i < self->nthreads - 1; i++)
  ASSERT_EQ(pthread_cancel(self->threads[i]), 0);
}

/*
* migration test with shared anon hugetlb page
*/
TEST_F_TIMEOUT(migration, shared_anon_htlb, 2*RUNTIME)
{
pid_t pid;
uint64_t *ptr;
int i;

if (self->nthreads < 2 || self->n1 < 0 || self->n2 < 0)
  SKIP(return, "Not enough threads or NUMA nodes available");

ptr = mmap(NULL, TWOMEG, PROT_READ | PROT_WRITE,
  MAP_SHARED | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0);
ASSERT_NE(ptr, MAP_FAILED);

memset(ptr, 0xde, TWOMEG);
for (i = 0; i < self->nthreads - 1; i++) {
  pid = fork();
  if (!pid) {
   prctl(PR_SET_PDEATHSIG, SIGHUP);
   /* Parent may have died before prctl so check now. */
   if (getppid() == 1)
    kill(getpid(), SIGHUP);
   access_mem(ptr);
  } else {
   self->pids[i] = pid;
  }
}

ASSERT_EQ(migrate(ptr, self->n1, self->n2), 0);
for (i = 0; i < self->nthreads - 1; i++)
  ASSERT_EQ(kill(self->pids[i], SIGTERM), 0);
}

TEST_HARNESS_MAIN

Messung V0.5

¤ Dauer der Verarbeitung: 0.11 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.