WARNING - OLD ARCHIVES

This is an archived copy of the Xen.org mailing list, which we have preserved to ensure that existing links to archives are not broken. The live archive, which contains the latest emails, can be found at http://lists.xen.org/
   
 
 
Xen 
 
Home Products Support Community News
 
   
 

xen-changelog

[Xen-changelog] [xen-unstable] docs: Example usage of pvrdtscp algorithm

To: xen-changelog@xxxxxxxxxxxxxxxxxxx
Subject: [Xen-changelog] [xen-unstable] docs: Example usage of pvrdtscp algorithm
From: Xen patchbot-unstable <patchbot-unstable@xxxxxxxxxxxxxxxxxxx>
Date: Fri, 11 Dec 2009 01:10:30 -0800
Delivery-date: Fri, 11 Dec 2009 01:18:16 -0800
Envelope-to: www-data@xxxxxxxxxxxxxxxxxxx
List-help: <mailto:xen-changelog-request@lists.xensource.com?subject=help>
List-id: BK change log <xen-changelog.lists.xensource.com>
List-post: <mailto:xen-changelog@lists.xensource.com>
List-subscribe: <http://lists.xensource.com/mailman/listinfo/xen-changelog>, <mailto:xen-changelog-request@lists.xensource.com?subject=subscribe>
List-unsubscribe: <http://lists.xensource.com/mailman/listinfo/xen-changelog>, <mailto:xen-changelog-request@lists.xensource.com?subject=unsubscribe>
Reply-to: xen-devel@xxxxxxxxxxxxxxxxxxx
Sender: xen-changelog-bounces@xxxxxxxxxxxxxxxxxxx
# HG changeset patch
# User Keir Fraser <keir.fraser@xxxxxxxxxx>
# Date 1260521481 0
# Node ID 1f5f36e11114d63c2a1c755106cb697666a92207
# Parent  1396dfb8d6badc181cda28364b3b1a9317b2462a
docs: Example usage of pvrdtscp algorithm

Signed-off-by: Dan Magenheimer <dan.magenheimer@xxxxxxxxxx>
---
 docs/misc/pvrdtscp.c |  307 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 307 insertions(+)

