Module: BOAST::MPPARuntime

Includes:
CRuntime
Defined in:
lib/BOAST/Runtime/MPPARuntime.rb

Instance Attribute Summary collapse

Attributes included from CompiledRuntime

#binary, #param_struct, #source

Instance Method Summary collapse

Methods included from CompiledRuntime

#build, #dump_binary, #dump_executable, #dump_module, #dump_source, #maqao_analysis, #reload_module

Instance Attribute Details

#binary_comp ⇒ Object

Returns the value of attribute binary_comp.



132
133
134
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 132

def binary_comp
  @binary_comp
end

#code_comp ⇒ Object

Returns the value of attribute code_comp.



130
131
132
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 130

def code_comp
  @code_comp
end

#multibinary ⇒ Object

Returns the value of attribute multibinary.



134
135
136
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 134

def multibinary
  @multibinary
end

#procedure_comp ⇒ Object

Returns the value of attribute procedure_comp.



131
132
133
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 131

def procedure_comp
  @procedure_comp
end

#source_comp ⇒ Object

Returns the value of attribute source_comp.



133
134
135
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 133

def source_comp
  @source_comp
end

Instance Method Details

#cleanup(kernel_files) ⇒ Object 



78
79
80
81
82
83
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 78

def cleanup(kernel_files)
  cleanup_old(kernel_files)
  ([io_bin, comp_bin, io_object, comp_object]).each { |fn|
    File::unlink(fn)
  }
end

#cleanup_old ⇒ Object 



71
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 71

alias cleanup_old cleanup

#comp_bin ⇒ Object 



101
102
103
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 101

def comp_bin
  return "#{base_path}.bincomp"
end

#comp_object ⇒ Object 



109
110
111
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 109

def comp_object
  return "#{base_path}.#{RbConfig::CONFIG["OBJEXT"]}comp"
end

#comp_source ⇒ Object 



117
118
119
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 117

def comp_source
  return "#{base_path}.ccomp"
end

#copy_array_param_from_host(param) ⇒ Object 



177
178
179
180
181
182
183
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 177

