ia64/linux-2.6.18-xen.hg

view init/calibrate.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /* calibrate.c: default delay calibration
2 *
3 * Excised from init/main.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
7 #include <linux/sched.h>
8 #include <linux/delay.h>
9 #include <linux/init.h>
11 #include <asm/timex.h>
13 static unsigned long preset_lpj;
14 static int __init lpj_setup(char *str)
15 {
16 preset_lpj = simple_strtoul(str,NULL,0);
17 return 1;
18 }
20 __setup("lpj=", lpj_setup);
22 #ifdef ARCH_HAS_READ_CURRENT_TIMER
24 /* This routine uses the read_current_timer() routine and gets the
25 * loops per jiffy directly, instead of guessing it using delay().
26 * Also, this code tries to handle non-maskable asynchronous events
27 * (like SMIs)
28 */
29 #define DELAY_CALIBRATION_TICKS ((HZ < 100) ? 1 : (HZ/100))
30 #define MAX_DIRECT_CALIBRATION_RETRIES 5
32 static unsigned long __devinit calibrate_delay_direct(void)
33 {
34 unsigned long pre_start, start, post_start;
35 unsigned long pre_end, end, post_end;
36 unsigned long start_jiffies;
37 unsigned long tsc_rate_min, tsc_rate_max;
38 unsigned long good_tsc_sum = 0;
39 unsigned long good_tsc_count = 0;
40 int i;
42 if (read_current_timer(&pre_start) < 0 )
43 return 0;
45 /*
46 * A simple loop like
47 * while ( jiffies < start_jiffies+1)
48 * start = read_current_timer();
49 * will not do. As we don't really know whether jiffy switch
50 * happened first or timer_value was read first. And some asynchronous
51 * event can happen between these two events introducing errors in lpj.
52 *
53 * So, we do
54 * 1. pre_start <- When we are sure that jiffy switch hasn't happened
55 * 2. check jiffy switch
56 * 3. start <- timer value before or after jiffy switch
57 * 4. post_start <- When we are sure that jiffy switch has happened
58 *
59 * Note, we don't know anything about order of 2 and 3.
60 * Now, by looking at post_start and pre_start difference, we can
61 * check whether any asynchronous event happened or not
62 */
64 for (i = 0; i < MAX_DIRECT_CALIBRATION_RETRIES; i++) {
65 pre_start = 0;
66 read_current_timer(&start);
67 start_jiffies = jiffies;
68 while (jiffies <= (start_jiffies + 1)) {
69 pre_start = start;
70 read_current_timer(&start);
71 }
72 read_current_timer(&post_start);
74 pre_end = 0;
75 end = post_start;
76 while (jiffies <=
77 (start_jiffies + 1 + DELAY_CALIBRATION_TICKS)) {
78 pre_end = end;
79 read_current_timer(&end);
80 }
81 read_current_timer(&post_end);
83 tsc_rate_max = (post_end - pre_start) / DELAY_CALIBRATION_TICKS;
84 tsc_rate_min = (pre_end - post_start) / DELAY_CALIBRATION_TICKS;
86 /*
87 * If the upper limit and lower limit of the tsc_rate is
88 * >= 12.5% apart, redo calibration.
89 */
90 if (pre_start != 0 && pre_end != 0 &&
91 (tsc_rate_max - tsc_rate_min) < (tsc_rate_max >> 3)) {
92 good_tsc_count++;
93 good_tsc_sum += tsc_rate_max;
94 }
95 }
97 if (good_tsc_count)
98 return (good_tsc_sum/good_tsc_count);
100 printk(KERN_WARNING "calibrate_delay_direct() failed to get a good "
101 "estimate for loops_per_jiffy.\nProbably due to long platform interrupts. Consider using \"lpj=\" boot option.\n");
102 return 0;
103 }
104 #else
105 static unsigned long __devinit calibrate_delay_direct(void) {return 0;}
106 #endif
108 /*
109 * This is the number of bits of precision for the loops_per_jiffy. Each
110 * bit takes on average 1.5/HZ seconds. This (like the original) is a little
111 * better than 1%
112 */
113 #define LPS_PREC 8
115 void __devinit calibrate_delay(void)
116 {
117 unsigned long ticks, loopbit;
118 int lps_precision = LPS_PREC;
120 if (preset_lpj) {
121 loops_per_jiffy = preset_lpj;
122 printk("Calibrating delay loop (skipped)... "
123 "%lu.%02lu BogoMIPS preset\n",
124 loops_per_jiffy/(500000/HZ),
125 (loops_per_jiffy/(5000/HZ)) % 100);
126 } else if ((loops_per_jiffy = calibrate_delay_direct()) != 0) {
127 printk("Calibrating delay using timer specific routine.. ");
128 printk("%lu.%02lu BogoMIPS (lpj=%lu)\n",
129 loops_per_jiffy/(500000/HZ),
130 (loops_per_jiffy/(5000/HZ)) % 100,
131 loops_per_jiffy);
132 } else {
133 loops_per_jiffy = (1<<12);
135 printk(KERN_DEBUG "Calibrating delay loop... ");
136 while ((loops_per_jiffy <<= 1) != 0) {
137 /* wait for "start of" clock tick */
138 ticks = jiffies;
139 while (ticks == jiffies)
140 /* nothing */;
141 /* Go .. */
142 ticks = jiffies;
143 __delay(loops_per_jiffy);
144 ticks = jiffies - ticks;
145 if (ticks)
146 break;
147 }
149 /*
150 * Do a binary approximation to get loops_per_jiffy set to
151 * equal one clock (up to lps_precision bits)
152 */
153 loops_per_jiffy >>= 1;
154 loopbit = loops_per_jiffy;
155 while (lps_precision-- && (loopbit >>= 1)) {
156 loops_per_jiffy |= loopbit;
157 ticks = jiffies;
158 while (ticks == jiffies)
159 /* nothing */;
160 ticks = jiffies;
161 __delay(loops_per_jiffy);
162 if (jiffies != ticks) /* longer than 1 tick */
163 loops_per_jiffy &= ~loopbit;
164 }
166 /* Round the value and print it */
167 printk("%lu.%02lu BogoMIPS (lpj=%lu)\n",
168 loops_per_jiffy/(500000/HZ),
169 (loops_per_jiffy/(5000/HZ)) % 100,
170 loops_per_jiffy);
171 }
173 }