kudu-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From t...@apache.org
Subject [4/6] kudu git commit: monotime: remove granularity argument
Date Sun, 14 Aug 2016 22:34:27 GMT
monotime: remove granularity argument

In practice, we almost never used the 'COARSE' granularity.
Instead, it just added an extra crufty argument to hundreds of call
sites.

Let's remove it for now so that the API is a little simpler. If we ever
have a perf-sensitive use case where COARSE makes sense, we can revive
this.

monotime.h is part of the public-facing client API, but MonoTime isn't
used in any public-facing methods. So, I think it's safe to remove the
argument without considering this a breaking change.

Change-Id: If1d375d54e8598105f3ec833c37d96a382c1a8f7
Reviewed-on: http://gerrit.cloudera.org:8080/3966
Tested-by: Kudu Jenkins
Reviewed-by: Alexey Serbin <aserbin@cloudera.com>
Reviewed-by: Adar Dembo <adar@cloudera.com>


Project: http://git-wip-us.apache.org/repos/asf/kudu/repo
Commit: http://git-wip-us.apache.org/repos/asf/kudu/commit/ea81e052
Tree: http://git-wip-us.apache.org/repos/asf/kudu/tree/ea81e052
Diff: http://git-wip-us.apache.org/repos/asf/kudu/diff/ea81e052

Branch: refs/heads/master
Commit: ea81e0528b8c4ece51656ea9b8ceb1341d31910f
Parents: 9d897e6
Author: Todd Lipcon <todd@apache.org>
Authored: Fri Aug 12 20:08:20 2016 -0700
Committer: Todd Lipcon <todd@apache.org>
Committed: Sun Aug 14 22:33:16 2016 +0000

----------------------------------------------------------------------
 src/kudu/client/batcher.cc                      |  2 +-
 src/kudu/client/client-internal.cc              | 10 ++--
 src/kudu/client/client-unittest.cc              |  2 +-
 src/kudu/client/client.cc                       | 26 ++++-----
 src/kudu/client/meta_cache.cc                   | 10 ++--
 src/kudu/client/scan_token-internal.cc          |  2 +-
 src/kudu/client/scanner-internal.cc             |  6 +-
 src/kudu/consensus/consensus_peers.cc           |  4 +-
 src/kudu/consensus/consensus_queue.cc           |  8 +--
 src/kudu/consensus/consensus_queue.h            |  2 +-
 src/kudu/consensus/log_anchor_registry.cc       |  4 +-
 src/kudu/consensus/raft_consensus.cc            | 12 ++--
 .../consensus/raft_consensus_quorum-test.cc     |  8 +--
 src/kudu/fs/log_block_manager.cc                |  6 +-
 .../integration-tests/client-stress-test.cc     |  4 +-
 .../integration-tests/cluster_itest_util.cc     | 60 ++++++++++----------
 src/kudu/integration-tests/cluster_verifier.cc  |  8 +--
 .../integration-tests/create-table-itest.cc     |  4 +-
 src/kudu/integration-tests/delete_table-test.cc |  4 +-
 .../integration-tests/external_mini_cluster.cc  | 14 ++---
 .../external_mini_cluster_fs_inspector.cc       | 26 ++++-----
 .../integration-tests/linked_list-test-util.h   | 12 ++--
 .../integration-tests/master-stress-test.cc     |  6 +-
 .../integration-tests/master_failover-itest.cc  |  8 +--
 .../integration-tests/raft_consensus-itest.cc   | 16 +++---
 src/kudu/integration-tests/tablet_copy-itest.cc |  8 +--
 src/kudu/integration-tests/test_workload.cc     |  4 +-
 .../integration-tests/write_throttling-itest.cc |  8 +--
 src/kudu/master/catalog_manager.cc              | 14 ++---
 src/kudu/master/master-test.cc                  |  4 +-
 src/kudu/master/master.cc                       |  4 +-
 src/kudu/master/master_rpc.cc                   |  4 +-
 src/kudu/master/ts_descriptor.cc                | 10 ++--
 src/kudu/rpc/connection.cc                      |  2 +-
 src/kudu/rpc/inbound_call.cc                    | 10 ++--
 src/kudu/rpc/negotiation.cc                     |  2 +-
 src/kudu/rpc/outbound_call.cc                   |  4 +-
 src/kudu/rpc/reactor-test.cc                    |  4 +-
 src/kudu/rpc/reactor.cc                         |  6 +-
 src/kudu/rpc/result_tracker.cc                  |  2 +-
 src/kudu/rpc/rpc-stress-test.cc                 |  2 +-
 src/kudu/rpc/rpc-test.cc                        |  2 +-
 src/kudu/rpc/rpc.cc                             |  2 +-
 src/kudu/rpc/rpc_controller.cc                  |  2 +-
 src/kudu/rpc/rpc_stub-test.cc                   |  2 +-
 src/kudu/rpc/sasl_rpc-test.cc                   |  4 +-
 src/kudu/server/hybrid_clock-test.cc            |  8 +--
 src/kudu/server/hybrid_clock.cc                 |  2 +-
 src/kudu/server/logical_clock-test.cc           |  2 +-
 src/kudu/server/pprof-path-handlers.cc          |  4 +-
 src/kudu/server/server_base.cc                  |  4 +-
 src/kudu/server/webui_util.cc                   |  2 +-
 src/kudu/tablet/compaction-test.cc              |  4 +-
 src/kudu/tablet/mvcc-test.cc                    |  2 +-
 src/kudu/tablet/tablet.cc                       |  4 +-
 src/kudu/tablet/tablet_mm_ops-test.cc           |  2 +-
 src/kudu/tablet/tablet_peer.cc                  |  6 +-
 .../tablet/transactions/transaction_driver.cc   | 12 ++--
 .../tablet/transactions/transaction_tracker.cc  |  4 +-
 .../tablet/transactions/write_transaction.cc    |  6 +-
 src/kudu/tools/ksck.cc                          |  6 +-
 src/kudu/tools/ksck_remote-test.cc              | 14 ++---
 src/kudu/tserver/heartbeater.cc                 |  4 +-
 src/kudu/tserver/scanner_metrics.cc             |  2 +-
 src/kudu/tserver/scanners.cc                    |  6 +-
 src/kudu/tserver/tablet_copy_service-test.cc    |  4 +-
 src/kudu/tserver/tablet_copy_service.cc         |  4 +-
 src/kudu/tserver/tablet_server-stress-test.cc   |  4 +-
 src/kudu/tserver/tablet_server-test.cc          |  8 +--
 src/kudu/tserver/tablet_service.cc              | 10 ++--
 src/kudu/tserver/ts_tablet_manager-test.cc      |  4 +-
 src/kudu/tserver/ts_tablet_manager.cc           |  4 +-
 src/kudu/tserver/tserver-path-handlers.cc       |  4 +-
 src/kudu/util/countdown_latch.h                 |  2 +-
 .../util/debug/trace_event_synthetic_delay.cc   |  2 +-
 src/kudu/util/failure_detector-test.cc          |  4 +-
 src/kudu/util/failure_detector.cc               |  2 +-
 src/kudu/util/maintenance_manager.cc            |  6 +-
 src/kudu/util/maintenance_manager.h             |  2 +-
 src/kudu/util/metrics.cc                        |  6 +-
 src/kudu/util/monotime-test.cc                  | 39 ++++++-------
 src/kudu/util/monotime.cc                       | 12 +---
 src/kudu/util/monotime.h                        | 14 +----
 src/kudu/util/net/socket.cc                     |  4 +-
 src/kudu/util/striped64-test.cc                 |  6 +-
 src/kudu/util/striped64.cc                      |  2 +-
 src/kudu/util/threadpool.cc                     |  6 +-
 src/kudu/util/throttler-test.cc                 |  6 +-
 88 files changed, 293 insertions(+), 320 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/client/batcher.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/batcher.cc b/src/kudu/client/batcher.cc
index 8b68c5b..26a5944 100644
--- a/src/kudu/client/batcher.cc
+++ b/src/kudu/client/batcher.cc
@@ -488,7 +488,7 @@ MonoTime Batcher::ComputeDeadlineUnlocked() const {
                                 << GetStackTrace();
     timeout = MonoDelta::FromSeconds(60);
   }
-  MonoTime ret = MonoTime::Now(MonoTime::FINE);
+  MonoTime ret = MonoTime::Now();
   ret.AddDelta(timeout);
   return ret;
 }

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/client/client-internal.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/client-internal.cc b/src/kudu/client/client-internal.cc
index aa2f98e..8f4ab6f 100644
--- a/src/kudu/client/client-internal.cc
+++ b/src/kudu/client/client-internal.cc
@@ -90,7 +90,7 @@ Status RetryFunc(const MonoTime& deadline,
                  const boost::function<Status(const MonoTime&, bool*)>& func) {
   DCHECK(deadline.Initialized());
 
-  MonoTime now = MonoTime::Now(MonoTime::FINE);
+  MonoTime now = MonoTime::Now();
   if (deadline.ComesBefore(now)) {
     return Status::TimedOut(timeout_msg);
   }
@@ -104,7 +104,7 @@ Status RetryFunc(const MonoTime& deadline,
     if (!retry) {
       return s;
     }
-    now = MonoTime::Now(MonoTime::FINE);
+    now = MonoTime::Now();
     MonoDelta func_time = now.GetDeltaSince(func_stime);
 
     VLOG(1) << retry_msg << " status=" << s.ToString();
@@ -124,7 +124,7 @@ Status RetryFunc(const MonoTime& deadline,
     VLOG(1) << "Waiting for " << HumanReadableElapsedTime::ToShortString(wait_secs)
             << " before retrying...";
     SleepFor(MonoDelta::FromSeconds(wait_secs));
-    now = MonoTime::Now(MonoTime::FINE);
+    now = MonoTime::Now();
 
   }
 
@@ -154,7 +154,7 @@ Status KuduClient::Data::SyncLeaderMasterRpc(
     }
 
     // Have we already exceeded our deadline?
-    MonoTime now = MonoTime::Now(MonoTime::FINE);
+    MonoTime now = MonoTime::Now();
     if (deadline.ComesBefore(now)) {
       return Status::TimedOut(Substitute("$0 timed out after deadline expired",
                                          func_name));
@@ -199,7 +199,7 @@ Status KuduClient::Data::SyncLeaderMasterRpc(
     }
 
     if (s.IsTimedOut()) {
-      if (MonoTime::Now(MonoTime::FINE).ComesBefore(deadline)) {
+      if (MonoTime::Now().ComesBefore(deadline)) {
         LOG(WARNING) << "Unable to send the request (" << req.ShortDebugString()
                      << ") to leader Master (" << leader_master_hostport().ToString()
                      << "): " << s.ToString();

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/client/client-unittest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/client-unittest.cc b/src/kudu/client/client-unittest.cc
index 6c0033d..8a06846 100644
--- a/src/kudu/client/client-unittest.cc
+++ b/src/kudu/client/client-unittest.cc
@@ -160,7 +160,7 @@ Status TestFunc(const MonoTime& deadline, bool* retry, int* counter) {
 } // anonymous namespace
 
 TEST(ClientUnitTest, TestRetryFunc) {
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(MonoDelta::FromMilliseconds(100));
   int counter = 0;
   Status s = RetryFunc(deadline, "retrying test func", "timed out",

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/client/client.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/client.cc b/src/kudu/client/client.cc
index f0fba94..2d92e99 100644
--- a/src/kudu/client/client.cc
+++ b/src/kudu/client/client.cc
@@ -229,7 +229,7 @@ Status KuduClientBuilder::Build(shared_ptr<KuduClient>* client) {
 
   // Let's allow for plenty of time for discovering the master the first
   // time around.
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(c->default_admin_operation_timeout());
   RETURN_NOT_OK_PREPEND(c->data_->SetMasterServerProxy(c.get(), deadline),
                         "Could not locate the leader master");
@@ -263,13 +263,13 @@ KuduTableCreator* KuduClient::NewTableCreator() {
 
 Status KuduClient::IsCreateTableInProgress(const string& table_name,
                                            bool *create_in_progress) {
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(default_admin_operation_timeout());
   return data_->IsCreateTableInProgress(this, table_name, deadline, create_in_progress);
 }
 
 Status KuduClient::DeleteTable(const string& table_name) {
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(default_admin_operation_timeout());
   return data_->DeleteTable(this, table_name, deadline);
 }
@@ -280,14 +280,14 @@ KuduTableAlterer* KuduClient::NewTableAlterer(const string& name) {
 
 Status KuduClient::IsAlterTableInProgress(const string& table_name,
                                           bool *alter_in_progress) {
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(default_admin_operation_timeout());
   return data_->IsAlterTableInProgress(this, table_name, deadline, alter_in_progress);
 }
 
 Status KuduClient::GetTableSchema(const string& table_name,
                                   KuduSchema* schema) {
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(default_admin_operation_timeout());
   string table_id_ignored;
   PartitionSchema partition_schema;
@@ -303,7 +303,7 @@ Status KuduClient::ListTabletServers(vector<KuduTabletServer*>* tablet_servers)
   ListTabletServersRequestPB req;
   ListTabletServersResponsePB resp;
 
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(default_admin_operation_timeout());
   Status s =
       data_->SyncLeaderMasterRpc<ListTabletServersRequestPB, ListTabletServersResponsePB>(
@@ -336,7 +336,7 @@ Status KuduClient::ListTables(vector<string>* tables,
   if (!filter.empty()) {
     req.set_name_filter(filter);
   }
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(default_admin_operation_timeout());
   Status s =
       data_->SyncLeaderMasterRpc<ListTablesRequestPB, ListTablesResponsePB>(
@@ -375,7 +375,7 @@ Status KuduClient::OpenTable(const string& table_name,
   KuduSchema schema;
   string table_id;
   PartitionSchema partition_schema;
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(default_admin_operation_timeout());
   RETURN_NOT_OK(data_->GetTableSchema(this,
                                       table_name,
@@ -546,7 +546,7 @@ Status KuduTableCreator::Create() {
 
   req.mutable_partition_schema()->CopyFrom(data_->partition_schema_);
 
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   if (data_->timeout_.Initialized()) {
     deadline.AddDelta(data_->timeout_);
   } else {
@@ -910,7 +910,7 @@ Status KuduTableAlterer::Alter() {
   MonoDelta timeout = data_->timeout_.Initialized() ?
     data_->timeout_ :
     data_->client_->default_admin_operation_timeout();
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(timeout);
   RETURN_NOT_OK(data_->client_->data_->AlterTable(data_->client_, req, deadline,
                                                   data_->has_alter_partitioning_steps));
@@ -1130,7 +1130,7 @@ Status KuduScanner::Open() {
 
   VLOG(1) << "Beginning scan " << ToString();
 
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(data_->configuration().timeout());
   set<string> blacklist;
 
@@ -1210,7 +1210,7 @@ Status KuduScanner::NextBatch(KuduScanBatch* batch) {
     // More data is available in this tablet.
     VLOG(1) << "Continuing scan " << ToString();
 
-    MonoTime batch_deadline = MonoTime::Now(MonoTime::FINE);
+    MonoTime batch_deadline = MonoTime::Now();
     batch_deadline.AddDelta(data_->configuration().timeout());
     data_->PrepareRequest(KuduScanner::Data::CONTINUE);
 
@@ -1258,7 +1258,7 @@ Status KuduScanner::NextBatch(KuduScanBatch* batch) {
     // server closed it for us.
     VLOG(1) << "Scanning next tablet " << ToString();
     data_->last_primary_key_.clear();
-    MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+    MonoTime deadline = MonoTime::Now();
     deadline.AddDelta(data_->configuration().timeout());
     set<string> blacklist;
 

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/client/meta_cache.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/meta_cache.cc b/src/kudu/client/meta_cache.cc
index 0ee1c39..4d47901 100644
--- a/src/kudu/client/meta_cache.cc
+++ b/src/kudu/client/meta_cache.cc
@@ -296,7 +296,7 @@ bool MetaCacheEntry::Contains(const string& partition_key) const {
 
 bool MetaCacheEntry::stale() const {
   DCHECK(Initialized());
-  return expiration_time_.ComesBefore(MonoTime::Now(MonoTime::FINE)) ||
+  return expiration_time_.ComesBefore(MonoTime::Now()) ||
          (!is_non_covered_range() && tablet_->stale());
 }
 
@@ -311,7 +311,7 @@ string MetaCacheEntry::DebugString(const KuduTable* table) const {
   string upper_bound_string = upper_bound.empty() ? "<end>" :
     table->partition_schema().PartitionKeyDebugString(upper_bound, *table->schema().schema_);
 
-  MonoDelta ttl = expiration_time_.GetDeltaSince(MonoTime::Now(MonoTime::FINE));
+  MonoDelta ttl = expiration_time_.GetDeltaSince(MonoTime::Now());
 
   if (is_non_covered_range()) {
     return strings::Substitute(
@@ -645,7 +645,7 @@ void LookupRpc::SendRpc() {
   // some additional tablets.
 
   // See KuduClient::Data::SyncLeaderMasterRpc().
-  MonoTime now = MonoTime::Now(MonoTime::FINE);
+  MonoTime now = MonoTime::Now();
   if (retrier().deadline().ComesBefore(now)) {
     SendRpcCb(Status::TimedOut("timed out after deadline expired"));
     return;
@@ -718,7 +718,7 @@ void LookupRpc::SendRpcCb(const Status& status) {
 
   // Check for more generic errors (TimedOut can come from multiple places).
   if (new_status.IsTimedOut()) {
-    if (MonoTime::Now(MonoTime::FINE).ComesBefore(retrier().deadline())) {
+    if (MonoTime::Now().ComesBefore(retrier().deadline())) {
       if (meta_cache_->client_->IsMultiMaster()) {
         LOG(WARNING) << "Leader Master timed out, re-trying...";
         ResetMasterLeaderAndRetry();
@@ -770,7 +770,7 @@ Status MetaCache::ProcessLookupResponse(const LookupRpc& rpc,
   VLOG(2) << "Processing master response for " << rpc.ToString()
           << ". Response: " << rpc.resp().ShortDebugString();
 
-  MonoTime expiration_time = MonoTime::Now(MonoTime::FINE);
+  MonoTime expiration_time = MonoTime::Now();
   expiration_time.AddDelta(MonoDelta::FromMilliseconds(rpc.resp().ttl_millis()));
 
   std::lock_guard<rw_spinlock> l(lock_);

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/client/scan_token-internal.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/scan_token-internal.cc b/src/kudu/client/scan_token-internal.cc
index 8697fb1..2da971b 100644
--- a/src/kudu/client/scan_token-internal.cc
+++ b/src/kudu/client/scan_token-internal.cc
@@ -210,7 +210,7 @@ Status KuduScanTokenBuilder::Data::Build(vector<KuduScanToken*>* tokens) {
   pb.set_cache_blocks(configuration_.spec().cache_blocks());
   pb.set_fault_tolerant(configuration_.is_fault_tolerant());
 
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(client->default_admin_operation_timeout());
 
   PartitionPruner pruner;

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/client/scanner-internal.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/scanner-internal.cc b/src/kudu/client/scanner-internal.cc
index 68c53bc..6b0544a 100644
--- a/src/kudu/client/scanner-internal.cc
+++ b/src/kudu/client/scanner-internal.cc
@@ -124,7 +124,7 @@ Status KuduScanner::Data::HandleError(const ScanRpcStatus& err,
   if (backoff) {
     MonoDelta sleep =
         KuduClient::Data::ComputeExponentialBackoff(scan_attempts_);
-    MonoTime now = MonoTime::Now(MonoTime::FINE);
+    MonoTime now = MonoTime::Now();
     now.AddDelta(sleep);
     if (deadline.ComesBefore(now)) {
       Status ret = Status::TimedOut("unable to retry before timeout",
@@ -231,7 +231,7 @@ ScanRpcStatus KuduScanner::Data::SendScanRpc(const MonoTime& overall_deadline,
   // if the first server we try happens to be hung.
   MonoTime rpc_deadline;
   if (allow_time_for_failover) {
-    rpc_deadline = MonoTime::Now(MonoTime::FINE);
+    rpc_deadline = MonoTime::Now();
     rpc_deadline.AddDelta(table_->client()->default_rpc_timeout());
     rpc_deadline = MonoTime::Earliest(overall_deadline, rpc_deadline);
   } else {
@@ -354,7 +354,7 @@ Status KuduScanner::Data::OpenTablet(const string& partition_key,
     // it's likely that the tablet is undergoing a leader election and will
     // soon have one.
     if (lookup_status.IsServiceUnavailable() &&
-        MonoTime::Now(MonoTime::FINE).ComesBefore(deadline)) {
+        MonoTime::Now().ComesBefore(deadline)) {
 
       // ServiceUnavailable means that we have already blacklisted all of the candidate
       // tablet servers. So, we clear the list so that we will cycle through them all

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/consensus/consensus_peers.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_peers.cc b/src/kudu/consensus/consensus_peers.cc
index 6ab83ce..21a0807 100644
--- a/src/kudu/consensus/consensus_peers.cc
+++ b/src/kudu/consensus/consensus_peers.cc
@@ -448,7 +448,7 @@ Status SetPermanentUuidForRemotePeer(const shared_ptr<Messenger>& messenger,
   // TODO generalize this exponential backoff algorithm, as we do the
   // same thing in catalog_manager.cc
   // (AsyncTabletRequestTask::RpcCallBack).
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(MonoDelta::FromMilliseconds(FLAGS_raft_get_node_instance_timeout_ms));
   int attempt = 1;
   while (true) {
@@ -465,7 +465,7 @@ Status SetPermanentUuidForRemotePeer(const shared_ptr<Messenger>& messenger,
 
     LOG(WARNING) << "Error getting permanent uuid from config peer " << hostport.ToString() << ": "
                  << s.ToString();
-    MonoTime now = MonoTime::Now(MonoTime::FINE);
+    MonoTime now = MonoTime::Now();
     if (now.ComesBefore(deadline)) {
       int64_t remaining_ms = deadline.GetDeltaSince(now).ToMilliseconds();
       int64_t base_delay_ms = 1 << (attempt + 3); // 1st retry delayed 2^4 ms, 2nd 2^5, etc..

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/consensus/consensus_queue.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_queue.cc b/src/kudu/consensus/consensus_queue.cc
index e32b153..fefa1d2 100644
--- a/src/kudu/consensus/consensus_queue.cc
+++ b/src/kudu/consensus/consensus_queue.cc
@@ -148,7 +148,7 @@ void PeerMessageQueue::SetLeaderMode(const OpId& committed_index,
 
   // Reset last communication time with all peers to reset the clock on the
   // failure timeout.
-  MonoTime now(MonoTime::Now(MonoTime::FINE));
+  MonoTime now(MonoTime::Now());
   for (const PeersMap::value_type& entry : peers_map_) {
     entry.second->last_successful_communication_time = now;
   }
@@ -299,7 +299,7 @@ Status PeerMessageQueue::RequestForPeer(const string& uuid,
   }
 
   MonoDelta unreachable_time =
-      MonoTime::Now(MonoTime::FINE).GetDeltaSince(peer->last_successful_communication_time);
+      MonoTime::Now().GetDeltaSince(peer->last_successful_communication_time);
   if (unreachable_time.ToSeconds() > FLAGS_follower_unavailable_considered_failed_sec) {
     if (CountVoters(*queue_state_.active_config) > 2) {
       // We never drop from 2 to 1 automatically, at least for now. We may want
@@ -470,7 +470,7 @@ void PeerMessageQueue::NotifyPeerIsResponsiveDespiteError(const std::string& pee
   std::lock_guard<simple_spinlock> l(queue_lock_);
   TrackedPeer* peer = FindPtrOrNull(peers_map_, peer_uuid);
   if (!peer) return;
-  peer->last_successful_communication_time = MonoTime::Now(MonoTime::FINE);
+  peer->last_successful_communication_time = MonoTime::Now();
 }
 
 void PeerMessageQueue::ResponseFromPeer(const std::string& peer_uuid,
@@ -531,7 +531,7 @@ void PeerMessageQueue::ResponseFromPeer(const std::string& peer_uuid,
     // Update the peer status based on the response.
     peer->is_new = false;
     peer->last_known_committed_idx = status.last_committed_idx();
-    peer->last_successful_communication_time = MonoTime::Now(MonoTime::FINE);
+    peer->last_successful_communication_time = MonoTime::Now();
 
     // If the reported last-received op for the replica is in our local log,
     // then resume sending entries from that point onward. Otherwise, resume

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/consensus/consensus_queue.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_queue.h b/src/kudu/consensus/consensus_queue.h
index 590adf5..16d2e4c 100644
--- a/src/kudu/consensus/consensus_queue.h
+++ b/src/kudu/consensus/consensus_queue.h
@@ -74,7 +74,7 @@ class PeerMessageQueue {
           last_received(MinimumOpId()),
           last_known_committed_idx(MinimumOpId().index()),
           is_last_exchange_successful(false),
-          last_successful_communication_time(MonoTime::Now(MonoTime::FINE)),
+          last_successful_communication_time(MonoTime::Now()),
           needs_tablet_copy(false),
           last_seen_term_(0) {}
 

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/consensus/log_anchor_registry.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log_anchor_registry.cc b/src/kudu/consensus/log_anchor_registry.cc
index 017ef79..68d8819 100644
--- a/src/kudu/consensus/log_anchor_registry.cc
+++ b/src/kudu/consensus/log_anchor_registry.cc
@@ -87,7 +87,7 @@ size_t LogAnchorRegistry::GetAnchorCountForTests() const {
 std::string LogAnchorRegistry::DumpAnchorInfo() const {
   string buf;
   std::lock_guard<simple_spinlock> l(lock_);
-  MonoTime now = MonoTime::Now(MonoTime::FINE);
+  MonoTime now = MonoTime::Now();
   for (const AnchorMultiMap::value_type& entry : anchors_) {
     const LogAnchor* anchor = entry.second;
     DCHECK(anchor->is_registered);
@@ -109,7 +109,7 @@ void LogAnchorRegistry::RegisterUnlocked(int64_t log_index,
   anchor->log_index = log_index;
   anchor->owner.assign(owner);
   anchor->is_registered = true;
-  anchor->when_registered = MonoTime::Now(MonoTime::FINE);
+  anchor->when_registered = MonoTime::Now();
   AnchorMultiMap::value_type value(log_index, anchor);
   anchors_.insert(value);
 }

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/consensus/raft_consensus.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus.cc b/src/kudu/consensus/raft_consensus.cc
index 4aac666..3cdaa3b 100644
--- a/src/kudu/consensus/raft_consensus.cc
+++ b/src/kudu/consensus/raft_consensus.cc
@@ -420,10 +420,10 @@ Status RaftConsensus::StartElection(ElectionMode mode) {
 }
 
 Status RaftConsensus::WaitUntilLeaderForTests(const MonoDelta& timeout) {
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(timeout);
   while (role() != consensus::RaftPeerPB::LEADER) {
-    MonoTime now = MonoTime::Now(MonoTime::FINE);
+    MonoTime now = MonoTime::Now();
     if (!now.ComesBefore(deadline)) {
       return Status::TimedOut(Substitute("Peer $0 is not leader of tablet $1 after $2. Role: $3",
                                          peer_uuid(), tablet_id(), timeout.ToString(), role()));
@@ -1087,7 +1087,7 @@ Status RaftConsensus::UpdateReplica(const ConsensusRequestPB* request,
     RETURN_NOT_OK(SnoozeFailureDetectorUnlocked());
 
     // Also prohibit voting for anyone for the minimum election timeout.
-    withhold_votes_until_ = MonoTime::Now(MonoTime::FINE);
+    withhold_votes_until_ = MonoTime::Now();
     withhold_votes_until_.AddDelta(MinimumElectionTimeout());
 
 
@@ -1341,7 +1341,7 @@ Status RaftConsensus::RequestVote(const VoteRequestPB* request, VoteResponsePB*
   //
   // See also https://ramcloud.stanford.edu/~ongaro/thesis.pdf
   // section 4.2.3.
-  MonoTime now = MonoTime::Now(MonoTime::COARSE);
+  MonoTime now = MonoTime::Now();
   if (!request->ignore_live_leader() &&
       now.ComesBefore(withhold_votes_until_)) {
     return RequestVoteRespondLeaderIsAlive(request, response);
@@ -1929,7 +1929,7 @@ Status RaftConsensus::EnsureFailureDetectorEnabledUnlocked() {
     return Status::OK();
   }
   return failure_detector_->Track(kTimerId,
-                                  MonoTime::Now(MonoTime::FINE),
+                                  MonoTime::Now(),
                                   // Unretained to avoid a circular ref.
                                   Bind(&RaftConsensus::ReportFailureDetected, Unretained(this)));
 }
@@ -1963,7 +1963,7 @@ Status RaftConsensus::SnoozeFailureDetectorUnlocked(const MonoDelta& additional_
     return Status::OK();
   }
 
-  MonoTime time = MonoTime::Now(MonoTime::FINE);
+  MonoTime time = MonoTime::Now();
   time.AddDelta(additional_delta);
 
   if (allow_logging == ALLOW_LOGGING) {

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/consensus/raft_consensus_quorum-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus_quorum-test.cc b/src/kudu/consensus/raft_consensus_quorum-test.cc
index 4e6c665..eb583d1 100644
--- a/src/kudu/consensus/raft_consensus_quorum-test.cc
+++ b/src/kudu/consensus/raft_consensus_quorum-test.cc
@@ -75,9 +75,9 @@ void DoNothing(const string& s) {
 }
 
 Status WaitUntilLeaderForTests(RaftConsensus* raft) {
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(MonoDelta::FromSeconds(15));
-  while (MonoTime::Now(MonoTime::FINE).ComesBefore(deadline)) {
+  while (MonoTime::Now().ComesBefore(deadline)) {
     if (raft->GetActiveRole() == RaftPeerPB::LEADER) {
       return Status::OK();
     }
@@ -304,7 +304,7 @@ class RaftConsensusQuorumTest : public KuduTest {
                                         int peer_idx,
                                         int leader_idx) {
     MonoDelta timeout(MonoDelta::FromSeconds(10));
-    MonoTime start(MonoTime::Now(MonoTime::FINE));
+    MonoTime start(MonoTime::Now());
 
     scoped_refptr<RaftConsensus> peer;
     CHECK_OK(peers_->GetPeerByIdx(peer_idx, &peer));
@@ -322,7 +322,7 @@ class RaftConsensusQuorumTest : public KuduTest {
           return;
         }
       }
-      MonoDelta elapsed = MonoTime::Now(MonoTime::FINE).GetDeltaSince(start);
+      MonoDelta elapsed = MonoTime::Now().GetDeltaSince(start);
       if (elapsed.MoreThan(timeout)) {
         break;
       }

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/fs/log_block_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/log_block_manager.cc b/src/kudu/fs/log_block_manager.cc
index dfeb454..5f95219 100644
--- a/src/kudu/fs/log_block_manager.cc
+++ b/src/kudu/fs/log_block_manager.cc
@@ -1414,7 +1414,7 @@ LogBlockContainer* LogBlockManager::GetAvailableContainer(
     const unordered_set<string>& full_root_paths) {
   LogBlockContainer* container = nullptr;
   int64_t disk_full_containers_delta = 0;
-  MonoTime now = MonoTime::Now(MonoTime::FINE);
+  MonoTime now = MonoTime::Now();
   {
     std::lock_guard<simple_spinlock> l(lock_);
     // Move containers from disk_full -> available.
@@ -1778,7 +1778,7 @@ bool FullDiskCache::IsRootFull(const std::string& root_path, MonoTime* expires_o
     expires = FindOrNull(cache_, root_path);
   }
   if (expires == nullptr) return false; // No entry exists.
-  if (expires->ComesBefore(MonoTime::Now(MonoTime::FINE))) return false; // Expired.
+  if (expires->ComesBefore(MonoTime::Now())) return false; // Expired.
   if (expires_out != nullptr) {
     *expires_out = *expires;
   }
@@ -1786,7 +1786,7 @@ bool FullDiskCache::IsRootFull(const std::string& root_path, MonoTime* expires_o
 }
 
 void FullDiskCache::MarkRootFull(const string& root_path) {
-  MonoTime expires = MonoTime::Now(MonoTime::FINE);
+  MonoTime expires = MonoTime::Now();
   expires.AddDelta(MonoDelta::FromSeconds(FLAGS_log_block_manager_full_disk_cache_seconds));
   std::lock_guard<percpu_rwlock> l(lock_);
   InsertOrUpdate(&cache_, root_path, expires); // Last one wins.

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/integration-tests/client-stress-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/client-stress-test.cc b/src/kudu/integration-tests/client-stress-test.cc
index 5a1f17b..b102ca5 100644
--- a/src/kudu/integration-tests/client-stress-test.cc
+++ b/src/kudu/integration-tests/client-stress-test.cc
@@ -239,7 +239,7 @@ TEST_F(ClientStressTest_LowMemory, TestMemoryThrottling) {
   work.Start();
 
   // Wait until we've rejected some number of requests.
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(kMaxWaitTime);
   while (true) {
     int64_t total_num_rejections = 0;
@@ -273,7 +273,7 @@ TEST_F(ClientStressTest_LowMemory, TestMemoryThrottling) {
     }
     if (total_num_rejections >= kMinRejections) {
       break;
-    } else if (deadline.ComesBefore(MonoTime::Now(MonoTime::FINE))) {
+    } else if (deadline.ComesBefore(MonoTime::Now())) {
       FAIL() << "Ran for " << kMaxWaitTime.ToString() << ", deadline expired and only saw "
              << total_num_rejections << " memory rejections";
     }

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/integration-tests/cluster_itest_util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/cluster_itest_util.cc b/src/kudu/integration-tests/cluster_itest_util.cc
index 9254c88..49eea9f 100644
--- a/src/kudu/integration-tests/cluster_itest_util.cc
+++ b/src/kudu/integration-tests/cluster_itest_util.cc
@@ -148,7 +148,7 @@ Status WaitForServersToAgree(const MonoDelta& timeout,
                              const TabletServerMap& tablet_servers,
                              const string& tablet_id,
                              int64_t minimum_index) {
-  MonoTime now = MonoTime::Now(MonoTime::COARSE);
+  MonoTime now = MonoTime::Now();
   MonoTime deadline = now;
   deadline.AddDelta(timeout);
 
@@ -185,7 +185,7 @@ Status WaitForServersToAgree(const MonoDelta& timeout,
     LOG(INFO) << "Not converged past " << minimum_index << " yet: " << ids;
     SleepFor(MonoDelta::FromMilliseconds(min(i * 100, 1000)));
 
-    now = MonoTime::Now(MonoTime::COARSE);
+    now = MonoTime::Now();
   }
   return Status::TimedOut(Substitute("Index $0 not available on all replicas after $1. ",
                                               minimum_index, timeout.ToString()));
@@ -196,7 +196,7 @@ Status WaitUntilAllReplicasHaveOp(const int64_t log_index,
                                   const string& tablet_id,
                                   const vector<TServerDetails*>& replicas,
                                   const MonoDelta& timeout) {
-  MonoTime start = MonoTime::Now(MonoTime::FINE);
+  MonoTime start = MonoTime::Now();
   MonoDelta passed = MonoDelta::FromMilliseconds(0);
   while (true) {
     vector<OpId> op_ids;
@@ -214,7 +214,7 @@ Status WaitUntilAllReplicasHaveOp(const int64_t log_index,
     } else {
       LOG(WARNING) << "Got error getting last opid for each replica: " << s.ToString();
     }
-    passed = MonoTime::Now(MonoTime::FINE).GetDeltaSince(start);
+    passed = MonoTime::Now().GetDeltaSince(start);
     if (passed.MoreThan(timeout)) {
       break;
     }
@@ -292,7 +292,7 @@ Status WaitUntilCommittedConfigNumVotersIs(int config_size,
                                            const TServerDetails* replica,
                                            const std::string& tablet_id,
                                            const MonoDelta& timeout) {
-  MonoTime start = MonoTime::Now(MonoTime::FINE);
+  MonoTime start = MonoTime::Now();
   MonoTime deadline = start;
   deadline.AddDelta(timeout);
 
@@ -301,7 +301,7 @@ Status WaitUntilCommittedConfigNumVotersIs(int config_size,
   Status s;
   ConsensusStatePB cstate;
   while (true) {
-    MonoDelta remaining_timeout = deadline.GetDeltaSince(MonoTime::Now(MonoTime::FINE));
+    MonoDelta remaining_timeout = deadline.GetDeltaSince(MonoTime::Now());
     s = GetConsensusState(replica, tablet_id, CONSENSUS_CONFIG_COMMITTED,
                           remaining_timeout, &cstate);
     if (s.ok()) {
@@ -310,7 +310,7 @@ Status WaitUntilCommittedConfigNumVotersIs(int config_size,
       }
     }
 
-    if (MonoTime::Now(MonoTime::FINE).GetDeltaSince(start).MoreThan(timeout)) {
+    if (MonoTime::Now().GetDeltaSince(start).MoreThan(timeout)) {
       break;
     }
     SleepFor(MonoDelta::FromMilliseconds(1 << backoff_exp));
@@ -326,27 +326,27 @@ Status WaitUntilCommittedConfigOpIdIndexIs(int64_t opid_index,
                                            const TServerDetails* replica,
                                            const std::string& tablet_id,
                                            const MonoDelta& timeout) {
-  MonoTime start = MonoTime::Now(MonoTime::FINE);
+  MonoTime start = MonoTime::Now();
   MonoTime deadline = start;
   deadline.AddDelta(timeout);
 
   Status s;
   ConsensusStatePB cstate;
   while (true) {
-    MonoDelta remaining_timeout = deadline.GetDeltaSince(MonoTime::Now(MonoTime::FINE));
+    MonoDelta remaining_timeout = deadline.GetDeltaSince(MonoTime::Now());
     s = GetConsensusState(replica, tablet_id, CONSENSUS_CONFIG_COMMITTED,
                           remaining_timeout, &cstate);
     if (s.ok() && cstate.config().opid_index() == opid_index) {
       return Status::OK();
     }
-    if (MonoTime::Now(MonoTime::FINE).GetDeltaSince(start).MoreThan(timeout)) break;
+    if (MonoTime::Now().GetDeltaSince(start).MoreThan(timeout)) break;
     SleepFor(MonoDelta::FromMilliseconds(10));
   }
   return Status::TimedOut(Substitute("Committed config opid_index does not equal $0 "
                                      "after waiting for $1. "
                                      "Last consensus state: $2. Last status: $3",
                                      opid_index,
-                                     MonoTime::Now(MonoTime::FINE).GetDeltaSince(start).ToString(),
+                                     MonoTime::Now().GetDeltaSince(start).ToString(),
                                      cstate.ShortDebugString(), s.ToString()));
 }
 
@@ -354,26 +354,26 @@ Status WaitUntilCommittedOpIdIndexIs(int64_t opid_index,
                                      TServerDetails* replica,
                                      const string& tablet_id,
                                      const MonoDelta& timeout) {
-  MonoTime start = MonoTime::Now(MonoTime::FINE);
+  MonoTime start = MonoTime::Now();
   MonoTime deadline = start;
   deadline.AddDelta(timeout);
 
   Status s;
   OpId op_id;
   while (true) {
-    MonoDelta remaining_timeout = deadline.GetDeltaSince(MonoTime::Now(MonoTime::FINE));
+    MonoDelta remaining_timeout = deadline.GetDeltaSince(MonoTime::Now());
     s = GetLastOpIdForReplica(tablet_id, replica, consensus::COMMITTED_OPID, remaining_timeout,
                               &op_id);
     if (s.ok() && op_id.index() == opid_index) {
       return Status::OK();
     }
-    if (MonoTime::Now(MonoTime::FINE).GetDeltaSince(start).MoreThan(timeout)) break;
+    if (MonoTime::Now().GetDeltaSince(start).MoreThan(timeout)) break;
     SleepFor(MonoDelta::FromMilliseconds(10));
   }
   return Status::TimedOut(Substitute("Committed consensus opid_index does not equal $0 "
                                      "after waiting for $1. Last opid: $2. Last status: $3",
                                      opid_index,
-                                     MonoTime::Now(MonoTime::FINE).GetDeltaSince(start).ToString(),
+                                     MonoTime::Now().GetDeltaSince(start).ToString(),
                                      OpIdToString(op_id),
                                      s.ToString()));
 }
@@ -400,7 +400,7 @@ Status GetReplicaStatusAndCheckIfLeader(const TServerDetails* replica,
 Status WaitUntilLeader(const TServerDetails* replica,
                        const string& tablet_id,
                        const MonoDelta& timeout) {
-  MonoTime start = MonoTime::Now(MonoTime::FINE);
+  MonoTime start = MonoTime::Now();
   MonoTime deadline = start;
   deadline.AddDelta(timeout);
 
@@ -408,13 +408,13 @@ Status WaitUntilLeader(const TServerDetails* replica,
   const int kMaxBackoffExp = 7;
   Status s;
   while (true) {
-    MonoDelta remaining_timeout = deadline.GetDeltaSince(MonoTime::Now(MonoTime::FINE));
+    MonoDelta remaining_timeout = deadline.GetDeltaSince(MonoTime::Now());
     s = GetReplicaStatusAndCheckIfLeader(replica, tablet_id, remaining_timeout);
     if (s.ok()) {
       return Status::OK();
     }
 
-    if (MonoTime::Now(MonoTime::FINE).GetDeltaSince(start).MoreThan(timeout)) {
+    if (MonoTime::Now().GetDeltaSince(start).MoreThan(timeout)) {
       break;
     }
     SleepFor(MonoDelta::FromMilliseconds(1 << backoff_exp));
@@ -431,20 +431,20 @@ Status FindTabletLeader(const TabletServerMap& tablet_servers,
   vector<TServerDetails*> tservers;
   AppendValuesFromMap(tablet_servers, &tservers);
 
-  MonoTime start = MonoTime::Now(MonoTime::FINE);
+  MonoTime start = MonoTime::Now();
   MonoTime deadline = start;
   deadline.AddDelta(timeout);
   Status s;
   int i = 0;
   while (true) {
-    MonoDelta remaining_timeout = deadline.GetDeltaSince(MonoTime::Now(MonoTime::FINE));
+    MonoDelta remaining_timeout = deadline.GetDeltaSince(MonoTime::Now());
     s = GetReplicaStatusAndCheckIfLeader(tservers[i], tablet_id, remaining_timeout);
     if (s.ok()) {
       *leader = tservers[i];
       return Status::OK();
     }
 
-    if (deadline.ComesBefore(MonoTime::Now(MonoTime::FINE))) break;
+    if (deadline.ComesBefore(MonoTime::Now())) break;
     i = (i + 1) % tservers.size();
     if (i == 0) {
       SleepFor(MonoDelta::FromMilliseconds(10));
@@ -452,7 +452,7 @@ Status FindTabletLeader(const TabletServerMap& tablet_servers,
   }
   return Status::TimedOut(Substitute("Unable to find leader of tablet $0 after $1. "
                                      "Status message: $2", tablet_id,
-                                     MonoTime::Now(MonoTime::FINE).GetDeltaSince(start).ToString(),
+                                     MonoTime::Now().GetDeltaSince(start).ToString(),
                                      s.ToString()));
 }
 
@@ -651,12 +651,12 @@ Status WaitForNumVotersInConfigOnMaster(const shared_ptr<MasterServiceProxy>& ma
                                         int num_voters,
                                         const MonoDelta& timeout) {
   Status s;
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(timeout);
   int num_voters_found = 0;
   while (true) {
     TabletLocationsPB tablet_locations;
-    MonoDelta time_remaining = deadline.GetDeltaSince(MonoTime::Now(MonoTime::FINE));
+    MonoDelta time_remaining = deadline.GetDeltaSince(MonoTime::Now());
     s = GetTabletLocations(master_proxy, tablet_id, time_remaining, &tablet_locations);
     if (s.ok()) {
       num_voters_found = 0;
@@ -665,7 +665,7 @@ Status WaitForNumVotersInConfigOnMaster(const shared_ptr<MasterServiceProxy>& ma
       }
       if (num_voters_found == num_voters) break;
     }
-    if (deadline.ComesBefore(MonoTime::Now(MonoTime::FINE))) break;
+    if (deadline.ComesBefore(MonoTime::Now())) break;
     SleepFor(MonoDelta::FromMilliseconds(10));
   }
   RETURN_NOT_OK(s);
@@ -682,12 +682,12 @@ Status WaitForNumTabletsOnTS(TServerDetails* ts,
                              const MonoDelta& timeout,
                              vector<ListTabletsResponsePB::StatusAndSchemaPB>* tablets) {
   Status s;
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(timeout);
   while (true) {
     s = ListTablets(ts, MonoDelta::FromSeconds(10), tablets);
     if (s.ok() && tablets->size() == count) break;
-    if (deadline.ComesBefore(MonoTime::Now(MonoTime::FINE))) break;
+    if (deadline.ComesBefore(MonoTime::Now())) break;
     SleepFor(MonoDelta::FromMilliseconds(10));
   }
   RETURN_NOT_OK(s);
@@ -703,7 +703,7 @@ Status WaitUntilTabletInState(TServerDetails* ts,
                               const std::string& tablet_id,
                               tablet::TabletStatePB state,
                               const MonoDelta& timeout) {
-  MonoTime start = MonoTime::Now(MonoTime::FINE);
+  MonoTime start = MonoTime::Now();
   MonoTime deadline = start;
   deadline.AddDelta(timeout);
   vector<ListTabletsResponsePB::StatusAndSchemaPB> tablets;
@@ -726,7 +726,7 @@ Status WaitUntilTabletInState(TServerDetails* ts,
         s = Status::NotFound("Tablet " + tablet_id + " not found");
       }
     }
-    if (deadline.ComesBefore(MonoTime::Now(MonoTime::FINE))) {
+    if (deadline.ComesBefore(MonoTime::Now())) {
       break;
     }
     SleepFor(MonoDelta::FromMilliseconds(10));
@@ -735,7 +735,7 @@ Status WaitUntilTabletInState(TServerDetails* ts,
                                      "Tablet state: $4, Status message: $5",
                                      tablet_id, ts->uuid(),
                                      tablet::TabletStatePB_Name(state),
-                                     MonoTime::Now(MonoTime::FINE).GetDeltaSince(start).ToString(),
+                                     MonoTime::Now().GetDeltaSince(start).ToString(),
                                      tablet::TabletStatePB_Name(last_state), s.ToString()));
 }
 

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/integration-tests/cluster_verifier.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/cluster_verifier.cc b/src/kudu/integration-tests/cluster_verifier.cc
index f156073..8c84807 100644
--- a/src/kudu/integration-tests/cluster_verifier.cc
+++ b/src/kudu/integration-tests/cluster_verifier.cc
@@ -58,12 +58,12 @@ void ClusterVerifier::SetScanConcurrency(int concurrency) {
 }
 
 void ClusterVerifier::CheckCluster() {
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(checksum_options_.timeout);
 
   Status s;
   double sleep_time = 0.1;
-  while (MonoTime::Now(MonoTime::FINE).ComesBefore(deadline)) {
+  while (MonoTime::Now().ComesBefore(deadline)) {
     s = DoKsck();
     if (s.ok()) {
       break;
@@ -139,12 +139,12 @@ void ClusterVerifier::CheckRowCountWithRetries(const std::string& table_name,
                                                ComparisonMode mode,
                                                int expected_row_count,
                                                const MonoDelta& timeout) {
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(timeout);
   Status s;
   while (true) {
     s = DoCheckRowCount(table_name, mode, expected_row_count);
-    if (s.ok() || deadline.ComesBefore(MonoTime::Now(MonoTime::FINE))) break;
+    if (s.ok() || deadline.ComesBefore(MonoTime::Now())) break;
     LOG(WARNING) << "CheckRowCount() has not succeeded yet: " << s.ToString()
                  << "... will retry";
     SleepFor(MonoDelta::FromMilliseconds(100));

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/integration-tests/create-table-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/create-table-itest.cc b/src/kudu/integration-tests/create-table-itest.cc
index 2164a18..8ffa535 100644
--- a/src/kudu/integration-tests/create-table-itest.cc
+++ b/src/kudu/integration-tests/create-table-itest.cc
@@ -283,9 +283,9 @@ TEST_F(CreateTableITest, TestCreateTableWithDeadTServers) {
   }
 
   // Give the lookup threads some time to crash the master.
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(MonoDelta::FromSeconds(15));
-  while (MonoTime::Now(MonoTime::FINE).ComesBefore(deadline)) {
+  while (MonoTime::Now().ComesBefore(deadline)) {
     ASSERT_TRUE(cluster_->master()->IsProcessAlive()) << "Master crashed!";
     SleepFor(MonoDelta::FromMilliseconds(100));
   }

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/integration-tests/delete_table-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/delete_table-test.cc b/src/kudu/integration-tests/delete_table-test.cc
index e23647a..e09c11d 100644
--- a/src/kudu/integration-tests/delete_table-test.cc
+++ b/src/kudu/integration-tests/delete_table-test.cc
@@ -222,14 +222,14 @@ void DeleteTableTest::DeleteTabletWithRetries(const TServerDetails* ts,
                                               const string& tablet_id,
                                               TabletDataState delete_type,
                                               const MonoDelta& timeout) {
-  MonoTime start(MonoTime::Now(MonoTime::FINE));
+  MonoTime start(MonoTime::Now());
   MonoTime deadline = start;
   deadline.AddDelta(timeout);
   Status s;
   while (true) {
     s = itest::DeleteTablet(ts, tablet_id, delete_type, boost::none, timeout);
     if (s.ok()) return;
-    if (deadline.ComesBefore(MonoTime::Now(MonoTime::FINE))) {
+    if (deadline.ComesBefore(MonoTime::Now())) {
       break;
     }
     SleepFor(MonoDelta::FromMilliseconds(10));

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/integration-tests/external_mini_cluster.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/external_mini_cluster.cc b/src/kudu/integration-tests/external_mini_cluster.cc
index 1b85fb8..0d3f7c6 100644
--- a/src/kudu/integration-tests/external_mini_cluster.cc
+++ b/src/kudu/integration-tests/external_mini_cluster.cc
@@ -289,7 +289,7 @@ Status ExternalMiniCluster::AddTabletServer() {
 }
 
 Status ExternalMiniCluster::WaitForTabletServerCount(int count, const MonoDelta& timeout) {
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(timeout);
 
   unordered_set<int> masters_to_search;
@@ -300,7 +300,7 @@ Status ExternalMiniCluster::WaitForTabletServerCount(int count, const MonoDelta&
   }
 
   while (true) {
-    MonoDelta remaining = deadline.GetDeltaSince(MonoTime::Now(MonoTime::FINE));
+    MonoDelta remaining = deadline.GetDeltaSince(MonoTime::Now());
     if (remaining.ToSeconds() < 0) {
       return Status::TimedOut(Substitute(
           "Timed out waiting for $0 TS(s) to register with all masters", count));
@@ -363,9 +363,9 @@ Status ExternalMiniCluster::WaitForTabletsRunning(ExternalTabletServer* ts,
   ListTabletsRequestPB req;
   ListTabletsResponsePB resp;
 
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(timeout);
-  while (MonoTime::Now(MonoTime::FINE).ComesBefore(deadline)) {
+  while (MonoTime::Now().ComesBefore(deadline)) {
     rpc::RpcController rpc;
     rpc.set_timeout(MonoDelta::FromSeconds(10));
     RETURN_NOT_OK(proxy.ListTablets(req, &resp, &rpc));
@@ -410,7 +410,7 @@ Status ExternalMiniCluster::GetLeaderMasterIndex(int* idx) {
   Synchronizer sync;
   vector<Sockaddr> addrs;
   HostPort leader_master_hp;
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(MonoDelta::FromSeconds(5));
 
   for (const scoped_refptr<ExternalMaster>& master : masters_) {
@@ -645,11 +645,11 @@ bool ExternalDaemon::IsProcessAlive() const {
 }
 
 Status ExternalDaemon::WaitForCrash(const MonoDelta& timeout) const {
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(timeout);
 
   int i = 1;
-  while (MonoTime::Now(MonoTime::FINE).ComesBefore(deadline)) {
+  while (MonoTime::Now().ComesBefore(deadline)) {
     if (!IsProcessAlive()) return Status::OK();
     int sleep_ms = std::min(i++ * 10, 200);
     SleepFor(MonoDelta::FromMilliseconds(sleep_ms));

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/integration-tests/external_mini_cluster_fs_inspector.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/external_mini_cluster_fs_inspector.cc b/src/kudu/integration-tests/external_mini_cluster_fs_inspector.cc
index c255463..7b294c4 100644
--- a/src/kudu/integration-tests/external_mini_cluster_fs_inspector.cc
+++ b/src/kudu/integration-tests/external_mini_cluster_fs_inspector.cc
@@ -223,13 +223,13 @@ Status ExternalMiniClusterFsInspector::CheckTabletDataStateOnTS(
 }
 
 Status ExternalMiniClusterFsInspector::WaitForNoData(const MonoDelta& timeout) {
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(timeout);
   Status s;
   while (true) {
     s = CheckNoData();
     if (s.ok()) return Status::OK();
-    if (deadline.ComesBefore(MonoTime::Now(MonoTime::FINE))) {
+    if (deadline.ComesBefore(MonoTime::Now())) {
       break;
     }
     SleepFor(MonoDelta::FromMilliseconds(10));
@@ -238,13 +238,13 @@ Status ExternalMiniClusterFsInspector::WaitForNoData(const MonoDelta& timeout) {
 }
 
 Status ExternalMiniClusterFsInspector::WaitForNoDataOnTS(int index, const MonoDelta& timeout) {
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(timeout);
   Status s;
   while (true) {
     s = CheckNoDataOnTS(index);
     if (s.ok()) return Status::OK();
-    if (deadline.ComesBefore(MonoTime::Now(MonoTime::FINE))) {
+    if (deadline.ComesBefore(MonoTime::Now())) {
       break;
     }
     SleepFor(MonoDelta::FromMilliseconds(10));
@@ -257,12 +257,12 @@ Status ExternalMiniClusterFsInspector::WaitForMinFilesInTabletWalDirOnTS(int ind
                                                                          int count,
                                                                          const MonoDelta& timeout) {
   int seen = 0;
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(timeout);
   while (true) {
     seen = CountWALSegmentsForTabletOnTS(index, tablet_id);
     if (seen >= count) return Status::OK();
-    if (deadline.ComesBefore(MonoTime::Now(MonoTime::FINE))) {
+    if (deadline.ComesBefore(MonoTime::Now())) {
       break;
     }
     SleepFor(MonoDelta::FromMilliseconds(10));
@@ -274,14 +274,14 @@ Status ExternalMiniClusterFsInspector::WaitForMinFilesInTabletWalDirOnTS(int ind
 
 Status ExternalMiniClusterFsInspector::WaitForReplicaCount(int expected, const MonoDelta& timeout) {
   Status s;
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(timeout);
   int found;
   while (true) {
     found = CountReplicasInMetadataDirs();
     if (found == expected) return Status::OK();
     if (CountReplicasInMetadataDirs() == expected) return Status::OK();
-    if (deadline.ComesBefore(MonoTime::Now(MonoTime::FINE))) {
+    if (deadline.ComesBefore(MonoTime::Now())) {
       break;
     }
     SleepFor(MonoDelta::FromMilliseconds(10));
@@ -296,18 +296,18 @@ Status ExternalMiniClusterFsInspector::WaitForTabletDataStateOnTS(
     const string& tablet_id,
     const vector<TabletDataState>& expected_states,
     const MonoDelta& timeout) {
-  MonoTime start = MonoTime::Now(MonoTime::FINE);
+  MonoTime start = MonoTime::Now();
   MonoTime deadline = start;
   deadline.AddDelta(timeout);
   Status s;
   while (true) {
     s = CheckTabletDataStateOnTS(index, tablet_id, expected_states);
     if (s.ok()) return Status::OK();
-    if (deadline.ComesBefore(MonoTime::Now(MonoTime::FINE))) break;
+    if (deadline.ComesBefore(MonoTime::Now())) break;
     SleepFor(MonoDelta::FromMilliseconds(5));
   }
   return Status::TimedOut(Substitute("Timed out after $0 waiting for correct tablet state: $1",
-                                     MonoTime::Now(MonoTime::FINE).GetDeltaSince(start).ToString(),
+                                     MonoTime::Now().GetDeltaSince(start).ToString(),
                                      s.ToString()));
 }
 
@@ -317,7 +317,7 @@ Status ExternalMiniClusterFsInspector::WaitForFilePatternInTabletWalDirOnTs(
     const vector<string>& substrings_disallowed,
     const MonoDelta& timeout) {
   Status s;
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(timeout);
 
   string data_dir = cluster_->tablet_server(ts_index)->data_dir();
@@ -363,7 +363,7 @@ Status ExternalMiniClusterFsInspector::WaitForFilePatternInTabletWalDirOnTs(
     if (!any_missing_required && !any_present_disallowed) {
       return Status::OK();
     }
-    if (deadline.ComesBefore(MonoTime::Now(MonoTime::FINE))) {
+    if (deadline.ComesBefore(MonoTime::Now())) {
       break;
     }
     SleepFor(MonoDelta::FromMilliseconds(10));

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/integration-tests/linked_list-test-util.h
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/linked_list-test-util.h b/src/kudu/integration-tests/linked_list-test-util.h
index 72349f2..8b149b9 100644
--- a/src/kudu/integration-tests/linked_list-test-util.h
+++ b/src/kudu/integration-tests/linked_list-test-util.h
@@ -337,13 +337,13 @@ class PeriodicWebUIChecker {
     for (int count = 0; is_running_.Load(); count++) {
       const std::string &url = urls_[count % urls_.size()];
       LOG(INFO) << "Curling URL " << url;
-      const MonoTime start = MonoTime::Now(MonoTime::FINE);
+      const MonoTime start = MonoTime::Now();
       Status status = curl.FetchURL(url, &dst);
       if (status.ok()) {
         CHECK_GT(dst.length(), 0);
       }
       // Sleep until the next period
-      const MonoTime end = MonoTime::Now(MonoTime::FINE);
+      const MonoTime end = MonoTime::Now();
       const MonoDelta elapsed = end.GetDeltaSince(start);
       const int64_t sleep_ns = period_.ToNanoseconds() - elapsed.ToNanoseconds();
       if (sleep_ns > 0) {
@@ -445,7 +445,7 @@ Status LinkedListTester::LoadLinkedList(
   scoped_refptr<server::Clock> ht_clock(new server::HybridClock());
   RETURN_NOT_OK(ht_clock->Init());
 
-  MonoTime start = MonoTime::Now(MonoTime::COARSE);
+  MonoTime start = MonoTime::Now();
   MonoTime deadline = start;
   deadline.AddDelta(run_for);
 
@@ -475,7 +475,7 @@ Status LinkedListTester::LoadLinkedList(
       DumpInsertHistogram(false);
     }
 
-    MonoTime now = MonoTime::Now(MonoTime::COARSE);
+    MonoTime now = MonoTime::Now();
     if (next_sample.ComesBefore(now)) {
       Timestamp now = ht_clock->Now();
       sampled_timestamps_and_counts_.push_back(
@@ -497,9 +497,9 @@ Status LinkedListTester::LoadLinkedList(
                             "Unable to generate next insert into linked list chain");
     }
 
-    MonoTime flush_start(MonoTime::Now(MonoTime::FINE));
+    MonoTime flush_start(MonoTime::Now());
     FlushSessionOrDie(session);
-    MonoDelta elapsed = MonoTime::Now(MonoTime::FINE).GetDeltaSince(flush_start);
+    MonoDelta elapsed = MonoTime::Now().GetDeltaSince(flush_start);
     latency_histogram_.Increment(elapsed.ToMicroseconds());
 
     (*written_count) += chains.size();

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/integration-tests/master-stress-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/master-stress-test.cc b/src/kudu/integration-tests/master-stress-test.cc
index b77d2eb..0a6a579 100644
--- a/src/kudu/integration-tests/master-stress-test.cc
+++ b/src/kudu/integration-tests/master-stress-test.cc
@@ -285,10 +285,10 @@ class MasterStressTest : public KuduTest {
     MessengerBuilder bld("RestartMasterMessenger");
     CHECK_OK(bld.Build(&messenger));
 
-    MonoTime deadline(MonoTime::Now(MonoTime::FINE));
+    MonoTime deadline(MonoTime::Now());
     deadline.AddDelta(MonoDelta::FromSeconds(FLAGS_num_seconds_to_run));
 
-    MonoTime now(MonoTime::Now(MonoTime::FINE));
+    MonoTime now(MonoTime::Now());
     while (now.ComesBefore(deadline)) {
       ExternalMaster* master = cluster_->master(
           rand_.Uniform(cluster_->num_masters()));
@@ -309,7 +309,7 @@ class MasterStressTest : public KuduTest {
       num_masters_restarted_.Increment();
 
       SleepFor(MonoDelta::FromMilliseconds(rand_.Uniform(200)));
-      now = MonoTime::Now(MonoTime::FINE);
+      now = MonoTime::Now();
     }
   }
 

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/integration-tests/master_failover-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/master_failover-itest.cc b/src/kudu/integration-tests/master_failover-itest.cc
index 5e9219b..1a9b1b0 100644
--- a/src/kudu/integration-tests/master_failover-itest.cc
+++ b/src/kudu/integration-tests/master_failover-itest.cc
@@ -197,7 +197,7 @@ TEST_F(MasterFailoverTest, TestPauseAfterCreateTableIssued) {
   cluster_->master(leader_idx)->Pause();
   ScopedResumeExternalDaemon resume_daemon(cluster_->master(leader_idx));
 
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(MonoDelta::FromSeconds(90));
   ASSERT_OK(client_->data_->WaitForCreateTableToFinish(client_.get(),
                                                        kTableName, deadline));
@@ -305,9 +305,9 @@ TEST_F(MasterFailoverTest, TestKUDU1374) {
   // 5. Leader master sees that all tablets in the table now have the new
   //    schema and ends the AlterTable() operation.
   // 6. The next IsAlterTableInProgress() call returns false.
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(MonoDelta::FromSeconds(90));
-  MonoTime now = MonoTime::Now(MonoTime::FINE);
+  MonoTime now = MonoTime::Now();
   while (now.ComesBefore(deadline)) {
     bool in_progress;
     ASSERT_OK(client_->IsAlterTableInProgress(kTableName, &in_progress));
@@ -316,7 +316,7 @@ TEST_F(MasterFailoverTest, TestKUDU1374) {
     }
 
     SleepFor(MonoDelta::FromMilliseconds(100));
-    now = MonoTime::Now(MonoTime::FINE);
+    now = MonoTime::Now();
   }
   ASSERT_TRUE(now.ComesBefore(deadline))
     << "Deadline elapsed before alter table completed";

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/integration-tests/raft_consensus-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/raft_consensus-itest.cc b/src/kudu/integration-tests/raft_consensus-itest.cc
index 4a1d5f7..7aff6da 100644
--- a/src/kudu/integration-tests/raft_consensus-itest.cc
+++ b/src/kudu/integration-tests/raft_consensus-itest.cc
@@ -147,8 +147,8 @@ class RaftConsensusITest : public TabletServerIntegrationTestBase {
                        int expected_count,
                        vector<string>* results) {
     LOG(INFO) << "Waiting for row count " << expected_count << "...";
-    MonoTime start = MonoTime::Now(MonoTime::FINE);
-    MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+    MonoTime start = MonoTime::Now();
+    MonoTime deadline = MonoTime::Now();
     deadline.AddDelta(MonoDelta::FromSeconds(90));
     while (true) {
       results->clear();
@@ -157,11 +157,11 @@ class RaftConsensusITest : public TabletServerIntegrationTestBase {
         return;
       }
       SleepFor(MonoDelta::FromMilliseconds(10));
-      if (!MonoTime::Now(MonoTime::FINE).ComesBefore(deadline)) {
+      if (!MonoTime::Now().ComesBefore(deadline)) {
         break;
       }
     }
-    MonoTime end = MonoTime::Now(MonoTime::FINE);
+    MonoTime end = MonoTime::Now();
     LOG(WARNING) << "Didn't reach row count " << expected_count;
     FAIL() << "Did not reach expected row count " << expected_count
            << " after " << end.GetDeltaSince(start).ToString()
@@ -1480,7 +1480,7 @@ void RaftConsensusITest::WaitForReplicasReportedToMaster(
     WaitForLeader wait_for_leader,
     bool* has_leader,
     master::TabletLocationsPB* tablet_locations) {
-  MonoTime deadline(MonoTime::Now(MonoTime::FINE));
+  MonoTime deadline(MonoTime::Now());
   deadline.AddDelta(timeout);
   while (true) {
     ASSERT_OK(GetTabletLocations(tablet_id, timeout, tablet_locations));
@@ -1497,7 +1497,7 @@ void RaftConsensusITest::WaitForReplicasReportedToMaster(
         break;
       }
     }
-    if (deadline.ComesBefore(MonoTime::Now(MonoTime::FINE))) break;
+    if (deadline.ComesBefore(MonoTime::Now())) break;
     SleepFor(MonoDelta::FromMilliseconds(20));
   }
   ASSERT_EQ(num_replicas, tablet_locations->replicas_size()) << tablet_locations->DebugString();
@@ -2219,7 +2219,7 @@ TEST_F(RaftConsensusITest, TestMemoryRemainsConstantDespiteTwoDeadFollowers) {
   workload.Start();
 
   // Run until the leader has rejected several transactions.
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(kMaxWaitTime);
   while (true) {
     int64_t num_rejections = 0;
@@ -2231,7 +2231,7 @@ TEST_F(RaftConsensusITest, TestMemoryRemainsConstantDespiteTwoDeadFollowers) {
         &num_rejections));
     if (num_rejections >= kMinRejections) {
       break;
-    } else if (deadline.ComesBefore(MonoTime::Now(MonoTime::FINE))) {
+    } else if (deadline.ComesBefore(MonoTime::Now())) {
       FAIL() << "Ran for " << kMaxWaitTime.ToString() << ", deadline expired";
     }
     SleepFor(MonoDelta::FromMilliseconds(200));

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/integration-tests/tablet_copy-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/tablet_copy-itest.cc b/src/kudu/integration-tests/tablet_copy-itest.cc
index 3106818..9938a3e 100644
--- a/src/kudu/integration-tests/tablet_copy-itest.cc
+++ b/src/kudu/integration-tests/tablet_copy-itest.cc
@@ -215,9 +215,9 @@ TEST_F(TabletCopyITest, TestRejectRogueLeader) {
   ASSERT_OK(cluster_->tablet_server(zombie_leader_index)->Resume());
 
   // Loop for a few seconds to ensure that the tablet doesn't transition to READY.
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(MonoDelta::FromSeconds(5));
-  while (MonoTime::Now(MonoTime::FINE).ComesBefore(deadline)) {
+  while (MonoTime::Now().ComesBefore(deadline)) {
     ASSERT_OK(itest::ListTablets(ts, timeout, &tablets));
     ASSERT_EQ(1, tablets.size());
     ASSERT_EQ(TABLET_DATA_TOMBSTONED, tablets[0].tablet_status().tablet_data_state());
@@ -241,9 +241,9 @@ TEST_F(TabletCopyITest, TestRejectRogueLeader) {
                                             timeout));
 
   // Wait another few seconds to be sure the tablet copy is rejected.
-  deadline = MonoTime::Now(MonoTime::FINE);
+  deadline = MonoTime::Now();
   deadline.AddDelta(MonoDelta::FromSeconds(5));
-  while (MonoTime::Now(MonoTime::FINE).ComesBefore(deadline)) {
+  while (MonoTime::Now().ComesBefore(deadline)) {
     ASSERT_OK(itest::ListTablets(ts, timeout, &tablets));
     ASSERT_EQ(1, tablets.size());
     ASSERT_EQ(TABLET_DATA_TOMBSTONED, tablets[0].tablet_status().tablet_data_state());

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/integration-tests/test_workload.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/test_workload.cc b/src/kudu/integration-tests/test_workload.cc
index e3e83ad..4cd9528 100644
--- a/src/kudu/integration-tests/test_workload.cc
+++ b/src/kudu/integration-tests/test_workload.cc
@@ -173,12 +173,12 @@ void TestWorkload::Setup() {
 
   // Retry KuduClient::TableExists() until we make that call retry reliably.
   // See KUDU-1074.
-  MonoTime deadline(MonoTime::Now(MonoTime::FINE));
+  MonoTime deadline(MonoTime::Now());
   deadline.AddDelta(MonoDelta::FromSeconds(10));
   Status s;
   while (true) {
     s = client_->TableExists(table_name_, &table_exists);
-    if (s.ok() || deadline.ComesBefore(MonoTime::Now(MonoTime::FINE))) break;
+    if (s.ok() || deadline.ComesBefore(MonoTime::Now())) break;
     SleepFor(MonoDelta::FromMilliseconds(10));
   }
   CHECK_OK(s);

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/integration-tests/write_throttling-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/write_throttling-itest.cc b/src/kudu/integration-tests/write_throttling-itest.cc
index 48c57ba..29e0fdf 100644
--- a/src/kudu/integration-tests/write_throttling-itest.cc
+++ b/src/kudu/integration-tests/write_throttling-itest.cc
@@ -84,7 +84,7 @@ TEST_F(WriteThrottlingTest, ThrottleWriteRpcPerSec) {
   session->SetTimeoutMillis(5000);
   ASSERT_OK(session->SetFlushMode(KuduSession::AUTO_FLUSH_SYNC));
   for (int t = 0; t < FLAGS_throttling_test_time; t++) {
-    MonoTime begin = MonoTime::Now(MonoTime::FINE);
+    MonoTime begin = MonoTime::Now();
     for (int i = 0; i < TARGET_QPS; i++) {
       gscoped_ptr<KuduInsert> insert(table_->NewInsert());
       KuduPartialRow* row = insert->mutable_row();
@@ -92,7 +92,7 @@ TEST_F(WriteThrottlingTest, ThrottleWriteRpcPerSec) {
       CHECK_OK(row->SetStringNoCopy("string_val", string_val));
       CHECK_OK(session->Apply(insert.release()));
     }
-    MonoTime end = MonoTime::Now(MonoTime::FINE);
+    MonoTime end = MonoTime::Now();
     MonoDelta delta = end.GetDeltaSince(begin);
     double qps = TARGET_QPS / delta.ToSeconds();
     LOG(INFO) << "Iteration " << t << " qps: " << qps;
@@ -116,7 +116,7 @@ TEST_F(WriteThrottlingTest, ThrottleWriteBytesPerSec) {
   session->SetTimeoutMillis(5000);
   ASSERT_OK(session->SetFlushMode(KuduSession::AUTO_FLUSH_SYNC));
   for (int t = 0; t < FLAGS_throttling_test_time; t++) {
-    MonoTime begin = MonoTime::Now(MonoTime::FINE);
+    MonoTime begin = MonoTime::Now();
     for (int i = 0; i < TARGET_QPS; i++) {
       gscoped_ptr<KuduInsert> insert(table_->NewInsert());
       KuduPartialRow* row = insert->mutable_row();
@@ -124,7 +124,7 @@ TEST_F(WriteThrottlingTest, ThrottleWriteBytesPerSec) {
       CHECK_OK(row->SetStringNoCopy("string_val", string_val));
       CHECK_OK(session->Apply(insert.release()));
     }
-    MonoTime end = MonoTime::Now(MonoTime::FINE);
+    MonoTime end = MonoTime::Now();
     MonoDelta delta = end.GetDeltaSince(begin);
     double qps = TARGET_QPS / delta.ToSeconds();
     double bps = TARGET_QPS * BYTES_PER_RPC / delta.ToSeconds();

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/master/catalog_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/catalog_manager.cc b/src/kudu/master/catalog_manager.cc
index 49001f8..fbea196 100644
--- a/src/kudu/master/catalog_manager.cc
+++ b/src/kudu/master/catalog_manager.cc
@@ -2172,7 +2172,7 @@ class RetryingTSRpcTask : public MonitoredTask {
     : master_(master),
       replica_picker_(std::move(replica_picker)),
       table_(table),
-      start_ts_(MonoTime::Now(MonoTime::FINE)),
+      start_ts_(MonoTime::Now()),
       attempt_(0),
       state_(kStateRunning) {
     deadline_ = start_ts_;
@@ -2196,7 +2196,7 @@ class RetryingTSRpcTask : public MonitoredTask {
     }
 
     // Calculate and set the timeout deadline.
-    MonoTime timeout = MonoTime::Now(MonoTime::FINE);
+    MonoTime timeout = MonoTime::Now();
     timeout.AddDelta(MonoDelta::FromMilliseconds(FLAGS_master_ts_rpc_timeout_ms));
     const MonoTime& deadline = MonoTime::Earliest(timeout, deadline_);
     rpc_.set_deadline(deadline);
@@ -2299,7 +2299,7 @@ class RetryingTSRpcTask : public MonitoredTask {
   // Returns true if rescheduling the task was successful.
   bool RescheduleWithBackoffDelay() {
     if (state() != kStateRunning) return false;
-    MonoTime now = MonoTime::Now(MonoTime::FINE);
+    MonoTime now = MonoTime::Now();
     // We assume it might take 10ms to process the request in the best case,
     // fail if we have less than that amount of time remaining.
     int64_t millis_remaining = deadline_.GetDeltaSince(now).ToMilliseconds() - 10;
@@ -2349,7 +2349,7 @@ class RetryingTSRpcTask : public MonitoredTask {
 
   // Clean up request and release resources. May call 'delete this'.
   void UnregisterAsyncTask() {
-    end_ts_ = MonoTime::Now(MonoTime::FINE);
+    end_ts_ = MonoTime::Now();
     if (table_ != nullptr) {
       table_->RemoveTask(this);
     } else {
@@ -2924,7 +2924,7 @@ void CatalogManager::HandleAssignCreatingTablet(TabletInfo* tablet,
                                                 DeferredAssignmentActions* deferred,
                                                 vector<scoped_refptr<TabletInfo> >* new_tablets) {
   MonoDelta time_since_updated =
-      MonoTime::Now(MonoTime::FINE).GetDeltaSince(tablet->last_create_tablet_time());
+      MonoTime::Now().GetDeltaSince(tablet->last_create_tablet_time());
   int64_t remaining_timeout_ms =
       FLAGS_tablet_creation_timeout_ms - time_since_updated.ToMilliseconds();
 
@@ -3150,7 +3150,7 @@ void CatalogManager::SendCreateTabletRequest(const scoped_refptr<TabletInfo>& ta
                                              const TabletMetadataLock& tablet_lock) {
   const consensus::RaftConfigPB& config =
       tablet_lock.data().pb.committed_consensus_state().config();
-  tablet->set_last_create_tablet_time(MonoTime::Now(MonoTime::FINE));
+  tablet->set_last_create_tablet_time(MonoTime::Now());
   for (const RaftPeerPB& peer : config.peers()) {
     AsyncCreateReplica* task = new AsyncCreateReplica(master_,
                                                       peer.permanent_uuid(),
@@ -3568,7 +3568,7 @@ TabletInfo::TabletInfo(const scoped_refptr<TableInfo>& table,
                        std::string tablet_id)
     : tablet_id_(std::move(tablet_id)),
       table_(table),
-      last_create_tablet_time_(MonoTime::Now(MonoTime::FINE)),
+      last_create_tablet_time_(MonoTime::Now()),
       reported_schema_version_(0) {}
 
 TabletInfo::~TabletInfo() {

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/master/master-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/master-test.cc b/src/kudu/master/master-test.cc
index 8775af1..1579214 100644
--- a/src/kudu/master/master-test.cc
+++ b/src/kudu/master/master-test.cc
@@ -919,9 +919,9 @@ TEST_F(MasterTest, TestMasterMetadataConsistentDespiteFailures) {
 
   // Spend some time hammering the master with create/alter/delete operations.
   MonoDelta time_to_run = MonoDelta::FromSeconds(AllowSlowTests() ? 10 : 1);
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(time_to_run);
-  while (MonoTime::Now(MonoTime::FINE).ComesBefore(deadline)) {
+  while (MonoTime::Now().ComesBefore(deadline)) {
     int next_action = r.Uniform(3);
     switch (next_action) {
       case 0:

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/master/master.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/master.cc b/src/kudu/master/master.cc
index 0910280..c8a4ab8 100644
--- a/src/kudu/master/master.cc
+++ b/src/kudu/master/master.cc
@@ -155,7 +155,7 @@ Status Master::WaitForCatalogManagerInit() {
 
 Status Master::WaitUntilCatalogManagerIsLeaderAndReadyForTests(const MonoDelta& timeout) {
   Status s;
-  MonoTime start = MonoTime::Now(MonoTime::FINE);
+  MonoTime start = MonoTime::Now();
   int backoff_ms = 1;
   const int kMaxBackoffMs = 256;
   do {
@@ -167,7 +167,7 @@ Status Master::WaitUntilCatalogManagerIsLeaderAndReadyForTests(const MonoDelta&
     }
     SleepFor(MonoDelta::FromMilliseconds(backoff_ms));
     backoff_ms = min(backoff_ms << 1, kMaxBackoffMs);
-  } while (MonoTime::Now(MonoTime::FINE).GetDeltaSince(start).LessThan(timeout));
+  } while (MonoTime::Now().GetDeltaSince(start).LessThan(timeout));
   return Status::TimedOut("Maximum time exceeded waiting for master leadership",
                           s.ToString());
 }

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/master/master_rpc.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/master_rpc.cc b/src/kudu/master/master_rpc.cc
index d14d6ea..e2aa5ec 100644
--- a/src/kudu/master/master_rpc.cc
+++ b/src/kudu/master/master_rpc.cc
@@ -137,7 +137,7 @@ string GetLeaderMasterRpc::ToString() const {
 
 void GetLeaderMasterRpc::SendRpc() {
   // Compute the actual deadline to use for each RPC.
-  MonoTime rpc_deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime rpc_deadline = MonoTime::Now();
   rpc_deadline.AddDelta(rpc_timeout_);
   MonoTime actual_deadline = MonoTime::Earliest(retrier().deadline(),
                                                 rpc_deadline);
@@ -179,7 +179,7 @@ void GetLeaderMasterRpc::SendRpcCb(const Status& status) {
 
   // If our replies timed out but the deadline hasn't passed, retry.
   if (status.IsTimedOut() &&
-      MonoTime::Now(MonoTime::FINE).ComesBefore(retrier().deadline())) {
+      MonoTime::Now().ComesBefore(retrier().deadline())) {
     mutable_retrier()->DelayedRetry(this, status);
     return;
   }

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/master/ts_descriptor.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/ts_descriptor.cc b/src/kudu/master/ts_descriptor.cc
index 003faeb..eeb83dc 100644
--- a/src/kudu/master/ts_descriptor.cc
+++ b/src/kudu/master/ts_descriptor.cc
@@ -46,9 +46,9 @@ Status TSDescriptor::RegisterNew(const NodeInstancePB& instance,
 TSDescriptor::TSDescriptor(std::string perm_id)
     : permanent_uuid_(std::move(perm_id)),
       latest_seqno_(-1),
-      last_heartbeat_(MonoTime::Now(MonoTime::FINE)),
+      last_heartbeat_(MonoTime::Now()),
       recent_replica_creations_(0),
-      last_replica_creations_decay_(MonoTime::Now(MonoTime::FINE)),
+      last_replica_creations_decay_(MonoTime::Now()),
       num_live_replicas_(0) {
 }
 
@@ -96,11 +96,11 @@ Status TSDescriptor::Register(const NodeInstancePB& instance,
 
 void TSDescriptor::UpdateHeartbeatTime() {
   std::lock_guard<simple_spinlock> l(lock_);
-  last_heartbeat_ = MonoTime::Now(MonoTime::FINE);
+  last_heartbeat_ = MonoTime::Now();
 }
 
 MonoDelta TSDescriptor::TimeSinceHeartbeat() const {
-  MonoTime now(MonoTime::Now(MonoTime::FINE));
+  MonoTime now(MonoTime::Now());
   std::lock_guard<simple_spinlock> l(lock_);
   return now.GetDeltaSince(last_heartbeat_);
 }
@@ -116,7 +116,7 @@ void TSDescriptor::DecayRecentReplicaCreationsUnlocked() {
   if (recent_replica_creations_ == 0) return;
 
   const double kHalflifeSecs = 60;
-  MonoTime now = MonoTime::Now(MonoTime::FINE);
+  MonoTime now = MonoTime::Now();
   double secs_since_last_decay = now.GetDeltaSince(last_replica_creations_decay_).ToSeconds();
   recent_replica_creations_ *= pow(0.5, secs_since_last_decay / kHalflifeSecs);
 

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/rpc/connection.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/connection.cc b/src/kudu/rpc/connection.cc
index e03ebf3..19b6bd8 100644
--- a/src/kudu/rpc/connection.cc
+++ b/src/kudu/rpc/connection.cc
@@ -64,7 +64,7 @@ Connection::Connection(ReactorThread *reactor_thread, Sockaddr remote,
       socket_(socket),
       remote_(std::move(remote)),
       direction_(direction),
-      last_activity_time_(MonoTime::Now(MonoTime::FINE)),
+      last_activity_time_(MonoTime::Now()),
       is_epoll_registered_(false),
       next_call_id_(1),
       sasl_client_(kSaslAppName, socket),

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/rpc/inbound_call.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/inbound_call.cc b/src/kudu/rpc/inbound_call.cc
index 8511402..edadf35 100644
--- a/src/kudu/rpc/inbound_call.cc
+++ b/src/kudu/rpc/inbound_call.cc
@@ -209,7 +209,7 @@ void InboundCall::DumpPB(const DumpRunningRpcsRequestPB& req,
   if (req.include_traces() && trace_) {
     resp->set_trace_buffer(trace_->DumpToString());
   }
-  resp->set_micros_elapsed(MonoTime::Now(MonoTime::FINE).GetDeltaSince(timing_.time_received)
+  resp->set_micros_elapsed(MonoTime::Now().GetDeltaSince(timing_.time_received)
                            .ToMicroseconds());
 }
 
@@ -232,20 +232,20 @@ Trace* InboundCall::trace() {
 void InboundCall::RecordCallReceived() {
   TRACE_EVENT_ASYNC_BEGIN0("rpc", "InboundCall", this);
   DCHECK(!timing_.time_received.Initialized());  // Protect against multiple calls.
-  timing_.time_received = MonoTime::Now(MonoTime::FINE);
+  timing_.time_received = MonoTime::Now();
 }
 
 void InboundCall::RecordHandlingStarted(scoped_refptr<Histogram> incoming_queue_time) {
   DCHECK(incoming_queue_time != nullptr);
   DCHECK(!timing_.time_handled.Initialized());  // Protect against multiple calls.
-  timing_.time_handled = MonoTime::Now(MonoTime::FINE);
+  timing_.time_handled = MonoTime::Now();
   incoming_queue_time->Increment(
       timing_.time_handled.GetDeltaSince(timing_.time_received).ToMicroseconds());
 }
 
 void InboundCall::RecordHandlingCompleted() {
   DCHECK(!timing_.time_completed.Initialized());  // Protect against multiple calls.
-  timing_.time_completed = MonoTime::Now(MonoTime::FINE);
+  timing_.time_completed = MonoTime::Now();
 
   if (!timing_.time_handled.Initialized()) {
     // Sometimes we respond to a call before we begin handling it (e.g. due to queue
@@ -264,7 +264,7 @@ bool InboundCall::ClientTimedOut() const {
     return false;
   }
 
-  MonoTime now = MonoTime::Now(MonoTime::FINE);
+  MonoTime now = MonoTime::Now();
   int total_time = now.GetDeltaSince(timing_.time_received).ToMilliseconds();
   return total_time > header_.timeout_millis();
 }

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/rpc/negotiation.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/negotiation.cc b/src/kudu/rpc/negotiation.cc
index 7854609..da07492 100644
--- a/src/kudu/rpc/negotiation.cc
+++ b/src/kudu/rpc/negotiation.cc
@@ -127,7 +127,7 @@ static Status WaitForClientConnect(Connection* conn, const MonoTime& deadline) {
   MonoTime now;
   MonoDelta remaining;
   while (true) {
-    now = MonoTime::Now(MonoTime::FINE);
+    now = MonoTime::Now();
     remaining = deadline.GetDeltaSince(now);
     DVLOG(4) << "Client waiting to connect for negotiation, time remaining until timeout deadline: "
              << remaining.ToString();

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/rpc/outbound_call.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/outbound_call.cc b/src/kudu/rpc/outbound_call.cc
index 0243c58..9e6457f 100644
--- a/src/kudu/rpc/outbound_call.cc
+++ b/src/kudu/rpc/outbound_call.cc
@@ -74,7 +74,7 @@ OutboundCall::OutboundCall(const ConnectionId& conn_id,
            << (controller->timeout().Initialized() ? controller->timeout().ToString() : "none");
   header_.set_call_id(kInvalidCallId);
   remote_method.ToPB(header_.mutable_remote_method());
-  start_time_ = MonoTime::Now(MonoTime::FINE);
+  start_time_ = MonoTime::Now();
 
   if (!controller_->required_server_features().empty()) {
     required_rpc_features_.insert(RpcFeatureFlag::APPLICATION_FEATURE_FLAGS);
@@ -314,7 +314,7 @@ void OutboundCall::DumpPB(const DumpRunningRpcsRequestPB& req,
   std::lock_guard<simple_spinlock> l(lock_);
   resp->mutable_header()->CopyFrom(header_);
   resp->set_micros_elapsed(
-    MonoTime::Now(MonoTime::FINE) .GetDeltaSince(start_time_).ToMicroseconds());
+    MonoTime::Now() .GetDeltaSince(start_time_).ToMicroseconds());
 }
 
 ///

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/rpc/reactor-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/reactor-test.cc b/src/kudu/rpc/reactor-test.cc
index c7af518..c32e936 100644
--- a/src/kudu/rpc/reactor-test.cc
+++ b/src/kudu/rpc/reactor-test.cc
@@ -64,12 +64,12 @@ TEST_F(ReactorTest, TestFunctionIsCalled) {
 }
 
 TEST_F(ReactorTest, TestFunctionIsCalledAtTheRightTime) {
-  MonoTime before = MonoTime::Now(MonoTime::FINE);
+  MonoTime before = MonoTime::Now();
   messenger_->ScheduleOnReactor(
       boost::bind(&ReactorTest::ScheduledTask, this, _1, Status::OK()),
       MonoDelta::FromMilliseconds(100));
   latch_.Wait();
-  MonoTime after = MonoTime::Now(MonoTime::FINE);
+  MonoTime after = MonoTime::Now();
   MonoDelta delta = after.GetDeltaSince(before);
   CHECK_GE(delta.ToMilliseconds(), 100);
 }

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/rpc/reactor.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/reactor.cc b/src/kudu/rpc/reactor.cc
index bb8ed20..76de99b 100644
--- a/src/kudu/rpc/reactor.cc
+++ b/src/kudu/rpc/reactor.cc
@@ -81,7 +81,7 @@ Status ShutdownError(bool aborted) {
 
 ReactorThread::ReactorThread(Reactor *reactor, const MessengerBuilder &bld)
   : loop_(kDefaultLibEvFlags),
-    cur_time_(MonoTime::Now(MonoTime::COARSE)),
+    cur_time_(MonoTime::Now()),
     last_unused_tcp_scan_(cur_time_),
     reactor_(reactor),
     connection_keepalive_time_(bld.connection_keepalive_time_),
@@ -238,7 +238,7 @@ void ReactorThread::TimerHandler(ev::timer &watcher, int revents) {
       "the timer handler.";
     return;
   }
-  MonoTime now(MonoTime::Now(MonoTime::COARSE));
+  MonoTime now(MonoTime::Now());
   VLOG(4) << name() << ": timer tick at " << now.ToString();
   cur_time_ = now;
 
@@ -353,7 +353,7 @@ Status ReactorThread::StartConnectionNegotiation(const scoped_refptr<Connection>
   DCHECK(IsCurrentThread());
 
   // Set a limit on how long the server will negotiate with a new client.
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(MonoDelta::FromMilliseconds(FLAGS_rpc_negotiation_timeout_ms));
 
   scoped_refptr<Trace> trace(new Trace());

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/rpc/result_tracker.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/result_tracker.cc b/src/kudu/rpc/result_tracker.cc
index 0ae64b2..61e5738 100644
--- a/src/kudu/rpc/result_tracker.cc
+++ b/src/kudu/rpc/result_tracker.cc
@@ -53,7 +53,7 @@ ResultTracker::RpcState ResultTracker::TrackRpcUnlocked(const RequestIdPB& reque
       request_id.client_id(),
       []{ return unique_ptr<ClientState>(new ClientState()); })->get();
 
-  client_state->last_heard_from = MonoTime::Now(MonoTime::FINE);
+  client_state->last_heard_from = MonoTime::Now();
 
   auto result = ComputeIfAbsentReturnAbsense(
       &client_state->completion_records,

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/rpc/rpc-stress-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc-stress-test.cc b/src/kudu/rpc/rpc-stress-test.cc
index 3be88de..b8dade1 100644
--- a/src/kudu/rpc/rpc-stress-test.cc
+++ b/src/kudu/rpc/rpc-stress-test.cc
@@ -151,7 +151,7 @@ class RpcStressTest : public RpcTestBase {
                      const scoped_refptr<RequestTracker>& request_tracker,
                      const shared_ptr<Messenger>& messenger,
                      int value) : latch_(1) {
-      MonoTime now = MonoTime::Now(MonoTime::FINE);
+      MonoTime now = MonoTime::Now();
       now.AddDelta(MonoDelta::FromMilliseconds(10000));
       rpc_ = new CalculatorServiceRpc(server_picker,
                                       request_tracker,

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/rpc/rpc-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc-test.cc b/src/kudu/rpc/rpc-test.cc
index dd8c265..3f11b12 100644
--- a/src/kudu/rpc/rpc-test.cc
+++ b/src/kudu/rpc/rpc-test.cc
@@ -342,7 +342,7 @@ static void AcceptAndReadForever(Socket* listen_sock) {
   Sockaddr remote;
   CHECK_OK(listen_sock->Accept(&server_sock, &remote, 0));
 
-  MonoTime deadline = MonoTime::Now(MonoTime::FINE);
+  MonoTime deadline = MonoTime::Now();
   deadline.AddDelta(MonoDelta::FromSeconds(10));
 
   size_t nread;

http://git-wip-us.apache.org/repos/asf/kudu/blob/ea81e052/src/kudu/rpc/rpc.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc.cc b/src/kudu/rpc/rpc.cc
index 3f19cc7..65218f4 100644
--- a/src/kudu/rpc/rpc.cc
+++ b/src/kudu/rpc/rpc.cc
@@ -73,7 +73,7 @@ void RpcRetrier::DelayedRetryCb(Rpc* rpc, const Status& status) {
   if (new_status.ok()) {
     // Has this RPC timed out?
     if (deadline_.Initialized()) {
-      MonoTime now = MonoTime::Now(MonoTime::FINE);
+      MonoTime now = MonoTime::Now();
       if (deadline_.ComesBefore(now)) {
         string err_str = Substitute("$0 passed its deadline", rpc->ToString());
         if (!last_error_.ok()) {


Mime
View raw message