generate_automake_test_programs.py 5.94 KB
Newer Older
1
2
3
4
#!/usr/bin/env python
from __future__ import print_function
from itertools import product

Pavel Kus's avatar
Pavel Kus committed
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
def create_test(m, g, t, p, d, s, l, language) :
    for kernel in ["all_kernels", "default_kernel"] if s == "2stage" else ["nokernel"]:
        endifs = 0
        extra_flags = []

        if (t == "eigenvalues" and kernel == "all_kernels"):
           continue

        if (g == 1):
            print("if WITH_GPU_VERSION")
            endifs += 1

        if (l == "all_layouts"):
            print("if WITH_MPI")
            endifs += 1

        if (s in ["scalapack_all", "scalapack_part"]):
            print("if WITH_SCALAPACK_TESTS")
            endifs += 1

        if kernel == "default_kernel":
            extra_flags.append("-DTEST_KERNEL=ELPA_2STAGE_{0}_DEFAULT".format(d.upper()))
        elif kernel == "all_kernels":
            extra_flags.append("-DTEST_ALL_KERNELS")

        if layout_flag[l]:
            extra_flags.append(layout_flag[l])

        if (p == "single"):
            if (d == "real"):
                print("if WANT_SINGLE_PRECISION_REAL")
            elif (d == "complex"):
                print("if WANT_SINGLE_PRECISION_COMPLEX")
            else:
                raise Exception("Oh no!")
            endifs += 1

        name = "test_{0}_{1}_{2}_{3}{4}{5}{6}{7}{8}".format(
                    d, p, t, s,
                    "" if kernel == "nokernel" else "_" + kernel,
                    "" if language == "fortran" else "_fromC",
                    "_gpu" if g else "",
                    "_analytic" if m == "analytic" else "",
                    "_all_layouts" if l == "all_layouts" else "")
        print("noinst_PROGRAMS += " + name)
        print("check_SCRIPTS += " + name + ".sh")
        if(language == "fortran"):
            print(name + "_SOURCES = test/Fortran/test.F90")
            print(name + "_LDADD = $(test_program_ldadd)")
            print(name + "_FCFLAGS = $(test_program_fcflags) \\")
        elif(language == "c"):
            print(name + "_SOURCES = test/C/test.c")
            print(name + "_LDADD = $(test_program_ldadd) $(FCLIBS)")
            print(name + "_CFLAGS = $(test_program_cflags) \\")
        else:
            raise Exception("Oh no, unknown language!")
        print("  -DTEST_CASE=\\\"{0}\\\" \\".format(name))
        print("  " + " \\\n  ".join([
            domain_flag[d],
            prec_flag[p],
            test_type_flag[t],
            solver_flag[s],
            gpu_flag[g],
            matrix_flag[m]] + extra_flags))

        print("endif\n" * endifs)

# generate Fortran tests
73
74
75
76
77
78
79
80
81
82
83
domain_flag = {
        "real"   : "-DTEST_REAL",
        "complex": "-DTEST_COMPLEX",
}
prec_flag = {
        "double" : "-DTEST_DOUBLE",
        "single" : "-DTEST_SINGLE",
}
solver_flag = {
        "1stage" : "-DTEST_SOLVER_1STAGE",
        "2stage" : "-DTEST_SOLVER_2STAGE",
Pavel Kus's avatar
Pavel Kus committed
84
        "scalapack_all" : "-DTEST_SCALAPACK_ALL",
85
        "scalapack_part" : "-DTEST_SCALAPACK_PART",
86
87
88
89
90
}
gpu_flag = {
        0 : "-DTEST_GPU=0",
        1 : "-DTEST_GPU=1",
}
Pavel Kus's avatar
Pavel Kus committed
91
92
93
94
matrix_flag = {
        "random" : "-DTEST_MATRIX_RANDOM",
        "analytic" : "-DTEST_MATRIX_ANALYTIC",
}
95

