microsoft/verona
Verona
Verona is a research programming language designed to prevent data races through a system of concurrent ownership and deep immutability. It utilizes a deeply immutable memory model to ensure that complex objects cannot be mutated, allowing data to be shared across concurrent threads without synchronization locks.
The project features a deterministic parallel execution engine that ensures reproducible outputs regardless of thread timing. It employs a region-based memory manager to assign memory regions to specific threads or processes, reducing contention in producer-consumer workloads.
The system manages memory using a reference-counting garbage collector capable of handling immutable cycles across multiple sub-interpreters. It further supports parallel execution safety through state transfer via message passing and provides tools to visualize region structures.
Features
- Deeply Immutable Memory Models - Implements a deeply immutable memory model that prevents mutation of complex objects to enable lock-free data sharing across threads.
- Thread-Local Region Ownership - Implements a concurrency model where memory regions are owned by specific threads to prevent data races.
- Ownership-Based Race Prevention - Managing shared data across multiple threads by applying strict ownership rules to prevent data races and memory corruption.
- State Transfer - Moves state and ownership between isolated sub-interpreters using a messaging system for parallel safety.
- Deep Immutability Enforcements - Implements recursive read-only modifiers to ensure complex objects cannot be mutated across concurrent threads.
- Inter-Interpreter State Transfer - Transfers state and ownership between isolated sub-interpreters using message passing to ensure parallel safety.
- Reference-Counting Garbage Collectors - Uses a reference-counting garbage collector to automatically manage memory for immutable objects.
- Regional Object Allocation - Organizes memory into distinct regions to improve efficiency and reduce contention in parallel workloads.
- Parallel Task Execution - Executes parallel tasks in a deterministic order to ensure consistent output across CPU cores.
- Concurrent Programming Languages - A research programming language designed specifically for data-race prevention via concurrent ownership and deep immutability.
- Deterministic Execution - Provides a deterministic parallel execution engine that ensures reproducible outputs regardless of thread timing.
- Lock-Free Parallel Execution - Ensures race-free results by combining message passing and ownership transfers for parallel execution.
- Region-Based Memory Managers - Employs a region-based memory manager to assign memory regions to specific threads, reducing contention in producer-consumer workloads.
- Deterministic Execution - Provides a parallel execution engine that ensures reproducible and consistent outputs regardless of thread timing.
- Memory Allocators - Implements a specialized memory allocator using message passing to reduce producer-consumer contention.
- Message-Passing Allocators - Employs a message-passing allocator to distribute memory and reduce contention in producer-consumer workloads.
- Cycle-Free Immutable Reclamation - Manages immutable objects across sub-interpreters using reference counting without requiring a local cycle collector.
- Reference Counting - Manages the lifecycle of immutable data structures and circular references using reference counting.
- Immutable Cycle Management - Uses reference counting to manage memory for deeply immutable data structures that contain circular references.
Star history
How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.
