3 changed files with 275 additions and 293 deletions
-
246offloading-cacher/cache-data.hpp
-
276offloading-cacher/cache.hpp
-
46offloading-cacher/util/dml-helper.hpp
@ -1,246 +0,0 @@ |
|||
#pragma once
|
|||
|
|||
#include <iostream>
|
|||
|
|||
#include <atomic>
|
|||
#include <memory>
|
|||
#include <vector>
|
|||
|
|||
#include <dml/dml.hpp>
|
|||
|
|||
#include "util/dml-helper.hpp"
|
|||
|
|||
namespace dsacache { |
|||
class Cache; |
|||
|
|||
// cache data holds all required information on
|
|||
// one cache entry and will both be stored
|
|||
// internally by the cache and handed out
|
|||
// as copies to the user
|
|||
// this class uses its object lifetime and
|
|||
// a global reference counter to allow
|
|||
// thread-safe copies and resource management
|
|||
|
|||
class CacheData { |
|||
public: |
|||
using dml_handler = dml::handler<dml::mem_copy_operation, std::allocator<uint8_t>>; |
|||
|
|||
private: |
|||
// data source and size of the block
|
|||
uint8_t* src_; |
|||
size_t size_; |
|||
|
|||
// global reference counting object
|
|||
std::atomic<int32_t>* active_; |
|||
|
|||
// global cache-location pointer
|
|||
std::atomic<uint8_t*>* cache_; |
|||
|
|||
// object-local incomplete cache location pointer
|
|||
// which is only available in the first instance
|
|||
uint8_t* incomplete_cache_; |
|||
|
|||
// dml handler vector pointer which is only
|
|||
// available in the first instance
|
|||
std::unique_ptr<std::vector<dml_handler>> handlers_; |
|||
|
|||
// deallocates the global cache-location
|
|||
// and invalidates it
|
|||
void Deallocate(); |
|||
|
|||
// checks whether there are at least two
|
|||
// valid references to this object which
|
|||
// is done as the cache always has one
|
|||
// internally to any living instance
|
|||
bool Active() const; |
|||
|
|||
friend Cache; |
|||
public: |
|||
CacheData(uint8_t* data, const size_t size); |
|||
CacheData(const CacheData& other); |
|||
~CacheData(); |
|||
|
|||
// waits on completion of caching operations
|
|||
// for this task and is safe to be called in
|
|||
// any state of the object
|
|||
void WaitOnCompletion(); |
|||
|
|||
// returns the cache data location for this
|
|||
// instance which is valid as long as the
|
|||
// instance is alive - !!! this may also
|
|||
// yield a nullptr !!!
|
|||
uint8_t* GetDataLocation() const; |
|||
}; |
|||
} |
|||
|
|||
inline void dsacache::CacheData::WaitOnCompletion() { |
|||
// the cache data entry can be in two states
|
|||
// either it is the original one which has not
|
|||
// been waited for in which case the handlers
|
|||
// are non-null or it is not
|
|||
|
|||
if (handlers_ == nullptr) { |
|||
std::cout << "[-] Waiting on cache-var-update for CacheData 0x" << std::hex << (uint64_t)src_ << std::dec << std::endl; |
|||
|
|||
// when no handlers are attached to this cache entry we wait on a
|
|||
// value change for the cache structure from nullptr to non-null
|
|||
// which will either go through immediately if the cache is valid
|
|||
// already or wait until the handler-owning thread notifies us
|
|||
|
|||
cache_->wait(nullptr); |
|||
|
|||
std::cout << "[+] Finished waiting on cache-var-update for CacheData 0x" << std::hex << (uint64_t)src_ << std::dec << std::endl; |
|||
} |
|||
else { |
|||
// when the handlers are non-null there are some DSA task handlers
|
|||
// available on which we must wait here
|
|||
|
|||
std::cout << "[-] Waiting on handlers for CacheData 0x" << std::hex << (uint64_t)src_ << std::dec << std::endl; |
|||
|
|||
// abort is set if any operation encountered an error
|
|||
|
|||
bool abort = false; |
|||
|
|||
for (auto& handler : *handlers_) { |
|||
auto result = handler.get(); |
|||
|
|||
if (result.status != dml::status_code::ok) { |
|||
std::cerr << "[x] Encountered bad status code for operation: " << dml::StatusCodeToString(result.status) << std::endl; |
|||
|
|||
// if one of the copy tasks failed we abort the whole task
|
|||
// after all operations are completed on it
|
|||
|
|||
abort = true; |
|||
} |
|||
} |
|||
|
|||
// the handlers are cleared after all have completed
|
|||
|
|||
handlers_ = nullptr; |
|||
|
|||
// now we act depending on whether an abort has been
|
|||
// called for which signals operation incomplete
|
|||
|
|||
if (abort) { |
|||
// store nullptr in the cache location
|
|||
|
|||
cache_->store(nullptr); |
|||
|
|||
// then free the now incomplete cache
|
|||
|
|||
// TODO: it would be possible to salvage the
|
|||
// TODO: operation at this point but this
|
|||
// TODO: is quite complicated so we just abort
|
|||
|
|||
numa_free(incomplete_cache_, size_); |
|||
} |
|||
else { |
|||
std::cout << "[+] Finished waiting on handlers for CacheData 0x" << std::hex << (uint64_t)src_ << std::dec << std::endl; |
|||
|
|||
// incomplete cache is now safe to use and therefore we
|
|||
// swap it with the global cache state of this entry
|
|||
// and notify potentially waiting threads
|
|||
|
|||
cache_->store(incomplete_cache_); |
|||
} |
|||
|
|||
// as a last step all waiting threads must
|
|||
// be notified (copies of this will wait on value
|
|||
// change of the cache) and the incomplete cache
|
|||
// is cleared to nullptr as it is not incomplete
|
|||
|
|||
cache_->notify_all(); |
|||
incomplete_cache_ = nullptr; |
|||
} |
|||
} |
|||
|
|||
inline dsacache::CacheData::CacheData(uint8_t* data, const size_t size) { |
|||
std::cout << "[-] New CacheData 0x" << std::hex << (uint64_t)data << std::dec << std::endl; |
|||
|
|||
src_ = data; |
|||
size_ = size; |
|||
active_ = new std::atomic<int32_t>(1); |
|||
cache_ = new std::atomic<uint8_t*>(); |
|||
incomplete_cache_ = nullptr; |
|||
handlers_ = std::make_unique<std::vector<dml_handler>>(); |
|||
} |
|||
|
|||
inline dsacache::CacheData::CacheData(const dsacache::CacheData& other) { |
|||
std::cout << "[-] Copy Created for CacheData 0x" << std::hex << (uint64_t)other.src_ << std::dec << std::endl; |
|||
|
|||
// we copy the ptr to the global atomic reference counter
|
|||
// and increase the amount of active references
|
|||
|
|||
active_ = other.active_; |
|||
const int current_active = active_->fetch_add(1); |
|||
|
|||
// source and size will be copied too
|
|||
// as well as the reference to the global
|
|||
// atomic cache pointer
|
|||
|
|||
src_ = other.src_; |
|||
size_ = other.size_; |
|||
cache_ = other.cache_; |
|||
|
|||
// incomplete cache and handlers will not
|
|||
// be copied because only the first instance
|
|||
// will wait on the completion of handlers
|
|||
|
|||
incomplete_cache_ = nullptr; |
|||
handlers_ = nullptr; |
|||
} |
|||
|
|||
inline dsacache::CacheData::~CacheData() { |
|||
std::cout << "[-] Destructor for CacheData 0x" << std::hex << (uint64_t)src_ << std::dec << std::endl; |
|||
|
|||
// if this is the first instance of this cache structure
|
|||
// and it has not been waited on and is now being destroyed
|
|||
// we must wait on completion here to ensure the cache
|
|||
// remains in a valid state
|
|||
|
|||
if (handlers_ != nullptr) { |
|||
WaitOnCompletion(); |
|||
} |
|||
|
|||
// due to fetch_sub returning the preivously held value
|
|||
// we must subtract one locally to get the current value
|
|||
|
|||
const int32_t v = active_->fetch_sub(1) - 1; |
|||
|
|||
// if the returned value is zero or lower
|
|||
// then we must execute proper deletion
|
|||
// as this was the last reference
|
|||
|
|||
if (v <= 0) { |
|||
std::cout << "[!] Full Destructor for CacheData 0x" << std::hex << (uint64_t)src_ << std::dec << std::endl; |
|||
|
|||
Deallocate(); |
|||
|
|||
delete active_; |
|||
delete cache_; |
|||
} |
|||
} |
|||
|
|||
inline void dsacache::CacheData::Deallocate() { |
|||
std::cout << "[!] Deallocating for CacheData 0x" << std::hex << (uint64_t)src_ << std::dec << std::endl; |
|||
|
|||
// although deallocate should only be called from
|
|||
// a safe context to do so, it can not hurt to
|
|||
// defensively perform the operation atomically
|
|||
|
|||
uint8_t* cache_local = cache_->exchange(nullptr); |
|||
if (cache_local != nullptr) numa_free(cache_local, size_); |
|||
} |
|||
|
|||
inline uint8_t* dsacache::CacheData::GetDataLocation() const { |
|||
return cache_->load(); |
|||
} |
|||
|
|||
inline bool dsacache::CacheData::Active() const { |
|||
// this entry is active if more than one
|
|||
// reference exists to it, as the Cache
|
|||
// will always keep one internally until
|
|||
// the entry is cleared from cache
|
|||
|
|||
return active_->load() > 1; |
|||
} |
|||
@ -1,46 +0,0 @@ |
|||
#pragma once
|
|||
|
|||
#include <dml/dml.hpp>
|
|||
|
|||
namespace dml { |
|||
inline const std::string StatusCodeToString(const dml::status_code code) { |
|||
switch (code) { |
|||
case dml::status_code::ok: |
|||
return "ok"; |
|||
case dml::status_code::false_predicate: |
|||
return "false predicate"; |
|||
case dml::status_code::partial_completion: |
|||
return "partial completion"; |
|||
case dml::status_code::nullptr_error: |
|||
return "nullptr error"; |
|||
case dml::status_code::bad_size: |
|||
return "bad size"; |
|||
case dml::status_code::bad_length: |
|||
return "bad length"; |
|||
case dml::status_code::inconsistent_size: |
|||
return "inconsistent size"; |
|||
case dml::status_code::dualcast_bad_padding: |
|||
return "dualcast bad padding"; |
|||
case dml::status_code::bad_alignment: |
|||
return "bad alignment"; |
|||
case dml::status_code::buffers_overlapping: |
|||
return "buffers overlapping"; |
|||
case dml::status_code::delta_delta_empty: |
|||
return "delta delta empty"; |
|||
case dml::status_code::batch_overflow: |
|||
return "batch overflow"; |
|||
case dml::status_code::execution_failed: |
|||
return "execution failed"; |
|||
case dml::status_code::unsupported_operation: |
|||
return "unsupported operation"; |
|||
case dml::status_code::queue_busy: |
|||
return "queue busy"; |
|||
case dml::status_code::error: |
|||
return "unknown error"; |
|||
case dml::status_code::config_error: |
|||
return "config error"; |
|||
default: |
|||
return "unhandled error"; |
|||
} |
|||
} |
|||
} |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue