CnC
 All Classes Namespaces Functions Variables Typedefs Enumerator Friends Groups Pages
Public Member Functions | Static Public Attributes
step_tuner< check_deps > Struct Template Reference

Default (NOP) implementations of the step_tuner interface. More...

List of all members.

Public Member Functions

template<typename Tag , typename Arg >
int priority (const Tag &tag, Arg &arg) const
 Allows defnintion of priorites to individual steps (which are identified by the tag).
template<typename Tag , typename Arg , typename T >
void depends (const Tag &tag, Arg &arg, T &dC) const
 Allows declaration of data dependencies (to items) of given step (identified by the tag).
bool preschedule () const
 Returns whether the step should be pre-scheduled.
template<typename Tag , typename Arg >
int affinity (const Tag &, Arg &) const
 Tell the scheduler the preferred thread for executing given step.
template<typename Tag , typename Arg >
int compute_on (const Tag &, Arg &) const
 tell the scheduler on which process to run the step (or range of steps) (distCnC)
template<typename Tag , typename Arg >
int was_canceled (const Tag &, Arg &) const
 check for cancelation of given step

Static Public Attributes

static const bool check_deps_in_ranges = check_deps

Additional Inherited Members

- Static Public Member Functions inherited from tuner_base
static int myPid ()
static int numProcs ()
template<typename Ctxt >
static int numThreads (const Ctxt &ctxt)
 returns number of threads used by scheduler in given context

Detailed Description

template<bool check_deps = true>
struct CnC::step_tuner< check_deps >

Default (NOP) implementations of the step_tuner interface.

Also defines the interface a user-provided tuner must satisfy. Derive your tuner from this (to avoid implementing the entire interface).

It is recommended that your tuner does not implement the methods as templates. Instead, you should use the actual types that it expects.

#include <cnc/default_tuner.h>

Definition at line 106 of file default_tuner.h.


Member Function Documentation

int affinity ( const Tag &  ,
Arg &   
) const
inline

Tell the scheduler the preferred thread for executing given step.

Not all schedulers might actually evaluate this call (see Scheduler); it involves a virtual function call whenever a step is (re-)scheduled. This feature is most useful in combination with the CNC_PIN_THREADS environment variable (Scheduler Control).

Returns:
thread id or AFFINITY_HERE (default)

Definition at line 170 of file default_tuner.h.

{
return AFFINITY_HERE;
}
int compute_on ( const Tag &  ,
Arg &   
) const
inline

tell the scheduler on which process to run the step (or range of steps) (distCnC)

Returns:
process id where the step will be executed, or COMPUTE_ON_ROUND_ROBIN, or COMPUTE_ON_LOCAL, or COMPUTE_ON_ALL, or COMPUTE_ON_ALL_OTHERS

Definition at line 178 of file default_tuner.h.

void depends ( const Tag &  tag,
Arg &  arg,
T &  dC 
) const
inline

Allows declaration of data dependencies (to items) of given step (identified by the tag).

When a step-instance is prescribed through a corresponding tag_collection::put, this method will be called. You can declare dependencies to items by calling dC.depends( item_collection, dependent_item_tag ) for every item the step is going to 'get' in its execute method. The actual step execution will be delayed until all dependencies can be satisfied. The default implementation does nothing (NOP). Your own implementation must accept dC by reference (T&). dC.depends accepts an additional optional argument to declare the process that will produce the item. You can either pass the process-rank or CnC::PRODUCER_UKNOWN or CnC::PRODUCER_LOCAL. This producer argument will have effect only if the tuner of the respective item-collection returns CnC::CONSUMER_UKNOWN, otherwise it will be ignored.

Parameters:
tagthe tag which identifies the step to be executed.
argthe argument as passed to context< Derived >::prescribed (usually the context)
dCopaque object (must be by reference!) providing method depends to declare item dependencies

Definition at line 141 of file default_tuner.h.

{
}
bool preschedule ( ) const
inline

Returns whether the step should be pre-scheduled.

Pre-scheduling provides an alternative method for detecting data dependencies.

The step instance will be run immediately when prescribed by a tag_collection::put. All items that are not yet available when accessed by the non-blocking get method will automatically be treated as dependent items. The pre-run will end at context::flush_gets() if any items are unavailable. The step execution will be delayed until all detected dependencies can be satisfied.

Definition at line 157 of file default_tuner.h.

{
return false;
}
int priority ( const Tag &  tag,
Arg &  arg 
) const
inline

Allows defnintion of priorites to individual steps (which are identified by the tag).

Returns:
the default implementation always return 1.
Parameters:
tagthe tag which identifies the step to be executed
argthe argument as passed to context< Derived >::prescribed (usually the context)
See also:
also CNCROOT/samples/floyd_warshall

Definition at line 114 of file default_tuner.h.

{
return 1;
}
int was_canceled ( const Tag &  ,
Arg &   
) const
inline

check for cancelation of given step

Returns:
true if step was canceled, false otherwise (default)
Note:
Must be thread-safe. Runtime will try to not execute the step, but it might still get executed. Best effort - but no guarantees. Canceling steps makes all determinism guarantees void.

For distributed memory your implementation might require to sync its state across processes. Currently there is no API exposed to do that conveniently. However, an example implementatino CnC::cancel_tuner is provided which works on distributed memory.

See also:
also CNCROOT/samples/floyd_warshall

Reimplemented in cancel_tuner< Tag, check_deps, Hasher, Equality >.

Definition at line 202 of file default_tuner.h.

{
return false;
}

Member Data Documentation

const bool check_deps_in_ranges = check_deps
static

true if steps launched through ranges consume items or need global locking, false otherwise. Avoiding checks for dependencies and global locks saves overhead and will perform better (e.g. for parallel_for). Safe execution (with checks) is the default (check_deps template argument).

Definition at line 186 of file default_tuner.h.


The documentation for this struct was generated from the following file: