initial implemementation

Author: stanminlee

CMakeLists.txt

@@ -218,6 +218,12 @@ set(STA_SOURCE
   spice/WriteSpice.cc
   spice/Xyce.cc
 
+  stadb/AnnoDb.cc
+  stadb/NetDbReader.cc
+  stadb/NetDbWriter.cc
+  stadb/ParaDb.cc
+  stadb/StaDb.cc
+
   tcl/TclTypeHelpers.cc
 
   util/Debug.cc
@@ -275,6 +281,7 @@ set(STA_TCL_FILES
   sdf/Sdf.tcl
   search/Search.tcl
   spice/WriteSpice.tcl
+  stadb/StaDb.tcl
   verilog/Verilog.tcl
   )
 
@@ -494,6 +501,7 @@ set(SWIG_FILES
   ${STA_HOME}/search/Property.i
   ${STA_HOME}/search/Search.i
   ${STA_HOME}/spice/WriteSpice.i
+  ${STA_HOME}/stadb/StaDb.i
   ${STA_HOME}/tcl/Exception.i
   ${STA_HOME}/tcl/Collections.i
   ${STA_HOME}/tcl/StaTclTypes.i

app/StaApp.i

@@ -37,6 +37,7 @@
 %include "sdf/Sdf.i"
 %include "search/Search.i"
 %include "search/Property.i"
+%include "stadb/StaDb.i"
 %include "util/Util.i"
 %include "spice/WriteSpice.i"
 %include "verilog/Verilog.i"

include/sta/Sta.hh

@@ -152,10 +152,13 @@ public:
                                       Scene *scene,
                                       const MinMaxAll *min_max,
                                       bool infer_latches);
-  // Compiled NLDM-only form of readLiberty
+  // Compiled NLDM-only form of readLiberty (also used inside .stadb).
   virtual LibertyLibrary *readLibDb(std::string_view filename);
   void writeLibDb(LibertyLibrary *library,
                   std::string_view filename);
+  // Serialize / restore a full session (liberty, netlist, sdc, delays).
+  void writeStaDb(std::string_view filename);
+  void readStaDb(std::string_view filename);
   // tmp public
   void readLibertyAfter(LibertyLibrary *liberty,
                         Scene *scene,

include/sta/StaDb.hh

@@ -0,0 +1,56 @@
+// OpenSTA, Static Timing Analyzer
+// Copyright (c) 2026, Parallax Software, Inc.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+//
+// The origin of this software must not be misrepresented; you must not
+// claim that you wrote the original software.
+//
+// Altered source versions must be plainly marked as such, and must not be
+// misrepresented as being the original software.
+//
+// This notice may not be removed or altered from any source distribution.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <string_view>
+
+namespace sta {
+
+class Sta;
+
+// Serialized STA session database (.stadb).
+//
+// One file holds a snapshot of the loaded session, each part written as
+// objects and values rather than as the text it was originally read from:
+//   liberty  - NLDM libraries, LibDb encoding
+//   network  - the linked netlist: cells, instances, nets, pins, NetDb encoding
+//   sdc      - constraints
+//   anno     - every delay and slew in the timing graph, AnnoDb encoding
+//
+// writeStaDb serializes the live Sta state into that file.
+// readStaDb deserializes it back into a session that is ready to report on:
+// the network comes back linked and the delays come back annotated, so no
+// link_design, delay calculation or parasitics are needed to repeat a report.
+
+constexpr uint32_t sta_db_version = 1;
+
+void writeStaDb(Sta *sta,
+                std::string_view filename);
+void readStaDb(Sta *sta,
+               std::string_view filename);
+
+} // namespace sta

liberty/LibDb.hh

@@ -47,12 +47,11 @@ constexpr uint32_t lib_db_id_null = 0xFFFFFFFFu;
 enum class LibDbModelKind : uint8_t { none = 0, gate = 1, check = 2 };
 enum class LibDbPortKind : uint8_t { scalar = 0, bus = 1, bundle = 2 };
 
-// Header for the libdb file.
+// Header for the libdb file. The rest of the file is one db block.
 struct LibDbHeader
 {
-  uint32_t version;      // version of the libdb format
-  uint64_t string_bytes; // bytes of serialized strings
-  uint64_t body_bytes;   // bytes of serialized body
+  uint32_t version;     // version of the libdb format
+  uint64_t block_bytes; // bytes of the packed string table + body
 };
 
 // Builds the file body as a growing byte list. Also keeps a list of unique
@@ -195,6 +194,68 @@ private:
   bool failed_{false};    // true if we read past the end or bad string id
 };
 
+////////////////////////////////////////////////////////////////
+// A "db block" is one self contained chunk of bytes:
+//
+//   [u32 string_count][(u32 length, characters)*][body bytes]
+//
+// The string table comes first so the reader can rebuild it before walking the
+// body, which only holds indexes into it. Liberty, netlist and annotations all
+// use this shape, so a .stadb file can hold each of them as an opaque byte
+// range and hand it back unchanged at load time.
+
+// Glue a writer's string list in front of its body.
+inline std::vector<uint8_t>
+dbPack(const DbWriter &writer)
+{
+  DbWriter block;
+  block.u32(static_cast<uint32_t>(writer.strings().size()));
+  for (const std::string &s : writer.strings()) {
+    block.u32(static_cast<uint32_t>(s.size()));
+    for (char c : s)
+      block.u8(static_cast<uint8_t>(c));
+  }
+  std::vector<uint8_t> bytes = block.bytes();
+  bytes.insert(bytes.end(), writer.bytes().begin(), writer.bytes().end());
+  return bytes;
+}
+
+// Split a block back into its string list and body.
+// False means the block is truncated or the string table is corrupt.
+inline bool
+dbUnpack(const uint8_t *data,
+         size_t size,
+         // Return values.
+         std::vector<std::string> &strings,
+         std::vector<uint8_t> &body)
+{
+  size_t pos = 0;
+  auto next_u32 = [&](uint32_t &v) {
+    if (pos + sizeof v > size)
+      return false;
+    std::memcpy(&v, data + pos, sizeof v);
+    pos += sizeof v;
+    return true;
+  };
+
+  uint32_t count = 0;
+  if (!next_u32(count))
+    return false;
+  strings.clear();
+  strings.reserve(count);
+  for (uint32_t i = 0; i < count; i++) {
+    uint32_t length = 0;
+    if (!next_u32(length) || pos + length > size)
+      return false;
+    strings.emplace_back(reinterpret_cast<const char *>(data + pos), length);
+    pos += length;
+  }
+  body.assign(data + pos, data + size);
+  return true;
+}
+
+////////////////////////////////////////////////////////////////
+
 // Compile an already loaded liberty library to filename.
 void writeLibDbFile(LibertyLibrary *library,
                     std::string_view filename,
@@ -204,4 +265,12 @@ void writeLibDbFile(LibertyLibrary *library,
 LibertyLibrary *readLibDbFile(std::string_view filename,
                               Network *network);
 
+// Same encoding without the file wrapper, for .stadb liberty sections.
+std::vector<uint8_t> writeLibDbBytes(LibertyLibrary *library,
+                                     Report *report);
+LibertyLibrary *readLibDbBytes(const uint8_t *data,
+                               size_t size,
+                               std::string_view label,
+                               Network *network);
+
 } // namespace sta

liberty/LibDbReader.cc

@@ -24,7 +24,7 @@
 
 // read_lib_db: rebuild one NLDM LibertyLibrary from a .libdb cache.
 //
-// File layout: [header][string_count][string table][body]
+// File layout: [header][db block: string table then body]
 // Body field order must match LibWriter in LibDbWriter.cc.
 // Shared axes/tables/attrs: first use reads id + full data; later uses reuse by id.
 // Strings: body stores an index; the string table holds the text once.
@@ -749,11 +749,29 @@ LibLoader::read()
   return lib_;
 }
 
+LibertyLibrary *
+readLibDbBytes(const uint8_t *data,
+               size_t size,
+               std::string_view label,
+               Network *network)
+{
+  // Split the block into the string list and body, then rebuild the library.
+  Report *report = network->report();
+  std::vector<std::string> strings;
+  std::vector<uint8_t> body;
+  if (!dbUnpack(data, size, strings, body))
+    report->error(1356, "{} has a corrupt string table.", label);
+
+  DbReader reader(body.data(), body.size(), &strings);
+  LibLoader loader(reader, label, network);
+  return loader.read();
+}
+
 LibertyLibrary *
 readLibDbFile(std::string_view filename,
               Network *network)
 {
-  // Validate .libdb + version, load string table, then LibLoader::read().
+  // Validate .libdb + version, then hand the block to readLibDbBytes().
   Report *report = network->report();
   std::string path(filename);
 
@@ -764,7 +782,7 @@ readLibDbFile(std::string_view filename,
   if (f == nullptr)
     report->error(1366, "cannot open {}.", path);
 
-  // File layout: [header][string_count][string bytes][body bytes]
+  // File layout: [header][block]
   LibDbHeader hdr{};
   if (fread(&hdr, sizeof hdr, 1, f) != 1) {
     fclose(f);
@@ -776,39 +794,15 @@ readLibDbFile(std::string_view filename,
                   path, hdr.version, lib_db_version);
   }
 
-  uint32_t string_count = 0;
-  bool ok = fread(&string_count, sizeof string_count, 1, f) == 1;
-  std::vector<uint8_t> string_bytes(hdr.string_bytes);
-  if (ok && hdr.string_bytes)
-    ok = fread(string_bytes.data(), hdr.string_bytes, 1, f) == 1;
-  std::vector<uint8_t> body(hdr.body_bytes);
-  if (ok && hdr.body_bytes)
-    ok = fread(body.data(), hdr.body_bytes, 1, f) == 1;
+  std::vector<uint8_t> block(hdr.block_bytes);
+  bool ok = true;
+  if (hdr.block_bytes)
+    ok = fread(block.data(), hdr.block_bytes, 1, f) == 1;
   fclose(f);
   if (!ok)
     report->error(1363, "{} is truncated.", path);
 
-  // Unpack (length, characters)* into the string list DbReader::str() uses.
-  std::vector<std::string> strings;
-  strings.reserve(string_count);
-  size_t pos = 0;
-  for (uint32_t i = 0; i < string_count; i++) {
-    uint32_t len = 0;
-    bool len_ok = pos + sizeof len <= string_bytes.size();
-    if (len_ok) {
-      std::memcpy(&len, string_bytes.data() + pos, sizeof len);
-      pos += sizeof len;
-    }
-    if (!len_ok || pos + len > string_bytes.size())
-      report->error(1356, "{} has a corrupt string table.", path);
-    strings.emplace_back(reinterpret_cast<const char *>(string_bytes.data() + pos), len);
-    pos += len;
-  }
-
-  // Hand body + string list to the loader; it rebuilds the library object.
-  DbReader reader(body.data(), body.size(), &strings);
-  LibLoader loader(reader, filename, network);
-  return loader.read();
+  return readLibDbBytes(block.data(), block.size(), filename, network);
 }
 
 } // namespace sta