Changeset b2ec5cf in mainline for kernel/generic/src

Timestamp:

2023-04-15T16:47:54Z (2 years ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

master, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

169815e

Parents:

dd218ea

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2023-04-15 11:54:58)

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2023-04-15 16:47:54)

Message:

Implement atomic_time_stat_t for lockless timekeeping

We keep monotonically increasing temporal statistics in several places.
They are frequently written from the thread that owns them, and rarely
read from other threads in certain syscalls. This new code serves the
purpose of avoiding the need for synchronization on the writer side.
On 64b system, we can simply assume that 64b writes are indivisible,
and relaxed atomic read/writes simply serve to formally prevent C
undefined behavior from data races (they translate to regular memory
reads/writes in assembly).

On 32b systems, we use the same algorithm that's been used for userspace
clock access, using three fields and some memory barriers to maintain
consistency of reads when the upper half changes. Only readers always
synchronize though. For writers, barriers are avoided in the common case
when the upper half remains unchanged.

Location:

kernel/generic/src

Files:

• cpu/cpu.c (modified) (1 diff)
• interrupt/interrupt.c (modified) (1 diff)
• sysinfo/stats.c (modified) (1 diff)
• time/clock.c (modified) (1 diff)

kernel/generic/src/cpu/cpu.c

@@ -103 +103 @@
         CPU->idle = false;
         CPU->last_cycle = get_cycle();
-        CPU->idle_cycles = 0;
-        CPU->busy_cycles = 0;
+        CPU->idle_cycles = ATOMIC_TIME_INITIALIZER();
+        CPU->busy_cycles = ATOMIC_TIME_INITIALIZER();
 
         cpu_identify();

kernel/generic/src/interrupt/interrupt.c

@@ -116 +116 @@
                 irq_spinlock_lock(&CPU->lock, false);
                 uint64_t now = get_cycle();
-                CPU->idle_cycles += now - CPU->last_cycle;
+                atomic_time_increment(&CPU->idle_cycles, now - CPU->last_cycle);
                 CPU->last_cycle = now;
                 CPU->idle = false;

kernel/generic/src/sysinfo/stats.c

@@ -124 +124 @@
                 stats_cpus[i].active = cpus[i].active;
                 stats_cpus[i].frequency_mhz = cpus[i].frequency_mhz;
-                stats_cpus[i].busy_cycles = cpus[i].busy_cycles;
-                stats_cpus[i].idle_cycles = cpus[i].idle_cycles;
+
+                stats_cpus[i].busy_cycles = atomic_time_read(&cpus[i].busy_cycles);
+                stats_cpus[i].idle_cycles = atomic_time_read(&cpus[i].idle_cycles);
 
                 irq_spinlock_unlock(&cpus[i].lock, true);

kernel/generic/src/time/clock.c

@@ -125 +125 @@
         irq_spinlock_lock(&CPU->lock, false);
         uint64_t now = get_cycle();
-        CPU->busy_cycles += now - CPU->last_cycle;
+        atomic_time_increment(&CPU->busy_cycles, now - CPU->last_cycle);
         CPU->last_cycle = now;
         irq_spinlock_unlock(&CPU->lock, false);