mirror of
https://github.com/saymrwulf/onnxruntime.git
synced 2026-07-04 04:07:22 +00:00
Set CMAKE_CUDA_STANDARD to 14 because we are using std::make_unique (#7534)
This commit is contained in:
Changming Sun
GitHub
parent
93e93d0851
commit
00882ce495
2 changed files with 1 additions and 153 deletions
|
|
@ -1367,11 +1367,7 @@ if (onnxruntime_USE_CUDA)
|
|||
enable_language(CUDA)
|
||||
message( STATUS "CMAKE_CUDA_COMPILER_VERSION: ${CMAKE_CUDA_COMPILER_VERSION}")
|
||||
|
||||
if (CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 11)
|
||||
set(CMAKE_CUDA_STANDARD 14)
|
||||
else()
|
||||
set(CMAKE_CUDA_STANDARD 11)
|
||||
endif()
|
||||
set(CMAKE_CUDA_STANDARD 14)
|
||||
file(TO_CMAKE_PATH ${onnxruntime_CUDNN_HOME} onnxruntime_CUDNN_HOME)
|
||||
set(ONNXRUNTIME_CUDA_LIBRARIES ${CUDA_LIBRARIES})
|
||||
|
||||
|
|
|
|||
|
|
@ -1,148 +0,0 @@
|
|||
// Copyright 2017 The Abseil Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
// -----------------------------------------------------------------------------
|
||||
// File: make_unique.h
|
||||
// -----------------------------------------------------------------------------
|
||||
//
|
||||
// This header file contains utility functions for managing the creation and
|
||||
// conversion of smart pointers. This file is an extension to the C++
|
||||
// standard <memory> library header file.
|
||||
/* Modifications Copyright (c) Microsoft. */
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstddef>
|
||||
#include <limits>
|
||||
#include <memory>
|
||||
#include <new>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
namespace onnxruntime {
|
||||
|
||||
template <typename T>
|
||||
using remove_extent_t = typename std::remove_extent<T>::type;
|
||||
|
||||
namespace memory_internal {
|
||||
|
||||
// Traits to select proper overload and return type for `absl::make_unique<>`.
|
||||
template <typename T>
|
||||
struct MakeUniqueResult {
|
||||
using scalar = std::unique_ptr<T>;
|
||||
};
|
||||
template <typename T>
|
||||
struct MakeUniqueResult<T[]> {
|
||||
using array = std::unique_ptr<T[]>;
|
||||
};
|
||||
template <typename T, size_t N>
|
||||
struct MakeUniqueResult<T[N]> {
|
||||
using invalid = void;
|
||||
};
|
||||
|
||||
} // namespace memory_internal
|
||||
|
||||
// gcc 4.8 has __cplusplus at 201301 but doesn't define make_unique. Other
|
||||
// supported compilers either just define __cplusplus as 201103 but have
|
||||
// make_unique (msvc), or have make_unique whenever __cplusplus > 201103 (clang)
|
||||
#if (__cplusplus > 201103L || defined(_MSC_VER)) && \
|
||||
!(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 8)
|
||||
using std::make_unique;
|
||||
#else
|
||||
// -----------------------------------------------------------------------------
|
||||
// Function Template: make_unique<T>()
|
||||
// -----------------------------------------------------------------------------
|
||||
//
|
||||
// Creates a `std::unique_ptr<>`, while avoiding issues creating temporaries
|
||||
// during the construction process. `absl::make_unique<>` also avoids redundant
|
||||
// type declarations, by avoiding the need to explicitly use the `new` operator.
|
||||
//
|
||||
// This implementation of `absl::make_unique<>` is designed for C++11 code and
|
||||
// will be replaced in C++14 by the equivalent `std::make_unique<>` abstraction.
|
||||
// `absl::make_unique<>` is designed to be 100% compatible with
|
||||
// `std::make_unique<>` so that the eventual migration will involve a simple
|
||||
// rename operation.
|
||||
//
|
||||
// For more background on why `std::unique_ptr<T>(new T(a,b))` is problematic,
|
||||
// see Herb Sutter's explanation on
|
||||
// (Exception-Safe Function Calls)[https://herbsutter.com/gotw/_102/].
|
||||
// (In general, reviewers should treat `new T(a,b)` with scrutiny.)
|
||||
//
|
||||
// Example usage:
|
||||
//
|
||||
// auto p = make_unique<X>(args...); // 'p' is a std::unique_ptr<X>
|
||||
// auto pa = make_unique<X[]>(5); // 'pa' is a std::unique_ptr<X[]>
|
||||
//
|
||||
// Three overloads of `absl::make_unique` are required:
|
||||
//
|
||||
// - For non-array T:
|
||||
//
|
||||
// Allocates a T with `new T(std::forward<Args> args...)`,
|
||||
// forwarding all `args` to T's constructor.
|
||||
// Returns a `std::unique_ptr<T>` owning that object.
|
||||
//
|
||||
// - For an array of unknown bounds T[]:
|
||||
//
|
||||
// `absl::make_unique<>` will allocate an array T of type U[] with
|
||||
// `new U[n]()` and return a `std::unique_ptr<U[]>` owning that array.
|
||||
//
|
||||
// Note that 'U[n]()' is different from 'U[n]', and elements will be
|
||||
// value-initialized. Note as well that `std::unique_ptr` will perform its
|
||||
// own destruction of the array elements upon leaving scope, even though
|
||||
// the array [] does not have a default destructor.
|
||||
//
|
||||
// NOTE: an array of unknown bounds T[] may still be (and often will be)
|
||||
// initialized to have a size, and will still use this overload. E.g:
|
||||
//
|
||||
// auto my_array = absl::make_unique<int[]>(10);
|
||||
//
|
||||
// - For an array of known bounds T[N]:
|
||||
//
|
||||
// `absl::make_unique<>` is deleted (like with `std::make_unique<>`) as
|
||||
// this overload is not useful.
|
||||
//
|
||||
// NOTE: an array of known bounds T[N] is not considered a useful
|
||||
// construction, and may cause undefined behavior in templates. E.g:
|
||||
//
|
||||
// auto my_array = absl::make_unique<int[10]>();
|
||||
//
|
||||
// In those cases, of course, you can still use the overload above and
|
||||
// simply initialize it to its desired size:
|
||||
//
|
||||
// auto my_array = absl::make_unique<int[]>(10);
|
||||
|
||||
// `absl::make_unique` overload for non-array types.
|
||||
template <typename T, typename... Args>
|
||||
typename memory_internal::MakeUniqueResult<T>::scalar make_unique(
|
||||
Args&&... args) {
|
||||
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
|
||||
}
|
||||
|
||||
// `absl::make_unique` overload for an array T[] of unknown bounds.
|
||||
// The array allocation needs to use the `new T[size]` form and cannot take
|
||||
// element constructor arguments. The `std::unique_ptr` will manage destructing
|
||||
// these array elements.
|
||||
template <typename T>
|
||||
typename memory_internal::MakeUniqueResult<T>::array make_unique(size_t n) {
|
||||
return std::unique_ptr<T>(new typename onnxruntime::remove_extent_t<T>[n]());
|
||||
}
|
||||
|
||||
// `absl::make_unique` overload for an array T[N] of known bounds.
|
||||
// This construction will be rejected.
|
||||
template <typename T, typename... Args>
|
||||
typename memory_internal::MakeUniqueResult<T>::invalid make_unique(
|
||||
Args&&... /* args */) = delete;
|
||||
#endif
|
||||
|
||||
}
|
||||
Loading…
Reference in a new issue