RaftLib  0.3a
C++ Stream Processing Template Library
Public Member Functions | Protected Member Functions | Static Protected Member Functions | Protected Attributes | List of all members
pool_schedule Class Reference
Inheritance diagram for pool_schedule:
[legend]
Collaboration diagram for pool_schedule:
[legend]

Public Member Functions

 pool_schedule (Map &map)
 
virtual ~pool_schedule ()
 
virtual void start ()
 
- Public Member Functions inherited from Schedule
 Schedule (Map &map)
 
virtual ~Schedule ()
 
virtual void init ()
 
void scheduleKernel (raft::kernel *const kernel)
 

Protected Member Functions

virtual bool scheduleKernel (raft::kernel *const kernel)
 
- Protected Member Functions inherited from Schedule
virtual void handleSchedule (raft::kernel *const kernel)=0
 

Static Protected Member Functions

static bool container_min_input (kernel_container *const a, kernel_container *const b)
 
static bool container_min_output (kernel_container *const a, kernel_container *const b)
 
- Static Protected Member Functions inherited from Schedule
static raft::kstatus checkSystemSignal (raft::kernel *const kernel, void *data, SystemSignalHandler &handlers)
 
static raft::kstatus quitHandler (FIFO &fifo, raft::kernel *kernel, const raft::signal signal, void *data)
 
static void invalidateOutputPorts (raft::kernel *kernel)
 
static bool kernelHasInputData (raft::kernel *kernel)
 
static bool kernelHasNoInputPorts (raft::kernel *kernel)
 

Protected Attributes

const float diff_weight = .20
 
decltype(std::thread::hardware_concurrency()) const n_threads
 
std::vector< std::thread * > pool
 
std::vector< kernel_container * > container
 
std::size_t kernel_count = 0
 
std::remove_reference< decltype(container.end()) >::type container_it
 
- Protected Attributes inherited from Schedule
SystemSignalHandler handlers
 
kernelkeeper & kernel_set
 
kernelkeeper & source_kernels
 
kernelkeeper & dst_kernels
 

Additional Inherited Members

- Static Public Member Functions inherited from Schedule
static bool kernelRun (raft::kernel *const kernel, volatile bool &finished, jmp_buf *gotostate=nullptr, jmp_buf *kernel_state=nullptr)
 

Constructor & Destructor Documentation

pool_schedule::pool_schedule ( Map map)

pool_schedule - constructor, takes a map object, calling this will launch threads. scheduler itself is also run as a thread.

Parameters
map- Map&

poolschedule.cpp -

Author
: Jonathan Beard
Version
: Thu Sep 11 15:49:57 2014

Copyright 2014 Jonathan Beard

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at:

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

initialize container objects

initialize threads

Here is the call graph for this function:

pool_schedule::~pool_schedule ( )
virtual

destructor, deletes threads and cleans up container objects.

join threads

delete threads

delete containers

Member Function Documentation

bool pool_schedule::container_min_input ( kernel_container *const  a,
kernel_container *const  b 
)
staticprotected

container_min - returns true if the input queue of a has fewer items than the input queue of b

Parameters
a- kernel_container * const
b- kernel_container * const
Returns
bool - true if a->qsize() < b->qsize()

Here is the call graph for this function:

Here is the caller graph for this function:

bool pool_schedule::container_min_output ( kernel_container *const  a,
kernel_container *const  b 
)
staticprotected

container_max - returns true if the output queue of a is greater than b.

Parameters
a- kernel_container * const
b- kernel_container * const
Returns
bool - true if a->outqsize > b->qoutsize

Here is the call graph for this function:

Here is the caller graph for this function:

bool pool_schedule::scheduleKernel ( raft::kernel *const  kernel)
protectedvirtual

BEGIN FUNCTIONS scheduleKernel - override base class function in order to add kernels to the right place.

Parameters
kernel- raft::kernel*
Returns
bool - always true

get a container

Here is the call graph for this function:

void pool_schedule::start ( )
virtual

start - call to start executing map, at this point the mapper sould have checked the topology and everything should be set up for running.

we want to get the max queue occupancy

some message exists

remove kernel

all done, shutdown

Implements Schedule.

Here is the call graph for this function:

Member Data Documentation

std::vector< kernel_container* > pool_schedule::container
protected

max_heap_container - sorted by max output-queue occupancy

const float pool_schedule::diff_weight = .20
protected

END FUNCTIONS, BEGIN VAR DECLS The thread has to have this much more "work" than the previous thread in order to get moved ot a new thread. Used in pool_schedule::start().

decltype( std::thread::hardware_concurrency() ) const pool_schedule::n_threads
protected

total # of hardware supported threads

std::vector< std::thread* > pool_schedule::pool
protected

used as a thread pool


The documentation for this class was generated from the following files: