You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tvm.apache.org by an...@apache.org on 2022/09/16 22:47:41 UTC
[tvm] 17/20: session optional
This is an automated email from the ASF dual-hosted git repository.
andrewzhaoluo pushed a commit to branch aluo/rebase-08312022-autotensorization-fq2i-changes
in repository https://gitbox.apache.org/repos/asf/tvm.git
commit 0def3b736c0fa037afc75259c24abe0c43895228
Author: Andrew Zhao Luo <an...@gmail.com>
AuthorDate: Fri Sep 2 15:18:13 2022 -0700
session optional
---
src/runtime/hexagon/rpc/simulator/session.cc | 113 ++++++++++++++++-----------
1 file changed, 68 insertions(+), 45 deletions(-)
diff --git a/src/runtime/hexagon/rpc/simulator/session.cc b/src/runtime/hexagon/rpc/simulator/session.cc
index 8943c0b4bf..0469ad5e6e 100644
--- a/src/runtime/hexagon/rpc/simulator/session.cc
+++ b/src/runtime/hexagon/rpc/simulator/session.cc
@@ -18,6 +18,7 @@
*/
#include <HexagonWrapper.h>
+#include <dmlc/optional.h>
#include <tvm/runtime/packed_func.h>
#include <tvm/runtime/registry.h>
// POSIX includes
@@ -30,7 +31,6 @@
#include <iterator>
#include <map>
#include <memory>
-#include <optional>
#include <sstream>
#include <string>
#include <utility>
@@ -55,6 +55,19 @@ using string_list = std::deque<std::string>;
namespace detail {
+// An "Optional" class, originally a replacement for llvm::Optional, then an
+// extension of dmlc::optional to make it compatible with C++17's std::optional.
+template <typename T>
+struct Optional : public dmlc::optional<T> {
+ using dmlc::optional<T>::optional;
+ using dmlc::optional<T>::operator=;
+ Optional(const T& val) : dmlc::optional<T>(val) {} // NOLINT(*)
+ Optional() = default;
+
+ T* operator->() { return &this->operator*(); }
+ const T* operator->() const { return &this->operator*(); }
+};
+
// Replacement for llvm::StringSwitch.
template <typename T>
class StringSwitch {
@@ -81,10 +94,10 @@ class StringSwitch {
private:
const std::string key;
std::map<std::string, T> map;
- std::optional<T> def_val;
+ Optional<T> def_val;
};
-using MaybeString = std::optional<std::string>;
+using MaybeString = Optional<std::string>;
MaybeString front(const string_list& deq) {
return !deq.empty() ? MaybeString(deq.front()) : MaybeString();
@@ -99,60 +112,65 @@ MaybeString pop_front(string_list& deq) { // NOLINT(*)
// Functions used when parsing the argument string.
-std::optional<int64_t> to_int(const MaybeString& str) {
+Optional<int64_t> to_int(const MaybeString& str) {
+ auto none = Optional<int64_t>();
if (str.has_value()) {
try {
size_t pos;
int64_t val = std::stoll(*str, &pos, 0);
- return pos == str->size() ? std::optional<int64_t>(val) : std::nullopt;
+ return pos == str->size() ? Optional<int64_t>(val) : none;
} catch (std::invalid_argument&) {
}
}
- return std::nullopt;
+ return none;
}
-std::optional<uint64_t> to_uint(const MaybeString& str) {
+Optional<uint64_t> to_uint(const MaybeString& str) {
+ auto none = Optional<uint64_t>();
if (str.has_value()) {
try {
size_t pos;
uint64_t val = std::stoull(*str, &pos, 0);
- return pos == str->size() ? std::optional<uint64_t>(val) : std::nullopt;
+ return pos == str->size() ? Optional<uint64_t>(val) : none;
} catch (std::invalid_argument&) {
}
}
- return std::nullopt;
+ return none;
}
-std::optional<float> to_float(const MaybeString& str) {
+Optional<float> to_float(const MaybeString& str) {
+ auto none = Optional<float>();
if (str.has_value()) {
try {
size_t pos;
float val = std::stof(*str, &pos);
- return pos == str->size() ? std::optional<float>(val) : std::nullopt;
+ return pos == str->size() ? Optional<float>(val) : none;
} catch (std::invalid_argument&) {
}
}
- return std::nullopt;
+ return none;
}
-std::optional<bool> to_bool(const MaybeString& str) {
+Optional<bool> to_bool(const MaybeString& str) {
+ auto none = Optional<bool>();
if (auto num = to_int(str)) {
if (*num == 0) return false;
if (*num == 1) return true;
- return std::nullopt;
+ return none;
}
if (str) {
if (*str == "true" || *str == "TRUE") return true;
if (*str == "false" || *str == "FALSE") return false;
}
- return std::nullopt;
+ return none;
}
template <typename T>
-using MaybeRange = std::optional<std::pair<T, T>>;
+using MaybeRange = Optional<std::pair<T, T>>;
-template <typename T, std::optional<T> Parse(const MaybeString&)>
+template <typename T, Optional<T> Parse(const MaybeString&)>
MaybeRange<T> to_range(const MaybeString& str) {
+ auto none = MaybeRange<T>();
if (str && !str->empty()) {
auto n = str->find('-', 1);
if (n != std::string::npos) {
@@ -163,7 +181,7 @@ MaybeRange<T> to_range(const MaybeString& str) {
}
}
}
- return std::nullopt;
+ return none;
}
} // namespace detail
@@ -209,7 +227,7 @@ class SimulatorRPCChannel final : public RPCChannel {
static HEX_8u_t PassVirtAddrCallback(void* handle, int threadno, HEX_8u_t RssV, HEX_8u_t RttV,
HEX_8u_t RxxV, HEX_1u_t imm);
- std::optional<HEXAPI_Cpu> GetCPU(const detail::MaybeString& cpu_str);
+ detail::Optional<HEXAPI_Cpu> GetCPU(const detail::MaybeString& cpu_str);
// File name templates for mkstemps.
#define SUFFIX ".cfg"
@@ -288,17 +306,17 @@ class SimulatorRPCChannel final : public RPCChannel {
bool HandleV2PTranslation(string_list& rest); // NOLINT(*)
bool HandleVerbose(string_list& rest); // NOLINT(*)
- using MaybeUInt64 = std::optional<uint64_t>;
+ using MaybeUInt64 = detail::Optional<uint64_t>;
using MaybeUIntRange = std::pair<MaybeUInt64, MaybeUInt64>;
bool should_parse_next(const string_list& rest);
- std::optional<HEXAPI_Interval> to_interval(const detail::MaybeString& str);
- std::optional<HEXAPI_TimingMode> to_timingmode(const detail::MaybeString& str);
- std::optional<HEXAPI_VerboseMode> to_verbosemode(const detail::MaybeString& str);
- std::optional<HEXAPI_Nullptr> to_nullptr(const detail::MaybeString& str);
+ detail::Optional<HEXAPI_Interval> to_interval(const detail::MaybeString& str);
+ detail::Optional<HEXAPI_TimingMode> to_timingmode(const detail::MaybeString& str);
+ detail::Optional<HEXAPI_VerboseMode> to_verbosemode(const detail::MaybeString& str);
+ detail::Optional<HEXAPI_Nullptr> to_nullptr(const detail::MaybeString& str);
MaybeUIntRange ahb_, axi2_;
- std::optional<uint32_t> debug_port_;
+ detail::Optional<uint32_t> debug_port_;
using OptionHandler = bool (SimulatorRPCChannel::*)(string_list&);
static std::map<std::string, OptionHandler> opt_map_;
@@ -538,14 +556,15 @@ HEX_8u_t SimulatorRPCChannel::PassVirtAddrCallback(void* handle, int threadno, H
return RssV;
}
-std::optional<HEXAPI_Cpu> SimulatorRPCChannel::GetCPU(const detail::MaybeString& cpu_str) {
- if (!cpu_str) return std::nullopt;
- return detail::StringSwitch<std::optional<HEXAPI_Cpu>>(*cpu_str)
+detail::Optional<HEXAPI_Cpu> SimulatorRPCChannel::GetCPU(const detail::MaybeString& cpu_str) {
+ auto none = detail::Optional<HEXAPI_Cpu>();
+ if (!cpu_str) return none;
+ return detail::StringSwitch<detail::Optional<HEXAPI_Cpu>>(*cpu_str)
.Case("v65", HEX_CPU_V65)
.Case("v66", HEX_CPU_V66)
.Case("v68", HEX_CPU_V68)
.Case("v69", HEX_CPU_V69)
- .Default(std::nullopt);
+ .Default(none);
}
SimulatorRPCChannel::SimulatorRPCChannel(int stack_size, std::string args) {
@@ -1246,8 +1265,9 @@ bool SimulatorRPCChannel::should_parse_next(const string_list& rest) {
return false;
}
-std::optional<HEXAPI_Interval> SimulatorRPCChannel::to_interval(const detail::MaybeString& str) {
- if (!str) return std::nullopt;
+detail::Optional<HEXAPI_Interval> SimulatorRPCChannel::to_interval(const detail::MaybeString& str) {
+ auto none = detail::Optional<HEXAPI_Interval>();
+ if (!str) return none;
if (auto val = detail::to_int(*str)) {
switch (*val) {
@@ -1260,18 +1280,19 @@ std::optional<HEXAPI_Interval> SimulatorRPCChannel::to_interval(const detail::Ma
}
}
- return detail::StringSwitch<std::optional<HEXAPI_Interval>>(*str)
+ return detail::StringSwitch<detail::Optional<HEXAPI_Interval>>(*str)
.Case("MILLISEC", HEX_MILLISEC)
.Case("MICROSEC", HEX_MICROSEC)
.Case("NANOSEC", HEX_NANOSEC)
.Case("PICOSEC", HEX_PICOSEC)
.Case("PCYCLE", HEX_PCYCLE)
- .Default(std::nullopt);
+ .Default(none);
}
-std::optional<HEXAPI_TimingMode> SimulatorRPCChannel::to_timingmode(
+detail::Optional<HEXAPI_TimingMode> SimulatorRPCChannel::to_timingmode(
const detail::MaybeString& str) {
- if (!str) return std::nullopt;
+ auto none = detail::Optional<HEXAPI_TimingMode>();
+ if (!str) return none;
if (auto val = detail::to_int(*str)) {
switch (*val) {
@@ -1283,17 +1304,18 @@ std::optional<HEXAPI_TimingMode> SimulatorRPCChannel::to_timingmode(
}
}
- return detail::StringSwitch<std::optional<HEXAPI_TimingMode>>(*str)
+ return detail::StringSwitch<detail::Optional<HEXAPI_TimingMode>>(*str)
.Case("NOTIMING", HEX_NOTIMING)
.Case("TIMING_NODBC", HEX_TIMING_NODBC)
.Case("TIMING", HEX_TIMING)
.Case("TIMING_COHERENCY", HEX_TIMING_COHERENCY)
- .Default(std::nullopt);
+ .Default(none);
}
-std::optional<HEXAPI_VerboseMode> SimulatorRPCChannel::to_verbosemode(
+detail::Optional<HEXAPI_VerboseMode> SimulatorRPCChannel::to_verbosemode(
const detail::MaybeString& str) {
- if (!str) return std::nullopt;
+ auto none = detail::Optional<HEXAPI_VerboseMode>();
+ if (!str) return none;
if (auto val = detail::to_int(*str)) {
switch (*val) {
@@ -1306,17 +1328,18 @@ std::optional<HEXAPI_VerboseMode> SimulatorRPCChannel::to_verbosemode(
}
}
- return detail::StringSwitch<std::optional<HEXAPI_VerboseMode>>(*str)
+ return detail::StringSwitch<detail::Optional<HEXAPI_VerboseMode>>(*str)
.Case("SILENT", HEX_SILENT)
.Case("QUIET", HEX_QUIET)
.Case("NORMAL", HEX_NORMAL)
.Case("VERBOSE", HEX_VERBOSE)
.Case("REALLY_VERBOSE", HEX_REALLY_VERBOSE)
- .Default(std::nullopt);
+ .Default(none);
}
-std::optional<HEXAPI_Nullptr> SimulatorRPCChannel::to_nullptr(const detail::MaybeString& str) {
- if (!str) return std::nullopt;
+detail::Optional<HEXAPI_Nullptr> SimulatorRPCChannel::to_nullptr(const detail::MaybeString& str) {
+ auto none = detail::Optional<HEXAPI_Nullptr>();
+ if (!str) return none;
if (auto val = detail::to_int(*str)) {
switch (*val) {
@@ -1328,12 +1351,12 @@ std::optional<HEXAPI_Nullptr> SimulatorRPCChannel::to_nullptr(const detail::Mayb
}
}
- return detail::StringSwitch<std::optional<HEXAPI_Nullptr>>(*str)
+ return detail::StringSwitch<detail::Optional<HEXAPI_Nullptr>>(*str)
.Case("IGNORE", HEX_NULLPTR_IGNORE)
.Case("WARN", HEX_NULLPTR_WARN)
.Case("FATAL", HEX_NULLPTR_FATAL)
.Case("PCZERO", HEX_NULLPTR_PCZERO)
- .Default(std::nullopt);
+ .Default(none);
}
TVM_REGISTER_GLOBAL("tvm.contrib.hexagon.create_hexagon_session")