Refactor new times builtin

Add support for using `getrusage()` if available.

Change the default precision of the `times` and `time` output to be
milliseconds. This exposes a bug in the formating of `time` output. See
issue #1333. I'll fix that in a subsequent change.

Related #16

Author: krader1961

config_ast.h.in

@@ -108,6 +108,7 @@
 #mesondefine _lib_ftruncate
 #mesondefine _lib_ftruncate64
 #mesondefine _lib_getexecname
+#mesondefine _lib_getrusage
 #mesondefine _lib_gettimeofday
 #mesondefine _lib_iswalnum
 #mesondefine _lib_iswprint

features/meson.build

@@ -83,6 +83,10 @@ if feature_data.get('_lib_lchmod', 0) == 0
     endif
 endif
 
+feature_data.set10('_lib_getrusage',
+    cc.has_function('getrusage',
+        prefix: '\n'.join(['#include <sys/resource.h>', '#include <sys/time.h>']),
+        args: feature_test_args))
 feature_data.set10('_lib_sigqueue',
     cc.has_function('sigqueue', prefix: '#include <signal.h>', args: feature_test_args))
 # TODO: Enable iswprint() detection when we understand why doing so causes the

src/cmd/ksh93/bltins/times.c

@@ -3,10 +3,8 @@
 //
 #include "config_ast.h"  // IWYU pragma: keep
 
-#include <errno.h>
-#include <math.h>
 #include <string.h>
-#include <sys/times.h>
+#include <sys/time.h>
 
 #include "builtins.h"
 #include "defs.h"
@@ -15,8 +13,71 @@
 #include "sfio.h"
 #include "shcmd.h"
 
