Compare commits

..

No commits in common. 'master' and 'absolute-shit' have entirely different histories.

2
.gitignore vendored

@ -4,5 +4,3 @@ cow-*
obj/ obj/
*~ *~
vgcore.* vgcore.*
target/
!cowslice/*.a

@ -5,7 +5,7 @@ PROJECT=cow
AUTHOR=Avril (Flanchan) <flanchan@cumallover.me> AUTHOR=Avril (Flanchan) <flanchan@cumallover.me>
VERSION_MAJOR=0 VERSION_MAJOR=0
VERSION_MINOR=3.0 VERSION_MINOR=2.0
VERSION=$(VERSION_MAJOR).$(VERSION_MINOR) VERSION=$(VERSION_MAJOR).$(VERSION_MINOR)
ifeq ($(PREFIX),) ifeq ($(PREFIX),)

@ -35,13 +35,6 @@ typedef struct cow_mapped_slice cow_t;
/// Writes to this instance pointer (`cow_ptr()`) are written to the allocated memory. /// Writes to this instance pointer (`cow_ptr()`) are written to the allocated memory.
/// Writes to any cloned instances do not propagate to this instance. /// Writes to any cloned instances do not propagate to this instance.
cow_t* cow_create(size_t size); cow_t* cow_create(size_t size);
/// Create a new copy-on-write area of `size` bytes from file `fd`.
/// Writes to this instance pointer (`cow_ptr()`) are written to the allocated memory.
/// Writes to any cloned instances do not propagate to this instance.
///
/// The resulting object does not own `fd`, but does own a duplicate of it.
cow_t* cow_create_fd(int fd, size_t size);
/// Free a cow area. This should be called on all clones before the parent of those clones is freed. /// Free a cow area. This should be called on all clones before the parent of those clones is freed.
void cow_free(cow_t* restrict cow); void cow_free(cow_t* restrict cow);
/// Create a clone of this instance. Any writes to the returned pointer will not be propagated to the input one. /// Create a clone of this instance. Any writes to the returned pointer will not be propagated to the input one.

@ -21,9 +21,7 @@ struct Cow : public _cow_util::Span<unsigned char> {
struct Fake; struct Fake;
Cow() = delete; Cow() = delete;
Cow(int fd, size_t size);
explicit Cow(size_t size); explicit Cow(size_t size);
Cow(Cow&& m); Cow(Cow&& m);
virtual ~Cow(); virtual ~Cow();

@ -3,68 +3,10 @@
#include <cow.hpp> #include <cow.hpp>
#include <utility> #include <utility>
template<typename T> XXX: Fuck this. Rewrite to use composition. Inheritance is a comlpete joke.
struct TypedCow : public _cow_util::Span<T> {
struct Fake;
template<typename... Args>
inline TypedCow(size_t sz, Args&&... args) : real(Cow(sz * sizeof(T))) { init_copy( T(std::forward<Args>(args)...) ); }
inline TypedCow(size_t sz, const T& copy) : real(Cow(sz * sizeof(T))) { init_copy(copy); }
inline TypedCow(size_t sz) : TypedCow(sz, T()){}
inline virtual ~TypedCow() { uninit(); }
inline virtual Fake clone() const { return Fake(*this); }
inline virtual cow_t* raw() const { return real.raw(); }
inline size_t size() const { return real.size() / sizeof(T); }
protected:
//inline explicit TypedCow(const TypedCow<T>& unsafeCopy) : real(Cow(unsafeCopy.real)){}
inline virtual void* area() override { return reinterpret_cast<void*>( real.ptr() ); }
inline virtual const void* area() const override { return reinterpret_cast<const void*>( real.ptr() ); }
inline void init_copy(const T& copy_from) {
T* ptr = this->ptr();
for(size_t i=0;i<size();i++)
new ((void*)(ptr+i)) T(copy_from);
}
// UNSAFE: Explicitly calls destructors of each element in this instance.
inline void uninit() {
T* ptr = this->ptr();
if(!ptr) return;
for(size_t i=0;i<size();i++)
(ptr+i)->~T();
}
private:
Cow real;
};
template<typename T> template<typename T>
struct TypedCow<T>::Fake : public TypedCow<T> { struct TypedCow : private Cow, public _cow_util::Span<T> {
//XXX: How THE FUCK do we initialise base's `real` here?????
Fake() = delete;
inline Fake(const Fake& copy) : fake(cow_clone(copy.fake)){}
inline Fake(Fake&& move) : fake(move.fake) { *const_cast<cow_t**>(&move.fake) = nullptr; }
inline Fake(const TypedCow<T>& clone) : fake(cow_clone(clone.raw())){}
inline cow_t* raw() const override { return fake; }
inline Fake clone() const override { return Fake(*this); }
inline ~Fake(){}
inline size_t size() const override { return fake ? cow_size(fake) : 0; }
protected:
inline void* area() override { return fake ? cow_ptr(fake) : nullptr; }
inline const void* area() const override { return fake ? cow_ptr_of(const void, fake) : nullptr; }
private:
cow_t* const fake;
};
#if 0
struct Fake; struct Fake;
friend class Fake; friend class Fake;
@ -74,8 +16,8 @@ struct TypedCow<T>::Fake : public TypedCow<T> {
inline TypedCow(size_t sz) : Cow(sz * sizeof(T)) { init_copy(T()); } inline TypedCow(size_t sz) : Cow(sz * sizeof(T)) { init_copy(T()); }
inline TypedCow(size_t sz, const T& copy_from) : TypedCow(sz) { init_copy(copy_from); } inline TypedCow(size_t sz, const T& copy_from) : TypedCow(sz) { init_copy(copy_from); }
//template<typename... Args> template<typename... Args>
//inline TypedCow(size_t sz, Args&&... args) : TypedCow(sz) { init_copy( T(std::forward<Args>(args)...) ); } inline TypedCow(size_t sz, Args&&... args) : TypedCow(sz) { init_copy( T(std::forward<Args>(args)...) ); }
virtual inline ~TypedCow() { uninit(); } virtual inline ~TypedCow() { uninit(); }
@ -118,4 +60,3 @@ struct TypedCow<T>::Fake : private Cow::Fake, public _cow_util::Span<T> {
inline const void* area() const override { return Cow::Fake::area(); } inline const void* area() const override { return Cow::Fake::area(); }
inline void* area() override { return Cow::Fake::area(); } inline void* area() override { return Cow::Fake::area(); }
}; };
#endif

@ -76,13 +76,13 @@ size_t cow_size(const cow_t* cow)
return cow->size; return cow->size;
} }
inline internal cow_t _cow_create_unboxed(int _fd, size_t size) inline internal cow_t _cow_create_unboxed(size_t size)
{ {
cow_t ret; cow_t ret;
ret.size = size; ret.size = size;
if( (ret.poisoned = if( (ret.poisoned =
((ret.fd = _fd < 0 ? shm_fd(size) : _fd) == -1)) ((ret.fd = shm_fd(size)) == -1))
) { ) {
ret.origin = NULL; ret.origin = NULL;
return ret; return ret;
@ -96,14 +96,7 @@ inline internal cow_t _cow_create_unboxed(int _fd, size_t size)
} }
cow_t* cow_create(size_t size) cow_t* cow_create(size_t size)
{ {
return box_value(_cow_create_unboxed(-1, size)); return box_value(_cow_create_unboxed(size));
}
cow_t* cow_create_fd(int fd, size_t size)
{
fd = dup(fd);
if(__builtin_expect(fd < 0, false)) return NULL;
return box_value(_cow_create_unboxed(fd, size));
} }
inline internal void _cow_free_unboxed(const cow_t* cow) inline internal void _cow_free_unboxed(const cow_t* cow)

@ -15,7 +15,6 @@ struct Cow::_inner {
~_inner(); ~_inner();
_inner(size_t sz); _inner(size_t sz);
_inner(int fd, size_t sz);
_inner(cow_t* ptr); _inner(cow_t* ptr);
_inner(const _inner& copy) = delete; _inner(const _inner& copy) = delete;
@ -28,12 +27,10 @@ Cow::_inner::~_inner() {
_cow_free_unboxed(ptr()); _cow_free_unboxed(ptr());
cow.poisoned=true; cow.poisoned=true;
} }
Cow::_inner::_inner(int fd, size_t sz) : cow(_cow_create_unboxed(fd, sz)){ Cow::_inner::_inner(size_t sz) : cow(_cow_create_unboxed(sz)){
if(UNLIKELY(cow.poisoned)) throw CowException(cow_err()); if(UNLIKELY(cow.poisoned)) throw CowException(cow_err());
} }
Cow::_inner::_inner(size_t sz) : _inner(-1, sz) {}
Cow::_inner::_inner(cow_t* ptr) : cow(*ptr) Cow::_inner::_inner(cow_t* ptr) : cow(*ptr)
{ {
free(ptr); free(ptr);
@ -41,7 +38,6 @@ Cow::_inner::_inner(cow_t* ptr) : cow(*ptr)
} }
Cow::Cow(size_t size) : super(std::make_shared<_inner>(size)){} Cow::Cow(size_t size) : super(std::make_shared<_inner>(size)){}
Cow::Cow(int fd, size_t size) : super(std::make_shared<_inner>(fd, size)){}
Cow::Cow(cow_t* raw) : super(std::make_shared<_inner>(raw)){} Cow::Cow(cow_t* raw) : super(std::make_shared<_inner>(raw)){}
Cow::Cow(Cow&& m) : super(std::move(*const_cast<std::shared_ptr<_inner>*>(&m.super))){} Cow::Cow(Cow&& m) : super(std::move(*const_cast<std::shared_ptr<_inner>*>(&m.super))){}

@ -44,7 +44,7 @@ _Static_assert
(offsetof(cow_t, size) == sizeof(void*), "`cow_t.size` should have an offset equal to `sizeof(void*)` or cow_size_unsafe() becomes UB."); (offsetof(cow_t, size) == sizeof(void*), "`cow_t.size` should have an offset equal to `sizeof(void*)` or cow_size_unsafe() becomes UB.");
#endif #endif
cow_t _cow_create_unboxed(int rfd, size_t size) internal; cow_t _cow_create_unboxed(size_t size) internal;
void _cow_free_unboxed(const cow_t* cow) internal; void _cow_free_unboxed(const cow_t* cow) internal;
#ifdef __cplusplus #ifdef __cplusplus

Loading…
Cancel
Save