rf_reconmap.c revision 1.1 1 1.1 oster /* $NetBSD: rf_reconmap.c,v 1.1 1998/11/13 04:20:33 oster Exp $ */
2 1.1 oster /*
3 1.1 oster * Copyright (c) 1995 Carnegie-Mellon University.
4 1.1 oster * All rights reserved.
5 1.1 oster *
6 1.1 oster * Author: Mark Holland
7 1.1 oster *
8 1.1 oster * Permission to use, copy, modify and distribute this software and
9 1.1 oster * its documentation is hereby granted, provided that both the copyright
10 1.1 oster * notice and this permission notice appear in all copies of the
11 1.1 oster * software, derivative works or modified versions, and any portions
12 1.1 oster * thereof, and that both notices appear in supporting documentation.
13 1.1 oster *
14 1.1 oster * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
15 1.1 oster * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
16 1.1 oster * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
17 1.1 oster *
18 1.1 oster * Carnegie Mellon requests users of this software to return to
19 1.1 oster *
20 1.1 oster * Software Distribution Coordinator or Software.Distribution (at) CS.CMU.EDU
21 1.1 oster * School of Computer Science
22 1.1 oster * Carnegie Mellon University
23 1.1 oster * Pittsburgh PA 15213-3890
24 1.1 oster *
25 1.1 oster * any improvements or extensions that they make and grant Carnegie the
26 1.1 oster * rights to redistribute these changes.
27 1.1 oster */
28 1.1 oster
29 1.1 oster /*************************************************************************
30 1.1 oster * rf_reconmap.c
31 1.1 oster *
32 1.1 oster * code to maintain a map of what sectors have/have not been reconstructed
33 1.1 oster *
34 1.1 oster *************************************************************************/
35 1.1 oster
36 1.1 oster /* :
37 1.1 oster * Log: rf_reconmap.c,v
38 1.1 oster * Revision 1.23 1996/07/27 23:36:08 jimz
39 1.1 oster * Solaris port of simulator
40 1.1 oster *
41 1.1 oster * Revision 1.22 1996/07/15 17:22:18 jimz
42 1.1 oster * nit-pick code cleanup
43 1.1 oster * resolve stdlib problems on DEC OSF
44 1.1 oster *
45 1.1 oster * Revision 1.21 1996/06/17 14:38:33 jimz
46 1.1 oster * properly #if out RF_DEMO code
47 1.1 oster * fix bug in MakeConfig that was causing weird behavior
48 1.1 oster * in configuration routines (config was not zeroed at start)
49 1.1 oster * clean up genplot handling of stacks
50 1.1 oster *
51 1.1 oster * Revision 1.20 1996/06/09 02:36:46 jimz
52 1.1 oster * lots of little crufty cleanup- fixup whitespace
53 1.1 oster * issues, comment #ifdefs, improve typing in some
54 1.1 oster * places (esp size-related)
55 1.1 oster *
56 1.1 oster * Revision 1.19 1996/06/07 21:33:04 jimz
57 1.1 oster * begin using consistent types for sector numbers,
58 1.1 oster * stripe numbers, row+col numbers, recon unit numbers
59 1.1 oster *
60 1.1 oster * Revision 1.18 1996/06/05 18:06:02 jimz
61 1.1 oster * Major code cleanup. The Great Renaming is now done.
62 1.1 oster * Better modularity. Better typing. Fixed a bunch of
63 1.1 oster * synchronization bugs. Made a lot of global stuff
64 1.1 oster * per-desc or per-array. Removed dead code.
65 1.1 oster *
66 1.1 oster * Revision 1.17 1996/05/31 22:26:54 jimz
67 1.1 oster * fix a lot of mapping problems, memory allocation problems
68 1.1 oster * found some weird lock issues, fixed 'em
69 1.1 oster * more code cleanup
70 1.1 oster *
71 1.1 oster * Revision 1.16 1996/05/30 23:22:16 jimz
72 1.1 oster * bugfixes of serialization, timing problems
73 1.1 oster * more cleanup
74 1.1 oster *
75 1.1 oster * Revision 1.15 1996/05/27 18:56:37 jimz
76 1.1 oster * more code cleanup
77 1.1 oster * better typing
78 1.1 oster * compiles in all 3 environments
79 1.1 oster *
80 1.1 oster * Revision 1.14 1996/05/24 22:17:04 jimz
81 1.1 oster * continue code + namespace cleanup
82 1.1 oster * typed a bunch of flags
83 1.1 oster *
84 1.1 oster * Revision 1.13 1996/05/24 04:40:57 jimz
85 1.1 oster * don't do recon meter demo stuff in kernel
86 1.1 oster *
87 1.1 oster * Revision 1.12 1996/05/23 00:33:23 jimz
88 1.1 oster * code cleanup: move all debug decls to rf_options.c, all extern
89 1.1 oster * debug decls to rf_options.h, all debug vars preceded by rf_
90 1.1 oster *
91 1.1 oster * Revision 1.11 1996/05/20 16:14:50 jimz
92 1.1 oster * switch to rf_{mutex,cond}_{init,destroy}
93 1.1 oster *
94 1.1 oster * Revision 1.10 1996/05/18 19:51:34 jimz
95 1.1 oster * major code cleanup- fix syntax, make some types consistent,
96 1.1 oster * add prototypes, clean out dead code, et cetera
97 1.1 oster *
98 1.1 oster * Revision 1.9 1995/12/12 18:10:06 jimz
99 1.1 oster * MIN -> RF_MIN, MAX -> RF_MAX, ASSERT -> RF_ASSERT
100 1.1 oster * fix 80-column brain damage in comments
101 1.1 oster *
102 1.1 oster * Revision 1.8 1995/12/06 15:05:23 root
103 1.1 oster * added copyright info
104 1.1 oster *
105 1.1 oster */
106 1.1 oster
107 1.1 oster #include "rf_raid.h"
108 1.1 oster #include <sys/time.h>
109 1.1 oster #include "rf_general.h"
110 1.1 oster #include "rf_utils.h"
111 1.1 oster #if RF_DEMO > 0
112 1.1 oster #include "rf_demo.h"
113 1.1 oster #endif /* RF_DEMO > 0 */
114 1.1 oster #include "rf_sys.h"
115 1.1 oster
116 1.1 oster /* special pointer values indicating that a reconstruction unit
117 1.1 oster * has been either totally reconstructed or not at all. Both
118 1.1 oster * are illegal pointer values, so you have to be careful not to
119 1.1 oster * dereference through them. RU_NOTHING must be zero, since
120 1.1 oster * MakeReconMap uses bzero to initialize the structure. These are used
121 1.1 oster * only at the head of the list.
122 1.1 oster */
123 1.1 oster #define RU_ALL ((RF_ReconMapListElem_t *) -1)
124 1.1 oster #define RU_NOTHING ((RF_ReconMapListElem_t *) 0)
125 1.1 oster
126 1.1 oster /* used to mark the end of the list */
127 1.1 oster #define RU_NIL ((RF_ReconMapListElem_t *) 0)
128 1.1 oster
129 1.1 oster
130 1.1 oster static void compact_stat_entry(RF_Raid_t *raidPtr, RF_ReconMap_t *mapPtr,
131 1.1 oster int i);
132 1.1 oster static void crunch_list(RF_ReconMap_t *mapPtr, RF_ReconMapListElem_t *listPtr);
133 1.1 oster static RF_ReconMapListElem_t *MakeReconMapListElem(RF_SectorNum_t startSector,
134 1.1 oster RF_SectorNum_t stopSector, RF_ReconMapListElem_t *next);
135 1.1 oster static void FreeReconMapListElem(RF_ReconMap_t *mapPtr,
136 1.1 oster RF_ReconMapListElem_t *p);
137 1.1 oster static void update_size(RF_ReconMap_t *mapPtr, int size);
138 1.1 oster static void PrintList(RF_ReconMapListElem_t *listPtr);
139 1.1 oster
140 1.1 oster /*-----------------------------------------------------------------------------
141 1.1 oster *
142 1.1 oster * Creates and initializes new Reconstruction map
143 1.1 oster *
144 1.1 oster *-----------------------------------------------------------------------------*/
145 1.1 oster
146 1.1 oster RF_ReconMap_t *rf_MakeReconMap(raidPtr, ru_sectors, disk_sectors, spareUnitsPerDisk)
147 1.1 oster RF_Raid_t *raidPtr;
148 1.1 oster RF_SectorCount_t ru_sectors; /* size of reconstruction unit in sectors */
149 1.1 oster RF_SectorCount_t disk_sectors; /* size of disk in sectors */
150 1.1 oster RF_ReconUnitCount_t spareUnitsPerDisk; /* zero unless distributed sparing */
151 1.1 oster {
152 1.1 oster RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
153 1.1 oster RF_ReconUnitCount_t num_rus = layoutPtr->stripeUnitsPerDisk / layoutPtr->SUsPerRU;
154 1.1 oster RF_ReconMap_t *p;
155 1.1 oster int rc;
156 1.1 oster
157 1.1 oster RF_Malloc(p, sizeof(RF_ReconMap_t), (RF_ReconMap_t *));
158 1.1 oster p->sectorsPerReconUnit = ru_sectors;
159 1.1 oster p->sectorsInDisk = disk_sectors;
160 1.1 oster
161 1.1 oster p->totalRUs = num_rus;
162 1.1 oster p->spareRUs = spareUnitsPerDisk;
163 1.1 oster p->unitsLeft = num_rus - spareUnitsPerDisk;
164 1.1 oster
165 1.1 oster RF_Malloc(p->status, num_rus * sizeof(RF_ReconMapListElem_t *), (RF_ReconMapListElem_t **));
166 1.1 oster RF_ASSERT(p->status != (RF_ReconMapListElem_t **) NULL);
167 1.1 oster
168 1.1 oster (void) bzero((char *) p->status, num_rus * sizeof(RF_ReconMapListElem_t *));
169 1.1 oster
170 1.1 oster p->size = sizeof(RF_ReconMap_t) + num_rus * sizeof(RF_ReconMapListElem_t *);
171 1.1 oster p->maxSize = p->size;
172 1.1 oster
173 1.1 oster rc = rf_mutex_init(&p->mutex);
174 1.1 oster if (rc) {
175 1.1 oster RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__,
176 1.1 oster __LINE__, rc);
177 1.1 oster RF_Free(p->status, num_rus * sizeof(RF_ReconMapListElem_t *));
178 1.1 oster RF_Free(p, sizeof(RF_ReconMap_t));
179 1.1 oster return(NULL);
180 1.1 oster }
181 1.1 oster return(p);
182 1.1 oster }
183 1.1 oster
184 1.1 oster
185 1.1 oster /*-----------------------------------------------------------------------------
186 1.1 oster *
187 1.1 oster * marks a new set of sectors as reconstructed. All the possible mergings get
188 1.1 oster * complicated. To simplify matters, the approach I take is to just dump
189 1.1 oster * something into the list, and then clean it up (i.e. merge elements and
190 1.1 oster * eliminate redundant ones) in a second pass over the list (compact_stat_entry()).
191 1.1 oster * Not 100% efficient, since a structure can be allocated and then immediately
192 1.1 oster * freed, but it keeps this code from becoming (more of) a nightmare of
193 1.1 oster * special cases. The only thing that compact_stat_entry() assumes is that the
194 1.1 oster * list is sorted by startSector, and so this is the only condition I maintain
195 1.1 oster * here. (MCH)
196 1.1 oster *
197 1.1 oster *-----------------------------------------------------------------------------*/
198 1.1 oster
199 1.1 oster void rf_ReconMapUpdate(raidPtr, mapPtr, startSector, stopSector)
200 1.1 oster RF_Raid_t *raidPtr;
201 1.1 oster RF_ReconMap_t *mapPtr;
202 1.1 oster RF_SectorNum_t startSector;
203 1.1 oster RF_SectorNum_t stopSector;
204 1.1 oster {
205 1.1 oster RF_SectorCount_t sectorsPerReconUnit = mapPtr->sectorsPerReconUnit;
206 1.1 oster RF_SectorNum_t i, first_in_RU, last_in_RU;
207 1.1 oster RF_ReconMapListElem_t *p, *pt;
208 1.1 oster
209 1.1 oster RF_LOCK_MUTEX(mapPtr->mutex);
210 1.1 oster RF_ASSERT(startSector >=0 && stopSector < mapPtr->sectorsInDisk && stopSector > startSector);
211 1.1 oster
212 1.1 oster while (startSector <= stopSector) {
213 1.1 oster i = startSector/mapPtr->sectorsPerReconUnit;
214 1.1 oster first_in_RU = i*sectorsPerReconUnit;
215 1.1 oster last_in_RU = first_in_RU + sectorsPerReconUnit -1 ;
216 1.1 oster p = mapPtr->status[i];
217 1.1 oster if (p!=RU_ALL) {
218 1.1 oster if (p==RU_NOTHING || p->startSector > startSector ) { /* insert at front of list */
219 1.1 oster
220 1.1 oster mapPtr->status[i] = MakeReconMapListElem(startSector, RF_MIN(stopSector,last_in_RU), (p==RU_NOTHING) ? NULL : p);
221 1.1 oster update_size(mapPtr, sizeof(RF_ReconMapListElem_t));
222 1.1 oster
223 1.1 oster } else { /* general case */
224 1.1 oster do { /* search for place to insert */
225 1.1 oster pt = p; p = p->next;
226 1.1 oster } while (p && (p->startSector < startSector));
227 1.1 oster pt->next = MakeReconMapListElem(startSector,RF_MIN(stopSector,last_in_RU),p);
228 1.1 oster update_size(mapPtr, sizeof(RF_ReconMapListElem_t));
229 1.1 oster }
230 1.1 oster compact_stat_entry(raidPtr, mapPtr, i);
231 1.1 oster }
232 1.1 oster startSector = RF_MIN(stopSector, last_in_RU) +1;
233 1.1 oster }
234 1.1 oster RF_UNLOCK_MUTEX(mapPtr->mutex);
235 1.1 oster }
236 1.1 oster
237 1.1 oster
238 1.1 oster
239 1.1 oster /*-----------------------------------------------------------------------------
240 1.1 oster *
241 1.1 oster * performs whatever list compactions can be done, and frees any space
242 1.1 oster * that is no longer necessary. Assumes only that the list is sorted
243 1.1 oster * by startSector. crunch_list() compacts a single list as much as possible,
244 1.1 oster * and the second block of code deletes the entire list if possible.
245 1.1 oster * crunch_list() is also called from MakeReconMapAccessList().
246 1.1 oster *
247 1.1 oster * When a recon unit is detected to be fully reconstructed, we set the
248 1.1 oster * corresponding bit in the parity stripe map so that the head follow
249 1.1 oster * code will not select this parity stripe again. This is redundant (but
250 1.1 oster * harmless) when compact_stat_entry is called from the reconstruction code,
251 1.1 oster * but necessary when called from the user-write code.
252 1.1 oster *
253 1.1 oster *-----------------------------------------------------------------------------*/
254 1.1 oster
255 1.1 oster static void compact_stat_entry(raidPtr, mapPtr, i)
256 1.1 oster RF_Raid_t *raidPtr;
257 1.1 oster RF_ReconMap_t *mapPtr;
258 1.1 oster int i;
259 1.1 oster {
260 1.1 oster RF_SectorCount_t sectorsPerReconUnit = mapPtr->sectorsPerReconUnit;
261 1.1 oster RF_ReconMapListElem_t *p = mapPtr->status[i];
262 1.1 oster
263 1.1 oster crunch_list(mapPtr, p);
264 1.1 oster
265 1.1 oster if ((p->startSector == i*sectorsPerReconUnit) &&
266 1.1 oster (p->stopSector == i*sectorsPerReconUnit +sectorsPerReconUnit -1)) {
267 1.1 oster mapPtr->status[i] = RU_ALL;
268 1.1 oster mapPtr->unitsLeft--;
269 1.1 oster FreeReconMapListElem(mapPtr,p);
270 1.1 oster }
271 1.1 oster }
272 1.1 oster
273 1.1 oster static void crunch_list(mapPtr, listPtr)
274 1.1 oster RF_ReconMap_t *mapPtr;
275 1.1 oster RF_ReconMapListElem_t *listPtr;
276 1.1 oster {
277 1.1 oster RF_ReconMapListElem_t *pt, *p = listPtr;
278 1.1 oster
279 1.1 oster if (!p) return;
280 1.1 oster pt = p; p = p->next;
281 1.1 oster while (p) {
282 1.1 oster if (pt->stopSector >= p->startSector-1) {
283 1.1 oster pt->stopSector = RF_MAX(pt->stopSector, p->stopSector);
284 1.1 oster pt->next = p->next;
285 1.1 oster FreeReconMapListElem(mapPtr, p);
286 1.1 oster p = pt->next;
287 1.1 oster }
288 1.1 oster else {
289 1.1 oster pt = p;
290 1.1 oster p = p->next;
291 1.1 oster }
292 1.1 oster }
293 1.1 oster }
294 1.1 oster
295 1.1 oster /*-----------------------------------------------------------------------------
296 1.1 oster *
297 1.1 oster * Allocate and fill a new list element
298 1.1 oster *
299 1.1 oster *-----------------------------------------------------------------------------*/
300 1.1 oster
301 1.1 oster static RF_ReconMapListElem_t *MakeReconMapListElem(
302 1.1 oster RF_SectorNum_t startSector,
303 1.1 oster RF_SectorNum_t stopSector,
304 1.1 oster RF_ReconMapListElem_t *next)
305 1.1 oster {
306 1.1 oster RF_ReconMapListElem_t *p;
307 1.1 oster
308 1.1 oster RF_Malloc(p, sizeof(RF_ReconMapListElem_t), (RF_ReconMapListElem_t *));
309 1.1 oster if (p == NULL)
310 1.1 oster return(NULL);
311 1.1 oster p->startSector = startSector;
312 1.1 oster p->stopSector = stopSector;
313 1.1 oster p->next = next;
314 1.1 oster return(p);
315 1.1 oster }
316 1.1 oster
317 1.1 oster /*-----------------------------------------------------------------------------
318 1.1 oster *
319 1.1 oster * Free a list element
320 1.1 oster *
321 1.1 oster *-----------------------------------------------------------------------------*/
322 1.1 oster
323 1.1 oster static void FreeReconMapListElem(mapPtr,p)
324 1.1 oster RF_ReconMap_t *mapPtr;
325 1.1 oster RF_ReconMapListElem_t *p;
326 1.1 oster {
327 1.1 oster int delta;
328 1.1 oster
329 1.1 oster if (mapPtr) {
330 1.1 oster delta = 0 - (int)sizeof(RF_ReconMapListElem_t);
331 1.1 oster update_size(mapPtr, delta);
332 1.1 oster }
333 1.1 oster RF_Free(p, sizeof(*p));
334 1.1 oster }
335 1.1 oster
336 1.1 oster /*-----------------------------------------------------------------------------
337 1.1 oster *
338 1.1 oster * Free an entire status structure. Inefficient, but can be called at any time.
339 1.1 oster *
340 1.1 oster *-----------------------------------------------------------------------------*/
341 1.1 oster void rf_FreeReconMap(mapPtr)
342 1.1 oster RF_ReconMap_t *mapPtr;
343 1.1 oster {
344 1.1 oster RF_ReconMapListElem_t *p, *q;
345 1.1 oster RF_ReconUnitCount_t numRUs;
346 1.1 oster RF_ReconUnitNum_t i;
347 1.1 oster
348 1.1 oster numRUs = mapPtr->sectorsInDisk / mapPtr->sectorsPerReconUnit;
349 1.1 oster if (mapPtr->sectorsInDisk % mapPtr->sectorsPerReconUnit)
350 1.1 oster numRUs++;
351 1.1 oster
352 1.1 oster for (i=0; i<numRUs; i++) {
353 1.1 oster p = mapPtr->status[i];
354 1.1 oster while (p != RU_NOTHING && p != RU_ALL) {
355 1.1 oster q = p; p = p->next;
356 1.1 oster RF_Free(q, sizeof(*q));
357 1.1 oster }
358 1.1 oster }
359 1.1 oster rf_mutex_destroy(&mapPtr->mutex);
360 1.1 oster RF_Free(mapPtr->status, mapPtr->totalRUs * sizeof(RF_ReconMapListElem_t *));
361 1.1 oster RF_Free(mapPtr, sizeof(RF_ReconMap_t));
362 1.1 oster }
363 1.1 oster
364 1.1 oster /*-----------------------------------------------------------------------------
365 1.1 oster *
366 1.1 oster * returns nonzero if the indicated RU has been reconstructed already
367 1.1 oster *
368 1.1 oster *---------------------------------------------------------------------------*/
369 1.1 oster
370 1.1 oster int rf_CheckRUReconstructed(mapPtr, startSector)
371 1.1 oster RF_ReconMap_t *mapPtr;
372 1.1 oster RF_SectorNum_t startSector;
373 1.1 oster {
374 1.1 oster RF_ReconMapListElem_t *l; /* used for searching */
375 1.1 oster RF_ReconUnitNum_t i;
376 1.1 oster
377 1.1 oster i = startSector / mapPtr->sectorsPerReconUnit;
378 1.1 oster l = mapPtr->status[i];
379 1.1 oster return( (l == RU_ALL) ? 1 : 0 );
380 1.1 oster }
381 1.1 oster
382 1.1 oster RF_ReconUnitCount_t rf_UnitsLeftToReconstruct(mapPtr)
383 1.1 oster RF_ReconMap_t *mapPtr;
384 1.1 oster {
385 1.1 oster RF_ASSERT(mapPtr != NULL);
386 1.1 oster return( mapPtr->unitsLeft );
387 1.1 oster }
388 1.1 oster
389 1.1 oster /* updates the size fields of a status descriptor */
390 1.1 oster static void update_size(mapPtr, size)
391 1.1 oster RF_ReconMap_t *mapPtr;
392 1.1 oster int size;
393 1.1 oster {
394 1.1 oster mapPtr->size += size;
395 1.1 oster mapPtr->maxSize = RF_MAX(mapPtr->size, mapPtr->maxSize);
396 1.1 oster }
397 1.1 oster
398 1.1 oster static void PrintList(listPtr)
399 1.1 oster RF_ReconMapListElem_t *listPtr;
400 1.1 oster {
401 1.1 oster while (listPtr) {
402 1.1 oster printf("%d,%d -> ",(int)listPtr->startSector,(int)listPtr->stopSector);
403 1.1 oster listPtr = listPtr->next;
404 1.1 oster }
405 1.1 oster printf("\n");
406 1.1 oster }
407 1.1 oster
408 1.1 oster void rf_PrintReconMap(raidPtr, mapPtr, frow, fcol)
409 1.1 oster RF_Raid_t *raidPtr;
410 1.1 oster RF_ReconMap_t *mapPtr;
411 1.1 oster RF_RowCol_t frow;
412 1.1 oster RF_RowCol_t fcol;
413 1.1 oster {
414 1.1 oster RF_ReconUnitCount_t numRUs;
415 1.1 oster RF_ReconMapListElem_t *p;
416 1.1 oster RF_ReconUnitNum_t i;
417 1.1 oster
418 1.1 oster numRUs = mapPtr->totalRUs;
419 1.1 oster if (mapPtr->sectorsInDisk % mapPtr->sectorsPerReconUnit)
420 1.1 oster numRUs++;
421 1.1 oster
422 1.1 oster for (i=0; i<numRUs; i++) {
423 1.1 oster p = mapPtr->status[i];
424 1.1 oster if (p==RU_ALL) /*printf("[%d] ALL\n",i)*/;
425 1.1 oster else if (p == RU_NOTHING) {
426 1.1 oster printf("%d: Unreconstructed\n",i);
427 1.1 oster } else {
428 1.1 oster printf("%d: ", i);
429 1.1 oster PrintList(p);
430 1.1 oster }
431 1.1 oster }
432 1.1 oster }
433 1.1 oster
434 1.1 oster void rf_PrintReconSchedule(mapPtr, starttime)
435 1.1 oster RF_ReconMap_t *mapPtr;
436 1.1 oster struct timeval *starttime;
437 1.1 oster {
438 1.1 oster static int old_pctg = -1;
439 1.1 oster struct timeval tv, diff;
440 1.1 oster int new_pctg;
441 1.1 oster
442 1.1 oster new_pctg = 100 - (rf_UnitsLeftToReconstruct(mapPtr) * 100 / mapPtr->totalRUs);
443 1.1 oster if (new_pctg != old_pctg) {
444 1.1 oster RF_GETTIME(tv);
445 1.1 oster RF_TIMEVAL_DIFF(starttime, &tv, &diff);
446 1.1 oster #if RF_DEMO > 0
447 1.1 oster if (rf_demoMode) {
448 1.1 oster rf_update_recon_meter(new_pctg);
449 1.1 oster }
450 1.1 oster else {
451 1.1 oster printf("%d %d.%06d\n",new_pctg, diff.tv_sec, diff.tv_usec);
452 1.1 oster }
453 1.1 oster #else /* RF_DEMO > 0 */
454 1.1 oster printf("%d %d.%06d\n",(int)new_pctg, (int)diff.tv_sec, (int)diff.tv_usec);
455 1.1 oster #endif /* RF_DEMO > 0 */
456 1.1 oster old_pctg = new_pctg;
457 1.1 oster }
458 1.1 oster }
459