Persistency CFT [2024-04-04, 2:30 - 4:00 pm]

[guysagnes]

Participants

✅@johannes-esr
✅@sbachmann-qorix
✅@guysagnes
✅@vinodreddy-g
Uwe Maucher
Jannik Szwajczyk
Vasile-Bogdan Badicu
✅@armin-acn
✅@arsibo

✅@hbragge-acn
Joshua Licht
Eva Peiker

report: ✅ / ❌

Agenda

• Feedback from last session
• PCL Wrapper - incubation report
  • Initial GENIVI PCL Wrapper persistency#3
• Agree on C++ API
  -> allow decision to
  • C++ Wrapper
  • C++ Own implementation

Meeting Minutes

• Town Hall Meeting

  • https://github.com/orgs/eclipse-score/discussions/825

• Information about Architecture workshop 08.-10.04.2025

  • https://github.com/orgs/eclipse-score/discussions/764
    -> Gopi check for align agenda

• Proposed API

  • Proposed APIs in context of the KVS: API proposal and prototype implementation persistency#2
    • API action to be taken in account the zero-copy
      -> return vec value will be replaced by fixed buffer defined in context of common library
  • Agreement to continue with the QORIX initial API definition.
    • Pull request to be agreed - Initial version 0.1,0

Alignment on C++ API

by Armin Bartsch

The json implementation parser should be unique and may be implemented in context communication

• Json Read
  • Parsisng: The returned C++ object becomes the owner of the data. Data will be dropped, when the object goes out of scope.
  • Accessing sub-objects: The returned C++ object will be a reference into the original object. It is the application's responsibility to keep the original object.
• Json Read / Write

- Modifying data may lead to dangling references
Possible remedies
- Return a copied object on any modification
- Reference counting
- Requires reference counting on Rust side and over the C++/Rust language boundary
- Introducing reference counts on Rust side requires re-arranging the whole data tree of tinyjson.
- Add a "generation" counter to root objects and try to determine whether a reference has become invalid.
- Let references consist of a pointer to the root object plus a path to the sub-object.
- Allocation free?
- Other ideas?
=> Solutions other than copying seem to add quite a bit of complexity.
=> Certifying two separate Json libraries for C++ and Rust might be less effort.

Result

In context of the realization we should be able to keep the freedom of interference in the case we implement separated library for C++ and Rust. To avoid the raising complexity it is decided that the process should have separated instances of the key-value-store.
This separation may be breakdown to the storage device in different files.
The persistence key-value-store shall not be to exchange values between the processes. In this case the IPC has to be involved.

Next Steps

• reuse the module_template reported under:
  -> https://github.com/eclipse-score/module_template

• Proposal for C++ API

• Extension of the API to support file system access

Next week architecture workshop planned in Ulm
Next Persistency CFT session planned on 17.04.2025