Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
par::cell::activation_arg_t
par::cntrl::mpi::admin
par::cell::adminRq_tA request that concerns a particular cell
par::sys::alockData for an anonymous rw-lock
par::mem::apointer< T >Provides you with a pointer to the local part (on this parXXL process) of an par::step::array or par::mem::chunk
par::cpp::aqueue< L, T >A simple round robin implementation of a queue of T
par::cpp::aqueue< 0, T >Specialization of a fixed length queue over type T for which the length can be chosen dynamically on construction
par::cell::arg_t
par::step::array< T >This class represents a distributed array
par::cpp::assignAndWrapper for binary assignment operation with the logical-and
par::cpp::assignBitandWrapper for binary assignment operation with operator&=(T const& )
par::cpp::assignBitorWrapper for binary assignment operation with operator|=(T const& )
par::cpp::assignBitxorWrapper for binary assignment operation with operator^=(T const& )
par::cpp::assignConstructWrapper for unary and binary construction with the void-constructor or copy-constructor respectively
par::cpp::assignDecWrapper for unary operation with operator++(T&)
par::cpp::assignDestructWrapper for unary destruction operation
par::cpp::assignDivideWrapper for binary assignment operation with operator/=(T const& )
par::cpp::assignEqWrapper for binary assignment operation with test for equallity
par::cpp::assignIncWrapper for unary operation with operator++(T&)
par::cpp::assignMaxWrapper for binary assignment operation with of the maximum of two values
par::cpp::assignMinWrapper for binary assignment operation with of the minimum of two values
par::cpp::assignMinusWrapper for binary assignment operation with operator-=(T const& )
par::cpp::assignModuloWrapper for binary assignment operation with operator%=(T const& )
par::cpp::assignMultiplyWrapper for binary assignment operation with operator*=(T const& )
par::cpp::assignNegWrapper for unary and binary operation with operator-(T&)
par::cpp::assignNotWrapper for unary and binary operation with operator!(T&)
par::cpp::assignOrWrapper for binary assignment operation with the logical-or
par::cpp::assignPlusWrapper for unary and binary operation with operator+(T&)
par::cpp::assignSLeftWrapper for binary assignment operation with operator<<=(T const& )
par::cpp::assignSRightWrapper for binary assignment operation with operator>>=(T const& )
par::cpp::assignSumWrapper for binary assignment operation with operator+=(T const& )
par::cpp::assignToWrapper for binary assignment operation with operator=(T const& )
par::cpp::assignZeroWrapper for unary assignment with Zero
par::sys::barrierA simple barrier that may live in thread or process shared memory
par::sys::fd::barrierA barrier that synchronizes through a file system
par::cpp::bckgdStart printing with background color x
par::cpp::block< N >An internal type to handle any data structure of size N
par::cell::body_tPar::cell cell bodies
par::step::boolPredicate
par::step::bulk< E >Bulk communication from a source array to a target array
par::step::bulk_genericThe shared code base of the par::step::bulk template classes
par::cell::CellActivation_t
par::cell::cellRq_tRequest that concern events for individual cells
par::mem::chidIdentify a chunk that is defined with respect to an object
par::mem::chid_matrix
par::mem::chid_matrix::chid_matrix::header
par::mem::chunk< T >A par::mem::chunk is a simple handle to a part of data defined by an offset and a length of what part should be mapped
par::mem::chunk< void >Par::mem::chunk<void> is the base of all other par::mem::chunk< T >
chunk_void
par::cell::collector< TData, TKey >Used to collect the data of the cells on one processor
par::cell::collector_arg_t
par::cell::CollectorGenericGeneric base class for all collector classes
par::cpp::colorStart printing in color x
par::cntrl::svm::comm_tInternal data structure that holds the information of the current parXXL session
par::cntrl::communicator< T >
par::cntrl::communicator< void >
communicator_void
par::step::compPredicate< T >
par::sys::fd::condNew class
par::sys::conditions< amount >Interface for posix conditions
par::sys::conditions< amount >::conditions::error
par::sys::conditions< 0 >Just a dummy wrapper around par::sys::mutex
par::sys::conditions< 0 >::conditions< 0 >::errorHandle errors of par::sys::conditions and derivatives
par::sys::fd::condmesgData structure to handle messages between the client sys::fconds and the dispatcher thread
par::sys::condsA group of condition variables that are glued to a par::cpp::mutex
par::cell::connector_tCell Output Connectors
par::cell::connectorTables_tHeader of Table of Output Connectors
par::cell::connectRq_t
par::step::ContextGenerate graphs via a generalized attachment model
par::cell::context_tPar::cell context for a particular parXXL process
par::step::contract_pair_extrExtraction class to construct the predecessors of a list
par::step::copy_error
par::sys::count< threshold >A ressource counter that is thread safe
par::sys::counted< T >A simple wrapper class to add reference counting to a base class T
par::sys::counter< threshold >A wrapper class template for \ par::sys::counterTemp< threshold, par::sys::conditions< 2 > >
par::sys::counterTemp< threshold, T >A ressource counter that is thread safe and may signal over- and under-flow conditions
par::cell::createRq_tCell creation request
par::sys::cref< T >A simple reference with counting
par::sys::cref_newA class needed for the implementation of UNINEW()
par::cell::Ctx_t
par::bench::dataCollect all interesting benchmarks on a per process level
par::cell::DataKey< TData, TKey >Class of "complete data": cumulating data to collect and key of the data
par::sys::dentry< T >A simple key-value structure for dictionaries of type T that are indexed by a string
par::cell::descriptor_tDescribes a cell creation request
par::sys::distribInstanceCollect information of a distribution instance
par::sys::distribution< distri >Provide functionality of a distribution function
par::step::dlistA distributed list of items
par::cell::dlist_tDoubly linked list of cells
par::cpp::double64_tA wrapped union type to access a 64 bit double through different angles
par::cpp::double64_t::double64_t::anatomyA structure type to split up a double into its different parts
par::cpp::dqueue< T >A simple round-robin queue with a maximal size that is determined at construction time
par::cpp::edge< dim >dim dimensional edges, a basic data structure for graphs
par::sys::fd::endpointDescribe the endpoint of a socket
par::cpp::enumbits< E >
par::sys::envClass to access environment variables
par::cntrl::errorA simple class to organize the catch of errors
par::cpp::errorStruct that all of par::cpp uses to throw errors
par::cntrl::mpi::error
par::sys::errorStruct that all of par::sys uses to throw errors
error1
par::sys::error::error::nameA class-wrapped enumeration type to capture int's that really are meant to be system error codes
par::step::extract_commat< T >Extraction class to identify the target process according to the position of the data
par::step::extract_indjumpExtraction class needed in par::step::forest::findroot and defivatives
par::step::extract_indjump_dist< val_t >Internal class for par::step::vforest::indjump
par::step::extract_over_parent< val_t >An extraction classes to shortcut a list needed in par::step::list< val_t >::ranking and to send the successors to the predecessors
par::step::extract_over_pred< val_t >Extraction class for par::step::list< val_t >::ranking to send the predecessors to the successors
par::step::extract_proc< T >Extraction class to identify the target process according to the contents of the data
par::step::extract_proc_genericThe common implementation core for the template par::step::extract_proc
par::mem::fcond< len >New class
par::sys::fd::fcond< len >A class template that fixes the amount of conditions to a compile time constant
par::sys::fd::fcondsA class that implements conditional variables similar to POSIX conditions but are extended to communicate between processes that are visible through file systems
par::sys::fd::fconds_threadA daemon thread that dispatches lock request between threads and processes
par::mem::file
par::sys::file
par::mem::file::file::contextEstablish the context of all mem::file
par::mem::file::file::freezerFreeze an existing stream during a certain time
par::mem::fixedUse this to maintain large chunks of memory
par::mem::fixed::fixed::contextEstablish the context of all mem::fixed
par::cpp::float32_tA wrapped union type to access a 32 bit float through different angles
par::cpp::float32_t::float32_t::anatomyA structure type to split up a float into its different parts
par::sys::fd::flockA class that implements the file system shared part of conditional variables
par::sys::fd::flock_entryAn entry in a data base that represents one indivudual file lock
par::step::forestA class that implements a distributed forest of items
par::cpp::garbage< T >The garbage collection engine for data structure T
par::cpp::garbage< typename par::cpp::block< N > >The garbage collection engine for data structures of size N
garbage_block_sizeofT
par::step::generic_extraction< S_t, T_t >Generic type from which all extraction types for par::step::bulk should inherit
par::cntrl::svm::group
par::mem::hashchunk< T >Template for a hash table for values of any T type
par::cpp::hashfunc< T >An interface that uses a predefined state to hash integers effectively
par::mem::hashl< data_t, key_t >An extentable hash array (list) with provision for clashes
par::mem::hashtab< data_t, key_t >A simple hash array with no provision on key clashes
par::mem::heapUse this to allocate large chunks of memory on the heap
par::mem::heap::heap::contextEstablish the context of all mem::heap
par::cpp::idA universal type to identify objects
par::step::index_rangeThe necessary control structure for indices of distributed arrays
par::step::index_setRepresents a set of indices
par::cntrl::infoAccess to the basic information of this parXXL run
par::cell::interaction_arg_t
par::cellnet::iter_t< dim, L >Iterate over the neighborhood of a point in dim dimensional space
par::step::iteratorThis implements two classes of iterators over index ranges
par::cell::killRq_tCell destruction request
par::mem::LargeNCubeFileReader< CData, CubeDim >
par::cpp::link< b >Store a number in a word by keeping b bits clean for some application flags
par::cell::linkBackRq_tAnswer sent to an connector
par::cell::linkGetRq_tCell output information request issued by a connector
par::cell::linkRq_tCell output information request between different cells
par::step::list< val_t >A distributed list of items
par::cpp::lnew_constructor< T >These classes are used by LNEW() to effectively do the allocation and construction of the individual elements in the new vector
par::cpp::lnew_stackerAuxiliary data type for LNEW() to anchor vector allocation and de-allocation on the stack
par::cell::LoadBalancing_tTypedef of Load Balancing informations and operations
par::mem::mapped
par::mem::mapped::mapped::contextEstablish the context of all mem::mapped
par::cntrl::matrix< T >This implements an generic interface to share (small) information amoung the parXXL processes
par::cellnet::Matrix2DR1< CFactoryOfCellDef, CFactorySupport >
par::cellnet::mesh< _dim, _Lx, _RR, CFactoryOfCellDef, CFactorySupport >
par::cellnet::meshFactory_t< dim, L, rad >All par::cellnet cell-factory types must be derived from this type
par::cellnet::meshParam_t< dim, L, rad >All par::cellnet cell-parameter types should be derived from an instantiation of this
par::cellnet::meshSelf< _dim, _Lx, _RR, CFactoryOfCellDef, CFactorySupport >
par::cellnet::meshVar_t< dim, L, rad >All par::cellnet cell-variable types should be derived from this type
par::cpp::min_max_t< T, size >An auxiliary class to be able to partially instantiate the corresponding functions
par::cell::mission_tMission of a par::cell process
par::cpp::mix< T >A two-way hash function for integer type T
par::sys::mix< T >
par::sys::fd::mount_pointAdministrate a particular mount point for a particular device
par::sys::mutexInterface for posix mutexes
par::sys::fd::mutexImplement a mutex over files
par::sys::mutex::mutex::errorFor mutexes
par::cntrl::svm::nodedataInternal data structure that holds the receive and send buffers for the SVM run time
par::mem::obidUniquely identify an object inside a par:: run
par::sys::once_both< T >Create a static ``variable'' of type T that is constructed and destructed exactly once
par::sys::once_copy< T >Create a static ``variable'' of type T that is constructed and destructed exactly once
par::sys::once_tA wrapper (resp. reimplementation and extension) of pthread_once_t
par::sys::once_void< T >Create a static ``variable'' of type T that is constructed and destructed exactly once
par::sys::optEncapsulates and eases the use of the getopt library call
par::cpp::opt_med_cl< T, size >
par::cpp::opt_med_cl< T, 4 >
par::cpp::opt_med_cl< T, 5 >
par::mem::orwgrid< T, D, condType >A relocatable variant of par::sys::owrgrid that can be used with a par::mem::store
par::sys::orwgrid< T, D, condType >A wrapper for par::cpp::orwgrid_rel that in addition provides allocation of the task table on the heap
par::sys::orwgrid_rel< T, D, condType >A D dimensional grid of ordered read-write locks of type T
par::sys::orwl< condType, LL >Ordered Read-Write Locks
par::sys::orwtask< condType, L >A wrapper around par::sys::orwtask_rel that also allocates space for the tables if necessary, i.e if L = 0
par::sys::orwtask_rel< condType, L >Ordered Read-Write Tasks
par::cell::output_tCell output
par::step::over_mess_parent
par::step::over_mess_pred
par::step::over_message_parent< val_t >
par::step::over_message_pred< val_t >
par::step::over_parentAn extraction classes to shortcut a list needed in par::step::dlist::findroot and to send the successors to the predecessors
par::step::over_predExtraction class for par::step::dlist::findroot to send the predecessors to the successors
par::step::pair_extrSpecialized extraction class for the generation of random lists
par::cntrl::svm::pairdataData structure that holds all necessary information for an individual pair of parXXL processes that is communicating
par::cell::param_tThis handles the initialization parameters of a cell
par::cell::paramDesc_tCell parameter descriptor
par::cpp::partition< twist, gT, lT >Generate one bucket of a partition of integers randomly with twist twist
par::sys::partition< twist, gT, lT >
par::cpp::partition< 0, gT, lT >Generate one bucket of a partition of integers deterministicly
par::sys::partition< 0, gT, lT >
partition< 0, gT, lT >::states
par::sys::partitionStates< twist, gT, lT >
par::sys::partitionStates< 0, gT, lT >
par::sys::permrandHold the status of an advanced pseudo random generator (PRG)
par::cell::permutation_arg_t
par::cell::PermutInfo_tTypedef for par::cell permutations, to control cell execution order
par::sys::persistentImplements a simple reference counting mechanism
par::bench::phasesHelper class to benchmark different phases of an application
par::cpp::predEQ< T >Wrapper class for operator==
par::cpp::predEQ< T[1] >
par::cpp::predEQ< T[n] >
par::cpp::predEV< T >Wrapper class for the equivalence operator (a <= b && a >= b)
par::cpp::predEV< T[1] >
par::cpp::predEV< T[n] >
par::cpp::predGE< T >Wrapper class for operator>=
par::cpp::predGE< T[1] >
par::cpp::predGE< T[n] >
par::cpp::predGT< T >Wrapper class for operator>
par::cpp::predGT< T[1] >
par::cpp::predGT< T[n] >
par::cpp::predLE< T >Wrapper class for operator<=
par::cpp::predLE< T[1] >
par::cpp::predLE< T[n] >
par::cpp::predLT< T >Wrapper class for operator<
par::cpp::predLT< T[1] >
par::cpp::predLT< T[n] >
par::cpp::predNE< T >Wrapper class for operator!=
par::cpp::predNE< T[1] >
par::cpp::predNE< T[n] >
par::cpp::predNV< T >Wrapper class for the equivalence operator (a < b || a > b)
par::cpp::predNV< T[1] >
par::cpp::predNV< T[n] >
par::cpp::primesProvides us with a large number of different prime numbers
par::cntrl::proc_dataPer parXXL process local data
par::mem::proto
par::sys::pthread_cancel_asynchronousNothing to be used directly but via the macro PAR_CONCUR
par::sys::pthread_cancel_deferredNothing to be used directly but via the macro PAR_SYS_MUT_EXCL
par::sys::quarantineInternal class
par::step::query_reply< E >This implements an extension of bulk that allows to imediately send back as much information as one receives
par::cpp::quit_action_close< T >Wrapper type to glue an action to a specific type
par::cpp::quit_action_close< T * >
par::cpp::quit_action_close< void >
par::cpp::quit_action_lock< T >Wrapper type to glue an action to a specific type
par::cpp::quit_action_lock< T * >
par::cpp::quit_action_lock< void >
par::cpp::quit_action_open< T >Wrapper type to glue an action to a specific type
par::cpp::quit_action_open< T * >
par::cpp::quit_action_open< void >
par::cpp::quit_action_rdlock< T >Wrapper type to glue an action to a specific type
par::cpp::quit_action_rdlock< T * >
par::cpp::quit_action_rdlock< void >
par::cpp::quit_action_reclaim< T >Wrapper type to glue an action to a specific type
par::cpp::quit_action_reclaim< T * >
par::cpp::quit_action_reclaim< void >
par::cpp::quit_action_release< T >Wrapper type to glue an action to a specific type
par::cpp::quit_action_release< T * >
par::cpp::quit_action_release< void >
par::cpp::quit_action_require< T >Wrapper type to glue an action to a specific type
par::cpp::quit_action_require< T * >
par::cpp::quit_action_require< void >
par::cpp::quit_action_unlock< T >Wrapper type to glue an action to a specific type
par::cpp::quit_action_unlock< T * >
par::cpp::quit_action_unlock< void >
par::cpp::quit_action_wrlock< T >Wrapper type to glue an action to a specific type
par::cpp::quit_action_wrlock< T * >
par::cpp::quit_action_wrlock< void >
par::cpp::quit_trigger_closeAssociate an action to termination
par::cpp::quit_trigger_lockAssociate an action to termination
par::cpp::quit_trigger_openAssociate an action to termination
par::cpp::quit_trigger_rdlockAssociate an action to termination
par::cpp::quit_trigger_reclaimAssociate an action to termination
par::cpp::quit_trigger_releaseAssociate an action to termination
par::cpp::quit_trigger_requireAssociate an action to termination
par::cpp::quit_trigger_unlockAssociate an action to termination
par::cpp::quit_trigger_wrlockAssociate an action to termination
par::sys::fd::rawlockImplement read-write locks over files
par::cntrl::svm::receive_bufferAn buffer for anon receives where the send is pending
par::cell::reductor< TData >Used to collect and reduce one data per processor
par::sys::refcountImplements a simple reference counting mechanism
par::cell::register_tTypedef of cell registration
par::cpp::registerline< T >
par::cpp::registerline< T >::registerline::data_t
par::mem::relocatableA base class from which all classes that are to be constructed inside a par::mem::store should inherit
par::cpp::relptr< T >A relocatable pointer type
par::cpp::relptr< void >
par::cpp::relptr< void const >
par::cpp::relptr< void const volatile >
par::cpp::relptr< void volatile >
par::cpp::relptr_voidThe specialization that implements the main functionality
par::cpp::relref< T >
par::cpp::relref< T const >
par::mem::reqInterface to allocate large chunks of memory
par::mem::req::req::contextEstablish the context of all mem::req
par::bench::resourcesCollects the benchmarks from all processes and produces the final statistic
par::sys::rlimit< rlimits >Helper class to manipulate different POSIX ressource limits
par::cell::Rq_tBaseclass for all par::cell requests
par::cell::RqBody_tCell request body
rusage
par::sys::rusageA wrapper arount the POSIX structure rusage
par::sys::rwhandle< lockobj >A handle for a rw-lock
par::sys::rwhandle2< lockobj >A double handle for an alternating rw-lock
par::sys::rwinfoThe state info of a par::sys::rwhandle
par::sys::rwlockImplements read/write-lock with semaphores
par::sys::fd::rwlockImplement read-write locks over file systems
par::sys::rwlock::rwlock::error
par::sys::rwobj_genericA generic read-write object class
par::cpp::secsInterpret a double value as seconds and print it in human perceivable form, ie as years, days, hours etc
par::sys::seed_tHold the state of a pseudo random process
par::sys::segment
par::mem::segment
par::mem::segment::segment::contextEstablish the context of all mem::segment
par::sys::semWrap the POSIX unnamed semaphore type
par::sys::sem::sem::error
par::sys::semconds< amount >A condition class that is sharable between threads and processes
par::sys::semconds< 0 >The innermost implementation of the par::sys::semconds classes
par::sys::semconds< 0 >::semconds< 0 >::error
par::sys::semmutA mutex class that is sharable between threads and processes
par::sys::semmut::semmut::error
par::cntrl::svm::send_bufferFor sends where the receive is pending
par::cntrl::svm::sent_queueHold a queue with the names of processors to whom we sent a message in this superstep
par::cntrl::serialize
par::sys::serialize
par::sys::serialize_commonImplements the serialization feature of the thread implementation
par::cntrl::serialize_commonImplements the serialization feature of the thread implementation
par::sys::sfd_common
par::sys::sfd_fileShared file descriptor for files
par::sys::sfd_file_private
par::sys::sfd_private
par::sys::sfd_segmentShared file descriptor for shared segments
par::sys::sfd_segment_private
par::sys::sigchain< sig >Cleanup signal handler class
par::cpp::simplex< dim >A wrapper class to handle dim dimensional simplices
par::step::sorting< T, seqsort >Template wrapper for a parallel sort based on different sequential sort algorithms
par::step::sorting_extraction< T_t >The special extraction type for sorting
par::sys::sortSpec< T >
par::sys::specific< T >Provide thread specific global variables
par::bench::spreadStore lists of values in spread sheet lines that are hashed into a directory hierarchy
par::mem::stack< T >Lets you collect items on a potentially growing stack
par::sys::statHold the status of a filesystem entry or file descriptor
stat_struct
par::cell::stat_tCompresses the main information about the output of a cell into one word
par::cntrl::mpi::stateImplement the stack of states that mpi has to remember
par::cntrl::svm::state
par::cntrl::state_markerNot to be used directly
par::cpp::statistic< D >Handle a statistic of random variable of base type D
par::cpp::statistic2< D >A class for two-dimensional statistics
par::mem::stoptr< T >Hold an absolutely relocatable reference to data inside a store
par::mem::stoptr_voidThe base class of all par::mem::stoptr
par::mem::stoptr_volatile< T volatile >Hold an absolutely relocatable reference to data inside a store
par::mem::stoptr_volatile< void const volatile >
par::mem::stoptr_volatile< void volatile >
par::mem::storeAn extendable storage class for potentially shared variables
par::mem::store::store::headerEach store will have a header that starts at its position 0
par::cntrl::strA shared string variable between the parXXL processes
par::sys::strA wrapper around a char* that implements POSIX str... functions
par::sys::str::str::stateClass to hold the state of the string search strtok
par::sys::stree< T >A template class that wraps POSIX functions tsearch etc
par::sys::strtmp
par::cntrl::strvecA strvec of size par::cntrl::info::np(), one value per parXXL process
par::step::subiterator
par::cpp::svErr< T >Compile time error detection for the par::cpp::subvector functions
par::cpp::svErr< T >::svErr::sD< d0 >
par::cpp::svErr< T >::svErr::sD< d0 >::svErr::sD::tD< d1 >
par::cpp::svErr< T >::svErr::sD< d0 >::svErr::sD::tD< d1 >::svErr::sD::tD::offset< off >
par::step::symmetric_extraction< T_t >
par::cell::sync_t
par::cell::system_tHandles the different call backs of an individual cell
par::cntrl::tag_state
TData
par::cpp::terminalClass wrapper around par::cpp::terminal_rel that does the correct allocations on the heap
par::cpp::terminal_relA simple class to draw on a terminal
par::cpp::terminal_rel::terminal_rel::state_t
par::cpp::termposPosition the cursor at point (x, y)
par::cpp::termupMove the cursor up x lines (or down if negative)
par::sys::thread< _phases >Launch a worker thread for a specific task
par::cntrl::thread
par::sys::thread_tThe interface class for par::sys::thread and derivatives
par::sys::thread_t::thread_t::attr_tA wrapper interface to implement POSIX thread attributes
par::bench::timerTake some time mesure
timespec
par::sys::timespecA wrapper to the system data structure timespec
par::bench::timingAuxiliary class for PAR_BENCH_TIMING
TKey
par::sys::trapCatching system faults
par::sys::trap::trap::contextStore the current context of a thread
par::cpp::uhash< twist, T >
par::sys::uhash< twist, T >Wrap cpp::uhash to have a random initialization from par::sys::seed_t
par::cntrl::uhash< twist, T >
par::cpp::uhash< 0, T >
par::cpp::uhash< 1, T >
par::cntrl::unserialize
par::sys::unserialize
par::mem::url_tParse an URL into its components
par::cell::var_tThe user may place arbitrary data at each cell. The only restriction is that their type must be derived from this
par::cntrl::variable< T >A shared variable between the parXXL processes
par::cntrl::vector< T >A vector of size par::cntrl::info::np(), one value per parXXL process
par::step::vforest< val_t >A class that implements a distributed valuated forest of items
par::step::voidPredicate
par::sys::ziggurat< exponent, distri >A class that implements Marsaglia's ziggurat method for sampling probability distributions with continuous, decreasing density function

Generated on Tue Oct 13 22:03:54 2009 for parXXL by  doxygen 1.5.8