53336ad488
Rather than having a number of static local variables, we now use a single `OffloadContext` struct to store global state. This is initialised by `olInit`, but is never deleted (de-initialization of Offload isn't yet implemented). The error reporting mechanism has not been moved to the struct, since that's going to cause issues with teardown (error messages must outlive liboffload).
100 lines
2.9 KiB
C++
100 lines
2.9 KiB
C++
//===- offload_impl.hpp- Implementation helpers for the Offload library ---===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
#pragma once
|
|
|
|
#include "PluginInterface.h"
|
|
#include <OffloadAPI.h>
|
|
#include <iostream>
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <set>
|
|
#include <string>
|
|
#include <unordered_set>
|
|
#include <vector>
|
|
|
|
#include "llvm/ADT/DenseSet.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/ADT/StringSet.h"
|
|
#include "llvm/Support/Error.h"
|
|
|
|
namespace llvm {
|
|
namespace offload {
|
|
bool isTracingEnabled();
|
|
bool isValidationEnabled();
|
|
} // namespace offload
|
|
} // namespace llvm
|
|
|
|
// Use the StringSet container to efficiently deduplicate repeated error
|
|
// strings (e.g. if the same error is hit constantly in a long running program)
|
|
llvm::StringSet<> &errorStrs();
|
|
|
|
// Use an unordered_set to avoid duplicates of error structs themselves.
|
|
// We cannot store the structs directly as returned pointers to them must always
|
|
// be valid, and a rehash of the set may invalidate them. This requires
|
|
// custom hash and equal_to function objects.
|
|
using ErrPtrT = std::unique_ptr<ol_error_struct_t>;
|
|
struct ErrPtrEqual {
|
|
bool operator()(const ErrPtrT &lhs, const ErrPtrT &rhs) const {
|
|
if (!lhs && !rhs) {
|
|
return true;
|
|
}
|
|
if (!lhs || !rhs) {
|
|
return false;
|
|
}
|
|
|
|
bool StrsEqual = false;
|
|
if (lhs->Details == NULL && rhs->Details == NULL) {
|
|
StrsEqual = true;
|
|
} else if (lhs->Details != NULL && rhs->Details != NULL) {
|
|
StrsEqual = (std::strcmp(lhs->Details, rhs->Details) == 0);
|
|
}
|
|
return (lhs->Code == rhs->Code) && StrsEqual;
|
|
}
|
|
};
|
|
struct ErrPtrHash {
|
|
size_t operator()(const ErrPtrT &e) const {
|
|
if (!e) {
|
|
// We shouldn't store empty errors (i.e. success), but just in case
|
|
return 0lu;
|
|
} else {
|
|
return std::hash<int>{}(e->Code);
|
|
}
|
|
}
|
|
};
|
|
using ErrSetT = std::unordered_set<ErrPtrT, ErrPtrHash, ErrPtrEqual>;
|
|
ErrSetT &errors();
|
|
|
|
namespace {
|
|
ol_errc_t GetErrorCode(std::error_code Code) {
|
|
if (Code.category() ==
|
|
error::make_error_code(error::ErrorCode::SUCCESS).category())
|
|
return static_cast<ol_errc_t>(Code.value());
|
|
|
|
return OL_ERRC_UNKNOWN;
|
|
}
|
|
} // namespace
|
|
|
|
inline ol_result_t llvmErrorToOffloadError(llvm::Error &&Err) {
|
|
if (!Err) {
|
|
// No error
|
|
return nullptr;
|
|
}
|
|
|
|
ol_errc_t ErrCode;
|
|
llvm::StringRef Details;
|
|
|
|
llvm::handleAllErrors(std::move(Err), [&](llvm::StringError &Err) {
|
|
ErrCode = GetErrorCode(Err.convertToErrorCode());
|
|
Details = errorStrs().insert(Err.getMessage()).first->getKeyData();
|
|
});
|
|
|
|
auto NewErr = std::unique_ptr<ol_error_struct_t>(
|
|
new ol_error_struct_t{ErrCode, Details.data()});
|
|
return errors().emplace(std::move(NewErr)).first->get();
|
|
}
|