← Back to branch summary

~ubuntu-branches/ubuntu/utopic/adios/utopic

« back to all changes in this revision

Viewing changes to .pc/python3.patch/utils/skel/lib/skelconf.py

  • Committer: Package Import Robot
  • Author(s): Alastair McKinstry
  • Date: 2013-12-09 15:21:31 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20131209152131-jtd4fpmdv3xnunnm
Tags: 1.5.0-1
* New upstream.
* Standards-Version: 3.9.5
* Include latest config.{sub,guess} 
* New watch file.
* Create libadios-bin for binaries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/python3.patch/utils/skel/lib/skelconf.py
 
1
import xml.dom.minidom
 
2
 
 
3
import skel_settings
 
4
import skel_have_adios_timing
 
5
 
 
6
 
 
7
class skelConfig:
 
8
    def __init__ (self, infile):
 
9
        doc = xml.dom.minidom.parse (infile)
 
10
 
 
11
        nodes = doc.childNodes
 
12
        if (nodes.length != 1):
 
13
            print 'malformed param file, should contain only a single skel-config element'
 
14
            raise SystemExit
 
15
        self.config_node = nodes[0]
 
16
 
 
17
        self.groups = []
 
18
        self.group_dict = {}
 
19
 
 
20
        for node in self.config_node.getElementsByTagName('adios-group'):
 
21
            this_group = group (node)
 
22
            self.groups.append (this_group)
 
23
            self.group_dict[this_group.get_name()] = this_group
 
24
 
 
25
        self.batches = []
 
26
 
 
27
        for node in self.config_node.getElementsByTagName('batch'):
 
28
            self.batches.append (batch (node) )
 
29
 
 
30
    def get_group (self, name):
 
31
        return self.group_dict[name]
 
32
 
 
33
    def get_groups (self):
 
34
        return self.groups
 
35
 
 
36
    def get_batches (self):
 
37
        return self.batches
 
38
 
 
39
    def get_application (self):
 
40
        return self.config_node.getAttribute ('application')
 
41
 
 
42
    def get_target (self):
 
43
        target = self.config_node.getAttribute ('target')
 
44
 
 
45
        if target == None or target == '':
 
46
            return "default"
 
47
 
 
48
        return target
 
49
 
 
50
 
 
51
class group:
 
52
    def __init__ (self, group_node):
 
53
        self.group_node = group_node
 
54
 
 
55
        self.scalars = []
 
56
        self.arrays = []
 
57
 
 
58
        self.scalar_dict = {}
 
59
        self.array_dict = {}
 
60
 
 
61
        for node in self.group_node.childNodes:
 
62
            if (node.localName == 'scalar'):
 
63
                this_scalar = scalar (node)
 
64
                self.scalars.append (this_scalar)
 
65
                self.scalar_dict[this_scalar.get_name()] = this_scalar
 
66
            if (node.localName == 'array'):
 
67
                this_array = array (node)
 
68
                self.arrays.append (this_array)
 
69
                self.array_dict[this_array.get_name()] = this_array
 
70
 
 
71
    def get_name (self):
 
72
        return self.group_node.getAttribute ('name')
 
73
 
 
74
    def get_scalars (self):
 
75
        return self.scalars
 
76
 
 
77
    def get_scalar (self, name):
 
78
        return self.scalar_dict[name]
 
79
 
 
80
    def get_arrays (self):
 
81
        return self.arrays
 
82
 
 
83
    def get_array (self, name):
 
84
        return self.array_dict[name]
 
85
 
 
86
 
 
87
class batch:
 
88
    def __init__ (self, batch_node):
 
89
        self.batch_node = batch_node
 
90
 
 
91
        self.tests = []
 
92
        for node in self.batch_node.getElementsByTagName ('test'):
 
93
            self.tests.append (test (node) )
 
94
 
 
95
    def get_tests (self):
 
96
        return self.tests
 
97
 
 
98
    def get_name (self):
 
99
        return self.batch_node.getAttribute ('name')
 
100
 
 
101
    def get_cores (self):
 
102
        return int (self.batch_node.getAttribute ('cores') )
 
103
 
 
104
    def get_walltime (self):
 
105
        return self.batch_node.getAttribute ('walltime')
 
106
 
 
107
 
 
108
class test:
 
109
    def __init__ (self, test_node):
 
110
        self.test_node = test_node
 
111
        self.measure = measure (self.test_node.getAttribute ('measure') )
 
112
 
 
113
 
 
114
    def get_type (self):
 