diff -r 1396dfb8d6ba -r 1f5f36e11114 docs/misc/pvrdtscp.c
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/docs/misc/pvrdtscp.c      Fri Dec 11 08:51:21 2009 +0000
@@ -0,0 +1,307 @@
+/* pvrdtscp algorithm
+ *
+ * This sample code demonstrates the use of the paravirtualized rdtscp
+ * algorithm.  Using this algorithm, an application may communicate with
+ * the Xen hypervisor (version 4.0+) to obtain timestamp information which
+ * is both monotonically increasing and has a fixed 1 GHz rate, even across
+ * migrations between machines with different TSC rates and offsets.
+ * Further,the algorithm provides performance near the performance of a
+ * native rdtsc/rdtscp instruction -- much faster than emulation PROVIDED
+ * the application is running on a machine on which the rdtscp instruction
+ * is supported and TSC is "safe". The application must also be running in a
+ * PV domain.  (HVM domains may be supported at a later time.) On machines
+ * where TSC is unsafe or the rdtscp instruction is not supported, Xen
+ * (v4.0+) provides emulation which is slower but consistent with the pvrdtscp
+ * algorithm, thus providing support for the algorithm for live migration
+ * across all machines.
+ *
+ * More information can be found within the Xen (4.0+) source tree at
+ *  docs/misc/tscmode.txt
+ *
+ * Copyright (c) 2009 Oracle Corporation and/or its affiliates.
+ * All rights reserved
+ * Written by: Dan Magenheimer <dan.magenheimer@xxxxxxxxxx>
+ * 
+ * This code is derived from code licensed under the GNU
+ * General Public License ("GPL") version 2 and is therefore itself
+ * also licensed under the GPL version 2.
+ *
+ * This code is known to compile and run on Oracle Enterprise Linux 5 Update 2
+ * using gcc version 4.1.2, but its purpose is to describe the pvrdtscp
+ * algorithm and its ABI to Xen version 4.0+ 
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/wait.h>
+
+#ifdef __LP64__
+#define __X86_64__
+typedef unsigned short u16;
+typedef unsigned int u32;
+typedef unsigned long u64;
+typedef int i32;
+typedef long i64;
+#define NSEC_PER_SEC 1000000000
+#else
+#define __X86_32__
+typedef unsigned int u16;
+typedef unsigned long u32;
+typedef unsigned long long u64;
+typedef long i32;
+typedef long long i64;
+#define NSEC_PER_SEC 1000000000L
+#endif
+
+static inline void hvm_cpuid(u32 idx, u32 sub,
+                               u32 *eax, u32 *ebx, u32 *ecx, u32 *edx)
+{
+       *eax = idx, *ecx = sub;
+       asm("cpuid" : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx)
+           : "0" (*eax), "2" (*ecx));
+}
+
+static inline void pv_cpuid(u32 idx, u32 sub,
+                               u32 *eax, u32 *ebx, u32 *ecx, u32 *edx)
+{
+       *eax = idx, *ecx = sub;
+       asm volatile ( "ud2a ; .ascii \"xen\"; cpuid" : "=a" (*eax),
+            "=b" (*ebx), "=c" (*ecx), "=d" (*edx) : "0" (*eax), "2" (*ecx));
+}
+
+static inline u64 do_rdtscp(u32 *aux)
+{
+static u64 last = 0;
+       u32 lo32, hi32;
+       u64 val;
+
+       asm volatile(".byte 0x0f,0x01,0xf9":"=a"(lo32),"=d"(hi32),"=c" (*aux));
+       val = lo32 | ((u64)hi32 << 32);
+       return val;
+}
+
+static inline int get_xen_tsc_mode(void)
+{
+       u32 val, dummy1, dummy2, dummy3;
+       pv_cpuid(0x40000003,0,&dummy1,&val,&dummy2,&dummy3);
+       return val;
+}
+
+static inline int get_xen_vtsc(void)
+{
+       u32 val, dummy1, dummy2, dummy3;
+       pv_cpuid(0x40000003,0,&val,&dummy1,&dummy2,&dummy3);
+       return val & 1;
+}
+
+static inline int get_xen_vtsc_khz(void)
+{
+       u32 val, dummy1, dummy2, dummy3;
+       pv_cpuid(0x40000003,0,&dummy1,&dummy2,&val,&dummy3);
+       return val;
+}
+
+static inline u32 get_xen_cpu_khz(void)
+{
+       u32 cpu_khz, dummy1, dummy2, dummy3;
+       pv_cpuid(0x40000003,2,&cpu_khz,&dummy1,&dummy2,&dummy3);
+       return cpu_khz;
+}
+
+static inline u32 get_xen_incarnation(void)
+{
+       u32 incarn, dummy1, dummy2, dummy3;
+       pv_cpuid(0x40000003,0,&dummy1,&dummy2,&dummy3,&incarn);
+       return incarn;
+}
+
+static inline void get_xen_time_values(u64 *offset, u32 *mul_frac, u32 *shift)
+{
+       u32 off_lo, off_hi, sys_lo, sys_hi, dummy;
+
+       pv_cpuid(0x40000003,1,&off_lo,&off_hi,mul_frac,shift);
+       *offset = off_lo | ((u64)off_hi << 32);
+}
+
+static inline u64 scale_delta(u64 delta, u32 tsc_mul_frac, i32 tsc_shift)
+{
+    u64 product;
+#ifdef __X86_32__
+    u32 tmp1, tmp2;
+#endif
+
+    if ( tsc_shift < 0 )
+        delta >>= -tsc_shift;
+    else
+        delta <<= tsc_shift;
+
+#ifdef __X86_32__
+    asm (
+        "mul  %5       ; "
+        "mov  %4,%%eax ; "
+        "mov  %%edx,%4 ; "
+        "mul  %5       ; "
+        "xor  %5,%5    ; "
+        "add  %4,%%eax ; "
+        "adc  %5,%%edx ; "
+        : "=A" (product), "=r" (tmp1), "=r" (tmp2)
+        : "a" ((u32)delta), "1" ((u32)(delta >> 32)), "2" (tsc_mul_frac) );
+#else
+    asm (
+        "mul %%rdx ; shrd $32,%%rdx,%%rax"
+        : "=a" (product) : "0" (delta), "d" ((u64)tsc_mul_frac) );
+#endif
+
+    return product;
+}
+
+static inline u64 get_pvrdtscp_timestamp(int *discontinuity)
+{
+       static int firsttime = 1;
+       static u64 last_pvrdtscp_timestamp = 0;
+       static u32 last_tsc_aux;
+       static u64 xen_ns_offset;
+       static u32 xen_tsc_to_ns_mul_frac, xen_tsc_to_ns_shift;
+       u32 this_tsc_aux;
+       u64 timestamp, cur_tsc, cur_ns;
+
+       if (firsttime) {
+               cur_tsc = do_rdtscp(&last_tsc_aux);
+               get_xen_time_values(&xen_ns_offset, &xen_tsc_to_ns_mul_frac,
+                                       &xen_tsc_to_ns_shift);
+               cur_ns = scale_delta(cur_tsc, xen_tsc_to_ns_mul_frac,
+                                       xen_tsc_to_ns_shift);
+               timestamp = cur_ns - xen_ns_offset;
+               last_pvrdtscp_timestamp = timestamp;
+               firsttime = 0;
+       }
+       cur_tsc = do_rdtscp(&this_tsc_aux);
+       *discontinuity = 0;
+       while (this_tsc_aux != last_tsc_aux) {
+               /* if tsc_aux changed, try again */
+               last_tsc_aux = this_tsc_aux;
+               get_xen_time_values(&xen_ns_offset, &xen_tsc_to_ns_mul_frac,
+                                       &xen_tsc_to_ns_shift);
+               cur_tsc = do_rdtscp(&this_tsc_aux);
+               *discontinuity = 1;
+       }
+
+       /* compute nsec from TSC and Xen time values */
+       cur_ns = scale_delta(cur_tsc, xen_tsc_to_ns_mul_frac,
+                                       xen_tsc_to_ns_shift);
+       timestamp = cur_ns - xen_ns_offset;
+
+       /* enforce monotonicity just in case */
+       if ((i64)(timestamp - last_pvrdtscp_timestamp) > 0)
+               last_pvrdtscp_timestamp = timestamp;
+       else {
+               /* this should never happen but we'll check it anyway in
+                * case of some strange combination of scaling errors
+                * occurs across a very fast migration */
+               printf("Time went backwards by %lluns\n",
+                   (unsigned long long)(last_pvrdtscp_timestamp-timestamp));
+               timestamp = ++last_pvrdtscp_timestamp;
+       }
+       return timestamp;
+}
+
+#define HVM 1
+#define PVM 0
+
+static int running_on_xen(int hvm, u16 *version_major, u16 *version_minor)
+{
+       u32 eax, ebx, ecx, edx, base;
+       union { char csig[16]; u32 u[4]; } sig;
+
+       for (base=0x40000000; base < 0x40010000; base += 0x100) {
+               if (hvm==HVM)
+                       hvm_cpuid(base,0,&eax,&ebx,&ecx,&edx);
+               else
+                       pv_cpuid(base,0,&eax,&ebx,&ecx,&edx);
+               sig.u[0] = ebx; sig.u[1] = ecx; sig.u[2] = edx;
+               sig.csig[12] = '\0';
+               if (!strcmp("XenVMMXenVMM",&sig.csig[0]) && (eax >= (base+2))) {
+                               if (hvm==HVM)
+                                       hvm_cpuid(base+1,0,&eax,&ebx,&ecx,&edx);
+                               else
+                                       pv_cpuid(base+1,0,&eax,&ebx,&ecx,&edx);
+                               *version_major = (eax >> 16) & 0xffff;
+                               *version_minor = eax & 0xffff;
+                               return 1;
+               }
+       }
+       return 0;
+}
+
+main(int ac, char **av)
+{
+       u32 dummy;
+       u16 version_hi, version_lo;
+       u64 ts, last_ts;
+       int status, discontinuity = 0;
+       pid_t pid;
+
+       if (running_on_xen(HVM,&version_hi,&version_lo)) {
+               printf("running on Xen v%d.%d as an HVM domain, "
+                       "pvrdtsc not supported, exiting\n",
+                       (int)version_hi, (int)version_lo);
+               exit(0);
+       }
+       pid = fork();
+       if (pid == -1) {
+               fprintf(stderr,"Huh? Fork failed\n");
+               return 0;
+       }
+       else if (pid == 0) { /* child */
+               pv_cpuid(0x40000000,0,&dummy,&dummy,&dummy,&dummy);
+               exit(0);
+       }
+       waitpid(pid,&status,0);
+       if (!WIFEXITED(status))
+               exit(0);
+       if (!running_on_xen(PVM,&version_hi,&version_lo)) {
+               printf("not running on Xen, exiting\n");
+               exit(0);
+       }
+       printf("running on Xen v%d.%d as a PV domain\n",
+               (int)version_hi, (int)version_lo);
+       if ( version_hi <= 3 ) {
+               printf("pvrdtscp requires Xen version 4.0 or greater\n");
+               /* exit(0); FIXME after xen-unstable is officially v4.0 */
+       }
+       if ( get_xen_tsc_mode() != 3 )
+               printf("tsc_mode not pvrdtscp, set tsc_mode=3, exiting\n");
+
+       /* OK, we are on Xen, now loop forever checking timestamps */
+       ts = get_pvrdtscp_timestamp(&discontinuity);
+       printf("Starting with ts=%lluns 0x%llx 
(%llusec)\n",ts,ts,ts/NSEC_PER_SEC);
+       printf("incarn=%d: vtsc=%d, vtsc_khz=%lu, phys cpu_khz=%lu\n",
+                               (unsigned long)get_xen_incarnation(),
+                               (unsigned long)get_xen_vtsc(),
+                               (unsigned long)get_xen_vtsc_khz(),
+                               (unsigned long)get_xen_cpu_khz());
+       ts = get_pvrdtscp_timestamp(&discontinuity);
+       last_ts = ts;
+       while (1) {
+               ts = get_pvrdtscp_timestamp(&discontinuity);
+               if (discontinuity)
+                       printf("migrated/restored, incarn=%d: "
+                               "vtsc now %d, vtsc_khz=%lu, phys cpu_khz=%lu\n",
+                               (unsigned long)get_xen_incarnation(),
+                               (unsigned long)get_xen_vtsc(),
+                               (unsigned long)get_xen_vtsc_khz(),
+                               (unsigned long)get_xen_cpu_khz());
+               if (ts < last_ts)
+                       /* this should NEVER happen, especially since there
+                        * is a check for it in get_pvrdtscp_timestamp() */
+                       printf("Time went backwards: %lluns (%llusec)\n",
+                               last_ts-ts,(last_ts-ts)/NSEC_PER_SEC);
+               if (ts > last_ts + 200000000LL)
+                       /* this is OK, usually about 2sec for save/restore
+                        * and a fraction of a second for live migrate */
+                       printf("Time jumped forward %lluns (%llusec)\n",
+                               ts-last_ts,(ts-last_ts)/NSEC_PER_SEC);
+               last_ts = ts;
+       }
+}

_______________________________________________
Xen-changelog mailing list
Xen-changelog@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-changelog

<Prev in Thread] Current Thread [Next in Thread>
  • [Xen-changelog] [xen-unstable] docs: Example usage of pvrdtscp algorithm, Xen patchbot-unstable <=