def copy_array_param_from_host( param )
  get_output.print <<EOF
  mppa_read(_mppa_from_host_size, &_mppa_#{param}_size, sizeof(_mppa_#{param}_size));
  #{param} = malloc(_mppa_#{param}_size);
  mppa_read(_mppa_from_host_var, #{param}, _mppa_#{param}_size);
EOF
end

#copy_array_param_from_ruby(par, param, ruby_param) ⇒ Object 



403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 403

def copy_array_param_from_ruby(par, param, ruby_param )
  rb_ptr = Variable::new("_boast_rb_ptr", CustomType, :type_name => "VALUE")
  (rb_ptr === ruby_param).pr
  get_output.print <<EOF
  if ( IsNArray(_boast_rb_ptr) ) {
struct NARRAY *_boast_n_ary;
size_t _boast_array_size;
Data_Get_Struct(_boast_rb_ptr, struct NARRAY, _boast_n_ary);
_boast_array_size = _boast_n_ary->total * na_sizeof[_boast_n_ary->type];
mppa_write(_mppa_fd_size, &_boast_array_size, sizeof(_boast_array_size));
#{par} = (void *) _boast_n_ary->ptr;
mppa_write(_mppa_fd_var, #{par}, _boast_array_size);
  } else {
rb_raise(rb_eArgError, "Wrong type of argument for %s, expecting array!", "#{param}");
  }
EOF
end

#copy_array_param_to_host(param) ⇒ Object 



200
201
202
203
204
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 200

def copy_array_param_to_host(param)
  get_output.print <<EOF
  mppa_write(_mppa_to_host_var, #{param}, _mppa_#{param}_size);
EOF
end

#copy_array_param_to_ruby(par, param, ruby_param) ⇒ Object 



471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 471

def copy_array_param_to_ruby(par, param, ruby_param)
  rb_ptr = Variable::new("_boast_rb_ptr", CustomType, :type_name => "VALUE")
  (rb_ptr === ruby_param).pr
  get_output.print <<EOF
  if ( IsNArray(_boast_rb_ptr) ) {
EOF
  if param.direction == :out or param.direction == :inout then
    get_output.print <<EOF
struct NARRAY *_boast_n_ary;
size_t _boast_array_size;
Data_Get_Struct(_boast_rb_ptr, struct NARRAY, _boast_n_ary);
_boast_array_size = _boast_n_ary->total * na_sizeof[_boast_n_ary->type];
mppa_read(_mppa_fd_var, #{par}, _boast_array_size);
EOF
  end
    get_output.print <<EOF
  } else {
rb_raise(rb_eArgError, "Wrong type of argument for %s, expecting array!", "#{param}");
  }
EOF
end

#copy_scalar_param_from_host(param) ⇒ Object 



185
186
187
188
189
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 185

def copy_scalar_param_from_host( param )
  get_output.print  <<EOF
  mppa_read(_mppa_from_host_var, &#{param}, sizeof(#{param}));
EOF
end

#copy_scalar_param_from_ruby(par, param, ruby_param) ⇒ Object 



421
422
423
424
425
426
427
428
429
430
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 421

def copy_scalar_param_from_ruby(par, param, ruby_param )
  case param.type
  when Int
    (par === FuncCall::new("NUM2INT", ruby_param)).pr if param.type.size == 4
    (par === FuncCall::new("NUM2LONG", ruby_param)).pr if param.type.size == 8
  when Real
    (par === FuncCall::new("NUM2DBL", ruby_param)).pr
  end
  get_output.puts "  mppa_write(_mppa_fd_var, &#{par}, sizeof(#{par}));"
end

#copy_scalar_param_to_host(param) ⇒ Object 



206
207
208
209
210
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 206

def copy_scalar_param_to_host(param)
  get_output.print <<EOF
  mppa_write(_mppa_to_host_var, &#{param}, sizeof(#{param}));
EOF
end

#copy_scalar_param_to_ruby(par, param, ruby_param) ⇒ Object 



493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 493

def copy_scalar_param_to_ruby(par, param, ruby_param)
  if param.scalar_output? then
    get_output.print <<EOF
  mppa_read(_mppa_fd_var, &#{par}, sizeof(#{par}));
EOF
    case param.type
    when Int
      if param.type.signed? then
        get_output.puts "  rb_hash_aset(_boast_refs, ID2SYM(rb_intern(\"#{param}\")),rb_int_new((long long)#{par}));"
      else
        get_output.puts "  rb_hash_aset(_boast_refs, ID2SYM(rb_intern(\"#{param}\")),rb_int_new((unsigned long long)#{par}));"
      end
    when Real
      get_output.puts "  rb_hash_aset(_boast_refs, ID2SYM(rb_intern(\"#{param}\")),rb_float_new((double)#{par}));"
    end
  end
end

#create_multibinary_source(mode) ⇒ Object 



353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 353

def create_multibinary_source(mode)
  f = File::open(self.send("#{mode}_source"),"w+")
  previous_lang = get_lang
  previous_output = get_output
  set_output(f)
  set_lang(@lang)

  fill_multibinary_source(mode)

  if debug_source? then
    f.rewind
    puts f.read
  end
  set_output(previous_output)
  set_lang(previous_lang)
  f.close
end

#create_multibinary_sources ⇒ Object 



371
372
373
374
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 371

def create_multibinary_sources
  create_multibinary_source(:io)
  create_multibinary_source(:comp)
end

#create_procedure_call ⇒ Object 



468
469
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 468

def create_procedure_call
end

#create_sources ⇒ Object 



376
377
378
379
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 376

def create_sources
  create_multibinary_sources
  create_module_file_source
end

#create_targets(linker, ldshared, ldshared_flags, ldflags, kernel_files) ⇒ Object 



162
163
164
165
166
167
168
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 162

def create_targets( linker, ldshared, ldshared_flags, ldflags, kernel_files )
  create_targets_old( linker, ldshared, ldshared_flags, ldflags, kernel_files )
  file multibinary_path => [io_bin, comp_bin] do
    sh "k1-create-multibinary --clusters #{comp_bin} --clusters-names \"comp-part\" --boot #{io_bin} --bootname \"io-part\" -T #{multibinary_path}"
  end
  Rake::Task[multibinary_path].invoke
end

#create_targets_old ⇒ Object 



70
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 70

alias create_targets_old create_targets

#fill_decl_module_params ⇒ Object 



386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 386

def fill_decl_module_params
  fill_decl_module_params_old
  get_output.print <<EOF
  int _mppa_i;
  int _mppa_load_id;
  int _mppa_pid;
  int _mppa_fd_size;
  int _mppa_fd_var;
  int _mppa_clust_list_size;
  int _mppa_clust_nb;
  int64_t _boast_duration;
  uint32_t * _mppa_clust_list;
  _mppa_load_id = mppa_load(0, 0, 0, \"#{multibinary_path}\");
  _mppa_pid = mppa_spawn(_mppa_load_id, NULL, \"io-part\", NULL, NULL);
EOF
end

#fill_decl_module_params_old ⇒ Object 



74
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 74

alias fill_decl_module_params_old fill_decl_module_params

#fill_module_header ⇒ Object 



381
382
383
384
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 381

def fill_module_header
  fill_module_header_old
  get_output.puts "#include <mppaipc.h>"
end

#fill_module_header_old ⇒ Object 



72
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 72

alias fill_module_header_old fill_module_header

#fill_multibinary_header ⇒ Object 



170
171
172
173
174
175
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 170

def fill_multibinary_header
  fill_library_header
  get_output.puts "#include <mppaipc.h>"
  get_output.puts "#include <mppa/osconfig.h>"
  get_output.puts "#include <time.h>"
end

#fill_multibinary_main_comp_source ⇒ Object 



322
323
324
325
326
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 322

def fill_multibinary_main_comp_source
  if @procedure_comp then
    get_output.puts "    #{@procedure_comp.name}();"
  end
end

#fill_multibinary_main_io_source ⇒ Object 



291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 291

def fill_multibinary_main_io_source
  multibinary_main_io_source_decl

  multibinary_main_io_source_get_params

  #Spawning cluster
  get_output.print <<EOF

  clock_gettime(CLOCK_REALTIME, &_mppa_start);
  for(_mppa_i=0; _mppa_i<_nb_clust; _mppa_i++){
_mppa_pid[_mppa_i] = mppa_spawn(_clust_list[_mppa_i], NULL, "comp-part", NULL, NULL);
  }
EOF
  #Calling IO procedure
  get_output.print "  _mppa_ret =" if @procedure.properties[:return]
  get_output.print "  #{@procedure.name}("
  get_output.print @procedure.parameters.map(&:name).join(", ")
  get_output.puts ");"

  #Waiting for clusters
  get_output.print <<EOF
  for(_mppa_i=0; _mppa_i<_nb_clust; _mppa_i++){
mppa_waitpid(_mppa_pid[_mppa_i], NULL, 0);
  }
  clock_gettime(CLOCK_REALTIME, &_mppa_stop);
  _mppa_duration = (int64_t)(_mppa_stop.tv_sec - _mppa_start.tv_sec) * 1000000000ll + _mppa_stop.tv_nsec - _mppa_start.tv_nsec;
EOF

  multibinary_main_io_source_send_results
end

#fill_multibinary_source(mode) ⇒ Object 



328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 328

def fill_multibinary_source(mode)
  fill_multibinary_header
  code = nil
  if mode == :io then
    code = @code
  else
    code = @code_comp
  end
  if code then
    code.rewind
    get_output.print code.read
  end
  get_output.puts "int main(int argc, const char* argv[]) {"
  if mode == :io then
    fill_multibinary_main_io_source
  else
    fill_multibinary_main_comp_source
  end
  get_output.print <<EOF
  mppa_exit(0);
  return 0;
}
EOF
end

#get_cluster_list_from_host ⇒ Object 



191
192
193
194
195
196
197
198
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 191

def get_cluster_list_from_host
  get_output.print <<EOF
  mppa_read(_mppa_from_host_size, &_mppa_clust_list_size, sizeof(_mppa_clust_list_size));
  _clust_list = malloc(_mppa_clust_list_size);
  _nb_clust = _mppa_clust_list_size / sizeof(*_clust_list);
  mppa_read(_mppa_from_host_var, _clust_list, _mppa_clust_list_size);
EOF
end

#get_params_value ⇒ Object 



432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 432

def get_params_value
  get_output.print <<EOF
  _mppa_fd_size = mppa_open(\"/mppa/buffer/board0#mppa0#pcie0#2/host#2\", O_WRONLY);
  _mppa_fd_var = mppa_open(\"/mppa/buffer/board0#mppa0#pcie0#3/host#3\", O_WRONLY);
EOF
  get_params_value_old
  get_output.print <<EOF
  if(_boast_rb_opts != Qnil) {
_boast_rb_ptr = rb_hash_aref(_boast_rb_opts, ID2SYM(rb_intern("clusters")));
if (_boast_rb_ptr != Qnil ) {
  int _boast_i;
  _mppa_clust_nb = RARRAY_LEN(_boast_rb_ptr);
  _mppa_clust_list = malloc(sizeof(uint32_t)*_mppa_clust_nb);
  for(_boast_i=0; _boast_i < _mppa_clust_nb; _boast_i++){
    _mppa_clust_list[_boast_i] = NUM2INT(rb_ary_entry(_boast_rb_ptr, _boast_i));
  }
} else {
  _mppa_clust_list = malloc(sizeof(uint32_t));
  _mppa_clust_list[0] = 0;
  _mppa_clust_nb = 1;
}
  } else {
_mppa_clust_list = malloc(sizeof(uint32_t));
_mppa_clust_list[0] = 0;
_mppa_clust_nb = 1;
  }
  
  _mppa_clust_list_size = sizeof(uint32_t)*_mppa_clust_nb;
  mppa_write(_mppa_fd_size, &_mppa_clust_list_size, sizeof(_mppa_clust_list_size));
  mppa_write(_mppa_fd_var, _mppa_clust_list, _mppa_clust_list_size);
  free(_mppa_clust_list);
  mppa_close(_mppa_fd_var);
  mppa_close(_mppa_fd_size);
EOF
end

#get_params_value_old ⇒ Object 



73
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 73

alias get_params_value_old get_params_value

#get_results ⇒ Object 



511
512
513
514
515
516
517
518
519
520
521
522
523
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 511

def get_results
  get_output.print <<EOF
  _mppa_fd_var = mppa_open(\"/mppa/buffer/host#4/board0#mppa0#pcie0#4\", O_RDONLY);
EOF
  get_results_old
  get_output.puts "  mppa_read(_mppa_fd_var, &_boast_params._boast_ret, sizeof(_boast_params._boast_ret));" if @procedure.properties[:return]
  get_output.puts "  mppa_read(_mppa_fd_var, &_boast_duration, sizeof(_boast_duration));"
  get_output.print <<EOF
  mppa_close(_mppa_fd_var);
  mppa_waitpid(_mppa_pid, NULL, 0);
  mppa_unload(_mppa_load_id);
EOF
end

#get_results_old ⇒ Object 



75
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 75

alias get_results_old get_results

#io_bin ⇒ Object 



97
98
99
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 97

def io_bin
  return "#{base_path}.binio"
end

#io_object ⇒ Object 



105
106
107
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 105

def io_object
  return "#{base_path}.#{RbConfig::CONFIG["OBJEXT"]}io"
end

#io_source ⇒ Object 



113
114
115
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 113

def io_source
  return "#{base_path}.cio"
end

#multibinary_main_io_source_decl ⇒ Object 



212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 212

def multibinary_main_io_source_decl
  #Parameters declaration
  @procedure.parameters.each { |param|
    get_output.print "  #{param.type.decl} "
    get_output.print "*" if param.dimension or param.scalar_output? or param.reference?
    get_output.puts "#{param.name};"
    if param.dimension then
      get_output.puts "  size_t _mppa_#{param}_size;"
    end
  }

  #Return value declaration
  get_output.puts "  #{@procedure.properties[:return].type.decl} _mppa_ret;" if @procedure.properties[:return]

  #Cluster list declaration
  get_output.print <<EOF
  uint32_t *_clust_list;
  int _nb_clust;
  int _mppa_clust_list_size;
EOF

  #Timer
  get_output.print <<EOF
  struct timespec _mppa_start, _mppa_stop;
  int64_t _mppa_duration;
EOF

  #Communication variables
  get_output.print <<EOF
  int _mppa_from_host_size, _mppa_from_host_var;
  int _mppa_to_host_size,   _mppa_to_host_var;
  int _mppa_pid[16], _mppa_i;
EOF
end

#multibinary_main_io_source_get_params ⇒ Object 



247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 247

def multibinary_main_io_source_get_params
  #Receiving parameters from Host
  get_output.print <<EOF
  _mppa_from_host_size = mppa_open("/mppa/buffer/board0#mppa0#pcie0#2/host#2", O_RDONLY);
  _mppa_from_host_var = mppa_open("/mppa/buffer/board0#mppa0#pcie0#3/host#3", O_RDONLY);
EOF
  @procedure.parameters.each { |param|
    if param.dimension then
      copy_array_param_from_host(param)
    else
      copy_scalar_param_from_host(param)
    end
  }

  #Receiving cluster list
  get_cluster_list_from_host

  get_output.print <<EOF
  mppa_close(_mppa_from_host_size);
  mppa_close(_mppa_from_host_var);
EOF
end

#multibinary_main_io_source_send_results ⇒ Object 



270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 270

def multibinary_main_io_source_send_results
  #Sending results to Host
  get_output.print <<EOF
  _mppa_to_host_var = mppa_open("/mppa/buffer/host#4/board0#mppa0#pcie0#4", O_WRONLY);
EOF
  @procedure.parameters.each { |param| 
    if param.direction == :out or param.direction == :inout then
      if param.dimension then
        copy_array_param_to_host(param)
      else
        copy_scalar_param_to_host(param)
      end
    end
  }
  copy_scalar_param_to_host("_mppa_ret") if @procedure.properties[:return]
  copy_scalar_param_to_host("_mppa_duration")
  get_output.print <<EOF
  mppa_close(_mppa_to_host_var);
EOF
end

#multibinary_path ⇒ Object 



93
94
95
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 93

def multibinary_path
  return "#{base_path}.mpk"
end

#save_binary ⇒ Object 



147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 147

def save_binary
  f = File::open(io_object,"rb")
  @binary = StringIO::new
  @binary.write( f.read )
  f.close
  f = File::open(comp_object,"rb")
  @binary_comp = StringIO::new
  @binary_comp.write( f.read )
  f.close
  f = File::open(multibinary_path,"rb")
  @multibinary = StringIO::new
  @multibinary.write( f.read )
  f.close
end

#save_source ⇒ Object 



136
137
138
139
140
141
142
143
144
145
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 136

def save_source
  f = File::open(io_source, "r")
  @source = StringIO::new
  @source.write( f.read )
  f.close
  f = File::open(comp_source, "r")
  @source_comp = StringIO::new
  @source_comp.write( f.read )
  f.close
end

#set_comp ⇒ Object 



125
126
127
128
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 125

def set_comp
  @code_comp = StringIO::new unless @code_comp
  set_output(@code_comp)
end

#set_io ⇒ Object 



121
122
123
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 121

def set_io
  set_output(@code)
end

#store_results ⇒ Object 



525
526
527
528
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 525

def store_results
  store_results_old
  get_output.print "  rb_hash_aset(_boast_stats,ID2SYM(rb_intern(\"duration\")),rb_float_new((double)_boast_duration*(double)1e-9));\n"
end

#store_results_old ⇒ Object 



76
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 76

alias store_results_old store_results

#target_depends ⇒ Object 



85
86
87
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 85

def target_depends
  return [ module_file_object ]
end

#target_sources ⇒ Object 



89
90
91
 
# File 'lib/BOAST/Runtime/MPPARuntime.rb', line 89

def target_sources
  return [ module_file_source, io_source, comp_source ]
end