115
        return self.test_node.getAttribute ('type')
 
116
 
 
117
    def get_method_params (self):
 
118
        return self.test_node.getAttribute ('method_params')
 
119
 
 
120
    def get_group_name (self):
 
121
        return self.test_node.getAttribute ('group')
 
122
 
 
123
    def get_method (self):
 
124
        return self.test_node.getAttribute ('method')
 
125
 
 
126
    def get_rm (self):
 
127
        return self.test_node.getAttribute ('rm')
 
128
 
 
129
    def get_tags (self):
 
130
        return self.test_node.getAttribute ('tags')
 
131
 
 
132
    def get_steps (self):
 
133
        steps = self.test_node.getAttribute ('steps')
 
134
        if steps == None or steps == '':
 
135
            return '1'
 
136
        else:
 
137
            return steps
 
138
 
 
139
    def get_iterations (self):
 
140
        iter = self.test_node.getAttribute ('iterations')
 
141
        if iter == None or iter == '':
 
142
            return '1'
 
143
        else:
 
144
            return iter
 
145
 
 
146
    def get_ext (self):
 
147
        return self.test_node.getAttribute ('ext')
 
148
 
 
149
    def get_measure (self):
 
150
        return self.measure
 
151
 
 
152
# the measure object hides the logic of which code to emit for the various measurement options
 
153
class measure:
 
154
    def __init__ (self, measure_string):
 
155
        self.settings_dict = skel_settings.skel_settings().get_settings_dict()
 
156
        self.measure_string = measure_string
 
157
 
 
158
    def use_barrier_before_open (self):
 
159
        val = self.settings_dict["barrier_before_open"]
 
160
        if val =="no":
 
161
            return False
 
162
 
 
163
        return True
 
164
 
 
165
    def use_barrier_before_access (self):
 
166
        val = self.settings_dict["barrier_before_access"]
 
167
        if val =="yes":
 
168
            return True 
 
169
 
 
170
        return False
 
171
 
 
172
    def use_barrier_before_close (self):
 
173
        val = self.settings_dict["barrier_before_close"]
 
174
        if val =="yes":
 
175
            return True 
 
176
 
 
177
        return False 
 
178
 
 
179
    def use_barrier_after_close (self):
 
180
        val = self.settings_dict["barrier_after_close"]
 
181
        if val =="yes":
 
182
            return True 
 
183
 
 
184
        return False 
 
185
 
 
186
    def use_barrier_before_final_time (self):
 
187
        val = self.settings_dict["barrier_after_steps"]
 
188
        if val =="no":
 
189
            return False 
 
190
 
 
191
        return True
 
192
 
 
193
    def use_reduce (self):
 
194
        #val = self.settings_dict["reduce_times"]
 
195
        #if val =="no":
 
196
        #    return False 
 
197
 
 
198
        # Only reduced output is available from skel. Use adios timing mechanism for more detailed results
 
199
 
 
200
        return True
 
201
 
 
202
    def report_all (self):
 
203
        #val = self.settings_dict["report_all"]
 
204
        #if val =="yes":
 
205
        #    return True 
 
206
 
 
207
        # Only reduced output is available from skel. Use adios timing mechanism for more detailed results
 
208
 
 
209
        return False
 
210
 
 
211
    def use_adios_timing (self):
 
212
        val = self.settings_dict["use_adios_timing"]
 
213
        if val =="yes" and skel_have_adios_timing.skel_have_adios_timing == True:
 
214
            return True 
 
215
 
 
216
        return False
 
217
 
 
218
    def use_sleep_before_open (self):
 
219
        val = self.settings_dict["sleep_before_open"]
 
220
        if val =="yes":
 
221
            return True 
 
222
 
 
223
        return False 
 
224
 
 
225
class scalar:
 
226
    def __init__ (self, scalar_node):
 
227
        self.scalar_node = scalar_node
 
228
 
 
229
    def get_name (self):
 
230
        return self.scalar_node.getAttribute ('name')
 
231
 
 
232
    def get_value (self):
 
233
        return self.scalar_node.getAttribute ('value')
 
234
 
 
235
 
 
236
class array:
 
237
    def __init__ (self, array_node):
 
238
        self.array_node = array_node
 
239
 
 
240
    def get_name (self):
 
241
        return self.array_node.getAttribute ('name')
 
242
 
 
243
    def get_gwrite (self):
 
244
        return self.array_node.getAttribute ('gwrite')
 
245
 
 
246
    def get_fill_method (self):
 
247
        return self.array_node.getAttribute ('fill-method')