96
test_type_flag = {
97
98
99
        "eigenvectors" : "-DTEST_EIGENVECTORS",
        "eigenvalues"  : "-DTEST_EIGENVALUES",
        "solve_tridiagonal"  : "-DTEST_SOLVE_TRIDIAGONAL",
100
        "cholesky"  : "-DTEST_CHOLESKY",
101
        "hermitian_multiply"  : "-DTEST_HERMITIAN_MULTIPLY",
102
        "qr"  : "-DTEST_QR_DECOMPOSITION",
Pavel Kus's avatar
Pavel Kus committed
103
        "generalized"  : "-DTEST_GENERALIZED_EIGENPROBLEM",
104
105
}

106
107
108
109
110
111
layout_flag = {
        "all_layouts" : "-DTEST_ALL_LAYOUTS",
        "square" : ""
}
for m, g, t, p, d, s, l in product(
                             sorted(matrix_flag.keys()),
Pavel Kus's avatar
Pavel Kus committed
112
                             sorted(gpu_flag.keys()),
113
114
115
                             sorted(test_type_flag.keys()),
                             sorted(prec_flag.keys()),
                             sorted(domain_flag.keys()),
116
117
                             sorted(solver_flag.keys()),
                             sorted(layout_flag.keys())):
Pavel Kus's avatar
Pavel Kus committed
118
    if(m == "analytic" and (g == 1 or t != "eigenvectors")):
Pavel Kus's avatar
Pavel Kus committed
119
120
        continue

121
    if(s in ["scalapack_all", "scalapack_part"]  and (g == 1 or t != "eigenvectors" or m != "analytic")):
Pavel Kus's avatar
Pavel Kus committed
122
123
        continue

124
    if (t == "solve_tridiagonal" and (s == "2stage" or d == "complex")):
125
126
        continue

127
128
129
    if (t == "cholesky" and (s == "2stage")):
        continue

130
131
132
    if (t == "hermitian_multiply" and (s == "2stage")):
        continue

133
134
135
    if (t == "qr" and (s == "1stage" or d == "complex")):
        continue

Pavel Kus's avatar
Pavel Kus committed
136
    create_test(m, g, t, p, d, s, l, "fortran")
137
138


Pavel Kus's avatar
Pavel Kus committed
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
# generate C tests
domain_flag = {
        "real"   : "-DTEST_REAL",
        "complex": "-DTEST_COMPLEX",
}
prec_flag = {
        "double" : "-DTEST_DOUBLE",
        "single" : "-DTEST_SINGLE",
}
solver_flag = {
        "1stage" : "-DTEST_SOLVER_1STAGE",
        "2stage" : "-DTEST_SOLVER_2STAGE",
#        "scalapack_all" : "-DTEST_SCALAPACK_ALL",
#        "scalapack_part" : "-DTEST_SCALAPACK_PART",
}
gpu_flag = {
        0 : "-DTEST_GPU=0",
#        1 : "-DTEST_GPU=1",
}
matrix_flag = {
        "random" : "-DTEST_MATRIX_RANDOM",
#        "analytic" : "-DTEST_MATRIX_ANALYTIC",
}
162

Pavel Kus's avatar
Pavel Kus committed
163
164
165
166
167
168
169
170
test_type_flag = {
        "eigenvectors" : "-DTEST_EIGENVECTORS",
#        "eigenvalues"  : "-DTEST_EIGENVALUES",
#        "solve_tridiagonal"  : "-DTEST_SOLVE_TRIDIAGONAL",
#        "cholesky"  : "-DTEST_CHOLESKY",
#        "hermitian_multiply"  : "-DTEST_HERMITIAN_MULTIPLY",
#        "qr"  : "-DTEST_QR_DECOMPOSITION",
}
171

Pavel Kus's avatar
Pavel Kus committed
172
173
174
175
176
177
178
179
180
181
182
183
184
185
layout_flag = {
#        "all_layouts" : "-DTEST_ALL_LAYOUTS",
        "square" : ""
}
for m, g, t, p, d, s, l in product(
                             sorted(matrix_flag.keys()),
                             sorted(gpu_flag.keys()),
                             sorted(test_type_flag.keys()),
                             sorted(prec_flag.keys()),
                             sorted(domain_flag.keys()),
                             sorted(solver_flag.keys()),
                             sorted(layout_flag.keys())):

    create_test(m, g, t, p, d, s, l, "c")
186

187

188

189
190