procfs: add num_to_str() to speed up /proc/stat

== stat_check.py
num = 0
with open("/proc/stat") as f:
        while num < 1000 :
                data = f.read()
                f.seek(0, 0)
                num = num + 1
==

perf shows

    20.39%  stat_check.py  [kernel.kallsyms]    [k] format_decode
    13.41%  stat_check.py  [kernel.kallsyms]    [k] number
    12.61%  stat_check.py  [kernel.kallsyms]    [k] vsnprintf
    10.85%  stat_check.py  [kernel.kallsyms]    [k] memcpy
     4.85%  stat_check.py  [kernel.kallsyms]    [k] radix_tree_lookup
     4.43%  stat_check.py  [kernel.kallsyms]    [k] seq_printf

This patch removes most of calls to vsnprintf() by adding num_to_str()
and seq_print_decimal_ull(), which prints decimal numbers without rich
functions provided by printf().

On my 8cpu box.
== Before patch ==
[root@bluextal test]# time ./stat_check.py

real    0m0.150s
user    0m0.026s
sys     0m0.121s

== After patch ==
[root@bluextal test]# time ./stat_check.py

real    0m0.055s
user    0m0.022s
sys     0m0.030s

[akpm@linux-foundation.org: remove incorrect comment, use less statck in num_to_str(), move comment from .h to .c, simplify seq_put_decimal_ull()]
[andrea@betterlinux.com: avoid breaking the ABI in /proc/stat]
Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Signed-off-by: Andrea Righi <andrea@betterlinux.com>
Cc: Eric Dumazet <eric.dumazet@gmail.com>
Cc: Glauber Costa <glommer@parallels.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Paul Turner <pjt@google.com>
Cc: Russell King <rmk@arm.linux.org.uk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/fs/proc/stat.c b/fs/proc/stat.c
index ac446114cd48a59154da3da4e0a5e446cf607970..6a0c62d6e4428bf38711d0afcd4d860061f0feb6 100644 (file)
--- a/fs/proc/stat.c
+++ b/fs/proc/stat.c
@@ -89,18 +89,19 @@ static int show_stat(struct seq_file *p, void *v)
        }
        sum += arch_irq_stat();
 
-       seq_printf(p, "cpu  %llu %llu %llu %llu %llu %llu %llu %llu %llu "
-               "%llu\n",
-               (unsigned long long)cputime64_to_clock_t(user),
-               (unsigned long long)cputime64_to_clock_t(nice),
-               (unsigned long long)cputime64_to_clock_t(system),
-               (unsigned long long)cputime64_to_clock_t(idle),
-               (unsigned long long)cputime64_to_clock_t(iowait),
-               (unsigned long long)cputime64_to_clock_t(irq),
-               (unsigned long long)cputime64_to_clock_t(softirq),
-               (unsigned long long)cputime64_to_clock_t(steal),
-               (unsigned long long)cputime64_to_clock_t(guest),
-               (unsigned long long)cputime64_to_clock_t(guest_nice));
+       seq_puts(p, "cpu ");
+       seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(user));
+       seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(nice));
+       seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(system));
+       seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(idle));
+       seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(iowait));
+       seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(irq));
+       seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(softirq));
+       seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(steal));
+       seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(guest));
+       seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(guest_nice));
+       seq_putc(p, '\n');
+
        for_each_online_cpu(i) {
                /* Copy values here to work around gcc-2.95.3, gcc-2.96 */
                user = kcpustat_cpu(i).cpustat[CPUTIME_USER];
@@ -113,26 +114,24 @@ static int show_stat(struct seq_file *p, void *v)
                steal = kcpustat_cpu(i).cpustat[CPUTIME_STEAL];
                guest = kcpustat_cpu(i).cpustat[CPUTIME_GUEST];
                guest_nice = kcpustat_cpu(i).cpustat[CPUTIME_GUEST_NICE];
-               seq_printf(p,
-                       "cpu%d %llu %llu %llu %llu %llu %llu %llu %llu %llu "
-                       "%llu\n",
-                       i,
-                       (unsigned long long)cputime64_to_clock_t(user),
-                       (unsigned long long)cputime64_to_clock_t(nice),
-                       (unsigned long long)cputime64_to_clock_t(system),
-                       (unsigned long long)cputime64_to_clock_t(idle),
-                       (unsigned long long)cputime64_to_clock_t(iowait),
-                       (unsigned long long)cputime64_to_clock_t(irq),
-                       (unsigned long long)cputime64_to_clock_t(softirq),
-                       (unsigned long long)cputime64_to_clock_t(steal),
-                       (unsigned long long)cputime64_to_clock_t(guest),
-                       (unsigned long long)cputime64_to_clock_t(guest_nice));
+               seq_printf(p, "cpu%d", i);
+               seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(user));
+               seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(nice));
+               seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(system));
+               seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(idle));
+               seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(iowait));
+               seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(irq));
+               seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(softirq));
+               seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(steal));
+               seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(guest));
+               seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(guest_nice));
+               seq_putc(p, '\n');
        }
        seq_printf(p, "intr %llu", (unsigned long long)sum);
 
        /* sum again ? it could be updated? */
        for_each_irq_nr(j)
