Crash Handling in Concurrent Server Query Execution
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Server systems with concurrent execution environments face challenges in handling crashes during user query processing, as crashes are disruptive and difficult to debug due to non-reproducible errors in multi-threaded environments.
Innovation Solution
Implementing a logging system that maintains stack entries for each execution entity to record state information, which is used to identify and prevent the execution of queries that caused crashes by adding their identifiers to a prohibited list, and logging status information to facilitate debugging and prevent future crashes.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If concurrent execution entities are employed to process user queries in parallel, then throughput performance and resource utilization are improved, but crashes occur that disrupt processing and are difficult to debug
Solution Approach 1:
The system performs preliminary actions by maintaining log stacks that continuously record state information for each execution entity before crashes occur. When a crash happens, these pre-recorded logs enable immediate debugging without needing to reproduce the error, thus maintaining high throughput while improving reliability through proactive error tracking
Solution Approach 2:
The system implements feedback mechanisms by monitoring execution state and logging it continuously. When crashes are detected, the feedback loop triggers debugging processes using the logged information, and subsequently prevents reproduction of crashing conditions, thereby maintaining system stability while preserving concurrent execution performance
2Use of energy by moving object
If multiple execution entities execute queries in parallel, then resource utilization is improved, but debugging becomes difficult due to non-reproducible errors
Solution Approach 1:
Log stacks continuously record detailed state information (register values, memory states, instruction pointers) for each execution entity before crashes occur. This preliminary logging captures the exact conditions leading to crashes, making debugging straightforward even in parallel execution environments where errors would otherwise be non-reproducible
Solution Approach 2:
The system creates copies of execution state information by maintaining duplicate log stacks for each execution entity. These log copies preserve the complete state at crash points, enabling debugging without needing to reproduce the exact parallel execution conditions that caused the original crash
3Ease of repair
If a logging system maintains state information for each execution entity, then crash debugging is facilitated, but system complexity increases
Solution Approach 1:
The logging system is segmented into separate log stacks for each execution entity, with each stack independently tracking state information for its associated thread. This segmentation isolates debugging information by execution context, making it easier to analyze crashes without being overwhelmed by system-wide complexity
Solution Approach 2:
Log stacks serve as intermediary structures between execution entities and the debugging process. They capture and store state information in a standardized format, acting as a buffer that simplifies the interface between complex parallel execution and the debugging analysis process
Data Source
AI summary
A server system provided according to an aspect of the present disclosure forms physical queries to process a user query received from a client system. Each physical query is thereafter executed in a corresponding concurrent execution entity (e.g., thread) to retrieve a respective data portion from a corresponding data source. A response to the user query is formed based on the data portions. State information corresponding to each execution entity is logged into log storage. According to another aspect, when a query (either physical or user) causes an execution environment to crash, the identifier of such query is added to a prohibited list. When a new query is to be executed, the initiation of execution of the new query is prevented if the identifier of the new query is present in the prohibited list.