Enabling c++20 on linux

cmake/CMakeLists.txt

@@ -32,7 +32,7 @@ include(CheckFunctionExists)
 include(GNUInstallDirs) # onnxruntime_providers_* require CMAKE_INSTALL_* variables
 
 # TODO: update this once all system adapt c++20
-if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+if(UNIX)
 set(CMAKE_CXX_STANDARD 20)
 else()
 set(CMAKE_CXX_STANDARD 17)

include/onnxruntime/core/common/eigen_common_wrapper.h

@@ -10,6 +10,7 @@
 // error: ignoring attributes on template argument "Eigen::PacketType<const float, Eigen::DefaultDevice>::type {aka __vector(4) float}" [-Werror=ignored-attributes]
 #if defined(__GNUC__)
 #pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated"
 #if __GNUC__ >= 6
 #pragma GCC diagnostic ignored "-Wignored-attributes"
 #endif

include/onnxruntime/core/common/logging/logging.h

@@ -85,7 +85,7 @@ using Timestamp = std::chrono::time_point<std::chrono::system_clock>;
 #endif
 #endif  // __APPLE__
 
-#if ORT_USE_CXX20_STD_CHRONO
+#if ORT_USE_CXX20_STD_CHRONO || defined(__linux__)
 namespace timestamp_ns = std::chrono;
 #else
 namespace timestamp_ns = ::date;

onnxruntime/contrib_ops/cpu/bert/embed_layer_norm.cc

