From 873fe958fdec1b2dce16c3f78a3e267dc29e56d1 Mon Sep 17 00:00:00 2001 From: Avril Date: Sat, 17 Dec 2022 06:13:02 +0000 Subject: [PATCH] Gave up on sepples impl MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fortune for day14's current commit: Half curse − 半凶 --- day14/Makefile | 117 ++++++++++++++++++++++++++++++++++++++++ day14/include/input.h | 39 ++++++++++++++ day14/src/input.cpp | 120 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 276 insertions(+) create mode 100644 day14/Makefile create mode 100644 day14/include/input.h create mode 100644 day14/src/input.cpp diff --git a/day14/Makefile b/day14/Makefile new file mode 100644 index 0000000..c404de2 --- /dev/null +++ b/day14/Makefile @@ -0,0 +1,117 @@ +# Generic C and C++ Makefile project template +# Contains targets for `release', `debug', and `clean'. + +PROJECT=project +AUTHOR=Avril (Flanchan) +VERSION=0.0.0 + +SRC_C = $(wildcard src/*.c) +SRC_CXX = $(wildcard src/*.cpp) + +INCLUDE=include + +# Link to these libraries dynamicalls +SHARED_LIBS= +# Link to these libraries statically +STATIC_LIBS= + +override __VERSION_SPLIT:= $(subst ., ,$(VERSION)) +override __VERSION_REVISION:=$(word 3,$(__VERSION_SPLIT)) 0 +override __VERSION_SPLIT:= MAJOR:$(word 1,$(__VERSION_SPLIT)) MINOR:$(word 2,$(__VERSION_SPLIT)) BUGFIX:$(word 1,$(subst r, ,$(__VERSION_REVISION))) REVISION:$(word 2,$(subst r, ,$(__VERSION_REVISION))) REVISION_STRING:$(word 3,$(__VERSION_SPLIT)) + +COMMON_FLAGS+= -W -Wall -Wstrict-aliasing -fno-strict-aliasing $(addprefix -I,$(INCLUDE)) +COMMON_FLAGS+= $(addprefix -D_VERSION_,$(subst :,=,$(__VERSION_SPLIT))) '-D_VERSION="$(VERSION)"' + +# Target arch. Set to blank for generic +ARCH?=native +# Enable OpenMP and loop parallelisation? (dyn-links to openmp) +PARALLEL?=yes + +OPT_FLAGS?= -fgraphite \ + -floop-interchange -ftree-loop-distribution -floop-strip-mine -floop-block \ + -fno-stack-check + +ifneq ($(ARCH),) + OPT_FLAGS+= $(addprefix -march=,$(ARCH)) +endif + +ifeq ($(PARALLEL),yes) + OPT_FLAGS+= -fopenmp -floop-parallelize-all -ftree-parallelize-loops=4 +endif + +CXX_OPT_FLAGS?= $(OPT_FLAGS) -felide-constructors + +CSTD?=gnu2x +CXXSTD?=gnu++23 + +CFLAGS += $(COMMON_FLAGS) --std=$(CSTD) +CXXFLAGS += $(COMMON_FLAGS) --std=$(CXXSTD) +LDFLAGS += $(addsuffix .a,$(addprefix -l:lib,$(STATIC_LIBS))) $(addprefix -l,$(SHARED_LIBS)) + + +STRIP=strip + +RELEASE_COMMON_FLAGS+= -Werror -fno-bounds-check +DEBUG_COMMON_FLAGS+= -ggdb -gz -fanalyzer -ftrapv -fbounds-check + +ifneq ($(TARGET_SPEC_FLAGS),no) + RELEASE_CFLAGS?= -O3 -flto $(OPT_FLAGS) + RELEASE_CXXFLAGS?= -O3 -flto $(CXX_OPT_FLAGS) + RELEASE_LDFLAGS?= -Wl,-O3 -Wl,-flto + + DEBUG_CFLAGS?= -Og + DEBUG_CXXFLAGS?= -Og + + DEBUG_LDFLAGS?= +endif + +DEBUG_CFLAGS+=-DDEBUG $(DEBUG_COMMON_FLAGS) +DEBUG_CXXFLAGS+=-DDEBUG $(DEBUG_COMMON_FLAGS) -fasynchronous-unwind-tables + +RELEASE_CFLAGS+=-DRELEASE $(RELEASE_COMMON_FLAGS) +RELEASE_CXXFLAGS+=-DRELEASE $(RELEASE_COMMON_FLAGS) + +# 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 + +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-rebuild: + rm -rf obj + +clean: clean-rebuild + rm -f $(PROJECT)-{release,debug,pgo} + diff --git a/day14/include/input.h b/day14/include/input.h new file mode 100644 index 0000000..a3d5204 --- /dev/null +++ b/day14/include/input.h @@ -0,0 +1,39 @@ +#pragma once + +#include + +#include + +struct Point { + uint64_t x,y; +}; + +struct Line { + Point start, end; +}; + +template +using Output = T* __restrict__; + +namespace Input { + struct Parser { + Parser(const char* string, size_t len) noexcept; + template + inline Parser(const char (&string)[N]) noexcept + : Parser(string, N) {} + + Parser(Parser&&) noexcept; + Parser(const Parser&) = delete; + + Parser& operator=(Parser&&) noexcept; + Parser& operator=(const Parser&) = delete; + + bool try_read_next(Output); + + virtual ~Parser(); + private: + struct _impl; + + std::unique_ptr<_impl> state_; + }; +} diff --git a/day14/src/input.cpp b/day14/src/input.cpp new file mode 100644 index 0000000..200457b --- /dev/null +++ b/day14/src/input.cpp @@ -0,0 +1,120 @@ + +#include + +#include + +namespace { + template + [[gnu::pure]] + inline T* gmemchr(T* ptr, char ch, size_t sz) noexcept { + return (T*)memchr((void*)ptr, ch, sz * sizeof(T)); + } + + template + inline size_t gmemchr_s(T* ptr, char ch, size_t sz) noexcept { + if(T* p = gmemchr(ptr, ch, sz)) return (size_t)(p - ptr); + else return 0; + } + + template requires(std::is_invocable_v) + struct Defer { + constexpr explicit Defer(std::nullptr_t) noexcept + : f(nullptr) {} + constexpr Defer(F&& func) noexcept(std::is_nothrow_move_constructible_v) + : f(std::make_unique(std::move(func))) {} + constexpr virtual ~Defer() noexcept(std::is_nothrow_invocable_v) { if(f) (*f)(); } + + constexpr Defer(Defer&& m) noexcept + : f(std::move(m.f)) {} + constexpr Defer(const Defer& p) noexcept requires(std::is_copy_constructible_v) + : f(p.f ? *p.f : nullptr) {} + constexpr Defer& operator=(Defer&& m) noexcept(std::is_nothrow_move_constructible_v) + { + if(this != std::addressof(m)) { + f = std::move(m.f); + } return *this; + } + constexpr Defer& operator=(const Defer& c) noexcept(std::is_nothrow_copy_constructible_v) requires(std::is_copy_constructible_v) + { + if(this != std::addressof(m)) { + if(c.f) f = std::make_unique(*c.f); + else f = nullptr; + } return *this; + } + + template + constexpr decltype(auto) operator()(Args&&... args) noexcept(std::is_nothrow_invocable_v) requires(std::is_invocable_v) + { return std::forward>( (*f)() ); } + private: + std::unique_ptr f; + }; + template requires(std::is_invocable_v) + constexpr auto defer_call(F&& func) noexcept(std::is_nothrow_move_constructible_v) { return Defer{std::move(func)}; } +#define $CAT_(a, b) a ## b +#define $CAT(a, b) $CAT_(a, b) +#define $DEFER(...) const auto $CAT(_$__defer_, __LINE__) = ::defer_call( __VA_ARGS__ ) +} + +namespace Input { + struct Parser::_impl { + struct { + const char* data; + size_t len; + } src; + + const char* cur_line; + size_t cur_len; + }; + Parser::Parser(const char* string, size_t len) noexcept + : state_(std::make_unique<_impl>()) + { + state_->cur_line = state_->src.data = string; + state_->cur_len = state_->src.len = len; + } + + Parser::~Parser() {} + + Parser::Parser(Parser&& p) noexcept + : state_(std::move(p.state_)) {} + + Parser& Parser::operator=(Parser&& p) noexcept + { + if(this != std::addressof(p)) { + state_ = std::move(p.state_); + } return *this; + } + + bool Parser::try_read_next(Output output) + { + const char* start = state_->cur_line; + const char* end = gmemchr(start, '\n', state_->cur_len); + if(!end) return false; + + size_t diff = (size_t)(end - state_->cur_line); + + if(diff > 1) { + auto string = std::string_view{ start, gmemchr_s(start, ' ', diff - 1) }; + + for(size_t i=0; + string.size() && string.data() < end; + i++, + string = std::string_view{ start += string.size(), // start = start + last size + gmemchr_s(start, ' ', diff - 1) // XXX: <-- this should be `start + string.size()` + }) + { + switch(i) { + case 0: output->start = parse_point(string); break; // First point + case 1: continue; // Arrow + case 2: output->end = parse_point(string); break; // Second point + case 3: continue; // Arrow + default: goto le; // Next point, quit + } + } + le: + end = ((const char*)string.data()) + string.size(); + state_->cur_len = (size_t)(end - state_->cur_line); // TODO: Is this the correct length calculation? I don't think it is.... + state_->cur_line = end; + return true; + } else return false; + } +}