Fixes C++ platform incompatibilities.

PiperOrigin-RevId: 423905712
Change-Id: Ifa43c14799dfcd47434bef936a06c107f4d0fce3

Author: Johannes Ballé

tensorflow_compression/cc/BUILD

@@ -7,11 +7,13 @@ cc_binary(
             "**/*.h",
             "**/*.cc",
         ],
-        exclude = ["**/*_test.cc"],
+        exclude = [
+            "**/*_test.cc",
+        ],
     ),
     copts = [
         "-pthread",
-        "-std=c++11",
+        "-std=c++14",
         "-D_GLIBCXX_USE_CXX11_ABI=0",
     ],
     linkshared = 1,

tensorflow_compression/cc/kernels/range_coder_kernels.cc

@@ -19,8 +19,6 @@ limitations under the License.
 #include <string>
 #include <utility>
 
-#include "absl/base/integral_types.h"
-#include "tensorflow_compression/cc/lib/range_coder.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/substitute.h"
 #include "absl/types/span.h"
@@ -36,6 +34,7 @@ limitations under the License.
 #include "tensorflow/core/framework/variant_tensor_data.h"
 #include "tensorflow/core/lib/core/errors.h"
 #include "tensorflow/core/lib/core/threadpool.h"
+#include "tensorflow_compression/cc/lib/range_coder.h"
 
 namespace tensorflow_compression {
 namespace {
@@ -367,11 +366,12 @@ class EntropyEncodeChannelOp : public tensorflow::OpKernel {
     tensorflow::thread::ThreadPool* workers =
         context->device()->tensorflow_cpu_worker_threads()->workers;
     tensorflow::mutex mu;
-    workers->ParallelFor(
-        handle.size(), cost_per_unit,
-        [&handle, &mu, context, value, index_stride](int64 start, int64 limit) {
-          PerShard(handle, value, index_stride, context, &mu, start, limit);
-        });
+    workers->ParallelFor(handle.size(), cost_per_unit,
+                         [&handle, &mu, context, value, index_stride](
+                             int64_t start, int64_t limit) {
+                           PerShard(handle, value, index_stride, context, &mu,
+                                    start, limit);
+                         });
 
     context->set_output(0, handle_tensor);
   }
@@ -382,19 +382,17 @@ class EntropyEncodeChannelOp : public tensorflow::OpKernel {
                        const int64_t index_stride,
                        tensorflow::OpKernelContext* context,
                        tensorflow::mutex* mu, int64_t start, int64_t limit) {
-#define REQUIRES_OK(status)                             \
-  if (auto s = (status); ABSL_PREDICT_FALSE(!s.ok())) { \
-    tensorflow::mutex_lock lock(*mu);                   \
-    context->SetStatus(s);                              \
-    return;                                             \
-  }
-
 #define REQUIRES(cond, status)        \
   if (!ABSL_PREDICT_TRUE(cond)) {     \
     tensorflow::mutex_lock lock(*mu); \
     context->SetStatus(status);       \
     return;                           \
   }
+#define REQUIRES_OK(status)           \
+  {                                   \
+    auto s = (status);                \
+    REQUIRES(s.ok(), s);              \
+  }
 
     const int64_t num_elements = value.dimension(1);
     auto* p_value = &value(start, 0);
@@ -467,7 +465,7 @@ class EntropyEncodeIndexOp : public tensorflow::OpKernel {
     tensorflow::mutex mu;
     workers->ParallelFor(
         handle.size(), cost_per_unit,
-        [&handle, &mu, context, value, index](int64 start, int64 limit) {
+        [&handle, &mu, context, value, index](int64_t start, int64_t limit) {
           PerShard(handle, index, value, context, &mu, start, limit);
         });
 
@@ -480,19 +478,17 @@ class EntropyEncodeIndexOp : public tensorflow::OpKernel {
                        TTypes<int32_t>::ConstMatrix value,
                        tensorflow::OpKernelContext* context,
                        tensorflow::mutex* mu, int64_t start, int64_t limit) {
-#define REQUIRES_OK(status)                             \
-  if (auto s = (status); ABSL_PREDICT_FALSE(!s.ok())) { \
-    tensorflow::mutex_lock lock(*mu);                   \
-    context->SetStatus(s);                              \
-    return;                                             \
-  }
-
 #define REQUIRES(cond, status)        \
   if (!ABSL_PREDICT_TRUE(cond)) {     \
     tensorflow::mutex_lock lock(*mu); \
     context->SetStatus(status);       \
     return;                           \
   }
+#define REQUIRES_OK(status)           \
+  {                                   \
+    auto s = (status);                \
+    REQUIRES(s.ok(), s);              \
+  }
 
     const int64_t num_elements = value.dimension(1);
     const int32_t* p_value = &value(start, 0);
@@ -621,7 +617,7 @@ class EntropyDecodeChannelOp : public tensorflow::OpKernel {
     tensorflow::mutex mu;
     workers->ParallelFor(handle.size(), cost_per_unit,
                          [&handle, &mu, context, index_stride, &output](
-                             int64 start, int64 limit) {
+                             int64_t start, int64_t limit) {
                            PerShard(handle, index_stride, output, context, &mu,
                                     start, limit);
                          });
@@ -634,19 +630,17 @@ class EntropyDecodeChannelOp : public tensorflow::OpKernel {
                        TTypes<int32_t>::Matrix output,
                        tensorflow::OpKernelContext* context,
                        tensorflow::mutex* mu, int64_t start, int64_t limit) {
-#define REQUIRES_OK(status)                             \
-  if (auto s = (status); ABSL_PREDICT_FALSE(!s.ok())) { \
-    tensorflow::mutex_lock lock(*mu);                   \
-    context->SetStatus(s);                              \
-    return;                                             \
-  }
-
 #define REQUIRES(cond, status)        \
   if (!ABSL_PREDICT_TRUE(cond)) {     \
     tensorflow::mutex_lock lock(*mu); \
     context->SetStatus(status);       \
     return;                           \
   }
+#define REQUIRES_OK(status)           \
+  {                                   \
+    auto s = (status);                \
+    REQUIRES(s.ok(), s);              \
+  }
 
     const int64_t num_elements = output.dimension(1);
     auto* p_output = &output(start, 0);
@@ -723,7 +717,7 @@ class EntropyDecodeIndexOp : public tensorflow::OpKernel {
     tensorflow::mutex mu;
     workers->ParallelFor(
         handle.size(), cost_per_unit,
-        [&handle, &mu, context, index, &output](int64 start, int64 limit) {
+        [&handle, &mu, context, index, &output](int64_t start, int64_t limit) {
           PerShard(handle, index, output, context, &mu, start, limit);
         });
 
@@ -736,19 +730,17 @@ class EntropyDecodeIndexOp : public tensorflow::OpKernel {
                        TTypes<int32_t>::Matrix output,
                        tensorflow::OpKernelContext* context,
                        tensorflow::mutex* mu, int64_t start, int64_t limit) {
-#define REQUIRES_OK(status)                             \
-  if (auto s = (status); ABSL_PREDICT_FALSE(!s.ok())) { \
-    tensorflow::mutex_lock lock(*mu);                   \
-    context->SetStatus(s);                              \
-    return;                                             \
-  }
-
 #define REQUIRES(cond, status)        \
   if (!ABSL_PREDICT_TRUE(cond)) {     \
     tensorflow::mutex_lock lock(*mu); \
     context->SetStatus(status);       \
     return;                           \
   }
+#define REQUIRES_OK(status)           \
+  {                                   \
+    auto s = (status);                \
+    REQUIRES(s.ok(), s);              \
+  }
 
     const int64_t num_elements = output.dimension(1);
     const int32_t* p_index = &index(start, 0);

tensorflow_compression/cc/kernels/range_coder_kernels.h

@@ -19,7 +19,6 @@ limitations under the License.
 #include <cstdint>
 #include <string>
 
-#include "absl/base/integral_types.h"
 #include "absl/types/span.h"
 #include "tensorflow/core/framework/tensor.h"
 #include "tensorflow/core/framework/tensor_types.h"

tensorflow_compression/cc/lib/range_coder.cc

@@ -19,19 +19,20 @@ limitations under the License.
 // a digitised message", presented to the Video & Data Recording Conference,
 // held in Southampton, July 24-27, 1979.
 //
+
 #include "tensorflow_compression/cc/lib/range_coder.h"
 
 #include <cstdint>
 #include <limits>
 #include <string>
 
-#include "absl/base/integral_types.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 #include "tensorflow/core/platform/logging.h"
 
 namespace tensorflow_compression {
+
 void RangeEncoder::Encode(int32_t lower, int32_t upper, int precision,
                           std::string* sink) {
   // Input requirement: 0 <= lower < upper <= 2^precision.
@@ -364,7 +365,7 @@ absl::Status RangeDecoder::CheckForErrorInternal(absl::Span<const T> cdf,
 }
 
 template absl::Status RangeDecoder::CheckForErrorInternal(
-    absl::Span<const int16>, int, bool) const;
+    absl::Span<const int16_t>, int, bool) const;
 template absl::Status RangeDecoder::CheckForErrorInternal(
-    absl::Span<const int32>, int, bool) const;
+    absl::Span<const int32_t>, int, bool) const;
 }  // namespace tensorflow_compression

tensorflow_compression/cc/lib/range_coder.h

@@ -21,13 +21,13 @@ limitations under the License.
 #include <string>
 #include <type_traits>
 
-#include "absl/base/integral_types.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 #include "tensorflow/core/platform/logging.h"
 
 namespace tensorflow_compression {
+
 class RangeEncoder {
  public:
   RangeEncoder() = default;
@@ -196,7 +196,7 @@ class RangeDecoder {
     static const T* Search(uint64_t lower_bound, uint64_t size, const T* pv,
                            int64_t len) {
       return std::find_if(pv, pv + len, [lower_bound, size](T value) {
-        return lower_bound <= size * static_cast<uint64>(value);
+        return lower_bound <= size * static_cast<uint64_t>(value);
       });
     }
   };