COMPILATION LISTING OF SEGMENT hash_ Compiled by: Multics PL/I Compiler, Release 28b, of April 11, 1983 Compiled at: Honeywell LCPD Phoenix, System M Compiled on: 09/16/83 1355.3 mst Fri Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 /* format: style4 */ 12 hash_: procedure; 13 14 /* format: style4 */ 15 16 /* originally coded by k.willis 2/71 */ 17 /* modified by T. Casey, Feb 75, to keep table between 70% and 85% full, 18* and to rehash only when adding an entry */ 19 /* Modified for move to hardcore; word entrypoints, no-write entrypoints; 20* Benson I. Margulies 1/82 */ 21 /* Modified by E. N. Kittlitz for no-write no-write, ensure that force_grow really does grow. */ 22 1 1 /* BEGIN INCLUDE FILE ... hashst.incl.pl1 */ 1 2 /* format: style4 */ 1 3 1 4 /* General Utility hash table */ 1 5 1 6 dcl 1 htable based (htp) aligned, /* hash table entries of level 2 are statistical info */ 1 7 2 nb fixed bin, /* number of buckets in hash table */ 1 8 2 ni fixed bin, /* number of entries used */ 1 9 2 np fixed bin, /* number of times hash_ called referincing this table */ 1 10 2 tnt fixed bin, /* total # of tries to find, enter, or delete an entry */ 1 11 2 id char (4), /* ht01 version 1 of hash_ */ 1 12 2 gnt fixed bin, /* greatest number of tries for search etc. */ 1 13 2 loht fixed bin (18) unsigned, /* length of hash table in words */ 1 14 2 pad bit (36) aligned, /* padding */ 1 15 2 buckets (1:hash_table_size_ refer (htable.nb)), /* 26111=((1024*255)/10 words per entry)-1 (8-word header) */ 1 16 3 name char (32) unaligned, /* identifier of entry */ 1 17 3 value bit (36) aligned, /* value corresponding to name */ 1 18 3 flags aligned, 1 19 4 ds bit (1) unal, /* deleted switch="1"b if deleted */ 1 20 4 empty bit (1) unal, 1 21 4 pad bit (34) unal, /* empty switch="1"b if empty */ 1 22 2 end_of_table bit (0) aligned; /* to get address */ 1 23 1 24 declare MAX_HT_BUCKETS_IN_SEG fixed bin init (26111) int static options (constant); 1 25 declare hash_table_size_ fixed bin; 1 26 1 27 /* END INCLUDE FILE ... hashst.incl.pl1 */ 23 24 25 26 27 28 /* this subroutine initializes, inserts, deletes, and searches for entries in a hash table. 29* 30* ***to initialize hash table 31* call hash_$make(htp,n,code); 32* htp is a pointer to the hash table(input) 33* n is the number of buckets wanted(input) 34* code is the error code(output) 35* 36* 37* ***to obtain the optimum size table for a given number of entries 38* n = hash_$opt_size(n_entries); 39* n_entries is the initial number of buckets that will be used(input) 40* n is the optimal table size, to be used in a call to hash_$make(output - function return value) 41* 42* 43* 44* ***to insert an entry in the table 45* call hash_$in(htp,ename,eval,code); 46* htp is a pointer to the hash table(input) 47* ename is the name of the entry(input) 48* eval is the value of the entry(input) 49* code is the error code(output) 50* 51* 52* ***to hash in without growing table 53* ***for use when table cannot just be extended off of end. 54* call hash_$in_no_grow(htp,ename,eval,code); 55* htp is a pointer to the hash table(input) 56* ename is the name of the entry(input) 57* eval is the value of the entry(input) 58* code is the error code(output) 59* 60* ***to delete an entry in the table 61* call hash_$out(htp,ename,eval,code); 62* htp is a pointer to the hash table(input) 63* ename is the name of the entry(input) 64* eval is the value of the entry(output) 65* code is the error code(output) 66* 67* 68* ***to search for an entry in the table 69* call hash_$search(htp,ename,eval,code) 70* htp is a pointer to the hash table(input) 71* ename is the name of the entry(input) 72* eval is the value of the entry(output) 73* code is the error code(output) 74* 75* ***to search without writing meters 76* call hash_$search_no_write(htp,ename,eval,code) 77* htp is a pointer to the hash table 78* ename is the name of the entry (input) 79* eval is the value of the entry(output) 80* code is the error code; 81**/ 82 83 84 /* PARAMETERS */ 85 86 dcl code fixed bin (35); /* error code */ 87 dcl ename char (*); /* name of an entry in hash table */ 88 dcl eval bit (36) aligned; /* value of entry corresponding to ename */ 89 dcl htp pointer; /* pointer to the hash table */ 90 dcl n_entries fixed bin; /* initial number of entries to be placed in table */ 91 92 93 94 dcl i fixed bin; 95 dcl n fixed bin; /* number of buckets wanted in new hash table */ 96 97 dcl loht fixed bin (24); /* length of table in words */ 98 dcl nb fixed bin; /* number of entries (buckets) in table */ 99 dcl max_ht_entries fixed bin; /* max value of nb - function of max_seg_size */ 100 dcl pname char (32) aligned; /* name of entry passed to hash_index */ 101 dcl pn pointer; 102 dcl (hashing_in, rehashing) bit (1) aligned init ("0"b); 103 dcl (emploc, hsi, nhsi, ntries) fixed bin; 104 dcl found bit (1) aligned; 105 106 dcl sys_info$max_seg_size ext fixed bin (19); 107 dcl (error_table_$namedup, error_table_$segnamedup, error_table_$noentry) ext fixed bin (35); 108 dcl (error_table_$bigarg, error_table_$full_hashtbl) ext fixed bin (35); 109 110 dcl hash_index_ entry (ptr, fixed bin (21), fixed bin, fixed bin) returns (fixed bin); /* hashing subroutine */ 111 dcl rehash_ entry (ptr, fixed bin, fixed bin (35)); 112 113 dcl (addr, divide, fixed, float, mod) builtin; 114 115 116 117 opt_size: entry (n_entries) returns (fixed bin); 118 119 /* Compute optimal table size to accomodate n_entries: 120* make it 70% full, then round upward to the next full page. */ 121 122 max_ht_entries = divide (sys_info$max_seg_size - 8, 10, 17, 0); 123 if n_entries >= max_ht_entries then /* if there are too many entries */ 124 return (n_entries); /* the caller will find out when he tries to use it */ 125 nb = fixed (float (n_entries) / .7); /* compute number of entries in 70% full table */ 126 loht = 8 + 10 * nb; /* compute word length of that table */ 127 i = mod (loht, 1024); /* round it up to next full page */ 128 if i > 0 then /* if a page is partially used */ 129 loht = loht + 1024 - i; /* fill it up */ 130 nb = divide (loht - 8, 10, 17, 0); /* compute number of entries that will fit */ 131 if nb > max_ht_entries then /* if that is bigger than a segment */ 132 nb = max_ht_entries; /* then make it a full segment */ 133 return (nb); 134 135 136 137 138 make: entry (htp, n, code); 139 140 max_ht_entries = divide (sys_info$max_seg_size - 8, 10, 17, 0); /* 8-word header, 10-word entries */ 141 if (n > max_ht_entries | n <= 0) then /* check number of buckets */ 142 code = error_table_$bigarg; 143 else do; 144 code = 0; 145 htable.ni = 0; /* initialize statistical info */ 146 htable.np = 0; 147 htable.tnt = 0; 148 htable.id = "ht02"; 149 htable.gnt = 1; 150 htable.loht = n * 10 + 8; 151 htable.nb = n; /* Now the refer extent is legal ! */ 152 htable.buckets (*).flags.empty = "1"b; 153 htable.buckets (*).flags.ds = "0"b; 154 htable.buckets (*).name = ""; 155 htable.buckets (*).value = ""b; 156 157 end; 158 return; 159 160 161 162 in: entry (htp, ename, eval, code); 163 if float (htable.ni) / float (htable.nb) > .85 /* if table is more than 85% full */ 164 then call grow_hash_table; /* internal procedure to grow it to 70% full */ 165 join_in: /* no_grow enters here */ 166 hashing_in = "1"b; /* we will rehash, if necessary, to add this entry */ 167 call hasher; 168 if ^found then do; /* entry did not already exist */ 169 htable.ni = htable.ni + 1; /* increment number of entries in table */ 170 htable.flags.empty (emploc), htable.flags.ds (emploc) = "0"b; /* set deleted and empty switches off */ 171 htable.value (emploc) = eval; /* store value in bucket(emploc) */ 172 htable.name (emploc) = pname; /* store identifier */ 173 end; 174 else if htable.value (hsi) = eval then code = error_table_$segnamedup; /* entry existed with same value */ 175 else code = error_table_$namedup; /* entry existed with different value */ 176 return; 177 178 179 180 search: entry (htp, ename, eval, code); 181 call hasher; 182 search_join: 183 if found then eval = htable.value (hsi); /* set return value to that found by search */ 184 else code = error_table_$noentry; /* entry was not found */ 185 return; 186 187 search_no_write: 188 entry (htp, ename, eval, code); 189 call hasher_no_write; 190 goto search_join; 191 192 193 194 out: entry (htp, ename, eval, code); 195 call hasher; 196 if found then do; /* entry was found-is at hsi */ 197 htable.ni = htable.ni - 1; /* decrement number of entries */ 198 eval = htable.value (hsi); /* set return value */ 199 htable.flags.ds (hsi) = "1"b; /* set deleted switch */ 200 nhsi = hsi + 1; 201 if nhsi > htable.nb then nhsi = 1; /* find the next hash entry */ 202 if htable.flags.empty (nhsi) = "1"b then do i = hsi by -1 to 1, htable.nb by -1 to nhsi; /* if empty */ 203 if htable.flags.ds (i) = "0"b then return; /* then reset any buckets that were deleted to empty */ 204 htable.flags.ds (i) = "0"b; /* to minimize length of future searches, since searches must */ 205 htable.flags.empty (i) = "1"b; /* search past deleted buckets, until they hit an empty one */ 206 end; 207 end; 208 else code = error_table_$noentry; /* entry was not found */ 209 return; 210 211 212 213 /* Entry for use when the table may not grow */ 214 215 in_no_grow: 216 inagain: entry (htp, ename, eval, code); 217 rehashing = "1"b; /* set switch to prevent endless recursion */ 218 go to join_in; 219 220 221 222 hasher: procedure; 223 declare can_write bit (1) aligned; 224 225 can_write = "1"b; 226 goto w_join; 227 228 hasher_no_write: 229 entry; 230 can_write = "0"b; 231 232 w_join: 233 234 htentry: emploc, code = 0; /* set to zero-changed if found or error */ 235 found = "0"b; 236 pn = addr (pname); /* get address of name to be passed to hash_index */ 237 if can_write 238 then htable.np = htable.np + 1; /* increment number of probes */ 239 pname = ename; /* make ename 32 characters */ 240 hsi = hash_index_ (pn, 32, 1, htable.nb); /* get the hash index of the name */ 241 hsi = hsi + 1; 242 ntries = 1; 243 srch: if htable.flags.empty (hsi) = "1"b then do; /* if bucket is empty */ 244 if emploc = 0 then emploc = hsi; /* emploc is first empty bucket, either empty or deleted, 245* where this entry could be added, if not found */ 246 update: if can_write then do; 247 if ntries > htable.gnt then htable.gnt = ntries; /* set greatest number of tries */ 248 htable.tnt = htable.tnt + ntries; /* set total number of tries */ 249 end; 250 return; 251 end; 252 if htable.flags.ds (hsi) = "1"b then do; /* if deleted, this would be where to add the entry */ 253 if emploc = 0 then emploc = hsi; /* so set emploc, if not already set */ 254 /* but we can not be sure the entry is not already in the table, 255* until we find an empty (not just deleted) bucket */ 256 end; 257 else do; /* there is an entry at hsi */ 258 if htable.name (hsi) = pname then do; /* if the names match */ 259 found = "1"b; /* then set found to 1 */ 260 go to update; /* go to check gnt */ 261 end; 262 end; 263 contsrch: hsi = hsi + 1; /* continue the search until found or empty bucket */ 264 if hsi > htable.nb then hsi = 1; /* get next bucket */ 265 if ntries > divide (htable.nb, 2, 17, 0) then do; /* if too many tries, we should rehash */ 266 if ^hashing_in then /* but only if this entry is to be added */ 267 goto update; /* so, for $search, or $out, we say "not found" */ 268 else if rehashing then goto giveup; /* also, if we are already rehashing, don't recurse */ 269 call grow_full_hash_table; /* internal procedure - makes a 70% full table */ 270 go to htentry; /* go start search over again, using rehashed table */ 271 end; 272 ntries = ntries + 1; /* increment the number of tries for search */ 273 go to srch; 274 end hasher; 275 276 277 grow_hash_table: proc; /* grow an 85% full table to 70% full */ 278 279 dcl full bit (1) aligned; 280 dcl new_size fixed bin; 281 282 full = "0"b; /* we will not insist on rehashing */ 283 goto grow_common; 284 285 grow_full_hash_table: entry; /* grow table to get rid of a run more than half 286* the length of the table long */ 287 288 full = "1"b; /* we will insist on rehashing */ 289 290 grow_common: 291 max_ht_entries = divide (sys_info$max_seg_size - 8, 10, 17, 0); 292 if htable.nb >= max_ht_entries then do; /* if table already at max size */ 293 if full then goto giveup; /* if we are insisting, exit with an error code */ 294 else return; /* otherwise add the entry without rehashing */ 295 end; 296 297 nb = htable.ni; /* pick up count of currently-used entries */ 298 if full then 299 if float (nb) / float (htable.nb) < .7 then /* if table not 70% full */ 300 nb = fixed (float (htable.nb) * .85); /* lie - say its 85% full - to make sure it grows */ 301 new_size = opt_size (nb); /* first estimate on size */ 302 if full then /* ensure it's a real growth */ 303 do while (new_size <= htable.nb); /* now let's force the issue */ 304 nb = nb + 1; 305 new_size = opt_size (nb); 306 end; 307 call rehash_ (htp, new_size, code); 308 if code ^= 0 then goto giveup; /* nonlocal goto */ 309 310 return; 311 312 end grow_hash_table; 313 314 /* Come here if table is too full to rehash */ 315 giveup: code = error_table_$full_hashtbl; 316 htable.tnt = htable.tnt + ntries; /* increment total number of tries */ 317 if ntries > htable.gnt then /* and update greatest number of tries */ 318 htable.gnt = ntries; 319 return; 320 321 end hash_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 09/16/83 1134.7 hash_.pl1 >spec>on>09/16/83-as>hash_.pl1 23 1 04/21/82 1211.8 hashst.incl.pl1 >ldd>include>hashst.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. addr builtin function dcl 113 ref 236 buckets 10 based structure array level 2 dcl 1-6 can_write 000144 automatic bit(1) dcl 223 set ref 225* 230* 237 246 code parameter fixed bin(35,0) dcl 86 set ref 138 141* 144* 162 174* 175* 180 184* 187 194 208* 215 215 232* 307* 308 315* divide builtin function dcl 113 ref 122 130 140 265 290 ds 21 based bit(1) array level 4 packed unaligned dcl 1-6 set ref 153* 170* 199* 203 204* 252 emploc 000120 automatic fixed bin(17,0) dcl 103 set ref 170 170 171 172 232* 244 244* 253 253* empty 21(01) based bit(1) array level 4 packed unaligned dcl 1-6 set ref 152* 170* 202 205* 243 ename parameter char unaligned dcl 87 ref 162 180 187 194 215 215 239 error_table_$bigarg 000020 external static fixed bin(35,0) dcl 108 ref 141 error_table_$full_hashtbl 000022 external static fixed bin(35,0) dcl 108 ref 315 error_table_$namedup 000012 external static fixed bin(35,0) dcl 107 ref 175 error_table_$noentry 000016 external static fixed bin(35,0) dcl 107 ref 184 208 error_table_$segnamedup 000014 external static fixed bin(35,0) dcl 107 ref 174 eval parameter bit(36) dcl 88 set ref 162 171 174 180 182* 187 194 198* 215 215 fixed builtin function dcl 113 ref 125 298 flags 21 based structure array level 3 dcl 1-6 float builtin function dcl 113 ref 125 163 163 298 298 298 found 000124 automatic bit(1) dcl 104 set ref 168 182 196 235* 259* full 000154 automatic bit(1) dcl 279 set ref 282* 288* 293 298 302 gnt 5 based fixed bin(17,0) level 2 dcl 1-6 set ref 149* 247 247* 317 317* hash_index_ 000024 constant entry external dcl 110 ref 240 hashing_in 000116 automatic bit(1) initial dcl 102 set ref 102* 165* 266 hsi 000121 automatic fixed bin(17,0) dcl 103 set ref 174 182 198 199 200 202 240* 241* 241 243 244 252 253 258 263* 263 264 264* htable based structure level 1 dcl 1-6 htp parameter pointer dcl 89 set ref 138 145 146 147 148 149 150 151 152 153 154 155 162 163 163 169 169 170 170 171 172 174 180 182 187 194 197 197 198 199 201 202 202 203 204 205 215 215 237 237 240 243 247 247 248 248 252 258 264 265 292 297 298 298 302 307* 316 316 317 317 i 000100 automatic fixed bin(17,0) dcl 94 set ref 127* 128 128 202* 203 204 205* id 4 based char(4) level 2 dcl 1-6 set ref 148* loht 6 based fixed bin(18,0) level 2 in structure "htable" unsigned dcl 1-6 in procedure "hash_" set ref 150* loht 000101 automatic fixed bin(24,0) dcl 97 in procedure "hash_" set ref 126* 127 128* 128 130 max_ht_entries 000103 automatic fixed bin(17,0) dcl 99 set ref 122* 123 131 131 140* 141 290* 292 mod builtin function dcl 113 ref 127 n parameter fixed bin(17,0) dcl 95 ref 138 141 141 150 151 n_entries parameter fixed bin(17,0) dcl 90 ref 117 123 123 125 name 10 based char(32) array level 3 packed unaligned dcl 1-6 set ref 154* 172* 258 nb 000102 automatic fixed bin(17,0) dcl 98 in procedure "hash_" set ref 125* 126 130* 131 131* 133 297* 298 298* 301* 304* 304 305* nb based fixed bin(17,0) level 2 in structure "htable" dcl 1-6 in procedure "hash_" set ref 151* 152 153 154 155 163 201 202 240* 264 265 292 298 298 302 new_size 000155 automatic fixed bin(17,0) dcl 280 set ref 301* 302 305* 307* nhsi 000122 automatic fixed bin(17,0) dcl 103 set ref 200* 201 201* 202 202 ni 1 based fixed bin(17,0) level 2 dcl 1-6 set ref 145* 163 169* 169 197* 197 297 np 2 based fixed bin(17,0) level 2 dcl 1-6 set ref 146* 237* 237 ntries 000123 automatic fixed bin(17,0) dcl 103 set ref 242* 247 247 248 265 272* 272 316 317 317 pn 000114 automatic pointer dcl 101 set ref 236* 240* pname 000104 automatic char(32) dcl 100 set ref 172 236 239* 258 rehash_ 000026 constant entry external dcl 111 ref 307 rehashing 000117 automatic bit(1) initial dcl 102 set ref 102* 217* 268 sys_info$max_seg_size 000010 external static fixed bin(19,0) dcl 106 ref 122 140 290 tnt 3 based fixed bin(17,0) level 2 dcl 1-6 set ref 147* 248* 248 316* 316 value 20 based bit(36) array level 3 dcl 1-6 set ref 155* 171* 174 182 198 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. MAX_HT_BUCKETS_IN_SEG internal static fixed bin(17,0) initial dcl 1-24 hash_table_size_ automatic fixed bin(17,0) dcl 1-25 NAMES DECLARED BY EXPLICIT CONTEXT. contsrch 001120 constant label dcl 263 giveup 000744 constant label dcl 315 ref 268 293 308 grow_common 001150 constant label dcl 290 ref 283 grow_full_hash_table 001145 constant entry internal dcl 285 ref 269 grow_hash_table 001142 constant entry internal dcl 277 ref 163 hash_ 000024 constant entry external dcl 12 hasher 000766 constant entry internal dcl 222 ref 167 181 195 hasher_no_write 000772 constant entry internal dcl 228 ref 189 htentry 000774 constant label dcl 232 ref 270 in 000313 constant entry external dcl 162 in_no_grow 000720 constant entry external dcl 215 inagain 000674 constant entry external dcl 215 join_in 000350 constant label dcl 165 ref 218 make 000136 constant entry external dcl 138 opt_size 000041 constant entry external dcl 117 ref 301 305 out 000523 constant entry external dcl 194 search 000426 constant entry external dcl 180 search_join 000450 constant label dcl 182 ref 190 search_no_write 000476 constant entry external dcl 187 srch 001044 constant label dcl 243 ref 273 update 001063 constant label dcl 246 ref 260 266 w_join 000774 constant label dcl 232 ref 226 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1444 1474 1261 1454 Length 1700 1261 30 170 162 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME hash_ 144 external procedure is an external procedure. hasher internal procedure shares stack frame of external procedure hash_. grow_hash_table internal procedure shares stack frame of external procedure hash_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME hash_ 000100 i hash_ 000101 loht hash_ 000102 nb hash_ 000103 max_ht_entries hash_ 000104 pname hash_ 000114 pn hash_ 000116 hashing_in hash_ 000117 rehashing hash_ 000120 emploc hash_ 000121 hsi hash_ 000122 nhsi hash_ 000123 ntries hash_ 000124 found hash_ 000144 can_write hasher 000154 full grow_hash_table 000155 new_size grow_hash_table THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. fx1_to_fl2 call_ext_in call_ext_out return fl2_to_fx1 mod_fx1 signal ext_entry ext_entry_desc THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. hash_index_ rehash_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bigarg error_table_$full_hashtbl error_table_$namedup error_table_$noentry error_table_$segnamedup sys_info$max_seg_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 102 000017 12 000023 117 000034 122 000050 123 000055 125 000071 126 000076 127 000101 128 000104 130 000111 131 000115 133 000121 138 000132 140 000151 141 000156 144 000166 145 000167 146 000172 147 000173 148 000174 149 000176 150 000200 151 000204 152 000206 153 000224 154 000242 155 000262 158 000277 162 000306 163 000334 165 000350 167 000352 168 000353 169 000355 170 000361 171 000367 172 000371 173 000375 174 000376 175 000412 176 000415 180 000424 181 000447 182 000450 184 000462 185 000465 187 000474 189 000517 190 000520 194 000521 195 000544 196 000545 197 000547 198 000554 199 000560 200 000562 201 000565 202 000571 203 000607 204 000627 205 000631 206 000633 207 000657 208 000660 209 000663 215 000672 217 000741 218 000743 315 000744 316 000747 317 000754 319 000757 222 000766 225 000767 226 000771 228 000772 230 000773 232 000774 235 000776 236 000777 237 001001 239 001007 240 001015 241 001041 242 001042 243 001044 244 001057 246 001063 247 001065 248 001074 250 001075 252 001076 253 001103 256 001107 258 001110 259 001115 260 001117 263 001120 264 001121 265 001126 266 001132 268 001134 269 001136 270 001137 272 001140 273 001141 277 001142 282 001143 283 001144 285 001145 288 001146 290 001150 292 001155 293 001161 294 001163 297 001164 298 001167 301 001205 302 001215 304 001225 305 001226 306 001236 307 001237 308 001253 310 001255 ----------------------------------------------------------- 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