commit
07cd0c252d
GPG Key ID:
284488987C31F630
@ -0,0 +1 @@
|
||||
Complete rewrite using `mmap` et al. Maybe in Rust of C++ idk
|
||||
@ -0,0 +1,73 @@
|
||||
SRC_C = $(wildcard src/*.c)
|
||||
SRC_CXX = $(wildcard src/*.cpp)
|
||||
SRC_CXX+= $(wildcard src/rng/*.cpp)
|
||||
|
||||
INCLUDE = include
|
||||
|
||||
PROJECT=shuffle3
|
||||
|
||||
COMMON_FLAGS = -Wall -pedantic $(addprefix -I,$(INCLUDE)) -fno-strict-aliasing
|
||||
|
||||
OPT_FLAGS?= -march=native -fgraphite -fopenmp -floop-parallelize-all -ftree-parallelize-loops=4 \
|
||||
-floop-interchange -ftree-loop-distribution -floop-strip-mine -floop-block \
|
||||
-fno-stack-check
|
||||
|
||||
CXX_OPT_FLAGS?= $(OPT_FLAGS) -felide-constructors
|
||||
|
||||
CFLAGS += $(COMMON_FLAGS) --std=gnu11
|
||||
CXXFLAGS += $(COMMON_FLAGS) --std=gnu++20 -fno-exceptions
|
||||
LDFLAGS += -lfmt
|
||||
|
||||
STRIP=strip
|
||||
|
||||
RELEASE_CFLAGS?= -O3 -flto $(OPT_FLAGS)
|
||||
RELEASE_CXXFLAGS?= -O3 -flto $(CXX_OPT_FLAGS)
|
||||
RELEASE_LDFLAGS?= -O3 -flto
|
||||
|
||||
DEBUG_CFLAGS?= -O0 -g -DDEBUG
|
||||
DEBUG_CXXFLAGS?= $(DEBUG_CFLAGS)
|
||||
DEBUG_LDFLAGS?=
|
||||
|
||||
# Objects
|
||||
|
||||
OBJ_C = $(addprefix obj/c/,$(SRC_C:.c=.o))
|
||||
OBJ_CXX = $(addprefix obj/cxx/,$(SRC_CXX:.cpp=.o))
|
||||
OBJ = $(OBJ_C) $(OBJ_CXX)
|
||||
|
||||
# Phonies
|
||||
|
||||
.PHONY: release
|
||||
release: | dirs $(PROJECT)-release
|
||||
|
||||
.PHONY: debug
|
||||
debug: | dirs $(PROJECT)-debug
|
||||
|
||||
# Targets
|
||||
|
||||
dirs:
|
||||
@mkdir -p obj/c{,xx}/src
|
||||
@mkdir -p obj/cxx/src/rng
|
||||
|
||||
obj/c/%.o: %.c
|
||||
$(CC) -c $< $(CFLAGS) -o $@ $(LDFLAGS)
|
||||
|
||||
obj/cxx/%.o: %.cpp
|
||||
$(CXX) -c $< $(CXXFLAGS) -o $@ $(LDFLAGS)
|
||||
|
||||
|
||||
$(PROJECT)-release: CFLAGS+= $(RELEASE_CFLAGS)
|
||||
$(PROJECT)-release: CXXFLAGS += $(RELEASE_CXXFLAGS)
|
||||
$(PROJECT)-release: LDFLAGS += $(RELEASE_LDFLAGS)
|
||||
$(PROJECT)-release: $(OBJ)
|
||||
$(CXX) $^ $(CXXFLAGS) -o $@ $(LDFLAGS)
|
||||
$(STRIP) $@
|
||||
|
||||
$(PROJECT)-debug: CFLAGS+= $(DEBUG_CFLAGS)
|
||||
$(PROJECT)-debug: CXXFLAGS += $(DEBUG_CXXFLAGS)
|
||||
$(PROJECT)-debug: LDFLAGS += $(DEBUG_LDFLAGS)
|
||||
$(PROJECT)-debug: $(OBJ)
|
||||
$(CXX) $^ $(CXXFLAGS) -o $@ $(LDFLAGS)
|
||||
|
||||
clean:
|
||||
rm -rf obj
|
||||
rm -f $(PROJECT)-{release,debug}
|
||||
@ -0,0 +1,35 @@
|
||||
* shuffle3-lean
|
||||
Redegisn/upgrade of =shuffle3=
|
||||
|
||||
* Goals
|
||||
- [X] Functioning in-place shuffle/unshuffle
|
||||
- [X] Shuffle
|
||||
- [X] Unshuffle
|
||||
- [X] Usable in-place s/us from command line
|
||||
- [X] Shuffle
|
||||
- [X] Unshuffle
|
||||
- [ ] Functioning out-of-place/in-memory shuffle/unshuffle
|
||||
- [ ] Shuffle
|
||||
- [ ] Unshuffle
|
||||
- [ ] Usable out-of-place s/us from command line
|
||||
- [ ] Shuffle
|
||||
- [ ] Unshuffle
|
||||
|
||||
** NO compatibility with =shuffle3=
|
||||
=shuffle3='s ~drng~ PRNG algorithm uses an outdated global state backend. We don't want to reuse this.
|
||||
As a result, output from =shuffle3= and =shuffle3-lean= is different.
|
||||
|
||||
* Improvements
|
||||
- *~70-80x* speedup from shuffle3 1.0
|
||||
- Huge reduction in syscalls
|
||||
- Takes advantage of the kernel's fs cache
|
||||
- Can properly handle large files without core dumping
|
||||
- Doesn't dump huge amounts of trash onto each stack frame
|
||||
|
||||
* Todo
|
||||
- [X] impl rng
|
||||
- [X] impl shuffling
|
||||
- [ ] impl out-of-place shuffling
|
||||
- [-] arg parsing and dispatch
|
||||
- [X] simple parsing
|
||||
- [ ] complex parsing
|
||||
@ -0,0 +1,28 @@
|
||||
// https://stackoverflow.com/a/30304782
|
||||
|
||||
#ifndef _COLORS_
|
||||
#define _COLORS_
|
||||
|
||||
/* FOREGROUND */
|
||||
#define RST "\x1B[0m"
|
||||
#define KRED "\x1B[31m"
|
||||
#define KGRN "\x1B[32m"
|
||||
#define KYEL "\x1B[33m"
|
||||
#define KBLU "\x1B[34m"
|
||||
#define KMAG "\x1B[35m"
|
||||
#define KCYN "\x1B[36m"
|
||||
#define KWHT "\x1B[37m"
|
||||
|
||||
#define FRED(x) KRED x RST
|
||||
#define FGRN(x) KGRN x RST
|
||||
#define FYEL(x) KYEL x RST
|
||||
#define FBLU(x) KBLU x RST
|
||||
#define FMAG(x) KMAG x RST
|
||||
#define FCYN(x) KCYN x RST
|
||||
#define FWHT(x) KWHT x RST
|
||||
|
||||
#define BOLD(x) "\x1B[1m" x RST
|
||||
#define UNDL(x) "\x1B[4m" x RST
|
||||
|
||||
#endif /* _COLORS_ */
|
||||
|
||||
@ -0,0 +1,43 @@
|
||||
#ifndef _DEBUG_H
|
||||
#define _DEBUG_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct debuginfo {
|
||||
const char* file;
|
||||
const char* function;
|
||||
int line;
|
||||
};
|
||||
|
||||
void _do_dprintf(struct debuginfo di, const char* fmt, ...);
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C++" {
|
||||
#include <utility>
|
||||
template<typename... Args>
|
||||
inline void _real_dprintf(const char* file, const char* function, int line, const char* fmt, Args&&... args)
|
||||
{
|
||||
#ifdef DEBUG
|
||||
debuginfo i = { file, function, line };
|
||||
_do_dprintf(i, fmt, std::forward<Args>(args)...);
|
||||
#endif
|
||||
}
|
||||
#define D_dprintf(fmt, ...) _real_dprintf(__FILE__, __func__, __LINE__, fmt __VA_OPT__(,) __VA_ARGS__)
|
||||
}
|
||||
#else
|
||||
|
||||
#ifdef DEBUG
|
||||
#define D_dprintf(fmt, ...) _do_dprintf( (struct debuginfo){.file = __FILE__, .function = __func__, .line = __LINE__}, fmt __VA_OPT__(,) __VA_ARGS__)
|
||||
#else
|
||||
static inline void _do__nothing(const char* fmt, ...) {}
|
||||
#define D_dprintf(fmt, ...) _do__nothing(fmt __VA_OPT__(,) __VA_ARGS__) //(fmt __VA_OPT__(,) __VA_ARGS__, (void)0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _DEBUG_H */
|
||||
@ -0,0 +1,74 @@
|
||||
#ifndef _MAP_H
|
||||
#define _MAP_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#define restrict __restrict__
|
||||
#endif
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
typedef struct mmap {
|
||||
int fd;
|
||||
|
||||
void* ptr;
|
||||
size_t len;
|
||||
} mmap_t;
|
||||
|
||||
int open_and_map(const char* file, mmap_t* restrict ptr);
|
||||
int unmap_and_close(mmap_t map);
|
||||
|
||||
typedef void* (*map_cb)(mmap_t map, void* user);
|
||||
void* map_and_then(const char* file, map_cb callback, void* user);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#include <panic.h>
|
||||
#include "reinterpret.h"
|
||||
#include <cstdint>
|
||||
namespace mm {
|
||||
struct mmap {
|
||||
inline static mmap_t create_raw(const char* file)
|
||||
{
|
||||
mmap_t map;
|
||||
if (!open_and_map(file, &map)) panic("Failed to map file");
|
||||
return map;
|
||||
}
|
||||
|
||||
inline mmap(mmap_t raw) :inner(raw){}
|
||||
inline mmap(const char* file)
|
||||
: inner(create_raw(file)) {}
|
||||
|
||||
inline mmap(mmap&& move) : inner(move.inner)
|
||||
{
|
||||
auto other = const_cast<mmap_t*>(&move.inner);
|
||||
other->ptr = nullptr;
|
||||
}
|
||||
inline mmap(const mmap& copt) = delete;
|
||||
|
||||
inline ~mmap()
|
||||
{
|
||||
if (inner.ptr) {
|
||||
::unmap_and_close(inner);
|
||||
}
|
||||
}
|
||||
|
||||
inline const span<const unsigned char> as_span() const { return span(as_ptr(), size()); }
|
||||
inline span<unsigned char> as_span() { return span(as_ptr(), size()); }
|
||||
|
||||
inline const std::uint8_t* as_ptr() const { return (const std::uint8_t*)inner.ptr; }
|
||||
inline std::uint8_t* as_ptr() { return (std::uint8_t*)inner.ptr; }
|
||||
|
||||
inline std::size_t size() const { return inner.len; }
|
||||
|
||||
inline int as_fd() const { return inner.fd; }
|
||||
inline const mmap_t& as_raw() const { return inner; }
|
||||
private:
|
||||
const mmap_t inner;
|
||||
};
|
||||
}
|
||||
|
||||
#undef restrict
|
||||
#endif
|
||||
|
||||
#endif /* _MAP_H */
|
||||
@ -0,0 +1,35 @@
|
||||
#ifndef _PANIC_H
|
||||
#define _PANIC_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct panicinfo {
|
||||
const char* file;
|
||||
const char* function;
|
||||
int line;
|
||||
};
|
||||
|
||||
void _do_panic(struct panicinfo pi, const char* fmt, ...) __attribute__((noreturn));
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C++" {
|
||||
#include <utility>
|
||||
template<typename... Args>
|
||||
__attribute__((noreturn)) inline void _real_panic(const char* file, const char* function, int line, const char* fmt, Args&&... args)
|
||||
{
|
||||
panicinfo i = { file, function, line };
|
||||
_do_panic(i, fmt, std::forward<Args>(args)...);
|
||||
}
|
||||
#define panic(fmt, ...) _real_panic(__FILE__, __func__, __LINE__, fmt __VA_OPT__(,) __VA_ARGS__)
|
||||
}
|
||||
#else
|
||||
#define panic(fmt, ...) _do_panic( (struct panicinfo){.file = __FILE__, .function = __func__, .line = __LINE__}, fmt __VA_OPT__(,) __VA_ARGS__)
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1 @@
|
||||
reinterpret.hpp
|
||||
@ -0,0 +1,61 @@
|
||||
#ifndef _REINTERPRET_H
|
||||
#define _REINTERPRET_H
|
||||
|
||||
#include <panic.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
#define restrict __restrict__
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#else
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
template<typename T>
|
||||
struct span {
|
||||
inline span(T* ptr, std::size_t len) : ptr(ptr), len(len) {}
|
||||
|
||||
template<typename U>
|
||||
inline span<U> reinterpret() const
|
||||
{
|
||||
auto bytes = size_bytes();
|
||||
//if (len_b % sizeof(U) != 0) panic("Cannot reinterpret T to U due to unmatch sizing constraints.");
|
||||
|
||||
return span<U>((U*)ptr, bytes / sizeof(U));
|
||||
}
|
||||
|
||||
inline const T& operator[](std::size_t i) const
|
||||
{
|
||||
if (i >= len) panic("Out of bounds access: %lu >= %lu", i, len);
|
||||
return ptr[i];
|
||||
}
|
||||
inline T& operator[](std::size_t i)
|
||||
{
|
||||
if (i >= len) panic("Out of bounds access: %lu >= %lu", i, len);
|
||||
return ptr[i];
|
||||
}
|
||||
|
||||
inline const T* as_ptr() const { return ptr; }
|
||||
inline T* as_ptr() { return ptr; }
|
||||
|
||||
inline const T* operator&() const { return as_ptr(); }
|
||||
inline T* operator&() { return as_ptr(); }
|
||||
|
||||
inline std::size_t size_bytes() const { return len * sizeof(T); }
|
||||
inline std::size_t size() const { return len; }
|
||||
private:
|
||||
T* const ptr;
|
||||
const std::size_t len;
|
||||
};
|
||||
|
||||
extern "C" {
|
||||
#endif
|
||||
uint64_t* bytes_to_long(uint8_t* ptr, size_t ptr_sz, size_t* restrict nsize);
|
||||
float* bytes_to_float(uint8_t* ptr, size_t ptr_sz, size_t* restrict nsize);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _REINTERPRET_H */
|
||||
@ -0,0 +1,59 @@
|
||||
#ifndef _RNG_H
|
||||
#define _RNG_H
|
||||
|
||||
#include "shuffle3.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
enum rng_kind {
|
||||
RNG_KIND_FRNG,
|
||||
RNG_KIND_DRNG,
|
||||
RNG_KIND_XORNG,
|
||||
};
|
||||
|
||||
typedef struct rng_init
|
||||
{
|
||||
enum rng_kind kind;
|
||||
union {
|
||||
struct {
|
||||
double state[2];
|
||||
} frng;
|
||||
struct {
|
||||
int32_t state;
|
||||
} drng;
|
||||
struct {
|
||||
uint64_t state[2];
|
||||
} xorng;
|
||||
} init;
|
||||
|
||||
} rng_init_opt;
|
||||
|
||||
typedef struct rng_impl* _UNIQUE rng_t;
|
||||
|
||||
rng_t rng_new(rng_init_opt kind);
|
||||
#define RNG_INIT(_kind,...) ((rng_init_opt){.kind=(_kind), .init.__VA_ARGS__ })
|
||||
void rng_free(rng_t ptr);
|
||||
|
||||
// Tests
|
||||
extern void rng_test();
|
||||
extern void rng_test_spec(rng_t rng);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
// RNG interfaces
|
||||
#include <rng/frng.hpp>
|
||||
#include <rng/drng.hpp>
|
||||
#include <rng/xoroshiro128plus.hpp>
|
||||
|
||||
namespace rng {
|
||||
void test_algo(RNG&& rng);
|
||||
|
||||
template<class R,
|
||||
typename std::enable_if<std::is_base_of<RNG, R>::value>::value __fuck>
|
||||
inline void test_algo(R&& rng) { test_algo(static_cast<RNG&&>(rng)); }
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _RNG_H */
|
||||
@ -0,0 +1,22 @@
|
||||
|
||||
#include "impl.hpp"
|
||||
#include <debug.h>
|
||||
namespace rng
|
||||
{
|
||||
struct drng : public RNG
|
||||
{
|
||||
inline drng(std::uint32_t seed) : state(seed){
|
||||
D_dprintf("drng: seeded with %u", seed);
|
||||
//dprintf(" dummy run sample: %f", sample());
|
||||
}
|
||||
inline drng() : drng(1){}
|
||||
|
||||
static drng from_time();
|
||||
|
||||
int rand();
|
||||
protected:
|
||||
double sample() override;
|
||||
private:
|
||||
std::uint32_t state;
|
||||
};
|
||||
}
|
||||
@ -0,0 +1,66 @@
|
||||
|
||||
#include "impl.hpp"
|
||||
#include <cmath>
|
||||
|
||||
#include <debug.h>
|
||||
|
||||
namespace rng
|
||||
{
|
||||
struct frng : public RNG
|
||||
{
|
||||
template<std::size_t N>
|
||||
static constexpr inline double dot(const std::array<double, N>& v, const std::array<double, N>& u)
|
||||
{
|
||||
double res=0;
|
||||
for(std::size_t i=0;i<N;i++)
|
||||
{
|
||||
res += v[i] * u[i];
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
static inline constexpr double fract(double x)
|
||||
{
|
||||
return x - floor(x);
|
||||
}
|
||||
static inline constexpr double sample_double(const std::array<double, 2>& state)
|
||||
{
|
||||
const constexpr std::array<double, 2> vec2 = { 12.9898, 78.223 };
|
||||
return fract(sin(dot(state, vec2)) * 43758.5453);
|
||||
}
|
||||
|
||||
#define P D_dprintf("frng: seeded with (%f, %f)", state[0], state[1]);
|
||||
inline constexpr frng(double s1, double s2) : state({s1, s2}){P}
|
||||
inline constexpr frng(const std::array<double, 2>& ar) : state(ar){P}
|
||||
inline constexpr frng(std::array<double, 2>&& ar) : state(ar){P}
|
||||
inline constexpr frng(const double (&ar)[2]) : state({ar[0], ar[1]}) {P}
|
||||
#undef P
|
||||
inline constexpr double next_double() override { return sample(); }
|
||||
inline constexpr float next_float() override { return (float)sample(); }
|
||||
protected:
|
||||
inline constexpr double sample() override
|
||||
{
|
||||
double res = sample_double(state);
|
||||
update_state(state, res);
|
||||
return res;
|
||||
}
|
||||
private:
|
||||
std::array<double, 2> state;
|
||||
static inline constexpr void update_state(std::array<double, 2>& state, double r)
|
||||
{
|
||||
float v1 = (float)state[0];
|
||||
float v2 = (float)state[1];
|
||||
|
||||
std::array<double, 2> nvec = {
|
||||
r,
|
||||
(double)v2,
|
||||
};
|
||||
|
||||
state[0] = sample_double(nvec);
|
||||
|
||||
nvec[1] = (double)v1;
|
||||
state[1] = sample_double(nvec);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@ -0,0 +1,35 @@
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <vector>
|
||||
#include <cstdint>
|
||||
|
||||
/// Base class for RNG impls
|
||||
struct RNG {
|
||||
virtual unsigned char byte();
|
||||
virtual void bytes(unsigned char* ptr, std::size_t len);
|
||||
|
||||
template<std::size_t N>
|
||||
inline void bytes(unsigned char (&arr)[N]) { return bytes(arr, N); }
|
||||
template<std::size_t N>
|
||||
inline void bytes(std::array<unsigned char, N>& array) { return bytes(&array[0], N); }
|
||||
inline void bytes(std::vector<unsigned char>& vec) { return bytes(&vec[0], vec.size()); }
|
||||
|
||||
bool chance();
|
||||
virtual bool chance(double chance);
|
||||
|
||||
virtual std::int32_t next_int();
|
||||
inline std::int32_t next_int(std::int32_t max) { return next_int(0, max); }
|
||||
std::int32_t next_int(std::int32_t min, std::int32_t max);
|
||||
|
||||
virtual std::int64_t next_long();
|
||||
inline std::int64_t next_long(std::int64_t max) { return next_long(0, max); }
|
||||
std::int64_t next_long(std::int64_t min, std::int64_t max);
|
||||
|
||||
inline virtual float next_float() { return (float)sample(); }
|
||||
inline virtual double next_double() { return sample(); }
|
||||
|
||||
virtual ~RNG() = default;
|
||||
protected:
|
||||
virtual double sample() = 0;
|
||||
};
|
||||
@ -0,0 +1,29 @@
|
||||
#pragma once
|
||||
|
||||
#include "impl.hpp"
|
||||
#include <debug.h>
|
||||
|
||||
namespace rng
|
||||
{
|
||||
struct xoroshiro128plus : public RNG
|
||||
{
|
||||
using State = std::array<std::uint64_t, 2>;
|
||||
#define P D_dprintf("xorng: seeded with (%lu, %lu)", state[0], state[1]);
|
||||
inline constexpr xoroshiro128plus(std::uint64_t s0, std::uint64_t s1) : state({s0, s1}){P}
|
||||
inline constexpr xoroshiro128plus(std::array<std::uint64_t, 2>&& ar) : state(ar){P}
|
||||
inline constexpr xoroshiro128plus(const std::array<std::uint64_t, 2>& ar) : state(ar){P}
|
||||
inline constexpr xoroshiro128plus(const std::uint64_t (&ar)[2]) : state({ar[0], ar[1]}){P}
|
||||
#undef P
|
||||
std::uint64_t next_ulong();
|
||||
using RNG::next_long;
|
||||
std::int64_t next_long() override;
|
||||
|
||||
void jump();
|
||||
void long_jump();
|
||||
protected:
|
||||
double sample() override;
|
||||
private:
|
||||
State state;
|
||||
};
|
||||
}
|
||||
|
||||
@ -0,0 +1,38 @@
|
||||
#pragma once
|
||||
|
||||
#include <rng.h>
|
||||
#include <reinterpret.h>
|
||||
#include <algorithm>
|
||||
#include <fmt/format.h>
|
||||
|
||||
namespace rng {
|
||||
template<typename T, typename R>
|
||||
inline void shuffle(R& rng, span<T> span)
|
||||
{
|
||||
if(!span.size()) return;
|
||||
fmt::print(" -> shuffling {} objects...", span.size());
|
||||
for(std::size_t i=span.size()-1;i>0;i--)
|
||||
{
|
||||
auto j = rng.next_long(i);
|
||||
std::swap(span[i], span[j]);
|
||||
}
|
||||
fmt::print(" OK\n");
|
||||
}
|
||||
|
||||
template<typename T, typename R>
|
||||
inline void unshuffle(R& rng, span<T> span)
|
||||
{
|
||||
if(!span.size()) return;
|
||||
std::vector<std::size_t> rng_values(span.size());
|
||||
|
||||
fmt::print(" -> unshuffling {} objects...", span.size());
|
||||
for(std::size_t i=span.size()-1;i>0;i--)
|
||||
rng_values.push_back(rng.next_long(i));
|
||||
|
||||
for(std::size_t i=1;i<span.size();i++) {
|
||||
std::swap(span[i], span[rng_values.back()]);
|
||||
rng_values.pop_back();
|
||||
}
|
||||
fmt::print(" OK\n");
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,30 @@
|
||||
#ifndef _SHUFFLE3_H
|
||||
#define _SHUFFLE3_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
#define _UNIQUE __restrict
|
||||
extern "C" {
|
||||
#else
|
||||
#define _UNIQUE restrict
|
||||
#endif
|
||||
|
||||
#ifdef DEBUG
|
||||
#define _FORCE_INLINE __attribute__((gnu_inline)) static inline
|
||||
#else
|
||||
#define _FORCE_INLINE __attribute__((gnu_inline)) extern inline
|
||||
#endif
|
||||
|
||||
/*
|
||||
#ifdef DEBUG
|
||||
#define dprintf(fmt, ...) printf("[dbg @" __FILE__ "->%s:%d] " fmt "\n", __func__, __LINE__ __VA_OPT__(,) __VA_ARGS__)
|
||||
#else
|
||||
#define dprintf(fmt, ...)
|
||||
#endif
|
||||
*/
|
||||
extern const char* _prog_name;
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _SHUFFLE3_H */
|
||||
@ -0,0 +1,52 @@
|
||||
#ifndef _WORK_H
|
||||
#define _WORK_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
enum work_buffer_opts {
|
||||
WORK_BO_CPIP=0, // Copy then run in place on output file (default)
|
||||
WORK_BO_BUFFERED=1, // Read whole input into memory then perform
|
||||
};
|
||||
|
||||
typedef struct _work_args {
|
||||
enum {
|
||||
OP_SHUFFLE_IP, // Shuffle in place
|
||||
OP_SHUFFLE_OP, // Shuffle out of place
|
||||
|
||||
OP_UNSHUFFLE_IP, // Unshuffle in place
|
||||
OP_UNSHUFFLE_OP, // Unshuffle out of place
|
||||
|
||||
OP_HELP, // Print help then exit
|
||||
} op;
|
||||
union {
|
||||
struct {
|
||||
const char* file;
|
||||
} op_shuffle_ip;
|
||||
|
||||
struct {
|
||||
enum work_buffer_opts buffered;
|
||||
const char* ifile;
|
||||
const char* ofile;
|
||||
} op_shuffle_op;
|
||||
|
||||
struct {
|
||||
const char* file;
|
||||
} op_unshuffle_ip;
|
||||
|
||||
struct {
|
||||
enum work_buffer_opts buffered;
|
||||
const char* ifile;
|
||||
const char* ofile;
|
||||
} op_unshuffle_op;
|
||||
} data;
|
||||
} work_args_t;
|
||||
|
||||
int do_work(const work_args_t args);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _WORK_H */
|
||||
@ -0,0 +1,19 @@
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <debug.h>
|
||||
|
||||
#include <colours.h>
|
||||
|
||||
void _do_dprintf(struct debuginfo info, const char* fmt, ...)
|
||||
{
|
||||
#ifdef DEBUG
|
||||
va_list li;
|
||||
va_start(li, fmt);
|
||||
fprintf(stderr, "["FGRN("dbg")" " FYEL("@") BOLD("%s") "->" FWHT("%s") ":" FYEL("%d") "]: ", info.file, info.function,info.line);
|
||||
vfprintf(stderr, fmt, li);
|
||||
fprintf(stderr, "\n");
|
||||
va_end(li);
|
||||
#endif
|
||||
}
|
||||
@ -0,0 +1,78 @@
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include <string.h>
|
||||
|
||||
|
||||
#include <shuffle3.h>
|
||||
#include <panic.h>
|
||||
#include <reinterpret.h>
|
||||
#include <map.h>
|
||||
#include <rng.h>
|
||||
#include <work.h>
|
||||
|
||||
#include <debug.h>
|
||||
|
||||
#define noreturn __attribute__((noreturn)) void
|
||||
|
||||
_Static_assert(sizeof(float)==sizeof(uint32_t), "float is not 32 bits");
|
||||
|
||||
const char* _prog_name;
|
||||
|
||||
noreturn help_then_exit()
|
||||
{
|
||||
fprintf(stderr, "Try passing `-h`\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
void usage()
|
||||
{
|
||||
printf( "shuffle3 - 3 pass binary shuffler\n"
|
||||
"Usage: %s -s <file>\n"
|
||||
"Usage: %s -u <file>\n", _prog_name, _prog_name);
|
||||
printf("\nOPTIONS:\n"
|
||||
" -s\tShuffle file in place\n"
|
||||
" -u\tUnshuffle file in place\n");
|
||||
}
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
_prog_name = argv[0];
|
||||
|
||||
work_args_t parsed;
|
||||
|
||||
if( !argv[1] || *(argv[1]) != '-') help_then_exit();
|
||||
|
||||
D_dprintf("Parsing `%c'", argv[1][1]);
|
||||
switch(argv[1][1])
|
||||
{
|
||||
case 's':
|
||||
parsed.op = OP_SHUFFLE_IP;
|
||||
if(!(parsed.data.op_shuffle_ip.file = argv[2]))
|
||||
{
|
||||
fprintf(stderr, "Error: -s expected file argument.\n");
|
||||
return 1;
|
||||
}
|
||||
D_dprintf("parsed.op = %d", OP_SHUFFLE_IP);
|
||||
break;
|
||||
case 'u':
|
||||
parsed.op = OP_UNSHUFFLE_IP;
|
||||
if(!(parsed.data.op_unshuffle_ip.file = argv[2]))
|
||||
{
|
||||
fprintf(stderr, "Error: -u expected file argument.\n");
|
||||
return 1;
|
||||
}
|
||||
D_dprintf("parsed.op = %d", OP_UNSHUFFLE_IP);
|
||||
break;
|
||||
case 'h':
|
||||
usage();
|
||||
return 0;
|
||||
default:
|
||||
fprintf(stderr, "Error: unknown argument `%s'\n\n", argv[1]);
|
||||
help_then_exit();
|
||||
panic("Unreachable");
|
||||
}
|
||||
|
||||
return do_work(parsed);
|
||||
}
|
||||
|
||||
@ -0,0 +1,56 @@
|
||||
#define _GNU_SOURCE
|
||||
#include<stdio.h>
|
||||
#include<stdlib.h>
|
||||
#include<string.h>
|
||||
#include<unistd.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include<sys/mman.h>
|
||||
#include<fcntl.h>
|
||||
|
||||
#define FILEMODE S_IRWXU | S_IRGRP | S_IROTH
|
||||
|
||||
#include <map.h>
|
||||
|
||||
int open_and_map(const char* file, mmap_t* restrict ptr)
|
||||
{
|
||||
int fd;
|
||||
struct stat st;
|
||||
if ((fd = open(file, O_RDWR, FILEMODE)) < 0) {
|
||||
perror("Failed to open file");
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (fstat(fd, &st) < 0) {
|
||||
perror("Failed to stat file");
|
||||
close(fd);
|
||||
return 0;
|
||||
}
|
||||
|
||||
register struct mmap map = { .fd = fd, .ptr = NULL, .len = st.st_size };
|
||||
|
||||
if ((map.ptr = mmap(NULL, map.len, PROT_READ | PROT_WRITE, MAP_SHARED,fd, 0)) == MAP_FAILED) {
|
||||
perror("mmap() failed");
|
||||
close(fd);
|
||||
return 0;
|
||||
}
|
||||
|
||||
*ptr = map;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int unmap_and_close(mmap_t map)
|
||||
{
|
||||
register int rval=1;
|
||||
if (munmap(map.ptr, map.len) < 0) {
|
||||
perror("munmap() failed");
|
||||
rval=0;
|
||||
}
|
||||
if (close(map.fd) <0) {
|
||||
perror("Failed to close fd");
|
||||
rval=0;
|
||||
}
|
||||
|
||||
return rval;
|
||||
}
|
||||
@ -0,0 +1,11 @@
|
||||
|
||||
#include <shuffle3.h>
|
||||
#include <reinterpret.hpp>
|
||||
#include <map.h>
|
||||
|
||||
|
||||
extern "C" void* map_and_then(const char* file, map_cb callback, void* user)
|
||||
{
|
||||
mm::mmap map(file);
|
||||
return callback(map.as_raw(), user);
|
||||
}
|
||||
@ -0,0 +1,18 @@
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <panic.h>
|
||||
|
||||
#include <colours.h>
|
||||
|
||||
__attribute__((noreturn)) void _do_panic(struct panicinfo info, const char* fmt, ...)
|
||||
{
|
||||
va_list li;
|
||||
va_start(li, fmt);
|
||||
fprintf(stderr, BOLD(UNDL(FRED("[!]"))) " (" BOLD("%s") "->" BOLD(FRED("%s")) ":" FYEL("%d") ") " BOLD(FRED("fatal error")) ": ", info.file, info.function, info.line);
|
||||
vfprintf(stderr, fmt, li);
|
||||
fprintf(stderr, "\n");
|
||||
va_end(li);
|
||||
abort();
|
||||
}
|
||||
@ -0,0 +1,22 @@
|
||||
#include <shuffle3.h>
|
||||
#include <reinterpret.hpp>
|
||||
|
||||
template<typename T>
|
||||
static inline T* bytes_to_t(std::uint8_t* ptr, std::size_t ptr_sz, std::size_t* restrict nsize)
|
||||
{
|
||||
span<uint8_t> bytes(ptr, ptr_sz);
|
||||
auto tout = bytes.reinterpret<T>();
|
||||
*nsize = tout.size();
|
||||
return tout.as_ptr();
|
||||
}
|
||||
|
||||
extern "C" {
|
||||
uint64_t* bytes_to_long(uint8_t* ptr, size_t ptr_sz, size_t* restrict nsize)
|
||||
{
|
||||
return bytes_to_t<uint64_t>(ptr, ptr_sz, nsize);
|
||||
}
|
||||
float* bytes_to_float(uint8_t* ptr, size_t ptr_sz, size_t* restrict nsize)
|
||||
{
|
||||
return bytes_to_t<float>(ptr, ptr_sz, nsize);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,92 @@
|
||||
#include <iostream>
|
||||
#include <cmath>
|
||||
|
||||
#include <rng/impl.hpp>
|
||||
|
||||
inline unsigned char RNG::byte()
|
||||
{
|
||||
return (unsigned char)next_int(255);
|
||||
}
|
||||
|
||||
void RNG::bytes(unsigned char* ptr, std::size_t len)
|
||||
{
|
||||
for(std::size_t i=0;i<len;i++)
|
||||
{
|
||||
ptr[i] = byte();
|
||||
}
|
||||
}
|
||||
|
||||
bool RNG::chance()
|
||||
{
|
||||
return chance(.5);
|
||||
}
|
||||
|
||||
bool RNG::chance(double d)
|
||||
{
|
||||
if (d<=0) return false;
|
||||
return sample() <= d;
|
||||
}
|
||||
|
||||
std::int32_t RNG::next_int(std::int32_t min, std::int32_t max)
|
||||
{
|
||||
return (std::int32_t)floor(sample() * (double)(max-min))+min;
|
||||
}
|
||||
|
||||
std::int32_t RNG::next_int()
|
||||
{
|
||||
return (chance() ? 1 : -1) * (std::int32_t)floor(sample() * (double)INT32_MAX);
|
||||
}
|
||||
|
||||
std::int64_t RNG::next_long(std::int64_t min, std::int64_t max)
|
||||
{
|
||||
return (std::int64_t)floor(sample() * (double)(max-min))+min;
|
||||
}
|
||||
|
||||
std::int64_t RNG::next_long()
|
||||
{
|
||||
return (chance() ? 1l : -1l) * (std::int64_t)floor(sample() * (double)INT64_MAX);
|
||||
}
|
||||
|
||||
#include <rng.h>
|
||||
#include <panic.h>
|
||||
namespace { // C interface
|
||||
using namespace std;
|
||||
#define extract_ptr(ptr) ((RNG*)(ptr))
|
||||
static inline RNG& extract_ref(rng_t rng)
|
||||
{
|
||||
return *extract_ptr(rng);
|
||||
}
|
||||
template<typename T>
|
||||
static inline T* extract_downcast_ptr(rng_t rng)
|
||||
{
|
||||
return dynamic_cast<T*>(extract_ptr(rng));
|
||||
}
|
||||
|
||||
extern "C"
|
||||
{
|
||||
|
||||
rng_t rng_new(rng_init_opt opt)
|
||||
{
|
||||
switch(opt.kind)
|
||||
{
|
||||
case RNG_KIND_FRNG: return (rng_t) new rng::frng(opt.init.frng.state);
|
||||
case RNG_KIND_DRNG: return (rng_t) new rng::drng(opt.init.drng.state);
|
||||
case RNG_KIND_XORNG: return (rng_t) new rng::xoroshiro128plus(opt.init.xorng.state);
|
||||
default: panic("Unknown RNG init opt: %d", opt.kind);
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void rng_free(rng_t rng)
|
||||
{
|
||||
RNG* ptr = (RNG*)rng;
|
||||
delete ptr;
|
||||
}
|
||||
|
||||
void rng_test_spec(rng_t rng)
|
||||
{
|
||||
cout << "rng_test_spec:" << endl;
|
||||
rng::test_algo(std::move(extract_ref(rng)));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,21 @@
|
||||
#include <cstdlib>
|
||||
#include <ctime>
|
||||
#include <iostream>
|
||||
|
||||
#include <rng/drng.hpp>
|
||||
|
||||
namespace rng
|
||||
{
|
||||
drng drng::from_time() { return drng(time(NULL)); }
|
||||
|
||||
int drng::rand()
|
||||
{
|
||||
return rand_r(&state);
|
||||
}
|
||||
|
||||
double drng::sample()
|
||||
{
|
||||
int val = rand_r(&state);
|
||||
return (double)val / (double)RAND_MAX;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,3 @@
|
||||
#include <rng/impl.hpp>
|
||||
#include <rng/frng.hpp>
|
||||
#include <iostream>
|
||||
@ -0,0 +1,37 @@
|
||||
#include <iostream>
|
||||
#include <rng.h>
|
||||
|
||||
namespace rng {
|
||||
void test_algo(RNG&& rng)
|
||||
{
|
||||
using namespace std;
|
||||
|
||||
for(int i=0;i<10;i++) {
|
||||
double d = rng.next_double();
|
||||
long l = rng.next_long(-10, 10);
|
||||
|
||||
std::array<bool, 10> ar;
|
||||
for(auto& i : ar) i = rng.chance();
|
||||
|
||||
cout << "\t(Sampled: " << d;
|
||||
cout << ", Long: " << l;
|
||||
cout << ", Bools: [ ";
|
||||
for(const auto& i : ar) cout << i << " ";
|
||||
cout << "])" << endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extern "C" void rng_test()
|
||||
{
|
||||
using namespace std;
|
||||
|
||||
cout << "frng:" << endl;
|
||||
rng::test_algo(rng::frng(1.0, 1.2));
|
||||
|
||||
cout << "drng:" << endl;
|
||||
rng::test_algo(rng::drng(10));
|
||||
|
||||
cout << "xoroshiro128+:" << endl;
|
||||
rng::test_algo(rng::xoroshiro128plus(100ul, 200ul));
|
||||
}
|
||||
@ -0,0 +1,86 @@
|
||||
#include <rng/xoroshiro128plus.hpp>
|
||||
#include <iostream>
|
||||
|
||||
using u64 = std::uint64_t;
|
||||
|
||||
#define XO xoroshiro128plus
|
||||
|
||||
static inline constexpr u64 rotl(u64 x, int k)
|
||||
{
|
||||
return (x << k) | (x >> (64 - k));
|
||||
}
|
||||
|
||||
namespace rng
|
||||
{
|
||||
inline constexpr u64 next(XO::State& s)
|
||||
{
|
||||
u64 s0 = s[0];
|
||||
u64 s1 = s[1];
|
||||
u64 result = s0 + s1;
|
||||
|
||||
s1 ^= s0;
|
||||
s[0] = rotl(s0, 24) ^ s1 ^ (s1 << 16);
|
||||
s[1] = rotl(s1, 37);
|
||||
|
||||
return result;
|
||||
}
|
||||
inline constexpr void xo_jump(XO::State& s)
|
||||
{
|
||||
constexpr const std::uint64_t JUMP[] = { 0xdf900294d8f554a5, 0x170865df4b3201fc };
|
||||
|
||||
std::uint64_t s0 = 0;
|
||||
std::uint64_t s1 = 0;
|
||||
for(u64 i = 0; i < sizeof JUMP / sizeof *JUMP; i++)
|
||||
for(int b = 0; b < 64; b++) {
|
||||
if (JUMP[i] & UINT64_C(1) << b) {
|
||||
s0 ^= s[0];
|
||||
s1 ^= s[1];
|
||||
}
|
||||
next(s);
|
||||
}
|
||||
|
||||
s[0] = s0;
|
||||
s[1] = s1;
|
||||
}
|
||||
|
||||
inline constexpr void xo_long_jump(XO::State& s)
|
||||
{
|
||||
constexpr const uint64_t LONG_JUMP[] = { 0xd2a98b26625eee7b, 0xdddf9b1090aa7ac1 };
|
||||
|
||||
std::uint64_t s0 = 0;
|
||||
std::uint64_t s1 = 0;
|
||||
for(u64 i = 0; i < sizeof LONG_JUMP / sizeof *LONG_JUMP; i++)
|
||||
for(int b = 0; b < 64; b++) {
|
||||
if (LONG_JUMP[i] & UINT64_C(1) << b) {
|
||||
s0 ^= s[0];
|
||||
s1 ^= s[1];
|
||||
}
|
||||
next(s);
|
||||
}
|
||||
|
||||
s[0] = s0;
|
||||
s[1] = s1;
|
||||
}
|
||||
|
||||
|
||||
void XO::jump() { xo_jump(state); }
|
||||
void XO::long_jump() { xo_long_jump(state); }
|
||||
|
||||
std::uint64_t XO::next_ulong()
|
||||
{
|
||||
return next(state);
|
||||
}
|
||||
std:: int64_t XO::next_long()
|
||||
{
|
||||
const u64 v = next_ulong();
|
||||
static_assert(sizeof(v) == sizeof(decltype(next_long())));
|
||||
|
||||
return *(const std::int64_t*)&v;
|
||||
}
|
||||
|
||||
|
||||
double XO::sample()
|
||||
{
|
||||
return (next(state) & ((INT64_C(1) << 53) - 1)) * (1.00 / (INT64_C(1) << 53));
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,129 @@
|
||||
#include <tuple>
|
||||
#include <functional>
|
||||
#include <cfloat>
|
||||
|
||||
#include <fmt/format.h>
|
||||
|
||||
#include <shuffle3.h>
|
||||
#include <panic.h>
|
||||
#include <map.h>
|
||||
#include <reinterpret.h>
|
||||
#include <shuffle.hpp>
|
||||
|
||||
#include <work.h>
|
||||
#include <debug.h>
|
||||
|
||||
template<typename T, typename Fn>
|
||||
std::tuple<T, T> minmax_t(const span<T>& array, Fn keep)
|
||||
{
|
||||
T highest;
|
||||
T lowest;
|
||||
bool init=false;
|
||||
D_dprintf("minmax_t: %p (%lu)", array.as_ptr(), array.size());
|
||||
for(std::size_t i=0;i<array.size();i++)
|
||||
{
|
||||
if(!keep(array[i])) continue;
|
||||
|
||||
auto item = array[i];
|
||||
if(!init) {
|
||||
init = true;
|
||||
lowest = highest = item;
|
||||
}
|
||||
else if(item < lowest) lowest = item;
|
||||
else if(item > highest) highest = item;
|
||||
}
|
||||
//fmt::print("MMX {}, {}\n", lowest, highest);
|
||||
return {lowest, highest};
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline std::tuple<T, T> minmax_t(const span<T>& array)
|
||||
{
|
||||
return minmax_t(array, [](T _val) { return true; });
|
||||
}
|
||||
|
||||
namespace work
|
||||
{
|
||||
/// Shuffle or unshuffle in place
|
||||
template<bool unshuffle>
|
||||
int xshuffle_ip(const char* file)
|
||||
{
|
||||
mm::mmap map(file);
|
||||
|
||||
if constexpr(unshuffle)
|
||||
{
|
||||
auto [byte_l, byte_h] = minmax_t(map.as_span().reinterpret<std::int8_t>());
|
||||
D_dprintf("MMX res (s8): %d -- %d", byte_l, byte_h);
|
||||
rng::drng drng((std::int32_t) ((0xfffa << 16) | (byte_l<<7) | byte_h ));
|
||||
rng::unshuffle(drng, map.as_span());
|
||||
|
||||
auto [float_l, float_h] = minmax_t(map.as_span().reinterpret<float>(), [](float f) -> bool { return !( (f!=f) || f < -FLT_MAX || f > FLT_MAX); });
|
||||
D_dprintf("MMX res (f32): %f -- %f", float_l, float_h);
|
||||
rng::frng frng(float_l, float_h);
|
||||
rng::unshuffle(frng, map.as_span().reinterpret<float>());
|
||||
|
||||
auto [long_l, long_h] = minmax_t(map.as_span().reinterpret<std::int64_t>());
|
||||
D_dprintf("MMX res (u64): %ld -- %ld", long_l, long_h);
|
||||
rng::xoroshiro128plus xorng(*(const std::uint64_t*)&long_l, *(const std::uint64_t*)&long_h);
|
||||
rng::unshuffle(xorng, map.as_span().reinterpret<std::int64_t>());
|
||||
} else {
|
||||
auto [long_l, long_h] = minmax_t(map.as_span().reinterpret<std::int64_t>());
|
||||
D_dprintf("MMX res (u64): %ld -- %ld", long_l, long_h);
|
||||
rng::xoroshiro128plus xorng(*(const std::uint64_t*)&long_l, *(const std::uint64_t*)&long_h);
|
||||
rng::shuffle(xorng, map.as_span().reinterpret<std::int64_t>());
|
||||
|
||||
auto [float_l, float_h] = minmax_t(map.as_span().reinterpret<float>(), [](float f) -> bool { return !( (f!=f) || f < -FLT_MAX || f > FLT_MAX); });
|
||||
D_dprintf("MMX res (f32): %f -- %f", float_l, float_h);
|
||||
rng::frng frng(float_l, float_h);
|
||||
rng::shuffle(frng, map.as_span().reinterpret<float>());
|
||||
|
||||
auto [byte_l, byte_h] = minmax_t(map.as_span().reinterpret<std::int8_t>());
|
||||
D_dprintf("MMX res (s8): %d -- %d", byte_l, byte_h);
|
||||
rng::drng drng((std::int32_t) ((0xfffa << 16) | (byte_l<<7) | byte_h ));
|
||||
rng::shuffle(drng, map.as_span());
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/// Shuffle or unshuffle out of place
|
||||
template<bool unshuffle>
|
||||
int xshuffle_op(const char* ifile, const char* ofile, bool is_buffered)
|
||||
{
|
||||
|
||||
if constexpr(unshuffle)
|
||||
{
|
||||
|
||||
} else {
|
||||
|
||||
}
|
||||
panic("Unimplemented");
|
||||
return 0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
int help()
|
||||
{
|
||||
//Print help then exit
|
||||
return 1;
|
||||
}
|
||||
|
||||
extern "C" int do_work(const work_args_t args)
|
||||
{
|
||||
using A = decltype(args.op);
|
||||
switch (args.op) {
|
||||
case A::OP_SHUFFLE_IP: return work::xshuffle_ip<false >(args.data.op_shuffle_ip.file);
|
||||
case A::OP_SHUFFLE_OP: return work::xshuffle_op<false >(args.data.op_shuffle_op.ifile,
|
||||
args.data.op_shuffle_op.ofile,
|
||||
args.data.op_shuffle_op.buffered == WORK_BO_BUFFERED);
|
||||
case A::OP_UNSHUFFLE_IP: return work::xshuffle_ip<true >(args.data.op_unshuffle_ip.file);
|
||||
case A::OP_UNSHUFFLE_OP: return work::xshuffle_op<true>(args.data.op_unshuffle_op.ifile,
|
||||
args.data.op_unshuffle_op.ofile,
|
||||
args.data.op_unshuffle_op.buffered == WORK_BO_BUFFERED);
|
||||
case A::OP_HELP: return help();
|
||||
|
||||
default: panic("Unknown op %d", (int)args.op);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in new issue