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

[johannes-esr]

Please contact @johannes-esr if you want to join the meeting.

Participants

@johannes-esr
@sven
@guysagnes
@vinodreddy-g
@hbragge-acn
Uwe Maucher
Eva Peiker
Jannik Szwajczyk
Vasile-Bogdan Badicu

Agenda

1. Presentation of Rust API proposal from Sven
2. Presentation of updated API proposal from @guysagnes

Meeting Minutes

1. PR with Persistency Implementation to be created next week
2. Further Updates on the API

Next Steps

• Agree on Rust API -> Meeting on 2025-03-27, 2:30 - 4pm
• Agre on C++ API
• Agree on underlying implementation
  • Proposal from qorix for Rust
    • C++ wrapper
    • or: C++ implementation
  • Client persistency library from Continental (C Interface with Rust & C++ wrappers on top)

[guysagnes]

Thanks for the proposal for the Key-Value-Store API and the good presentation of the content.
The interface fit mainly to the requirement identified inside SCORE.

For the initialization it will be good to get more information about the parameters used to identify the KVS.

let kvs = RtKvs :: open(RtInstanceId :: new(0), RtSacId :: new(0), false, false) ?;

The description is not clear enough for me. I expect this allow the better separation during initialization.
Parameter:
. inst_id: Instance specifier
. sac_1d: Software architecture element ID

[guysagnes]

SCORE Persistence - Continental 2025.03.20

The approach of the initial realisation is in alignment with the realisation done inside GENIVI System Infrastructure - Persistence

• The concept is based on the separation of the data management isnide the device storage.

• The separation is related to the applications and users.

deployment

A single library offers the expected API for handling key-values and files access.

Library based

The representation of the library based access.
This approach offer simple access to the device storage, it can be fast started and is independent from network infrastructure.
It requests a defined access in context of the different runtime context. The synchronization should be addressed to the Rust Library.

Service based

The implementation service based can offer an abstraction to the implementation language e.g., LoLa (Low Latency API).
The advantage of the service approach is the abstraction of the possbility to provide different service in to realise the persistence for the applications e.g., raw data partition to cloud managed data.
The service based approach imply a dependency to the protocol used in the system. It has impact on the startup performance and the early accessibility to the entries inside persistence.

Remarks:
The concept providing a service for the application can be investigation on top of the Persistence-SCORE stack as a kind of Content-Provider.

Persistence SCORE API (Rust)

The Persistence SCORE may provide a common access definition for key-value and file system.

Parameter description:

• ldbid: parameter allows the identification of the accessibility of the content

  • 0x00 : Public access (ReadOnly)
  • 0x01..0xFE : Shared group assigned to an application
  • 0xFF : Local key

• resource_id: resource identifier, it is a string that should be unique on application level

• user_no: represent the user related data, allow separation of data based on the active user in system. The user can be used to access default and initial values.

  • 0x00 : system / node - not user specific
  • 0x01..0xFD : User assigned identifiers
  • 0xFE : User to access configurable default values
  • 0xFF : User to access initial values

• Result: the result is reported in two steps

  • return of the function e.g., empty or vector with data.
  • state of the function - Ok or Err

Initialization/Deinitialization

Key Value Store

File Handling

Feedback

collected during the call -

• The requirements do not expect shared data in context of persistence. The sharing of information is in responsibility of the communication, The relation application has to share the information if requested.

  • open point: how to handle information managed centrally like hardware-configuration expected accessible by all application
    => This point can be addressed as new feature inside the SCORE Architecture alignment

• The user (human) specific data are not reflected in the requirement. To get this aspect the application has to create dedicated instance of the storage for the related user. The application is then in responsibility to control the user-data and related action e.g., specific user-reset.