← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/ecl/intrepid

« back to all changes in this revision

Viewing changes to src/gmp/tests/devel/rshift.c

  • Committer: Bazaar Package Importer
  • Author(s): Peter Van Eynde
  • Date: 2006-05-17 02:46:26 UTC
  • Revision ID: james.westby@ubuntu.com-20060517024626-lljr08ftv9g9vefl
Tags: upstream-0.9h-20060510
Import upstream version 0.9h-20060510

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gmp/tests/devel/rshift.c
 
1
/*
 
2
Copyright 1996, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
 
3
 
 
4
This file is part of the GNU MP Library.
 
5
 
 
6
The GNU MP Library is free software; you can redistribute it and/or modify
 
7
it under the terms of the GNU Lesser General Public License as published by
 
8
the Free Software Foundation; either version 2.1 of the License, or (at your
 
9
option) any later version.
 
10
 
 
11
The GNU MP Library is distributed in the hope that it will be useful, but
 
12
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 
13
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 
14
License for more details.
 
15
 
 
16
You should have received a copy of the GNU Lesser General Public License
 
17
along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
 
18
the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 
19
MA 02111-1307, USA.
 
20
*/
 
21
 
 
22
#include <stdio.h>
 
23
#include "gmp.h"
 
24
#include "gmp-impl.h"
 
25
 
 
26
#if defined (USG) || defined (__SVR4) || defined (_UNICOS) || defined (__hpux)
 
27
#include <time.h>
 
28
 
 
29
int
 
30
cputime ()
 
31
{
 
32
  if (CLOCKS_PER_SEC < 100000)
 
33
    return clock () * 1000 / CLOCKS_PER_SEC;
 
34
  return clock () / (CLOCKS_PER_SEC / 1000);
 
35
}
 
36
#else
 
37
#include <sys/types.h>
 
38
#include <sys/time.h>
 
39
#include <sys/resource.h>
 
40
 
 
41
int
 
42
cputime ()
 
43
{
 
44
  struct rusage rus;
 
45
 
 
46
  getrusage (0, &rus);
 
47
  return rus.ru_utime.tv_sec * 1000 + rus.ru_utime.tv_usec / 1000;
 
48
}
 
49
#endif
 
50
 
 
51
#define M * 1000000
 
52
 
 
53
#ifndef CLOCK
 
54
#error "Don't know CLOCK of your machine"
 
55
#endif
 
56
 
 
57
#ifndef OPS
 
58
#define OPS (CLOCK/5)
 
59
#endif
 
60
#ifndef SIZE
 
61
#define SIZE 496
 
62
#endif
 
63
#ifndef TIMES
 
64
#define TIMES OPS/SIZE
 
65
#else
 
66
#undef OPS
 
67
#define OPS (SIZE*TIMES)
 
68
#endif
 
69
 
 
70
mp_limb_t
 
71
refmpn_rshift (wp, up, usize, cnt)
 
72
     register mp_ptr wp;
 
73
     register mp_srcptr up;
 
74
     mp_size_t usize;
 
75
     register unsigned int cnt;
 
76
{
 
77
  register mp_limb_t high_limb, low_limb;
 
78
  register unsigned sh_1, sh_2;
 
79
  register mp_size_t i;
 
80
  mp_limb_t retval;
 
81
 
 
82
#ifdef DEBUG
 
83
  if (usize == 0 || cnt == 0)
 
84
    abort ();
 
85
#endif
 
86
 
 
87
  sh_1 = cnt;
 
88
#if 0
 
89
  if (sh_1 == 0)
 
90
    {
 
91
      if (wp != up)
 
92
        {
 
93
          /* Copy from low end to high end, to allow specified input/output
 
94
             overlapping.  */
 
95
          for (i = 0; i < usize; i++)
 
96
            wp[i] = up[i];
 
97
        }
 
98
      return 0;
 
99
    }
 
100
#endif
 
101
 
 
102
  wp -= 1;
 
103
  sh_2 = BITS_PER_MP_LIMB - sh_1;
 
104
  high_limb = up[0];
 
105
  retval = high_limb << sh_2;
 
106
  low_limb = high_limb;
 
107
 
 
108
  for (i = 1; i < usize; i++)
 
109
    {
 
110
      high_limb = up[i];
 
111
      wp[i] = (low_limb >> sh_1) | (high_limb << sh_2);
 
112
      low_limb = high_limb;
 
113
    }
 
114
  low_limb >>= sh_1;
 
115
  wp[i] = low_limb;
 
116
 
 
117
  return retval;
 
118
}
 
119
 
 
120
#ifndef CNT
 
121
#define CNT 4
 
122
#endif
 
123
 
 
124
main (argc, argv)
 
125
     int argc;
 
126
     char **argv;
 
127
{
 
128
  mp_limb_t s1[SIZE];
 
129
  mp_limb_t dx[SIZE+2];
 
130
  mp_limb_t dy[SIZE+2];
 
131
  mp_limb_t cyx, cyy;
 
132
  int i;
 
133
  long t0, t;
 
134
  int test;
 
135
  int cnt = CNT;
 
136
  mp_size_t size;
 
137
 
 
138
  for (test = 0; ; test++)
 
139
    {
 
140
#if TIMES == 1 && ! defined (PRINT)
 
141
      if (test % (SIZE > 10000 ? 1 : 10000 / SIZE) == 0)
 
142
        {
 
143
          printf ("\r%d", test);
 
144
          fflush (stdout);
 
145
        }
 
146
#endif
 
147
 
 
148
#if TIMES == 1
 
149
      cnt = random () % (BITS_PER_MP_LIMB - 1) + 1;
 
150
#endif
 
151
 
 
152
#ifdef RANDOM
 
153
      size = random () % SIZE + 1;
 
154
#else
 
155
      size = SIZE;
 
156
#endif
 
157
      mpn_random2 (s1, size);
 
158
 
 
159
      dx[size+1] = 0x12345678;
 
160
      dy[size+1] = 0x12345678;
 
161
      dx[0] = 0x87654321;
 
162
      dy[0] = 0x87654321;
 
163
 
 
164
#if TIMES != 1
 
165
      mpn_random (s1, size);
 
166
 
 
167
#ifndef NOCHECK
 
168
      t0 = cputime();
 
169
      for (i = 0; i < TIMES; i++)
 
170
        refmpn_rshift (dx+1, s1, size, cnt);
 
171
      t = cputime() - t0;
 
172
      printf ("refmpn_rshift: %5ldms (%.2f cycles/limb)\n",
 
173
              t, ((double) t * CLOCK) / (OPS * 1000.0));
 
174
#endif
 
175
 
 
176
      t0 = cputime();
 
177
      for (i = 0; i < TIMES; i++)
 
178
        mpn_rshift (dx+1, s1, size, cnt);
 
179
      t = cputime() - t0;
 
180
      printf ("mpn_rshift:    %5ldms (%.2f cycles/limb)\n",
 
181
              t, ((double) t * CLOCK) / (OPS * 1000.0));
 
182
#endif
 
183
 
 
184
#ifndef NOCHECK
 
185
      mpn_random2 (s1, size);
 
186
 
 
187
#ifdef PRINT
 
188
      printf ("%-*d ", (int) (2 * sizeof(mp_limb_t)), cnt); mpn_print (s1, size);
 
189
#endif
 
190
 
 
191
      /* Put garbage in the destination.  */
 
192
      for (i = 0; i < size; i++)
 
193
        {
 
194
          dx[i+1] = 0xdead;
 
195
          dy[i+1] = 0xbeef;
 
196
        }
 
197
 
 
198
      cyx = refmpn_rshift (dx+1, s1, size, cnt);
 
199
      cyy = mpn_rshift (dy+1, s1, size, cnt);
 
200
#ifdef PRINT
 
201
      printf ("%*lX ", (int) (2 * sizeof(mp_limb_t)), cyx);
 
202
      mpn_print (dx+1, size);
 
203
      printf ("%*lX ", (int) (2 * sizeof(mp_limb_t)), cyy);
 
204
      mpn_print (dy+1, size);
 
205
#endif
 
206
      if (cyx != cyy || mpn_cmp (dx, dy, size+2) != 0
 
207
          || dx[0] != 0x87654321 || dx[size+1] != 0x12345678)
 
208
        {
 
209
#ifndef PRINT
 
210
          printf ("%*lX ", (int) (2 * sizeof(mp_limb_t)), cyx);
 
211
          mpn_print (dx+1, size);
 
212
          printf ("%*lX ", (int) (2 * sizeof(mp_limb_t)), cyy);
 
213
          mpn_print (dy+1, size);
 
214
#endif
 
215
          printf ("\n");
 
216
          if (dy[0] != 0x87654321)
 
217
            printf ("clobbered at low end\n");
 
218
          if (dy[size+1] != 0x12345678)
 
219
            printf ("clobbered at high end\n");
 
220
          printf ("TEST NUMBER %u\n", test);
 
221
          abort();
 
222
        }
 
223
#endif
 
224
    }
 
225
}
 
226
 
 
227
mpn_print (mp_ptr p, mp_size_t size)
 
228
{
 
229
  mp_size_t i;
 
230
 
 
231
  for (i = size - 1; i >= 0; i--)
 
232
    {
 
233
#ifdef _LONG_LONG_LIMB
 
234
      printf ("%0*lX%0*lX", (int) (sizeof(mp_limb_t)),
 
235
              (unsigned long) (p[i] >> (BITS_PER_MP_LIMB/2)),
 
236
              (int) (sizeof(mp_limb_t)), (unsigned long) (p[i]));
 
237
#else
 
238
      printf ("%0*lX", (int) (2 * sizeof(mp_limb_t)), p[i]);
 
239
#endif
 
240
#ifdef SPACE
 
241
      if (i != 0)
 
242
        printf (" ");
 
243
#endif
 
244
    }
 
245
  puts ("");
 
246
}