Patent EP0381655A2 successfully refreshed from Google Patents.
← Back to Patent Explorer
EP0381655A2 Expired / Lapsed EP ⏱️ 0.0 years remaining

Method for synchronizing the dispatching of tasks among multitasking operating systems

Assignee: International Business Machines Corp
•
Filing: 1990-01-30
•
Granted: —
•
Expires: 2010-01-30
📄 Original PDF 🌐 Google Patents 🔄 Sync Now

Abstract

Abstract A method for synchronizing the dispatching of tasks from a CPU-based first multitasking operating system (OS) with threads of function calls opportunistically dispatched from a CPU-based second multitasking operating system. The second OS includes a set of callable resources. In the method, a task becomes bound to a thread for the duration of that thread's ownership of a callable resource from the second OS. Also, a thread becomes available on a work queue of threads for binding to a task only if the thread owns exactly one resource. After execution, the function is eliminated from the thread and ownership of that resource is relinquished and passed to the next thread queued on that resource. A task can remain bound to the same thread if there are no other threads asserting ownership to the next resource being called by the original thread. With contention, however, the task relinquishes the thread and becomes bound to another thread on the work queue.

Inventors

  • 👤 Steven Hirsh Goldberg
  • 👤 Gerald Wayne Holten
  • 👤 Jerome Anthony Mouton, Jr.

Bibliographic Details

Application Number —
Jurisdiction EP
Data Source google_patents
Last Synchronized 2026-11-01 21:33
CPC Classifications
G; G06; G06F; G06F8/00; G06F8/40; G06F8/41; G06F8/45; G06F8/458

Claims Analysis

Total Claims: 10
Claim 1
Independent Claim 178 words
A method for synchronizing the dispatching of tasks from a CPU-based first multitasking operating system (OS) with threads of function calls opportunistically dispatched by a CPU-based second multitasking OS, said second OS including a set of callable resources comprising the steps of: (a) securing ownership by a thread to one of the second OS resources named by a function call in said thread, upon the conditions that: (1) the thread is the only thread enqueued against the resource, and (2) the thread does not own any other resource; otherwise, (3) enqueuing the thread against each resource named by a function call in said thread; (b) enqueuing threads owning resources against tasks, binding the next available task to the first thread of the task thread's queue, and executing a predetermined one of the function calls of the first thread by the bound task; and (c) after execution, causing the first bound thread to relinquish ownership of its resource, and causing the next thread queued against said same resource to become the resource owner and to be enqueued against tasks.
Claim 2
Independent Claim 178 words
A method for synchronizing the dispatching of tasks from a CPU-based first multitasking operating system (OS) with threads of function calls opportunistically dispatched by a CPU-based second multitasking OS, said second OS including a set of callable resources comprising the steps of: (a) securing ownership by a thread to one of the second OS resources named by a function call in said thread, upon the conditions that: (1) the thread is the only thread enqueued against the resource, and (2) the thread does not own any other resource; otherwise, (3) enqueuing the thread against each resource named by a function call in said thread; (b) enqueuing threads owning resources against tasks, binding the next available task to the first thread of the task thread's queue, and executing a predetermined one of the function calls of the first thread by the bound task; and (c) after execution, causing the first bound thread to relinquish ownership of its resource, and causing the next thread queued against said same resource to become the resource owner and to be enqueued against tasks.
Claim 3
Independent Claim 181 words
A method for synchronizing the dispatching of tasks from a CPU-based multitasking operating system (OS) responsive to at least one demand placed by at least one application upon a CPU-resident OSI type layered communications subsystem, said subsystem including callable resources associated with the layers, comprising the steps of: (a) forming a thread of service requests to a set of resources counterpart to each demand, and either: (1) securing ownership of one resource named by the thread, if the thread is the only thread enqueued against the resource, and if the thread does not own any other resource, or (2) enqueuing the thread against each resource named by said thread; (b) enqueuing those threads owning resources against tasks, binding the next available task to the first thread in the task thread queue, and executing a predetermined one of the service requests by the bound task; and (c) after execution, causing the first bound thread to relinquish ownership of its resource, and causing the next thread queued against said same resource to become the resource owner and to be enqueued against the tasks.
Claim 4
Independent Claim 181 words
A method for synchronizing the dispatching of tasks from a CPU-based multitasking operating system (OS) responsive to at least one demand placed by at least one application upon a CPU-resident OSI type layered communications subsystem, said subsystem including callable resources associated with the layers, comprising the steps of: (a) forming a thread of service requests to a set of resources counterpart to each demand, and either: (1) securing ownership of one resource named by the thread, if the thread is the only thread enqueued against the resource, and if the thread does not own any other resource, or (2) enqueuing the thread against each resource named by said thread; (b) enqueuing those threads owning resources against tasks, binding the next available task to the first thread in the task thread queue, and executing a predetermined one of the service requests by the bound task; and (c) after execution, causing the first bound thread to relinquish ownership of its resource, and causing the next thread queued against said same resource to become the resource owner and to be enqueued against the tasks.
Claim 5
Dependent Claim 25 words
The method according to claim 2, wherein after a service request named in a thread has been executed, removing said service request from the thread.
Claim 6
Dependent Claim 119 words
The method according to claim 2, wherein said method comprises the further steps of: (d) ascertaining the presence of an additional service request in the first bound thread, and enqueuing the thread against the resource counterpart to said additional service request, if the additional service request is present; and (e) ascertaining whether said first bound thread is the first in the resource queue, and, if first, causing said first bound thread to become the resource owner, and causing said additional service request to be executed by the current task without having to be enqueued against OS tasks, whereby a single thread opportunistically passes through the communications layers using the same task in the absence of contention within the subsystem.
Claim 7
Dependent Claim 76 words
The method according to claim 4, wherein if the first bound thread was not first enqueued against the resource, then said method comprises the further steps of: (f) causing the task to stop processing said first bound thread and to obtain another thread to process from those threads enqueued against the tasks; and (g) enqueuing the now abandoned first bound thread against a resource counterpart to another service request, if present, in said first bound thread.
Claim 8
Dependent Claim 12 words
The method according to claim 2, wherein the resources are tie groups.
Claim 9
Dependent Claim 295 words
A computer-implemented method for allocating tasks in a multitasking layered communications subsystem as a function of service request (work) distribution, each layer providing a unique set of functions for establishing an association between counterpart connection endpoints, each layer being manifest by at least one control block, each control block being a state representation of the connection endpoints in that layer, each control block further including indicia of a request to provide service, a thread being denominated as a sequence of related service requests performed in a synchronous manner, each service request being associated with counterpart control blocks, each control block further being split within a layer such that it depicts the adjacent layers to a connection within any given layer, each layer including at least one tie, each tie being the connection relation between split portions of the control block in the same layer, a tie group being an undirected graph of ties, only one thread executing per tie group at a time, comprising the steps of: (a) starting a thread responsive to each communication subsystem-oriented command generated by a host-based application, and either binding the thread to an available counterpart tie group and appending said started thread to a queue of available threads, or enqueuing the thread to the counterpart tie group; (b) binding the next available task to the first thread in the queue of available threads provided that there is no other thread with a service request to a control block in the same tie group already bound to any task; and (c) in the event that the first available thread violates the constraint of there being only one bound thread per tie group, binding of a second available thread in the same tie group only after the first thread becomes free.
Claim 10
Dependent Claim 295 words
A computer-implemented method for allocating tasks in a multitasking layered communications subsystem as a function of service request (work) distribution, each layer providing a unique set of functions for establishing an association between counterpart connection endpoints, each layer being manifest by at least one control block, each control block being a state representation of the connection endpoints in that layer, each control block further including indicia of a request to provide service, a thread being denominated as a sequence of related service requests performed in a synchronous manner, each service request being associated with counterpart control blocks, each control block further being split within a layer such that it depicts the adjacent layers to a connection within any given layer, each layer including at least one tie, each tie being the connection relation between split portions of the control block in the same layer, a tie group being an undirected graph of ties, only one thread executing per tie group at a time, comprising the steps of: (a) starting a thread responsive to each communication subsystem-oriented command generated by a host-based application, and either binding the thread to an available counterpart tie group and appending said started thread to a queue of available threads, or enqueuing the thread to the counterpart tie group; (b) binding the next available task to the first thread in the queue of available threads provided that there is no other thread with a service request to a control block in the same tie group already bound to any task; and (c) in the event that the first available thread violates the constraint of there being only one bound thread per tie group, binding of a second available thread in the same tie group only after the first thread becomes free.

References Cited (Backward Citations)

No citation records indexed.

USPTO Annuity & Maintenance Windows

Maintenance schedule is calculated for granted US utility patents.

Assigned Categories & Tags

No categories assigned to this patent yet.

Assign Category Tag