United States Patent [191
`Tandai et a1.
`
`llllllllllllllllllllllllllllllllIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHIIII
`US005293618A
`[11] Patent Number:
`5,293,618
`[45] Date of Patent:
`Mar. 8, 1994
`
`[54] METHOD FOR CONTROLLING ACCESS TO
`A SHARED FILE AND APPARATUS
`THEREFOR
`[75] Inventors: Michio Tandai, Yokohama; Masaaki
`Hanna, Fujisawa; Fujio Fujita,
`Yokohama, all of Japan
`[73] Assignees: Hitachi, Ltd., Tokyo; Hitachi
`Software Engineering Co, Ltd,
`Yokohama, both of Japan
`[21] Appl. No.: 614,088
`[22] Filed:
`Nov. 15, 1990
`[30]
`Foreigi Application Priority Data
`Nov. 18, 1989 [JP]
`Japan ................................ .. 1-300611
`
`[51] Int. Cl.5 ........................ .. G06F 7/00; G06F 7/20;
`G06F 7/04
`[52] US. Cl. ........................... .. 395/650; 364/DIG. 1;
`364/246.6; 364/228.l; 364/243.41
`[58] Field of Search ............... .. 395/650; 364/DIG. l,
`364/246.6, 228.1, 243.41
`References Cited
`U.S. PATENT DOCUMENTS
`
`[56]
`
`4,823,310 4/l989 Grand ............................... .. 364/900
`4,897,782 1/1990 Bennett et al. .................... .. 364/200
`
`OTHER PUBLICATIONS
`“DASD sharing with other systems”, Manual for Pro
`
`grammer of Hitachi Program Product VOS 3/ES Sys
`tem, 1988, pp. 97-104.
`
`Primary Examiner-Gareth D. Shaw
`Assistant Examiner-A. Katbab
`Attorney, Agent, or Firm-Antonelli, Terry, Stout &
`Kraus
`
`ABSTRACT
`[57]
`In an information processing system including a ?le
`shared by computer systems each having a central pro
`cessing system and a main memory, a method for con
`trolling access to the shared ?le includes a step of stor
`ing blocks read from the ?le into the main memory
`when the blocks of the file are updated, and a step of
`comparing at least a portion of the blocks held in a
`cache memory with at least a portion of the blocks
`stored in the main memory. When the comparison of at
`least the portion of the blocks held in the cache memory
`with at least the portion of the blocks stored in the main
`memory indicates mismatching, the block is read from
`the ?le into the main memory, and when the compari
`son indicates matching, the block of the main memory is
`updated. The data to be updated may be in a resident
`area, an input/output buffer or a same area.
`
`4 Claims, 8 Drawing Sheets
`
`I
`
`START )
`
`READ UPDATE STATUS
`INDICATOR OF BLOCK TO
`BE UPDATED IN CACHE
`MEMORY
`
`ARE CONTENT CF SAVE
`AREA AND UPDATE
`STATUS INDICATOR IN
`CACHE MEMORY EQUAL?
`
`502
`
`YES
`
`503
`
`UPDATE UPDATE STATUS
`INDICATOR IN CACHE
`MEMORY AND UPDATE
`BLOCK ON DISK MEDIUM
`
`END
`
`504
`i
`
`WRITE BLOCK INTO
`MAIN MEMORY
`
`Petitioner Microsoft Corporation - Ex. 1062, p. 1
`
`

`
`US. Patent
`
`Mar. 8, 1994
`
`Sheet 1 of 8
`
`5,293,618
`
`IoI F I6 I
`_§QMPUTER__SYSTEM__L
`
`cQMPuTER _S_YSTEM
`
`IoI’
`"31
`
`CH
`)
`
`CENTRAL
`PROCESSING UNIT
`MAIN
`3
`MEMORY
`I02
`,I05
`
`1/0 BUFFER
`
`CH CENTRAL
`I
`PROCESSING uNIT
`' MAIN
`\
`I
`'03 MEMoRY
`‘94"02
`rI05’
`
`1/0 BUFFER
`
`/
`
`.
`
`sAvE ~|O6
`AREA
`
`I???
`
`RESIDENT
`AREA
`
`RESIDENT
`AREA
`
`‘
`
`I
`
`I
`
`E
`
`,
`
`sAvE “'06
`AREA
`
`,
`
`I9?
`
`RESIDENT
`AREA
`
`REsIoENT
`AREA
`
`’
`
`I
`
`,
`
`‘x. &
`
`RESIDENT
`AREA
`
`.
`'
`
`1
`
`REsIoENT
`AREA
`
`'
`
`=
`
`FII_E
`
`_
`
`IIQ
`/
`cAcI-IE MEMORY
`UPDATE STATUS
`INDICATOR
`
`H3
`.EJ
`
`,_../IO8
`
`Petitioner Microsoft Corporation - Ex. 1062, p. 2
`
`

`
`U.S. Patent
`
`Mar. 8, 1994
`
`Sheet 2 of 8
`
`5,293,618
`
`F l G. 2
`
`I
`~ 2OI
`
`DATA
`201 ' ‘“ ACCESSING
`UNIT
`
`DATA
`ACCESSING
`UNIT
`
`CHANNEL
`PROGRAM
`UNIT
`
`~ 202
`
`FIG. 3
`
`OPERATION OF DATA
`ACCESSING UNIT
`
`304
`I
`ISSUE CHANNEL PROGRAM
`HAVING PROCESS OF FIG.5
`
`/3o5
`
`NO
`
`IS DECISION IN 502
`OF FIG.5 YES ‘?
`
`YES
`
`END
`
`30,
`I
`
`ISSUE CHANNEL PROGRAM
`HAVING PROCESS OF FIG.4
`AND START TO READ
`BLOCK TO BE UPDATED
`INTO I/O BUFFER
`
`SAVE UPDATE STATUS
`INDICATOR INTO SAVE
`AREA
`
`UPDATE CONTENT OF
`BLOCK IN NO BUFFER
`
`I
`
`Petitioner Microsoft Corporation - Ex. 1062, p. 3
`
`

`
`US. Patent
`
`Mar. 8, 1994
`
`Sheet 3 of 8
`
`5,293,618
`
`FIG. 4
`
`I
`
`START I
`
`POSITION READING OF BLOCK
`BY CHANNEL PROGRAM UNIT ” 40'
`TO THE BLOCKON DISK MEDIUM
`
`READ BLOCK INTO MAIN
`MEMORY AND sTORE
`UPDATE sTATus INDICATOR J‘ 402
`INTO CACHE MEMORY
`
`END
`
`FIG. 5
`
`I
`
`START I
`
`READ UPDATE STATUS
`INDICATOR OF BLOCK TO M 50|
`BE UPDATED IN CACHE
`MEMORY
`
`502
`ARE CONTENT OF SAVE
`AREA AND UPDATE
`NO
`STATUS INDICATOR IN
`CACHE MEMORY EQUAL?/
`YES
`503
`
`504
`
`UPDATE UPDATE STATUS
`INDICATOR IN CACHE
`MEMORY AND UPDATE
`BLOCK ON DISK MEDIUM
`
`wRlTE BLOCK INTO
`MAIN MEMORY
`
`END
`
`Petitioner Microsoft Corporation - Ex. 1062, p. 4
`
`

`
`US. Patent
`
`Mar. 8, 1994
`
`Sheet 4 of 8
`
`5,293,618
`
`FIG. 6
`
`I
`
`START I
`
`READ INDEX BLOCK
`HAVING POINTER AND
`WRITE BLOCK AT ADDRESS
`POINTED BY POINTER
`(DATA ACCESSING UNIT)
`
`ISSUE CHANNEL PROGRAM
`HAVING PROCESS OF FIG. 8
`AND START READING OF
`INDEX BLOCK FROM DISK
`INTO I/O BUFFER
`
`DETERMINE TARGET BLOCK
`ADDRESS BASED ON POINTER
`IN INDEX BLOCK
`
`~602
`
`ISSUE CHANNEL PROGRAM
`HAVING PROCESS OF FIG.9
`FOR READING TARGET BLOCK
`
`M603
`
`IS DECISION IN 802
`OF FIG.9 YES ?
`
`604
`
`NO
`
`YES
`
`END
`
`Petitioner Microsoft Corporation - Ex. 1062, p. 5
`
`

`
`US. Patent
`
`Mar. 8, 1994
`
`Sheet 5 of 8
`
`5,293,618
`
`FIG. 7
`
`I09
`
`POINTER RELATIONSHIP IN FILE G
`
`662
`
`IST BLOCKS
`
`2ND BLOCKS
`
`664
`
`\
`/
`
`FIG. 8
`
`I
`
`START I
`
`POSITION TO BLOCK
`ON DISK MEDIUM
`
`~TOI
`
`WRITE BLOCK INTO MAIN
`MEMORY AND STORE
`BLOCK INTO CACHE
`MEMORY
`
`~702
`
`END
`
`Petitioner Microsoft Corporation - Ex. 1062, p. 6
`
`

`
`U.S. Patent
`
`Mar. 8, 1994
`
`Sheet 6 of 8
`
`FIG. 9
`
`I
`
`START I
`
`COMPARE INDEX BLOCK
`80'
`STORED IN I/O BUFFER
`WITH INDEX BLOCK IN V
`CORRESPONDING
`CACHE MEMORY
`
`802
`ARE CONTENT OF NO ‘0
`BUFFER AND CONTENT OF
`CACHE MEMORY EQUAL ? /
`YES
`803
`
`8§>4
`
`WR'TE TARGET BLOCK
`POINTED BY POINTER OF
`INDEX BLOCK INTO
`MAIN MEMORY
`
`WRITE INDEX BLOCK
`INTO MAIN MEMORY
`
`END
`
`Petitioner Microsoft Corporation - Ex. 1062, p. 7
`
`

`
`US. Patent
`
`Mar. 8, 1994
`
`Sheet 7 of 8
`
`5,293,618
`
`FIG. I0
`
`I . START
`
`I
`
`ISSUE CHANNEL
`PROGRAM HAVING PROCESS
`OF FIG.II AND DETERMINE ~9OI
`WHETHER CONTENT OF
`BLOCK IN RESIDENT
`AREA IS LATEST oNE
`
`902
`
`IS DECISION IN I002
`OF FIG. II YES ?
`
`NO
`
`YES
`
`9(53
`
`USE coNTENT OF BLOCK
`IN RESIDENT AREA
`
`904
`
`3
`
`STORE CONTENT OF
`NEWLY READ BLOCK INTD
`RESIDENT AREA AND USE
`THE coNTENT
`
`END
`
`Petitioner Microsoft Corporation - Ex. 1062, p. 8
`
`

`
`US. Patent
`
`Mar. 8, 1994
`
`Sheet 8 of 8
`
`5,293,618
`
`FIG.
`
`I
`
`START I
`
`READ UPDATE STATUS
`INDICATOR IN CACHE
`MEMORY CORRESPONDING
`TO BLOCK TO BE WRITTEN
`
`~IOO|
`
`I002
`
`,ARE CONTENT OF
`RESIDENT AREA AND
`UPDATE STATUS
`INDICATOR IN CACHE
`MEMORY EQUAL ?
`
`YES
`
`I003
`
`I
`
`WRITE BLOCK INTO
`MAIN MEMORY
`
`END
`
`Petitioner Microsoft Corporation - Ex. 1062, p. 9
`
`

`
`1
`
`5,293,618
`2
`cuted by another computer system. Thus, the resident
`function cannot be used among the computer systems.
`
`METHOD FOR CONTROLLING ACCESS TO A
`SHARED FILE AND APPARATUS THEREFOR
`
`SUMMARY OF THE INVENTION
`It is a ?rst object of the present invention to enhance
`a processing ef?ciency of an overall information pro
`cessing system by eliminating the exclusive control
`during a time period from the reading of a desired block
`to the writing of update data in an update process for a
`?le shared by a plurality of computer systems with the
`updating, or from the reading of a block having a
`pointer such as an index to the reading of a desired
`block at an address pointed by the pointer.
`It is a second object of the present invention to en
`hance a data access performance in a ?le shared by a
`plurality of computer systems with the updating by
`suppressing the reading from the file and using the con
`tent of the block stored in a main memory when the
`desired block has not been updated.
`It is another object of the present invention to pro
`vide a system which enhances a data accessing perfor
`mance of computer systems of a multi-computer system
`for a ?le shared by the computer system with the updat
`ing by using a resident area of a main memory of each of
`the computer systems and a cache memory of the ?le
`shared by the computer systems so that the input/out
`put to the ?le medium is reduced.
`- In order to achieve the above objects, in accordance
`with the present invention, there are provided a cache
`memory for storing all or a predetermined portion of a
`block written from a shared ?le into a main memory,
`and means for comparing at the time of updating a block
`all or portion of the block stored in the cache memory
`with the content of data in the main memory and read~
`ing the shared ?le if the comparison indicates mismatch
`ing. In order to support the above sequence, there is
`provided a scheme wherein when a block on the shared
`?le to be accessed is written into the main memory, an
`entire portion of the block or a portion of the block
`which uniquely represents an update status of the block
`(hereinafter referred to as an update indicator) is also
`stored in the cache memory. The entire block in the
`cache memory or the update indicator is updated in the
`cache memory when the block is written into the ?le.
`Thus, the cache memory can also be shared by the
`plurality of computer systems. By comparing the entire
`block in the cache memory or the update indicator with
`the entire content of the block or the content of the
`update area stored in the main memory when the block
`was written into the main memory, it is possible to
`determine whether the block has been updated by a
`process of another computer system or not, without
`actually reading the block stored in the ?le. The deci
`sion may be made without physical movement such as
`the movement of an access arm of a disk drive or the
`rotation of a disk. Since no physical movement which
`occupies a considerable portion of an input/output time
`to the disk ?le is involved, the decision time for the
`process of another computer system is very small and
`negligible.
`When the block is written in a block update process,
`the content of the cache memory is compared with the
`content of the corresponding data stored in the main
`memory to determine whether the updating has been
`made by a process of another computer system during a
`time period from the reading of the block to the writing.
`In the writing of the block for updating, the content
`when the block was written into the main memory is
`
`BACKGROUND OF THE INVENTION
`The present invention relates to access control to a
`shared ?le stored, for example on a disk drive or mag
`netic tape drive which is shared and updated by a plu
`rality of computer systems, and more particularly to
`access control which eliminates need for exclusive con
`trol in an update process and improves performance of
`data accessing in block writing.
`In middle size to large size information processing
`systems, one disk ?le is frequently shared by a plurality
`of computer systems. Especially, a system register disk
`?le on which ?les are registered is shared and fre
`quently updated or overwritten.
`In the past, when one ?le is shared by a plurality of
`computer systems, duplicate updating is prevented by
`exclusive control of the writing of a desired block to the
`reading for updating when data processing is to be per
`formed for the desired stored block by a computer sys
`tem. For example, as described in the “DASD Sharing
`with other systems” manual for Programmer of Hitachi
`Program Product VOS3/ES System, 1988, pages
`97-104, when an I/O request to a shared ?le is issued, a
`disk drive on which the shared ?le is stored is exclu
`sively occupied by the associated computer system by
`an instruction set such as a RESERVE macro which is
`issued from a CPU to the disk drive to designate and
`occupy the disk drive, and I/O requests from other
`computer systems have to wait until the occupation is
`released by an instruction set such as a DEQ macro
`which is issued to release the designated disk drive from
`the occupation (exclusive control).
`The ?le such as a system register comprises an index
`?eld and a data ?eld, and in many cases, it is a ?le struc
`ture having a pointer relationship among blocks of the
`?le. When the ?le is shared with updating, the exclusive
`control is performed even for an input process without
`updating, during a period from the reading of an index
`having the pointer into a desired data block to the read
`ing by the disk drive of the data block which is at the
`address pointed by the pointer. This is done in order to
`prevent process discrepancy that if addition (updating)
`of a record to a data block is done in an updating pro
`cess by another computer system during the period
`from the reading of the index in the input process to the
`reading of the data block, the target data which was in
`the data block pointed by the index at the time of read
`ing of the index in the input process has been moved to
`another data block and the target data which should
`exist cannot be located.
`In the prior art, when the computer system accesses
`the shared ?le, the exclusive control is performed to
`suppress simultaneous access by other computer sys
`tems. Accordingly, the processing performance of the
`overall information processing system cannot be en
`hanced. In a single computer system, a resident area is
`provided in a main memory to reduce input/output
`operation of the ?le and enhance data accessing perfor
`mance. On the other hand, in a multi-computer system,
`in the input process from the computer system to the
`shared ?le, the content of the desired block which has
`been previously written into the main memory is not
`used but the block on the ?le is fetched on the assump
`tion that the block has been updated by a process exe
`
`5
`
`25
`
`45
`
`50
`
`65
`
`Petitioner Microsoft Corporation - Ex. 1062, p. 10
`
`

`
`5,293,618
`3
`4
`compared with the content of the cache memory, and if
`FIG. 9 shows a process of the channel program unit
`the comparison matches, it means that no updating by
`for reading a target block pointed by an index block,
`another computer system has been made and the block
`used in FIG. 6,
`is updated. If the comparison mismatches, the block is
`FIG. 10 shows a process of the data accessing unit for
`read out. In this manner, the data is correctly updated
`block reading by utilizing a residential area in a main
`without the exclusive control and the duplicate updat
`memory, and
`ing by the plurality of computer systems is prevented.
`FIG. 11 shows a process of the channel program unit
`In a file having a structure which has a pointer rela
`for block reading used in FIG. 10.
`tionship such as an index shared by a plurality of com
`puter systems with the updating, when a target block is
`read in an input process is which an index block having
`a pointer is written into the main memory and the target
`block is read based on an address pointed by the pointer,
`the content of the index block written into the main
`memory is compared with the content of the index
`block stored in the cache memory to determine whether
`the index block has been updated by another computer
`system during a time period from the reading of the
`index block to the reading of the target block. Namely,
`it is determined whether the address of the target block
`may be determined at the time of reading of the target
`block based on the content of the index block at the time
`of writing into the main memory. Thus, when the target
`block is read, the content of the index block stored in
`the main memory is compared with the content of the
`index block stored in the cache memory, and if the
`comparison matches, the target block is read, and if the
`comparison mismatches, the index block is read. In this
`manner, the process from the reading of the index block
`having the pointer to the reading of the target block at
`the address pointed by the pointer is correctly carried
`out without exclusive control.
`Further, by comparing the update indicator of the
`block which is in the cache memory when the block is
`read with the update indicator of the block which was
`in the main memory when the block was written into
`the main memory, it is possible to determine whether
`the content of the block stored in the main memory can
`be used as it is or not. If the comparison matches, the
`input/output operation to the ?le which is accompanied
`by the physical movement is not carried out but the
`content of the block stored in the main memory is used
`as it is. If the comparison mismatches, the block is read
`from the ?le. In this manner, the input/output operation
`to the ?le which is accompanied by the physical move
`ment can be reduced. A high advantage is expected
`particularly when the present technique is applied to the
`index having a high access frequency and a small stor
`age capacity.
`
`20
`
`25
`
`DESCRIPTION OF THE PREFERRED
`EMBODIMENTS
`Embodiments of the present invention will now be
`explained with reference to the accompanying draw
`mgs.
`FIG. 1 shows a system con?guration of one embodi
`ment of the present invention, in which two computer
`systems 101 and 101' share a common ?le 108. In the
`following description, the ?le 108 is a disk ?le. The disk
`?le 108 includes a plurality of disk media 109 and a
`cache memory 110. A block data in a block 111 stored
`on the disk medium 109 contains a data ?eld stored in an
`predetermined update area 112 to represent an update
`status. The update status of the block can be detected by
`checking the update area 112. The computer system 101
`includes a central processing unit 102, a channel 103 and
`a main memory 104. The central processing unit 102
`starts an input/output operation and carries out arith
`metic and logical operations, and the channel 103 con
`trols the input/output to the disk ?le 108 to transfer data
`with the main memory 104. The main memory 104 has
`an input/output buffer 105 for the block 111 on the disk
`medium 109 of the disk ?le 108, a save area 106 for
`saving the update area 112 of the block 111, and a resi
`dent area 107 for reducing the input/output operation
`to the disk ?le 108. The cache memory 110 in the disk
`?le 108 may store the entire block inputted or outputted
`by a command from the channel 103 or only the content
`of the update area which is a portion of the block. In the
`present embodiment, only the latter is stored at an up
`date status indicator 113 in the cache memory 110.
`FIG. 2 shows a relationship of the processing units of
`the present invention. In FIG. 2, numerals 201 and 201’
`denote data accessing units in the central processing
`units 102 and 102' of the computer systems 101 and 101'
`for executing I/O operations, and numeral 202 denotes
`a channel program unit for executing a channel pro
`gram for the disk ?le in the input/output channel 103 or
`the disk ?le 108.
`First, referring to FIGS. 3 to 5, the operation of the
`data accessing units 201 and 201' and the channel pro
`gram unit 202 in the update process is explained. FIG. 3
`shows a ?ow chart of the data accessing unit (201 in the
`present example) in the update process, FIG. 4 shows a
`?ow chart of the channel program unit 202 for block
`reading, and FIG. 5 shows a ?ow chart of the channel
`program unit 202 for block updating.
`The data accessing unit 201 ?rst issues a channel
`program of a process shown in FIG. 4 to the channel
`program unit 202 in order to read, prior to the updating,
`the block 111 to be updated which is stored on the disk
`medium 109 of the disk ?le 108 into the input/output
`buffer 105 of the main memory 104 (step 301). In accor
`dance with the process shown in FIG. 4, the channel
`program unit 202 locates the block 111 on the disk me
`dium 109 (step 401), writes the block 111 into the input
`/output buffer 105 in the main memory 104, and stores
`a portion of the block 111 or the content of the update
`
`40
`
`45
`
`55
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`FIG. 1 shows as system con?guration of one embodi
`ment of the present invention,
`FIG. 2 shows a relational con?guration of processing
`units of the present invention,
`FIG. 3 shows a process of a data accessing unit which
`eliminates exclusive control in an update process,
`FIG. 4 shows a process of a channel program unit for
`block reading used in FIG. 3,
`FIG. 5 shows a process of the channel program unit
`for block updating used in FIG. 3,
`FIG. 6 shows a process of a data accessing unit which
`eliminates exclusive control in an input process for a ?le
`having an index,
`FIG. 7 shows a conceptual view of a pointer relation
`ship among a plurality of blocks in a ?le,
`FIG. 8 shows a process of the channel program unit
`for index block reading used in FIG. 6,
`
`Petitioner Microsoft Corporation - Ex. 1062, p. 11
`
`

`
`5
`
`40
`
`20
`
`5,293,618
`5
`6
`of a target block at the address pointed by the pointer,
`area 112 into the update status indicator 113 of the
`cache memory 110 (step 402).
`and FIG. 7 shows a pointer relationship between a
`block 664 in the ?le and an index block 662 having a
`The update area may store count data or time which
`pointer which indicates the location of the block. FIG.
`may be used as an index of history of the updating of the
`block which is frequently updated. Alternatively, the
`8 shows a flow chart of the channel program unit 202
`for reading the index block, and FIG. 9 shows a ?ow
`entire content of the block 111 may be stored in the area
`112. (This will be described later with reference to
`chart of the channel program unit 202 for reading the
`FIGS. 6 and 8).
`target block pointed by the index block.
`The data accessing unit 201 than saves the content of
`The disk medium 109 shown in FIG. 7 has a ?rst
`the data stored in the input/output buffer 105 into the
`group of blocks 662 and a second group of blocks 664.
`save area 106 (step 302). Then, the data accessing unit
`The former contains an index to indicate the location of
`201 updates the content of the block under consider
`the latter on the disk medium.
`ation in the input/output buffer 105 (step 303) and
`The data accessing unit 201 ?rst issues a channel
`writes it into the disk ?le 108 by issuing a channel pro
`program of the process shown in FIG. 8 to the channel
`gram of a process shown in FIG. 5 to the channel pro
`program unit 202 in order to write the index block
`gram unit 202 (step 304). In accordance with the pro
`stored on the disk medium 109 of the disk ?le 108 into
`the input/output buffer 105 of the main memory 104
`cess shown in FIG. 5, the channel program unit ?rst
`reads the content stored in the cache memory 110, that
`(step 601). The process of the channel program of FIG.
`is, the content of the block to be updated which has
`8 differs from that of FIG. 4 only in that the entire block
`been in the update status indicator 113 (step 501). Then,
`instead of a portion of the block as in FIG. 4 is stored
`into the cache memory 110. The channel'program of
`it compares the content of the update area 112 at the
`time of the reading which has been saved in the save
`FIG. 4 may also be used in the present embodiment by
`using the pointer ?eld in the index block of FIG. 4 as the
`area 106 of the main memory with the content of the
`update status indicator 113 in the cache memory 110 to
`update status indicator. In response to the issuance of
`determine whether the update status indicator 113 of
`the channel program of FIG. 8, the channel program
`the cache memory 110 of the disk ?le has been updated
`unit 202 positions a read head to the block 111 to be read
`by the other computer system 101’ after the reading of
`on the disk medium 109 (step 701) and reads the block
`the block or not (step 502). Since the decision is made
`into the input/output buffer 105 in the main memory
`by comparing the data in the cache memory 110 with
`104 and also stores the content of the block 111 into the
`cache memory 110 (step 702).
`out reading the block from the disk medium 109, no
`rotation waiting time of the disk medium 109 due to the
`Then, the data accessing unit 201 determines the
`read operation nor the physical movement due to the
`address of the target block based on the pointer in the
`fetched index block (step 602), and issues the channel
`movement of the access arm of the disk ?le 108 is in
`volved, and the process time is minimized. In the step
`program of FIG. 9 to the channel program unit 202 to
`502, if there has been no updating by the other com
`read the target block (step 603). In accordance with the
`puter system 101' the decision is YES and the updated
`process of FIG. 9, the channel program unit 202 com
`data is overwritten on the update status indicator 113 of
`pares the content of the index block fetched into the
`the block in the cache memory 110 and it is written into
`input/output buffer 105 of the main memory 104 with
`the disk medium 109 (step 503) to complete the desired
`the content of the index block stored in the cache mem
`updating. In the step 502, if the decision is NO, it means
`ory 110 (step 801) to determine whether the index block
`that there has been updating of the disk data by the
`has been updated by the other computer system 101’
`other computer system 101’ the channel program unit
`during a time period from the reading of the index block
`202 writes the block into the main memory 104 to up
`to the reading of the target block (step 802). If the com~
`date the data which has been updated by the other
`parison matches (YES in the step 802), it means that
`computer system (step 504).
`there has been no updating of the index block by the
`On the other hand, the data accessing unit 201 exam
`other computer system 101' and the pointer of the index
`ines the result of execution of the channel program of
`block stored in the input/ output buffer 105 may be used.
`Thus, the target block designated by the pointer is read
`FIG. 5 by the channel program unit 202, and if the
`decision in the step 502 is YES, it means that the block
`(step 803). If the content of the index block has not been
`has been read for updating, and the process is termi
`modi?ed, it is necessary for the processing unit which
`updates the index block and the target block pointed by
`nated. If the decision is NO, it means that the updating
`has been made by the other computer system 101’, and
`the pointer of the index block to follow the process
`sequence of ?rst updating the index block and then
`the process returns to the step 302 to process block
`which has been updated by the other computer system
`updating the target block, or carry out the exclusive
`101' (step 305).
`control during a time period from the updating of the
`In this manner, by the processes of the data accessing
`target block to the updating of the index block to pre
`vent the input/output operation during the period from
`unit and the channel program unit shown in FIGS. 3 to
`5, the duplicate updating due to the duplication of the
`the updating of the target block to the updating of the
`updating by a plurality of computer systems can be
`index block in order to assure that the content of the
`prevented without the exclusive control.
`target block pointed by the pointer of the index block
`Referring now to FIGS. 6 to 9, the operation of the
`matches the content of the index block. If the decision
`data accessing unit 201 and the channel program unit
`in the step 802 is NO, it means that there has been updat
`202 when the input process for a block is carried out by
`ing of the index block by the other computer system
`tracking a pointer between blocks for a ?le having a
`101' and the index block is written again into the input
`structure which has a pointer relationship among blocks
`/output buffer 105 to recycle the process (step 804).
`65
`as represented by an index. FIG. 6 shows a flow chart of
`Like the step 502 of FIG. 5, the decision of the step 802
`the data accessing unit 201 from the reading of an index
`can be processed in a minimum process time without
`block having a pointer from the disk ?le to the reading
`rotation waiting time of the disk medium.
`
`50
`
`55
`
`Petitioner Microsoft Corporation - Ex. 1062, p. 12
`
`

`
`5
`
`3O
`
`5,293,618
`7
`8
`On the other hand, the data accessing unit 201 exam
`Further, like in the step 502 of FIG. 5, the comparison
`ines the result of execution of the channel program of
`in the cache memory 110 is done in a minimum process
`FIG. 9, and if the decision in the step 802 is YES, it
`time without the rotation waiting time of the disk me
`means that the target block has been written, and the
`dium 109.
`process is terminated. If the decision is NO, it means
`We claim:
`that there has been updating by the other computer
`1. An information processing system comprising:
`system 101’ and the process returns to the step 602 to
`a plurality of computer systems each including a
`recycle the process (step 604).
`central processing unit, a channel connected to the
`By the processes of the data accessing unit and the
`central processing unit, and a main memory con
`channel program unit shown in FIGS. 6 to 9, the exclu
`nected to the central processing unit; and
`sive control in the input process of the ?le can be elimi
`a shared storage device connected to the channel of
`nated where the ?le having the structure which has the
`each of the computer systems for storing a plurality
`pointer relationship among blocks is shared by a plural
`of data blocks each including an update area indi
`ity of computer systems with the updating.
`cating an update status of the associated data block;
`Referring now to FIGS. 10 and 11, the enhancement
`wherein the shared storage device includes a cache
`of performance of data accessing by the resident area
`memory connected to the channel of each of the
`107 of the block on the main memory 104 for each of the
`computer systems; and
`computer systems 101 and 101’ is explained. FIG. 10
`wherein the central processing unit and the channel
`shows a flow chart of the data accessing unit 201 for
`of each of the computer systems include means for
`reducing the input/output operation to the disk medium
`reading a data block to be updated from the shared
`109 to enhance the speed of data accessing by providing
`storage device,
`the resident area 107 in the main memory 104, and FIG.
`storing the data block to be updated in the main mem
`11 shows a flow chart of the channel program unit 202
`ory of the associated computer system,
`for reading the block.
`storing at least the update area of the data block to be
`The data accessing unit 201 ?rst issues the channel
`updated in the cache memory as an update status
`program of FIG. 11 to the channel program unit 202
`indicator,
`(step 901) to determine whether the content of the block
`updating the data block to be updated in the main
`in the resident area 107 of the main memory 104 is the
`memory,
`latest one or not, that is, whether the content of the
`reading the update status indicator from the cache
`block in the resident area 107 may be used as it is or not.
`memory,
`The channel program unit 202 reads the update status
`determining whether the update status indicator read
`indicator 113 in the cache memory 110 corresponding
`from the cache memory and a corresponding por
`to the block be read (step 1001) to and determines if the
`tion of the updated data block in the main memory
`content of the update area in the block in the resident
`are equal,
`area 107 is equal to the content of the update status
`if the update status indicator and the corresponding
`indicator 113 in the cache memory 110 (step 1002). If
`portion of the updated data block are equal, updat
`they are equal, it means that the content of the block in
`ing the update status indicator in the cache mem
`the resident area 107 may be used as it is (YES in the
`ory, reading the updated data block from the main
`step 1002), and the process is terminated. If they are not
`memory, and storing the updated data block in the
`equal or the content corresponding to the block has not
`shared storage device in place of the data block to
`yet been stored in the update area 113 of the cache
`be updated, and
`memory 110 (NO in the step 1002), the block is read
`if the update status indicator and the corresponding
`from the disk medium 109 (step 1003). If the content
`portion of the updated data block are not equal,
`corresponding to the block has not been stored in the
`reading the data block to be updated from the
`update status indicator 113 of the cache memory 110,
`shared storage device, storing the data block to be
`the update status indicator is newly stored into the
`updated in the main memory, and repeating the
`cache memory 110.
`preceding functions beginning with updating the
`On the other hand, the data a