[Xen-devel] [PATCH v6 1/6] x86/intel_pstate: add some calculation related support

[Wei Wang <wei.w.wang@xxxxxxxxx>]

The added calculation related functions will be used in the intel_pstate.c.
They are copied from the Linux kernel(commit 2418f4f2, f3002134, eb18cba7).

Signed-off-by: Wei Wang <wei.w.wang@xxxxxxxxx>
---
 changes in v6:
 1) #define clamp() - remove the typecast on the result of max();
 2) add some comments to explain the functionality of some functions;
 3) alignment changes.

 xen/arch/x86/oprofile/op_model_athlon.c |  9 ----
 xen/include/asm-x86/div64.h             | 91 +++++++++++++++++++++++++++++++++
 xen/include/xen/kernel.h                | 23 +++++++++
 3 files changed, 114 insertions(+), 9 deletions(-)

diff --git a/xen/arch/x86/oprofile/op_model_athlon.c 
b/xen/arch/x86/oprofile/op_model_athlon.c
index c0a81ed..4122eee 100644
--- a/xen/arch/x86/oprofile/op_model_athlon.c
+++ b/xen/arch/x86/oprofile/op_model_athlon.c
@@ -103,15 +103,6 @@ static u64 ibs_op_ctl;
 #define IBS_FETCH_CODE                  13
 #define IBS_OP_CODE                     14
 
-#define clamp(val, min, max) ({                        \
-       typeof(val) __val = (val);              \
-       typeof(min) __min = (min);              \
-       typeof(max) __max = (max);              \
-       (void) (&__val == &__min);              \
-       (void) (&__val == &__max);              \
-       __val = __val < __min ? __min: __val;   \
-       __val > __max ? __max: __val; })
-
 /*
  * 16-bit Linear Feedback Shift Register (LFSR)
  */
diff --git a/xen/include/asm-x86/div64.h b/xen/include/asm-x86/div64.h
index dd49f64..b20df2d 100644
--- a/xen/include/asm-x86/div64.h
+++ b/xen/include/asm-x86/div64.h
@@ -11,4 +11,95 @@
     __rem;                                      \
 })
 
+/*
+ * div_u64_rem - unsigned 64bit divide with 32bit divisor
+ * @dividend:  64bit dividend
+ * @divisor:   32bit divisor
+ * @remainder: 32bit remainder
+ */
+static inline uint64_t div_u64_rem(uint64_t dividend, uint32_t divisor,
+                                   uint32_t *remainder)
+{
+    *remainder = do_div(dividend, divisor);
+    return dividend;
+}
+
+static inline uint64_t div_u64(uint64_t dividend, uint32_t  divisor)
+{
+    uint32_t remainder;
+
+    return div_u64_rem(dividend, divisor, &remainder);
+}
+
+/*
+ * div64_u64 - unsigned 64bit divide with 64bit divisor
+ * @dividend: 64bit dividend
+ * @divisor:  64bit divisor
+ *
+ * This implementation is a modified version of the algorithm proposed
+ * by the book 'Hacker's Delight'.  The original source and full proof
+ * can be found here and is available for use without restriction.
+ *
+ * 'http://www.hackersdelight.org/HDcode/newCode/divDouble.c.txt'
+ */
+static inline uint64_t div64_u64(uint64_t dividend, uint64_t divisor)
+{
+    uint32_t high = divisor >> 32;
+    uint64_t quot;
+
+    if ( high == 0 )
+        quot = div_u64(dividend, divisor);
+    else
+    {
+        int n = 1 + fls(high);
+
+        quot = div_u64(dividend >> n, divisor >> n);
+
+        if ( quot != 0 )
+            quot--;
+        if ( (dividend - quot * divisor) >= divisor )
+            quot++;
+    }
+    return quot;
+}
+
+/*
+ * div_u64_rem - signed 64bit divide with 32bit divisor
+ * @dividend:  64bit dividend
+ * @divisor:   32bit divisor
+ * @remainder: 32bit remainder
+ */
+static inline int64_t div_s64_rem(int64_t dividend, int32_t divisor,
+                                  int32_t *remainder)
+{
+    int64_t quotient;
+
+    if ( dividend < 0 )
+    {
+        quotient = div_u64_rem(-dividend, ABS(divisor),
+                               (uint32_t *)remainder);
+        *remainder = -*remainder;
+        if ( divisor > 0 )
+            quotient = -quotient;
+    }
+    else
+    {
+        quotient = div_u64_rem(dividend, ABS(divisor),
+                        (uint32_t *)remainder);
+        if ( divisor < 0 )
+            quotient = -quotient;
+    }
+    return quotient;
+}
+
+/*
+ * div_s64 - signed 64bit divide with 32bit divisor
+ */
+static inline int64_t div_s64(int64_t dividend, int32_t divisor)
+{
+    int32_t remainder;
+
+    return div_s64_rem(dividend, divisor, &remainder);
+}
+
 #endif
diff --git a/xen/include/xen/kernel.h b/xen/include/xen/kernel.h
index 548b64d..96c7948 100644
--- a/xen/include/xen/kernel.h
+++ b/xen/include/xen/kernel.h
@@ -43,6 +43,29 @@
 #define MAX(x,y) ((x) > (y) ? (x) : (y))
 
 /**
+ * clamp - return a value clamped to a given range with strict typechecking
+ * @val: current value
+ * @lo: lowest allowable value
+ * @hi: highest allowable value
+ *
+ * This macro does strict typechecking of lo/hi to make sure they are of the
+ * same type as val.  See the unnecessary pointer comparisons.
+ */
+#define clamp(val, lo, hi) min(max(val, lo), hi)
+
+/*
+ * clamp_t - return a value clamped to a given range using a given type
+ * @type: the type of variable to use
+ * @val: current value
+ * @lo: minimum allowable value
+ * @hi: maximum allowable value
+ *
+ * This macro does no typechecking and uses temporary variables of type
+ * 'type' to make all the comparisons.
+ */
+#define clamp_t(type, val, lo, hi) min_t(type, max_t(type, val, lo), hi)
+
+/**
  * container_of - cast a member of a structure out to the containing structure
  *
  * @ptr:       the pointer to the member.
-- 
1.9.1


_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxx
http://lists.xen.org/xen-devel