Revert "Convert task timestamps to UInt32 delta-times since system boot."

This reverts commit d23a96f.

Author: NHDaly

base/Base_compiler.jl

@@ -163,21 +163,6 @@ between two moments in time.
 """
 time_ns() = ccall(:jl_hrtime, UInt64, ())
 
-"""
-    delta_time_ns() -> UInt32
-
-Get the amount of nanoseconds since system boot.
-To convert to a time matching `time_ns()`, call `delta_ns_to_time_ns(dt)`.
-"""
-delta_time_ns() = ccall(:jl_delta_time_now, UInt32, ())
-
-"""
-    delta_ns_to_time_ns(dt::UInt32) -> UInt64
-
-Convert the return value of `delta_time_ns()` to a time matching `time_ns()`.
-"""
-delta_ns_to_time_ns(dt) = ccall(:jl_hrtime_from_delta, UInt64, (UInt32,), dt)
-
 # A warning to be interpolated in the docstring of every dangerous mutating function in Base, see PR #50824
 const _DOCS_ALIASING_WARNING = """
 !!! warning

base/experimental.jl

@@ -517,7 +517,7 @@ function task_metrics(b::Bool)
 end
 
 """
-    Base.Experimental.task_cpu_time_ns(t::Task) -> Union{UInt32, Nothing}
+    Base.Experimental.task_cpu_time_ns(t::Task) -> Union{UInt64, Nothing}
 
 Return the total nanoseconds that the task `t` has spent running.
 This metric is only updated when `t` yields or completes unless `t` is the current task, in
@@ -539,14 +539,14 @@ function task_cpu_time_ns(t::Task=current_task())
     if t == current_task()
         # These metrics fields can't update while we're running.
         # But since we're running we need to include the time since we last started running!
-        return t.cpu_time_ns + (delta_time_ns() - t.last_started_running_at)
+        return t.cpu_time_ns + (time_ns() - t.last_started_running_at)
     else
         return t.cpu_time_ns
     end
 end
 
 """
-    Base.Experimental.task_wall_time_ns(t::Task) -> Union{UInt32, Nothing}
+    Base.Experimental.task_wall_time_ns(t::Task) -> Union{UInt64, Nothing}
 
 Return the total nanoseconds that the task `t` was runnable.
 This is the time since the task first entered the run queue until the time at which it
@@ -562,9 +562,9 @@ See [`Base.Experimental.task_metrics`](@ref).
 function task_wall_time_ns(t::Task=current_task())
     t.metrics_enabled || return nothing
     start_at = t.first_enqueued_at
-    start_at == 0 && return UInt32(0)
+    start_at == 0 && return UInt64(0)
     end_at = t.finished_at
-    end_at == 0 && return delta_time_ns() - start_at
+    end_at == 0 && return time_ns() - start_at
     return end_at - start_at
 end
 

base/task.jl

@@ -1118,7 +1118,7 @@ function try_yieldto(undo)
     ct = current_task()
     # [task] wait_time -(re)started-> user_time
     if ct.metrics_enabled
-        @atomic :monotonic ct.last_started_running_at = delta_time_ns()
+        @atomic :monotonic ct.last_started_running_at = time_ns()
     end
     if ct._isexception
         exc = ct.result
@@ -1209,7 +1209,7 @@ end
 # update the `cpu_time_ns` field of `t` to include the time since it last started running.
 function record_cpu_time!(t::Task)
     if t.metrics_enabled && !istaskdone(t)
-        @atomic :monotonic t.cpu_time_ns += delta_time_ns() - t.last_started_running_at
+        @atomic :monotonic t.cpu_time_ns += time_ns() - t.last_started_running_at
     end
     return t
 end
@@ -1219,7 +1219,7 @@ end
 # then set the `first_enqueued_at` field to the current time.
 function maybe_record_enqueued!(t::Task)
     if t.metrics_enabled && t.first_enqueued_at == 0
-        @atomic :monotonic t.first_enqueued_at = delta_time_ns()
+        @atomic :monotonic t.first_enqueued_at = time_ns()
     end
     return t
 end

src/init.c

@@ -46,19 +46,8 @@ extern BOOL (WINAPI *hSymRefreshModuleList)(HANDLE);
 jl_array_t *jl_module_init_order;
 arraylist_t *jl_entrypoint_mis;
 
-JL_DLLEXPORT uint64_t jl_system_boot_time = 0;
 JL_DLLEXPORT size_t jl_page_size;
 
