Virtual Thread Execution on Multi-Core Systems Without Kernel Support
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Operating systems that do not support kernel threads limit user threads to run on a single core, leading to non-preemptive execution and blocking of other threads, as they appear as a single schedulable entity, hindering concurrent processing on multi-core systems.
Innovation Solution
Creating a virtual thread that represents a new user thread, accompanied by a separate process independently scheduled by the operating system, allowing both processes to execute concurrently across multiple cores, with a communications channel for synchronization and memory access management.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If user threads are used in an operating system without kernel thread support, then the system can create multiple threads within a single process, but the threads cannot execute concurrently on multiple cores because they appear as a single schedulable entity to the operating system
Solution Approach 1:
The patent segments the single process into multiple independent processes, each running a user thread. By forking the process and using inter-process communication (IPC) mechanisms, the system creates multiple schedulable entities that can execute concurrently on multiple cores, while maintaining the user-thread abstraction within each process context.
Solution Approach 2:
The patent introduces an intermediary mechanism (IPC channel) between forked processes to enable coordination and data sharing. This intermediary allows user threads in different processes to communicate and synchronize, effectively simulating kernel-thread-like concurrency while working around the operating system's lack of native kernel thread support.
2Device complexity
If user threads are implemented without kernel thread support, then the implementation is simpler and requires fewer operating system resources, but the threads are non-preemptive and block other threads from execution
Solution Approach 1:
The patent dynamically creates and destroys processes as needed for user thread execution. Each user thread operates within a dynamically forked process that can be independently scheduled by the operating system, enabling preemption at the process level while maintaining the simplicity of user-thread implementation within each process context.
3Device complexity
If multiple user threads are created within a single process, then memory sharing is simplified as all threads access the same address space, but the single process cannot be scheduled on multiple cores simultaneously
Solution Approach 1:
The patent implements a nested structure where user threads are contained within forked processes, which in turn communicate through IPC mechanisms. This nested architecture allows each process to have its own address space (simplifying memory management within the thread), while the outer process layer enables multi-core utilization through independent scheduling of multiple processes by the operating system.
Data Source
AI summary
Techniques are provided to allow concurrent operation of threads in an operating system that does not support kernel threads. A first process may create a first thread. The first thread may create a second process. The second process is granted access to a portion of the address space of the first thread. Synchronization information is passed between the first thread and the second process over a communications channel.