* rf_reconstruct.c: adopt nilkas' suggestion regard statics and

__inline__ - this is a proof of concept and will cover the raidframe
source as a whole over coming updates. Update namespace of function to
prefix with rf_ - comments again welcome.

* overall: rework the macros in rf_etimer.h and the resultant changes
to their use to count microseconds and not clock ticks. Restore the code
in rf_revent.c to a similar strcuture to before the previous commit,
and use the system timers to govern resource usage.

Tested with local i386/IDE and the reconstruction of a disk in my
array - performance has improved for reconstruction at no noticable
CPU cost.

1 files changed, 28 insertions, 41 deletions

diff --git a/sys/dev/raidframe/rf_etimer.h b/sys/dev/raidframe/rf_etimer.h
index 2033b9b46c6..826744a316f 100644
--- a/sys/dev/raidframe/rf_etimer.h
+++ b/sys/dev/raidframe/rf_etimer.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: rf_etimer.h,v 1.2 1999/02/16 00:02:43 niklas Exp $	*/
+/*	$OpenBSD: rf_etimer.h,v 1.3 1999/08/03 13:56:37 peter Exp $	*/
 /*	$NetBSD: rf_etimer.h,v 1.3 1999/02/05 00:06:11 oster Exp $	*/
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
@@ -27,57 +27,44 @@
  * rights to redistribute these changes.
  */
 
-/* rf_etimer.h -- header file for code related to accurate timing
- * This code currently assumes that the elapsed time between START_TIMER
- * and START_TIMER is less than the period of the cycle counter.  This
- * means the events you want to time must be less than:
- *        clock speed               max time
- *        ----------                --------
- *           175 MHz                 24 sec
- *           150 MHz                 28 sec
- *           125 MHz                 34 sec
- *
- *
- */
-
-
 #ifndef _RF__RF_TIMER_H_
 #define _RF__RF_TIMER_H_
 
 #include "rf_options.h"
+#include "rf_utils.h"
 
-extern unsigned int rpcc(void);
-#define rf_read_cycle_counter rpcc
-
-#define RF_DEF_TIMER_MAX_VAL            0xFFFFFFFF
-
-typedef struct RF_EtimerVal_s {
-	unsigned ccnt;		/* cycle count */
-}       RF_EtimerVal_t;
+#include <sys/time.h>
+#include <sys/kernel.h>
 
 struct RF_Etimer_s {
-	RF_EtimerVal_t st;
-	RF_EtimerVal_t et;
-	unsigned long ticks;	/* elapsed time in ticks */
+	struct timeval st;
+	struct timeval et;
+	struct timeval diff;
 };
 
-extern long rf_timer_max_val;
-extern long rf_timer_ticks_per_second;
-extern unsigned long rf_timer_ticks_per_usec;
+#define RF_ETIMER_START(_t_) 					\
+		{						\
+			int s;					\
+			bzero(&(_t_), sizeof (_t_));		\
+			s = splclock();				\
+			(_t_).st = mono_time;			\
+			splx(s);				\
+		}
 
-#define RF_ETIMER_TICKS2US(_tcks_)  ( (_tcks_) / rf_timer_ticks_per_usec )
-#define RF_ETIMER_START(_t_)  { (_t_).st.ccnt = rf_read_cycle_counter(); }
-#define RF_ETIMER_STOP(_t_)   { (_t_).et.ccnt = rf_read_cycle_counter(); }
-#define RF_ETIMER_EVAL(_t_) { \
-	if ((_t_).st.ccnt < (_t_).et.ccnt) \
-		(_t_).ticks = (_t_).et.ccnt - (_t_).st.ccnt; \
-	else \
-		(_t_).ticks = rf_timer_max_val - ((_t_).st.ccnt - (_t_).et.ccnt); \
-}
+#define RF_ETIMER_STOP(_t_) 					\
+		{						\
+			int s;					\
+			s = splclock();				\
+			(_t_).et = mono_time;			\
+			splx(s);				\
+		}
 
-#define RF_ETIMER_VAL_TICKS(_t_)  ((_t_).ticks)
-#define RF_ETIMER_VAL_US(_t_)      (RF_ETIMER_TICKS2US((_t_).ticks))
-#define RF_ETIMER_VAL_MS(_t_)      (RF_ETIMER_TICKS2US((_t_).ticks)/1000)
+#define RF_ETIMER_EVAL(_t_)					\
+	{							\
+		RF_TIMEVAL_DIFF(&(_t_).st, &(_t_).et, &(_t_).diff) \
+	}
 
+#define RF_ETIMER_VAL_US(_t_)      (RF_TIMEVAL_TO_US((_t_).diff))
+#define RF_ETIMER_VAL_MS(_t_)      (RF_TIMEVAL_TO_US((_t_).diff)/1000)
 
 #endif				/* !_RF__RF_TIMER_H_ */