Optimize fastpath in Pool_role

Use an Atomic that can be accessed without holding the mutex.
On the fastpath, where the role is already set this returns much more quickly.
On the slowpath we still acquire the mutex and update the value as we did before,
although we read the atomic value again to check whether we've raced with another thread that has updated it meanwhile already.

Before (measuring both unloaded, and loaded situation where other threads are accessing the mutex):
```
Running benchmarks (no workloads)
╭────────────────────────────────────┬───────────────────────────┬───────────────────────────┬───────────────────────────╮
│name                                │  major-allocated          │  minor-allocated          │  monotonic-clock          │
├────────────────────────────────────┼───────────────────────────┼───────────────────────────┼───────────────────────────┤
│  Cached reads/Pool_role.is_master  │             0.0000 mjw/run│             4.0000 mnw/run│             23.6039 ns/run│
╰────────────────────────────────────┴───────────────────────────┴───────────────────────────┴───────────────────────────╯

Cached reads/Pool_role.is_master (ns):
 { monotonic-clock per run = 23.603889 (confidence: 23.644693 to 23.568067);
   r² = Some 0.999899 }

Running benchmarks (workloads)
╭────────────────────────────────────┬───────────────────────────┬───────────────────────────┬───────────────────────────╮
│name                                │  major-allocated          │  minor-allocated          │  monotonic-clock          │
├────────────────────────────────────┼───────────────────────────┼───────────────────────────┼───────────────────────────┤
│  Cached reads/Pool_role.is_master  │             0.0000 mjw/run│             7.4201 mnw/run│             76.4067 ns/run│
╰────────────────────────────────────┴───────────────────────────┴───────────────────────────┴───────────────────────────╯

Cached reads/Pool_role.is_master (ns):
 { monotonic-clock per run = 76.406674 (confidence: 86.718075 to 66.336404);
   r² = Some 0.608131 }
```

After:
```
Running benchmarks (no workloads)
╭────────────────────────────────────┬───────────────────────────┬───────────────────────────┬───────────────────────────╮
│name                                │  major-allocated          │  minor-allocated          │  monotonic-clock          │
├────────────────────────────────────┼───────────────────────────┼───────────────────────────┼───────────────────────────┤
│  Cached reads/Pool_role.is_master  │             0.0000 mjw/run│             0.0000 mnw/run│              3.1256 ns/run│
╰────────────────────────────────────┴───────────────────────────┴───────────────────────────┴───────────────────────────╯

Cached reads/Pool_role.is_master (ns):
 { monotonic-clock per run = 3.125616 (confidence: 3.131412 to 3.120373);
   r² = Some 0.999885 }

Running benchmarks (workloads)
╭────────────────────────────────────┬───────────────────────────┬───────────────────────────┬───────────────────────────╮
│name                                │  major-allocated          │  minor-allocated          │  monotonic-clock          │
├────────────────────────────────────┼───────────────────────────┼───────────────────────────┼───────────────────────────┤
│  Cached reads/Pool_role.is_master  │             0.0000 mjw/run│             0.0000 mnw/run│              6.2872 ns/run│
╰────────────────────────────────────┴───────────────────────────┴───────────────────────────┴───────────────────────────╯

Cached reads/Pool_role.is_master (ns):
 { monotonic-clock per run = 6.287197 (confidence: 6.737363 to 5.830140);
   r² = Some 0.706843 }
```

Signed-off-by: Edwin Török <[email protected]>

Author: edwintorok

ocaml/tests/bench/bench_cached_reads.ml

@@ -7,8 +7,6 @@ let run () =
 let mutex_workload =
   Bechamel_simple_cli.thread_workload ~before:ignore ~after:ignore ~run
 
-let free_threads (stop, t) = Atomic.set stop true ; Array.iter Thread.join t
-
 let benchmarks =
   Test.make_grouped ~name:"Cached reads"
     [Test.make ~name:"Pool_role.is_master" (Staged.stage Pool_role.is_master)]

ocaml/xapi-aux/pool_role.ml

@@ -28,21 +28,19 @@ type t =
   (* IP address *)
   | Broken
 
-let role = ref None
+let role = Atomic.make None
 
-let role_unit_tests = ref false
+let role_unit_tests = Atomic.make false
 
 let role_m = Mutex.create ()
 
 let with_pool_role_lock f = Xapi_stdext_threads.Threadext.Mutex.execute role_m f
 
 let set_pool_role_for_test () =
-  with_pool_role_lock (fun _ ->
-      role := Some Master ;
-      role_unit_tests := true
-  )
+  Atomic.set role (Some Master) ;
+  Atomic.set role_unit_tests true
 
-let is_unit_test () = with_pool_role_lock (fun _ -> !role_unit_tests)
+let is_unit_test () = Atomic.get role_unit_tests
 
 let string_of = function
   | Master ->
@@ -80,15 +78,18 @@ let read_pool_role () =
     )
 
 let get_role () =
-  with_pool_role_lock (fun _ ->
-      match !role with
-      | Some x ->
-          x
-      | None ->
-          let r = read_pool_role () in
-          role := Some r ;
-          r
-  )
+  match Atomic.get role with
+  | Some x ->
+      x
+  | None ->
+      with_pool_role_lock (fun _ ->
+          match Atomic.get role with
+          | Some x ->
+              x
+          | None ->
+              let r = read_pool_role () in
+              Atomic.set role (Some r) ; r
+      )
 
 let is_master () = get_role () = Master