Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
[simix] Use C++ templates for generating the marshaling/unmashaling code
[simgrid.git] / src / simix / simcalls.py
1 #!/usr/bin/env python
2 # -*- coding: utf-8 -*-
3
4 # Copyright (c) 2014-2015. The SimGrid Team. All rights reserved.
5
6 # This program is free software; you can redistribute it and/or modify it
7 # under the terms of the license (GNU LGPL) which comes with this package.
8
9 import re
10 import glob
11
12 types = [
13     ('char', 'c'),
14     ('const char*', 'cc'),
15     ('int', 'i'),
16     ('long', 'l'),
17     ('unsigned char', 'uc'),
18     ('unsigned short', 'us'),
19     ('unsigned int', 'ui'),
20     ('unsigned long', 'ul'),
21     ('float', 'f'),
22     ('double', 'd'),
23     ('void*', 'dp'),
24     ('FPtr', 'fp'),
25     ('const void*', 'cp'),
26     ('size_t', 'sz'),
27     ('sg_size_t', 'sgsz'),
28     ('sg_offset_t', 'sgoff'),
29     ('void', ''),
30     ('void*', 'dp'),
31     ('FPtr', 'fp'),
32     ]
33
34
35 class Arg(object):
36     simcall_types = {k: v for k, v in types}
37
38     def __init__(self, name, type, casted=None):
39         self.name = name
40         self.type = type
41         self.casted = casted
42         assert type in self.simcall_types, '%s not in (%s)' % (
43             type, ', '.join(self.simcall_types.keys()))
44
45     def field(self):
46         return self.simcall_types[self.type]
47
48     def rettype(self):
49         return '%s' % self.casted if self.casted else self.type
50
51     def cast(self):
52         return '(%s)' % self.casted if self.casted else ''
53
54
55 class Simcall(object):
56     simcalls_BODY = None
57     simcalls_PRE = None
58
59     def __init__(self, name, handler, res, args, call_kind):
60         self.name = name
61         self.res = res
62         self.args = args
63         self.need_handler = handler
64         self.call_kind = call_kind
65
66     def check(self):
67         # libsmx.c  simcall_BODY_
68         if self.simcalls_BODY is None:
69             f = open('libsmx.cpp')
70             self.simcalls_BODY = set(
71                 re.findall('simcall_BODY_(.*?)\(', f.read()))
72             f.close()
73         if self.name not in self.simcalls_BODY:
74             print '# ERROR: No function calling simcall_BODY_%s' % self.name
75             print '# Add something like this to libsmx.c:'
76             print '%s simcall_%s(%s) {' % (self.res.rettype(), self.name, ', '.join('%s %s' % (arg.rettype(), arg.name) for arg in self.args))
77             print '  return simcall_BODY_%s(%s);' % (self.name)
78             print '}'
79             return False
80
81         # smx_*.c void simcall_HANDLER_host_on(smx_simcall_t simcall,
82         # smx_host_t h)
83         if self.simcalls_PRE is None:
84             self.simcalls_PRE = set()
85             for fn in glob.glob('smx_*') + glob.glob('../mc/*'):
86                 f = open(fn)
87                 self.simcalls_PRE |= set(
88                     re.findall('simcall_HANDLER_(.*?)\(', f.read()))
89                 f.close()
90         if self.need_handler:
91             if (self.name not in self.simcalls_PRE):
92                 print '# ERROR: No function called simcall_HANDLER_%s' % self.name
93                 print '# Add something like this to the relevant C file (like smx_io.c if it\'s an IO call):'
94                 print '%s simcall_HANDLER_%s(smx_simcall_t simcall%s) {' % (self.res.rettype(), self.name, ''.join(', %s %s' % (arg.rettype(), arg.name)
95                                                                                                                    for arg in self.args))
96                 print '  // Your code handling the simcall'
97                 print '}'
98                 return False
99         else:
100             if (self.name in self.simcalls_PRE):
101                 print '# ERROR: You have a function called simcall_HANDLER_%s, but that simcall is not using any handler' % self.name
102                 print '# Either change your simcall definition, or kill that function'
103                 return False
104         return True
105
106     def enum(self):
107         return '  SIMCALL_%s,' % (self.name.upper())
108
109     def string(self):
110         return '  "SIMCALL_%s",' % self.name.upper()
111
112     def accessors(self):
113         res = []
114         res.append('')
115         # Arguments getter/setters
116         for i in range(len(self.args)):
117             arg = self.args[i]
118             res.append('static inline %s simcall_%s__get__%s(smx_simcall_t simcall) {' % (
119                 arg.rettype(), self.name, arg.name))
120             res.append(
121                 '  return simgrid::simix::unmarshal<%s>(simcall->args[%i]);' % (arg.rettype(), i))
122             res.append('}')
123             res.append('static inline void simcall_%s__set__%s(smx_simcall_t simcall, %s arg) {' % (
124                 self.name, arg.name, arg.rettype()))
125             res.append('    simgrid::simix::marshal<%s>(simcall->args[%i], arg);' % (arg.rettype(), i))
126             res.append('}')
127
128         # Return value getter/setters
129         if self.res.type != 'void':
130             res.append(
131                 'static inline %s simcall_%s__get__result(smx_simcall_t simcall){' % (self.res.rettype(), self.name))
132             res.append('    return simgrid::simix::unmarshal<%s>(simcall->result);' % self.res.rettype())
133             res.append('}')
134             res.append(
135                 'static inline void simcall_%s__set__result(smx_simcall_t simcall, %s result){' % (self.name, self.res.rettype()))
136             res.append('    simgrid::simix::marshal<%s>(simcall->result, result);' % (self.res.rettype()))
137             res.append('}')
138         return '\n'.join(res)
139
140     def case(self):
141         res = []
142         args = [ ("simgrid::simix::unmarshal<%s>(simcall->args[%d])" % (arg.rettype(), i))
143             for i, arg in enumerate(self.args) ]
144         res.append('case SIMCALL_%s:' % (self.name.upper()))
145         if self.need_handler:
146             call = "simcall_HANDLER_%s(simcall%s%s)" % (self.name,
147                 ", " if len(args) > 0 else "",
148                 ', '.join(args))
149         else:
150             call = "SIMIX_%s(%s)" % (self.name, ', '.join(args))
151         if self.call_kind == 'Func':
152             res.append("      simgrid::simix::marshal<%s>(simcall->result, %s);" % (self.res.rettype(), call))
153         else:
154             res.append("      " + call + ";");
155         res.append('      %sbreak;  \n' %
156                    ('SIMIX_simcall_answer(simcall);\n      ' if self.call_kind != 'Blck' else ' '))
157         return '\n'.join(res)
158
159     def body(self):
160         res = ['  ']
161         res.append(
162             'inline static %s simcall_BODY_%s(%s) {' % (self.res.rettype(),
163                                                         self.name,
164                                                         ', '.join('%s %s' % (arg.rettype(), arg.name) for arg in self.args)))
165         res.append(
166             '    /* Go to that function to follow the code flow through the simcall barrier */')
167         if self.need_handler:
168             res.append('    if (0) simcall_HANDLER_%s(%s);' % (self.name,
169                                                                ', '.join(["&SIMIX_process_self()->simcall"] + [arg.name for arg in self.args])))
170         else:
171             res.append('    if (0) SIMIX_%s(%s);' % (self.name,
172                                                      ', '.join(arg.name for arg in self.args)))
173         res.append('    return simcall<%s%s>(SIMCALL_%s%s);' % (
174             self.res.rettype(),
175             "".join([ ", " + arg.rettype() for i, arg in enumerate(self.args) ]),
176             self.name.upper(),
177             "".join([ ", " + arg.name for i, arg in enumerate(self.args) ])
178             ));
179         res.append('  }')
180         return '\n'.join(res)
181
182     def handler_prototype(self):
183         if self.need_handler:
184             return "XBT_PRIVATE %s simcall_HANDLER_%s(smx_simcall_t simcall%s);" % (self.res.rettype() if self.call_kind == 'Func' else 'void',
185                                                                                     self.name,
186                                                                                     ''.join(', %s %s' % (arg.rettype(), arg.name)
187                                                                                             for i, arg in enumerate(self.args)))
188         else:
189             return ""
190
191
192 def parse(fn):
193     simcalls = []
194     resdi = None
195     simcalls_guarded = {}
196     for line in open(fn).read().split('\n'):
197         if line.startswith('##'):
198             resdi = []
199             simcalls_guarded[re.search(r'## *(.*)', line).group(1)] = resdi
200         if line.startswith('#') or not line:
201             continue
202         match = re.match(
203             r'(\S*?) *(\S*?) *(\S*?) *\((.*?)(?:, *(.*?))?\) *(.*)', line)
204         assert match, line
205         ans, handler, name, rest, resc, args = match.groups()
206         assert (ans == 'Proc' or ans == 'Func' or ans == 'Blck'), "Invalid call type: '%s'. Faulty line:\n%s\n" % (
207             ans, line)
208         assert (handler == 'H' or handler == '-'), "Invalid need_handler indication: '%s'. Faulty line:\n%s\n" % (
209             handler, line)
210         sargs = []
211         for n, t, c in re.findall(r'\((.*?), *(.*?)(?:, *(.*?))?\)', args):
212             sargs.append(Arg(n, t, c))
213         sim = Simcall(name, handler == 'H',
214                       Arg('result', rest, resc), sargs, ans)
215         if resdi is None:
216             simcalls.append(sim)
217         else:
218             resdi.append(sim)
219     return simcalls, simcalls_guarded
220
221
222 def header(name):
223     fd = open(name, 'w')
224     fd.write(
225         '/**********************************************************************/\n')
226     fd.write(
227         '/* File generated by src/simix/simcalls.py from src/simix/simcalls.in */\n')
228     fd.write(
229         '/*                                                                    */\n')
230     fd.write(
231         '/*                    DO NOT EVER CHANGE THIS FILE                    */\n')
232     fd.write(
233         '/*                                                                    */\n')
234     fd.write(
235         '/* change simcalls specification in src/simix/simcalls.in             */\n')
236     fd.write(
237         '/**********************************************************************/\n\n')
238     fd.write('/*\n')
239     fd.write(
240         ' * Note that the name comes from http://en.wikipedia.org/wiki/Popping\n')
241     fd.write(
242         ' * Indeed, the control flow is doing a strange dance in there.\n')
243     fd.write(' *\n')
244     fd.write(
245         ' * That\'s not about http://en.wikipedia.org/wiki/Poop, despite the odor :)\n')
246     fd.write(' */\n\n')
247     return fd
248
249
250 def handle(fd, func, simcalls, guarded_simcalls):
251     def nonempty(e): return e != ''
252     fd.write(
253         '\n'.join(filter(nonempty, (func(simcall) for simcall in simcalls))))
254
255     for guard, list in guarded_simcalls.items():
256         fd.write('\n#if %s\n' % (guard))
257         fd.write('\n'.join(func(simcall) for simcall in list))
258         fd.write('\n#endif\n')
259
260 if __name__ == '__main__':
261     import sys
262     simcalls, simcalls_dict = parse('simcalls.in')
263
264     ok = True
265     ok &= all(map(Simcall.check, simcalls))
266     for k, v in simcalls_dict.items():
267         ok &= all(map(Simcall.check, v))
268     # FIXME: we should not hide it
269     # if not ok:
270     #  print ("Some checks fail!")
271     #  sys.exit(1)
272
273     #
274     # smx_popping_accessors.c
275     #
276     fd = header('popping_accessors.h')
277     fd.write('#include "src/simix/popping_private.h"');
278     handle(fd, Simcall.accessors, simcalls, simcalls_dict)
279     fd.write(
280         "\n\n/* The prototype of all simcall handlers, automatically generated for you */\n\n")
281     handle(fd, Simcall.handler_prototype, simcalls, simcalls_dict)
282     fd.close()
283
284     #
285     # smx_popping_enum.c
286     #
287     fd = header("popping_enum.h")
288     fd.write('/**\n')
289     fd.write(' * @brief All possible simcalls.\n')
290     fd.write(' */\n')
291     fd.write('typedef enum {\n')
292     fd.write('  SIMCALL_NONE,\n')
293
294     handle(fd, Simcall.enum, simcalls, simcalls_dict)
295
296     fd.write('  NUM_SIMCALLS\n')
297     fd.write('} e_smx_simcall_t;\n')
298     fd.close()
299
300     #
301     # smx_popping_generated.cpp
302     #
303
304     fd = header("popping_generated.cpp")
305
306     fd.write('#include <xbt/base.h>\n')
307     fd.write('#include "smx_private.h"\n')
308     fd.write('#if HAVE_MC\n')
309     fd.write('#include "src/mc/mc_forward.hpp"\n')
310     fd.write('#endif\n')
311     fd.write('\n')
312     fd.write('XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_popping);\n\n')
313
314     fd.write(
315         '/** @brief Simcalls\' names (generated from src/simix/simcalls.in) */\n')
316     fd.write('const char* simcall_names[] = {\n')
317
318     fd.write('   "SIMCALL_NONE",')
319     handle(fd, Simcall.string, simcalls, simcalls_dict)
320
321     fd.write('};\n\n')
322
323     fd.write('/** @private\n')
324     fd.write(
325         ' * @brief (in kernel mode) unpack the simcall and activate the handler\n')
326     fd.write(' * \n')
327     fd.write(' * This function is generated from src/simix/simcalls.in\n')
328     fd.write(' */\n')
329     fd.write(
330         'void SIMIX_simcall_handle(smx_simcall_t simcall, int value) {\n')
331     fd.write(
332         '  XBT_DEBUG("Handling simcall %p: %s", simcall, SIMIX_simcall_name(simcall->call));\n')
333     fd.write('  SIMCALL_SET_MC_VALUE(simcall, value);\n')
334     fd.write(
335         '  if (simcall->issuer->context->iwannadie && simcall->call != SIMCALL_PROCESS_CLEANUP)\n')
336     fd.write('    return;\n')
337     fd.write('  switch (simcall->call) {\n')
338
339     handle(fd, Simcall.case, simcalls, simcalls_dict)
340
341     fd.write('    case NUM_SIMCALLS:\n')
342     fd.write('      break;\n')
343     fd.write('    case SIMCALL_NONE:\n')
344     fd.write(
345         '      THROWF(arg_error,0,"Asked to do the noop syscall on %s@%s",\n')
346     fd.write('          SIMIX_process_get_name(simcall->issuer),\n')
347     fd.write(
348         '          sg_host_get_name(SIMIX_process_get_host(simcall->issuer))\n')
349     fd.write('          );\n')
350     fd.write('      break;\n')
351     fd.write('\n')
352     fd.write('  }\n')
353     fd.write('}\n')
354
355     fd.close()
356
357     #
358     # smx_popping_bodies.cpp
359     #
360     fd = header('popping_bodies.cpp')
361     fd.write('#include "smx_private.h"\n')
362     fd.write('#include "src/mc/mc_forward.hpp"\n')
363     fd.write('#include "xbt/ex.h"\n')
364     fd.write('#include <simgrid/simix.hpp>\n')
365     fd.write("/** @cond */ // Please Doxygen, don't look at this\n")
366     fd.write('''
367 template<class R, class... T>
368 inline static R simcall(e_smx_simcall_t call, T const&... t)
369 {
370   smx_process_t self = SIMIX_process_self();
371   simgrid::simix::marshal(&self->simcall, call, t...);
372   if (self != simix_global->maestro_process) {
373     XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name.c_str(),
374               SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
375     SIMIX_process_yield(self);
376   } else {
377     SIMIX_simcall_handle(&self->simcall, 0);
378   }
379   return simgrid::simix::unmarshal<R>(self->simcall.result);
380 }
381 ''')
382     handle(fd, Simcall.body, simcalls, simcalls_dict)
383     fd.write("/** @endcond */\n");
384     fd.close()