CA-409482: Using computed delay for RRD loop

RRD loop is executed each 5 seconds. It delays fixed 5 seconds between each
loop. But the loop self also consumes time (The time consuming depends on CPU's
count. If there are many CPUs, the time consuming may be hundreds milliseconds).
This implementation leads RRD will take an offset after several loops. Then one
of RRD data lose and a gap can be observed on XenCenter performance graph.

The solution is to use computed delay (timeslice - loop time consuming) instead
of fixed delay.

Signed-off-by: Bengang Yuan <[email protected]>

Author: BengangY

ocaml/xcp-rrdd/bin/rrdd/dune

@@ -46,6 +46,8 @@
     http_lib
     httpsvr
     inotify
+    mtime
+    mtime.clock
     rpclib.core
     rpclib.json
     rpclib.xml

ocaml/xcp-rrdd/bin/rrdd/rrdd_server.ml

@@ -717,7 +717,8 @@ module Plugin = struct
         let open Rrdd_shared in
         if with_lock registered_m (fun _ -> Hashtbl.mem registered uid) then
           with_lock last_loop_end_time_m (fun _ ->
-              !last_loop_end_time +. !timeslice -. Unix.gettimeofday ()
+              let span = Mtime.span !last_loop_end_time (Mtime_clock.now ()) in
+              !timeslice -. (Mtime.Span.to_float_ns span /. 1_000_000_000.)
           )
         else
           -1.

ocaml/xcp-rrdd/bin/rrdd/rrdd_shared.ml

@@ -24,7 +24,7 @@ let enable_all_dss = ref false
 let timeslice : float ref = ref 5.
 
 (* Timestamp of the last monitoring loop end. *)
-let last_loop_end_time : float ref = ref neg_infinity
+let last_loop_end_time : Mtime.t ref = ref Mtime.min_stamp
 
 (* The mutex that protects the last_loop_end_time against data corruption. *)
 let last_loop_end_time_m : Mutex.t = Mutex.create ()

ocaml/xcp-rrdd/bin/rrdd/xcp_rrdd.ml

@@ -537,17 +537,33 @@ let monitor_write_loop writers =
       Xenctrl.with_intf (fun xc ->
           while true do
             try
+              let last_loop_start_time = Mtime_clock.now () in
               do_monitor_write xc writers ;
               with_lock Rrdd_shared.last_loop_end_time_m (fun _ ->
-                  Rrdd_shared.last_loop_end_time := Unix.gettimeofday ()
+                  Rrdd_shared.last_loop_end_time := Mtime_clock.now ()
               ) ;
-              Thread.delay !Rrdd_shared.timeslice
+              let span =
+                Mtime.span last_loop_start_time !Rrdd_shared.last_loop_end_time
+              in
+              let duration_in_second =
+                Mtime.Span.to_float_ns span /. 1_000_000_000.
+              in
+              let delay = !Rrdd_shared.timeslice -. duration_in_second in
+              (* Using computed delay (timeslice - loop time consuming) instead
+                 of fixed delay*)
+              if delay > 0.0 then
+                Thread.delay delay
+              else
+                warn
+                  "%s: Monitor write loop took so long time that the delay \
+                   (%f) is less than 0, so skip the delay"
+                  __FUNCTION__ delay
             with e ->
               Backtrace.is_important e ;
               warn
-                "Monitor/write thread caught an exception. Pausing for 10s, \
-                 then restarting: %s"
-                (Printexc.to_string e) ;
+                "%s: Monitor/write thread caught an exception. Pausing for \
+                 10s, then restarting: %s"
+                __FUNCTION__ (Printexc.to_string e) ;
               log_backtrace e ;
               Thread.delay 10.
           done