ifcparse: inline the file reader accessors and pre-size the inverse index

full_buffer_impl::size(), get(), get_u32() and get_u64() (and their mmap_impl
twins) were defined out of line, so every character the lexer read crossed a
call boundary with its own bounds check. Callgrind put the three at 5.6% of
parse self time; inlining them lets the compiler hoist the checks out of the
scanning loops, which is worth more than their own cost.

Also reserve the streamer's inverse vector from the file size (about one
record per 32 bytes of SPF on real models) and shrink it once the bulk load
is sorted, so the doubling copies and the capacity slack go away.

Parse time, C++ file constructor, 12-core Linux box:
  TXG            58 MB   1.35 s -> 1.15 s
  210_King      148 MB   3.70 s -> 3.09 s
  OKgate22      232 MB   6.18 s -> 5.30 s
Python ifcopenshell.open(): 1.40 -> 1.22, 3.70 -> 3.24, 6.27 -> 5.52 s.
Memory unchanged. The removed exported symbols mean the Python wrapper must
be rebuilt against this library.

This commit was written by an AI coding tool and has not been verified by
a human.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013wcN7XquTfUi4vsKQ4KchL

src/ifcparse/file_reader.cpp

@@ -75,33 +75,6 @@ full_buffer_impl::full_buffer_impl(const std::string& content, const caller_fed_
     , size_(content.size()) {
 }
 
-size_t full_buffer_impl::size() const { return size_; }
-
-char full_buffer_impl::get(size_t pos) const {
-    if (pos >= buf_.size()) {
-        throw std::out_of_range("get out of range");
-    }
-    return buf_[pos];
-}
-
-uint64_t full_buffer_impl::get_u64(size_t pos) const {
-    if (pos + sizeof(uint64_t) > buf_.size()) {
-        throw std::out_of_range("get_u64 out of range");
-    }
-    uint64_t value;
-    std::memcpy(&value, buf_.data() + pos, sizeof(value));
-    return value;
-}
-
-uint32_t full_buffer_impl::get_u32(size_t pos) const {
-    if (pos + sizeof(uint32_t) > buf_.size()) {
-        throw std::out_of_range("get_u32 out of range");
-    }
-    uint32_t value;
-    std::memcpy(&value, buf_.data() + pos, sizeof(value));
-    return value;
-}
-
 void full_buffer_impl::push_next_page(const std::string& data) {
     buf_.insert(buf_.end(), data.begin(), data.end());
     size_ = buf_.size();
@@ -247,33 +220,6 @@ mmap_impl::mmap_impl(const std::string& fn) {
     size_ = static_cast<size_t>(map_.size());
 }
 
-size_t mmap_impl::size() const { return size_; }
-
-char mmap_impl::get(size_t pos) const {
-    if (pos >= size_) {
-        throw std::out_of_range("get out of range");
-    }
-    return map_.data()[pos];
-}
-
-uint64_t mmap_impl::get_u64(size_t pos) const {
-    if (pos + sizeof(uint64_t) > size_) {
-        throw std::out_of_range("get_u64 out of range");
-    }
-    uint64_t value;
-    std::memcpy(&value, map_.data() + pos, sizeof(value));
-    return value;
-}
-
-uint32_t mmap_impl::get_u32(size_t pos) const {
-    if (pos + sizeof(uint32_t) > size_) {
-        throw std::out_of_range("get_u32 out of range");
-    }
-    uint32_t value;
-    std::memcpy(&value, map_.data() + pos, sizeof(value));
-    return value;
-}
-
 void mmap_impl::push_next_page(const std::string&) {
     throw std::logic_error("push_next_page: backend does not support pushed mode");
 }

src/ifcparse/file_reader.h

@@ -37,6 +37,7 @@
 #include <memory>
 #include <stdexcept>
 #include <string>
+#include <cstring>
 #include <type_traits>
 #include <unordered_map>
 #include <utility>
@@ -201,10 +202,29 @@ public:
     explicit full_buffer_impl(const caller_fed_tag& tag);
     full_buffer_impl(const std::string& content, const caller_fed_tag& tag);
 
-    size_t size() const;
+    size_t size() const { return size_; }
-    char get(size_t position) const;
+    char get(size_t position) const {
-    uint32_t get_u32(size_t position) const;
+        if (position >= size_) {
-    uint64_t get_u64(size_t position) const;
+            throw std::out_of_range("get out of range");
+        }
+        return buf_.data()[position];
+    }
+    uint32_t get_u32(size_t position) const {
+        if (position + sizeof(uint32_t) > size_) {
+            throw std::out_of_range("get_u32 out of range");
+        }
+        uint32_t value;
+        std::memcpy(&value, buf_.data() + position, sizeof(value));
+        return value;
+    }
+    uint64_t get_u64(size_t position) const {
+        if (position + sizeof(uint64_t) > size_) {
+            throw std::out_of_range("get_u64 out of range");
+        }
+        uint64_t value;
+        std::memcpy(&value, buf_.data() + position, sizeof(value));
+        return value;
+    }
     void push_next_page(const std::string& page_data);
     void drop_pages(size_t up_to_position);
 
@@ -249,10 +269,29 @@ class IFC_PARSE_API mmap_impl {
 public:
     explicit mmap_impl(const std::string& path);
 
-    size_t size() const;
+    size_t size() const { return size_; }
-    char get(size_t position) const;
+    char get(size_t position) const {
-    uint32_t get_u32(size_t position) const;
+        if (position >= size_) {
-    uint64_t get_u64(size_t position) const;
+            throw std::out_of_range("get out of range");
+        }
+        return map_.data()[position];
+    }
+    uint32_t get_u32(size_t position) const {
+        if (position + sizeof(uint32_t) > size_) {
+            throw std::out_of_range("get_u32 out of range");
+        }
+        uint32_t value;
+        std::memcpy(&value, map_.data() + position, sizeof(value));
+        return value;
+    }
+    uint64_t get_u64(size_t position) const {
+        if (position + sizeof(uint64_t) > size_) {
+            throw std::out_of_range("get_u64 out of range");
+        }
+        uint64_t value;
+        std::memcpy(&value, map_.data() + position, sizeof(value));
+        return value;
+    }
     void push_next_page(const std::string& page_data);
     void drop_pages(size_t up_to_position);
 

src/ifcparse/parse.cpp

@@ -2412,6 +2412,9 @@ void ifcopenshell::impl::in_memory_file_storage::read_from_stream(Reader* s, con
     std::vector<std::string> schemas;
 
     instance_streamer<Reader> streamer(s, file, logger_.get());
+    // One inverse record per ~32 bytes of SPF text is a slight over-estimate on
+    // real models; reserving avoids the doubling copies and the capacity slack.
+    streamer.inverses().reserve(s->size() / 32);
     streamer.yield_header_instances(false);
 
     if (const auto* header = streamer.header()) {

src/ifcparse/storage.h

@@ -448,6 +448,7 @@ namespace ifcopenshell {
             void sort() const {
                 if (!sorted_) {
                     std::sort(base_.begin(), base_.end(), record_less);
+                    base_.shrink_to_fit();
                     sorted_ = true;
                     invalidate_materialized();
                 }