xor.c 4.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169
  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. #define BH_TRACE 0
  19. #include <linux/module.h>
  20. #include <linux/gfp.h>
  21. #include <linux/raid/xor.h>
  22. #include <linux/jiffies.h>
  23. #include <linux/preempt.h>
  24. #include <asm/xor.h>
  25. /* The xor routines to use. */
  26. static struct xor_block_template *active_template;
  27. void
  28. xor_blocks(unsigned int src_count, unsigned int bytes, void *dest, void **srcs)
  29. {
  30. unsigned long *p1, *p2, *p3, *p4;
  31. p1 = (unsigned long *) srcs[0];
  32. if (src_count == 1) {
  33. active_template->do_2(bytes, dest, p1);
  34. return;
  35. }
  36. p2 = (unsigned long *) srcs[1];
  37. if (src_count == 2) {
  38. active_template->do_3(bytes, dest, p1, p2);
  39. return;
  40. }
  41. p3 = (unsigned long *) srcs[2];
  42. if (src_count == 3) {
  43. active_template->do_4(bytes, dest, p1, p2, p3);
  44. return;
  45. }
  46. p4 = (unsigned long *) srcs[3];
  47. active_template->do_5(bytes, dest, p1, p2, p3, p4);
  48. }
  49. EXPORT_SYMBOL(xor_blocks);
  50. /* Set of all registered templates. */
  51. static struct xor_block_template *__initdata template_list;
  52. #define BENCH_SIZE (PAGE_SIZE)
  53. static void __init
  54. do_xor_speed(struct xor_block_template *tmpl, void *b1, void *b2)
  55. {
  56. int speed;
  57. unsigned long now, j;
  58. int i, count, max;
  59. tmpl->next = template_list;
  60. template_list = tmpl;
  61. preempt_disable();
  62. /*
  63. * Count the number of XORs done during a whole jiffy, and use
  64. * this to calculate the speed of checksumming. We use a 2-page
  65. * allocation to have guaranteed color L1-cache layout.
  66. */
  67. max = 0;
  68. for (i = 0; i < 5; i++) {
  69. j = jiffies;
  70. count = 0;
  71. while ((now = jiffies) == j)
  72. cpu_relax();
  73. while (time_before(jiffies, now + 1)) {
  74. mb(); /* prevent loop optimzation */
  75. tmpl->do_2(BENCH_SIZE, b1, b2);
  76. mb();
  77. count++;
  78. mb();
  79. }
  80. if (count > max)
  81. max = count;
  82. }
  83. preempt_enable();
  84. speed = max * (HZ * BENCH_SIZE / 1024);
  85. tmpl->speed = speed;
  86. printk(KERN_INFO " %-10s: %5d.%03d MB/sec\n", tmpl->name,
  87. speed / 1000, speed % 1000);
  88. }
  89. static int __init
  90. calibrate_xor_blocks(void)
  91. {
  92. void *b1, *b2;
  93. struct xor_block_template *f, *fastest;
  94. /*
  95. * Note: Since the memory is not actually used for _anything_ but to
  96. * test the XOR speed, we don't really want kmemcheck to warn about
  97. * reading uninitialized bytes here.
  98. */
  99. b1 = (void *) __get_free_pages(GFP_KERNEL | __GFP_NOTRACK, 2);
  100. if (!b1) {
  101. printk(KERN_WARNING "xor: Yikes! No memory available.\n");
  102. return -ENOMEM;
  103. }
  104. b2 = b1 + 2*PAGE_SIZE + BENCH_SIZE;
  105. /*
  106. * If this arch/cpu has a short-circuited selection, don't loop through
  107. * all the possible functions, just test the best one
  108. */
  109. fastest = NULL;
  110. #ifdef XOR_SELECT_TEMPLATE
  111. fastest = XOR_SELECT_TEMPLATE(fastest);
  112. #endif
  113. #define xor_speed(templ) do_xor_speed((templ), b1, b2)
  114. if (fastest) {
  115. printk(KERN_INFO "xor: automatically using best "
  116. "checksumming function:\n");
  117. xor_speed(fastest);
  118. goto out;
  119. } else {
  120. printk(KERN_INFO "xor: measuring software checksum speed\n");
  121. XOR_TRY_TEMPLATES;
  122. fastest = template_list;
  123. for (f = fastest; f; f = f->next)
  124. if (f->speed > fastest->speed)
  125. fastest = f;
  126. }
  127. printk(KERN_INFO "xor: using function: %s (%d.%03d MB/sec)\n",
  128. fastest->name, fastest->speed / 1000, fastest->speed % 1000);
  129. #undef xor_speed
  130. out:
  131. free_pages((unsigned long)b1, 2);
  132. active_template = fastest;
  133. return 0;
  134. }
  135. static __exit void xor_exit(void) { }
  136. MODULE_LICENSE("GPL");
  137. /* when built-in xor.o must initialize before drivers/md/md.o */
  138. core_initcall(calibrate_xor_blocks);
  139. module_exit(xor_exit);