COMPILATION LISTING OF SEGMENT lm_check_for_deadlock_ Compiled by: Multics PL/I Compiler, Release 28e, of February 14, 1985 Compiled at: Honeywell Multics Op. - System M Compiled on: 03/05/85 0907.9 mst Tue Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 4* * * 5* *********************************************************** */ 6 7 /* DESCRIPTION: 8* Lock Manager Deadlock Detection 9* 10* Determines whether a deadlock (lock-wait cycle) exists involving this 11* transaction and returns this determination via the error code. 12* 13* Lock_Deadlock_ptr -> a bit array of dimension (p_n_lock_deadlock, p_n_lock_deadlock). 14* (x,y) is ON <=> transaction x is waiting for a lock held by transaction y. 15* transaction 1 must be this transaction. As an optimization, it is only 16* necessary to consider transactions which are waiting for locks and 17* the current transaction (since a transaction which is not waiting cannot 18* be involved in a deadlock). 19* 20* No lock need be held by this transaction, since a deadlock is stable. 21* 22* This program implements the Transitive Closure algorithm of 23* Reingold, Nievergelt and Deo, Combinatorial Algorithms, 24* page 341-341, to find an adjacency matrix. If 25* any diagonal bit is on, there is a cycle. If (1, 1) is on 26* the calling txn is in the cycle. All those txns t 27* whose diagonals are on and for which (1, t) is on 28* are part of this deadlock, so we can determine 29* the youngest one (by bit order of TXN id). Only 30* the youngest will roll back. 31**/ 32 /* HISTORY: 33* 34*Written by J. Bongiovanni, January 1983. 35*Modified: 36*04/28/83 by Benson I. Margulies: Reimplemented to use sneaky ADJ algorithm 37* and optimize the small cases. 38*05/01/84 by R. Michael Tague: Added the History section. Added 39* %include dm_lm_meters. 40*10/16/84 by Stanford S. Cox: For DMS program standards. 41**/ 42 43 /* format: style2,^inddcls,ifthenstmt,ifthendo,^indnoniterdo,^inditerdo,ind3,idind32 */ 44 lm_check_for_deadlock_: 45 procedure (p_lock_deadlock_ptr, p_lock_deadlock_txn_ids_ptr, p_n_lock_deadlock, p_notify_txn, p_code); 46 47 /* Parameter */ 48 49 dcl p_code fixed bin (35); /* Standard error code */ 50 dcl p_lock_deadlock_ptr ptr parameter; /* -> lock_deadlock array */ 51 dcl p_lock_deadlock_txn_ids_ptr ptr parameter; 52 dcl p_n_lock_deadlock fixed bin parameter;/* Number of transactions in array */ 53 dcl p_notify_txn bit (36) aligned; 54 55 /* Automatic */ 56 57 dcl (l, txn_idx) fixed bin; /* array indices */ 58 dcl youngest bit (36) aligned; 59 60 /* External */ 61 62 dcl dm_system_data_$max_n_transactions 63 fixed bin ext; 64 dcl dm_error_$lock_deadlock fixed bin (35) external; 65 66 67 68 69 p_code = 0; 70 lock_deadlock_ptr = p_lock_deadlock_ptr; 71 lock_deadlock_txn_ids_ptr = p_lock_deadlock_txn_ids_ptr; 72 n_lock_deadlock = p_n_lock_deadlock; 73 p_notify_txn = ""b; 74 75 76 /***** First, convert the digraph matrix to an adjancy matrix. */ 77 /***** The three different procedures are to allow the compiler to avoid */ 78 /***** EIS when possible, since the speed difference is large. */ 79 80 if n_lock_deadlock = 36 /* These procedure take advantage of */ then call CLOSURE_SINGLE_WORD (lock_deadlock_ptr); 81 /* the non-eis bit manipulation */ 82 else if n_lock_deadlock = 72 /* instructions */ then call CLOSURE_DOUBLE_WORD (lock_deadlock_ptr); 83 else call CLOSURE_MULTI_WORD (lock_deadlock_ptr); 84 85 /***** Now, wait_own is really ADJ (wait_own*). If (1, 1) is on, */ 86 /***** then there is a deadlock involving us. */ 87 88 if ^lock_deadlock.wait_own (1, 1) then return; 89 90 /***** Now, the diagonal entries are TXN's that are involved in some deadlock */ 91 /***** wait_own (1, txn_idx) --> that txn txn_idx is in our deadlock. */ 92 /***** this could also be benefited by the 36/72 trick, but is not really */ 93 /***** worth it. */ 94 95 youngest = (36)"0"b; 96 97 do txn_idx = 2 to n_lock_deadlock; 98 if lock_deadlock.wait_own (txn_idx, txn_idx) 99 then if lock_deadlock.wait_own (1, txn_idx) 100 then if lock_deadlock_txn_ids (txn_idx) > youngest then youngest = lock_deadlock_txn_ids (txn_idx); 101 end; 102 103 if lock_deadlock_txn_ids (1) > youngest /* we are junior */ then do; 104 p_code = dm_error_$lock_deadlock; 105 return; 106 end; 107 108 p_notify_txn = youngest; 109 110 return; 111 112 113 CLOSURE_MULTI_WORD: 114 procedure (cm_p_lock_deadlock_ptr); 115 116 dcl cm_p_lock_deadlock_ptr ptr; 117 dcl 1 cm_lock_deadlock like lock_deadlock aligned based (cm_p_lock_deadlock_ptr); 118 dcl cm_owner_txn_idx fixed bin; 119 dcl cm_waiter_txn_idx fixed bin; 120 121 do cm_owner_txn_idx = 1 to hbound (cm_lock_deadlock.wait_own, 1); 122 do cm_waiter_txn_idx = 1 to hbound (cm_lock_deadlock.wait_own, 1); 123 if cm_lock_deadlock.wait_own (cm_waiter_txn_idx, cm_owner_txn_idx) 124 then cm_lock_deadlock.wait_own (cm_waiter_txn_idx, *) = 125 cm_lock_deadlock.wait_own (cm_waiter_txn_idx, *) | cm_lock_deadlock.wait_own (cm_owner_txn_idx, *); 126 end; 127 end; 128 end CLOSURE_MULTI_WORD; 129 130 CLOSURE_SINGLE_WORD: 131 procedure (cs_p_lock_deadlock_ptr); 132 133 dcl cs_p_lock_deadlock_ptr ptr; 134 declare rows (36) bit (36) aligned based (cs_p_lock_deadlock_ptr); 135 /* force compiler for efficiency */ 136 dcl cs_owner_txn_idx fixed bin; 137 dcl cs_waiter_txn_idx fixed bin; 138 139 do cs_owner_txn_idx = 1 to n_lock_deadlock; 140 do cs_waiter_txn_idx = 1 to n_lock_deadlock; 141 if substr (rows (cs_waiter_txn_idx), cs_owner_txn_idx, 1) 142 then rows (cs_waiter_txn_idx) = rows (cs_waiter_txn_idx) | rows (cs_owner_txn_idx); 143 end; 144 end; 145 146 end CLOSURE_SINGLE_WORD; 147 148 CLOSURE_DOUBLE_WORD: 149 procedure (cd_p_lock_deadlock_ptr); 150 151 dcl cd_p_lock_deadlock_ptr ptr; 152 declare rows (72) bit (72) aligned based (cd_p_lock_deadlock_ptr); 153 /* force compiler for efficiency */ 154 dcl cd_owner_txn_idx fixed bin; 155 dcl cd_waiter_txn_idx fixed bin; 156 157 do cd_owner_txn_idx = 1 to n_lock_deadlock; 158 do cd_waiter_txn_idx = 1 to n_lock_deadlock; 159 if substr (rows (cd_waiter_txn_idx), cd_owner_txn_idx, 1) 160 then rows (cd_waiter_txn_idx) = rows (cd_waiter_txn_idx) | rows (cd_owner_txn_idx); 161 end; 162 end; 163 end CLOSURE_DOUBLE_WORD; 164 165 1 1 /* BEGIN INCLUDE FILE - dm_lm_system_data.incl.pl1 */ 1 2 1 3 /* format: style3,idind25 */ 1 4 /* HISTORY: 1 5* 1 6*Written by Benson Margulies, 4/83. 1 7*Modified: 1 8*04/24/84 by R. Michael Tague: moved the meters structure definition to 1 9* dm_lm_meters.incl.pl1. Added this history section. 1 10*05/01/84 by R. Michael Tague: removed the %include dm_lm_meters. 1 11*10/17/84 by Stanford S. Cox: Added version constant, and changed 1 12* transaction_table to use a refer extent (to allow outer ring reference). 1 13**/ 1 14 1 15 dcl lock_seg_ptr ptr; 1 16 dcl lock_transaction_table_ptr 1 17 ptr; 1 18 dcl lock_hash_table_ptr ptr; 1 19 dcl lock_aux_seg_ptr ptr; 1 20 dcl lock_block_ptr ptr; 1 21 dcl lock_block_array_ptr ptr; 1 22 dcl lock_free_block_ptr ptr; 1 23 dcl lock_object_ptr ptr; 1 24 dcl lock_owner_ptr ptr; 1 25 dcl lock_segments_ptr ptr; 1 26 dcl lock_waiter_ptr ptr; 1 27 dcl lock_deadlock_ptr ptr; 1 28 1 29 dcl n_lock_blocks fixed bin; 1 30 dcl n_lock_deadlock fixed bin; 1 31 1 32 dcl LOCK_SEG_VERSION_1 char (8) aligned init ("locksg 1") int static options (constant); 1 33 1 34 dcl 1 lock_seg aligned based (lock_seg_ptr), 1 35 /* Per-system lock data */ 1 36 2 version char (8) aligned, 1 37 2 header aligned, 1 38 3 lock fixed bin (71), /* Fast Lock on system lock operations */ 1 39 3 n_lock_segments fixed bin, /* Number of segments in system lock data */ 1 40 3 lock_seg_size fixed bin (19), /* Number of words per segment */ 1 41 3 max_lock_segments fixed bin, /* Maximum number of segments */ 1 42 3 n_transaction_table_entries 1 43 fixed bin, /* Size of transaction table */ 1 44 3 n_hash_table_entries 1 45 fixed bin, /* Size of hash table */ 1 46 3 hash_mask bit (36) aligned, /* Used by hashing routine */ 1 47 3 free_list_ptr aligned like lock_virtual_ptr, 1 48 /* Thread of free blocks */ 1 49 3 transaction_table_offset 1 50 fixed bin (18) unsigned aligned, 1 51 /* Offset of transaction table */ 1 52 3 hash_table_offset fixed bin (18) unsigned aligned, 1 53 /* Offset of hash table */ 1 54 3 n_lock_blocks fixed bin, /* Number of blocks crated */ 1 55 3 lock_array_offset fixed bin (18) unsigned aligned, 1 56 /* Offset of block array */ 1 57 2 transaction_table (0 refer (lock_seg.n_transaction_table_entries)) aligned like lock_transaction_table, 1 58 2 hash_table aligned like lock_hash_table, 1 59 2 meters aligned like lock_meters, 1 60 2 free fixed bin (71); /* Free space */ 1 61 1 62 dcl 1 lock_aux_seg aligned based (lock_aux_seg_ptr), 1 63 /* Other than first segment */ 1 64 2 n_lock_blocks fixed bin, /* Number of blocks in this segment */ 1 65 2 lock_array_offset fixed bin (18) unsigned aligned, 1 66 /* Offset of block array */ 1 67 2 free fixed bin (71); /* Free space */ 1 68 1 69 dcl 1 lock_transaction_table aligned based (lock_transaction_table_ptr), 1 70 /* Process table entry */ 1 71 2 deadlock_inx fixed bin, /* Index used for deadlock detection */ 1 72 2 process_id bit (36) aligned, /* Multics process identifier */ 1 73 2 txn_id bit (36) aligned, /* Current transaction ID */ 1 74 2 ev_channel fixed bin (71), 1 75 2 own_ptr aligned like lock_virtual_ptr, 1 76 /* First in thread of owning blocks */ 1 77 2 wait_ptr aligned like lock_virtual_ptr; 1 78 /* Waiting block */ 1 79 1 80 dcl 1 lock_hash_table aligned based (lock_hash_table_ptr), 1 81 2 buckets (lock_seg.n_hash_table_entries) aligned like lock_virtual_ptr; 1 82 1 83 1 84 dcl 1 lock_block aligned based (lock_block_ptr), 1 85 /* Generic block */ 1 86 2 seg_inx fixed bin unal, 1 87 2 type fixed bin unal, 1 88 2 pad (5) bit (36) aligned; 1 89 1 90 dcl 1 lock_block_array (n_lock_blocks) aligned like lock_block based (lock_block_array_ptr); 1 91 1 92 dcl 1 lock_free_block aligned based (lock_free_block_ptr), 1 93 /* Free block */ 1 94 2 seg_inx fixed bin unal, 1 95 2 type fixed bin unal, /* TYPE_FREE */ 1 96 2 free_fp aligned like lock_virtual_ptr, 1 97 /* Thread of free blocks */ 1 98 2 pad (4) bit (36) aligned; 1 99 1 100 dcl 1 lock_object aligned based (lock_object_ptr), 1 101 /* That which is locked */ 1 102 2 seg_inx fixed bin unal, 1 103 2 type fixed bin unal, /* TYPE_OBJECT */ 1 104 2 uid bit (36) aligned, /* Page File UID */ 1 105 2 ci_no fixed bin (35), /* Control Interval (-1 => Page File) */ 1 106 2 owners_ptr aligned like lock_virtual_ptr, 1 107 /* First in thread of owning blocks */ 1 108 2 waiters_ptr aligned like lock_virtual_ptr, 1 109 /* First in thread of waiting blocks */ 1 110 2 ht_fp aligned like lock_virtual_ptr; 1 111 /* Hash Table thread */ 1 112 1 113 dcl 1 lock_owner aligned based (lock_owner_ptr), 1 114 /* Owner of a lock */ 1 115 2 seg_inx fixed bin unal, 1 116 2 type fixed bin unal, /* TYPE_OWNER */ 1 117 2 lock_ptr aligned like lock_virtual_ptr, 1 118 /* Pointer to lock_object */ 1 119 2 mode fixed bin, /* Type of lock */ 1 120 2 owners_fp aligned like lock_virtual_ptr, 1 121 /* Thread of owners */ 1 122 2 transaction_fp aligned like lock_virtual_ptr, 1 123 /* Thread of locks owned by this transaction */ 1 124 2 transaction_ptr aligned like lock_virtual_ptr; 1 125 /* Pointer to transaction table entry */ 1 126 1 127 1 128 dcl 1 lock_waiter aligned based (lock_waiter_ptr), 1 129 /* Waiter for a lock */ 1 130 2 seg_inx fixed bin unal, 1 131 2 type fixed bin unal, /* TYPE_WAITER */ 1 132 2 lock_ptr aligned like lock_virtual_ptr, 1 133 /* Pointer to lock_object */ 1 134 2 mode fixed bin, /* Desired mode */ 1 135 2 waiters_fp aligned like lock_virtual_ptr, 1 136 /* Thread of waiters */ 1 137 2 transaction_ptr aligned like lock_virtual_ptr, 1 138 /* Process table entry of this proces */ 1 139 2 pad bit (36) aligned; 1 140 1 141 1 142 dcl 1 lock_segments aligned based (lock_segments_ptr), 1 143 2 seg_baseptr (lock_seg.n_lock_segments) ptr unal; 1 144 1 145 dcl 1 lock_virtual_ptr aligned based, 1 146 2 seg_inx fixed bin unal, 1 147 2 offset fixed bin (18) unsigned unal; 1 148 1 149 dcl 1 lock_deadlock aligned based (lock_deadlock_ptr), 1 150 2 wait_own (n_lock_deadlock, n_lock_deadlock) bit (1) unaligned; 1 151 1 152 declare 1 lock_deadlock_36 aligned based (lock_deadlock_ptr), 1 153 2 wait_own (36, 36) bit (1) unaligned; 1 154 1 155 declare 1 lock_deadlock_72 aligned based (lock_deadlock_ptr), 1 156 2 wait_own (72, 72) bit (1) unaligned; 1 157 /* (x,y) ON => x waiting for lock owned by y */ 1 158 1 159 declare lock_deadlock_txn_ids_ptr 1 160 pointer; 1 161 declare lock_deadlock_txn_ids (n_lock_deadlock) bit (36) aligned based (lock_deadlock_txn_ids_ptr); 1 162 dcl ( 1 163 TYPE_FREE init (1), 1 164 TYPE_OBJECT init (2), 1 165 TYPE_OWNER init (3), 1 166 TYPE_WAITER init (4), 1 167 MAX_TYPE init (4) 1 168 ) fixed bin int static options (constant); 1 169 1 170 1 171 dcl 1 NULL_VPTR aligned int static options (constant), 1 172 2 seg_inx fixed bin unal init (-1), 1 173 2 offset fixed bin (18) unsigned unal init (0); 1 174 1 175 1 176 dcl LOCK_BLOCK_SIZE fixed bin int static options (constant) init (6); 1 177 /* Size of all lock blocks */ 1 178 1 179 dcl LOCK_SEGNAME char (9) int static options (constant) init ("lock_seg_"); 1 180 1 181 dcl lock_segno pic "999"; 1 182 1 183 dcl ( 1 184 LOCK_MESSAGE_DEADLOCK init (1243657) 1 185 ) fixed bin (71) int static options (constant); 1 186 1 187 1 188 /* END INCLUDE FILE - dm_lm_system_data.incl.pl1 */ 166 2 1 /* BEGIN INCLUDE FILE - dm_lm_meters.incl.pl1 * 2 2* 2 3*/* format: style3,idind25 */ 2 4 2 5 /* DESCRIPTION: 2 6* 2 7* This is the lock manager meters structure. 2 8**/ 2 9 /* HISTORY: 2 10*Written by R. Michael Tague, 4/24/84. 2 11*Modified: 2 12*05/01/84 by R. Michael Tague: Collected all of the meters together into 2 13* the meters structure. 2 14**/ 2 15 2 16 dcl lock_meters_ptr ptr; 2 17 dcl LOCK_METERS_VERSION_1 char (8) aligned int static options (constant) 2 18 init ("LMMETER1"); 2 19 2 20 dcl 1 lock_meters aligned based (lock_meters_ptr), 2 21 2 version char (8), 2 22 2 lm_meters aligned, 2 23 3 lock_calls fixed bin (35), 2 24 3 unlock_all_calls fixed bin (35), 2 25 3 waits fixed bin (35), 2 26 3 deadlock_checks fixed bin (35), 2 27 3 real_deadlock_checks 2 28 fixed bin (35), 2 29 3 deadlock_checks_36 fixed bin (35), 2 30 3 deadlock_checks_72 fixed bin (35), 2 31 3 deadlock_self_youngest 2 32 fixed bin (35), 2 33 3 deadlock_other_youngest 2 34 fixed bin (35), 2 35 3 file_locks_by_mode (2:6) fixed bin (35), 2 36 3 ci_locks_by_mode (2:3) fixed bin (35), 2 37 3 allocates fixed bin (35), 2 38 3 frees fixed bin (35), 2 39 3 dup_file_locks_by_mode 2 40 (2:6) fixed bin (35), 2 41 3 dup_ci_locks_by_mode 2 42 (2:3) fixed bin (35), 2 43 3 pad (11) fixed bin (35); 2 44 2 45 /* END INCLUDE FILE - dm_lm_meters.incl.pl1 */ 167 168 169 end lm_check_for_deadlock_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 03/05/85 0759.5 lm_check_for_deadlock_.pl1 >spec>on>7138.pbf>lm_check_for_deadlock_.pl1 166 1 01/07/85 0859.2 dm_lm_system_data.incl.pl1 >ldd>include>dm_lm_system_data.incl.pl1 167 2 01/07/85 0859.1 dm_lm_meters.incl.pl1 >ldd>include>dm_lm_meters.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. cd_owner_txn_idx 000146 automatic fixed bin(17,0) dcl 154 set ref 157* 159 159* cd_p_lock_deadlock_ptr parameter pointer dcl 151 ref 148 159 159 159 159 cd_waiter_txn_idx 000147 automatic fixed bin(17,0) dcl 155 set ref 158* 159 159 159* cm_lock_deadlock based structure level 1 dcl 117 cm_owner_txn_idx 000120 automatic fixed bin(17,0) dcl 118 set ref 121* 123 123* cm_p_lock_deadlock_ptr parameter pointer dcl 116 ref 113 121 122 123 123 123 123 cm_waiter_txn_idx 000121 automatic fixed bin(17,0) dcl 119 set ref 122* 123 123 123* cs_owner_txn_idx 000134 automatic fixed bin(17,0) dcl 136 set ref 139* 141 141* cs_p_lock_deadlock_ptr parameter pointer dcl 133 ref 130 141 141 141 141 cs_waiter_txn_idx 000135 automatic fixed bin(17,0) dcl 137 set ref 140* 141 141 141* dm_error_$lock_deadlock 000010 external static fixed bin(35,0) dcl 64 ref 104 lock_block based structure level 1 dcl 1-84 lock_deadlock based structure level 1 dcl 1-149 lock_deadlock_ptr 000102 automatic pointer dcl 1-27 set ref 70* 80* 82* 83* 88 98 98 lock_deadlock_txn_ids based bit(36) array dcl 1-161 ref 98 98 103 lock_deadlock_txn_ids_ptr 000106 automatic pointer dcl 1-159 set ref 71* 98 98 103 lock_hash_table based structure level 1 dcl 1-80 lock_meters based structure level 1 dcl 2-20 lock_transaction_table based structure level 1 dcl 1-69 lock_virtual_ptr based structure level 1 dcl 1-145 n_lock_deadlock 000104 automatic fixed bin(17,0) dcl 1-30 set ref 72* 80 82 88 88 97 98 98 98 98 121 122 123 123 123 123 123 123 123 123 123 123 123 139 140 157 158 p_code parameter fixed bin(35,0) dcl 49 set ref 44 69* 104* p_lock_deadlock_ptr parameter pointer dcl 50 ref 44 70 p_lock_deadlock_txn_ids_ptr parameter pointer dcl 51 ref 44 71 p_n_lock_deadlock parameter fixed bin(17,0) dcl 52 ref 44 72 p_notify_txn parameter bit(36) dcl 53 set ref 44 73* 108* rows based bit(36) array dcl 134 in procedure "CLOSURE_SINGLE_WORD" set ref 141 141* 141 141 rows based bit(72) array dcl 152 in procedure "CLOSURE_DOUBLE_WORD" set ref 159 159* 159 159 txn_idx 000100 automatic fixed bin(17,0) dcl 57 set ref 97* 98 98 98 98 98* wait_own based bit(1) array level 2 in structure "lock_deadlock" packed unaligned dcl 1-149 in procedure "lm_check_for_deadlock_" ref 88 98 98 wait_own based bit(1) array level 2 in structure "cm_lock_deadlock" packed unaligned dcl 117 in procedure "CLOSURE_MULTI_WORD" set ref 121 122 123 123* 123 123 youngest 000101 automatic bit(36) dcl 58 set ref 95* 98 98* 103 108 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. LOCK_BLOCK_SIZE internal static fixed bin(17,0) initial dcl 1-176 LOCK_MESSAGE_DEADLOCK internal static fixed bin(71,0) initial dcl 1-183 LOCK_METERS_VERSION_1 internal static char(8) initial dcl 2-17 LOCK_SEGNAME internal static char(9) initial unaligned dcl 1-179 LOCK_SEG_VERSION_1 internal static char(8) initial dcl 1-32 MAX_TYPE internal static fixed bin(17,0) initial dcl 1-162 NULL_VPTR internal static structure level 1 dcl 1-171 TYPE_FREE internal static fixed bin(17,0) initial dcl 1-162 TYPE_OBJECT internal static fixed bin(17,0) initial dcl 1-162 TYPE_OWNER internal static fixed bin(17,0) initial dcl 1-162 TYPE_WAITER internal static fixed bin(17,0) initial dcl 1-162 dm_system_data_$max_n_transactions external static fixed bin(17,0) dcl 62 l automatic fixed bin(17,0) dcl 57 lock_aux_seg based structure level 1 dcl 1-62 lock_aux_seg_ptr automatic pointer dcl 1-19 lock_block_array based structure array level 1 dcl 1-90 lock_block_array_ptr automatic pointer dcl 1-21 lock_block_ptr automatic pointer dcl 1-20 lock_deadlock_36 based structure level 1 dcl 1-152 lock_deadlock_72 based structure level 1 dcl 1-155 lock_free_block based structure level 1 dcl 1-92 lock_free_block_ptr automatic pointer dcl 1-22 lock_hash_table_ptr automatic pointer dcl 1-18 lock_meters_ptr automatic pointer dcl 2-16 lock_object based structure level 1 dcl 1-100 lock_object_ptr automatic pointer dcl 1-23 lock_owner based structure level 1 dcl 1-113 lock_owner_ptr automatic pointer dcl 1-24 lock_seg based structure level 1 dcl 1-34 lock_seg_ptr automatic pointer dcl 1-15 lock_segments based structure level 1 dcl 1-142 lock_segments_ptr automatic pointer dcl 1-25 lock_segno automatic picture(3) unaligned dcl 1-181 lock_transaction_table_ptr automatic pointer dcl 1-16 lock_waiter based structure level 1 dcl 1-128 lock_waiter_ptr automatic pointer dcl 1-26 n_lock_blocks automatic fixed bin(17,0) dcl 1-29 NAMES DECLARED BY EXPLICIT CONTEXT. CLOSURE_DOUBLE_WORD 000274 constant entry internal dcl 148 ref 82 CLOSURE_MULTI_WORD 000123 constant entry internal dcl 113 ref 83 CLOSURE_SINGLE_WORD 000224 constant entry internal dcl 130 ref 80 lm_check_for_deadlock_ 000011 constant entry external dcl 44 NAMES DECLARED BY CONTEXT OR IMPLICATION. hbound builtin function ref 121 122 substr builtin function ref 141 159 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 422 434 360 432 Length 636 360 12 165 41 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME lm_check_for_deadlock_ 110 external procedure is an external procedure. CLOSURE_MULTI_WORD internal procedure shares stack frame of external procedure lm_check_for_deadlock_. CLOSURE_SINGLE_WORD internal procedure shares stack frame of external procedure lm_check_for_deadlock_. CLOSURE_DOUBLE_WORD internal procedure shares stack frame of external procedure lm_check_for_deadlock_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME lm_check_for_deadlock_ 000100 txn_idx lm_check_for_deadlock_ 000101 youngest lm_check_for_deadlock_ 000102 lock_deadlock_ptr lm_check_for_deadlock_ 000104 n_lock_deadlock lm_check_for_deadlock_ 000106 lock_deadlock_txn_ids_ptr lm_check_for_deadlock_ 000120 cm_owner_txn_idx CLOSURE_MULTI_WORD 000121 cm_waiter_txn_idx CLOSURE_MULTI_WORD 000134 cs_owner_txn_idx CLOSURE_SINGLE_WORD 000135 cs_waiter_txn_idx CLOSURE_SINGLE_WORD 000146 cd_owner_txn_idx CLOSURE_DOUBLE_WORD 000147 cd_waiter_txn_idx CLOSURE_DOUBLE_WORD THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. return ext_entry NO EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. dm_error_$lock_deadlock LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 44 000004 69 000016 70 000020 71 000023 72 000026 73 000030 80 000031 82 000036 83 000043 88 000045 95 000050 97 000051 98 000061 101 000104 103 000106 104 000112 105 000116 108 000117 110 000122 113 000123 121 000125 122 000135 123 000145 126 000217 127 000221 128 000223 130 000224 139 000226 140 000235 141 000245 143 000267 144 000271 146 000273 148 000274 157 000276 158 000305 159 000315 161 000346 162 000350 163 000352 ----------------------------------------------------------- Historical Background This edition of the Multics software materials and documentation is provided and donated to Massachusetts Institute of Technology by Group BULL including BULL HN Information Systems Inc. as a contribution to computer science knowledge. This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology, Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell BULL Inc., Groupe BULL and BULL HN Information Systems Inc. to the development of this operating system. Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970), renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership of Professor Fernando Jose Corbato. Users consider that Multics provided the best software architecture for managing computer hardware properly and for executing programs. Many subsequent operating systems incorporated Multics principles. Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. . ----------------------------------------------------------- Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without fee is hereby granted,provided that the below copyright notice and historical background appear in all copies and that both the copyright notice and historical background and this permission notice appear in supporting documentation, and that the names of MIT, HIS, BULL or BULL HN not be used in advertising or publicity pertaining to distribution of the programs without specific prior written permission. Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc. Copyright 2006 by BULL HN Information Systems Inc. Copyright 2006 by Bull SAS All Rights Reserved