RaftLib  0.3a
C++ Stream Processing Template Library
fifo.hpp
1 
20 #ifndef _FIFO_HPP_
21 #define _FIFO_HPP_ 1
22 #include <cstddef>
23 #include <typeinfo>
24 #include <iterator>
25 #include <list>
26 #include <vector>
27 #include <sstream>
28 #include <map>
29 #include <utility>
30 #include <functional>
31 #include <cassert>
32 #include <type_traits>
33 #include <stdexcept>
34 #include "bufferdata.tcc"
35 #include "blocked.hpp"
36 #include "signalvars.hpp"
37 
38 
40 class Schedule;
41 class Allocate;
42 
43 namespace raft
44 {
45  class kernel;
46 }
47 
48 class FIFO
49 {
50 #include "autorelease.tcc"
51 public:
52 
53 
58  FIFO();
59 
63  virtual ~FIFO();
64 
69  virtual std::size_t size() = 0;
70 
77  virtual std::size_t space_avail() = 0;
78 
84  virtual std::size_t capacity() = 0;
85 
95  template < class T,
96  typename std::enable_if<
97  std::is_pod< T >::value >::type* = nullptr > T& allocate()
98  {
99  void *ptr( nullptr );
101  local_allocate( &ptr );
102  return( *( reinterpret_cast< T* >( ptr ) ) );
103  }
104 
105  template < class T,
106  class ... Args,
107  typename std::enable_if<
108  std::is_object< T >::value and not
109  std::is_fundamental< T >::value >::type* = nullptr > T&
110  allocate( Args&&... params )
111  {
112  void *ptr( nullptr );
114  local_allocate( &ptr );
115  T * __attribute__((__unused__)) temp( new (ptr) T( std::forward< Args >( params )... ) );
116  return( *( reinterpret_cast< T* >( ptr ) ) );
117  }
118 
124  virtual void deallocate() = 0;
125 
133  template < class T > auto allocate_s() ->
134  autorelease< T, allocatetype >
135  {
136  void *ptr( nullptr );
137  local_allocate( &ptr );
138  return( autorelease< T, allocatetype >(
139  reinterpret_cast< T* >( ptr ), (*this) ) );
140  }
141 
157  template < class T >
158  auto allocate_range( const std::size_t n ) ->
159  std::vector< std::reference_wrapper< T > >
160  {
161  std::vector< std::reference_wrapper< T > > output;
162  void *ptr( (void*) &output );
163  local_allocate_n( ptr, n );
165  return( std::forward<
166  std::vector<
167  std::reference_wrapper< T > > >( output ) );
168  }
175  virtual void send( const raft::signal = raft::none ) = 0;
176 
183  virtual void send_range( const raft::signal = raft::none ) = 0;
184 
195  template < class T >
196  void push( const T &item, const raft::signal signal = raft::none )
197  {
198  void *ptr( (void*) &item );
200  local_push( ptr, signal );
201  return;
202  }
203 
214  template < class T >
215  void push( T &&item, const raft::signal signal = raft::none )
216  {
218  void *ptr( reinterpret_cast< void* >( &item ) );
220  local_push( ptr, signal );
221  return;
222  }
223 
235  template< class iterator_type >
236  void insert( iterator_type begin,
237  iterator_type end,
238  const raft::signal signal = raft::none )
239  {
240  void *begin_ptr( reinterpret_cast< void* >( &begin ) );
241  void *end_ptr ( reinterpret_cast< void* >( &end ) );
242  local_insert( begin_ptr, end_ptr, signal, typeid( iterator_type ).hash_code() );
243  return;
244  }
245 
253  template< class T >
254  void pop( T &item, raft::signal *signal = nullptr )
255  {
256  void *ptr( reinterpret_cast< void* >( &item ) );
257  local_pop( ptr, signal );
258  return;
259  }
260 
261 #if 0
262  template< class T >
263  auto pop_s() -> autorelease< T, poptype >
264  {
265  return( autorelease< T, poptype >( (*this) ) );
266  }
267 #endif
268 
280  template< class T >
281  void pop_range( pop_range_t< T > &items,
282  const std::size_t n_items )
283  {
284  void *ptr_items( (void*)&items );
285  local_pop_range( ptr_items, n_items );
286  return;
287  }
288 
297  template< class T >
298  T& peek( raft::signal *signal = nullptr )
299  {
300  void *ptr( nullptr );
301  local_peek( &ptr, signal );
302  return( *( reinterpret_cast< T* >( ptr ) ) );
303  }
304 
313  template< class T >
314  auto peek_range( const std::size_t n ) ->
315  autorelease< T, peekrange >
316  {
317  void *ptr = nullptr;
318  void *sig = nullptr;
319  std::size_t curr_pointer_loc( 0 );
320  local_peek_range( &ptr, &sig, n, curr_pointer_loc );
321  return( autorelease< T, peekrange >(
322  (*this),
323  reinterpret_cast< T * const >( ptr ),
324  reinterpret_cast< Buffer::Signal* >( sig ),
325  curr_pointer_loc,
326  n ) );
327  }
337  virtual void unpeek() = 0;
338 
351  template < class T,
352  typename std::enable_if<
353  std::is_pod< T >::value >::type* = nullptr >
354  void recycle( const T &t, const std::size_t range = 1 )
355  {
356  local_recycle( range );
357  }
358 
359  template < class T,
360  typename std::enable_if<
361  std::is_object< T >::value and not
362  std::is_fundamental< T >::value >::type* = nullptr >
363  void recycle( const T &t, const std::size_t range = 1 )
364  {
365  recyclefunc f( []( void *ptr )
366  {
367  T *ptr_cast( reinterpret_cast< T* >( ptr ) );
368  ptr_cast->~T();
369  } );
370  local_recycle( range, f );
371  }
372 
373 
374 
383  virtual void get_zero_read_stats( Blocked &copy );
384 
393  virtual void get_zero_write_stats( Blocked &copy );
394 
411  virtual void resize( const std::size_t n_items,
412  const std::size_t align,
413  volatile bool &exit_alloc ) = 0;
414 
423  virtual float get_frac_write_blocked() = 0;
424 
433  virtual void invalidate() = 0;
434 
442  virtual bool is_invalid() = 0;
443 protected:
444 
445  using recyclefunc =
446  std::function< void ( void* ) >;
447 
454  virtual void set_src_kernel( raft::kernel * const k ) = 0;
461  virtual void set_dst_kernel( raft::kernel * const k ) = 0;
467  virtual raft::signal signal_peek() = 0;
472  virtual void signal_pop() = 0;
473 
482  virtual void inline_signal_send( const raft::signal sig ) = 0;
483 
495  virtual void local_allocate( void **ptr ) = 0;
496 
503  virtual void local_allocate_n( void *ptr, const std::size_t n ) = 0;
513  virtual void local_push( void *ptr, const raft::signal &signal ) = 0;
514 
523  virtual void local_insert( void *ptr_begin,
524  void *ptr_end,
525  const raft::signal &signal,
526  const std::size_t iterator_type ) = 0;
527 
534  virtual void local_pop( void *ptr, raft::signal *signal ) = 0;
535 
542  virtual void local_pop_range( void *ptr_data,
543  std::size_t n_items ) = 0;
550  virtual void local_peek( void **ptr,
551  raft::signal *signal ) = 0;
563  virtual void local_peek_range( void **ptr,
564  void **sig,
565  const std::size_t n_items,
566  std::size_t &curr_pointer_loc ) = 0;
567 
573  virtual void local_recycle( const std::size_t range ) = 0;
574 
575  virtual void local_recycle( const std::size_t range,
576  recyclefunc func ) = 0;
577 
578 
582  friend class Schedule;
583  friend class Allocate;
584 };
585 
586 
587 #endif /* END _FIFO_HPP_ */
virtual void inline_signal_send(const raft::signal sig)=0
virtual std::size_t capacity()=0
void recycle(const T &t, const std::size_t range=1)
Definition: fifo.hpp:354
virtual void get_zero_read_stats(Blocked &copy)
Definition: fifo.cpp:32
virtual void send(const raft::signal=raft::none)=0
virtual void resize(const std::size_t n_items, const std::size_t align, volatile bool &exit_alloc)=0
void push(const T &item, const raft::signal signal=raft::none)
Definition: fifo.hpp:196
virtual float get_frac_write_blocked()=0
auto allocate_range(const std::size_t n) -> std::vector< std::reference_wrapper< T > >
Definition: fifo.hpp:158
virtual std::size_t size()=0
Definition: blocked.hpp:24
virtual void send_range(const raft::signal=raft::none)=0
virtual void local_allocate(void **ptr)=0
void pop(T &item, raft::signal *signal=nullptr)
Definition: fifo.hpp:254
auto allocate_s() -> autorelease< T, allocatetype >
Definition: fifo.hpp:133
void push(T &&item, const raft::signal signal=raft::none)
Definition: fifo.hpp:215
FIFO()
Definition: fifo.cpp:22
virtual void local_pop(void *ptr, raft::signal *signal)=0
virtual void local_allocate_n(void *ptr, const std::size_t n)=0
T & peek(raft::signal *signal=nullptr)
Definition: fifo.hpp:298
virtual void unpeek()=0
virtual void signal_pop()=0
virtual void local_push(void *ptr, const raft::signal &signal)=0
virtual std::size_t space_avail()=0
virtual ~FIFO()
Definition: fifo.cpp:27
Definition: allocate.hpp:54
void insert(iterator_type begin, iterator_type end, const raft::signal signal=raft::none)
Definition: fifo.hpp:236
virtual void set_src_kernel(raft::kernel *const k)=0
T & allocate(Args &&...params)
Definition: fifo.hpp:110
Definition: schedule.hpp:34
virtual void invalidate()=0
virtual void deallocate()=0
Definition: kernel.hpp:57
Definition: globalmap.cpp:3
virtual raft::signal signal_peek()=0
virtual bool is_invalid()=0
virtual void get_zero_write_stats(Blocked &copy)
Definition: fifo.cpp:39
Definition: fifo.hpp:48
void pop_range(pop_range_t< T > &items, const std::size_t n_items)
Definition: fifo.hpp:281
virtual void set_dst_kernel(raft::kernel *const k)=0
T & allocate()
Definition: fifo.hpp:97
virtual void local_insert(void *ptr_begin, void *ptr_end, const raft::signal &signal, const std::size_t iterator_type)=0
virtual void local_pop_range(void *ptr_data, std::size_t n_items)=0
virtual void local_peek_range(void **ptr, void **sig, const std::size_t n_items, std::size_t &curr_pointer_loc)=0
virtual void local_peek(void **ptr, raft::signal *signal)=0
virtual void local_recycle(const std::size_t range)=0
auto peek_range(const std::size_t n) -> autorelease< T, peekrange >
Definition: fifo.hpp:314