Skip to content

GitLab

Commit 1bc644a1 authored by Nianchen Deng's avatar Nianchen Deng
Browse files

sync

parent 6294701e
Hide whitespace changes
Inline Side-by-side
cpp/utils/Eye.h
View file @ 1bc644a1
#pragma once
enum Eye {
Eye_Left, Eye_Right
};
\ No newline at end of file
cpp/utils/Logger.h deleted 100644 → 0
View file @ 6294701e
#pragma once
#include <stdarg.h>
#include <iostream>
#include <string>
#include <sstream>
#include <cuda_runtime_api.h>
#include <NvInfer.h>
namespace nv = nvinfer1;
typedef void(*ExternalLogFuncPtr)(int severity, const char*);
class Logger : public nv::ILogger {
public:
ExternalLogFuncPtr externalLogFunc = nullptr;
int logLevel = 1;
static Logger instance;
void verbose(const char* fmt, ...) {
va_list args;
va_start(args, fmt);
logf(nv::ILogger::Severity::kVERBOSE, fmt, args);
va_end(args);
}
void info(const char* fmt, ...) {
va_list args;
va_start(args, fmt);
logf(nv::ILogger::Severity::kINFO, fmt, args);
va_end(args);
}
void warning(const char* fmt, ...) {
va_list args;
va_start(args, fmt);
logf(nv::ILogger::Severity::kWARNING, fmt, args);
va_end(args);
}
void error(const char* fmt, ...) {
va_list args;
va_start(args, fmt);
logf(nv::ILogger::Severity::kERROR, fmt, args);
va_end(args);
}
bool checkErr(cudaError_t err, const char* file, int line) {
if (err == cudaSuccess)
return true;
error("Cuda error %s at %s (Line %d): %s", cudaGetErrorName(err), file, line,
cudaGetErrorString(err));
return false;
}
virtual void log(nv::ILogger::Severity severity, const char* msg) noexcept {
if ((int)severity > logLevel)
return;
if (externalLogFunc == nullptr) {
switch (severity) {
case nv::ILogger::Severity::kVERBOSE:
std::cout << "[VERBOSE] " << msg << std::endl;
break;
case nv::ILogger::Severity::kINFO:
std::cout << "[INFO] " << msg << std::endl;
break;
case nv::ILogger::Severity::kWARNING:
std::cerr << "[WARNING] " << msg << std::endl;
break;
case nv::ILogger::Severity::kERROR:
std::cerr << "[ERROR] " << msg << std::endl;
break;
case nv::ILogger::Severity::kINTERNAL_ERROR:
std::cerr << "[ERROR] " << msg << std::endl;
break;
}
return;
}
externalLogFunc((int)severity, msg);
}
void logf(nv::ILogger::Severity severity, const char* fmt, va_list args) {
char buffer[4096];
vsprintf(buffer, fmt, args);
log(severity, buffer);
}
};
#define CHECK(__ERR_CODE__) do { if (!Logger::instance.checkErr((__ERR_CODE__), __FILE__, __LINE__)) return false; } while (0)
#define CHECK_EX(__ERR_CODE__) do { if (!Logger::instance.checkErr((__ERR_CODE__), __FILE__, __LINE__)) throw std::exception(); } while (0)
cpp/utils/Resource.h deleted 100644 → 0
View file @ 6294701e
#pragma once
#include <map>
#include <vector>
class Resource {
public:
virtual ~Resource() {}
virtual void *getBuffer() const = 0;
virtual size_t size() const = 0;
};
class CudaBuffer : public Resource {
public:
CudaBuffer(void *buffer = nullptr, size_t size = 0)
: _buffer(buffer), _ownBuffer(false), _size(size) {}
CudaBuffer(size_t size) : _buffer(nullptr), _ownBuffer(true), _size(size) {
CHECK_EX(cudaMalloc(&_buffer, size));
}
CudaBuffer(const CudaBuffer &rhs) = delete;
virtual ~CudaBuffer() {
if (!_ownBuffer || _buffer == nullptr)
return;
try {
CHECK_EX(cudaFree(_buffer));
} catch (std::exception &ex) {
Logger::instance.warning("Exception raised in destructor: %s", ex.what());
}
_buffer = nullptr;
_ownBuffer = false;
}
virtual void *getBuffer() const { return _buffer; }
template <class T> T *getBuffer() const { return (T *)getBuffer(); }
virtual size_t size() const { return _size; }
private:
void *_buffer;
bool _ownBuffer;
size_t _size;
};
template <typename T> class CudaArray : public CudaBuffer {
public:
CudaArray(size_t n) : CudaBuffer(n * sizeof(T)) {}
CudaArray(T *buffer, size_t n) : CudaBuffer(buffer, n * sizeof(T)) {}
CudaArray(const std::vector<T> &hostArray) : CudaBuffer(hostArray.size() * sizeof(T)) {
cudaMemcpy(getBuffer(), hostArray.data(), size(), cudaMemcpyHostToDevice);
}
CudaArray(const CudaArray<T> &rhs) = delete;
size_t n() const { return size() / sizeof(T); }
operator T *() { return (T *)getBuffer(); }
CudaArray<T> *subArray(size_t offset, size_t n = -1) {
if (n == -1)
n = this->n() - offset;
return new CudaArray<T>(*this + offset, n);
}
};
class GraphicsResource : public Resource {
public:
cudaGraphicsResource_t getHandler() { return _res; }
virtual ~GraphicsResource() {
if (_res == nullptr)
return;
try {
CHECK_EX(cudaGraphicsUnregisterResource(_res));
} catch (std::exception &ex) {
Logger::instance.warning("Exception raised in destructor: %s", ex.what());
}
_res = nullptr;
}
virtual size_t size() const { return _size; }
protected:
cudaGraphicsResource_t _res;
size_t _size;
GraphicsResource() : _res(nullptr), _size(0) {}
};
template <typename T> class GlTextureResource : public GraphicsResource {
public:
GlTextureResource(GLuint textureID, glm::uvec2 textureSize) {
CHECK_EX(cudaGraphicsGLRegisterImage(&_res, textureID, GL_TEXTURE_2D,
cudaGraphicsRegisterFlagsWriteDiscard));
_size = textureSize.x * textureSize.y * sizeof(T);
_textureSize = textureSize;
}
virtual ~GlTextureResource() { cudaGraphicsUnmapResources(1, &_res, 0); }
virtual void *getBuffer() const {
cudaArray_t buffer;
try {
CHECK_EX(cudaGraphicsSubResourceGetMappedArray(&buffer, _res, 0, 0));
} catch (...) {
return nullptr;
}
return buffer;
}
operator T *() { return (T *)getBuffer(); }
glm::uvec2 textureSize() { return _textureSize; }
private:
glm::uvec2 _textureSize;
};
class Resources {
public:
std::map<std::string, Resource *> resources;
std::vector<cudaGraphicsResource_t> graphicsResources;
void addResource(const std::string &name, Resource *res) {
auto gres = dynamic_cast<GraphicsResource *>(res);
if (gres != nullptr)
graphicsResources.push_back(gres->getHandler());
resources[name] = res;
}
void clear() {
resources.clear();
graphicsResources.clear();
}
};
template <typename T, typename T2 = T>
void dumpArray(std::ostream &so, CudaArray<T> &arr, size_t maxDumpRows = 0,
size_t elemsPerRow = 1) {
int chns = sizeof(T) / sizeof(T2);
T2 *hostArr = new T2[arr.n() * chns];
cudaMemcpy(hostArr, arr.getBuffer(), arr.n() * sizeof(T), cudaMemcpyDeviceToHost);
dumpHostBuffer<T2>(so, hostArr, arr.n() * sizeof(T), chns * elemsPerRow, maxDumpRows);
delete[] hostArr;
}
\ No newline at end of file
cpp/utils/common.h
View file @ 1bc644a1
......@@ -8,32 +8,34 @@
#include <string>
#include <sstream>
#include <GL/glew.h>
#include <cuda_gl_interop.h>
#include <glm/glm.hpp>
#include "Logger.h"
#include "Eye.h"
#include "common/logger.h"
#include "common/fmt.h"
#ifdef WIN32
typedef unsigned int uint;
#endif
#ifndef _countof
#define _countof(x) (sizeof(x)/sizeof((x)[0]))
#ifndef COUNTOF
#define COUNTOF(__x__) (sizeof(__x__) / sizeof((__x__)[0]))
#endif
#ifndef CEILDIV
#define CEILDIV(__x__, __y__) (uint) ceil((__x__) / (float)(__y__))
#endif
#define INTERVAL(__start__, __end__) (((__end__) - (__start__)) / (float)CLOCKS_PER_SEC * 1000)
inline unsigned int getElementSize(nv::DataType t) {
inline uint getElementSize(nv::DataType t) {
switch (t) {
case nv::DataType::kINT32:
case nv::DataType::kFLOAT:
case nv::DataType::kFLOAT:
return 4;
case nv::DataType::kHALF:
return 2;
case nv::DataType::kBOOL:
case nv::DataType::kINT8:
return 1;
default:
throw std::runtime_error("Invalid DataType.");
}
default:
throw std::runtime_error("Invalid DataType.");
}
}
template <typename T> void dumpRow(std::ostream &os, T *buf, size_t n) {
......@@ -71,50 +73,6 @@ void dumpHostBuffer(std::ostream &os, T *buf, size_t bufSize, size_t rowCount,
}
}
class CudaStream {
public:
CudaStream() { cudaStreamCreate(&stream); }
operator cudaStream_t() { return stream; }
virtual ~CudaStream() { cudaStreamDestroy(stream); }
private:
cudaStream_t stream;
};
class CudaEvent {
public:
CudaEvent() { cudaEventCreate(&mEvent); }
operator cudaEvent_t() { return mEvent; }
virtual ~CudaEvent() { cudaEventDestroy(mEvent); }
private:
cudaEvent_t mEvent;
};
struct CudaMapScope {
std::vector<cudaGraphicsResource_t> resources_;
cudaStream_t stream_;
CudaMapScope(const std::vector<cudaGraphicsResource_t> &resources,
cudaStream_t stream = nullptr)
: resources_(resources), stream_(stream) {}
~CudaMapScope() {
if (!resources_.empty())
cudaGraphicsUnmapResources((int)resources_.size(), resources_.data(), stream_);
}
cudaError_t map() {
if (!resources_.empty())
return cudaGraphicsMapResources((int)resources_.size(), resources_.data(), stream_);
return cudaSuccess;
}
};
template <typename T> struct Destroy {
void operator()(T *t) {
if (t != nullptr)
......@@ -122,28 +80,9 @@ template <typename T> struct Destroy {
}
};
class Range {
public:
Range(glm::vec2 bound, uint steps) :
_start(bound.x),
_step((bound.y - bound.x) / (steps - 1)),
_steps(steps) {}
__host__ __device__ float get(uint i) { return _start + i * _step; }
__host__ __device__ float start() { return _start; }
__host__ __device__ float stop() { return _start + _step * _steps; }
__host__ __device__ uint steps() { return _steps; }
private:
float _start;
float _step;
uint _steps;
};
#include "Formatter.h"
template <class T> using uptr = std::unique_ptr<T, ::Destroy<T>>;
template <class T> using sptr = std::shared_ptr<T>;
#define INTERVAL(__start__, __end__) (((__end__) - (__start__)) / (float)CLOCKS_PER_SEC * 1000)
#include "Resource.h"
#include "Formatter.h"
\ No newline at end of file
enum Eye { Eye_Left, Eye_Right };
\ No newline at end of file
cpp/utils/common/fmt.h 0 → 100644
View file @ 1bc644a1
#include <string>
namespace utils::common {
template <typename... Args> static std::string fmt(const std::string &format, Args... args) {
auto size_buf = std::snprintf(nullptr, 0, format.c_str(), args...) + 1;
std::unique_ptr<char[]> buf(new (std::nothrow) char[size_buf]);
if (!buf)
return std::string("");
std::snprintf(buf.get(), size_buf, format.c_str(), args...);
return std::string(buf.get(), buf.get() + size_buf - 1);
}
template <typename... Args> static std::wstring fmt(const std::wstring &format, Args... args) {
auto size_buf = std::snprintf(nullptr, 0, format.c_str(), args...) + 1;
std::unique_ptr<char[]> buf(new (std::nothrow) char[size_buf]);
if (!buf)
return std::wstring("");
std::snprintf(buf.get(), size_buf, format.c_str(), args...);
return std::wstring(buf.get(), buf.get() + size_buf - 1);
}
} // namespace utils::common
cpp/utils/common/logger.cpp 0 → 100644
View file @ 1bc644a1
#include "logger.h"
#include <iostream>
#include <sstream>
#include <string>
namespace utils::common {
Logger Logger::instance;
void Logger::verbose(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
logf(nvinfer1::ILogger::Severity::kVERBOSE, fmt, args);
va_end(args);
}
void Logger::info(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
logf(nvinfer1::ILogger::Severity::kINFO, fmt, args);
va_end(args);
}
void Logger::warning(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
logf(nvinfer1::ILogger::Severity::kWARNING, fmt, args);
va_end(args);
}
void Logger::error(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
logf(nvinfer1::ILogger::Severity::kERROR, fmt, args);
va_end(args);
}
void Logger::log(nvinfer1::ILogger::Severity severity, const char *msg) noexcept {
if ((int)severity > logLevel)
return;
if (externalLogFunc == nullptr) {
switch (severity) {
case nvinfer1::ILogger::Severity::kVERBOSE:
std::cout << "[VERBOSE] " << msg << std::endl;
break;
case nvinfer1::ILogger::Severity::kINFO:
std::cout << "[INFO] " << msg << std::endl;
break;
case nvinfer1::ILogger::Severity::kWARNING:
std::cerr << "[WARNING] " << msg << std::endl;
break;
case nvinfer1::ILogger::Severity::kERROR:
std::cerr << "[ERROR] " << msg << std::endl;
break;
case nvinfer1::ILogger::Severity::kINTERNAL_ERROR:
std::cerr << "[ERROR] " << msg << std::endl;
break;
}
return;
}
externalLogFunc((int)severity, msg);
}
void Logger::logf(nvinfer1::ILogger::Severity severity, const char *fmt, va_list args) {
char buffer[4096];
vsprintf(buffer, fmt, args);
log(severity, buffer);
}
} // namespace utils::common
cpp/utils/common/logger.h 0 → 100644
View file @ 1bc644a1
#pragma once
#include <NvInfer.h>
#include <stdarg.h>
typedef void (*ExternalLogFuncPtr)(int severity, const char *);
namespace utils::common {
class Logger : public nvinfer1::ILogger {
public:
ExternalLogFuncPtr externalLogFunc = nullptr;
int logLevel = 1;
static Logger instance;
void verbose(const char *fmt, ...);
void info(const char *fmt, ...);
void warning(const char *fmt, ...);
void error(const char *fmt, ...);
virtual void log(nvinfer1::ILogger::Severity severity, const char *msg) noexcept;
void logf(nvinfer1::ILogger::Severity severity, const char *fmt, va_list args);
};
} // namespace utils::common
cpp/utils/cuda.h
View file @ 1bc644a1
#include "thread_index.h"
#include "cuda/index.h"
#include "cuda/error.h"
#include "cuda/event.h"
#include "cuda/stream.h"
#include "cuda/map_resources_scope.h"
#include "cuda/array.h"
#include "cuda/gl_texture.h"
#include "cuda/resources.h"
#ifdef __INTELLISENSE__
#define CU_INVOKE(__func__) __func__
......@@ -8,4 +15,3 @@
#define CU_INVOKE1(__func__, __grdSize__, __blkSize__) __func__<<<__grdSize__, __blkSize__>>>
#endif
inline unsigned int ceilDiv(unsigned int a, unsigned int b) { return (unsigned int)ceil(a / (float)b); }
\ No newline at end of file
cpp/utils/cuda/array.h 0 → 100644
View file @ 1bc644a1
#include "resource.h"
#include <vector>
namespace utils::cuda {
template <typename T> class Array : public BufferResource {
public:
Array(size_t n) : CudaBuffer(n * sizeof(T)) {}
Array(T *buffer, size_t n) : CudaBuffer(buffer, n * sizeof(T)) {}
Array(const std::vector<T> &hostArray) : CudaBuffer(hostArray.size() * sizeof(T)) {
cudaMemcpy(getBuffer(), hostArray.data(), size(), cudaMemcpyHostToDevice);
}
size_t n() const { return size() / sizeof(T); }
operator T *() { return (T *)getBuffer(); }
Array<T> subArray(size_t offset, size_t n = -1) {
if (n == -1)
n = this->n() - offset;
return Array<T>((T *)*this + offset, n);
}
};
} // namespace utils::cuda
cpp/utils/cuda/error.cpp 0 → 100644
View file @ 1bc644a1
#include "error.h"
#include "../common/logger.h"
namespace utils::cuda {
bool checkErr(cudaError_t err, const char *file, int line) {
if (err == cudaSuccess)
return true;
common::Logger::instance.error("Cuda error %s at %s (Line %d): %s", cudaGetErrorName(err),
file, line, cudaGetErrorString(err));
return false;
}
} // namespace utils::cuda
cpp/utils/cuda/error.h 0 → 100644
View file @ 1bc644a1
#include <cuda_runtime.h>
namespace utils::cuda {
bool checkErr(cudaError_t err, const char *file, int line);
} // namespace utils::cuda
#define RET_IF_FAILED(__ERR_CODE__) \
do { \
if (!utils::cuda::checkErr((__ERR_CODE__), __FILE__, __LINE__)) \
return false; \
} while (0)
#define THROW_IF_FAILED(__ERR_CODE__) \
do { \
if (!utils::cuda::checkErr((__ERR_CODE__), __FILE__, __LINE__)) \
throw std::exception(); \
} while (0)
cpp/utils/cuda/event.h 0 → 100644
View file @ 1bc644a1
#include <cuda_runtime.h>
#include <memory>
namespace utils::cuda {
class Event {
public:
Event() : _p_event(std::make_shared<cudaEvent_t>()) { cudaEventCreate(_p_event.get()); }
virtual ~Event() {
if (_p_event.use_count() == 1)
cudaEventDestroy(*_p_event);
}
operator cudaEvent_t() { return *_p_event; }
private:
std::shared_ptr<cudaEvent_t> _p_event;
};
} // namespace utils::cuda
cpp/utils/cuda/gl_texture.h 0 → 100644
View file @ 1bc644a1
#include <cuda_gl_interop.h>
#include "resource.h"
namespace utils::cuda {
template <typename T> class GlTextureResource : public GraphicsResource {
public:
GlTextureResource(GLuint textureID, glm::uvec2 textureSize) {
CHECK_EX(cudaGraphicsGLRegisterImage(&_res, textureID, GL_TEXTURE_2D,
cudaGraphicsRegisterFlagsWriteDiscard));
_size = textureSize.x * textureSize.y * sizeof(T);
_textureSize = textureSize;
}
virtual ~GlTextureResource() { cudaGraphicsUnmapResources(1, &_res, 0); }
virtual void *getBuffer() const {
cudaArray_t buffer;
try {
CHECK_EX(cudaGraphicsSubResourceGetMappedArray(&buffer, _res, 0, 0));
} catch (...) {
return nullptr;
}
return buffer;
}
operator T *() { return (T *)getBuffer(); }
glm::uvec2 textureSize() { return _textureSize; }
private:
glm::uvec2 _textureSize;
};
} // namespace utils::cuda
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