kudu-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ale...@apache.org
Subject kudu git commit: standard notation for fixed-size integer type names
Date Tue, 19 Sep 2017 18:27:35 GMT
Repository: kudu
Updated Branches:
  refs/heads/master 052d1def8 -> 5c8a8a2ab


standard notation for fixed-size integer type names

Prefer the standard notation for fixed-size integer types
in the Kudu code, e.g., use uint32_t instead of uint32.  In addition
to unification of type naming, this helps to avoid including the
kudu/gutil/integral_types.h extra header file.

The gutil is left unchanged in that regard.

This patch does not contain any functional changes.

Change-Id: If8588275d0d81e5915c798d4d244bba560b6d25f
Reviewed-on: http://gerrit.cloudera.org:8080/8099
Tested-by: Kudu Jenkins
Reviewed-by: Todd Lipcon <todd@apache.org>


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

Branch: refs/heads/master
Commit: 5c8a8a2ab9d20ef89e6264cc43b0a3747567434e
Parents: 052d1de
Author: Alexey Serbin <aserbin@cloudera.com>
Authored: Mon Sep 18 16:50:56 2017 -0700
Committer: Alexey Serbin <aserbin@cloudera.com>
Committed: Tue Sep 19 18:26:19 2017 +0000

----------------------------------------------------------------------
 src/kudu/cfile/bloomfile-test.cc                |  3 +--
 src/kudu/client/client-test.cc                  |  2 +-
 src/kudu/client/scan_configuration.h            |  3 +--
 src/kudu/common/generic_iterators-test.cc       |  7 +++--
 src/kudu/common/row_changelist-test.cc          |  6 ++---
 src/kudu/common/types-test.cc                   |  5 ++--
 src/kudu/consensus/raft_consensus.cc            |  9 +++----
 src/kudu/fs/block_id.h                          |  1 -
 src/kudu/gutil/ref_counted.h                    |  2 +-
 src/kudu/integration-tests/tablet_copy-itest.cc |  5 ++--
 src/kudu/integration-tests/ts_itest-base.h      |  2 +-
 src/kudu/rpc/retriable_rpc.h                    |  2 +-
 src/kudu/rpc/rpc-test-base.h                    |  4 +--
 src/kudu/security/token_signer.cc               |  9 +++----
 src/kudu/tablet/tablet_metadata.cc              |  2 +-
 src/kudu/tablet/tablet_metadata.h               |  3 +--
 src/kudu/tools/kudu-admin-test.cc               |  9 +++----
 src/kudu/tools/tool_action_tablet.cc            |  4 +--
 src/kudu/tserver/scanners.cc                    |  3 +--
 src/kudu/tserver/tablet_copy_client.h           |  3 +--
 src/kudu/tserver/tablet_copy_source_session.h   |  3 +--
 src/kudu/util/async_logger.cc                   |  2 +-
 src/kudu/util/async_logger.h                    |  3 +--
 src/kudu/util/bloom_filter.h                    |  5 ++--
 src/kudu/util/condition_variable.cc             |  4 +--
 src/kudu/util/debug/trace_event_impl.cc         | 28 ++++++++++----------
 src/kudu/util/debug/trace_event_impl.h          | 17 ++++++------
 src/kudu/util/file_cache-stress-test.cc         |  2 +-
 src/kudu/util/logging-test.cc                   |  4 +--
 src/kudu/util/memory/memory.h                   |  7 +++--
 src/kudu/util/os-util.cc                        |  3 +--
 src/kudu/util/pb_util-internal.h                |  4 +--
 src/kudu/util/spinlock_profiling.cc             |  7 +++--
 src/kudu/util/test_util.cc                      |  3 +--
 src/kudu/util/thread.cc                         |  5 ++--
 35 files changed, 80 insertions(+), 101 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/cfile/bloomfile-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/bloomfile-test.cc b/src/kudu/cfile/bloomfile-test.cc
index 34aead3..afd8171 100644
--- a/src/kudu/cfile/bloomfile-test.cc
+++ b/src/kudu/cfile/bloomfile-test.cc
@@ -32,7 +32,6 @@
 #include "kudu/fs/fs_manager.h"
 #include "kudu/gutil/endian.h"
 #include "kudu/gutil/gscoped_ptr.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/util/bloom_filter.h"
 #include "kudu/util/mem_tracker.h"
 #include "kudu/util/slice.h"
