]>
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> | |
21 | #include <linux/raid/md.h> | |
22 | #include <linux/raid/xor.h> | |
23 | #include <asm/xor.h> | |
24 | ||
25 | /* The xor routines to use. */ | |
26 | static struct xor_block_template *active_template; | |
27 | ||
28 | void | |
29 | xor_block(unsigned int count, unsigned int bytes, void **ptr) | |
30 | { | |
31 | unsigned long *p0, *p1, *p2, *p3, *p4; | |
32 | ||
33 | p0 = (unsigned long *) ptr[0]; | |
34 | p1 = (unsigned long *) ptr[1]; | |
35 | if (count == 2) { | |
36 | active_template->do_2(bytes, p0, p1); | |
37 | return; | |
38 | } | |
39 | ||
40 | p2 = (unsigned long *) ptr[2]; | |
41 | if (count == 3) { | |
42 | active_template->do_3(bytes, p0, p1, p2); | |
43 | return; | |
44 | } | |
45 | ||
46 | p3 = (unsigned long *) ptr[3]; | |
47 | if (count == 4) { | |
48 | active_template->do_4(bytes, p0, p1, p2, p3); | |
49 | return; | |
50 | } | |
51 | ||
52 | p4 = (unsigned long *) ptr[4]; | |
53 | active_template->do_5(bytes, p0, p1, p2, p3, p4); | |
54 | } | |
55 | ||
56 | /* Set of all registered templates. */ | |
57 | static struct xor_block_template *template_list; | |
58 | ||
59 | #define BENCH_SIZE (PAGE_SIZE) | |
60 | ||
61 | static void | |
62 | do_xor_speed(struct xor_block_template *tmpl, void *b1, void *b2) | |
63 | { | |
64 | int speed; | |
65 | unsigned long now; | |
66 | int i, count, max; | |
67 | ||
68 | tmpl->next = template_list; | |
69 | template_list = tmpl; | |
70 | ||
71 | /* | |
72 | * Count the number of XORs done during a whole jiffy, and use | |
73 | * this to calculate the speed of checksumming. We use a 2-page | |
74 | * allocation to have guaranteed color L1-cache layout. | |
75 | */ | |
76 | max = 0; | |
77 | for (i = 0; i < 5; i++) { | |
78 | now = jiffies; | |
79 | count = 0; | |
80 | while (jiffies == now) { | |
81 | mb(); | |
82 | tmpl->do_2(BENCH_SIZE, b1, b2); | |
83 | mb(); | |
84 | count++; | |
85 | mb(); | |
86 | } | |
87 | if (count > max) | |
88 | max = count; | |
89 | } | |
90 | ||
91 | speed = max * (HZ * BENCH_SIZE / 1024); | |
92 | tmpl->speed = speed; | |
93 | ||
94 | printk(" %-10s: %5d.%03d MB/sec\n", tmpl->name, | |
95 | speed / 1000, speed % 1000); | |
96 | } | |
97 | ||
98 | static int | |
99 | calibrate_xor_block(void) | |
100 | { | |
101 | void *b1, *b2; | |
102 | struct xor_block_template *f, *fastest; | |
103 | ||
104 | b1 = (void *) __get_free_pages(GFP_KERNEL, 2); | |
105 | if (! b1) { | |
106 | printk("raid5: Yikes! No memory available.\n"); | |
107 | return -ENOMEM; | |
108 | } | |
109 | b2 = b1 + 2*PAGE_SIZE + BENCH_SIZE; | |
110 | ||
111 | /* | |
112 | * If this arch/cpu has a short-circuited selection, don't loop through all | |
113 | * the possible functions, just test the best one | |
114 | */ | |
115 | ||
116 | fastest = NULL; | |
117 | ||
118 | #ifdef XOR_SELECT_TEMPLATE | |
119 | fastest = XOR_SELECT_TEMPLATE(fastest); | |
120 | #endif | |
121 | ||
122 | #define xor_speed(templ) do_xor_speed((templ), b1, b2) | |
123 | ||
124 | if (fastest) { | |
125 | printk(KERN_INFO "raid5: automatically using best checksumming function: %s\n", | |
126 | fastest->name); | |
127 | xor_speed(fastest); | |
128 | } else { | |
129 | printk(KERN_INFO "raid5: measuring checksumming speed\n"); | |
130 | XOR_TRY_TEMPLATES; | |
131 | fastest = template_list; | |
132 | for (f = fastest; f; f = f->next) | |
133 | if (f->speed > fastest->speed) | |
134 | fastest = f; | |
135 | } | |
136 | ||
137 | printk("raid5: using function: %s (%d.%03d MB/sec)\n", | |
138 | fastest->name, fastest->speed / 1000, fastest->speed % 1000); | |
139 | ||
140 | #undef xor_speed | |
141 | ||
142 | free_pages((unsigned long)b1, 2); | |
143 | ||
144 | active_template = fastest; | |
145 | return 0; | |
146 | } | |
147 | ||
148 | static __exit void xor_exit(void) { } | |
149 | ||
150 | EXPORT_SYMBOL(xor_block); | |
151 | MODULE_LICENSE("GPL"); | |
152 | ||
153 | module_init(calibrate_xor_block); | |
154 | module_exit(xor_exit); |