Quelle  spinlock_test.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
#include <linux/init.h>
#include <linux/kthread.h>
#include <linux/hrtimer.h>
#include <linux/fs.h>
#include <linux/debugfs.h>
#include <linux/export.h>
#include <linux/spinlock.h>
#include <asm/debug.h>

static int ss_get(void *data, u64 *val)
{
 ktime_t start, finish;
 int loops;
 int cont;
 DEFINE_RAW_SPINLOCK(ss_spin);

 loops = 1000000;
 cont = 1;

 start = ktime_get();

 while (cont) {
  raw_spin_lock(&ss_spin);
  loops--;
  if (loops == 0)
   cont = 0;
  raw_spin_unlock(&ss_spin);
 }

 finish = ktime_get();

 *val = ktime_us_delta(finish, start);

 return 0;
}

DEFINE_DEBUGFS_ATTRIBUTE(fops_ss, ss_get, NULL, "%llu\n");



struct spin_multi_state {
 raw_spinlock_t lock;
 atomic_t start_wait;
 atomic_t enter_wait;
 atomic_t exit_wait;
 int loops;
};

struct spin_multi_per_thread {
 struct spin_multi_state *state;
 ktime_t start;
};

static int multi_other(void *data)
{
 int loops;
 int cont;
 struct spin_multi_per_thread *pt = data;
 struct spin_multi_state *s = pt->state;

 loops = s->loops;
 cont = 1;

 atomic_dec(&s->enter_wait);

 while (atomic_read(&s->enter_wait))
  ; /* spin */

 pt->start = ktime_get();

 atomic_dec(&s->start_wait);

 while (atomic_read(&s->start_wait))
  ; /* spin */

 while (cont) {
  raw_spin_lock(&s->lock);
  loops--;
  if (loops == 0)
   cont = 0;
  raw_spin_unlock(&s->lock);
 }

 atomic_dec(&s->exit_wait);
 while (atomic_read(&s->exit_wait))
  ; /* spin */
 return 0;
}

static int multi_get(void *data, u64 *val)
{
 ktime_t finish;
 struct spin_multi_state ms;
 struct spin_multi_per_thread t1, t2;

 ms.lock = __RAW_SPIN_LOCK_UNLOCKED("multi_get");
 ms.loops = 1000000;

 atomic_set(&ms.start_wait, 2);
 atomic_set(&ms.enter_wait, 2);
 atomic_set(&ms.exit_wait, 2);
 t1.state = &ms;
 t2.state = &ms;

 kthread_run(multi_other, &t2, "multi_get");

 multi_other(&t1);

 finish = ktime_get();

 *val = ktime_us_delta(finish, t1.start);

 return 0;
}

DEFINE_DEBUGFS_ATTRIBUTE(fops_multi, multi_get, NULL, "%llu\n");

static int __init spinlock_test(void)
{
 debugfs_create_file_unsafe("spin_single", S_IRUGO, mips_debugfs_dir, NULL,
       &fops_ss);
 debugfs_create_file_unsafe("spin_multi", S_IRUGO, mips_debugfs_dir, NULL,
       &fops_multi);
 return 0;
}
device_initcall(spinlock_test);