+// Print user and system mode CPU times.
+static_fn void print_times(struct timeval utime, struct timeval stime) {
+    int ut_min = utime.tv_sec / 60;
+    int ut_sec = utime.tv_sec % 60;
+    int ut_ms = utime.tv_usec / 1000;
+    int st_min = stime.tv_sec / 60;
+    int st_sec = stime.tv_sec % 60;
+    int st_ms = stime.tv_usec / 1000;
+    sfprintf(sfstdout, "%dm%d.%03ds %dm%d.%03ds\n", ut_min, ut_sec, ut_ms, st_min, st_sec, st_ms);
+}
+
+#if _lib_getrusage
+
+// Use getrusage() rather than times() since the former typically has higher resolution.
+#include <sys/resource.h>
+
+// Print user and system mode CPU times for both the shell and its child processes.
+static_fn void print_cpu_times(Shell_t *shp) {
+    UNUSED(shp);
+    struct rusage usage;
+
+    // Print the time (user & system) consumed by the shell.
+    getrusage(RUSAGE_SELF, &usage);
+    print_times(usage.ru_utime, usage.ru_stime);
+    // Print the time (user & system) consumed by the child processes of the shell.
+    getrusage(RUSAGE_CHILDREN, &usage);
+    print_times(usage.ru_utime, usage.ru_stime);
+}
+
+#else  // _lib_getrusage
+
+// Use times() since getrusage() isn't available. Note that it typically has a lower resolution
+// which is why we prefer getrusage().
+#include <sys/times.h>
+
+// Print user and system mode CPU times for both the shell and its child processes.
+static_fn void print_cpu_times(Shell_t *shp) {
+    struct tms cpu_times;
+    struct timeval utime, stime;
+    double dtime;
+
+    times(&cpu_times);
+
+    // Print the time (user & system) consumed by the shell.
+    dtime = (double)cpu_times.tms_utime / shp->gd->lim.clk_tck;
+    utime.tv_sec = dtime / 60;
+    utime.tv_usec = 1000000 * (dtime - utime.tv_sec);
+    dtime = (double)cpu_times.tms_stime / shp->gd->lim.clk_tck;
+    stime.tv_sec = dtime / 60;
+    stime.tv_usec = 1000000 * (dtime - utime.tv_sec);
+    print_times(utime, stime);
+
+    // Print the time (user & system) consumed by the child processes of the shell.
+    dtime = (double)cpu_times.tms_cutime / shp->gd->lim.clk_tck;
+    utime.tv_sec = dtime / 60;
+    utime.tv_usec = 1000000 * (dtime - utime.tv_sec);
+    dtime = (double)cpu_times.tms_cstime / shp->gd->lim.clk_tck;
+    stime.tv_sec = dtime / 60;
+    stime.tv_usec = 1000000 * (dtime - utime.tv_sec);
+    print_times(utime, stime);
+}
+
+#endif  // _lib_getrusage
+
 int b_times(int argc, char *argv[], Shbltin_t *context) {
-    Shell_t *shp = context->shp;
     const char *cmd = argv[0];
 
     while ((argc = optget(argv, sh_opttimes))) {
@@ -44,31 +105,6 @@ int b_times(int argc, char *argv[], Shbltin_t *context) {
         __builtin_unreachable();
     }
 
-    struct tms cpu_times;
-    clock_t rv = times(&cpu_times);
-    if (rv == (clock_t)-1) {
-        errormsg(SH_DICT, ERROR_usage(2), "times() function unexpectedly failed: errno %d %s",
-                 errno, strerror(errno));
-        __builtin_unreachable();
-    }
-
-    double utime, stime, utime_min, utime_sec, stime_min, stime_sec;
-
-    utime = (double)cpu_times.tms_utime / shp->gd->lim.clk_tck;
-    utime_min = floor(utime / 60);
-    utime_sec = utime - utime_min;
-    stime = (double)cpu_times.tms_stime / shp->gd->lim.clk_tck;
-    stime_min = floor(stime / 60);
-    stime_sec = stime - stime_min;
-    sfprintf(sfstdout, "%dm%.2fs %dm%.2fs\n", (int)utime_min, utime_sec, (int)stime_min, stime_sec);
-
-    utime = (double)cpu_times.tms_cutime / shp->gd->lim.clk_tck;
-    utime_min = floor(utime / 60);
-    utime_sec = utime - utime_min;
-    stime = (double)cpu_times.tms_cstime / shp->gd->lim.clk_tck;
-    stime_min = floor(stime / 60);
-    stime_sec = stime - stime_min;
-    sfprintf(sfstdout, "%dm%.2fs %dm%.2fs\n", (int)utime_min, utime_sec, (int)stime_min, stime_sec);
-
+    print_cpu_times(context->shp);
     return 0;
 }

src/cmd/ksh93/data/msg.c

@@ -187,6 +187,6 @@ const char e_prohibited[] = "login setuid/setgid shells prohibited";
 const char hist_fname[] = "/.sh_history";
 const char e_dot[] = ".";
 const char e_envmarker[] = "A__z";
-const char e_timeformat[] = "\nreal\t%2lR\nuser\t%2lU\nsys\t%2lS";
+const char e_timeformat[] = "\nreal\t%3lR\nuser\t%3lU\nsys\t%3lS";
 const char e_dict[] = "libshell";
 const char e_funload[] = "function, built-in or type definition for %s not found in %s";

src/cmd/ksh93/tests/time.exp

@@ -2,7 +2,7 @@
 set pid [spawn $ksh]
 expect_prompt
 
-set zero_time_re "\[\t \]*0m0\.\[0-9\]\[0-9\]s"
+set zero_time_re "\[\t \]*0m0\.\[0-9\]\[0-9\]\[0-9\]s"
 
 # ==========
 log_test_entry
@@ -16,7 +16,7 @@ expect_prompt
 # Timing a simple sleep command works.
 log_test_entry
 send "time sleep 1\r"
-expect -re "\r\nreal\[\t \]*0m1\.\[0-9\]\[0-9\]s\r\nuser$zero_time_re\r\nsys$zero_time_re\r\n" {
+expect -re "\r\nreal\[\t \]*0m1\.00\[0-9\]s\r\nuser$zero_time_re\r\nsys$zero_time_re\r\n" {
     puts "time sleep 1 produces expected output"
 }
 expect_prompt
@@ -25,7 +25,7 @@ expect_prompt
 # Timing a more complex pipeline works.
 log_test_entry
 send "time { sleep 0.05 | sleep 0.05; }\r"
-expect -re "\r\nreal\[\t \]*0m0\.0\[5-9\]s\r\nuser$zero_time_re\r\nsys$zero_time_re\r\n" {
+expect -re "\r\nreal\[\t \]*0m0\.0\[0-9\]\[0-9\]s\r\nuser$zero_time_re\r\nsys$zero_time_re\r\n" {
     puts "time sleep 0.05 pipeline produces expected output"
 }
 expect_prompt