Use CLOCK_MONOTONIC for serialization time as well.

This removes the last use of non-monotonic timers, even if it's
only for logging information.

Don't use COARSE, since we have no idea how coarse that is
and we want millisecond-level precision. But we don't really
care about the nanoseconds.

diff --git a/main.cpp b/main.cpp
index 32d654cee654bef1bea675585c1a0c23250e3129..ef75277eb5899285b0fe994b07c0c03f6da030b1 100644 (file)
--- a/main.cpp
+++ b/main.cpp
@@ -67,14 +67,14 @@ void do_nothing(int signum)
 {
 }
 
 {
 }
 

-CubemapStateProto collect_state(const timeval &serialize_start,
+CubemapStateProto collect_state(const timespec &serialize_start,

                                 const vector<Acceptor *> acceptors,
                                 const multimap<string, InputWithRefcount> inputs,
                                 ServerPool *servers)
 {
        CubemapStateProto state = servers->serialize();  // Fills streams() and clients().
        state.set_serialize_start_sec(serialize_start.tv_sec);
                                 const vector<Acceptor *> acceptors,
                                 const multimap<string, InputWithRefcount> inputs,
                                 ServerPool *servers)
 {
        CubemapStateProto state = servers->serialize();  // Fills streams() and clients().
        state.set_serialize_start_sec(serialize_start.tv_sec);

-       state.set_serialize_start_usec(serialize_start.tv_usec);
+       state.set_serialize_start_usec(serialize_start.tv_nsec / 1000);

        
        for (size_t i = 0; i < acceptors.size(); ++i) {
                state.add_acceptors()->MergeFrom(acceptors[i]->serialize());
        
        for (size_t i = 0; i < acceptors.size(); ++i) {
                state.add_acceptors()->MergeFrom(acceptors[i]->serialize());


@@ -390,7 +390,7 @@ start:
        find_deleted_streams(config, &deleted_urls);
 
        CubemapStateProto loaded_state;
        find_deleted_streams(config, &deleted_urls);
 
        CubemapStateProto loaded_state;

-       struct timeval serialize_start;
+       timespec serialize_start;

        set<string> deserialized_urls;
        map<sockaddr_in6, Acceptor *, Sockaddr6Compare> deserialized_acceptors;
        multimap<string, InputWithRefcount> inputs;  // multimap due to older versions without deduplication.
        set<string> deserialized_urls;
        map<sockaddr_in6, Acceptor *, Sockaddr6Compare> deserialized_acceptors;
        multimap<string, InputWithRefcount> inputs;  // multimap due to older versions without deduplication.


@@ -406,7 +406,7 @@ start:
                }
 
                serialize_start.tv_sec = loaded_state.serialize_start_sec();
                }
 
                serialize_start.tv_sec = loaded_state.serialize_start_sec();

-               serialize_start.tv_usec = loaded_state.serialize_start_usec();
+               serialize_start.tv_nsec = loaded_state.serialize_start_usec() * 1000ull;

 
                // Deserialize the streams.
                map<string, string> stream_headers_for_url;  // See below.
 
                // Deserialize the streams.
                map<string, string> stream_headers_for_url;  // See below.


@@ -529,14 +529,15 @@ start:
                input_stats_thread->run();
        }
 
                input_stats_thread->run();
        }
 

-       struct timeval server_start;
-       gettimeofday(&server_start, NULL);
+       timespec server_start;
+       int err = clock_gettime(CLOCK_MONOTONIC, &server_start);
+       assert(err != -1);

        if (state_fd != -1) {
                // Measure time from we started deserializing (below) to now, when basically everything
                // is up and running. This is, in other words, a conservative estimate of how long our
                // “glitch” period was, not counting of course reconnects if the configuration changed.
                double glitch_time = server_start.tv_sec - serialize_start.tv_sec +
        if (state_fd != -1) {
                // Measure time from we started deserializing (below) to now, when basically everything
                // is up and running. This is, in other words, a conservative estimate of how long our
                // “glitch” period was, not counting of course reconnects if the configuration changed.
                double glitch_time = server_start.tv_sec - serialize_start.tv_sec +

-                       1e-6 * (server_start.tv_usec - serialize_start.tv_usec);
+                       1e-9 * (server_start.tv_nsec - serialize_start.tv_nsec);

                log(INFO, "Re-exec happened in approx. %.0f ms.", glitch_time * 1000.0);
        }
 
                log(INFO, "Re-exec happened in approx. %.0f ms.", glitch_time * 1000.0);
        }
 


@@ -545,7 +546,8 @@ start:
        }
 
        // OK, we've been HUPed. Time to shut down everything, serialize, and re-exec.
        }
 
        // OK, we've been HUPed. Time to shut down everything, serialize, and re-exec.

-       gettimeofday(&serialize_start, NULL);
+       err = clock_gettime(CLOCK_MONOTONIC, &serialize_start);
+       assert(err != -1);

 
        if (input_stats_thread != NULL) {
                input_stats_thread->stop();
 
        if (input_stats_thread != NULL) {
                input_stats_thread->stop();