1 /* 2 * getrusage04 - accuracy of getrusage() with RUSAGE_THREAD 3 * 4 * This program is used for testing the following upstream commit: 5 * 761b1d26df542fd5eb348837351e4d2f3bc7bffe. 6 * 7 * getrusage() returns cpu resource usage with accuracy of 10ms 8 * when RUSAGE_THREAD is specified to the argument who. Meanwhile, 9 * accuracy is 1ms when RUSAGE_SELF is specified. This bad accuracy 10 * of getrusage() caused a big impact on some application which is 11 * critical to accuracy of cpu usage. The upstream fix removed 12 * casts to clock_t in task_u/stime(), to keep granularity of 13 * cputime_t over the calculation. 14 * 15 * Note that the accuracy on powerpc and s390x systems is always 16 * 10ms when either RUSAGE_THREAD or RUSAGE_SELF specified, so 17 * this test won't be executed on those platforms. 18 * 19 * Copyright (C) 2011 Red Hat, Inc. 20 * Copyright (C) 2013 Cyril Hrubis <chrubis (at) suse.cz> 21 * 22 * This program is free software; you can redistribute it and/or 23 * modify it under the terms of version 2 of the GNU General Public 24 * License as published by the Free Software Foundation. 25 * 26 * This program is distributed in the hope that it would be useful, 27 * but WITHOUT ANY WARRANTY; without even the implied warranty of 28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 29 * 30 * Further, this software is distributed without any warranty that it 31 * is free of the rightful claim of any third person regarding 32 * infringement or the like. Any license provided herein, whether 33 * implied or otherwise, applies only to this software file. Patent 34 * licenses, if any, provided herein do not apply to combinations of 35 * this program with other software, or any other product whatsoever. 36 * 37 * You should have received a copy of the GNU General Public License 38 * along with this program; if not, write the Free Software 39 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 40 * 02110-1301, USA. 41 */ 42 43 #define _GNU_SOURCE 44 #include <sys/types.h> 45 #include <sys/resource.h> 46 #include <sys/time.h> 47 #include <errno.h> 48 #include <stdio.h> 49 #include <stdlib.h> 50 #include <time.h> 51 52 #include "test.h" 53 #include "safe_macros.h" 54 #include "lapi/posix_clocks.h" 55 56 char *TCID = "getrusage04"; 57 int TST_TOTAL = 1; 58 59 #define RECORD_MAX 20 60 #define FACTOR_MAX 10 61 62 #ifndef RUSAGE_THREAD 63 #define RUSAGE_THREAD 1 64 #endif 65 66 static long BIAS_MAX; 67 68 static int opt_factor; 69 static char *factor_str; 70 static long factor_nr = 1; 71 72 option_t child_options[] = { 73 {"m:", &opt_factor, &factor_str}, 74 {NULL, NULL, NULL} 75 }; 76 77 static void fusage(void); 78 static void busyloop(long wait); 79 static void setup(void); 80 static void cleanup(void); 81 82 int main(int argc, char *argv[]) 83 { 84 struct rusage usage; 85 unsigned long ulast, udelta, slast, sdelta; 86 int i, lc; 87 char msg_string[BUFSIZ]; 88 89 tst_parse_opts(argc, argv, child_options, fusage); 90 91 #if (__powerpc__) || (__powerpc64__) || (__s390__) || (__s390x__) 92 tst_brkm(TCONF, NULL, "This test is not designed for current system"); 93 #endif 94 95 setup(); 96 97 if (opt_factor) 98 factor_nr = SAFE_STRTOL(cleanup, factor_str, 0, FACTOR_MAX); 99 100 tst_resm(TINFO, "Using %ld as multiply factor for max [us]time " 101 "increment (1000+%ldus)!", factor_nr, BIAS_MAX * factor_nr); 102 103 for (lc = 0; TEST_LOOPING(lc); lc++) { 104 tst_count = 0; 105 i = 0; 106 SAFE_GETRUSAGE(cleanup, RUSAGE_THREAD, &usage); 107 tst_resm(TINFO, "utime:%12luus; stime:%12luus", 108 usage.ru_utime.tv_usec, usage.ru_stime.tv_usec); 109 ulast = usage.ru_utime.tv_usec; 110 slast = usage.ru_stime.tv_usec; 111 112 while (i < RECORD_MAX) { 113 SAFE_GETRUSAGE(cleanup, RUSAGE_THREAD, &usage); 114 udelta = usage.ru_utime.tv_usec - ulast; 115 sdelta = usage.ru_stime.tv_usec - slast; 116 if (udelta > 0 || sdelta > 0) { 117 i++; 118 tst_resm(TINFO, "utime:%12luus; stime:%12luus", 119 usage.ru_utime.tv_usec, 120 usage.ru_stime.tv_usec); 121 if (udelta > 1000 + (BIAS_MAX * factor_nr)) { 122 sprintf(msg_string, 123 "utime increased > %ldus:", 124 1000 + BIAS_MAX * factor_nr); 125 tst_brkm(TFAIL, cleanup, msg_string, 126 " delta = %luus", udelta); 127 } 128 if (sdelta > 1000 + (BIAS_MAX * factor_nr)) { 129 sprintf(msg_string, 130 "stime increased > %ldus:", 131 1000 + BIAS_MAX * factor_nr); 132 tst_brkm(TFAIL, cleanup, msg_string, 133 " delta = %luus", sdelta); 134 } 135 } 136 ulast = usage.ru_utime.tv_usec; 137 slast = usage.ru_stime.tv_usec; 138 busyloop(100000); 139 } 140 } 141 142 tst_resm(TPASS, "Test Passed"); 143 144 cleanup(); 145 tst_exit(); 146 } 147 148 static void fusage(void) 149 { 150 printf(" -m n use n as multiply factor for max [us]time " 151 "increment (1000+(1000*n)us),\n default value is 1\n"); 152 } 153 154 static void busyloop(long wait) 155 { 156 while (wait--) ; 157 } 158 159 /* 160 * The resolution of getrusage timers currently depends on CONFIG_HZ settings, 161 * as they are measured in jiffies. 162 * 163 * The problem is that there is no reasonable API to get either getrusage 164 * timers resolution or duration of jiffie. 165 * 166 * Here we use clock_getres() with linux specific CLOCK_REALTIME_COARSE (added 167 * in 2.6.32) which is also based on jiffies. This timer has the same 168 * granularity as getrusage but it's not guaranteed and it may change in the 169 * future. 170 * 171 * The default value for resolution was choosen to be 4ms as it corresponds to 172 * CONFIG_HZ=250 which seems to be default value. 173 */ 174 static unsigned long guess_timer_resolution(void) 175 { 176 struct timespec res; 177 178 if (clock_getres(CLOCK_REALTIME_COARSE, &res)) { 179 tst_resm(TINFO, 180 "CLOCK_REALTIME_COARSE not supported, using 4000 us"); 181 return 4000; 182 } 183 184 if (res.tv_nsec < 1000000 || res.tv_nsec > 10000000) { 185 tst_resm(TINFO, "Unexpected CLOCK_REALTIME_COARSE resolution," 186 " using 4000 us"); 187 return 4000; 188 } 189 190 tst_resm(TINFO, "Expected timers granularity is %li us", 191 res.tv_nsec / 1000); 192 193 return res.tv_nsec / 1000; 194 } 195 196 static void setup(void) 197 { 198 tst_sig(NOFORK, DEF_HANDLER, cleanup); 199 200 if (tst_is_virt(VIRT_XEN) || tst_is_virt(VIRT_KVM)) 201 tst_brkm(TCONF, NULL, "This testcase is not supported on this" 202 " virtual machine."); 203 204 BIAS_MAX = guess_timer_resolution(); 205 206 TEST_PAUSE; 207 } 208 209 static void cleanup(void) 210 { 211 } 212
