fix(bench): cpu time stats

Author: tony612

benchmark/config/config.exs

@@ -1,7 +1,4 @@
 use Mix.Config
 
 config :logger, :console, metadata: [:module, :line]
-
-config :sasl, errlog_type: :error
-
-import_config "#{Mix.env()}.exs"
+config :logger, level: :info

benchmark/config/dev.exs

@@ -5,7 +5,7 @@ defmodule Benchmark.ClientManager do
   alias Benchmark.Stats.Histogram
 
   defstruct init_time: nil,
-            cpu_acc: %{sys_t: 0, user_t: 0},
+            init_rusage: nil,
             histograms: %{},
             histogram_opts: nil
 
@@ -39,12 +39,10 @@ defmodule Benchmark.ClientManager do
         end)
       end)
 
-    # relative util will be returned next time calling
-    :cpu_sup.util()
-
     state = %__MODULE__{
       histograms: histograms,
       init_time: Time.utc_now(),
+      init_rusage: Benchmark.Syscall.getrusage(),
       histogram_opts: hs_opts
     }
 

benchmark/config/prod.exs

@@ -17,26 +17,27 @@ defmodule Benchmark.ClientWorker do
   def unary_loop(ch, %{req_size: req_size, resp_size: resp_size} = payload, {pid, no} = manager) do
     start = Time.utc_now()
     unary_call(ch, req_size, resp_size)
-    dur = Time.diff(Time.utc_now(), start, :microsecond)
+    dur = Time.diff(Time.utc_now(), start, :nanosecond)
     GenServer.cast(pid, {:track_rpc, no, dur})
     unary_loop(ch, payload, manager)
   end
 
   def unary_call(ch, req_size, resp_size) do
+    payload_type = Grpc.Testing.PayloadType.value(:COMPRESSABLE)
+
     payload =
       Grpc.Testing.Payload.new(
-        type: Grpc.Testing.PayloadType.value(:COMPRESSABLE),
-        body: String.duplicate(<<0>>, req_size)
+        type: payload_type,
+        body: List.duplicate(<<0>>, req_size)
       )
 
     req =
       Grpc.Testing.SimpleRequest.new(
-        response_type: payload.type,
+        response_type: payload_type,
         response_size: resp_size,
         payload: payload
       )
 
-    Logger.debug("Sending rpc #{inspect(req)}")
     Grpc.Testing.BenchmarkService.Stub.unary_call(ch, req)
   end
 end

benchmark/lib/benchmark/client_manager.ex

@@ -3,7 +3,7 @@ defmodule Benchmark.Server do
             port: nil,
             pid: nil,
             init_time: nil,
-            cpu_acc: %{sys_t: 0, user_t: 0}
+            init_rusage: nil
 
   def get_stats(server, reset \\ false) do
     {server, stats} = Benchmark.Stats.CpuTime.get_stats(server, reset)

benchmark/lib/benchmark/client_worker.ex

@@ -9,14 +9,12 @@ defmodule Benchmark.ServerManager do
     cores = Benchmark.Manager.set_cores(config.core_limit)
     {:ok, pid, port} = GRPC.Server.start(Grpc.Testing.BenchmarkService.Server, config.port)
 
-    # relative util will be returned next time calling
-    :cpu_sup.util()
-
     %Benchmark.Server{
       cores: cores,
       port: port,
       pid: pid,
-      init_time: Time.utc_now()
+      init_time: Time.utc_now(),
+      init_rusage: Benchmark.Syscall.getrusage()
     }
   end
 

benchmark/lib/benchmark/server.ex

@@ -1,26 +1,33 @@
 defmodule Benchmark.Stats.CpuTime do
   def get_stats(state, reset \\ false) do
     now = Time.utc_now()
-    util = :cpu_sup.util([:detailed])
+    rusage = Benchmark.Syscall.getrusage()
     duration = Time.diff(now, state.init_time, :microsecond) / 1000_000
-    {_, [kernel: sys_t, nice_user: _, user: user_t], _, _} = util
-    %{sys_t: sys_t0, user_t: user_t0} = state.cpu_acc
-    sys_t = sys_t0 + sys_t
-    user_t = user_t0 + user_t
+
+    {utime, stime} = cpu_time_diff(rusage, state.init_rusage)
 
     state =
       if reset do
-        %{state | init_time: Time.utc_now(), cpu_acc: %{sys_t: 0, user_t: 0}}
+        %{state | init_time: Time.utc_now(), init_rusage: rusage}
       else
-        %{state | cpu_acc: %{sys_t: sys_t, user_t: user_t}}
+        state
       end
 
     stats = %{
       time_elapsed: duration,
-      time_user: user_t,
-      time_system: sys_t
+      time_user: utime,
+      time_system: stime
     }
 
     {state, stats}
   end
+
+  def cpu_time_diff(
+        %{utime: {u_sec1, u_usec1}, stime: {s_sec1, s_usec1}},
+        %{utime: {u_sec0, u_usec0}, stime: {s_sec0, s_usec0}}
+      ) do
+    utime = u_sec1 - u_sec0 + (u_usec1 - u_usec0) / 1000_000
+    stime = s_sec1 - s_sec0 + (s_usec1 - s_usec0) / 1000_000
+    {utime, stime}
+  end
 end

benchmark/lib/benchmark/server_manager.ex

@@ -72,7 +72,4 @@ defmodule Grpc.Testing.WorkerService.Server do
     send(stream.local[:main_pid], {:quit, self()})
     Grpc.Testing.Void.new()
   end
-
-  def get_stats(_) do
-  end
 end

benchmark/lib/benchmark/stats/cpu_time.ex

@@ -14,7 +14,7 @@ defmodule Benchmark.MixProject do
   # Run "mix help compile.app" to learn about applications.
   def application do
     [
-      extra_applications: [:logger, :os_mon]
+      extra_applications: [:logger]
     ]
   end