Skip to content

GitLab

"...git@developer.sourcefind.cn:OpenDAS/torchaudio.git" did not exist on "51401084103d9791c43943d5bf756f80ab1b1713"
Commit ae98b52a authored by Chao Liu's avatar Chao Liu
Browse files

remove online compilation from CK

parent cb954213
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 1999 deletions
host/online_compile/hip_utility/hipoc_kernel.cpp deleted 100644 → 0
View file @ cb954213
/*******************************************************************************
*
* MIT License
*
* Copyright (c) 2017 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*******************************************************************************/
#include <env.hpp>
#include <hipoc_kernel.hpp>
#include <hipCheck.hpp>
#include <hip/hip_ext.h>
#include <hip/hip_runtime.h>
#include <chrono>
#include <thread>
namespace online_compile {
void HIPOCKernelInvoke::run(void* args, std::size_t size) const
{
HipEventPtr start = nullptr;
HipEventPtr stop = nullptr;
void* config[] = {// HIP_LAUNCH_PARAM_* are macros that do horrible things
// NOLINTNEXTLINE cppcoreguidelines-pro-type-cstyle-cast
HIP_LAUNCH_PARAM_BUFFER_POINTER,
args,
// NOLINTNEXTLINE cppcoreguidelines-pro-type-cstyle-cast
HIP_LAUNCH_PARAM_BUFFER_SIZE,
&size,
// NOLINTNEXTLINE cppcoreguidelines-pro-type-cstyle-cast
HIP_LAUNCH_PARAM_END};
if(callback)
{
start = make_hip_event();
stop = make_hip_event();
}
MY_HIP_CHECK(hipExtModuleLaunchKernel(fun,
gdims[0],
gdims[1],
gdims[2],
ldims[0],
ldims[1],
ldims[2],
0,
stream,
nullptr,
reinterpret_cast<void**>(&config),
start.get(),
stop.get()));
if(callback)
{
MY_HIP_CHECK(hipEventSynchronize(stop.get()));
callback(start.get(), stop.get());
}
}
HIPOCKernelInvoke HIPOCKernel::Invoke(hipStream_t stream,
std::function<void(hipEvent_t, hipEvent_t)> callback) const
{
return HIPOCKernelInvoke{stream, fun, ldims, gdims, name, callback};
}
} // namespace online_compile
host/online_compile/hip_utility/hipoc_program.cpp deleted 100644 → 0
View file @ cb954213
/*******************************************************************************
*
* MIT License
*
* Copyright (c) 2017 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*******************************************************************************/
#include <hip_build_utils.hpp>
#include <hipoc_program.hpp>
#include <kernel.hpp>
#include <stringutils.hpp>
#include <target_properties.hpp>
#include <env.hpp>
#include <write_file.hpp>
#include <boost/optional.hpp>
#include <boost/filesystem/operations.hpp>
#include <cstring>
#include <mutex>
#include <sstream>
#include <unistd.h>
namespace online_compile {
static hipModulePtr CreateModule(const boost::filesystem::path& hsaco_file)
{
hipModule_t raw_m;
MY_HIP_CHECK(hipModuleLoad(&raw_m, hsaco_file.string().c_str()));
hipModulePtr m{raw_m};
return m;
}
template <typename T> /// intended for std::string and std::vector<char>
hipModulePtr CreateModuleInMem(const T& blob)
{
hipModule_t raw_m;
MY_HIP_CHECK(hipModuleLoadData(&raw_m, reinterpret_cast<const void*>(blob.data())));
hipModulePtr m{raw_m};
return m;
}
HIPOCProgramImpl::HIPOCProgramImpl(const std::string& program_name,
const boost::filesystem::path& filespec)
: program(program_name), hsaco_file(filespec)
{
this->module = CreateModule(hsaco_file);
}
HIPOCProgramImpl::HIPOCProgramImpl(const std::string& program_name,
std::string params,
const TargetProperties& target_)
: program(program_name), target(target_)
{
BuildCodeObject(params);
if(!binary.empty())
{
module = CreateModuleInMem(this->binary);
}
else
{
module = CreateModule(this->hsaco_file);
}
}
void HIPOCProgramImpl::BuildCodeObjectInFile(std::string& params,
const std::string& src,
const std::string& filename)
{
this->dir.emplace(filename);
hsaco_file = dir->path / (filename + ".o");
if(online_compile::EndsWith(filename, ".cpp"))
{
hsaco_file = HipBuild(dir, filename, src, params, target);
}
else
throw std::runtime_error("Only HIP kernel source of .cpp file is supported");
if(!boost::filesystem::exists(hsaco_file))
throw std::runtime_error("Cant find file: " + hsaco_file.string());
}
void HIPOCProgramImpl::BuildCodeObject(std::string params)
{
std::string filename = program;
if(online_compile::EndsWith(filename, ".cpp"))
{
params += " -Wno-everything";
}
BuildCodeObjectInFile(params, GetKernelSrc(this->program), filename);
}
HIPOCProgram::HIPOCProgram() {}
HIPOCProgram::HIPOCProgram(const std::string& program_name,
std::string params,
const TargetProperties& target)
: impl(std::make_shared<HIPOCProgramImpl>(program_name, params, target))
{
}
HIPOCProgram::HIPOCProgram(const std::string& program_name, const boost::filesystem::path& hsaco)
: impl(std::make_shared<HIPOCProgramImpl>(program_name, hsaco))
{
}
hipModule_t HIPOCProgram::GetModule() const { return impl->module.get(); }
boost::filesystem::path HIPOCProgram::GetCodeObjectPathname() const { return impl->hsaco_file; }
std::string HIPOCProgram::GetCodeObjectBlob() const
{
return {impl->binary.data(), impl->binary.size()};
}
bool HIPOCProgram::IsCodeObjectInMemory() const { return !impl->binary.empty(); };
} // namespace online_compile
host/online_compile/hip_utility/kernel_build_params.cpp deleted 100644 → 0
View file @ cb954213
/*******************************************************************************
*
* MIT License
*
* Copyright (c) 2019 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*******************************************************************************/
#include <sstream>
#include <boost/range/adaptor/transformed.hpp>
#include <kernel_build_params.hpp>
#include <stringutils.hpp>
namespace online_compile {
static std::string GenerateDefines(const std::vector<KernelBuildParameter>& options,
const std::string& prefix)
{
const auto strs =
options | boost::adaptors::transformed([&prefix](const KernelBuildParameter& define) {
std::ostringstream ss;
ss << '-';
if(define.type == ParameterTypes::Define)
ss << prefix;
ss << define.name;
if(!define.value.empty())
{
switch(define.type)
{
case ParameterTypes::Define: ss << '='; break;
case ParameterTypes::Option: ss << ' '; break;
}
ss << define.value;
}
return ss.str();
});
return JoinStrings(strs, " ");
}
} // namespace online_compile
host/online_compile/hip_utility/kernel_cache.cpp deleted 100644 → 0
View file @ cb954213
/*******************************************************************************
*
* MIT License
*
* Copyright (c) 2017 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*******************************************************************************/
/* ************************************************************************
* Copyright 2015 Vratis, Ltd.
*
* 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
*
* http://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.
* ************************************************************************ */
#include <env.hpp>
#include <kernel_cache.hpp>
#include <stringutils.hpp>
#include <iostream>
#include <iterator>
namespace online_compile {
const std::vector<Kernel>& KernelCache::GetKernels(const std::string& algorithm,
const std::string& network_config)
{
std::pair<std::string, std::string> key = std::make_pair(algorithm, network_config);
const auto it = kernel_map.find(key);
if(it != kernel_map.end())
{
return it->second;
}
static const std::vector<Kernel> empty{};
return empty;
}
bool KernelCache::HasKernels(const std::string& algorithm, const std::string& network_config) const
{
const auto key = std::make_pair(algorithm, network_config);
const auto it = kernel_map.find(key);
if(it == kernel_map.end())
return false;
if(it->second.empty())
{
throw std::runtime_error(
"There should be at least one kernel in kernel cache if an entry exists");
}
return true;
}
bool KernelCache::HasProgram(const std::string& name, const std::string& params) const
{
const auto key = std::make_pair(name, params);
return program_map.count(key) > 0;
}
void KernelCache::AddProgram(Program prog, const std::string& program_name, std::string params)
{
program_map[std::make_pair(program_name, params)] = prog;
}
Kernel KernelCache::AddKernel(const Handle& h,
const std::string& algorithm,
const std::string& network_config,
const std::string& program_name,
const std::string& kernel_name,
const std::vector<size_t>& vld,
const std::vector<size_t>& vgd,
std::string params,
std::size_t cache_index)
{
const std::pair<std::string, std::string> key = std::make_pair(algorithm, network_config);
Program program;
auto program_it = program_map.find(std::make_pair(program_name, params));
if(program_it != program_map.end())
{
program = program_it->second;
}
else
{
program = h.LoadProgram(program_name, params);
program_map[std::make_pair(program_name, params)] = program;
}
Kernel kernel{};
kernel = Kernel{program, kernel_name, vld, vgd};
if(!network_config.empty() && !algorithm.empty())
{
this->AddKernel(key, kernel, cache_index);
}
return kernel;
}
void KernelCache::AddKernel(Key key, Kernel k, std::size_t cache_index)
{
auto&& v = kernel_map[key];
if(cache_index >= v.size())
{
v.resize(cache_index + 1);
}
v[cache_index] = k;
}
void KernelCache::ClearKernels(const std::string& algorithm, const std::string& network_config)
{
if(network_config.empty() || algorithm.empty())
{
throw std::runtime_error("Network config or algorithm empty.");
}
const std::pair<std::string, std::string> key = std::make_pair(algorithm, network_config);
auto&& v = this->kernel_map[key];
if(!v.empty()) {}
v.clear();
}
KernelCache::KernelCache() {}
} // namespace online_compile
host/online_compile/hip_utility/logger.cpp deleted 100644 → 0
View file @ cb954213
#include <config.h>
#include <logger.hpp>
#include <iostream>
#include <string>
using namespace std;
namespace online_compile {
#if OLC_DEBUG
static LogLevel defLevel = LogLevel::Info2;
#else
static LogLevel defLevel = LogLevel::Error;
#endif
string LogLevelString(LogLevel level)
{
switch(level)
{
case LogLevel::Error: return ("Error");
case LogLevel::Warning: return ("Warning");
case LogLevel::Info: return ("Info");
case LogLevel::Info2: return ("Info2");
default: return ("Unknown");
};
};
ostream& fdt_log(LogLevel level, const char* header, const char* content)
{
if(level > online_compile::defLevel)
{
return (cerr);
};
cerr << endl << LogLevelString(level) << ":" << header << ", " << content;
return (cerr);
}
ostream& fdt_log() { return (cerr); };
void fdt_log_flush() { cerr << endl; }
}; // namespace online_compile
host/online_compile/hip_utility/md5.cpp deleted 100644 → 0
View file @ cb954213
/*
* Derived from a public-domain MD5 implementation. Original license
* below.
*
* This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
* MD5 Message-Digest Algorithm (RFC 1321).
*
* Homepage:
* http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
*
* Author:
* Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
*
* This software was written by Alexander Peslyak in 2001. No copyright is
* claimed, and the software is hereby placed in the public domain.
* In case this attempt to disclaim copyright and place the software in the
* public domain is deemed null and void, then the software is
* Copyright (c) 2001 Alexander Peslyak and it is hereby released to the
* general public under the following terms:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted.
*
* There's ABSOLUTELY NO WARRANTY, express or implied.
*
* (This is a heavily cut-down "BSD license".)
*
* This differs from Colin Plumb's older public domain implementation in that
* no exactly 32-bit integer data type is required (any 32-bit or wider
* unsigned integer data type will do), there's no compile-time endianness
* configuration, and the function prototypes match OpenSSL's. No code from
* Colin Plumb's implementation has been reused; this comment merely compares
* the properties of the two independent implementations.
*
* The primary goals of this implementation are portability and ease of use.
* It is meant to be fast, but not as fast as possible. Some known
* optimizations are not included to reduce source code size and avoid
* compile-time configuration.
*/
#include <md5.hpp>
#include <array>
#include <cstring>
#include <cstdint>
#include <sstream>
#include <iomanip>
#define MD5_DIGEST_LENGTH 16
struct MD5_CTX
{
uint32_t lo, hi;
uint32_t a, b, c, d;
unsigned char buffer[64];
uint32_t block[MD5_DIGEST_LENGTH];
};
/*
* The basic MD5 functions.
*
* F and G are optimized compared to their RFC 1321 definitions for
* architectures that lack an AND-NOT instruction, just like in Colin Plumb's
* implementation.
*/
#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
#define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y))))
#define H(x, y, z) (((x) ^ (y)) ^ (z))
#define H2(x, y, z) ((x) ^ ((y) ^ (z)))
#define I(x, y, z) ((y) ^ ((x) | ~(z)))
/*
* The MD5 transformation for all four rounds.
*/
#define STEP(f, a, b, c, d, x, t, s) \
(a) += f((b), (c), (d)) + (x) + (t); \
(a) = (((a) << (s)) | (((a)&0xffffffff) >> (32 - (s)))); \
(a) += (b);
/*
* SET reads 4 input bytes in little-endian byte order and stores them in a
* properly aligned word in host byte order.
*
* The check for little-endian architectures that tolerate unaligned memory
* accesses is just an optimization. Nothing will break if it fails to detect
* a suitable architecture.
*
* Unfortunately, this optimization may be a C strict aliasing rules violation
* if the caller's data buffer has effective type that cannot be aliased by
* uint32_t. In practice, this problem may occur if these MD5 routines are
* inlined into a calling function, or with future and dangerously advanced
* link-time optimizations. For the time being, keeping these MD5 routines in
* their own translation unit avoids the problem.
*/
#if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
#define SET(n) (*reinterpret_cast<const uint32_t*>(&ptr[(n)*4]))
#define GET(n) SET(n)
#else
#define SET(n) \
(ctx->block[(n)] = static_cast<uint32_t>(ptr[(n)*4]) | \
(static_cast<uint32_t>(ptr[(n)*4 + 1]) << 8) | \
(static_cast<uint32_t>(ptr[(n)*4 + 2]) << 16) | \
(static_cast<uint32_t>(ptr[(n)*4 + 3]) << 24))
#define GET(n) (ctx->block[(n)])
#endif
/*
* This processes one or more 64-byte data blocks, but does NOT update the bit
* counters. There are no alignment requirements.
*/
static const void* body(MD5_CTX* ctx, const void* data, size_t size)
{
const unsigned char* ptr;
uint32_t a, b, c, d;
ptr = static_cast<const unsigned char*>(data);
a = ctx->a;
b = ctx->b;
c = ctx->c;
d = ctx->d;
do
{
uint32_t saved_a = a, saved_b = b, saved_c = c, saved_d = d;
/* Round 1 */
STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
/* Round 2 */
STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
/* Round 3 */
STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11)
STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23)
STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11)
STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23)
STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11)
STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23)
STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11)
STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23)
/* Round 4 */
STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
a += saved_a;
b += saved_b;
c += saved_c;
d += saved_d;
ptr += 64;
} while((size -= 64) != 0u);
ctx->a = a;
ctx->b = b;
ctx->c = c;
ctx->d = d;
return ptr;
}
static void MD5_Init(MD5_CTX* ctx)
{
ctx->a = 0x67452301;
ctx->b = 0xefcdab89;
ctx->c = 0x98badcfe;
ctx->d = 0x10325476;
ctx->lo = 0;
ctx->hi = 0;
}
static void MD5_Update(MD5_CTX* ctx, const void* data, size_t size)
{
uint32_t saved_lo;
size_t used;
saved_lo = ctx->lo;
if((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
ctx->hi++;
ctx->hi += size >> 29;
used = saved_lo & 0x3f;
if(used != 0u)
{
size_t available = 64 - used;
if(size < available)
{
memcpy(&ctx->buffer[used], data, size);
return;
}
memcpy(&ctx->buffer[used], data, available);
data = static_cast<const unsigned char*>(data) + available;
size -= available;
body(ctx, ctx->buffer, 64);
}
if(size >= 64)
{
data = body(ctx, data, size & ~size_t{0x3f});
size &= 0x3f;
}
memcpy(ctx->buffer, data, size);
}
#define OUT(dst, src) \
(dst)[0] = static_cast<unsigned char>(src); \
(dst)[1] = static_cast<unsigned char>((src) >> 8); \
(dst)[2] = static_cast<unsigned char>((src) >> 16); \
(dst)[3] = static_cast<unsigned char>((src) >> 24);
static void MD5_Final(unsigned char* result, MD5_CTX* ctx)
{
size_t used, available;
used = ctx->lo & 0x3f;
ctx->buffer[used++] = 0x80;
available = 64 - used;
if(available < 8)
{
memset(&ctx->buffer[used], 0, available);
body(ctx, ctx->buffer, 64);
used = 0;
available = 64;
}
memset(&ctx->buffer[used], 0, available - 8);
ctx->lo <<= 3;
OUT(&ctx->buffer[56], ctx->lo)
OUT(&ctx->buffer[60], ctx->hi)
body(ctx, ctx->buffer, 64);
OUT(&result[0], ctx->a)
OUT(&result[4], ctx->b)
OUT(&result[8], ctx->c)
OUT(&result[12], ctx->d)
memset(ctx, 0, sizeof(*ctx));
}
namespace online_compile {
std::string md5(std::string s)
{
std::array<unsigned char, MD5_DIGEST_LENGTH> result{};
MD5_CTX ctx{};
MD5_Init(&ctx);
MD5_Update(&ctx, s.data(), s.length());
MD5_Final(result.data(), &ctx);
std::ostringstream sout;
sout << std::hex << std::setfill('0');
for(auto c : result)
sout << std::setw(2) << int{c};
return sout.str();
}
} // namespace online_compile
host/online_compile/hip_utility/target_properties.cpp deleted 100644 → 0
View file @ cb954213
/*******************************************************************************
*
* MIT License
*
* Copyright (c) 2020 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*******************************************************************************/
#include <env.hpp>
#include <handle.hpp>
#include <stringutils.hpp>
#include <target_properties.hpp>
#include <map>
#include <string>
OLC_DECLARE_ENV_VAR(OLC_DEBUG_ENFORCE_DEVICE)
namespace online_compile {
static std::string GetDeviceNameFromMap(const std::string& in)
{
// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
static std::map<std::string, std::string> device_name_map = {
{"Ellesmere", "gfx803"},
{"Baffin", "gfx803"},
{"RacerX", "gfx803"},
{"Polaris10", "gfx803"},
{"Polaris11", "gfx803"},
{"Tonga", "gfx803"},
{"Fiji", "gfx803"},
{"gfx800", "gfx803"},
{"gfx802", "gfx803"},
{"gfx804", "gfx803"},
{"Vega10", "gfx900"},
{"gfx901", "gfx900"},
{"10.3.0 Sienna_Cichlid 18", "gfx1030"},
};
const char* const p_asciz = online_compile::GetStringEnv(OLC_DEBUG_ENFORCE_DEVICE{});
if(p_asciz != nullptr && strlen(p_asciz) > 0)
return {p_asciz};
const auto name = in.substr(0, in.find(':')); // str.substr(0, npos) returns str.
auto match = device_name_map.find(name);
if(match != device_name_map.end())
return match->second;
return name; // NOLINT (performance-no-automatic-move)
}
void TargetProperties::Init(const Handle* const handle)
{
const auto rawName = [&]() -> std::string { return handle->GetDeviceNameImpl(); }();
name = GetDeviceNameFromMap(rawName);
// DKMS driver older than 5.9 may report incorrect state of SRAMECC feature.
// Therefore we compute default SRAMECC and rely on it for now.
sramecc = [&]() -> boost::optional<bool> {
if(name == "gfx906" || name == "gfx908")
return {true};
return {};
}();
// However we need to store the reported state, even if it is incorrect,
// to use together with COMGR.
sramecc_reported = [&]() -> boost::optional<bool> {
if(rawName.find(":sramecc+") != std::string::npos)
return true;
if(rawName.find(":sramecc-") != std::string::npos)
return false;
return sramecc; // default
}();
xnack = [&]() -> boost::optional<bool> {
if(rawName.find(":xnack+") != std::string::npos)
return true;
if(rawName.find(":xnack-") != std::string::npos)
return false;
return {}; // default
}();
InitDbId();
}
void TargetProperties::InitDbId()
{
dbId = name;
if(name == "gfx906" || name == "gfx908")
{
// Let's stay compatible with existing gfx906/908 databases.
// When feature equal to the default (SRAMECC ON), do not
// append feature suffix. This is for backward compatibility
// with legacy databases ONLY!
if(!sramecc || !(*sramecc))
dbId += "_nosramecc";
}
else
{
if(sramecc && *sramecc)
dbId += "_sramecc";
}
if(xnack && *xnack)
dbId += "_xnack";
}
} // namespace online_compile
host/online_compile/hip_utility/tmp_dir.cpp deleted 100644 → 0
View file @ cb954213
/*******************************************************************************
*
* MIT License
*
* Copyright (c) 2019 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*******************************************************************************/
#include <tmp_dir.hpp>
#include <env.hpp>
#include <boost/filesystem.hpp>
#include <logger.hpp>
OLC_DECLARE_ENV_VAR(OLC_DEBUG_SAVE_TEMP_DIR)
namespace online_compile {
void SystemCmd(std::string cmd)
{
fdt_log(LogLevel::Info, "SystemCmd", cmd.c_str());
fdt_log_flush();
if(std::system(cmd.c_str()) != 0)
throw std::runtime_error("Can't execute " + cmd);
}
TmpDir::TmpDir(std::string prefix)
: path(boost::filesystem::temp_directory_path() /
boost::filesystem::unique_path("online_compile-" + prefix + "-%%%%-%%%%-%%%%-%%%%"))
{
boost::filesystem::create_directories(this->path);
}
void TmpDir::Execute(std::string exe, std::string args) const
{
std::string cd = "cd " + this->path.string() + "; ";
std::string cmd = cd + exe + " " + args; // + " > /dev/null";
SystemCmd(cmd);
}
TmpDir::~TmpDir()
{
if(!online_compile::IsEnabled(OLC_DEBUG_SAVE_TEMP_DIR{}))
{
boost::filesystem::remove_all(this->path);
}
}
} // namespace online_compile
host/online_compile/include/binary_cache.hpp deleted 100644 → 0
View file @ cb954213
/*******************************************************************************
*
* MIT License
*
* Copyright (c) 2017 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*******************************************************************************/
#ifndef GUARD_OLC_BINARY_CACHE_HPP
#define GUARD_OLC_BINARY_CACHE_HPP
#include <target_properties.hpp>
#include <boost/filesystem/path.hpp>
#include <string>
namespace online_compile {
boost::filesystem::path
GetCacheFile(const std::string& device, const std::string& name, const std::string& args);
boost::filesystem::path GetCachePath();
boost::filesystem::path LoadBinary(const TargetProperties& target,
std::size_t num_cu,
const std::string& name,
const std::string& args);
void SaveBinary(const boost::filesystem::path& binary_path,
const TargetProperties& target,
const std::string& name,
const std::string& args);
} // namespace online_compile
#endif
host/online_compile/include/config.h.in deleted 100644 → 0
View file @ cb954213
/*******************************************************************************
*
* MIT License
*
* Copyright (c) 2017 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*******************************************************************************/
#ifndef GUARD_CONFIG_H_IN
#define GUARD_CONFIG_H_IN
// "_PACKAGE_" to avoid name contentions: the macros like
// HIP_VERSION_MAJOR are defined in hip_version.h.
// clang-format off
#define HIP_PACKAGE_VERSION_MAJOR @OLC_hip_VERSION_MAJOR@
#define HIP_PACKAGE_VERSION_MINOR @OLC_hip_VERSION_MINOR@
#define HIP_PACKAGE_VERSION_PATCH @OLC_hip_VERSION_PATCH@
// clang-format on
#define HIP_PACKAGE_VERSION_FLAT \
((HIP_PACKAGE_VERSION_MAJOR * 1000ULL + HIP_PACKAGE_VERSION_MINOR) * 1000000 + \
HIP_PACKAGE_VERSION_PATCH)
#cmakedefine01 OLC_DEBUG
#cmakedefine OLC_HIP_COMPILER "@OLC_HIP_COMPILER@"
#cmakedefine EXTRACTKERNEL_BIN "@EXTRACTKERNEL_BIN@"
#cmakedefine OLC_OFFLOADBUNDLER_BIN "@OLC_OFFLOADBUNDLER_BIN@"
#endif
host/online_compile/include/env.hpp deleted 100644 → 0
View file @ cb954213
/*******************************************************************************
*
* MIT License
*
* Copyright (c) 2017 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*******************************************************************************/
#ifndef GUARD_OLC_ENV_HPP
#define GUARD_OLC_ENV_HPP
#include <cstdlib>
#include <cstring>
#include <string>
#include <vector>
namespace online_compile {
/// \todo Rework: Case-insensitive string compare, ODR, (?) move to .cpp
// Declare a cached environment variable
#define OLC_DECLARE_ENV_VAR(x) \
struct x \
{ \
static const char* value() { return #x; } \
};
/*
* Returns false if a feature-controlling environment variable is defined
* and set to something which disables a feature.
*/
inline bool IsEnvvarValueDisabled(const char* name)
{
const auto value_env_p = std::getenv(name);
return value_env_p != nullptr &&
(std::strcmp(value_env_p, "disable") == 0 || std::strcmp(value_env_p, "disabled") == 0 ||
std::strcmp(value_env_p, "0") == 0 || std::strcmp(value_env_p, "no") == 0 ||
std::strcmp(value_env_p, "false") == 0);
}
inline bool IsEnvvarValueEnabled(const char* name)
{
const auto value_env_p = std::getenv(name);
return value_env_p != nullptr &&
(std::strcmp(value_env_p, "enable") == 0 || std::strcmp(value_env_p, "enabled") == 0 ||
std::strcmp(value_env_p, "1") == 0 || std::strcmp(value_env_p, "yes") == 0 ||
std::strcmp(value_env_p, "true") == 0);
}
// Return 0 if env is enabled else convert environment var to an int.
// Supports hexadecimal with leading 0x or decimal
inline unsigned long int EnvvarValue(const char* name, unsigned long int fallback = 0)
{
const auto value_env_p = std::getenv(name);
if(value_env_p == nullptr)
{
return fallback;
}
else
{
return strtoul(value_env_p, nullptr, 0);
}
}
inline std::vector<std::string> GetEnv(const char* name)
{
const auto p = std::getenv(name);
if(p == nullptr)
return {};
else
return {{p}};
}
template <class T>
inline const char* GetStringEnv(T)
{
static const std::vector<std::string> result = GetEnv(T::value());
if(result.empty())
return nullptr;
else
return result.front().c_str();
}
template <class T>
inline bool IsEnabled(T)
{
static const bool result = online_compile::IsEnvvarValueEnabled(T::value());
return result;
}
template <class T>
inline bool IsDisabled(T)
{
static const bool result = online_compile::IsEnvvarValueDisabled(T::value());
return result;
}
template <class T>
inline unsigned long int Value(T, unsigned long int fallback = 0)
{
static const auto result = online_compile::EnvvarValue(T::value(), fallback);
return result;
}
} // namespace online_compile
#endif
host/online_compile/include/exec_utils.hpp deleted 100644 → 0
View file @ cb954213
/*******************************************************************************
*
* MIT License
*
* Copyright (c) 2019 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*******************************************************************************/
#ifndef EXEC_OLC_UTILS_HPP
#define EXEC_OLC_UTILS_HPP
#include <istream>
#include <ostream>
#include <string>
namespace online_compile {
namespace exec {
/// Redirecting both input and output is not supported.
int Run(const std::string& p, std::istream* in, std::ostream* out);
} // namespace exec
} // namespace online_compile
#endif // EXEC_UTILS_HPP
host/online_compile/include/handle.hpp deleted 100644 → 0
View file @ cb954213
This diff is collapsed.
host/online_compile/include/hipCheck.hpp deleted 100644 → 0
View file @ cb954213
#ifndef _HIP_OLC_CHECK_HPP_
#define _HIP_OLC_CHECK_HPP_
#include <hip/hip_runtime.h>
#include <sstream>
#include <vector>
// Here flag can be a constant, variable or function call
#define MY_HIP_CHECK(flag) \
do \
{ \
hipError_t _tmpVal; \
if((_tmpVal = flag) != hipSuccess) \
{ \
std::ostringstream ostr; \
ostr << "HIP Function Failed (" << __FILE__ << "," << __LINE__ << ") " \
<< hipGetErrorString(_tmpVal); \
throw std::runtime_error(ostr.str()); \
} \
} while(0)
#endif
host/online_compile/include/hip_build_utils.hpp deleted 100644 → 0
View file @ cb954213
This diff is collapsed.
host/online_compile/include/hipoc_kernel.hpp deleted 100644 → 0
View file @ cb954213
This diff is collapsed.
host/online_compile/include/hipoc_program.hpp deleted 100644 → 0
View file @ cb954213
/*******************************************************************************
*
* MIT License
*
* Copyright (c) 2017 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*******************************************************************************/
#ifndef GUARD_OLC_HIPOC_PROGRAM_HPP
#define GUARD_OLC_HIPOC_PROGRAM_HPP
#include <target_properties.hpp>
#include <manage_ptr.hpp>
#include <hipoc_program_impl.hpp>
#include <boost/filesystem/path.hpp>
#include <hip/hip_runtime_api.h>
#include <string>
namespace online_compile {
struct HIPOCProgramImpl;
struct HIPOCProgram
{
HIPOCProgram();
/// This ctor builds the program from source, initializes module.
/// Also either CO pathname (typically if offline tools were used)
/// or binary blob (if comgr was used to build the program)
/// is initialized. GetModule(), GetCodeObjectPathname(),
/// GetCodeObjectBlob() return appropriate data after this ctor.
/// Other ctors only guarantee to initialize module.
HIPOCProgram(const std::string& program_name,
std::string params,
const TargetProperties& target);
HIPOCProgram(const std::string& program_name, const boost::filesystem::path& hsaco);
std::shared_ptr<const HIPOCProgramImpl> impl;
hipModule_t GetModule() const;
/// \return Pathname of CO file, if it resides on the filesystem.
boost::filesystem::path GetCodeObjectPathname() const;
/// \return Copy of in-memory CO blob.
std::string GetCodeObjectBlob() const;
/// \return True if CO blob resides in-memory.
/// False if CO resides on filesystem.
bool IsCodeObjectInMemory() const;
};
} // namespace online_compile
#endif
host/online_compile/include/hipoc_program_impl.hpp deleted 100644 → 0
View file @ cb954213
This diff is collapsed.
host/online_compile/include/kernel.hpp deleted 100644 → 0
View file @ cb954213
This diff is collapsed.
host/online_compile/include/kernel_build_params.hpp deleted 100644 → 0
View file @ cb954213
This diff is collapsed.
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment