My Project
mapbase.hpp
1 
29 #ifndef _MAPBASE_HPP_
30 #define _MAPBASE_HPP_ 1
31 #include <typeinfo>
32 #include <cassert>
33 #include <cxxabi.h>
34 #include <vector>
35 #include <thread>
36 #include <sstream>
37 
38 #include "kernelkeeper.tcc"
39 #include "portexception.hpp"
40 #include "schedule.hpp"
41 #include "simpleschedule.hpp"
42 #include "kernel.hpp"
43 #include "port_info.hpp"
44 #include "allocate.hpp"
45 #include "dynalloc.hpp"
46 #include "stdalloc.hpp"
47 
54 {
55 public:
57  src( a ),
58  dst( b )
59  {
60  }
61 
62  kernel_pair_t( const kernel_pair_t &other ) : src( other.src ),
63  dst( other.dst )
64  {
65  }
66 
67  kernel_pair_t& operator = ( const kernel_pair_t &other )
68  {
69  src = other.src;
70  dst = other.dst;
71  return( *this );
72  }
73 
74  raft::kernel& getSrc()
75  {
76  return( *src );
77  }
78 
79  raft::kernel& getDst()
80  {
81  return( *dst );
82  }
83 
84 private:
85  raft::kernel *src = nullptr;
86  raft::kernel *dst = nullptr;
87 };
88 
89 
95 namespace order
96 {
97  enum spec { in, out };
98 }
99 
100 class MapBase
101 {
102 public:
107  MapBase();
111  virtual ~MapBase();
112 
113 
130  template < order::spec t = order::in >
132  raft::kernel *b,
133  const std::size_t buffer = 0 )
134  {
136  if( ! a->input.hasPorts() )
137  {
138  source_kernels += a;
139  }
140  if( ! b->output.hasPorts() )
141  {
142  dst_kernels += b;
143  }
144 
145 
146  all_kernels += a;
147  all_kernels += b;
148  PortInfo *port_info_a;
149  try{
150  port_info_a = &(a->output.getPortInfo());
151  }
152  catch( PortNotFoundException &ex )
153  {
154  int status( 0 );
155  std::stringstream ss;
156  ss <<
157  "Source port from kernel " <<
158  abi::__cxa_demangle( typeid( *a ).name(), 0, 0, &status ) <<
159  "has more than a single port.";
160 
161  throw AmbiguousPortAssignmentException( ss.str() );
162  }
163  port_info_a->fixed_buffer_size = buffer;
164  PortInfo *port_info_b;
165  try{
166  port_info_b = &(b->input.getPortInfo());
167  }
168  catch( PortNotFoundException &ex )
169  {
170  int status( 0 );
171  std::stringstream ss;
172  ss << "Destination port from kernel " <<
173  abi::__cxa_demangle( typeid( *b ).name(), 0, 0, &status ) <<
174  "has more than a single port.";
175  throw AmbiguousPortAssignmentException( ss.str() );
176  }
177  port_info_b->fixed_buffer_size = buffer;
178 
179  join( *a, port_info_a->my_name, *port_info_a,
180  *b, port_info_b->my_name, *port_info_b );
181  switch( t )
182  {
183  case( order::in ):
184  {
185  port_info_a->out_of_order = false;
186  port_info_b->out_of_order = false;
187  }
188  break;
189  case( order::out ):
190  {
191  port_info_a->out_of_order = true;
192  port_info_b->out_of_order = true;
193  }
194  break;
195  }
196  return( kernel_pair_t( a, b ) );
197  }
198 
213  template < order::spec t = order::in >
215  const std::string a_port,
216  raft::kernel *b,
217  const std::size_t buffer = 0 )
218  {
219  if( ! a->input.hasPorts() )
220  {
221  source_kernels += a;
222  }
223  if( ! b->output.hasPorts() )
224  {
225  dst_kernels += b;
226  }
227 
228 
229  all_kernels += a;
230  all_kernels += b;
231  PortInfo &port_info_a( a->output.getPortInfoFor( a_port ) );
232  port_info_a.fixed_buffer_size = buffer;
233  PortInfo *port_info_b;
234  try{
235  port_info_b = &(b->input.getPortInfo());
236  }
237  catch( PortNotFoundException &ex )
238  {
239  int status( 0 );
240  std::stringstream ss;
241  ss << "Destination port from kernel " <<
242  abi::__cxa_demangle( typeid( *b ).name(), 0, 0, &status ) <<
243  "has more than a single port.";
244  throw AmbiguousPortAssignmentException( ss.str() );
245  }
246  port_info_b->fixed_buffer_size = buffer;
247  join( *a, a_port , port_info_a,
248  *b, port_info_b->my_name, *port_info_b );
249  switch( t )
250  {
251  case( order::in ):
252  {
253  port_info_a.out_of_order = false;
254  port_info_b->out_of_order = false;
255  }
256  break;
257  case( order::out ):
258  {
259  port_info_a.out_of_order = true;
260  port_info_b->out_of_order = true;
261  }
262  break;
263  }
264  return( kernel_pair_t( a, b ) );
265  }
266 
267 
282  template < order::spec t = order::in >
284  raft::kernel *b,
285  const std::string b_port,
286  const std::size_t buffer = 0 )
287  {
288  if( ! a->input.hasPorts() )
289  {
290  source_kernels += a;
291  }
292  if( ! b->output.hasPorts() )
293  {
294  dst_kernels += b;
295  }
296 
297 
298  all_kernels += a;
299  all_kernels += b;
300  PortInfo *port_info_a;
301  try{
302  port_info_a = &(a->output.getPortInfo() );
303  }
304  catch( PortNotFoundException &ex )
305  {
306  std::stringstream ss;
307  int status( 0 );
308  ss << "Source port from kernel " <<
309  abi::__cxa_demangle( typeid( *a ).name(), 0, 0, &status ) <<
310  "has more than a single port.";
311  throw AmbiguousPortAssignmentException( ss.str() );
312  }
313  port_info_a->fixed_buffer_size = buffer;
314 
315  PortInfo &port_info_b( b->input.getPortInfoFor( b_port) );
316  port_info_b.fixed_buffer_size = buffer;
317 
318  join( *a, port_info_a->my_name, *port_info_a,
319  *b, b_port, port_info_b );
320  switch( t )
321  {
322  case( order::in ):
323  {
324  port_info_a->out_of_order = false;
325  port_info_b.out_of_order = false;
326  }
327  break;
328  case( order::out ):
329  {
330  port_info_a->out_of_order = true;
331  port_info_b.out_of_order = true;
332  }
333  break;
334  }
335  return( kernel_pair_t( a, b ) );
336  }
337 
350  template < order::spec t = order::in >
352  const std::string a_port,
353  raft::kernel *b,
354  const std::string b_port,
355  const std::size_t buffer = 0 )
356  {
357  if( ! a->input.hasPorts() )
358  {
359  source_kernels += a;
360  }
361  if( ! b->output.hasPorts() )
362  {
363  dst_kernels += b;
364  }
365 
366  all_kernels += a;
367  all_kernels += b;
368  auto &port_info_a( a->output.getPortInfoFor( a_port ) );
369  port_info_a.fixed_buffer_size = buffer;
370  auto &port_info_b( b->input.getPortInfoFor( b_port) );
371  port_info_b.fixed_buffer_size = buffer;
372 
373  join( *a, a_port, port_info_a,
374  *b, b_port, port_info_b );
375  switch( t )
376  {
377  case( order::in ):
378  {
379  port_info_a.out_of_order = false;
380  port_info_b.out_of_order = false;
381  }
382  break;
383  case( order::out ):
384  {
385  port_info_a.out_of_order = true;
386  port_info_b.out_of_order = true;
387  }
388  break;
389  }
390  return( kernel_pair_t( a, b ) );
391  }
392 
393 
394 
395 protected:
410  static void join( raft::kernel &a, const std::string name_a, PortInfo &a_info,
411  raft::kernel &b, const std::string name_b, PortInfo &b_info );
412 
413  static void insert( raft::kernel *a, PortInfo &a_out,
414  raft::kernel *b, PortInfo &b_in,
415  raft::kernel *i );
416 
418  kernelkeeper source_kernels;
420  kernelkeeper dst_kernels;
422  kernelkeeper all_kernels;
429  std::vector< MapBase* > sub_maps;
430 
431  friend class Map;
432 };
433 #endif /* END _MAPBASE_HPP_ */
kernel_pair_t link(raft::kernel *a, raft::kernel *b, const std::string b_port, const std::size_t buffer=0)
Definition: mapbase.hpp:283
static void join(raft::kernel &a, const std::string name_a, PortInfo &a_info, raft::kernel &b, const std::string name_b, PortInfo &b_info)
Definition: mapbase.cpp:55
Port input
Definition: kernel.hpp:117
PortInfo & getPortInfoFor(const std::string port_name)
Definition: port.cpp:108
kernel_pair_t link(raft::kernel *a, const std::string a_port, raft::kernel *b, const std::size_t buffer=0)
Definition: mapbase.hpp:214
PortInfo & getPortInfo()
Definition: port.cpp:121
Definition: mapbase.hpp:100
kernelkeeper all_kernels
Definition: mapbase.hpp:422
kernel_pair_t link(raft::kernel *a, const std::string a_port, raft::kernel *b, const std::string b_port, const std::size_t buffer=0)
Definition: mapbase.hpp:351
kernelkeeper dst_kernels
Definition: mapbase.hpp:420
virtual bool hasPorts()
Definition: port.cpp:84
std::vector< MapBase * > sub_maps
Definition: mapbase.hpp:429
Definition: map.hpp:47
MapBase()
Definition: mapbase.cpp:35
kernelkeeper source_kernels
Definition: mapbase.hpp:418
kernel_pair_t link(raft::kernel *a, raft::kernel *b, const std::size_t buffer=0)
Definition: mapbase.hpp:131
Definition: mapbase.hpp:95
Definition: portexception.hpp:39
Definition: mapbase.hpp:53
Definition: port_info.hpp:39
Definition: kernel.hpp:57
Definition: portexception.hpp:57
virtual ~MapBase()
Definition: mapbase.cpp:40