@@ -63,7 +62,7 @@ class BloomFileTest : public BloomFileTestBase {
 
     int positive_count = 0;
     // Check that the FP rate for keys we didn't insert is what we expect.
-    for (uint64 i = 0; i < FLAGS_n_keys; i++) {
+    for (uint64_t i = 0; i < FLAGS_n_keys; i++) {
       uint64_t key = random();
       Slice s(reinterpret_cast<char *>(&key), sizeof(key));
 

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/client/client-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/client-test.cc b/src/kudu/client/client-test.cc
index cb1ab12..6ed26be 100644
--- a/src/kudu/client/client-test.cc
+++ b/src/kudu/client/client-test.cc
@@ -3024,7 +3024,7 @@ TEST_F(ClientTest, TestAutoFlushBackgroundPreFlush) {
     // For details on this behavior please see the diagram in the body of the
     // KuduSession::Data::ApplyWriteOp() method.
     EXPECT_GT(kFlushIntervalMs / 10,
-              static_cast<int32>(sw.elapsed().wall_millis()));
+              static_cast<int32_t>(sw.elapsed().wall_millis()));
   }
   ASSERT_OK(session->Flush());
 

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/client/scan_configuration.h
----------------------------------------------------------------------
diff --git a/src/kudu/client/scan_configuration.h b/src/kudu/client/scan_configuration.h
index 168c87f..26c1bcc 100644
--- a/src/kudu/client/scan_configuration.h
+++ b/src/kudu/client/scan_configuration.h
@@ -26,7 +26,6 @@
 #include "kudu/client/client.h"
 #include "kudu/client/schema.h"
 #include "kudu/common/scan_spec.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/port.h"
 #include "kudu/util/auto_release_pool.h"
 #include "kudu/util/memory/arena.h"
@@ -175,7 +174,7 @@ class ScanConfiguration {
   ScanSpec spec_;
 
   bool has_batch_size_bytes_;
-  uint32 batch_size_bytes_;
+  uint32_t batch_size_bytes_;
 
   KuduClient::ReplicaSelection selection_;
 

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/common/generic_iterators-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/generic_iterators-test.cc b/src/kudu/common/generic_iterators-test.cc
index ffb1da2..ed5ed14 100644
--- a/src/kudu/common/generic_iterators-test.cc
+++ b/src/kudu/common/generic_iterators-test.cc
@@ -40,7 +40,6 @@
 #include "kudu/common/schema.h"
 #include "kudu/common/types.h"
 #include "kudu/gutil/casts.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/mathlimits.h"
 #include "kudu/gutil/port.h"
 #include "kudu/util/memory/arena.h"
@@ -255,7 +254,7 @@ TEST(TestMaterializingIterator, TestMaterializingPredicatePushdown) {
   spec.AddPredicate(pred1.pred_);
   LOG(INFO) << "Predicate: " << pred1.pred_.ToString();
 
-  vector<uint32> ints;
+  vector<uint32_t> ints;
   for (int i = 0; i < 100; i++) {
     ints.push_back(i);
   }
@@ -286,7 +285,7 @@ TEST(TestPredicateEvaluatingIterator, TestPredicateEvaluation) {
   spec.AddPredicate(pred1.pred_);
   LOG(INFO) << "Predicate: " << pred1.pred_.ToString();
 
-  vector<uint32> ints;
+  vector<uint32_t> ints;
   for (int i = 0; i < 100; i++) {
     ints.push_back(i);
   }
@@ -331,7 +330,7 @@ TEST(TestPredicateEvaluatingIterator, TestPredicateEvaluation) {
 TEST(TestPredicateEvaluatingIterator, TestDontWrapWhenNoPredicates) {
   ScanSpec spec;
 
-  vector<uint32> ints;
+  vector<uint32_t> ints;
   shared_ptr<VectorIterator> colwise(new VectorIterator(ints));
   shared_ptr<RowwiseIterator> materializing(new MaterializingIterator(colwise));
   shared_ptr<RowwiseIterator> outer_iter(materializing);

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/common/row_changelist-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/row_changelist-test.cc b/src/kudu/common/row_changelist-test.cc
index 503417d..8a5765b 100644
--- a/src/kudu/common/row_changelist-test.cc
+++ b/src/kudu/common/row_changelist-test.cc
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <cstdint>
 #include <ostream>
 #include <string>
 
@@ -23,10 +24,9 @@
 
 #include "kudu/common/common.pb.h"
 #include "kudu/common/row.h"
-#include "kudu/common/rowblock.h"
 #include "kudu/common/row_changelist.h"
+#include "kudu/common/rowblock.h"
 #include "kudu/common/schema.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/util/faststring.h"
 #include "kudu/util/hexdump.h"
@@ -67,7 +67,7 @@ TEST_F(TestRowChangeList, TestEncodeDecodeUpdates) {
   // Construct an update with several columns changed
   Slice update1("update1");
   Slice update2("update2");
-  uint32 update3 = 12345;
+  uint32_t update3 = 12345;
 
   int c0_id = schema_.column_id(0);
   int c1_id = schema_.column_id(1);

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/common/types-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/types-test.cc b/src/kudu/common/types-test.cc
index dc2fc3d..2d3e9a8 100644
--- a/src/kudu/common/types-test.cc
+++ b/src/kudu/common/types-test.cc
@@ -26,7 +26,6 @@
 
 #include "kudu/common/common.pb.h"
 #include "kudu/common/types.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/mathlimits.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/util/slice.h"
@@ -47,7 +46,7 @@ TEST_F(TestTypes, TestTimestampPrinting) {
   const TypeInfo* info = GetTypeInfo(UNIXTIME_MICROS);
 
   // Test the minimum value
-  int64 time;
+  int64_t time;
   info->CopyMinValue(&time);
   string result;
   info->AppendDebugStringForValue(&time, &result);
@@ -75,7 +74,7 @@ TEST_F(TestTypes, TestTimestampPrinting) {
   result = "";
 
   // Test the maximum value.
-  time = MathLimits<int64>::kMax;
+  time = MathLimits<int64_t>::kMax;
   info->AppendDebugStringForValue(&time, &result);
   ASSERT_EQ("294247-01-10T04:00:54.775807Z", result);
   result = "";

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/consensus/raft_consensus.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus.cc b/src/kudu/consensus/raft_consensus.cc
index 8a251a1..588dd67 100644
--- a/src/kudu/consensus/raft_consensus.cc
+++ b/src/kudu/consensus/raft_consensus.cc
@@ -45,7 +45,6 @@
 #include "kudu/consensus/pending_rounds.h"
 #include "kudu/consensus/quorum_util.h"
 #include "kudu/gutil/bind.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/move.h"
 #include "kudu/gutil/port.h"
@@ -1668,9 +1667,9 @@ Status RaftConsensus::UnsafeChangeConfig(const UnsafeChangeConfigRequestPB&
req,
   int64_t current_term;
   RaftConfigPB committed_config;
   int64_t all_replicated_index;
-  int64 last_committed_index;
+  int64_t last_committed_index;
   OpId preceding_opid;
-  uint64 msg_timestamp;
+  uint64_t msg_timestamp;
   {
     // Take the snapshot of the replica state and queue state so that
     // we can stick them in the consensus update request later.
@@ -1734,7 +1733,7 @@ Status RaftConsensus::UnsafeChangeConfig(const UnsafeChangeConfigRequestPB&
req,
                                               SecureShortDebugString(new_config)));
   }
   new_config.set_unsafe_config_change(true);
-  int64 replicate_opid_index = preceding_opid.index() + 1;
+  int64_t replicate_opid_index = preceding_opid.index() + 1;
   new_config.set_opid_index(replicate_opid_index);
 
   // Sanity check the new config. 'type' is irrelevant here.
@@ -1756,7 +1755,7 @@ Status RaftConsensus::UnsafeChangeConfig(const UnsafeChangeConfigRequestPB&
req,
   // This makes this request appear to come from a new leader that
   // the local replica doesn't know about yet. If the local replica
   // happens to be the leader, this will cause it to step down.
-  int64 new_term = current_term + 1;
+  int64_t new_term = current_term + 1;
   consensus_req.set_caller_term(new_term);
   consensus_req.mutable_preceding_id()->CopyFrom(preceding_opid);
   consensus_req.set_committed_index(last_committed_index);

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/fs/block_id.h
----------------------------------------------------------------------
diff --git a/src/kudu/fs/block_id.h b/src/kudu/fs/block_id.h
index ed77f71..bbfba6c 100644
--- a/src/kudu/fs/block_id.h
+++ b/src/kudu/fs/block_id.h
@@ -25,7 +25,6 @@
 #include <unordered_set>
 #include <vector>
 
-#include "kudu/gutil/hash/hash.h"
 #include "kudu/gutil/stringprintf.h"
 
 namespace kudu {

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/gutil/ref_counted.h
----------------------------------------------------------------------
diff --git a/src/kudu/gutil/ref_counted.h b/src/kudu/gutil/ref_counted.h
index 0fef5a6..776b5b8 100644
--- a/src/kudu/gutil/ref_counted.h
+++ b/src/kudu/gutil/ref_counted.h
@@ -7,7 +7,7 @@
 
 #include <cassert>
 #include <cstddef>
-#include <utility>
+#include <utility>  // IWYU pragma: keep
 
 #include "kudu/gutil/atomicops.h"
 #include "kudu/gutil/macros.h"

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/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 03accae..4360c4c 100644
--- a/src/kudu/integration-tests/tablet_copy-itest.cc
+++ b/src/kudu/integration-tests/tablet_copy-itest.cc
@@ -50,7 +50,6 @@
 #include "kudu/fs/fs_manager.h"
 #include "kudu/gutil/basictypes.h"
 #include "kudu/gutil/gscoped_ptr.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -1587,8 +1586,8 @@ TEST_F(TabletCopyITest, TestTabletCopyMetrics) {
       kTimeout));
 
   // Check that the final bytes fetched is equal to the final bytes sent, and both are positive.
-  int64 bytes_sent = TabletCopyBytesSent(cluster_->tablet_server(leader_index));
-  int64 bytes_fetched = TabletCopyBytesFetched(cluster_->tablet_server(follower_index));
+  int64_t bytes_sent = TabletCopyBytesSent(cluster_->tablet_server(leader_index));
+  int64_t bytes_fetched = TabletCopyBytesFetched(cluster_->tablet_server(follower_index));
   ASSERT_GT(bytes_sent, 0);
   ASSERT_EQ(bytes_sent, bytes_fetched);
 

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/integration-tests/ts_itest-base.h
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/ts_itest-base.h b/src/kudu/integration-tests/ts_itest-base.h
index 0458da8..7346ac3 100644
--- a/src/kudu/integration-tests/ts_itest-base.h
+++ b/src/kudu/integration-tests/ts_itest-base.h
@@ -405,7 +405,7 @@ class TabletServerIntegrationTestBase : public TabletServerTestBase {
     CHECK_OK(GetLastOpIdForEachReplica(tablet_id, replicas, consensus::RECEIVED_OPID,
                                        MonoDelta::FromSeconds(10), &op_ids));
 
-    int64 max_index = 0;
+    int64_t max_index = 0;
     int max_replica_index = -1;
     for (int i = 0; i < op_ids.size(); i++) {
       if (op_ids[i].index() > max_index) {

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/rpc/retriable_rpc.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/retriable_rpc.h b/src/kudu/rpc/retriable_rpc.h
index 1facf0e..ba84689 100644
--- a/src/kudu/rpc/retriable_rpc.h
+++ b/src/kudu/rpc/retriable_rpc.h
@@ -127,7 +127,7 @@ class RetriableRpc : public Rpc {
   internal::SequenceNumber sequence_number_;
 
   // The number of times this RPC has been attempted
-  int32 num_attempts_;
+  int32_t num_attempts_;
 
   // Keeps track of the replica the RPCs were sent to.
   // TODO Remove this and pass the used replica around. For now we need to keep this as

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/rpc/rpc-test-base.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc-test-base.h b/src/kudu/rpc/rpc-test-base.h
index 757f1fe..41afff9 100644
--- a/src/kudu/rpc/rpc-test-base.h
+++ b/src/kudu/rpc/rpc-test-base.h
@@ -226,8 +226,8 @@ class GenericCalculatorService : public ServiceIf {
     LOG(INFO) << "got call: " << pb_util::SecureShortDebugString(req);
     SleepFor(MonoDelta::FromMicroseconds(req.sleep_micros()));
 
-    uint32 pattern = req.pattern();
-    uint32 num_repetitions = req.num_repetitions();
+    uint32_t pattern = req.pattern();
+    uint32_t num_repetitions = req.num_repetitions();
     Slice sidecar;
     CHECK_OK(incoming->GetInboundSidecar(req.sidecar_idx(), &sidecar));
     CHECK_EQ(sidecar.size(), sizeof(uint32) * num_repetitions);

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/security/token_signer.cc
----------------------------------------------------------------------
diff --git a/src/kudu/security/token_signer.cc b/src/kudu/security/token_signer.cc
index fd1f017..08c84be 100644
--- a/src/kudu/security/token_signer.cc
+++ b/src/kudu/security/token_signer.cc
@@ -29,7 +29,6 @@
 #include <gflags/gflags.h>
 #include <glog/logging.h>
 
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/gutil/walltime.h"
 #include "kudu/security/crypto.h"
@@ -182,8 +181,8 @@ Status TokenSigner::CheckNeedKey(unique_ptr<TokenSigningPrivateKey>*
tsk) const
   unique_lock<RWMutex> l(lock_);
   if (tsk_deque_.empty()) {
     // No active key: need a new one.
-    const int64 key_seq_num = last_key_seq_num_ + 1;
-    const int64 key_expiration = now + key_validity_seconds_;
+    const int64_t key_seq_num = last_key_seq_num_ + 1;
+    const int64_t key_expiration = now + key_validity_seconds_;
     // Generation of cryptographically strong key takes many CPU cycles;
     // do not want to block other parallel activity.
     l.unlock();
@@ -214,8 +213,8 @@ Status TokenSigner::CheckNeedKey(unique_ptr<TokenSigningPrivateKey>*
tsk) const
   const auto key_creation_time = key->expire_time() - key_validity_seconds_;
   if (key_creation_time + key_rotation_seconds_ <= now) {
     // It's time to create and start propagating next key.
-    const int64 key_seq_num = last_key_seq_num_ + 1;
-    const int64 key_expiration = now + key_validity_seconds_;
+    const int64_t key_seq_num = last_key_seq_num_ + 1;
+    const int64_t key_expiration = now + key_validity_seconds_;
     // Generation of cryptographically strong key takes many CPU cycles:
     // do not want to block other parallel activity.
     l.unlock();

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/tablet/tablet_metadata.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/tablet_metadata.cc b/src/kudu/tablet/tablet_metadata.cc
index f00de4c..9347fcd 100644
--- a/src/kudu/tablet/tablet_metadata.cc
+++ b/src/kudu/tablet/tablet_metadata.cc
@@ -72,7 +72,7 @@ using strings::Substitute;
 namespace kudu {
 namespace tablet {
 
-const int64 kNoDurableMemStore = -1;
+const int64_t kNoDurableMemStore = -1;
 
 // ============================================================================
 //  Tablet Metadata

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/tablet/tablet_metadata.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/tablet_metadata.h b/src/kudu/tablet/tablet_metadata.h
index e9cde54..83445ed 100644
--- a/src/kudu/tablet/tablet_metadata.h
+++ b/src/kudu/tablet/tablet_metadata.h
@@ -32,7 +32,6 @@
 #include "kudu/fs/block_id.h"
 #include "kudu/gutil/atomicops.h"
 #include "kudu/gutil/gscoped_ptr.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/tablet/metadata.pb.h"
@@ -58,7 +57,7 @@ class RowSetMetadata;
 typedef std::vector<std::shared_ptr<RowSetMetadata> > RowSetMetadataVector;
 typedef std::unordered_set<int64_t> RowSetMetadataIds;
 
-extern const int64 kNoDurableMemStore;
+extern const int64_t kNoDurableMemStore;
 
 // Manages the "blocks tracking" for the specified tablet.
 //

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/tools/kudu-admin-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tools/kudu-admin-test.cc b/src/kudu/tools/kudu-admin-test.cc
index fbb1be4..44e2447 100644
--- a/src/kudu/tools/kudu-admin-test.cc
+++ b/src/kudu/tools/kudu-admin-test.cc
@@ -44,7 +44,6 @@
 #include "kudu/consensus/opid.pb.h"
 #include "kudu/consensus/quorum_util.h"
 #include "kudu/gutil/gscoped_ptr.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/strings/split.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -1061,7 +1060,7 @@ TEST_F(AdminCliTest, TestUnsafeChangeConfigWithMultiplePendingConfigs)
{
 
 Status GetTermFromConsensus(const vector<TServerDetails*>& tservers,
                             const string& tablet_id,
-                            int64 *current_term) {
+                            int64_t *current_term) {
   ConsensusStatePB cstate;
   for (auto& ts : tservers) {
     RETURN_NOT_OK(
@@ -1091,7 +1090,7 @@ TEST_F(AdminCliTest, TestLeaderStepDown) {
                                      MonoDelta::FromSeconds(10)));
   }
 
-  int64 current_term;
+  int64_t current_term;
   ASSERT_OK(GetTermFromConsensus(tservers, tablet_id_,
                                  &current_term));
 
@@ -1109,7 +1108,7 @@ TEST_F(AdminCliTest, TestLeaderStepDown) {
       Status::IllegalState("").CodeAsString()) != string::npos;
   ASSERT_TRUE(s.ok() || not_currently_leader);
   if (s.ok()) {
-    int64 new_term;
+    int64_t new_term;
     ASSERT_EVENTUALLY([&]() {
         ASSERT_OK(GetTermFromConsensus(tservers, tablet_id_,
                                        &new_term));
@@ -1133,7 +1132,7 @@ TEST_F(AdminCliTest, TestLeaderStepDownWhenNotPresent) {
                                      MonoDelta::FromSeconds(10)));
   }
 
-  int64 current_term;
+  int64_t current_term;
   ASSERT_TRUE(GetTermFromConsensus(tservers, tablet_id_,
                                    &current_term).IsNotFound());
   string stdout;

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/tools/tool_action_tablet.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tools/tool_action_tablet.cc b/src/kudu/tools/tool_action_tablet.cc
index db6c4b7..b16eb3b 100644
--- a/src/kudu/tools/tool_action_tablet.cc
+++ b/src/kudu/tools/tool_action_tablet.cc
@@ -18,6 +18,7 @@
 #include "kudu/tools/tool_action.h"
 
 #include <algorithm>
+#include <cstdint>
 #include <fstream>  // IWYU pragma: keep
 #include <iostream>
 #include <memory>
@@ -37,7 +38,6 @@
 #include "kudu/consensus/metadata.pb.h"
 #include "kudu/consensus/opid.pb.h"
 #include "kudu/consensus/opid_util.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/strings/split.h"
@@ -336,7 +336,7 @@ Status ChangeLeader(const client::sp::shared_ptr<KuduClient>&
client, const stri
   ConsensusStatePB cstate;
   RETURN_NOT_OK(GetConsensusState(proxy, tablet_id, old_leader_uuid,
                                   client->default_admin_operation_timeout(), &cstate));
-  int64 current_term = -1;
+  int64_t current_term = -1;
   MonoTime deadline = MonoTime::Now() + timeout;
 
   while (MonoTime::Now() < deadline) {

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/tserver/scanners.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/scanners.cc b/src/kudu/tserver/scanners.cc
index d0b9c57..92a955b 100644
--- a/src/kudu/tserver/scanners.cc
+++ b/src/kudu/tserver/scanners.cc
@@ -28,7 +28,6 @@
 #include "kudu/gutil/bind.h"
 #include "kudu/gutil/bind_helpers.h"
 #include "kudu/gutil/hash/string_hash.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -118,7 +117,7 @@ ScannerManager::ScannerMapStripe& ScannerManager::GetStripeByScannerId(const
str
 
 void ScannerManager::NewScanner(const scoped_refptr<TabletReplica>& tablet_replica,
                                 const std::string& requestor_string,
-                                uint64 row_format_flags,
+                                uint64_t row_format_flags,
                                 SharedScanner* scanner) {
   // Keep trying to generate a unique ID until we get one.
   bool success = false;

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/tserver/tablet_copy_client.h
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/tablet_copy_client.h b/src/kudu/tserver/tablet_copy_client.h
index 68a3cc4..95dd865 100644
--- a/src/kudu/tserver/tablet_copy_client.h
+++ b/src/kudu/tserver/tablet_copy_client.h
@@ -25,7 +25,6 @@
 #include <gtest/gtest_prod.h>
 
 #include "kudu/fs/block_manager.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/util/metrics.h"
@@ -66,7 +65,7 @@ struct TabletCopyClientMetrics {
   explicit TabletCopyClientMetrics(const scoped_refptr<MetricEntity>& metric_entity);
 
   scoped_refptr<Counter> bytes_fetched;
-  scoped_refptr<AtomicGauge<int32>> open_client_sessions;
+  scoped_refptr<AtomicGauge<int32_t>> open_client_sessions;
 };
 
 // Client class for using tablet copy to copy a tablet from another host.

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/tserver/tablet_copy_source_session.h
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/tablet_copy_source_session.h b/src/kudu/tserver/tablet_copy_source_session.h
index fbd58fd..4f21435 100644
--- a/src/kudu/tserver/tablet_copy_source_session.h
+++ b/src/kudu/tserver/tablet_copy_source_session.h
@@ -30,7 +30,6 @@
 #include "kudu/consensus/metadata.pb.h"
 #include "kudu/fs/block_id.h"
 #include "kudu/fs/block_manager.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/stl_util.h"
@@ -57,7 +56,7 @@ struct TabletCopySourceMetrics {
   explicit TabletCopySourceMetrics(const scoped_refptr<MetricEntity>& metric_entity);
 
   scoped_refptr<Counter> bytes_sent;
-  scoped_refptr<AtomicGauge<int32>> open_source_sessions;
+  scoped_refptr<AtomicGauge<int32_t>> open_source_sessions;
 };
 
 // Caches file size and holds a shared_ptr reference to a RandomAccessFile.

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/util/async_logger.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/async_logger.cc b/src/kudu/util/async_logger.cc
index 1b1d9e4..9eb0bc6 100644
--- a/src/kudu/util/async_logger.cc
+++ b/src/kudu/util/async_logger.cc
@@ -106,7 +106,7 @@ void AsyncLogger::Flush() {
   }
 }
 
-uint32 AsyncLogger::LogSize() {
+uint32_t AsyncLogger::LogSize() {
   return wrapped_->LogSize();
 }
 

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/util/async_logger.h
----------------------------------------------------------------------
diff --git a/src/kudu/util/async_logger.h b/src/kudu/util/async_logger.h
index 7a7d37b..68fc369 100644
--- a/src/kudu/util/async_logger.h
+++ b/src/kudu/util/async_logger.h
@@ -28,7 +28,6 @@
 
 #include <glog/logging.h>
 
-#include "kudu/gutil/integral_types.h"
 #include "kudu/util/condition_variable.h"
 #include "kudu/util/mutex.h"
 
@@ -95,7 +94,7 @@ class AsyncLogger : public google::base::Logger {
   // Get the current LOG file size.
   // The returned value is approximate since some
   // logged data may not have been flushed to disk yet.
-  uint32 LogSize() override;
+  uint32_t LogSize() override;
 
   // Return a count of how many times an application thread was
   // blocked due to the buffers being full and the writer thread

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/util/bloom_filter.h
----------------------------------------------------------------------
diff --git a/src/kudu/util/bloom_filter.h b/src/kudu/util/bloom_filter.h
index 1ebd323..0783a28 100644
--- a/src/kudu/util/bloom_filter.h
+++ b/src/kudu/util/bloom_filter.h
@@ -22,7 +22,6 @@
 
 #include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/hash/city.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/util/bitmap.h"
 #include "kudu/util/slice.h"
@@ -59,8 +58,8 @@ class BloomKeyProbe {
 
     // Use the top and bottom halves of the 64-bit hash
     // as the two independent hash functions for mixing.
-    h_1_ = static_cast<uint32>(h);
-    h_2_ = static_cast<uint32>(h >> 32);
+    h_1_ = static_cast<uint32_t>(h);
+    h_2_ = static_cast<uint32_t>(h >> 32);
   }
 
   const Slice &key() const { return key_; }

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/util/condition_variable.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/condition_variable.cc b/src/kudu/util/condition_variable.cc
index be4afa4..c79a0a4 100644
--- a/src/kudu/util/condition_variable.cc
+++ b/src/kudu/util/condition_variable.cc
@@ -7,12 +7,12 @@
 #include <sys/time.h>
 
 #include <cerrno>
+#include <cstdint>
 #include <ctime>
 #include <ostream>
 
 #include <glog/logging.h>
 
-#include "kudu/gutil/integral_types.h"
 #include "kudu/util/monotime.h"
 #include "kudu/util/mutex.h"
 #include "kudu/util/thread_restrictions.h"
@@ -79,7 +79,7 @@ bool ConditionVariable::TimedWait(const MonoDelta& max_time) const {
   ThreadRestrictions::AssertWaitAllowed();
 
   // Negative delta means we've already timed out.
-  int64 nsecs = max_time.ToNanoseconds();
+  int64_t nsecs = max_time.ToNanoseconds();
   if (nsecs < 0) {
     return false;
   }

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/util/debug/trace_event_impl.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/debug/trace_event_impl.cc b/src/kudu/util/debug/trace_event_impl.cc
index e8f00ab..5ff27b0 100644
--- a/src/kudu/util/debug/trace_event_impl.cc
+++ b/src/kudu/util/debug/trace_event_impl.cc
@@ -286,7 +286,7 @@ class TraceBufferRingBuffer : public TraceBuffer {
   size_t queue_tail_;
 
   size_t current_iteration_index_;
-  uint32 current_chunk_seq_;
+  uint32_t current_chunk_seq_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceBufferRingBuffer);
 };
@@ -312,7 +312,7 @@ class TraceBufferVector : public TraceBuffer {
     ++in_flight_chunk_count_;
     // + 1 because zero chunk_seq is not allowed.
     return gscoped_ptr<TraceBufferChunk>(
-        new TraceBufferChunk(static_cast<uint32>(*index) + 1));
+        new TraceBufferChunk(static_cast<uint32_t>(*index) + 1));
   }
 
   virtual void ReturnChunk(size_t index,
@@ -426,7 +426,7 @@ TraceLog::ThreadLocalEventBuffer* TraceLog::PerThreadInfo::AtomicTakeBuffer()
{
       0));
 }
 
-void TraceBufferChunk::Reset(uint32 new_seq) {
+void TraceBufferChunk::Reset(uint32_t new_seq) {
   for (size_t i = 0; i < next_free_; ++i)
     chunk_[i].Reset();
   next_free_ = 0;
@@ -476,14 +476,14 @@ class TraceLog::OptionalAutoLock {
 
 // Use this function instead of TraceEventHandle constructor to keep the
 // overhead of ScopedTracer (trace_event.h) constructor minimum.
-void MakeHandle(uint32 chunk_seq, size_t chunk_index, size_t event_index,
+void MakeHandle(uint32_t chunk_seq, size_t chunk_index, size_t event_index,
                 TraceEventHandle* handle) {
   DCHECK(chunk_seq);
   DCHECK(chunk_index < (1u << 16));
   DCHECK(event_index < (1u << 16));
   handle->chunk_seq = chunk_seq;
-  handle->chunk_index = static_cast<uint16>(chunk_index);
-  handle->event_index = static_cast<uint16>(event_index);
+  handle->chunk_index = static_cast<uint16_t>(chunk_index);
+  handle->event_index = static_cast<uint16_t>(event_index);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -697,10 +697,10 @@ void TraceEvent::AppendValueAsJSON(unsigned char type,
       *out += value.as_bool ? "true" : "false";
       break;
     case TRACE_VALUE_TYPE_UINT:
-      SubstituteAndAppend(out, "$0", static_cast<uint64>(value.as_uint));
+      SubstituteAndAppend(out, "$0", static_cast<uint64_t>(value.as_uint));
       break;
     case TRACE_VALUE_TYPE_INT:
-      SubstituteAndAppend(out, "$0", static_cast<int64>(value.as_int));
+      SubstituteAndAppend(out, "$0", static_cast<int64_t>(value.as_int));
       break;
     case TRACE_VALUE_TYPE_DOUBLE: {
       // FIXME: base/json/json_writer.cc is using the same code,
@@ -740,7 +740,7 @@ void TraceEvent::AppendValueAsJSON(unsigned char type,
     case TRACE_VALUE_TYPE_POINTER:
       // JSON only supports double and int numbers.
       // So as not to lose bits from a 64-bit pointer, output as a hex string.
-      StringAppendF(out, "\"0x%" PRIx64 "\"", static_cast<uint64>(
+      StringAppendF(out, "\"0x%" PRIx64 "\"", static_cast<uint64_t>(
                                      reinterpret_cast<intptr_t>(
                                      value.as_pointer)));
       break;
@@ -757,7 +757,7 @@ void TraceEvent::AppendValueAsJSON(unsigned char type,
 }
 
 void TraceEvent::AppendAsJSON(std::string* out) const {
-  int64 time_int64 = timestamp_;
+  int64_t time_int64 = timestamp_;
   int process_id = TraceLog::GetInstance()->process_id();
   // Category group checked at category creation time.
   DCHECK(!strchr(name_, '"'));
@@ -787,11 +787,11 @@ void TraceEvent::AppendAsJSON(std::string* out) const {
   *out += "}";
 
   if (phase_ == TRACE_EVENT_PHASE_COMPLETE) {
-    int64 duration = duration_;
+    int64_t duration = duration_;
     if (duration != -1)
       StringAppendF(out, ",\"dur\":%" PRId64, duration);
     if (thread_timestamp_ >= 0) {
-      int64 thread_duration = thread_duration_;
+      int64_t thread_duration = thread_duration_;
       if (thread_duration != -1)
         StringAppendF(out, ",\"tdur\":%" PRId64, thread_duration);
     }
@@ -799,14 +799,14 @@ void TraceEvent::AppendAsJSON(std::string* out) const {
 
   // Output tts if thread_timestamp is valid.
   if (thread_timestamp_ >= 0) {
-    int64 thread_time_int64 = thread_timestamp_;
+    int64_t thread_time_int64 = thread_timestamp_;
     StringAppendF(out, ",\"tts\":%" PRId64, thread_time_int64);
   }
 
   // If id_ is set, print it out as a hex string so we don't loose any
   // bits (it might be a 64-bit pointer).
   if (flags_ & TRACE_EVENT_FLAG_HAS_ID)
-    StringAppendF(out, ",\"id\":\"0x%" PRIx64 "\"", static_cast<uint64>(id_));
+    StringAppendF(out, ",\"id\":\"0x%" PRIx64 "\"", static_cast<uint64_t>(id_));
 
   // Instant events also output their scope.
   if (phase_ == TRACE_EVENT_PHASE_INSTANT) {

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/util/debug/trace_event_impl.h
----------------------------------------------------------------------
diff --git a/src/kudu/util/debug/trace_event_impl.h b/src/kudu/util/debug/trace_event_impl.h
index 53b1690..09f38a8 100644
--- a/src/kudu/util/debug/trace_event_impl.h
+++ b/src/kudu/util/debug/trace_event_impl.h
@@ -20,11 +20,10 @@
 #include "kudu/gutil/bind_helpers.h"
 #include "kudu/gutil/callback.h"
 #include "kudu/gutil/gscoped_ptr.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/macros.h"
+#include "kudu/gutil/ref_counted.h"
 #include "kudu/gutil/spinlock.h"
 #include "kudu/gutil/walltime.h"
-#include "kudu/gutil/ref_counted.h"
 #include "kudu/util/mutex.h"
 
 // Older style trace macros with explicit id and extra data
@@ -83,9 +82,9 @@ class ConvertableToTraceFormat : public kudu::RefCountedThreadSafe<ConvertableTo
 };
 
 struct TraceEventHandle {
-  uint32 chunk_seq;
-  uint16 chunk_index;
-  uint16 event_index;
+  uint32_t chunk_seq;
+  uint16_t chunk_index;
+  uint16_t event_index;
 };
 
 const int kTraceMaxNumArgs = 2;
@@ -185,16 +184,16 @@ class BASE_EXPORT TraceEvent {
 // TraceBufferChunk is the basic unit of TraceBuffer.
 class BASE_EXPORT TraceBufferChunk {
  public:
-  TraceBufferChunk(uint32 seq)
+  explicit TraceBufferChunk(uint32_t seq)
       : next_free_(0),
         seq_(seq) {
   }
 
-  void Reset(uint32 new_seq);
+  void Reset(uint32_t new_seq);
   TraceEvent* AddTraceEvent(size_t* event_index);
   bool IsFull() const { return next_free_ == kTraceBufferChunkSize; }
 
-  uint32 seq() const { return seq_; }
+  uint32_t seq() const { return seq_; }
   size_t capacity() const { return kTraceBufferChunkSize; }
   size_t size() const { return next_free_; }
 
@@ -214,7 +213,7 @@ class BASE_EXPORT TraceBufferChunk {
  private:
   size_t next_free_;
   TraceEvent chunk_[kTraceBufferChunkSize];
-  uint32 seq_;
+  uint32_t seq_;
 };
 
 // TraceBuffer holds the events as they are collected.

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/util/file_cache-stress-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/file_cache-stress-test.cc b/src/kudu/util/file_cache-stress-test.cc
index bf150f5..2ea451a 100644
--- a/src/kudu/util/file_cache-stress-test.cc
+++ b/src/kudu/util/file_cache-stress-test.cc
@@ -329,7 +329,7 @@ Status FileCacheStressTest<RWFile>::WriteRandomChunk(
   uint64_t file_size;
   RETURN_NOT_OK(file->Size(&file_size));
   uint64_t off = file_size > 0 ? rand->Uniform(file_size) : 0;
-  uint8 buf[64];
+  uint8_t buf[64];
   RETURN_NOT_OK(file->Write(off, GenerateRandomChunk(buf, sizeof(buf), rand)));
   (*metrics)[BaseName(file->filename())]["write"]++;
   return Status::OK();

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/util/logging-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/logging-test.cc b/src/kudu/util/logging-test.cc
index d9ba2ca..9514d55 100644
--- a/src/kudu/util/logging-test.cc
+++ b/src/kudu/util/logging-test.cc
@@ -16,6 +16,7 @@
 // under the License.
 
 #include <atomic>
+#include <cstdint>
 #include <ctime>
 #include <ostream>
 #include <string>
@@ -26,7 +27,6 @@
 #include <gmock/gmock-matchers.h>
 #include <gtest/gtest.h>
 
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/util/async_logger.h"
 #include "kudu/util/barrier.h"
@@ -117,7 +117,7 @@ class CountingLogger : public google::base::Logger {
     flush_count_++;
   }
 
-  uint32 LogSize() override {
+  uint32_t LogSize() override {
     return 0;
   }
 

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/util/memory/memory.h
----------------------------------------------------------------------
diff --git a/src/kudu/util/memory/memory.h b/src/kudu/util/memory/memory.h
index 972589e..315631b 100644
--- a/src/kudu/util/memory/memory.h
+++ b/src/kudu/util/memory/memory.h
@@ -46,7 +46,6 @@
 #include "kudu/util/memory/overwrite.h"
 #include "kudu/util/mutex.h"
 #include "kudu/gutil/gscoped_ptr.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/port.h"
 #include "kudu/gutil/singleton.h"
@@ -883,11 +882,11 @@ class GuaranteeMemory : public BufferAllocator {
   }
 
   virtual bool ReallocateInternal(size_t requested,
-                                  size_t minimal,
+                                  size_t /* minimal */,
                                   Buffer* buffer,
                                   BufferAllocator* originator) OVERRIDE {
-    int64 additional_memory = requested - (buffer != NULL ? buffer->size() : 0);
-    return additional_memory <= static_cast<int64>(Available())
+    int64_t additional_memory = requested - (buffer != NULL ? buffer->size() : 0);
+    return additional_memory <= static_cast<int64_t>(Available())
         && DelegateReallocate(&limit_, requested, requested,
                               buffer, originator);
   }

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/util/os-util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/os-util.cc b/src/kudu/util/os-util.cc
index 8277821..d29eaff 100644
--- a/src/kudu/util/os-util.cc
+++ b/src/kudu/util/os-util.cc
@@ -35,7 +35,6 @@
 #include <string>
 #include <vector>
 
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/strings/numbers.h"
 #include "kudu/gutil/strings/split.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -89,7 +88,7 @@ Status ParseStat(const std::string& buffer, std::string* name, ThreadStats*
stat
     return Status::IOError("Unrecognised /proc format");
   }
 
-  int64 tmp;
+  int64_t tmp;
   if (safe_strto64(splits[kUserTicks], &tmp)) {
     stats->user_ns = tmp * (1e9 / kTicksPerSec);
   }

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/util/pb_util-internal.h
----------------------------------------------------------------------
diff --git a/src/kudu/util/pb_util-internal.h b/src/kudu/util/pb_util-internal.h
index b148166..48a501d 100644
--- a/src/kudu/util/pb_util-internal.h
+++ b/src/kudu/util/pb_util-internal.h
@@ -61,7 +61,7 @@ class SequentialFileFileInputStream : public google::protobuf::io::ZeroCopyInput
     total_read_ -= count;
   }
 
-  int64 ByteCount() const OVERRIDE {
+  int64_t ByteCount() const OVERRIDE {
     return total_read_;
   }
 
@@ -113,7 +113,7 @@ class WritableFileOutputStream : public google::protobuf::io::ZeroCopyOutputStre
     buffer_offset_ -= count;
   }
 
-  int64 ByteCount() const OVERRIDE {
+  int64_t ByteCount() const OVERRIDE {
     return flushed_ + buffer_offset_;
   }
 

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/util/spinlock_profiling.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/spinlock_profiling.cc b/src/kudu/util/spinlock_profiling.cc
index 8e639ac..b6abf59 100644
--- a/src/kudu/util/spinlock_profiling.cc
+++ b/src/kudu/util/spinlock_profiling.cc
@@ -26,7 +26,6 @@
 #include "kudu/gutil/atomicops.h"
 #include "kudu/gutil/bind.h"
 #include "kudu/gutil/casts.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/macros.h"
 #include "kudu/gutil/once.h"
 #include "kudu/gutil/port.h"
@@ -231,7 +230,7 @@ bool ContentionStacks::CollectSample(uint64_t* iterator, StackTrace* s,
int64_t*
 }
 
 
-void SubmitSpinLockProfileData(const void *contendedlock, int64 wait_cycles) {
+void SubmitSpinLockProfileData(const void *contendedlock, int64_t wait_cycles) {
   TRACE_COUNTER_INCREMENT("spinlock_wait_cycles", wait_cycles);
   bool profiling_enabled = base::subtle::Acquire_Load(&g_profiling_enabled);
   bool long_wait_time = wait_cycles > FLAGS_lock_contention_trace_threshold_cycles;
@@ -332,7 +331,7 @@ void StopSynchronizationProfiling() {
 // The hook expected by gutil is in the gutil namespace. Simply forward into the
 // kudu namespace so we don't need to qualify everything.
 namespace gutil {
-void SubmitSpinLockProfileData(const void *contendedlock, int64 wait_cycles) {
+void SubmitSpinLockProfileData(const void *contendedlock, int64_t wait_cycles) {
   kudu::SubmitSpinLockProfileData(contendedlock, wait_cycles);
 }
 } // namespace gutil
@@ -343,7 +342,7 @@ void SubmitSpinLockProfileData(const void *contendedlock, int64 wait_cycles)
{
 // we risk a deadlock. So, this implementation just does the bare minimum to expose
 // tcmalloc contention.
 namespace base {
-void SubmitSpinLockProfileData(const void* contendedlock, int64 wait_cycles) {
+void SubmitSpinLockProfileData(const void* /* contendedlock */, int64_t wait_cycles) {
 #if !defined(__APPLE__)
   auto t = kudu::Trace::CurrentTrace();
   if (t) {

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/util/test_util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/test_util.cc b/src/kudu/util/test_util.cc
index 7ffbe84..e5d2a4b 100644
--- a/src/kudu/util/test_util.cc
+++ b/src/kudu/util/test_util.cc
@@ -33,7 +33,6 @@
 #include <glog/logging.h>
 #include <gtest/gtest-spi.h>
 
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/strings/numbers.h"
 #include "kudu/gutil/strings/split.h"
 #include "kudu/gutil/strings/strcat.h"
@@ -64,7 +63,7 @@ namespace kudu {
 const char* kInvalidPath = "/dev/invalid-path-for-kudu-tests";
 static const char* const kSlowTestsEnvVariable = "KUDU_ALLOW_SLOW_TESTS";
 
-static const uint64 kTestBeganAtMicros = Env::Default()->NowMicros();
+static const uint64_t kTestBeganAtMicros = Env::Default()->NowMicros();
 
 // Global which production code can check to see if it is running
 // in a GTest environment (assuming the test binary links in this module,

http://git-wip-us.apache.org/repos/asf/kudu/blob/5c8a8a2a/src/kudu/util/thread.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/thread.cc b/src/kudu/util/thread.cc
index 9bcb71f..c4b651b 100644
--- a/src/kudu/util/thread.cc
+++ b/src/kudu/util/thread.cc
@@ -43,7 +43,6 @@
 #include "kudu/gutil/bind.h"
 #include "kudu/gutil/bind_helpers.h"
 #include "kudu/gutil/dynamic_annotations.h"
-#include "kudu/gutil/integral_types.h"
 #include "kudu/gutil/mathlimits.h"
 #include "kudu/gutil/once.h"
 #include "kudu/gutil/strings/substitute.h"
@@ -160,7 +159,7 @@ class ThreadMgr {
     thread_categories_.clear();
   }
 
-  static void SetThreadName(const std::string& name, int64 tid);
+  static void SetThreadName(const std::string& name, int64_t tid);
 
   Status StartInstrumentation(const scoped_refptr<MetricEntity>& metrics, WebCallbackRegistry*
web);
 
@@ -226,7 +225,7 @@ class ThreadMgr {
   void PrintThreadCategoryRows(const ThreadCategory& category, ostringstream* output);
 };
 
-void ThreadMgr::SetThreadName(const string& name, int64 tid) {
+void ThreadMgr::SetThreadName(const string& name, int64_t tid) {
   // On linux we can get the thread names to show up in the debugger by setting
   // the process name for the LWP.  We don't want to do this for the main
   // thread because that would rename the process, causing tools like killall


Mime
View raw message