Interface system and method for asynchronous refresh sharing resource

A technology for interfacing systems and resources, applied in the system field, and can solve problems such as system errors

Inactive Publication Date: 2000-10-04
IBM CORP
View PDF1 Cites 6 Cited by
  • Summary
  • Abstract
  • Description
  • Claims
  • Application Information

AI Technical Summary

Problems solved by technology

Such a system generally requires tasks that need to access data structures and objects to wait to update data structures and ob

Method used

the structure of the environmentally friendly knitted fabric provided by the present invention; figure 2 Flow chart of the yarn wrapping machine for environmentally friendly knitted fabrics and storage devices; image 3 Is the parameter map of the yarn covering machine
View more

Image

Smart Image Click on the blue labels to locate them in the text.
Viewing Examples
Smart Image
  • Interface system and method for asynchronous refresh sharing resource
  • Interface system and method for asynchronous refresh sharing resource
  • Interface system and method for asynchronous refresh sharing resource

Examples

Experimental program
Comparison scheme
Effect test

example 1

[0147] Example 1. Maintaining a list of lock waiters

[0148] As mentioned above, in a preferred embodiment, the asynchronous facility of the present invention is combined with the synchronous lock facility.

[0149] There is no design showing the synchronization lock functionality, but in a DFS / MVS environment, the lock facility uses low-level MVS operating system facilities to make tasks wait on locks. DFX is a POSIX application. If DFS encounters a procedural surprise, POSIX facilities are not designed to handle tasks waiting on these low-level OS functions (WAIT / POST). Therefore, when a program accident occurs, the DFS lock package not only arranges WAIT_ELEMENTS on the lock itself, but also in a global list, which can be used as a check, and all waiting tasks can be woken up and notified of the accident.

[0150]Referring to Fig. 9, when a task is waiting for a lock, as mentioned above, it uses the lock_or_wait routine to queue its WAIT_ELEMENT to the lock, and also add...

example 2

[0162] Example 2. Manage I / O devices occupying queues

[0163] This example relates to the system described in U.S. Patent Application (Serial No. 09 / 240,719) filed October 29, 1999 by S.T. Marcotte, System and Method for I / O Servicing Commands Issuing Application Effects of I / O Requests , assignee volume number EN998137. Marcotte describes an I / O queuing system, that is, if the number of I / Os issued to a device is greater than Max_Issued, Max_Issued is an adjustable number, which is adjusted according to the application using the I / O driver described here, the system There is an active queue on the device that is queuing delayed I / O.

[0164] Referring to FIG. 16, in this example, a hold queue 270 of aevents272, 273, 275 is provided, which is anchored by holdHead271 and HoldTail274, along with max_issued287, current_issued288 and device_lock289. Max_issued stores the maximum number of I / O operations sent to the device, and current_issued288 stores the number of I / O events a...

example 3

[0182] Example 3. Managing service thread regions with asynchronous locks

[0183] Referring to Figures 22 to 28, there is a limited task area that can service requests from client threads for work that must for one reason or another (depending on the application) run on the service thread, and the request will be Handled on a first-come, first-served basis. In this example, the client thread can either wait for the request to complete, or not wait for the request to complete (this means that the request can be either asynchronous or synchronous). There can be any number of client or server threads, depending on the application. Specifically, for example, in IBM DFS / MVS products, a user task invokes DFS to issue a file request. For various reasons these task requests cannot be run under the calling task, the service task must pick up the user file request and run it. Therefore, there is a limited area of ​​service threads, and a certain number of user tasks (approximately e...

the structure of the environmentally friendly knitted fabric provided by the present invention; figure 2 Flow chart of the yarn wrapping machine for environmentally friendly knitted fabrics and storage devices; image 3 Is the parameter map of the yarn covering machine
Login to view more

PUM

No PUM Login to view more

Abstract

Tasks make updates requested by calling tasks to a shared resource serially in a first come first served manner, atomically, but not necessarily synchronously, such that a current task holding an exclusive lock on the shared resource makes the updates on behalf of one or more calling tasks queued on the lock. Updates waiting in a queue on the lock to the shared resource may be made while the lock is held, and others deferred for post processing after the lock is released. Some update requests may also, at the calling application's option, be executed synchronously. Provision is made for nested asynchronous locking. Data structures (wait_elements) describing update requests may queued in a wait queue for update requests awaiting execution by a current task, other than the calling task, currently holding an exclusive lock on the shared resource. Other queues are provided for queuing data structures removed from the wait queue but not yet processed; data structures for requests to unlock or downgrade a lock; data structures for requests which have been processed and need to be returned to free storage; and data structures for requests that need to be awakened or that describe post processing routines that are to be run while the lock is not held.

Description

Background of the invention [0001] Technical Field of the Invention [0002] The present invention relates to interface systems and methods. More specifically, it relates to a system and method for managing locks that allow asynchronous updates to shared resources without task switching, waiting, or CPU idling. Background technique [0003] Computer systems provide many mechanisms and methods for preventing updates to data structures and objects in memory. A typical approach is to update a shared resource that resides in computer memory while taking an exclusive lock (thus ensuring atomic updates of the resource). Such a system generally requires tasks that need to access data structures and objects to wait to update the data structures and objects until the exclusive lock is granted, so it is often necessary to suspend the waiting tasks, which may cause system errors. [0004] Therefore, there is a technical need for a system and method that can eliminate or reduce tasks...

Claims

the structure of the environmentally friendly knitted fabric provided by the present invention; figure 2 Flow chart of the yarn wrapping machine for environmentally friendly knitted fabrics and storage devices; image 3 Is the parameter map of the yarn covering machine
Login to view more

Application Information

Patent Timeline
no application Login to view more
IPC IPC(8): G06F12/00G06F3/00G06F9/44G06F9/46G06F9/50G06F9/52G06F17/30G11B23/00
CPCY10S707/99938Y10S707/99931G06F2209/523Y10S707/99952G06F9/526
Inventor S·T·马科特
Owner IBM CORP
Who we serve
  • R&D Engineer
  • R&D Manager
  • IP Professional
Why Eureka
  • Industry Leading Data Capabilities
  • Powerful AI technology
  • Patent DNA Extraction
Social media
Try Eureka
PatSnap group products

Browse by: Latest US Patents, China's latest patents, Technical Efficacy Thesaurus, Application Domain, Technology Topic.

© 2024 PatSnap. All rights reserved.Legal|Privacy policy|Modern Slavery Act Transparency Statement|Sitemap