Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A system for controlling a synchronization object of a computer processing system comprising: one or more processors programmed and configured to cause the execution of: one or more processing threads; a background thread configured to manage a processing flow of the one or more processing threads, the background thread configured to process one or more predetermined abort points for the one or more processing threads, the one or more abort points configured to direct any one of the one or more processing threads to execute exit processing code when an abort indicator signals that the one or more processing threads should be aborted; and a synchronization object for synchronizing the processing of the one or more processing threads, the synchronization object comprising a waiting queue for processing requests made by the one or more processing threads, the synchronization object programmed and configured to: upon receiving a processing request from any one of the one or more processing threads, queue the processing thread from which the request is received in the waiting queue until the processing request can be processed, wherein the synchronization object releases any of the one or more processing threads that are in the waiting queue in response to a request that the one or more processing threads should be aborted.
The system controls synchronization objects in a computer processing system to manage thread execution and abort handling. It addresses the challenge of efficiently coordinating multiple processing threads while ensuring orderly termination when an abort is triggered. The system includes one or more processors that execute multiple processing threads and a background thread responsible for managing their flow. The background thread processes predetermined abort points, which direct any processing thread to execute exit processing code when an abort indicator is activated. A synchronization object coordinates thread processing by maintaining a waiting queue for thread requests. When a thread submits a request, it is queued until processing is possible. If an abort request is received, the synchronization object releases all queued threads, allowing them to terminate gracefully. This ensures threads are synchronized and can be aborted without causing system instability or data corruption. The system improves thread management by integrating abort handling directly into the synchronization mechanism, reducing the risk of deadlocks or incomplete processing during termination.
2. The system of claim 1 wherein releasing processing threads comprises calling a cancel waiting function that releases any of the one or more processing threads that are in the waiting queue.
This invention relates to a system for managing processing threads in a computing environment, particularly addressing the problem of efficiently releasing threads that are in a waiting state. The system includes a mechanism for monitoring and controlling the execution of multiple processing threads, where some threads may be in a waiting queue due to resource constraints or other dependencies. The system dynamically releases these waiting threads by invoking a cancel waiting function, which terminates or frees any threads that are currently queued. This ensures that system resources are not unnecessarily occupied by idle threads, improving overall performance and responsiveness. The system may also include additional features such as thread prioritization, resource allocation tracking, and adaptive scheduling to further optimize thread management. The cancel waiting function can be triggered based on predefined conditions, such as timeouts, resource availability, or external signals, allowing for flexible and efficient thread handling. By proactively releasing waiting threads, the system prevents resource wastage and enhances the efficiency of parallel processing tasks.
3. The system of claim 2 wherein the synchronization object is further configured to: upon receiving a subsequent processing request from any one of the one or more processing threads, return a signal indicating the subsequent processing request was aborted and not processed.
The invention relates to a system for managing synchronization between multiple processing threads in a computing environment. The problem addressed is ensuring efficient and controlled access to shared resources while preventing race conditions and deadlocks. The system includes a synchronization object that coordinates access to a shared resource among one or more processing threads. The synchronization object is configured to receive a processing request from a thread and determine whether to grant or deny access based on predefined criteria. If access is granted, the synchronization object processes the request and updates the shared resource accordingly. If access is denied, the synchronization object may queue the request for later processing or reject it entirely. The synchronization object is further configured to handle subsequent processing requests by returning a signal indicating that the request was aborted and not processed. This ensures that only the most recent or highest-priority request is processed, preventing unnecessary or conflicting operations on the shared resource. The system may also include mechanisms for prioritizing requests, tracking request status, and notifying threads of processing outcomes. The synchronization object may be implemented as a software module, a hardware component, or a combination thereof, depending on the specific requirements of the computing environment. The invention aims to improve system performance, reliability, and resource utilization by providing a robust synchronization mechanism for multi-threaded applications.
4. The system of claim 3 wherein the synchronization object comprises an API, the API comprising at least one function for processing threads to make processing requests of the synchronization object, the at least one function configured to: while the abort indicator is not signaled, not return until the processing request is processed or the cancel waiting function is processed; and, if the abort indicator is signaled, return a signal indicating the request was aborted without processing the request.
This invention relates to a synchronization system for managing thread processing in a computing environment. The system addresses the problem of efficiently handling thread synchronization while providing mechanisms to abort pending requests when necessary. The synchronization object includes an application programming interface (API) with functions that process thread requests. These functions ensure that while an abort indicator is not active, the system does not return control until the request is fully processed or a cancel waiting function is executed. If the abort indicator is signaled, the API function immediately returns an abort signal without processing the request, allowing for timely cancellation of pending operations. The system ensures that threads can be synchronized while maintaining the ability to interrupt or cancel operations as needed, improving system responsiveness and resource management. The synchronization object may also include a cancel waiting function that allows threads to cancel their own pending requests, further enhancing flexibility in thread management. The overall system provides a robust framework for thread synchronization with built-in mechanisms for request cancellation, ensuring efficient and responsive processing in multi-threaded environments.
5. The system of claim 4 wherein if the synchronization object is busy processing requests, queuing additional requesting processing threads in the waiting queue until the synchronization object is available to process the additional requests or until the cancel waiting function is called.
This invention relates to a synchronization system for managing concurrent access to shared resources in a computing environment. The problem addressed is ensuring orderly and efficient handling of multiple processing threads that request access to a shared resource, preventing conflicts and deadlocks while maintaining system performance. The system includes a synchronization object that controls access to a shared resource. When a processing thread requests access, the synchronization object evaluates its current state. If the object is busy processing other requests, the system queues additional requesting threads in a waiting queue. These threads remain in the queue until the synchronization object becomes available to process them or until a cancel waiting function is explicitly called to remove them from the queue. This mechanism ensures that threads do not overwhelm the system with simultaneous requests and that resource access is managed in a controlled manner. The waiting queue dynamically adjusts based on the synchronization object's availability, allowing the system to handle varying loads efficiently. The cancel waiting function provides a way to terminate pending requests, offering flexibility in managing thread operations. This approach improves system stability and responsiveness by preventing resource contention and ensuring fair access to shared resources.
6. The system of claim 1 wherein the synchronization object is a semaphore object representing a system resource.
This invention relates to computer systems and resource management, specifically addressing synchronization mechanisms for controlling access to shared system resources. The problem being solved is ensuring proper coordination among multiple processes or threads to prevent resource conflicts, deadlocks, or race conditions when accessing shared resources in a computing environment. The system includes a synchronization object, which in this specific embodiment is a semaphore object. A semaphore is a signaling mechanism used to manage access to a shared resource by multiple processes or threads. It allows a limited number of threads to access the resource simultaneously, preventing resource contention. The semaphore object tracks the availability of the resource and enforces access rules, such as permitting access only when the resource is free or limiting concurrent access to a predefined number of threads. The system further includes a resource manager that interacts with the semaphore object to control access to the shared resource. The resource manager may initialize the semaphore with an initial count representing the number of available resource instances. Threads or processes request access by signaling the semaphore, which either grants access if the count is sufficient or blocks the request until the resource becomes available. The semaphore decrements the count when access is granted and increments it when the resource is released, ensuring proper synchronization. This approach improves system stability and performance by preventing resource conflicts and ensuring orderly access to shared resources in a multi-threaded or multi-process computing environment.
7. The system of claim 6 wherein the system resource is a memory object.
A system for managing memory objects in a computing environment addresses the challenge of efficiently allocating, tracking, and deallocating memory resources to prevent leaks and optimize performance. The system includes a memory management module that dynamically allocates memory objects based on application demands, monitors their usage, and automatically deallocates them when they are no longer needed. The system also includes a tracking module that logs memory object metadata, such as allocation time, size, and reference counts, to facilitate debugging and performance analysis. Additionally, a garbage collection module periodically scans the memory space to identify and reclaim unused or orphaned memory objects, reducing fragmentation and improving system efficiency. The memory objects may include various data structures, such as arrays, linked lists, or custom objects, and the system ensures their proper lifecycle management to prevent memory leaks and ensure optimal resource utilization. The system may also integrate with existing memory management frameworks or operate as a standalone solution, depending on the deployment requirements. By automating memory management tasks, the system enhances application stability, reduces development overhead, and improves overall system performance.
8. The system of claim 7 wherein the system resource is at least one of a volatile memory, non-volatile memory, or a memory pool.
9. A method for controlling a synchronization object of a computer processing system comprising: executing one or more processing threads; executing a background thread configured to manage a processing flow of the one or more processing threads, the background thread configured to process one or more predetermined abort points for the one or more processing threads, the one or more abort points configured to direct any one of the one or more processing threads to execute exit processing code when an abort indicator signals that the one or more processing threads should be aborted; and executing a synchronization object for synchronizing the processing of the one or more processing threads, the synchronization object comprising a waiting queue for processing requests made by the one or more processing threads, the synchronization object programmed and configured to: upon receiving a processing request from any one of the one or more processing threads, queue the processing thread from which the request is received in the waiting queue until the processing request can be processed, wherein the synchronization object releases any of the one or more processing threads that are in the waiting queue in response to a request that the one or more processing threads should be aborted.
This invention relates to a method for managing synchronization objects in a computer processing system to handle thread aborts efficiently. The system involves multiple processing threads and a background thread that oversees their execution. The background thread monitors predetermined abort points within the processing threads, which are designed to trigger exit processing code when an abort indicator is activated. This ensures that threads can be terminated gracefully when needed. The synchronization object in this system is responsible for coordinating the processing of the threads. It includes a waiting queue where threads place requests for processing. When a thread submits a request, it is added to the queue and waits until its turn to execute. If an abort request is issued, the synchronization object releases all threads in the waiting queue, allowing them to exit or transition to a different state. This mechanism ensures that threads are not left waiting indefinitely when an abort is signaled, improving system responsiveness and resource management. The approach is particularly useful in environments where threads must be terminated or redirected quickly, such as in real-time or high-availability systems.
10. The method of claim 9 wherein releasing processing threads comprises calling a cancel waiting function that releases any of the one or more processing threads that are in the waiting queue.
This invention relates to a system for managing processing threads in a computing environment, particularly addressing the problem of efficiently releasing threads that are waiting in a queue. The system includes a method for handling thread processing where one or more processing threads are assigned to execute tasks. These threads may enter a waiting state when they are idle or awaiting resources. The method involves monitoring the status of these threads and determining when to release them from the waiting queue. The release process is triggered by a cancel waiting function, which actively frees any threads that are currently in the waiting state. This function ensures that resources are not unnecessarily occupied by idle threads, improving system efficiency and responsiveness. The method may also include additional steps such as detecting thread states, prioritizing thread execution, and dynamically adjusting the waiting queue based on system load. The overall goal is to optimize thread management by minimizing waiting times and maximizing resource utilization in a multi-threaded computing environment.
11. The method of claim 10 wherein the synchronization object is further configured to: upon receiving a subsequent processing request from any one of the one or more processing threads, return a signal indicating the subsequent processing request was aborted and not processed.
This invention relates to a method for managing synchronization objects in a multi-threaded processing environment. The problem addressed is ensuring efficient and controlled handling of processing requests from multiple threads to prevent resource contention and improve system performance. The method involves a synchronization object that coordinates access to shared resources among one or more processing threads. The synchronization object is configured to receive a processing request from a thread and determine whether to process the request based on predefined criteria. If the request meets the criteria, the synchronization object processes the request and returns a success signal. If not, it returns a signal indicating the request was aborted and not processed. The synchronization object can be further configured to handle subsequent processing requests from any of the threads. Upon receiving such a request, it returns a signal indicating the request was aborted, ensuring that only valid requests are processed. This mechanism helps maintain system stability and prevents unauthorized or redundant processing. The method ensures that only valid processing requests are executed, reducing unnecessary resource consumption and improving overall system efficiency. The synchronization object acts as a gatekeeper, filtering out invalid or redundant requests while allowing legitimate ones to proceed. This approach is particularly useful in high-concurrency environments where multiple threads compete for shared resources.
12. The method of claim 11 wherein the synchronization object comprises an API, the API comprising at least one function for processing threads to make processing requests of the synchronization object, the at least one function configured to: while the abort indicator is not signaled, not return until the processing request is processed or the cancel waiting function is processed; and, if the abort indicator is signaled, return a signal indicating the request was aborted without processing the request.
This invention relates to thread synchronization in computing systems, specifically addressing the need for efficient and reliable thread management when processing requests through synchronization objects. The invention provides a method for handling thread synchronization where a synchronization object includes an application programming interface (API) with at least one function for processing threads. This function manages processing requests made to the synchronization object. While an abort indicator is not signaled, the function ensures that it does not return until the processing request is either fully processed or a cancel waiting function is executed. If the abort indicator is signaled, the function immediately returns a signal indicating that the request was aborted without further processing. This mechanism allows for controlled interruption of thread operations, preventing resource waste and ensuring system responsiveness. The synchronization object may include additional functions for thread management, such as waiting for a condition or signaling an event, which are integrated into the overall synchronization framework. The invention enhances thread coordination by providing a clear and efficient way to handle request processing and cancellation, improving system performance and reliability in multi-threaded environments.
13. The method of claim 12 wherein if the synchronization object is busy processing requests, queuing additional requesting processing threads in the waiting queue until the synchronization object is available to process the additional requests or until the cancel waiting function is called.
This invention relates to thread synchronization in computing systems, specifically addressing the challenge of managing concurrent access to shared resources by multiple processing threads. The method involves a synchronization object that controls access to a shared resource, ensuring that only one thread can process a request at a time. When the synchronization object is busy processing a request, additional requesting threads are placed in a waiting queue. These threads remain in the queue until the synchronization object becomes available to handle their requests or until a cancel waiting function is invoked to terminate the wait. The synchronization object may also include a timeout mechanism, allowing threads to wait for a specified duration before automatically exiting the queue if the synchronization object remains unavailable. The method ensures orderly and efficient access to shared resources, preventing conflicts and deadlocks while providing flexibility for threads to exit the queue if necessary. This approach is particularly useful in multi-threaded applications where resource contention is high, improving system stability and performance.
14. The method of claim 9 wherein the synchronization object is a semaphore object representing a system resource.
A method for managing access to system resources in a computing environment involves using a synchronization object, specifically a semaphore, to control concurrent access. The semaphore represents a system resource, such as a shared memory block, a file, or a hardware device, and ensures that only a limited number of processes or threads can access the resource simultaneously. The method includes initializing the semaphore with a predefined count, which indicates the maximum number of concurrent accesses allowed. When a process or thread requests access to the resource, it performs a wait operation on the semaphore, decrementing the count if resources are available. If the count is zero, the request is blocked until another process releases the resource by performing a signal operation, incrementing the count. This mechanism prevents resource contention and ensures proper synchronization among multiple processes or threads. The method may also include error handling for cases where the semaphore is invalid or the system resource is unavailable. The approach is particularly useful in multi-threaded or distributed computing systems where multiple entities need coordinated access to shared resources.
15. The method of claim 14 wherein the system resource is at least one of volatile or non-volatile memory.
**Technical Summary for Prior Art Search Database** The invention relates to a method for managing system resources in a computing environment, specifically addressing the efficient allocation and utilization of memory resources. The problem being solved involves optimizing the use of system memory, whether volatile (e.g., RAM) or non-volatile (e.g., flash storage), to improve performance, reduce latency, or enhance data persistence in computing systems. The method involves dynamically assigning or reallocating memory resources based on system demands, application requirements, or predefined policies. This includes monitoring memory usage, identifying underutilized or overutilized memory regions, and redistributing resources accordingly. The system may prioritize critical operations, such as real-time processing or data caching, to ensure optimal performance. Additionally, the method may incorporate predictive algorithms to anticipate memory needs and preemptively allocate resources, reducing the risk of bottlenecks or failures. The invention further specifies that the system resources being managed include both volatile and non-volatile memory types. Volatile memory, such as RAM, is used for temporary data storage during active operations, while non-volatile memory, such as SSDs or flash storage, retains data even when power is off. The method ensures seamless integration between these memory types, allowing for efficient data transfer, caching, or persistence as needed. By dynamically managing memory resources, the invention aims to enhance system efficiency, reduce power consumption, and improve overall reliability in computing environments. This approach is particularly useful in high-performance computing, embedded systems, and data-intensive applications where
16. The method of claim 14 wherein the system resource comprises a network communications device.
A system and method for managing network communications devices in a computing environment. The invention addresses the challenge of efficiently allocating and monitoring system resources, particularly network communications devices, to optimize performance and reduce downtime. The method involves dynamically assigning network communications devices to tasks or processes based on current system demands, availability, and performance metrics. The system monitors the status and utilization of each network communications device, adjusting allocations in real-time to prevent bottlenecks or overloading. Additionally, the method includes failover mechanisms to automatically reroute communications through alternative devices if a primary device fails or becomes unavailable. The system may also prioritize critical communications to ensure high-priority tasks receive sufficient bandwidth and resources. By dynamically managing network communications devices, the invention improves overall system efficiency, reliability, and responsiveness in distributed computing environments. The method can be applied in data centers, cloud computing platforms, or any system requiring robust network resource management.
17. A computer program product for sharing computing resources, the computer program product comprising a non-transitory computer-readable storage medium encoded with computer-executable program code programmed to cause the execution across one or more processors of: executing one or more processing threads; executing a background thread configured to manage a processing flow of the one or more processing threads, the background thread configured to process one or more predetermined abort points for the one or more processing threads, the one or more abort points configured to direct any of the one or more processing threads to execute exit processing code when an abort indicator signals that the one or more processing threads should be aborted; and executing a synchronization object for synchronizing the processing of the one or more processing threads, the synchronization object comprising a waiting queue for processing requests made by the one or more processing threads, the synchronization object programmed and configured to: upon receiving a processing request from any of the one or more processing threads, queue the processing thread from which the request is received in the waiting queue until the processing request can be processed, wherein the synchronization object releases any of the one or more processing threads that are in the waiting queue in response to a request that the one or more processing threads should be aborted.
This invention relates to a system for managing and sharing computing resources, particularly in environments where multiple processing threads must be coordinated and efficiently terminated when necessary. The system addresses the challenge of ensuring orderly and synchronized execution of threads while allowing for controlled termination when required, such as during system shutdowns or error conditions. The system includes a background thread that oversees the execution of one or more processing threads. The background thread monitors predetermined abort points within the processing threads, which are checkpoints where the threads can be instructed to terminate. When an abort indicator is triggered, the processing threads execute exit processing code to safely terminate their operations. Additionally, a synchronization object is used to manage thread synchronization, featuring a waiting queue for processing requests from the threads. When a thread submits a request, it is placed in the waiting queue until the request can be processed. If an abort request is received, the synchronization object releases all waiting threads, allowing them to proceed or terminate as needed. This ensures that threads are either processed in an orderly manner or safely aborted when required, improving system reliability and resource management.
18. The computer program product of claim 17 wherein releasing processing threads comprises calling a cancel waiting function that releases any of the processing threads that are in the waiting queue.
This invention relates to a computer program product for managing processing threads in a computing system, particularly addressing the problem of efficiently releasing threads that are waiting in a queue. The system includes a processing queue for managing threads and a waiting queue for holding threads that are waiting for resources or conditions to be met before execution. The invention provides a mechanism to release processing threads from the waiting queue when certain conditions are triggered, such as when a task is canceled or when resources become available. The release process involves calling a cancel waiting function, which actively removes threads from the waiting queue, allowing them to be reallocated or terminated as needed. This ensures that waiting threads do not indefinitely consume system resources and improves overall system efficiency by freeing up resources for other tasks. The invention also includes a method for monitoring the waiting queue and determining when to invoke the cancel waiting function based on predefined criteria, such as timeouts or resource availability. By dynamically managing the waiting queue, the system prevents resource contention and enhances performance in multi-threaded environments.
19. The computer program product of claim 18 wherein the synchronization object, upon receiving a subsequent processing request from any one of the one or more processing threads, returns a signal indicating the subsequent request was aborted and not processed.
This invention relates to computer program products for managing synchronization objects in multi-threaded processing environments. The problem addressed is ensuring efficient and controlled handling of processing requests from multiple threads to prevent conflicts or race conditions when accessing shared resources. The invention involves a synchronization object that coordinates access to shared resources among one or more processing threads. When a processing request is received, the synchronization object determines whether the request should be processed or aborted based on predefined criteria. If the request is aborted, the synchronization object returns a signal indicating the request was not processed, allowing the thread to handle the abort appropriately. This mechanism ensures that only valid or prioritized requests proceed, improving system stability and performance. The synchronization object may include logic to evaluate request conditions, such as thread priority, resource availability, or system state, before deciding whether to process or abort a request. The abort signal provides feedback to the requesting thread, enabling it to retry, adjust its behavior, or take alternative actions. This approach is particularly useful in high-concurrency environments where uncontrolled access to shared resources could lead to errors or performance degradation. The invention enhances thread coordination by providing a clear and immediate response when a request is aborted, allowing threads to adapt dynamically.
20. The computer program product of claim 19 wherein the synchronization object comprises an API, the API comprising at least one function for processing threads to make processing requests of the synchronization object, the at least one function configured to: while the abort indicator is not signaled, not return until the processing request is processed or the cancel waiting function is processed; and, if the abort indicator is signaled, return a signal indicating the request was aborted without processing the request.
This invention relates to a computer program product for managing thread synchronization in a computing system, specifically addressing the need for efficient and reliable thread coordination in multi-threaded environments. The invention provides a synchronization object that includes an application programming interface (API) with functions for processing thread requests. The API functions are designed to handle thread processing requests while monitoring an abort indicator. When the abort indicator is not signaled, the function does not return until the processing request is completed or a cancel waiting function is executed. If the abort indicator is signaled, the function immediately returns a signal indicating that the request was aborted without further processing. This mechanism ensures that threads can be gracefully terminated or interrupted when necessary, improving system responsiveness and resource management. The synchronization object and its API functions enable precise control over thread execution, allowing for efficient handling of concurrent operations while preventing deadlocks and ensuring proper termination of pending requests. The invention is particularly useful in systems where threads must be synchronized with external events or conditions, such as user input, system state changes, or other asynchronous operations.
Unknown
August 11, 2020
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.