-               seq_printf(p, " %u", kstat_irqs(j));
+               seq_put_decimal_ull(p, ' ', kstat_irqs(j));
 
        seq_printf(p,
                "\nctxt %llu\n"
@@ -149,7 +148,7 @@ static int show_stat(struct seq_file *p, void *v)
        seq_printf(p, "softirq %llu", (unsigned long long)sum_softirq);
 
        for (i = 0; i < NR_SOFTIRQS; i++)
-               seq_printf(p, " %u", per_softirq_sums[i]);
+               seq_put_decimal_ull(p, ' ', per_softirq_sums[i]);
        seq_putc(p, '\n');
 
        return 0;

diff --git a/fs/seq_file.c b/fs/seq_file.c
index aa242dc99373bec0fe981d22508921454759bd14..7d19816c4cc9799265e6b1b876eb0851bf214b44 100644 (file)
--- a/fs/seq_file.c
+++ b/fs/seq_file.c
@@ -644,6 +644,39 @@ int seq_puts(struct seq_file *m, const char *s)
 }
 EXPORT_SYMBOL(seq_puts);
 
+/*
+ * A helper routine for putting decimal numbers without rich format of printf().
+ * only 'unsigned long long' is supported.
+ * This routine will put one byte delimiter + number into seq_file.
+ * This routine is very quick when you show lots of numbers.
+ * In usual cases, it will be better to use seq_printf(). It's easier to read.
+ */
+int seq_put_decimal_ull(struct seq_file *m, char delimiter,
+                       unsigned long long num)
+{
+       int len;
+
+       if (m->count + 2 >= m->size) /* we'll write 2 bytes at least */
+               goto overflow;
+
+       m->buf[m->count++] = delimiter;
+
+       if (num < 10) {
+               m->buf[m->count++] = num + '0';
+               return 0;
+       }
+
+       len = num_to_str(m->buf + m->count, m->size - m->count, num);
+       if (!len)
+               goto overflow;
+       m->count += len;
+       return 0;
+overflow:
+       m->count = m->size;
+       return -1;
+}
+EXPORT_SYMBOL(seq_put_decimal_ull);
+
 /**
  * seq_write - write arbitrary data to buffer
  * @seq: seq_file identifying the buffer to which data should be written

diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index f2085b541a245719a136d9912f333b399a32f7da..3e140add5360c54553cb0c473dd8f0aa8e433fd5 100644 (file)
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -312,6 +312,8 @@ extern long long simple_strtoll(const char *,char **,unsigned int);
 #define strict_strtoull        kstrtoull
 #define strict_strtoll kstrtoll
 
+extern int num_to_str(char *buf, int size, unsigned long long num);
+
 /* lib/printf utilities */
 
 extern __printf(2, 3) int sprintf(char *buf, const char * fmt, ...);

diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index 44f1514b00bad206310e813ee24223a38aa8cfa0..5bba42c99448b3438afd7e107281150b7b6d26ed 100644 (file)
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -121,9 +121,10 @@ int single_release(struct inode *, struct file *);
 void *__seq_open_private(struct file *, const struct seq_operations *, int);
 int seq_open_private(struct file *, const struct seq_operations *, int);
 int seq_release_private(struct inode *, struct file *);
+int seq_put_decimal_ull(struct seq_file *m, char delimiter,
+                       unsigned long long num);
 
 #define SEQ_START_TOKEN ((void *)1)
-
 /*
  * Helpers for iteration over list_head-s in seq_files
  */

diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 38e612e66da5993f7b1eb92065ebfec45216d83c..385c40291cdb9e492d4705f90ff19ceb7b778da4 100644 (file)
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -212,6 +212,26 @@ char *put_dec(char *buf, unsigned long long num)
        }
 }
 
+/*
+ * Convert passed number to decimal string.
+ * Returns the length of string.  On buffer overflow, returns 0.
+ *
+ * If speed is not important, use snprintf(). It's easy to read the code.
+ */
+int num_to_str(char *buf, int size, unsigned long long num)
+{
+       char tmp[21];           /* Enough for 2^64 in decimal */
+       int idx, len;
+
+       len = put_dec(tmp, num) - tmp;
+
+       if (len > size)
+               return 0;
+       for (idx = 0; idx < len; ++idx)
+               buf[idx] = tmp[len - idx - 1];
+       return  len;
+}
+
 #define ZEROPAD        1               /* pad with zero */
 #define SIGN   2               /* unsigned/signed long */
 #define PLUS   4               /* show plus */