ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/holofile.c
Revision: 3.57
Committed: Thu Sep 9 01:41:21 2004 UTC (19 years, 6 months ago) by greg
Content type: text/plain
Branch: MAIN
CVS Tags: rad3R7P2, rad3R7P1, rad3R6, rad3R6P1, rad3R8, rad3R9
Changes since 3.56: +7 -6 lines
Log Message:
Reduced frequency of fragmentation checks and improved logic

File Contents

# User Rev Content
1 gregl 3.1 #ifndef lint
2 greg 3.57 static const char RCSid[] = "$Id: holofile.c,v 3.56 2004/09/09 01:06:19 greg Exp $";
3 gregl 3.1 #endif
4     /*
5     * Routines for managing holodeck files
6     *
7     * 9/30/97 GWLarson
8     */
9    
10 schorsch 3.49 #include "copyright.h"
11    
12     #include <string.h>
13    
14 greg 3.54 #include "platform.h"
15 schorsch 3.55 #include "rtprocess.h"
16 greg 3.54
17 gregl 3.1 #include "holo.h"
18 greg 3.53
19 gregl 3.1 #ifndef CACHESIZE
20 greg 3.45 #ifdef SMLMEM
21     #define CACHESIZE 5
22     #else
23 gwlarson 3.38 #define CACHESIZE 17 /* default cache size (Mbytes, 0==inf) */
24 gwlarson 3.35 #endif
25 gregl 3.1 #endif
26     #ifndef FREEBEAMS
27 gwlarson 3.25 #define FREEBEAMS 1500 /* maximum beams to free at a time */
28 gregl 3.1 #endif
29     #ifndef PCTFREE
30 gregl 3.21 #define PCTFREE 15 /* maximum fraction to free (%) */
31 gregl 3.1 #endif
32 gwlarson 3.31 #ifndef MAXFRAGB
33     #define MAXFRAGB 16 /* fragment blocks/file to track (0==inf) */
34 gregl 3.15 #endif
35 gwlarson 3.32 #ifndef FF_DEFAULT
36     /* when to free a beam fragment */
37 gwlarson 3.39 #define FF_DEFAULT (FF_WRITE|FF_KILL)
38 gwlarson 3.32 #endif
39 gwlarson 3.29 #ifndef MINDIRSEL
40     /* minimum directory seek length */
41     #define MINDIRSEL (4*BUFSIZ/sizeof(BEAMI))
42     #endif
43 gregl 3.1
44 gregl 3.6 #ifndef BSD
45     #define write writebuf /* safe i/o routines */
46     #define read readbuf
47     #endif
48 gregl 3.4
49 gwlarson 3.31 #define FRAGBLK 512 /* number of fragments to allocate at a time */
50 gregl 3.4
51 gwlarson 3.32 int hdfragflags = FF_DEFAULT; /* tells when to free fragments */
52 gregl 3.14 unsigned hdcachesize = CACHESIZE*1024*1024; /* target cache size */
53 gwlarson 3.32 unsigned long hdclock; /* clock value */
54 gregl 3.1
55     HOLO *hdlist[HDMAX+1]; /* holodeck pointers (NULL term.) */
56    
57 gregl 3.16 static struct fraglist {
58 gregl 3.1 short nlinks; /* number of holodeck sections using us */
59 gwlarson 3.41 short writable; /* 0 read-only, <0 write error encountered */
60 gregl 3.13 int nfrags; /* number of known fragments */
61 gregl 3.4 BEAMI *fi; /* fragments, descending file position */
62 greg 3.46 off_t flen; /* last known file length */
63 gregl 3.16 } *hdfragl; /* fragment lists, indexed by file descriptor */
64 gregl 3.1
65 gregl 3.16 static int nhdfragls; /* size of hdfragl array */
66 gregl 3.1
67 schorsch 3.55 static HOLO *hdalloc(HDGRID *hproto);
68     static char *hdrealloc(char *ptr, unsigned siz, char *rout);
69     static void hdattach(int fd, int wr);
70     static void hdrelease(int fd);
71     static void hdmarkdirty(HOLO *hp, int i);
72     static unsigned int hdmemuse(int all);
73     static int hdfilord(const void *hb1, const void *hb2);
74     static off_t hdallocfrag(int fd, uint32 nrays);
75     static int hdsyncbeam(HOLO *hp, int i);
76     static int hdlrulist(HDBEAMI *hb, int nents, int n, HOLO *hp);
77     static int hdfreecache(int pct, HOLO *honly);
78    
79    
80 gregl 3.4
81 gwlarson 3.40 HOLO *
82 schorsch 3.55 hdalloc( /* allocate and set holodeck section based on grid */
83     HDGRID *hproto
84     )
85 gwlarson 3.40 {
86     HOLO hdhead;
87     register HOLO *hp;
88     int n;
89     /* copy grid to temporary header */
90 schorsch 3.49 memcpy((void *)&hdhead, (void *)hproto, sizeof(HDGRID));
91 gwlarson 3.40 /* compute grid vectors and sizes */
92     hdcompgrid(&hdhead);
93     /* allocate header with directory */
94     n = sizeof(HOLO)+nbeams(&hdhead)*sizeof(BEAMI);
95     if ((hp = (HOLO *)malloc(n)) == NULL)
96     return(NULL);
97     /* copy header information */
98 schorsch 3.51 *hp = hdhead;
99 gwlarson 3.40 /* allocate and clear beam list */
100     hp->bl = (BEAM **)malloc((nbeams(hp)+1)*sizeof(BEAM *)+sizeof(BEAM));
101     if (hp->bl == NULL) {
102 greg 3.42 free((void *)hp);
103 gwlarson 3.40 return(NULL);
104     }
105 schorsch 3.49 memset((void *)hp->bl, '\0', (nbeams(hp)+1)*sizeof(BEAM *)+sizeof(BEAM));
106 gwlarson 3.40 hp->bl[0] = (BEAM *)(hp->bl+nbeams(hp)+1); /* set blglob(hp) */
107     hp->fd = -1;
108     hp->dirty = 0;
109     hp->priv = NULL;
110     /* clear beam directory */
111 schorsch 3.49 memset((void *)hp->bi, '\0', (nbeams(hp)+1)*sizeof(BEAMI));
112 gwlarson 3.40 return(hp); /* all is well */
113     }
114    
115    
116 gwlarson 3.26 char *
117 schorsch 3.55 hdrealloc( /* (re)allocate memory, retry then error */
118     char *ptr,
119     unsigned siz,
120     char *rout
121     )
122 gwlarson 3.26 {
123     register char *newp;
124     /* call malloc/realloc */
125     if (ptr == NULL) newp = (char *)malloc(siz);
126 greg 3.43 else newp = (char *)realloc((void *)ptr, siz);
127 gwlarson 3.26 /* check success */
128     if (newp == NULL && rout != NULL) {
129     hdfreecache(25, NULL); /* free some memory */
130     errno = 0; /* retry */
131     newp = hdrealloc(ptr, siz, NULL);
132     if (newp == NULL) { /* give up and report error */
133     sprintf(errmsg, "out of memory in %s", rout);
134     error(SYSTEM, errmsg);
135     }
136     }
137     return(newp);
138     }
139    
140    
141 schorsch 3.55 void
142     hdattach( /* start tracking file fragments for some section */
143     register int fd,
144     int wr
145     )
146 gregl 3.1 {
147 gregl 3.16 if (fd >= nhdfragls) {
148 gwlarson 3.26 hdfragl = (struct fraglist *)hdrealloc((char *)hdfragl,
149     (fd+1)*sizeof(struct fraglist), "hdattach");
150 schorsch 3.49 memset((void *)(hdfragl+nhdfragls),
151     '\0', (fd+1-nhdfragls)*sizeof(struct fraglist));
152 gregl 3.16 nhdfragls = fd+1;
153 gregl 3.1 }
154 gregl 3.16 hdfragl[fd].nlinks++;
155 gwlarson 3.41 hdfragl[fd].writable = wr; /* set writable flag */
156 greg 3.53 /* get file length */
157     hdfragl[fd].flen = lseek(fd, (off_t)0, SEEK_END);
158 gregl 3.1 }
159    
160    
161     /* Do we need a routine to locate file fragments given known occupants? */
162    
163    
164 schorsch 3.55 void
165     hdrelease( /* stop tracking file fragments for some section */
166     register int fd
167     )
168 gregl 3.1 {
169 schorsch 3.52 if ((fd < 0) | (fd >= nhdfragls) || !hdfragl[fd].nlinks)
170 gregl 3.1 return;
171 gregl 3.16 if (!--hdfragl[fd].nlinks && hdfragl[fd].nfrags) {
172 greg 3.42 free((void *)hdfragl[fd].fi);
173 gregl 3.16 hdfragl[fd].fi = NULL;
174     hdfragl[fd].nfrags = 0;
175 gregl 3.1 }
176     }
177    
178    
179 schorsch 3.55 extern HOLO *
180     hdinit( /* initialize a holodeck section in a file */
181     int fd, /* corresponding file descriptor */
182     HDGRID *hproto /* holodeck section grid */
183     )
184 gregl 3.1 {
185 greg 3.46 off_t rtrunc;
186     off_t fpos;
187 gwlarson 3.41 int writable;
188 gregl 3.1 register HOLO *hp;
189     register int n;
190     /* prepare for system errors */
191     errno = 0;
192 greg 3.53 if ((fpos = lseek(fd, (off_t)0, SEEK_CUR)) < 0)
193 gregl 3.1 error(SYSTEM, "cannot determine holodeck file position");
194     if (hproto == NULL) { /* assume we're loading it */
195     HDGRID hpr;
196     /* load header */
197     if (read(fd, (char *)&hpr, sizeof(HDGRID)) != sizeof(HDGRID))
198     error(SYSTEM, "cannot load holodeck header");
199     /* allocate grid */
200     if ((hp = hdalloc(&hpr)) == NULL)
201     goto memerr;
202     /* load beam directory */
203     n = nbeams(hp)*sizeof(BEAMI);
204     if (read(fd, (char *)(hp->bi+1), n) != n)
205     error(SYSTEM, "failure loading holodeck directory");
206 gregl 3.6 /* check that it's clean */
207 gwlarson 3.28 for (n = nbeams(hp); n > 0; n--)
208     if (hp->bi[n].fo < 0) {
209     hp->bi[n].fo = 0;
210     error(WARNING, "dirty holodeck section");
211     break;
212     }
213 gwlarson 3.41 /* check writability */
214     if (fd < nhdfragls && hdfragl[fd].nlinks)
215     writable = hdfragl[fd].writable;
216     else
217 greg 3.53 writable = lseek(fd, fpos, SEEK_SET) == fpos &&
218 gwlarson 3.41 write(fd, (char *)hp, sizeof(HDGRID)) ==
219     sizeof(HDGRID);
220     } else { /* else assume we're creating it */
221 gregl 3.1 if ((hp = hdalloc(hproto)) == NULL)
222     goto memerr;
223     /* write header and skeleton */
224     n = nbeams(hp)*sizeof(BEAMI);
225     if (write(fd, (char *)hproto, sizeof(HDGRID)) !=
226     sizeof(HDGRID) ||
227     write(fd, (char *)(hp->bi+1), n) != n)
228     error(SYSTEM, "cannot write header to holodeck file");
229 gwlarson 3.41 writable = 1;
230 gregl 3.1 }
231     hp->fd = fd;
232     hp->dirty = 0;
233     biglob(hp)->fo = fpos + sizeof(HDGRID);
234 gregl 3.13 /* start tracking fragments */
235 gwlarson 3.41 hdattach(fd, writable);
236 gregl 3.13 /* check rays on disk */
237     fpos = hdfilen(fd);
238 gwlarson 3.22 biglob(hp)->nrd = rtrunc = 0;
239 gregl 3.13 for (n = hproto == NULL ? nbeams(hp) : 0; n > 0; n--)
240 schorsch 3.52 if (hp->bi[n].nrd) {
241 gwlarson 3.27 if (hp->bi[n].fo+hp->bi[n].nrd*sizeof(RAYVAL) > fpos) {
242 gwlarson 3.22 rtrunc += hp->bi[n].nrd;
243     hp->bi[n].nrd = 0;
244     } else
245 gregl 3.13 biglob(hp)->nrd += hp->bi[n].nrd;
246 schorsch 3.52 }
247 gwlarson 3.22 if (rtrunc) {
248     sprintf(errmsg, "truncated section, %ld rays lost (%.1f%%)",
249     rtrunc, 100.*rtrunc/(rtrunc+biglob(hp)->nrd));
250     error(WARNING, errmsg);
251     }
252 gregl 3.1 /* add to holodeck list */
253     for (n = 0; n < HDMAX; n++)
254     if (hdlist[n] == NULL) {
255     hdlist[n] = hp;
256     break;
257     }
258     /* all done */
259     return(hp);
260     memerr:
261     error(SYSTEM, "cannot allocate holodeck grid");
262 schorsch 3.55 return NULL; /* pro forma return */
263 gregl 3.1 }
264    
265    
266 schorsch 3.55 void
267     hdmarkdirty( /* mark holodeck directory position dirty */
268     register HOLO *hp,
269     int i
270     )
271 gwlarson 3.28 {
272     static BEAMI smudge = {0, -1};
273     int mindist, minpos;
274     register int j;
275    
276     if (!hp->dirty++) { /* write smudge first time */
277 greg 3.53 if (lseek(hp->fd, biglob(hp)->fo+(i-1)*sizeof(BEAMI),
278     SEEK_SET) < 0 ||
279     write(hp->fd, (char *)&smudge,
280 gwlarson 3.28 sizeof(BEAMI)) != sizeof(BEAMI))
281 gwlarson 3.37 error(SYSTEM, "seek/write error in hdmarkdirty");
282 gwlarson 3.28 hp->dirseg[0].s = i;
283     hp->dirseg[0].n = 1;
284     return;
285     }
286     /* insert into segment list */
287     for (j = hp->dirty; j--; ) {
288     if (!j || hp->dirseg[j-1].s < i) {
289     hp->dirseg[j].s = i;
290     hp->dirseg[j].n = 1;
291     break;
292     }
293 schorsch 3.51 *(hp->dirseg+j) = *(hp->dirseg+(j-1));
294 gwlarson 3.28 }
295 gwlarson 3.29 do { /* check neighbors */
296     mindist = nbeams(hp); /* find closest */
297     for (j = hp->dirty; --j; )
298     if (hp->dirseg[j].s -
299     (hp->dirseg[j-1].s + hp->dirseg[j-1].n)
300     < mindist) {
301     minpos = j;
302     mindist = hp->dirseg[j].s -
303 gwlarson 3.28 (hp->dirseg[j-1].s + hp->dirseg[j-1].n);
304 gwlarson 3.29 }
305     /* good enough? */
306     if (hp->dirty <= MAXDIRSE && mindist > MINDIRSEL)
307     break;
308 gwlarson 3.28 j = minpos - 1; /* coalesce neighbors */
309     if (hp->dirseg[j].s + hp->dirseg[j].n <
310 gwlarson 3.29 hp->dirseg[minpos].s + hp->dirseg[minpos].n)
311 gwlarson 3.28 hp->dirseg[j].n = hp->dirseg[minpos].s +
312     hp->dirseg[minpos].n - hp->dirseg[j].s;
313 gwlarson 3.29 hp->dirty--;
314     while (++j < hp->dirty) /* close the gap */
315 schorsch 3.51 *(hp->dirseg+j) = *(hp->dirseg+(j+1));
316 gwlarson 3.29 } while (mindist <= MINDIRSEL);
317 gwlarson 3.28 }
318    
319    
320 schorsch 3.55 extern int
321     hdsync( /* update beams and directory on disk */
322     register HOLO *hp,
323     int all
324     )
325 gregl 3.1 {
326     register int j, n;
327    
328 gregl 3.12 if (hp == NULL) { /* do all holodecks */
329 gregl 3.1 n = 0;
330     for (j = 0; hdlist[j] != NULL; j++)
331 gregl 3.12 n += hdsync(hdlist[j], all);
332 gregl 3.1 return(n);
333     }
334 gregl 3.12 /* sync the beams */
335 gregl 3.15 for (j = (all ? nbeams(hp) : 0); j > 0; j--)
336 gregl 3.12 if (hp->bl[j] != NULL)
337     hdsyncbeam(hp, j);
338 gregl 3.13 if (!hp->dirty) /* directory clean? */
339 gregl 3.1 return(0);
340 gwlarson 3.28 errno = 0; /* write dirty segments */
341     for (j = 0; j < hp->dirty; j++) {
342 greg 3.46 if (lseek(hp->fd, biglob(hp)->fo +
343 greg 3.53 (hp->dirseg[j].s-1)*sizeof(BEAMI), SEEK_SET) < 0)
344 gwlarson 3.28 error(SYSTEM, "cannot seek on holodeck file");
345     n = hp->dirseg[j].n * sizeof(BEAMI);
346     if (write(hp->fd, (char *)(hp->bi+hp->dirseg[j].s), n) != n)
347     error(SYSTEM, "cannot update section directory");
348     }
349     hp->dirty = 0; /* all clean */
350 gregl 3.1 return(1);
351     }
352    
353    
354 schorsch 3.55 unsigned int
355     hdmemuse( /* return memory usage (in bytes) */
356     int all /* include overhead (painful) */
357     )
358 gregl 3.1 {
359     long total = 0;
360     register int i, j;
361    
362     for (j = 0; hdlist[j] != NULL; j++) {
363     total += blglob(hdlist[j])->nrm * sizeof(RAYVAL);
364     if (all) {
365     total += sizeof(HOLO) + sizeof(BEAM *) +
366     nbeams(hdlist[j]) *
367     (sizeof(BEAM *)+sizeof(BEAMI));
368     for (i = nbeams(hdlist[j]); i > 0; i--)
369     if (hdlist[j]->bl[i] != NULL)
370     total += sizeof(BEAM);
371     }
372     }
373     if (all)
374 gregl 3.16 for (j = 0; j < nhdfragls; j++) {
375     total += sizeof(struct fraglist);
376     if (hdfragl[j].nfrags)
377 gregl 3.4 total += FRAGBLK*sizeof(BEAMI) *
378 gregl 3.16 ((hdfragl[j].nfrags-1)/FRAGBLK + 1) ;
379 gregl 3.4 }
380 gregl 3.1 return(total);
381 gregl 3.8 }
382    
383    
384 schorsch 3.55 extern off_t
385     hdfilen( /* return file length for fd */
386     int fd
387     )
388 gregl 3.8 {
389 greg 3.46 off_t fpos, flen;
390 gregl 3.8
391     if (fd < 0)
392     return(-1);
393 gregl 3.16 if (fd >= nhdfragls || !hdfragl[fd].nlinks) {
394 greg 3.53 if ((fpos = lseek(fd, (off_t)0, SEEK_CUR)) < 0)
395 gregl 3.8 return(-1);
396 greg 3.53 flen = lseek(fd, (off_t)0, SEEK_END);
397     lseek(fd, fpos, SEEK_SET);
398 gregl 3.8 return(flen);
399     }
400 gregl 3.16 return(hdfragl[fd].flen);
401 gregl 3.1 }
402    
403    
404 schorsch 3.55 extern off_t
405     hdfiluse( /* compute file usage (in bytes) */
406 greg 3.56 int fd /* open file descriptor to check */
407 schorsch 3.55 )
408 gregl 3.1 {
409 greg 3.46 off_t total = 0;
410 greg 3.57 register int j;
411 gregl 3.1
412     for (j = 0; hdlist[j] != NULL; j++) {
413     if (hdlist[j]->fd != fd)
414     continue;
415     total += biglob(hdlist[j])->nrd * sizeof(RAYVAL);
416 greg 3.57 total += nbeams(hdlist[j])*sizeof(BEAMI) + sizeof(HDGRID);
417     #if 0
418     for (i = nbeams(hdlist[j]); i > 0; i--)
419 greg 3.56 if (hdlist[j]->bl[i] != NULL)
420     total += sizeof(RAYVAL) *
421 gregl 3.1 (hdlist[j]->bl[i]->nrm -
422     hdlist[j]->bi[i].nrd);
423 greg 3.57 #endif
424 gregl 3.1 }
425 greg 3.57 return(total); /* doesn't include fragments, unflushed rays */
426 gregl 3.1 }
427    
428    
429 schorsch 3.55 extern RAYVAL *
430     hdnewrays( /* allocate space for add'l rays and return pointer */
431     register HOLO *hp,
432     register int i,
433     int nr /* number of new rays desired */
434     )
435 gregl 3.1 {
436     RAYVAL *p;
437     int n;
438    
439 gwlarson 3.32 if (nr <= 0) return(NULL);
440 schorsch 3.52 CHECK((i < 1) | (i > nbeams(hp)),
441 gwlarson 3.32 CONSISTENCY, "bad beam index given to hdnewrays");
442 gregl 3.1 if (hp->bl[i] != NULL)
443     hp->bl[i]->tick = hdclock; /* preempt swap */
444     if (hdcachesize > 0 && hdmemuse(0) >= hdcachesize)
445     hdfreecache(PCTFREE, NULL); /* free some space */
446     if (hp->bl[i] == NULL) { /* allocate (and load) */
447     n = hp->bi[i].nrd + nr;
448 gwlarson 3.26 hp->bl[i] = (BEAM *)hdrealloc(NULL, hdbsiz(n), "hdnewrays");
449 gregl 3.1 blglob(hp)->nrm += n;
450 gwlarson 3.32 if ((n = hp->bl[i]->nrm = hp->bi[i].nrd)) {
451 gwlarson 3.26 errno = 0;
452 greg 3.53 if (lseek(hp->fd, hp->bi[i].fo, SEEK_SET) < 0)
453 gregl 3.1 error(SYSTEM, "seek error on holodeck file");
454     n *= sizeof(RAYVAL);
455     if (read(hp->fd, (char *)hdbray(hp->bl[i]), n) != n)
456     error(SYSTEM,
457     "error reading beam from holodeck file");
458     }
459     } else { /* just grow in memory */
460 gwlarson 3.26 hp->bl[i] = (BEAM *)hdrealloc((char *)hp->bl[i],
461     hdbsiz(hp->bl[i]->nrm + nr), "hdnewrays");
462 gregl 3.1 blglob(hp)->nrm += nr;
463     }
464 gwlarson 3.32 if (hdfragflags&FF_ALLOC && hp->bi[i].nrd)
465     hdfreefrag(hp, i); /* relinquish old fragment */
466 gregl 3.1 p = hdbray(hp->bl[i]) + hp->bl[i]->nrm;
467     hp->bl[i]->nrm += nr; /* update in-core structure */
468 schorsch 3.49 memset((void *)p, '\0', nr*sizeof(RAYVAL));
469 gwlarson 3.25 blglob(hp)->tick = hp->bl[i]->tick = hdclock++; /* update LRU clock */
470 gregl 3.1 return(p); /* point to new rays */
471     }
472    
473    
474 schorsch 3.55 extern BEAM *
475     hdgetbeam( /* get beam (from file if necessary) */
476     register HOLO *hp,
477     register int i
478     )
479 gregl 3.1 {
480     register int n;
481    
482 schorsch 3.52 CHECK((i < 1) | (i > nbeams(hp)),
483 gwlarson 3.32 CONSISTENCY, "bad beam index given to hdgetbeam");
484 gregl 3.1 if (hp->bl[i] == NULL) { /* load from disk */
485     if (!(n = hp->bi[i].nrd))
486     return(NULL);
487     if (hdcachesize > 0 && hdmemuse(0) >= hdcachesize)
488     hdfreecache(PCTFREE, NULL); /* get free space */
489 gwlarson 3.26 hp->bl[i] = (BEAM *)hdrealloc(NULL, hdbsiz(n), "hdgetbeam");
490     blglob(hp)->nrm += hp->bl[i]->nrm = n;
491 gregl 3.1 errno = 0;
492 greg 3.53 if (lseek(hp->fd, hp->bi[i].fo, SEEK_SET) < 0)
493 gregl 3.1 error(SYSTEM, "seek error on holodeck file");
494     n *= sizeof(RAYVAL);
495     if (read(hp->fd, (char *)hdbray(hp->bl[i]), n) != n)
496     error(SYSTEM, "error reading beam from holodeck file");
497 gwlarson 3.32 if (hdfragflags&FF_READ)
498     hdfreefrag(hp, i); /* relinquish old frag. */
499 gregl 3.1 }
500 gwlarson 3.25 blglob(hp)->tick = hp->bl[i]->tick = hdclock++; /* update LRU clock */
501 gregl 3.1 return(hp->bl[i]);
502     }
503    
504    
505     int
506 schorsch 3.55 hdfilord( /* order beams for quick loading */
507     register const void *hb1,
508     register const void *hb2
509     )
510 gregl 3.14 {
511 greg 3.47 register off_t c;
512 gregl 3.17 /* residents go first */
513 schorsch 3.55 if (((HDBEAMI*)hb2)->h->bl[((HDBEAMI*)hb2)->b] != NULL)
514     return(((HDBEAMI*)hb1)->h->bl[((HDBEAMI*)hb1)->b] == NULL);
515     if (((HDBEAMI*)hb1)->h->bl[((HDBEAMI*)hb1)->b] != NULL)
516 gregl 3.17 return(-1);
517     /* otherwise sort by file descriptor */
518 schorsch 3.55 if (((HDBEAMI*)hb1)->h->fd != ((HDBEAMI*)hb2)->h->fd)
519     return(((HDBEAMI*)hb1)->h->fd - ((HDBEAMI*)hb2)->h->fd);
520 gregl 3.14 /* then by position in file */
521 schorsch 3.55 c = ((HDBEAMI*)hb1)->h->bi[((HDBEAMI*)hb1)->b].fo
522     - ((HDBEAMI*)hb2)->h->bi[((HDBEAMI*)hb2)->b].fo;
523 gregl 3.17 return(c > 0 ? 1 : c < 0 ? -1 : 0);
524 gregl 3.14 }
525    
526    
527 schorsch 3.55 extern void
528     hdloadbeams( /* load a list of beams in optimal order */
529     register HDBEAMI *hb, /* list gets sorted by hdfilord() */
530     int n, /* list length */
531     void (*bf)(BEAM *bp, HDBEAMI *hb) /* callback function (optional) */
532     )
533 gregl 3.14 {
534     unsigned origcachesize, memuse;
535 gwlarson 3.23 int bytesloaded, needbytes, bytes2free;
536 gregl 3.14 register BEAM *bp;
537     register int i;
538     /* precheck consistency */
539 gwlarson 3.25 if (n <= 0) return;
540 gregl 3.14 for (i = n; i--; )
541 schorsch 3.52 if (hb[i].h==NULL || (hb[i].b<1) | (hb[i].b>nbeams(hb[i].h)))
542 gregl 3.14 error(CONSISTENCY, "bad beam in hdloadbeams");
543     /* sort list for optimal access */
544 greg 3.44 qsort((void *)hb, n, sizeof(HDBEAMI), hdfilord);
545 gregl 3.17 bytesloaded = 0; /* run through loaded beams */
546     for ( ; n && (bp = hb->h->bl[hb->b]) != NULL; n--, hb++) {
547 gwlarson 3.23 bp->tick = hdclock; /* preempt swap */
548 gregl 3.17 bytesloaded += bp->nrm;
549     if (bf != NULL)
550 gwlarson 3.23 (*bf)(bp, hb);
551 gregl 3.17 }
552     bytesloaded *= sizeof(RAYVAL);
553 gregl 3.15 if ((origcachesize = hdcachesize) > 0) {
554 gregl 3.17 needbytes = 0; /* figure out memory needs */
555 gregl 3.15 for (i = n; i--; )
556 gregl 3.17 needbytes += hb[i].h->bi[hb[i].b].nrd;
557 gregl 3.15 needbytes *= sizeof(RAYVAL);
558     do { /* free enough memory */
559     memuse = hdmemuse(0);
560 gregl 3.17 bytes2free = needbytes - (int)(hdcachesize-memuse);
561     if (bytes2free > (int)(memuse - bytesloaded))
562 gregl 3.15 bytes2free = memuse - bytesloaded;
563     } while (bytes2free > 0 &&
564     hdfreecache(100*bytes2free/memuse, NULL) < 0);
565 gregl 3.17 hdcachesize = 0; /* load beams w/o swap */
566 gregl 3.15 }
567 gregl 3.14 for (i = 0; i < n; i++)
568     if ((bp = hdgetbeam(hb[i].h, hb[i].b)) != NULL && bf != NULL)
569 gwlarson 3.23 (*bf)(bp, hb+i);
570 gregl 3.14 hdcachesize = origcachesize; /* resume dynamic swapping */
571     }
572    
573    
574 schorsch 3.55 extern int
575     hdfreefrag( /* free a file fragment */
576     HOLO *hp,
577     int i
578     )
579 gregl 3.19 {
580 gwlarson 3.32 register BEAMI *bi = &hp->bi[i];
581 gregl 3.19 register struct fraglist *f;
582     register int j, k;
583    
584 gwlarson 3.32 if (bi->nrd <= 0)
585 gwlarson 3.33 return(0);
586 gwlarson 3.32 DCHECK(hp->fd < 0 | hp->fd >= nhdfragls || !hdfragl[hp->fd].nlinks,
587     CONSISTENCY, "bad file descriptor in hdfreefrag");
588     f = &hdfragl[hp->fd];
589 gwlarson 3.41 if (!f->writable)
590     return(0);
591 gregl 3.19 if (f->nfrags % FRAGBLK == 0) { /* delete empty remnants */
592     for (j = k = 0; k < f->nfrags; j++, k++) {
593     while (f->fi[k].nrd == 0)
594     if (++k >= f->nfrags)
595     goto endloop;
596     if (k > j)
597 schorsch 3.51 *(f->fi+j) = *(f->fi+k);
598 gregl 3.19 }
599     endloop:
600     f->nfrags = j;
601     }
602     j = f->nfrags++; /* allocate a slot in free list */
603 gwlarson 3.31 #if MAXFRAGB
604     if (j >= MAXFRAGB*FRAGBLK) {
605     f->nfrags = j--; /* stop list growth */
606     if (bi->nrd <= f->fi[j].nrd)
607 gwlarson 3.33 return(0); /* new one no better than discard */
608 gwlarson 3.31 }
609 gregl 3.19 #endif
610 gwlarson 3.32 if (j % FRAGBLK == 0) { /* more (or less) free list space */
611 gwlarson 3.26 register BEAMI *newp;
612 gregl 3.19 if (f->fi == NULL)
613 gwlarson 3.26 newp = (BEAMI *)malloc((j+FRAGBLK)*sizeof(BEAMI));
614 gregl 3.19 else
615 greg 3.43 newp = (BEAMI *)realloc((void *)f->fi,
616 gregl 3.19 (j+FRAGBLK)*sizeof(BEAMI));
617 gwlarson 3.26 if (newp == NULL) {
618     f->nfrags--; /* graceful failure */
619 gwlarson 3.33 return(0);
620 gwlarson 3.26 }
621     f->fi = newp;
622 gregl 3.19 }
623     for ( ; ; j--) { /* insert in descending list */
624     if (!j || bi->fo < f->fi[j-1].fo) {
625     f->fi[j].fo = bi->fo;
626     f->fi[j].nrd = bi->nrd;
627     break;
628     }
629 schorsch 3.51 *(f->fi+j) = *(f->fi+(j-1));
630 gregl 3.19 }
631     /* coalesce adjacent fragments */
632     /* successors never empty */
633     if (j && f->fi[j-1].fo == f->fi[j].fo + f->fi[j].nrd*sizeof(RAYVAL)) {
634     f->fi[j].nrd += f->fi[j-1].nrd;
635     f->fi[j-1].nrd = 0;
636     }
637     for (k = j+1; k < f->nfrags; k++) /* get non-empty predecessor */
638     if (f->fi[k].nrd) {
639     if (f->fi[j].fo == f->fi[k].fo +
640     f->fi[k].nrd*sizeof(RAYVAL)) {
641     f->fi[k].nrd += f->fi[j].nrd;
642     f->fi[j].nrd = 0;
643     }
644     break;
645     }
646 gwlarson 3.32 biglob(hp)->nrd -= bi->nrd; /* tell fragment it's free */
647     bi->nrd = 0;
648 greg 3.47 bi->fo = 0;
649 gwlarson 3.39 hdmarkdirty(hp, i); /* assume we'll reallocate */
650 gwlarson 3.33 return(1);
651 gregl 3.19 }
652    
653    
654 schorsch 3.55 extern int
655     hdfragOK( /* get fragment list status for file */
656     int fd,
657     int *listlen,
658     register int32 *listsiz
659     )
660 gwlarson 3.32 {
661     register struct fraglist *f;
662     register int i;
663    
664 schorsch 3.52 if ((fd < 0) | (fd >= nhdfragls) || !(f = &hdfragl[fd])->nlinks)
665 gwlarson 3.32 return(0); /* listless */
666     if (listlen != NULL)
667     *listlen = f->nfrags;
668     if (listsiz != NULL)
669     for (i = f->nfrags, *listsiz = 0; i--; )
670     *listsiz += f->fi[i].nrd;
671     #if MAXFRAGB
672     return(f->nfrags < MAXFRAGB*FRAGBLK);
673     #else
674     return(1); /* list never fills up */
675     #endif
676     }
677    
678    
679 greg 3.46 off_t
680 schorsch 3.55 hdallocfrag( /* allocate a file fragment */
681     int fd,
682     uint32 nrays
683     )
684 gregl 3.19 {
685     register struct fraglist *f;
686 gwlarson 3.33 register int j;
687 greg 3.46 off_t nfo;
688 gregl 3.19
689     if (nrays == 0)
690     return(-1L);
691 gwlarson 3.32 DCHECK(fd < 0 | fd >= nhdfragls || !hdfragl[fd].nlinks,
692     CONSISTENCY, "bad file descriptor in hdallocfrag");
693 gregl 3.19 f = &hdfragl[fd];
694 gwlarson 3.33 for (j = f->nfrags; j-- > 0; ) /* first fit algorithm */
695     if (f->fi[j].nrd >= nrays)
696     break;
697     if (j < 0) { /* no fragment -- extend file */
698 gregl 3.19 nfo = f->flen;
699     f->flen += nrays*sizeof(RAYVAL);
700     } else { /* else use fragment */
701 gwlarson 3.33 nfo = f->fi[j].fo;
702     f->fi[j].fo += nrays*sizeof(RAYVAL);
703     f->fi[j].nrd -= nrays;
704 gregl 3.19 }
705     return(nfo);
706     }
707    
708    
709 gregl 3.14 int
710 schorsch 3.55 hdsyncbeam( /* sync beam in memory with beam on disk */
711     register HOLO *hp,
712     register int i
713     )
714 gregl 3.1 {
715 gwlarson 3.39 int fragfreed;
716 greg 3.48 uint32 nrays;
717 gregl 3.19 unsigned int n;
718 greg 3.46 off_t nfo;
719 gregl 3.13 /* check file status */
720 gwlarson 3.41 if (hdfragl[hp->fd].writable <= 0)
721     return(hdfragl[hp->fd].writable);
722 gwlarson 3.32 DCHECK(i < 1 | i > nbeams(hp),
723     CONSISTENCY, "bad beam index in hdsyncbeam");
724 gregl 3.11 /* is current fragment OK? */
725 gregl 3.12 if (hp->bl[i] == NULL || (nrays = hp->bl[i]->nrm) == hp->bi[i].nrd)
726 gregl 3.1 return(0);
727 gwlarson 3.39 /* relinquish old fragment? */
728     fragfreed = hdfragflags&FF_WRITE && hp->bi[i].nrd && hdfreefrag(hp,i);
729 gregl 3.19 if (nrays) { /* get and write new fragment */
730     nfo = hdallocfrag(hp->fd, nrays);
731 gregl 3.11 errno = 0;
732 greg 3.53 if (lseek(hp->fd, nfo, SEEK_SET) < 0)
733 gregl 3.11 error(SYSTEM, "cannot seek on holodeck file");
734     n = hp->bl[i]->nrm * sizeof(RAYVAL);
735     if (write(hp->fd, (char *)hdbray(hp->bl[i]), n) != n) {
736 gwlarson 3.41 hdfragl[hp->fd].writable = -1;
737 gregl 3.18 hdsync(NULL, 0); /* sync directories */
738 gregl 3.12 error(SYSTEM, "write error in hdsyncbeam");
739 gregl 3.11 }
740 gregl 3.19 hp->bi[i].fo = nfo;
741     } else
742 greg 3.47 hp->bi[i].fo = 0;
743 gwlarson 3.34 biglob(hp)->nrd += nrays - hp->bi[i].nrd;
744     hp->bi[i].nrd = nrays;
745 gwlarson 3.39 if (!fragfreed)
746     hdmarkdirty(hp, i); /* need to flag dir. ent. */
747 gregl 3.1 return(1);
748     }
749    
750    
751 schorsch 3.55 extern int
752     hdfreebeam( /* free beam, writing if dirty */
753     register HOLO *hp,
754     register int i
755     )
756 gregl 3.1 {
757 gregl 3.11 int nchanged;
758 gregl 3.1
759     if (hp == NULL) { /* clear all holodecks */
760     nchanged = 0;
761     for (i = 0; hdlist[i] != NULL; i++)
762     nchanged += hdfreebeam(hdlist[i], 0);
763     return(nchanged);
764     }
765 gwlarson 3.41 if (hdfragl[hp->fd].writable < 0) /* check for file error */
766 gregl 3.13 return(0);
767 gregl 3.1 if (i == 0) { /* clear entire holodeck */
768 gwlarson 3.36 if (blglob(hp)->nrm == 0)
769     return(0); /* already clear */
770 gregl 3.1 nchanged = 0;
771 gregl 3.10 for (i = nbeams(hp); i > 0; i--)
772     if (hp->bl[i] != NULL)
773     nchanged += hdfreebeam(hp, i);
774 gwlarson 3.36 DCHECK(blglob(hp)->nrm != 0,
775     CONSISTENCY, "bad beam count in hdfreebeam");
776 gregl 3.1 return(nchanged);
777     }
778 gwlarson 3.32 DCHECK(i < 1 | i > nbeams(hp),
779     CONSISTENCY, "bad beam index to hdfreebeam");
780 gregl 3.1 if (hp->bl[i] == NULL)
781     return(0);
782     /* check for additions */
783     nchanged = hp->bl[i]->nrm - hp->bi[i].nrd;
784 gregl 3.11 if (nchanged)
785 gregl 3.12 hdsyncbeam(hp, i); /* write new fragment */
786 gregl 3.1 blglob(hp)->nrm -= hp->bl[i]->nrm;
787 greg 3.42 free((void *)hp->bl[i]); /* free memory */
788 gregl 3.1 hp->bl[i] = NULL;
789     return(nchanged);
790     }
791    
792    
793 schorsch 3.55 extern int
794     hdkillbeam( /* delete beam from holodeck */
795     register HOLO *hp,
796     register int i
797     )
798 gregl 3.10 {
799 gregl 3.11 int nchanged;
800 gregl 3.10
801     if (hp == NULL) { /* clobber all holodecks */
802     nchanged = 0;
803     for (i = 0; hdlist[i] != NULL; i++)
804     nchanged += hdkillbeam(hdlist[i], 0);
805     return(nchanged);
806     }
807     if (i == 0) { /* clobber entire holodeck */
808 schorsch 3.52 if ((biglob(hp)->nrd == 0) & (blglob(hp)->nrm == 0))
809 gwlarson 3.36 return(0); /* already empty */
810     nchanged = 0;
811 gregl 3.10 nchanged = 0;
812     for (i = nbeams(hp); i > 0; i--)
813     if (hp->bi[i].nrd > 0 || hp->bl[i] != NULL)
814     nchanged += hdkillbeam(hp, i);
815 gwlarson 3.32 DCHECK(biglob(hp)->nrd != 0 | blglob(hp)->nrm != 0,
816     CONSISTENCY, "bad beam count in hdkillbeam");
817 gregl 3.10 return(nchanged);
818     }
819 gwlarson 3.41 DCHECK(i < 1 | i > nbeams(hp), CONSISTENCY,
820     "bad beam index to hdkillbeam");
821     DCHECK(!hdfragl[hp->fd].writable, CONSISTENCY,
822     "hdkillbeam called on read-only holodeck");
823 gregl 3.10 if (hp->bl[i] != NULL) { /* free memory */
824     blglob(hp)->nrm -= nchanged = hp->bl[i]->nrm;
825 greg 3.42 free((void *)hp->bl[i]);
826 gwlarson 3.39 hp->bl[i] = NULL;
827 gregl 3.10 } else
828     nchanged = hp->bi[i].nrd;
829 gwlarson 3.39 if (hp->bi[i].nrd && !(hdfragflags&FF_KILL && hdfreefrag(hp,i))) {
830     biglob(hp)->nrd -= hp->bi[i].nrd; /* free failed */
831     hp->bi[i].nrd = 0;
832 greg 3.47 hp->bi[i].fo = 0;
833 gwlarson 3.39 hdmarkdirty(hp, i);
834 gregl 3.10 }
835     return(nchanged);
836     }
837    
838    
839 gregl 3.14 int
840 schorsch 3.55 hdlrulist( /* add beams from holodeck to LRU list */
841     register HDBEAMI *hb, /* beam list */
842     int nents, /* current list length */
843     int n, /* maximum list length */
844     register HOLO *hp /* section we're adding from */
845     )
846 gregl 3.1 {
847     register int i, j;
848     /* insert each beam from hp */
849 gregl 3.21 for (i = 1; i <= nbeams(hp); i++) {
850 gregl 3.1 if (hp->bl[i] == NULL) /* check if loaded */
851     continue;
852 gregl 3.14 #if 0
853     if (hp->bl[i]->tick == hdclock) /* preempt swap? */
854     continue;
855     #endif
856     if ((j = ++nents) >= n) /* grow list if we can */
857 gregl 3.1 nents--;
858     for ( ; ; ) { /* bubble into place */
859     if (!--j || hp->bl[i]->tick >=
860 gregl 3.14 hb[j-1].h->bl[hb[j-1].b]->tick) {
861     hb[j].h = hp;
862     hb[j].b = i;
863 gregl 3.1 break;
864     }
865 schorsch 3.51 *(hb+j) = *(hb+(j-1));
866 gregl 3.1 }
867     }
868 gregl 3.14 return(nents); /* return new list length */
869 gregl 3.1 }
870    
871    
872 gregl 3.14 int
873 schorsch 3.55 hdfreecache( /* free up cache space, writing changes */
874     int pct, /* maximum percentage to free */
875     register HOLO *honly /* NULL means check all */
876     )
877 gregl 3.1 {
878 gregl 3.14 HDBEAMI hb[FREEBEAMS];
879 gregl 3.1 int freetarget;
880 gregl 3.14 int n;
881 gregl 3.1 register int i;
882 gwlarson 3.25 #ifdef DEBUG
883     unsigned membefore;
884    
885     membefore = hdmemuse(0);
886     #endif
887 gregl 3.1 /* compute free target */
888     freetarget = (honly != NULL) ? blglob(honly)->nrm :
889     hdmemuse(0)/sizeof(RAYVAL) ;
890     freetarget = freetarget*pct/100;
891 gregl 3.14 if (freetarget <= 0)
892     return(0);
893 gregl 3.1 /* find least recently used */
894 gregl 3.14 n = 0;
895 gregl 3.1 if (honly != NULL)
896 gregl 3.14 n = hdlrulist(hb, n, FREEBEAMS, honly);
897 gregl 3.1 else
898     for (i = 0; hdlist[i] != NULL; i++)
899 gregl 3.14 n = hdlrulist(hb, n, FREEBEAMS, hdlist[i]);
900 gregl 3.1 /* free LRU beams */
901 gregl 3.14 for (i = 0; i < n; i++) {
902     hdfreebeam(hb[i].h, hb[i].b);
903     if ((freetarget -= hb[i].h->bi[hb[i].b].nrd) <= 0)
904 gregl 3.1 break;
905     }
906 gregl 3.12 hdsync(honly, 0); /* synchronize directories as necessary */
907 gwlarson 3.25 #ifdef DEBUG
908     sprintf(errmsg,
909     "%dK before, %dK after hdfreecache (%dK total), %d rays short\n",
910     membefore>>10, hdmemuse(0)>>10, hdmemuse(1)>>10, freetarget);
911     wputs(errmsg);
912     #endif
913 gregl 3.14 return(-freetarget); /* return how far past goal we went */
914 gregl 3.1 }
915    
916    
917 schorsch 3.55 extern void
918     hddone( /* clean up holodeck section and free */
919     register HOLO *hp /* NULL means clean up all */
920     )
921 gregl 3.1 {
922     register int i;
923    
924     if (hp == NULL) { /* NULL means clean up everything */
925     while (hdlist[0] != NULL)
926     hddone(hdlist[0]);
927 greg 3.42 free((void *)hdfragl);
928 gwlarson 3.24 hdfragl = NULL; nhdfragls = 0;
929 gregl 3.1 return;
930     }
931     /* flush all data and free memory */
932 gwlarson 3.37 hdflush(hp);
933 gregl 3.1 /* release fragment resources */
934     hdrelease(hp->fd);
935     /* remove hp from active list */
936     for (i = 0; hdlist[i] != NULL; i++)
937     if (hdlist[i] == hp) {
938     while ((hdlist[i] = hdlist[i+1]) != NULL)
939     i++;
940     break;
941     }
942 greg 3.42 free((void *)hp->bl); /* free beam list */
943     free((void *)hp); /* free holodeck struct */
944 gregl 3.1 }