Architecture Requirements

This section defines architectural requirements for the OpenSOMEIP implementation, covering modularity, thread safety, and memory management.

Overview

The OpenSOMEIP architecture is designed with:

  1. Modular layered architecture

  2. Thread-safe operations

  3. Safe memory management

  4. Clear separation of concerns

Requirements

Modularity

Requirement: Modular Architecture REQ_ARCH_001
status: implemented
priority: high
satisfies: feat_req_someip_2, feat_req_someip_3, feat_req_someip_4, feat_req_someip_14, feat_req_someip_15, feat_req_someip_697
satisfied_by: REQ_PAL_MUTEX_LOCK, REQ_PAL_MUTEX_UNLOCK, REQ_PAL_MUTEX_TRYLOCK, REQ_PAL_MUTEX_NONCOPY, REQ_PAL_CV_WAIT, REQ_PAL_CV_WAIT_PRED, REQ_PAL_CV_NOTIFY_ONE, REQ_PAL_CV_NOTIFY_ALL, REQ_PAL_CV_OWNERSHIP, REQ_PAL_THREAD_CREATE, REQ_PAL_THREAD_JOINABLE, REQ_PAL_THREAD_JOIN, REQ_PAL_THREAD_NONCOPY, REQ_PAL_LOCK_ACQUIRE, REQ_PAL_LOCK_RELEASE, REQ_PAL_LOCK_NONCOPY, REQ_PAL_SLEEP_DURATION, REQ_PAL_SLEEP_ZERO, REQ_PAL_MEM_ALLOC, REQ_PAL_MEM_INDEPENDENT, REQ_PAL_NET_CLOSE, REQ_PAL_NET_SHUTDOWN, REQ_PAL_NET_NONBLOCK, REQ_PAL_NET_BLOCK, REQ_PAL_BYTE_HTONS, REQ_PAL_BYTE_NTOHS, REQ_PAL_BYTE_HTONL, REQ_PAL_BYTE_NTOHL

The implementation shall follow a modular layered architecture:

  • Core Layer (someip-common): Message structures, serialization

  • Transport Layer (someip-transport): UDP/TCP transports

  • Protocol Layer: SD, TP, RPC, Events

  • Safety Layer (someip-e2e): E2E protection

Each layer shall:

  • Have clearly defined interfaces

  • Depend only on lower layers

  • Be independently testable

  • Be replaceable without affecting other layers

Rationale: Modularity enables maintainability, testability, and selective deployment.

Code Location: CMakeLists.txt, src/CMakeLists.txt

Thread Safety

Requirement: Thread Safety REQ_ARCH_002
status: implemented
priority: high

The implementation shall be thread-safe:

  • Shared data structures protected by appropriate synchronization

  • Session manager thread-safe for concurrent requests

  • Transport operations safe for multi-threaded use

  • No data races in normal operation

  • Document thread-safety guarantees in API documentation

Rationale: Automotive applications require concurrent operation without data corruption.

Code Location: All source files

Memory Management

Requirement: Safe Memory Management REQ_ARCH_003
status: implemented
priority: high
satisfied_by: REQ_PAL_MEM_ALLOC, REQ_PAL_MEM_INDEPENDENT

The implementation shall use safe memory management:

  • RAII (Resource Acquisition Is Initialization) patterns

  • Smart pointers (std::unique_ptr, std::shared_ptr)

  • No raw pointer ownership

  • Bounds checking on all array/vector access

  • No memory leaks in normal operation

Rationale: Memory safety is critical for reliability and aligns with safety-oriented design goals.

Code Location: All source files

Error Handling

Requirement: Consistent Error Handling REQ_ARCH_004
status: implemented
priority: high

The implementation shall use consistent error handling:

  • Return Result enum for operation status

  • No exceptions in core protocol code

  • Validate all external inputs

  • Implement safe failure modes

  • Log errors with sufficient context

Rationale: Consistent error handling improves reliability and debuggability.

Code Location: include/common/result.h

Coding Standards

Requirement: Coding Standards Compliance REQ_ARCH_005
status: implemented
priority: medium
satisfies: feat_req_someip_105, feat_req_someip_109, feat_req_someip_449, feat_req_someip_472

The implementation shall follow coding standards:

  • C++17 standard

  • Naming conventions per docs/CODING_GUIDELINES.md

  • Clang-format for consistent formatting

  • Clang-tidy for static analysis

  • Doxygen comments for public APIs

Rationale: Consistent coding standards improve readability and maintainability.

Code Location: .clang-format, .clang-tidy

Build System

Requirement: CMake Build System REQ_ARCH_006
status: implemented
priority: medium

The implementation shall use CMake for build configuration:

  • CMake 3.20+ required

  • Support for multiple compilers (GCC, Clang, MSVC)

  • Optional features via CMake options

  • Export compile commands for IDE integration

  • Install targets for system installation

Rationale: CMake provides cross-platform build configuration.

Code Location: CMakeLists.txt

Testing Infrastructure

Requirement: Comprehensive Testing REQ_ARCH_007
status: implemented
priority: high

The implementation shall include comprehensive testing:

  • Unit tests using Google Test

  • Integration tests using pytest

  • Code coverage reporting

  • Continuous integration via GitHub Actions

  • Test traceability to requirements

Rationale: Testing ensures correctness and prevents regressions.

Code Location: tests/

Traceability

Implementation Files

  • CMakeLists.txt - Main build configuration

  • src/CMakeLists.txt - Source build configuration

  • include/common/result.h - Error handling

  • .clang-format - Formatting configuration

  • .clang-tidy - Static analysis configuration

  • docs/CODING_GUIDELINES.md - Coding standards

Test Files

  • tests/CMakeLists.txt - Test configuration

  • tests/*.cpp - Unit tests

  • tests/integration/*.py - Integration tests

  • tests/system/*.py - System tests