| 0 | |
Description: From upstream, avoid nested C functions
|
| 1 | |
--- a/CUtils/c_sources/rhyper.c
|
| 2 | |
+++ b/CUtils/c_sources/rhyper.c
|
| 3 | |
@@ -52,55 +52,61 @@
|
| 4 | |
* If (i > 7), use Stirling's approximation, otherwise use table lookup.
|
| 5 | |
*/
|
| 6 | |
|
| 7 | |
-static double afc(int i)
|
| 8 | |
-{
|
| 9 | |
- static int computed=10;
|
| 10 | |
- static double al[1756] =
|
| 11 | |
- {
|
| 12 | |
- 0.0,
|
| 13 | |
- 0,/*ln(0!)*/
|
| 14 | |
- 0,/*ln(1!)*/
|
| 15 | |
- 0.693147180559945309,/*ln(2!)*/
|
| 16 | |
- 1.791759469228055,/*ln(3!)*/
|
| 17 | |
- 3.17805383034794562,/*ln(4!)*/
|
| 18 | |
- 4.78749174278204599,/*ln(5!)*/
|
| 19 | |
- 6.579251212010101,/*ln(6!)*/
|
| 20 | |
- 8.5251613610654143,/*ln(7!)*/
|
| 21 | |
- 10.6046029027452502,/*ln(8!)*/
|
| 22 | |
- 12.8018274800814696,/*ln(9!)*/
|
| 23 | |
- 15.1044125730755153,/*ln(10!)*/
|
| 24 | |
- };
|
| 25 | |
- double compute(int n) {
|
| 26 | |
- static long double cur=3628800;
|
| 27 | |
- static int i=11;
|
| 28 | |
- static volatile int mutex=0;
|
| 29 | |
-
|
| 30 | |
- while (__sync_lock_test_and_set(&mutex, 1)) {
|
| 31 | |
- /* Internal loop with only read to avoid cache line ping-pong
|
| 32 | |
- on multi-processors */
|
| 33 | |
- while(mutex) {
|
| 34 | |
- /* spinlock */
|
| 35 | |
- }
|
| 36 | |
- }
|
| 37 | |
+struct afc_data {
|
| 38 | |
+ int computed;
|
| 39 | |
+ double al[1756];
|
| 40 | |
+};
|
| 41 | |
+
|
| 42 | |
+double compute(int n, struct afc_data * __restrict__ data) {
|
| 43 | |
+ static long double cur=3628800;
|
| 44 | |
+ static int i=11;
|
| 45 | |
+ static volatile int mutex=0;
|
| 46 | |
|
| 47 | |
- for(; i<=n; i++) {
|
| 48 | |
- cur*=i;
|
| 49 | |
- al[i+1]=logl(cur);
|
| 50 | |
+ while (__sync_lock_test_and_set(&mutex, 1)) {
|
| 51 | |
+ /* Internal loop with only read to avoid cache line ping-pong
|
| 52 | |
+ on multi-processors */
|
| 53 | |
+ while(mutex) {
|
| 54 | |
+ /* spinlock */
|
| 55 | |
}
|
| 56 | |
- computed=n;
|
| 57 | |
- __sync_lock_release(&mutex);
|
| 58 | |
- return al[i];
|
| 59 | |
- };
|
| 60 | |
+ }
|
| 61 | |
|
| 62 | |
+ for(; i<=n; i++) {
|
| 63 | |
+ cur*=i;
|
| 64 | |
+ data->al[i+1]=logl(cur);
|
| 65 | |
+ }
|
| 66 | |
+ data->computed=n;
|
| 67 | |
+ __sync_lock_release(&mutex);
|
| 68 | |
+ return data->al[i];
|
| 69 | |
+};
|
| 70 | |
+
|
| 71 | |
+static double afc(int i)
|
| 72 | |
+{
|
| 73 | |
double di, value;
|
| 74 | |
+ static struct afc_data data = {
|
| 75 | |
+ .computed = 10,
|
| 76 | |
+ .al = {
|
| 77 | |
+ 0.0,
|
| 78 | |
+ 0,/*ln(0!)*/
|
| 79 | |
+ 0,/*ln(1!)*/
|
| 80 | |
+ 0.693147180559945309,/*ln(2!)*/
|
| 81 | |
+ 1.791759469228055,/*ln(3!)*/
|
| 82 | |
+ 3.17805383034794562,/*ln(4!)*/
|
| 83 | |
+ 4.78749174278204599,/*ln(5!)*/
|
| 84 | |
+ 6.579251212010101,/*ln(6!)*/
|
| 85 | |
+ 8.5251613610654143,/*ln(7!)*/
|
| 86 | |
+ 10.6046029027452502,/*ln(8!)*/
|
| 87 | |
+ 12.8018274800814696,/*ln(9!)*/
|
| 88 | |
+ 15.1044125730755153,/*ln(10!)*/
|
| 89 | |
+ }
|
| 90 | |
+ };
|
| 91 | |
|
| 92 | |
if (i < 0) {
|
| 93 | |
fprintf(stderr, "rhyper.c: afc(i), i=%d < 0 -- SHOULD NOT HAPPEN!\n", i);
|
| 94 | |
exit(1);
|
| 95 | |
- } else if (i <= computed) {
|
| 96 | |
- value = al[i + 1];
|
| 97 | |
+ } else if (i <= data.computed) {
|
| 98 | |
+ value = data.al[i + 1];
|
| 99 | |
} else if (i <= 1754) {
|
| 100 | |
- value = compute(i);
|
| 101 | |
+ value = compute(i, &data);
|
| 102 | |
} else {
|
| 103 | |
di = i;
|
| 104 | |
value = (di + 0.5) * log(di) - di + 0.08333333333333 / di
|