-JL_DLLEXPORT delta_timestamp jl_delta_time_now(void) {
-    return jl_delta_timestamp(jl_hrtime() - jl_system_boot_time);
-}
-JL_DLLEXPORT delta_timestamp jl_delta_timestamp(uint64_t t) {
-    return (t - jl_system_boot_time);
-}
-JL_DLLEXPORT uint64_t jl_hrtime_from_delta(delta_timestamp t) {
-    return t + jl_system_boot_time;
-}
-
 void jl_init_stack_limits(int ismaster, void **stack_lo, void **stack_hi)
 {
 #ifdef _OS_WINDOWS_
@@ -746,8 +735,6 @@ static void init_global_mutexes(void) {
 
 JL_DLLEXPORT void julia_init(JL_IMAGE_SEARCH rel)
 {
-    jl_system_boot_time = jl_hrtime();
-
     // initialize many things, in no particular order
     // but generally running from simple platform things to optional
     // configuration features

src/jltypes.c

@@ -3786,10 +3786,10 @@ void jl_init_types(void) JL_GC_DISABLED
                                 jl_bool_type,
                                 jl_uint16_type,
                                 jl_bool_type,
-                                jl_uint32_type,
-                                jl_uint32_type,
-                                jl_uint32_type,
-                                jl_uint32_type),
+                                jl_uint64_type,
+                                jl_uint64_type,
+                                jl_uint64_type,
+                                jl_uint64_type),
                         jl_emptysvec,
                         0, 1, 6);
     XX(task);

src/julia.h

@@ -2274,15 +2274,6 @@ typedef struct _jl_handler_t {
 
 #define JL_RNG_SIZE 5 // xoshiro 4 + splitmix 1
 
-// delta_timestamp values are nanoseconds since the boot-time of the julia runtime system.
-// To convert to a real time, use jl_dt2hrtime(dt) and jl_hrtime2ns(hrt).
-typedef uint32_t delta_timestamp;
-
-extern JL_DLLEXPORT uint64_t jl_system_boot_time;
-JL_DLLEXPORT delta_timestamp jl_delta_time_now(void);
-JL_DLLEXPORT delta_timestamp jl_delta_timestamp(uint64_t t);
-JL_DLLEXPORT uint64_t jl_hrtime_from_delta(delta_timestamp t);
-
 typedef struct _jl_task_t {
     JL_DATA_TYPE
     jl_value_t *next; // invasive linked list for scheduler
@@ -2305,13 +2296,13 @@ typedef struct _jl_task_t {
     // flag indicating whether or not to record timing metrics for this task
     uint8_t metrics_enabled;
     // timestamp this task first entered the run queue
-    _Atomic(uint32_t) first_enqueued_at;
+    _Atomic(uint64_t) first_enqueued_at;
     // timestamp this task was most recently scheduled to run
-    _Atomic(uint32_t) last_started_running_at;
+    _Atomic(uint64_t) last_started_running_at;
     // time this task has spent running; updated when it yields or finishes.
-    _Atomic(uint32_t) cpu_time_ns;
+    _Atomic(uint64_t) cpu_time_ns;
     // timestamp this task finished (i.e. entered state DONE or FAILED).
-    _Atomic(uint32_t) finished_at;
+    _Atomic(uint64_t) finished_at;
 
 // hidden state:
     // cached floating point environment

src/task.c

@@ -316,7 +316,7 @@ void JL_NORETURN jl_finish_task(jl_task_t *ct)
     if (ct->metrics_enabled) {
         // [task] user_time -finished-> wait_time
         assert(jl_atomic_load_relaxed(&ct->first_enqueued_at) != 0);
-        delta_timestamp now = jl_delta_time_now();
+        uint64_t now = jl_hrtime();
         jl_atomic_store_relaxed(&ct->finished_at, now);
         jl_atomic_fetch_add_relaxed(&ct->cpu_time_ns, now - jl_atomic_load_relaxed(&ct->last_started_running_at));
     }
@@ -1261,7 +1261,7 @@ CFI_NORETURN
         // [task] wait_time -started-> user_time
         assert(jl_atomic_load_relaxed(&ct->first_enqueued_at) != 0);
         assert(jl_atomic_load_relaxed(&ct->last_started_running_at) == 0);
-        jl_atomic_store_relaxed(&ct->last_started_running_at, jl_delta_time_now());
+        jl_atomic_store_relaxed(&ct->last_started_running_at, jl_hrtime());
     }
     JL_PROBE_RT_START_TASK(ct);
     jl_timing_block_task_enter(ct, ptls, NULL);
@@ -1619,7 +1619,7 @@ jl_task_t *jl_init_root_task(jl_ptls_t ptls, void *stack_lo, void *stack_hi)
     ct->metrics_enabled = jl_atomic_load_relaxed(&jl_task_metrics_enabled) != 0;
     if (ct->metrics_enabled) {
         // [task] created -started-> user_time
-        delta_timestamp now = jl_delta_time_now();
+        uint64_t now = jl_hrtime();
         jl_atomic_store_relaxed(&ct->first_enqueued_at, now);
         jl_atomic_store_relaxed(&ct->last_started_running_at, now);
     }