diff options
Diffstat (limited to 'modules/core/c++')
| -rw-r--r-- | modules/core/c++/abstract/encode.hpp | 19 | ||||
| -rw-r--r-- | modules/core/c++/abstract/forst.hpp | 615 | ||||
| -rw-r--r-- | modules/core/c++/chunk.hpp | 10 | ||||
| -rw-r--r-- | modules/core/c++/forst_chunk.hpp | 73 | ||||
| -rw-r--r-- | modules/core/c++/fplbm.hpp | 83 | ||||
| -rw-r--r-- | modules/core/c++/write_vtk.hpp | 3 |
6 files changed, 749 insertions, 54 deletions
diff --git a/modules/core/c++/abstract/encode.hpp b/modules/core/c++/abstract/encode.hpp index 571722a..1593656 100644 --- a/modules/core/c++/abstract/encode.hpp +++ b/modules/core/c++/abstract/encode.hpp @@ -25,8 +25,27 @@ struct NativeRaw { struct Json { static constexpr string_literal name = "enc::Json"; }; + +/** + * A packed little endian binary layout. See abstract/forst.hpp. + * + * Every value sits at a computable byte offset, so reading one member costs no + * decoding of the members before it. Fixed size schemas are inline; variable + * length ones spend their slot on dimensions plus an offset and put their bytes + * in a single dynamic layer after the static section. + */ +struct Forst { + static constexpr string_literal name = "enc::Forst"; +}; } // namespace enc +/** + * Declared here rather than in any one codec header so that an encoding does + * not have to include an unrelated one to specialise it. json.hpp and + * forst.hpp are siblings; neither should need the other. + */ +template <typename Schema, typename Encoding> class codec; + #ifndef KEL_LBM_DEFAULT_DATA_ENCODING #define KEL_LBM_DEFAULT_DATA_ENCODING ::kel::lbm::enc::Native #endif diff --git a/modules/core/c++/abstract/forst.hpp b/modules/core/c++/abstract/forst.hpp new file mode 100644 index 0000000..878ad58 --- /dev/null +++ b/modules/core/c++/abstract/forst.hpp @@ -0,0 +1,615 @@ +#pragma once + +#include "data.hpp" +#include "encode.hpp" +#include "schema.hpp" +#include "templates.hpp" + +#include <cstddef> +#include <string_view> +#include <cstdint> +#include <bit> +#include <cstring> +#include <string> +#include <type_traits> +#include <vector> + +/** + * A packed little endian binary encoding for the schema system. + * + * Every value sits at a computable byte offset, so reading one member costs no + * decoding of the members before it. A value is a static section followed by a + * single dynamic layer. Little endian, byte packed, no alignment and no + * padding. Fixed size members sit inline; a variable length member spends its + * static slot on its dimensions as UInt64 each and then an offset, and its + * bytes live in the dynamic layer. + * + * An offset is measured from the byte just past the offset field that holds + * it, so resolving one is a single add with no layer base to track. + * + * This is forstio's Forst format reimplemented against lbm's own schema types + * (lbm's abstract/ is a private reimplementation of forstio's data/codec, so + * the two schema vocabularies are distinct C++ types and nothing could be + * shared), and deliberately cut down to **one dynamic layer**. That makes + * `String` and `Array<Fixed>` expressible while `Array<String>` and + * `Array<Array<...>>` are not -- a static_assert says so rather than letting a + * nested dynamic value mis-encode. + * + * Chunk is not handled here: abstract/ sits below chunk.hpp and must not reach + * up into it. The Chunk layout lives in forst_chunk.hpp, which is what a result + * writer includes. + * + * One limitation shared with enc::Json: a bare `data<Chunk<...>, enc::Forst>` + * is ambiguous, because chunk.hpp already specialises + * `data<Chunk<...>, Encode>` for any encoding and neither specialisation is + * more specialised than the other. Wrap the chunk in a Struct, which is what a + * field always is in practice. + * + * Why it is worth having: a `Struct<Member<Chunk<...>,Key>...>` is entirely + * fixed size, so its encoding *is* the packed field data, byte for byte, with + * no framing overhead and no serialisation pass. Results are written as ASCII + * VTK today, which measures 4-5x larger. + */ +namespace kel { +namespace lbm { + +namespace err { +/// The buffer ended before a value that the layout said was there. +struct forst_truncated { + static constexpr std::string_view description = "Truncated Forst buffer"; + static constexpr bool is_critical = false; +}; + +/// A length or offset in the buffer does not agree with the buffer itself. +struct forst_malformed { + static constexpr std::string_view description = "Malformed Forst buffer"; + static constexpr bool is_critical = false; +}; +} // namespace err + +namespace impl { + +/** + * The layout of a schema. + * + * `layers` is dynamicity depth: 0 for something wholly fixed size, and one + * more for each level of variable length nesting. `static_size` is the bytes + * the schema occupies in a static section -- for a variable length schema that + * is the size of its dimensions plus its offset, not of its contents. + */ +template <typename Schema> struct forst_info { + static_assert(always_false<Schema>, "This schema has no Forst layout"); +}; + +template <> struct forst_info<sch::Void> { + static constexpr uint64_t layers = 0u; + static constexpr uint64_t static_size = 0u; +}; + +template <> struct forst_info<sch::Bool> { + static constexpr uint64_t layers = 0u; + static constexpr uint64_t static_size = 1u; +}; + +template <typename Kind, uint64_t N> struct forst_info<sch::Primitive<Kind, N>> { + static constexpr uint64_t layers = 0u; + static constexpr uint64_t static_size = N; +}; + +/** + * Stored as its storage type, not its interface type. The whole point of a + * mixed precision member is that the narrow form is what occupies space. + */ +template <typename Storage, typename Interface> +struct forst_info<sch::MixedPrecision<Storage, Interface>> { + static constexpr uint64_t layers = forst_info<Storage>::layers; + static constexpr uint64_t static_size = forst_info<Storage>::static_size; +}; + +/// Length, then offset. +template <> struct forst_info<sch::String> { + static constexpr uint64_t layers = 1u; + static constexpr uint64_t static_size = 16u; +}; + +template <typename T, uint64_t... D> struct forst_info<sch::FixedArray<T, D...>> { + static constexpr uint64_t layers = forst_info<T>::layers; + static constexpr uint64_t static_size = + ct_multiply<uint64_t, D...>::value * forst_info<T>::static_size; +}; + +template <typename T, uint64_t... D> struct forst_info<sch::Tensor<T, D...>> { + static constexpr uint64_t layers = forst_info<T>::layers; + static constexpr uint64_t static_size = + ct_multiply<uint64_t, D...>::value * forst_info<T>::static_size; +}; + +/// One UInt64 per dimension, then the offset. +template <typename T, uint64_t Dim> struct forst_info<sch::Array<T, Dim>> { + static constexpr uint64_t layers = 1u + forst_info<T>::layers; + static constexpr uint64_t static_size = 8u * Dim + 8u; +}; + +template <typename... T> struct forst_info<sch::Tuple<T...>> { + template <uint64_t i> static constexpr uint64_t max_layers(){ + if constexpr (i < sizeof...(T)){ + using Ti = typename parameter_pack_type<i, T...>::type; + const uint64_t here = forst_info<Ti>::layers; + const uint64_t rest = max_layers<i + 1u>(); + return (here > rest) ? here : rest; + } + return 0u; + } + + template <uint64_t i> static constexpr uint64_t sum_static(){ + if constexpr (i < sizeof...(T)){ + using Ti = typename parameter_pack_type<i, T...>::type; + return forst_info<Ti>::static_size + sum_static<i + 1u>(); + } + return 0u; + } + + static constexpr uint64_t layers = max_layers<0u>(); + static constexpr uint64_t static_size = sum_static<0u>(); + + /// Byte offset of member i within the static section. + template <uint64_t i> static constexpr uint64_t offset_of(){ + if constexpr (i == 0u){ + return 0u; + } else { + using Prev = typename parameter_pack_type<i - 1u, T...>::type; + return offset_of<i - 1u>() + forst_info<Prev>::static_size; + } + } +}; + +template <typename... T, string_literal... Keys> +struct forst_info<sch::Struct<sch::Member<T, Keys>...>> { + using AsTuple = sch::Tuple<T...>; + + static constexpr uint64_t layers = forst_info<AsTuple>::layers; + static constexpr uint64_t static_size = forst_info<AsTuple>::static_size; + + template <uint64_t i> static constexpr uint64_t offset_of(){ + return forst_info<AsTuple>::template offset_of<i>(); + } +}; + +} // namespace impl + +/** + * The encoded bytes. + * + * Holds its own buffer and copies deeply, like enc::Native. Binary rather than + * text, so unlike data<Schema, enc::Json> this is a byte vector. + */ +template <typename Schema> class data<Schema, enc::Forst> final { +public: + using SchemaType = Schema; + +private: + std::vector<uint8_t> value_; + +public: + data() = default; + + explicit data(std::vector<uint8_t> value__) : value_{std::move(value__)} {} + + void set(std::vector<uint8_t> value__) { value_ = std::move(value__); } + + const std::vector<uint8_t> &bytes() const { return value_; } + std::vector<uint8_t> &bytes() { return value_; } + + const uint8_t *raw() const { return value_.empty() ? nullptr : value_.data(); } + uint8_t *raw() { return value_.empty() ? nullptr : value_.data(); } + + data<sch::UInt64, enc::Native> size() const { return {value_.size()}; } +}; + +namespace impl { + +/** + * Little endian is assumed, never converted. + * + * wasm is little endian by specification and every host this runs on is too. + * A big endian target should fail to build rather than silently produce + * byte-swapped field data that looks almost plausible. + */ +static_assert(std::endian::native == std::endian::little, + "Forst assumes a little endian host"); + +/** + * Bytes a value needs in the dynamic layer. Zero for anything fixed size. + * + * With one layer the contents of a dynamic member are themselves always fixed + * size, so this never has to recurse into a dynamic child's own dynamic part. + */ +template <typename Schema> struct forst_dynamic_size { + static uint64_t apply(const data<Schema, enc::Native> &){ return 0u; } +}; + +template <> struct forst_dynamic_size<sch::String> { + static uint64_t apply(const data<sch::String, enc::Native> &from){ + return from.size().get(); + } +}; + +template <typename T, uint64_t Dim> struct forst_dynamic_size<sch::Array<T, Dim>> { + static uint64_t apply(const data<sch::Array<T, Dim>, enc::Native> &from){ + uint64_t count = 1u; + for(uint64_t i = 0u; i < Dim; ++i){ + count *= from.meta().flat_at(i).get(); + } + return count * forst_info<T>::static_size; + } +}; + +template <typename T, uint64_t... D> +struct forst_dynamic_size<sch::FixedArray<T, D...>> { + static uint64_t apply(const data<sch::FixedArray<T, D...>, enc::Native> &from){ + if constexpr (forst_info<T>::layers == 0u){ + return 0u; + } else { + uint64_t total = 0u; + constexpr uint64_t count = ct_multiply<uint64_t, D...>::value; + for(uint64_t i = 0u; i < count; ++i){ + total += forst_dynamic_size<T>::apply(from.flat_at(i)); + } + return total; + } + } +}; + +template <typename... T, string_literal... Keys> +struct forst_dynamic_size<sch::Struct<sch::Member<T, Keys>...>> { + using Schema = sch::Struct<sch::Member<T, Keys>...>; + + template <uint64_t i> + static uint64_t step(const data<Schema, enc::Native> &from){ + if constexpr (i < sizeof...(T)){ + using Ti = typename parameter_pack_type<i, T...>::type; + return forst_dynamic_size<Ti>::apply(from.template get_at_index<i>()) + + step<i + 1u>(from); + } + return 0u; + } + + static uint64_t apply(const data<Schema, enc::Native> &from){ + return step<0u>(from); + } +}; + +/// Writes a value's static bytes at `at`, appending any contents at `dyn`. +template <typename Schema> struct forst_write; + +template <typename Kind, uint64_t N> struct forst_write<sch::Primitive<Kind, N>> { + static void apply(const data<sch::Primitive<Kind, N>, enc::Native> &from, + uint8_t *base, uint64_t at, uint64_t &){ + auto value = from.get(); + static_assert(sizeof(value) == N, "Primitive storage must be its width"); + std::memcpy(base + at, &value, N); + } +}; + +template <> struct forst_write<sch::Bool> { + static void apply(const data<sch::Bool, enc::Native> &from, uint8_t *base, + uint64_t at, uint64_t &){ + base[at] = from.get() ? 1u : 0u; + } +}; + +template <> struct forst_write<sch::Void> { + static void apply(const data<sch::Void, enc::Native> &, uint8_t *, uint64_t, + uint64_t &){} +}; + +template <> struct forst_write<sch::String> { + static void apply(const data<sch::String, enc::Native> &from, uint8_t *base, + uint64_t at, uint64_t &dyn){ + const uint64_t length = from.size().get(); + std::memcpy(base + at, &length, 8u); + + // Measured from just past the offset field, so resolving it is one add. + const uint64_t offset = dyn - (at + 16u); + std::memcpy(base + at + 8u, &offset, 8u); + + if(length > 0u){ + std::memcpy(base + dyn, from.stl_view().data(), length); + } + dyn += length; + } +}; + +template <typename T, uint64_t Dim> struct forst_write<sch::Array<T, Dim>> { + static void apply(const data<sch::Array<T, Dim>, enc::Native> &from, + uint8_t *base, uint64_t at, uint64_t &dyn){ + static_assert(forst_info<T>::layers == 0u, + "One dynamic layer only: an Array element must be fixed size. " + "Array<String> and Array<Array<...>> need a second layer."); + + uint64_t count = 1u; + for(uint64_t i = 0u; i < Dim; ++i){ + const uint64_t extent = from.meta().flat_at(i).get(); + std::memcpy(base + at + 8u * i, &extent, 8u); + count *= extent; + } + + const uint64_t offset = dyn - (at + forst_info<sch::Array<T, Dim>>::static_size); + std::memcpy(base + at + 8u * Dim, &offset, 8u); + + // Elements are fixed size, so they go straight into the layer with no + // dynamic part of their own. + uint64_t unused = 0u; + const uint64_t stride = forst_info<T>::static_size; + for(uint64_t i = 0u; i < count; ++i){ + forst_write<T>::apply(from.flat_at(i), base, dyn + i * stride, unused); + } + dyn += count * stride; + } +}; + +template <typename T, uint64_t... D> struct forst_write<sch::FixedArray<T, D...>> { + static void apply(const data<sch::FixedArray<T, D...>, enc::Native> &from, + uint8_t *base, uint64_t at, uint64_t &dyn){ + constexpr uint64_t count = ct_multiply<uint64_t, D...>::value; + constexpr uint64_t stride = forst_info<T>::static_size; + for(uint64_t i = 0u; i < count; ++i){ + forst_write<T>::apply(from.flat_at(i), base, at + i * stride, dyn); + } + } +}; + +template <typename T, uint64_t... D> struct forst_write<sch::Tensor<T, D...>> { + static void apply(const data<sch::Tensor<T, D...>, enc::Native> &from, + uint8_t *base, uint64_t at, uint64_t &dyn){ + constexpr uint64_t count = ct_multiply<uint64_t, D...>::value; + constexpr uint64_t stride = forst_info<T>::static_size; + for(uint64_t i = 0u; i < count; ++i){ + forst_write<T>::apply(from.flat_at(i), base, at + i * stride, dyn); + } + } +}; +template <typename... T, string_literal... Keys> +struct forst_write<sch::Struct<sch::Member<T, Keys>...>> { + using Schema = sch::Struct<sch::Member<T, Keys>...>; + using Info = forst_info<Schema>; + + template <uint64_t i> + static void step(const data<Schema, enc::Native> &from, uint8_t *base, + uint64_t at, uint64_t &dyn){ + if constexpr (i < sizeof...(T)){ + using Ti = typename parameter_pack_type<i, T...>::type; + forst_write<Ti>::apply(from.template get_at_index<i>(), base, + at + Info::template offset_of<i>(), dyn); + step<i + 1u>(from, base, at, dyn); + } + } + + static void apply(const data<Schema, enc::Native> &from, uint8_t *base, + uint64_t at, uint64_t &dyn){ + step<0u>(from, base, at, dyn); + } +}; + + +/** + * Reads a value's static bytes at `at`. + * + * Every read is bounds checked against the buffer rather than trusted: the + * bytes may have come off a network from a peer that is older, newer, or + * hostile, and a bad offset would otherwise be an out of bounds read. + */ +template <typename Schema> struct forst_read; + +template <typename Kind, uint64_t N> struct forst_read<sch::Primitive<Kind, N>> { + static error_or<void> apply(const uint8_t *base, uint64_t size, uint64_t at, + data<sch::Primitive<Kind, N>, enc::Native> &to){ + if(at + N > size){ + return make_error<err::forst_truncated>(); + } + typename native_data_type<sch::Primitive<Kind, N>>::type value{}; + std::memcpy(&value, base + at, N); + to.set(value); + return make_void(); + } +}; + +template <> struct forst_read<sch::Bool> { + static error_or<void> apply(const uint8_t *base, uint64_t size, uint64_t at, + data<sch::Bool, enc::Native> &to){ + if(at + 1u > size){ + return make_error<err::forst_truncated>(); + } + to.set(base[at] != 0u); + return make_void(); + } +}; + +template <> struct forst_read<sch::Void> { + static error_or<void> apply(const uint8_t *, uint64_t, uint64_t, + data<sch::Void, enc::Native> &){ + return make_void(); + } +}; + +template <> struct forst_read<sch::String> { + static error_or<void> apply(const uint8_t *base, uint64_t size, uint64_t at, + data<sch::String, enc::Native> &to){ + if(at + 16u > size){ + return make_error<err::forst_truncated>(); + } + + uint64_t length = 0u; + uint64_t offset = 0u; + std::memcpy(&length, base + at, 8u); + std::memcpy(&offset, base + at + 8u, 8u); + + const uint64_t start = at + 16u + offset; + // Checked as a sum that cannot wrap, so a hostile length plus a + // hostile offset cannot alias back into the static section. + if(start > size or length > size - start){ + return make_error<err::forst_malformed>(); + } + + to.set(std::string{reinterpret_cast<const char *>(base + start), + static_cast<std::size_t>(length)}); + return make_void(); + } +}; + +template <typename T, uint64_t Dim> struct forst_read<sch::Array<T, Dim>> { + static error_or<void> apply(const uint8_t *base, uint64_t size, uint64_t at, + data<sch::Array<T, Dim>, enc::Native> &to){ + static_assert(forst_info<T>::layers == 0u, + "One dynamic layer only: an Array element must be fixed size."); + + constexpr uint64_t slot = forst_info<sch::Array<T, Dim>>::static_size; + if(at + slot > size){ + return make_error<err::forst_truncated>(); + } + + index_data<Dim> extents; + uint64_t count = 1u; + for(uint64_t i = 0u; i < Dim; ++i){ + uint64_t extent = 0u; + std::memcpy(&extent, base + at + 8u * i, 8u); + extents.flat_at(i).set(extent); + + // Reject an extent product that would overflow before it is used + // to size an allocation. + if(extent != 0u and count > (~uint64_t{0u}) / extent){ + return make_error<err::forst_malformed>(); + } + count *= extent; + } + + uint64_t offset = 0u; + std::memcpy(&offset, base + at + 8u * Dim, 8u); + + constexpr uint64_t stride = forst_info<T>::static_size; + const uint64_t start = at + slot + offset; + if(start > size or (stride != 0u and count > (size - start) / stride)){ + return make_error<err::forst_malformed>(); + } + + to = data<sch::Array<T, Dim>, enc::Native>{extents}; + for(uint64_t i = 0u; i < count; ++i){ + auto eov = forst_read<T>::apply(base, size, start + i * stride, + to.flat_at(i)); + if(eov.is_error()){ + return eov; + } + } + return make_void(); + } +}; + +template <typename T, uint64_t... D> struct forst_read<sch::FixedArray<T, D...>> { + static error_or<void> apply(const uint8_t *base, uint64_t size, uint64_t at, + data<sch::FixedArray<T, D...>, enc::Native> &to){ + constexpr uint64_t count = ct_multiply<uint64_t, D...>::value; + constexpr uint64_t stride = forst_info<T>::static_size; + for(uint64_t i = 0u; i < count; ++i){ + auto eov = forst_read<T>::apply(base, size, at + i * stride, + to.flat_at(i)); + if(eov.is_error()){ + return eov; + } + } + return make_void(); + } +}; + +template <typename T, uint64_t... D> struct forst_read<sch::Tensor<T, D...>> { + static error_or<void> apply(const uint8_t *base, uint64_t size, uint64_t at, + data<sch::Tensor<T, D...>, enc::Native> &to){ + constexpr uint64_t count = ct_multiply<uint64_t, D...>::value; + constexpr uint64_t stride = forst_info<T>::static_size; + for(uint64_t i = 0u; i < count; ++i){ + auto eov = forst_read<T>::apply(base, size, at + i * stride, + to.flat_at(i)); + if(eov.is_error()){ + return eov; + } + } + return make_void(); + } +}; + +template <typename... T, string_literal... Keys> +struct forst_read<sch::Struct<sch::Member<T, Keys>...>> { + using Schema = sch::Struct<sch::Member<T, Keys>...>; + using Info = forst_info<Schema>; + + template <uint64_t i> + static error_or<void> step(const uint8_t *base, uint64_t size, uint64_t at, + data<Schema, enc::Native> &to){ + if constexpr (i < sizeof...(T)){ + using Ti = typename parameter_pack_type<i, T...>::type; + auto eov = forst_read<Ti>::apply( + base, size, at + Info::template offset_of<i>(), + to.template get_at_index<i>()); + if(eov.is_error()){ + return eov; + } + return step<i + 1u>(base, size, at, to); + } + return make_void(); + } + + static error_or<void> apply(const uint8_t *base, uint64_t size, uint64_t at, + data<Schema, enc::Native> &to){ + return step<0u>(base, size, at, to); + } +}; + +} // namespace impl + +/** + * Translates between a native value and its Forst bytes. + */ +template <typename Schema> class codec<Schema, enc::Forst> final { +public: + static_assert(impl::forst_info<Schema>::layers <= 1u, + "Forst here carries exactly one dynamic layer. A schema needing more " + "-- Array<String>, Array<Array<...>> -- has to be flattened."); + + codec() = default; + + KEL_FORBID_COPY(codec); + KEL_DEFAULT_MOVE(codec); + + error_or<void> encode(const data<Schema, enc::Native> &from, + data<Schema, enc::Forst> &to){ + constexpr uint64_t static_size = impl::forst_info<Schema>::static_size; + const uint64_t dynamic_size = impl::forst_dynamic_size<Schema>::apply(from); + + std::vector<uint8_t> buffer; + try { + buffer.resize(static_cast<std::size_t>(static_size + dynamic_size)); + } catch (const std::exception &e){ + (void) e; + return make_error<err::out_of_memory>(); + } + + uint64_t dyn = static_size; + if(not buffer.empty()){ + impl::forst_write<Schema>::apply(from, buffer.data(), 0u, dyn); + } + + to.set(std::move(buffer)); + return make_void(); + } + + error_or<void> decode(const data<Schema, enc::Forst> &from, + data<Schema, enc::Native> &to){ + const uint64_t size = from.size().get(); + if(size < impl::forst_info<Schema>::static_size){ + return make_error<err::forst_truncated>(); + } + return impl::forst_read<Schema>::apply(from.raw(), size, 0u, to); + } +}; + +} // namespace lbm +} // namespace kel diff --git a/modules/core/c++/chunk.hpp b/modules/core/c++/chunk.hpp index 126add8..8edd6ff 100644 --- a/modules/core/c++/chunk.hpp +++ b/modules/core/c++/chunk.hpp @@ -97,6 +97,16 @@ public: return values_.flat_data(); } + /** + * The const counterpart data<FixedArray> has always had. Without it a + * const-correct reader -- a Forst encode, or a writer taking + * `const data<Sch>&` the way write_vtk_file does -- cannot reach the + * bytes at all. + */ + auto flat_data() const { + return values_.flat_data(); + } + static constexpr auto flat_size() { return data<InnerSchema,Encode>::flat_dims(); } diff --git a/modules/core/c++/forst_chunk.hpp b/modules/core/c++/forst_chunk.hpp new file mode 100644 index 0000000..7d4c105 --- /dev/null +++ b/modules/core/c++/forst_chunk.hpp @@ -0,0 +1,73 @@ +#pragma once + +#include "abstract/forst.hpp" +#include "chunk.hpp" + +/** + * The Forst layout for Chunk. + * + * Separate from abstract/forst.hpp because abstract/ sits below chunk.hpp and + * must not reach up into it. Include this rather than the abstract header when + * encoding fields. + * + * A Chunk is its InnerSchema -- a FixedArray widened by the ghost ring -- so it + * is entirely fixed size and encodes to exactly the bytes already sitting in + * flat_data(). That is what makes sending a field snapshot free of any + * serialisation pass or second buffer, which matters most in a browser tab + * where a second 18 MiB allocation may simply not be available. + * + * The encoded extents are `Sides + 2*Ghost`, not the logical sides. A reader + * without Ghost cannot index the buffer, which is why the result manifest + * carries it. + */ +namespace kel { +namespace lbm { +namespace impl { + +template <typename T, uint64_t Ghost, uint64_t... Sides> +struct forst_info<sch::Chunk<T, Ghost, Sides...>> { + using Inner = typename sch::Chunk<T, Ghost, Sides...>::InnerSchema; + static constexpr uint64_t layers = forst_info<Inner>::layers; + static constexpr uint64_t static_size = forst_info<Inner>::static_size; +}; + +template <typename T, uint64_t Ghost, uint64_t... Sides> +struct forst_write<sch::Chunk<T, Ghost, Sides...>> { + using Schema = sch::Chunk<T, Ghost, Sides...>; + using Value = typename Schema::StoredValueSchema; + + static void apply(const data<Schema, enc::Native> &from, uint8_t *base, + uint64_t at, uint64_t &dyn){ + const uint64_t count = data<Schema, enc::Native>::flat_size().get(); + constexpr uint64_t stride = forst_info<Value>::static_size; + const auto *elements = from.flat_data(); + for(uint64_t i = 0u; i < count; ++i){ + forst_write<Value>::apply(elements[i], base, at + i * stride, dyn); + } + } +}; + +template <typename T, uint64_t Ghost, uint64_t... Sides> +struct forst_read<sch::Chunk<T, Ghost, Sides...>> { + using Schema = sch::Chunk<T, Ghost, Sides...>; + using Value = typename Schema::StoredValueSchema; + + static error_or<void> apply(const uint8_t *base, uint64_t size, uint64_t at, + data<Schema, enc::Native> &to){ + const uint64_t count = data<Schema, enc::Native>::flat_size().get(); + constexpr uint64_t stride = forst_info<Value>::static_size; + auto *elements = to.flat_data(); + for(uint64_t i = 0u; i < count; ++i){ + auto eov = forst_read<Value>::apply(base, size, at + i * stride, + elements[i]); + if(eov.is_error()){ + return eov; + } + } + return make_void(); + } +}; + +} // namespace impl +} // namespace lbm +} // namespace kel diff --git a/modules/core/c++/fplbm.hpp b/modules/core/c++/fplbm.hpp index bc99da5..780572b 100644 --- a/modules/core/c++/fplbm.hpp +++ b/modules/core/c++/fplbm.hpp @@ -2,7 +2,6 @@ #include "common.hpp" #include "particle/particle.hpp" -#include "particle/integrate.hpp" #include "iterator.hpp" namespace kel { @@ -13,7 +12,6 @@ struct FpLbm {}; struct FpLbmOneParticle {}; struct FpLbmMomentumOneParticle {}; struct FpLbmOneParticleNoVelocity{}; -struct FpLbmOneParticleGather {}; } namespace method { struct FpLbm {}; @@ -101,7 +99,10 @@ public: // We already computed this in reset // compute_rho_u<T,Descriptor>(dfs,rho,vel); - mom = mom + force * half; + + // ------------------------- + // mom = mom + force * half; + // ------------------------- auto vel = mom / rho; auto eq = equilibrium<T,Descriptor>(rho,vel); @@ -140,11 +141,10 @@ public: }; template<typename T, typename Descriptor, typename Encode> -class component<T, Descriptor, cmpt::FpLbmOneParticleGather, Encode> final { +class component<T, Descriptor, cmpt::FpLbmOneParticle, Encode> final { public: - using Component = cmpt::FpLbmOneParticleGather; + using Component = cmpt::FpLbmOneParticle; private: - // An acceleration, as the comment above says -- now typed as one. kel::lbm::data<sch::LbmAcceleration<sch::Vector<T,Descriptor::D>>> body_acceleration_; public: component(): @@ -175,28 +175,31 @@ public: auto parts = pg.template get<"particles">(); auto parts_size = parts.meta().at({0u}); - auto& pi = parts.at(index); + auto& pi = parts.at(index); auto& pirb = pi.template get<"rigid_body">(); + // Unwrapped once: the sweep works in raw lattice offsets. auto& pirb_pos = pirb.template get<"position">().handle(); auto& pirb_pos_old = pirb.template get<"position_old">().handle(); - auto& p_rad = pi.template get<"collision">().template get<"radius">().handle(); + auto& p_coll = pg.template get<"collision">().at({}); + auto& p_rad = p_coll.template get<"radius">().handle(); - kel::lbm::data<typename particle_aabb<typename ParticleSchema::ValueType>::AABB> aabb; - if(not particle_aabb<typename ParticleSchema::ValueType>::try_calculate(pg,index,mom_f.meta(),aabb)){ + auto eo_aabb = particle_aabb<typename ParticleSchema::ValueType>::calculate(pg,{{0u}},mom_f.meta()); + if(eo_aabb.is_error()){ return; } + auto& aabb = eo_aabb.get_value(); kel::lbm::data<sch::Scalar<T>> three; three.at({}).set(3.0f); - kel::lbm::data<sch::Scalar<T>> two; - two.at({}).set(2.0f); - kel::lbm::data<sch::Scalar<T>> one; one.at({}) = 1.0f; + + kel::lbm::data<sch::Scalar<T>> k; + k.at({}) = 1.0f; kel::lbm::data<sch::Scalar<T>> eps; eps.at({}) = 1.5f; @@ -222,51 +225,27 @@ public: // vel_s is technically time the density of the particle? // force = body_acceleration_ * por + ( vel_s - mom) * two * flip_por; - force = ( vel_s - mom) * two * flip_por; + // force = ( vel_s - mom) * eps * flip_por; + force = ( vel_s - mom) * k * flip_por; // force = (vel_s - mom) * flip_por / (flip_por / two + one); force_p = force_p - force; }, aabb.template get<"a">(), aabb.template get<"b">()); - /** - * Accumulate rather than assign, so a contact pass can add to this - * before cmpt::ParticleIntegrate turns the total into motion. - */ - auto& pirb_force = pirb.template get<"force">(); - pirb_force = pirb_force + force_p; - } -}; - -/** - * The original fused one-particle step, kept so existing call sites keep - * working. The body acceleration rides straight through to the integrator; - * it used to be called global_force_, which it never was -- the integrator - * takes an acceleration, not a force. - */ -template<typename T, typename Descriptor, typename Encode> -class component<T, Descriptor, cmpt::FpLbmOneParticle, Encode> final { -public: - using Component = cmpt::FpLbmOneParticle; -private: - // An acceleration, as the comment above says -- now typed as one. - kel::lbm::data<sch::LbmAcceleration<sch::Vector<T,Descriptor::D>>> body_acceleration_; -public: - component(): - body_acceleration_{} - {} - component(kel::lbm::data<sch::LbmAcceleration<sch::Vector<T,Descriptor::D>>> body_acceleration__): - body_acceleration_{body_acceleration__} - {} - - template<typename CellFieldSchema, typename MacroFieldSchema, typename ParticleSchema> - void apply(const kel::lbm::data<CellFieldSchema, Encode>& field, const kel::lbm::data<MacroFieldSchema,Encode>& macros, const kel::lbm::data<ParticleSchema,Encode>& pg, kel::lbm::data<sch::FixedArray<sch::UInt64,1u>> index, kel::lbm::data<sch::UInt64> time_step, kel::lbm::data<sch::UInt64> sub_steps) const { - component<T,Descriptor,cmpt::ParticleForceReset,Encode> reset; - component<T,Descriptor,cmpt::FpLbmOneParticleGather,Encode> gather; - component<T,Descriptor,cmpt::ParticleIntegrate,Encode> integrate{body_acceleration_}; + auto& pirb_acc = pirb.template get<"acceleration">(); + // Mass moved onto the particle; the quotient is untyped because force + // and mass have no units, so the acceleration unit is attached here. + pirb_acc = kel::lbm::data<sch::LbmAcceleration<sch::Vector<T,Descriptor::D>>>{ + force_p / (pirb.template get<"mass">().at({}))} + + body_acceleration_; - reset.apply(pg,index,time_step); - gather.apply(field,macros,pg,index,time_step,sub_steps); - integrate.apply(pg,index,time_step,sub_steps); + if(sub_steps.get() > 0u){ + // The sub step length in lattice time units: one full step split sss ways. + kel::lbm::data<sch::LbmSecond<sch::Scalar<T>>> sss_inv{one / sss}; + for(kel::lbm::data<sch::UInt64> i{0u}; i < sub_steps; ++i){ + verlet_step_lambda<T,Descriptor::D>(pi,sss_inv); + } + } } }; } diff --git a/modules/core/c++/write_vtk.hpp b/modules/core/c++/write_vtk.hpp index 028a26f..4c67b74 100644 --- a/modules/core/c++/write_vtk.hpp +++ b/modules/core/c++/write_vtk.hpp @@ -1,7 +1,6 @@ #pragma once #include "abstract/error.hpp" - #include "abstract/data.hpp" #include "abstract/data_math.hpp" @@ -47,7 +46,7 @@ struct lbm_vtk_writer<sch::FixedArray<T,D>> { static kel::lbm::error_or<void> apply(std::ostream& vtk_file, const kel::lbm::data<sch::FixedArray<T,D>>& field){ kel::lbm::data<sch::FixedArray<sch::UInt64,D>> index; for(kel::lbm::data<sch::UInt64> it{0}; it.get() < D; ++it){ - index.at({0u}).set(0u); + index.at(it).set(0u); } // vtk_file<<"VECTORS "<<name<<" float\n"; |
