README
上传用户:qaz666999
上传日期:2022-08-06
资源大小:2570k
文件大小:4k
源码类别:

数学计算

开发平台:

Unix_Linux

  1. Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
  2. This file is part of the GNU MP Library.
  3. The GNU MP Library is free software; you can redistribute it and/or modify
  4. it under the terms of the GNU Lesser General Public License as published by
  5. the Free Software Foundation; either version 3 of the License, or (at your
  6. option) any later version.
  7. The GNU MP Library is distributed in the hope that it will be useful, but
  8. WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  9. or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  10. License for more details.
  11. You should have received a copy of the GNU Lesser General Public License
  12. along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.
  13. The code in this directory works for Cray vector systems such as C90,
  14. J90, T90 (both the CFP variant and the IEEE variant) and SV1.  (For
  15. the T3E and T3D systems, see the `alpha' subdirectory at the same
  16. level as the directory containing this file.)
  17. The cfp subdirectory is for systems utilizing the traditional Cray
  18. floating-point format, and the ieee subdirectory is for the newer
  19. systems that use the IEEE floating-point format.
  20. There are several issues that reduces speed on Cray systems.  For
  21. systems with cfp floating point, the main obstacle is the forming of
  22. 128-bit products.  For IEEE systems, adding, and in particular
  23. computing carry is the main issue.  There are no vectorizing
  24. unsigned-less-than instructions, and the sequence that implement that
  25. operation is very long.
  26. Shifting is the only operation that is simple to make fast.  All Cray
  27. systems have a bitblt instructions (Vi Vj,Vj<Ak and Vi Vj,Vj>Ak) that
  28. should be really useful.
  29. For best speed for cfp systems, we need a mul_basecase, since that
  30. reduces the need for carry propagation to a minimum.  Depending on the
  31. size (vn) of the smaller of the two operands (V), we should split U and V
  32. in different chunk sizes:
  33. U split in 2 32-bit parts
  34. V split according to the table:
  35. parts 4 5 6 7 8
  36. bits/part 16 13 11 10 8
  37. max allowed vn 1 8 32 64 256
  38. number of multiplies 8 10 12 14 16
  39. peak cycles/limb 4 5 6 7 8
  40. U split in 3 22-bit parts
  41. V split according to the table:
  42. parts 3 4 5
  43. bits/part 22 16 13
  44. max allowed vn 16 1024 8192
  45. number of multiplies 9 12 15
  46. peak cycles/limb 4.5 6 7.5
  47. U split in 4 16-bit parts
  48. V split according to the table:
  49. parts 4
  50. bits/part 16
  51. max allowed vn 65536
  52. number of multiplies 16
  53. peak cycles/limb 8
  54. (A T90 CPU can accumulate two products per cycle.)
  55. IDEA:
  56. * Rewrite mpn_add_n:
  57.     short cy[n + 1];
  58.     #pragma _CRI ivdep
  59.       for (i = 0; i < n; i++)
  60. { s = up[i] + vp[i];
  61.   rp[i] = s;
  62.   cy[i + 1] = s < up[i]; }
  63.       more_carries = 0;
  64.     #pragma _CRI ivdep
  65.       for (i = 1; i < n; i++)
  66. { s = rp[i] + cy[i];
  67.   rp[i] = s;
  68.   more_carries += s < cy[i]; }
  69.       cys = 0;
  70.       if (more_carries)
  71. {
  72.   cys = rp[1] < cy[1];
  73.   for (i = 2; i < n; i++)
  74.     { rp[i] += cys;
  75.       cys = rp[i] < cys; }
  76. }
  77.       return cys + cy[n];
  78. * Write mpn_add3_n for adding three operands.  First add operands 1
  79.   and 2, and generate cy[].  Then add operand 3 to the partial result,
  80.   and accumulate carry into cy[].  Finally propagate carry just like
  81.   in the new mpn_add_n.
  82. IDEA:
  83. Store fewer bits, perhaps 62, per limb.  That brings mpn_add_n time
  84. down to 2.5 cycles/limb and mpn_addmul_1 times to 4 cycles/limb.  By
  85. storing even fewer bits per limb, perhaps 56, it would be possible to
  86. write a mul_mul_basecase that would run at effectively 1 cycle/limb.
  87. (Use VM here to better handle the romb-shaped multiply area, perhaps
  88. rouding operand sizes up to the next power of 2.)