]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * xor.c : Multiple Devices driver for Linux | |
3 | * | |
4 | * Copyright (C) 1996, 1997, 1998, 1999, 2000, | |
5 | * Ingo Molnar, Matti Aarnio, Jakub Jelinek, Richard Henderson. | |
6 | * | |
7 | * Dispatch optimized RAID-5 checksumming functions. | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License as published by | |
11 | * the Free Software Foundation; either version 2, or (at your option) | |
12 | * any later version. | |
13 | * | |
14 | * You should have received a copy of the GNU General Public License | |
15 | * (for example /usr/src/linux/COPYING); if not, write to the Free | |
16 | * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
17 | */ | |
18 | ||
19 | #define BH_TRACE 0 | |
20 | #include <linux/module.h> | |
5a0e3ad6 | 21 | #include <linux/gfp.h> |
1da177e4 | 22 | #include <linux/raid/xor.h> |
bff61975 | 23 | #include <linux/jiffies.h> |
56a51991 | 24 | #include <linux/preempt.h> |
1da177e4 LT |
25 | #include <asm/xor.h> |
26 | ||
27c4d548 HX |
27 | #ifndef XOR_SELECT_TEMPLATE |
28 | #define XOR_SELECT_TEMPLATE(x) (x) | |
29 | #endif | |
30 | ||
1da177e4 LT |
31 | /* The xor routines to use. */ |
32 | static struct xor_block_template *active_template; | |
33 | ||
34 | void | |
9bc89cd8 | 35 | xor_blocks(unsigned int src_count, unsigned int bytes, void *dest, void **srcs) |
1da177e4 | 36 | { |
9bc89cd8 | 37 | unsigned long *p1, *p2, *p3, *p4; |
1da177e4 | 38 | |
9bc89cd8 DW |
39 | p1 = (unsigned long *) srcs[0]; |
40 | if (src_count == 1) { | |
41 | active_template->do_2(bytes, dest, p1); | |
1da177e4 LT |
42 | return; |
43 | } | |
44 | ||
9bc89cd8 DW |
45 | p2 = (unsigned long *) srcs[1]; |
46 | if (src_count == 2) { | |
47 | active_template->do_3(bytes, dest, p1, p2); | |
1da177e4 LT |
48 | return; |
49 | } | |
50 | ||
9bc89cd8 DW |
51 | p3 = (unsigned long *) srcs[2]; |
52 | if (src_count == 3) { | |
53 | active_template->do_4(bytes, dest, p1, p2, p3); | |
1da177e4 LT |
54 | return; |
55 | } | |
56 | ||
9bc89cd8 DW |
57 | p4 = (unsigned long *) srcs[3]; |
58 | active_template->do_5(bytes, dest, p1, p2, p3, p4); | |
1da177e4 | 59 | } |
685784aa | 60 | EXPORT_SYMBOL(xor_blocks); |
1da177e4 LT |
61 | |
62 | /* Set of all registered templates. */ | |
af7cf25d | 63 | static struct xor_block_template *__initdata template_list; |
1da177e4 LT |
64 | |
65 | #define BENCH_SIZE (PAGE_SIZE) | |
66 | ||
af7cf25d | 67 | static void __init |
1da177e4 LT |
68 | do_xor_speed(struct xor_block_template *tmpl, void *b1, void *b2) |
69 | { | |
70 | int speed; | |
6a328475 | 71 | unsigned long now, j; |
1da177e4 LT |
72 | int i, count, max; |
73 | ||
74 | tmpl->next = template_list; | |
75 | template_list = tmpl; | |
76 | ||
56a51991 JK |
77 | preempt_disable(); |
78 | ||
1da177e4 LT |
79 | /* |
80 | * Count the number of XORs done during a whole jiffy, and use | |
81 | * this to calculate the speed of checksumming. We use a 2-page | |
82 | * allocation to have guaranteed color L1-cache layout. | |
83 | */ | |
84 | max = 0; | |
85 | for (i = 0; i < 5; i++) { | |
6a328475 | 86 | j = jiffies; |
1da177e4 | 87 | count = 0; |
6a328475 JK |
88 | while ((now = jiffies) == j) |
89 | cpu_relax(); | |
90 | while (time_before(jiffies, now + 1)) { | |
685784aa | 91 | mb(); /* prevent loop optimzation */ |
1da177e4 LT |
92 | tmpl->do_2(BENCH_SIZE, b1, b2); |
93 | mb(); | |
94 | count++; | |
95 | mb(); | |
96 | } | |
97 | if (count > max) | |
98 | max = count; | |
99 | } | |
100 | ||
56a51991 JK |
101 | preempt_enable(); |
102 | ||
1da177e4 LT |
103 | speed = max * (HZ * BENCH_SIZE / 1024); |
104 | tmpl->speed = speed; | |
105 | ||
685784aa | 106 | printk(KERN_INFO " %-10s: %5d.%03d MB/sec\n", tmpl->name, |
1da177e4 LT |
107 | speed / 1000, speed % 1000); |
108 | } | |
109 | ||
685784aa DW |
110 | static int __init |
111 | calibrate_xor_blocks(void) | |
1da177e4 LT |
112 | { |
113 | void *b1, *b2; | |
114 | struct xor_block_template *f, *fastest; | |
115 | ||
27c4d548 | 116 | fastest = XOR_SELECT_TEMPLATE(NULL); |
39457acd | 117 | |
39457acd MS |
118 | if (fastest) { |
119 | printk(KERN_INFO "xor: automatically using best " | |
120 | "checksumming function %-10s\n", | |
121 | fastest->name); | |
122 | goto out; | |
123 | } | |
39457acd | 124 | |
33f65df7 VN |
125 | /* |
126 | * Note: Since the memory is not actually used for _anything_ but to | |
127 | * test the XOR speed, we don't really want kmemcheck to warn about | |
128 | * reading uninitialized bytes here. | |
129 | */ | |
130 | b1 = (void *) __get_free_pages(GFP_KERNEL | __GFP_NOTRACK, 2); | |
685784aa DW |
131 | if (!b1) { |
132 | printk(KERN_WARNING "xor: Yikes! No memory available.\n"); | |
1da177e4 LT |
133 | return -ENOMEM; |
134 | } | |
135 | b2 = b1 + 2*PAGE_SIZE + BENCH_SIZE; | |
136 | ||
137 | /* | |
685784aa DW |
138 | * If this arch/cpu has a short-circuited selection, don't loop through |
139 | * all the possible functions, just test the best one | |
1da177e4 LT |
140 | */ |
141 | ||
1da177e4 LT |
142 | #define xor_speed(templ) do_xor_speed((templ), b1, b2) |
143 | ||
39457acd MS |
144 | printk(KERN_INFO "xor: measuring software checksum speed\n"); |
145 | XOR_TRY_TEMPLATES; | |
146 | fastest = template_list; | |
147 | for (f = fastest; f; f = f->next) | |
148 | if (f->speed > fastest->speed) | |
149 | fastest = f; | |
1da177e4 | 150 | |
685784aa | 151 | printk(KERN_INFO "xor: using function: %s (%d.%03d MB/sec)\n", |
1da177e4 LT |
152 | fastest->name, fastest->speed / 1000, fastest->speed % 1000); |
153 | ||
154 | #undef xor_speed | |
155 | ||
156 | free_pages((unsigned long)b1, 2); | |
39457acd | 157 | out: |
1da177e4 LT |
158 | active_template = fastest; |
159 | return 0; | |
160 | } | |
161 | ||
162 | static __exit void xor_exit(void) { } | |
163 | ||
1da177e4 LT |
164 | MODULE_LICENSE("GPL"); |
165 | ||
685784aa DW |
166 | /* when built-in xor.o must initialize before drivers/md/md.o */ |
167 | core_initcall(calibrate_xor_blocks); | |
1da177e4 | 168 | module_exit(xor_exit); |