@@ -92,7 +92,36 @@ Status EmbedLayerNorm<T>::Compute(OpKernelContext* context) const {
     const float epsilon_value = epsilon();
 
     concurrency::ThreadPool::TryBatchParallelFor(
+#if __cplusplus >= 202002L
+        context->GetOperatorThreadPool(), n,
+    [input_ids_data,
+     word_embedding_length,
+     sequence_length,
+     position_ids_data,
+     broadcast_position_ids,
+     position_embedding_data,
+     word_embedding_data,
+     segment_ids_data,
+     segment_embedding_data,
+     position_embedding_length,
+     segment_embedding_length,
+     output_data,
+     embedding_sum_data,
+     gamma_data,
+     beta_data,
+     epsilon_value,
+     hidden_size,
+     &failed](ptrdiff_t index) {
+#else
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated"
+#endif
         context->GetOperatorThreadPool(), n, [=, &failed](ptrdiff_t index) {
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+#endif
           int word_col_index = input_ids_data[index];
           if (word_col_index < 0 || word_col_index >= word_embedding_length) {
             failed.store(true, std::memory_order_release);

onnxruntime/core/common/logging/sinks/ostream_sink.cc

@@ -33,7 +33,11 @@ void OStreamSink::SendImpl(const Timestamp& timestamp, const std::string& logger
   // Going with #2 as it should scale better at the cost of creating the message in memory first
   // before sending to the stream.
 
+#ifdef _WIN32
+  std::wostringstream msg;
+#else
   std::ostringstream msg;
+#endif
 
 #ifndef ORT_MINIMAL_BUILD
   if (message.Severity() == Severity::kWARNING) {

onnxruntime/core/providers/cpu/ml/tree_ensemble_aggregator.h

@@ -136,7 +136,7 @@ struct TreeNodeElement {
 
   inline NODE_MODE_ORT mode() const { return NODE_MODE_ORT(flags & 0xF); }
   inline bool is_not_leaf() const { return !(flags & NODE_MODE_ORT::LEAF); }
-  inline bool is_missing_track_true() const { return flags & MissingTrack::kTrue; }
+  inline bool is_missing_track_true() const { return static_cast<int>(flags) & static_cast<int>(MissingTrack::kTrue);}
 };
 
 template <typename InputType, typename ThresholdType, typename OutputType>

onnxruntime/core/providers/cpu/text/string_normalizer.cc

@@ -221,7 +221,14 @@ class Utf8ConverterGeneric {
   }
 
  private:
+#if __cplusplus >= 202002L
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
   std::codecvt_utf8<wchar_t> converter_;
+#if __cplusplus >= 202002L
+#pragma GCC diagnostic pop
+#endif
 };
 
 // We need to specialize for MS as there is

onnxruntime/core/providers/cuda/math/topk_impl.cuh

@@ -421,7 +421,7 @@ Status TopKImpl(const CudaKernel* kernel, bool use_deterministic_compute,
       });
     }
 
-    auto XPT = static_cast<int64_t>(ceil(static_cast<double>(dimension) / GridDim::maxThreadsPerBlock));
+    auto XPT = static_cast<int64_t>(ceil(static_cast<double>(dimension) / static_cast<double>(GridDim::maxThreadsPerBlock)));
     if (BT * 2 >= K || 0 == sorted) {
       RadixTopK<CudaT, BT, 2><<<N, BT, 256 * sizeof(uint32_t), stream>>>(
           input_x_ptr, output_v_ptr, output_i, elem_nums, size, axis, K, largest, sorted, dimension, XPT,
@@ -452,8 +452,8 @@ Status TopKImpl(const CudaKernel* kernel, bool use_deterministic_compute,
     CUDA_RETURN_IF_ERROR(cub::DeviceRadixSort::SortPairs(nullptr, temp_bytes, input_key, output_key, input_value, output_value, dimension, 0, sizeof(T) * 8, stream));
     auto temp_storage_buffer = kernel->GetScratchBuffer<char>(temp_bytes, ort_stream);
     auto* temp_storage = temp_storage_buffer.get();
-    auto blocks_per_grid_D = (int)(ceil(static_cast<float>(dimension) / BT));
-    auto blocks_per_grid_K = (int)(ceil(static_cast<float>(K) / BT));
+    auto blocks_per_grid_D = (int)(ceil(static_cast<float>(dimension) / static_cast<float>(BT)));
+    auto blocks_per_grid_K = (int)(ceil(static_cast<float>(K) / static_cast<float>(BT)));
     for (int64_t i = 0; i < N; i++) {
       FillInput<CudaT><<<blocks_per_grid_D, BT, 0, stream>>>(input_x_ptr, input_key, input_value, elem_nums, size, axis, K, i, dimension);
       CUDA_RETURN_IF_ERROR(1 == largest ? cub::DeviceRadixSort::SortPairsDescending(temp_storage, temp_bytes, input_key, output_key, input_value, output_value, dimension, 0, sizeof(T) * 8, stream)

onnxruntime/core/providers/migraphx/migraphx_execution_provider.cc

@@ -1217,7 +1217,7 @@ Status MIGraphXExecutionProvider::Compile(const std::vector<FusedNodeAndGraph>&
     map_input_index_[fused_node.Name()] = input_name_index;
     map_no_input_shape_[fused_node.Name()] = no_input_shape;
     NodeComputeInfo compute_info;
-    compute_info.create_state_func = [=](ComputeContext* context, FunctionState* state) {
+    compute_info.create_state_func = [=,this](ComputeContext* context, FunctionState* state) {
       std::unique_ptr<MIGraphXFuncState> p = std::make_unique<MIGraphXFuncState>();
       *p = {context->allocate_func, context->release_func, context->allocator_handle, map_progs_[context->node_name],
             map_onnx_string_[context->node_name], options, t_, map_input_index_[context->node_name], &mgx_mu_,

onnxruntime/core/providers/tensorrt/tensorrt_execution_provider.cc

@@ -3510,7 +3510,7 @@ Status TensorrtExecutionProvider::CreateNodeComputeInfoFromGraph(const GraphView
   // Create function state
   // TODO: remove default capture
   NodeComputeInfo compute_info;
-  compute_info.create_state_func = [=](ComputeContext* context, FunctionState* state) {
+  compute_info.create_state_func = [=, this](ComputeContext* context, FunctionState* state) {
     std::unique_ptr<TensorrtFuncState> p = std::make_unique<TensorrtFuncState>();
     // translate tactic sources string to nvinfer1::TacticSources
     nvinfer1::TacticSources tactics = 0;
@@ -3537,7 +3537,7 @@ Status TensorrtExecutionProvider::CreateNodeComputeInfoFromGraph(const GraphView
   };
 
   // Create compute function
-  compute_info.compute_func = [this](FunctionState state, const OrtApi* api, OrtKernelContext* context) {
+  compute_info.compute_func = [=, this](FunctionState state, const OrtApi* api, OrtKernelContext* context) {
     // The GPU device is set again here to handle multithreading scenarios.
     // Consider the following:
     // Users can create multiple threads to initialize separate inference sessions on different devices (not just the default device 0)
@@ -4197,7 +4197,7 @@ Status TensorrtExecutionProvider::CreateNodeComputeInfoFromPrecompiledEngine(con
   // Create function state
   // TODO: remove default capture
   NodeComputeInfo compute_info;
-  compute_info.create_state_func = [=](ComputeContext* context, FunctionState* state) {
+  compute_info.create_state_func = [=, this](ComputeContext* context, FunctionState* state) {
     std::unique_ptr<TensorrtShortFuncState> p = std::make_unique<TensorrtShortFuncState>();
     *p = {context->allocate_func,
           context->release_func,
@@ -4220,7 +4220,7 @@ Status TensorrtExecutionProvider::CreateNodeComputeInfoFromPrecompiledEngine(con
   };
 
   // Create compute function
-  compute_info.compute_func = [this](FunctionState state, const OrtApi* api, OrtKernelContext* context) {
+  compute_info.compute_func = [=, this](FunctionState state, const OrtApi* api, OrtKernelContext* context) {
     // The GPU device is set again here to handle multithreading scenarios.
     // Consider the following:
     // Users can create multiple threads to initialize separate inference sessions on different devices (not just the default device 0)

onnxruntime/test/onnx/microbenchmark/eigen.cc

@@ -8,6 +8,7 @@
 #pragma GCC diagnostic ignored "-Wunused-parameter"
 #pragma GCC diagnostic ignored "-Wunused-result"
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#pragma GCC diagnostic ignored "-Wdeprecated"
 
 // _deps/eigen-src/unsupported/Eigen/CXX11/../../../Eigen/src/Core/arch/NEON/PacketMath.h:1671:9:
 // error: ‘void* memcpy(void*, const void*, size_t)’ copying an object of non-trivial type ‘Eigen::internal::Packet4c’

onnxruntime/test/onnx/microbenchmark/tptest.cc

@@ -102,7 +102,14 @@ static void BM_ThreadPoolSimpleParallelFor(benchmark::State& state) {
   for (auto _ : state) {
     for (int j = 0; j < 100; j++) {
       ThreadPool::TrySimpleParallelFor(tp.get(), len, [&](size_t) {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvolatile"
         for (volatile size_t x = 0; x < body; x++) {
+#pragma GCC diagnostic pop
+#else
+		for (volatile size_t x = 0; x < body; x++) {
+#endif
         }
       });
     }