F Prime Memory Allocators

F Prime provides several memory allocation strategies to suit different embedded system requirements. This document describes the three main allocator types: MemAllocator, BufferManager, and StaticMemory.

MemAllocator

The MemAllocator provides a basic heap-based memory allocation interface. This allocator is suitable for systems with sufficient memory resources where dynamic allocation is acceptable.

Key Features

Dynamic heap allocation
Support for variable-sized allocations
Standard malloc/free semantics
Thread-safe allocation and deallocation

Usage Considerations

Most flexible allocation strategy
Higher memory overhead due to heap management
May introduce memory fragmentation
Not recommended for hard real-time systems due to non-deterministic timing

Example Usage

// Create an allocator instance
MemAllocator allocator;

// Allocate memory
U8* buffer = static_cast<U8*>(allocator.allocate(size));

// Use the buffer
// ...

// Deallocate when done
allocator.deallocate(buffer);

BufferManager

The BufferManager implements a fixed-size buffer pool allocation strategy. This allocator is ideal for systems that need deterministic memory management and primarily work with fixed-size buffers.

Key Features

Pre-allocated buffer pool
Fixed buffer sizes
O(1) allocation and deallocation
No fragmentation
Deterministic timing

Usage Considerations

Efficient for fixed-size allocations
Predictable memory usage
Good for real-time systems
Limited to pre-configured buffer sizes
May waste memory if buffer sizes don't match usage patterns

Example Usage

// Configure buffer pool
const NATIVE_INT_TYPE BUFFER_SIZE = 1024;
const NATIVE_INT_TYPE NUM_BUFFERS = 10;

// Create a buffer manager
BufferManager manager(BUFFER_SIZE, NUM_BUFFERS);

// Allocate a buffer
U8* buffer = manager.allocate();

// Use the buffer
// ...

// Return to pool
manager.deallocate(buffer);

StaticMemory

StaticMemory provides compile-time memory allocation. This is the most deterministic and safest allocation strategy, ideal for critical systems where dynamic allocation is not allowed.

Key Features

Compile-time allocation
Zero runtime overhead
No fragmentation
Completely deterministic
No allocation failures possible at runtime

Usage Considerations

Most predictable memory usage
Best for hard real-time systems
Memory size must be known at compile time
No flexibility for runtime size changes
May use more memory than necessary due to worst-case sizing

Example Usage

// Define static buffer at compile time
StaticMemory<1024> staticBuffer;

// Access memory
U8* buffer = staticBuffer.getData();

// Use the fixed buffer
// ...

// No deallocation needed

Choosing an Allocator

Consider these factors when selecting a memory allocator:

System Requirements
- Hard real-time constraints
- Memory constraints
- Performance requirements
- Safety certification needs
Usage Patterns
- Fixed vs variable buffer sizes
- Allocation frequency
- Buffer lifetime
- Thread safety requirements
Trade-offs
- Memory efficiency vs flexibility
- Performance vs determinism
- Compile-time vs runtime configuration
- Memory overhead vs features

Recommendation Guidelines

Use StaticMemory for:
- Safety-critical systems
- Hard real-time requirements
- Systems requiring certification
- When allocation sizes are known at compile time
Use BufferManager for:
- Systems needing deterministic allocation
- When working with fixed-size buffers
- Real-time systems with less strict requirements
- When memory fragmentation must be avoided
Use MemAllocator for:
- Development and testing
- Systems with adequate memory resources
- When flexibility is more important than determinism
- Non-critical system components

Implementation Notes

When implementing a component that uses these allocators:

Document the chosen allocator and rationale
Consider providing allocator configuration parameters
Implement proper error handling for allocation failures
Consider memory alignment requirements
Test with different allocation patterns
Monitor memory usage and fragmentation

Best Practices

Memory Management
- Always check allocation results
- Clean up allocated memory properly
- Use RAII patterns when possible
- Monitor memory usage
Configuration
- Document memory requirements
- Include safety margins
- Consider alignment requirements
- Plan for future growth
Testing
- Test allocation failures
- Verify memory leaks
- Check fragmentation patterns
- Test concurrent access

Remember that the choice of allocator can significantly impact system behavior, reliability, and certification efforts. Choose carefully based on your specific requirements and constraints.


*F´ Version*
*Affected Component*

Document Memory Management Setup #1688

Description

Feature Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions