00001
00002
00003 extern "C" void abort ();
00004
00005 template <typename T>
00006 class J
00007 {
00008 public:
00009 J(T x, T y) : b (x), e (y) {}
00010 T begin ();
00011 T end ();
00012 private:
00013 T b, e;
00014 };
00015
00016 template <typename T> T J<T>::begin () { return b; }
00017 template <typename T> T J<T>::end () { return e; }
00018
00019 int results[2000];
00020
00021 void
00022 baz (int i)
00023 {
00024 if (i < 0 || i >= 2000)
00025 abort ();
00026 results[i]++;
00027 }
00028
00029 void
00030 f1 (int x, int y)
00031 {
00032 #pragma omp parallel for
00033 for (int i = x; i <= y; i += 6)
00034 baz (i);
00035 }
00036
00037 void
00038 f2 (int x, int y)
00039 {
00040 int i;
00041 #pragma omp parallel for private(i)
00042 for (i = x; i < y - 1; i = 1 - 6 + 7 + i)
00043 baz (i);
00044 }
00045
00046 template <typename T>
00047 void
00048 f3 (int x, int y)
00049 {
00050 #pragma omp parallel for
00051 for (int i = x; i <= y; i = i + 9 - 8)
00052 baz (i);
00053 }
00054
00055 template <typename T>
00056 void
00057 f4 (int x, int y)
00058 {
00059 int i;
00060 #pragma omp parallel for lastprivate(i)
00061 for (i = x + 2000 - 64; i > y + 10; --i)
00062 baz (i);
00063 }
00064
00065 void
00066 f5 (int x, int y)
00067 {
00068 #pragma omp parallel for
00069 for (int i = x + 2000 - 64; i > y + 10L; i -= 10L)
00070 baz (i);
00071 }
00072
00073 template <int N>
00074 void
00075 f6 (int x, int y)
00076 {
00077 #pragma omp parallel for
00078 for (int i = x + 2000 - 64; i > y + 10L; i = i - 12 + 2L)
00079 baz (i + N);
00080 }
00081
00082 template <long N>
00083 void
00084 f7 (int i, int x, int y)
00085 {
00086 #pragma omp parallel for
00087 for (i = x - 10; i <= y + 10; i += N)
00088 baz (i);
00089 }
00090
00091 template <long N>
00092 void
00093 f8 (J<int> j)
00094 {
00095 int i;
00096 #pragma omp parallel for
00097 for (i = j.begin (); i <= j.end () + N; i += 2)
00098 baz (i);
00099 }
00100
00101 template <typename T, long N>
00102 void
00103 f9 (T x, T y)
00104 {
00105 #pragma omp parallel for
00106 for (T i = x; i <= y; i = i + N)
00107 baz (i);
00108 }
00109
00110 template <typename T, long N>
00111 void
00112 f10 (T x, T y)
00113 {
00114 T i;
00115 #pragma omp parallel for
00116 for (i = x; i > y; i = i + N)
00117 baz (i);
00118 }
00119
00120 template <typename T>
00121 void
00122 f11 (T x, long y)
00123 {
00124 #pragma omp parallel
00125 {
00126 #pragma omp for nowait
00127 for (T i = x; i <= y; i += 3L)
00128 baz (i);
00129 #pragma omp single
00130 baz (y + 3);
00131 }
00132 }
00133
00134 template <typename T>
00135 void
00136 f12 (T x, T y)
00137 {
00138 T i;
00139 #pragma omp parallel for
00140 for (i = x; i > y; --i)
00141 baz (i);
00142 }
00143
00144 #define check(expr) \
00145 for (int i = 0; i < 2000; i++) \
00146 if (expr) \
00147 { \
00148 if (results[i] != 1) \
00149 abort (); \
00150 results[i] = 0; \
00151 } \
00152 else if (results[i]) \
00153 abort ()
00154
00155 int
00156 main ()
00157 {
00158 f1 (10, 1990);
00159 check (i >= 10 && i <= 1990 && (i - 10) % 6 == 0);
00160 f2 (0, 1999);
00161 check (i < 1998 && (i & 1) == 0);
00162 f3<char> (20, 1837);
00163 check (i >= 20 && i <= 1837);
00164 f4<int> (0, 30);
00165 check (i > 40 && i <= 2000 - 64);
00166 f5 (0, 100);
00167 check (i >= 116 && i <= 2000 - 64 && (i - 116) % 10 == 0);
00168 f6<-10> (10, 110);
00169 check (i >= 116 && i <= 2000 - 64 && (i - 116) % 10 == 0);
00170 f7<6> (0, 12, 1800);
00171 check (i >= 2 && i <= 1808 && (i - 2) % 6 == 0);
00172 f8<121> (J<int> (14, 1803));
00173 check (i >= 14 && i <= 1924 && (i & 1) == 0);
00174 f9<int, 7> (33, 1967);
00175 check (i >= 33 && i <= 1967 && (i - 33) % 7 == 0);
00176 f10<int, -7> (1939, 17);
00177 check (i >= 21 && i <= 1939 && (i - 21) % 7 == 0);
00178 f11<int> (16, 1981);
00179 check (i >= 16 && i <= 1984 && (i - 16) % 3 == 0);
00180 f12<int> (1761, 37);
00181 check (i > 37 && i <= 1761);
00182 }