| ►Nexamples | |
| ►Nbfs | |
| CBfsNode | |
| CNodeParentPair | |
| CTreeInfo | |
| ►Nk_means | |
| CCentroidAccumulated | A point which contains "count" accumulated vectors |
| CClosestCentroid | Assignment of a point to a cluster, which is the input to |
| CKMeansModel | Model returned by KMeans algorithm containing results |
| ►Npage_rank | |
| CPagePageLink | A pair (page source, page target) |
| CPageRankPair | A pair (page, rank) |
| CZipfGraphGen | |
| ►Nstochastic_gradient_descent | |
| CDataPoint | Model for one point consisting of a d-dimensional position and a label |
| CGradientResult | |
| CLeastSquaresGradient | |
| CStochasticGradientDescent | |
| CSumResult | |
| ►Nsuffix_sorting | |
| CIndexChar | |
| CIndexFlag | |
| CIndexRank | A pair (index, rank) |
| CIndexRankFlag | |
| ►Nword_count | |
| CHashWordHasher | |
| ►Nfoxxll | FOXXLL library namespace |
| ►Nmng_local | Block Manager Internals |
| Cadd_filler | Contains per block filler for foxxll::typed_block , not intended for direct use |
| Cadd_filler< BaseType, 0 > | |
| Cblock_w_bids | Contains BID references for foxxll::typed_block , not intended for direct use |
| Cblock_w_bids< Type, Size, RawSize, 0 > | |
| Cblock_w_info | Contains per block information for foxxll::typed_block , not intended for direct use |
| Cblock_w_info< Type, RawSize, NBids, void > | |
| Celement_block | Contains data elements for foxxll::typed_block , not intended for direct use |
| Cexpand_struct | Helper to compute the size of the filler , not intended for direct use |
| Cfiller_struct | |
| Cfiller_struct< 0 > | |
| Caddressable_fifo_queue | |
| ►Caddressable_priority_queue | |
| Ccmp | |
| Caligned_alloc_settings | |
| Cbad_ext_alloc | |
| Cbad_parameter | |
| Cbasic_allocation_strategy | |
| CBID | |
| CBID< 0 > | Specialization of block identifier class (BID) for variable size block size |
| Cblock_manager | Block manager class |
| Cblock_prefetcher | |
| ►Cblock_scheduler | |
| Cprediction_sequence_element | |
| Cblock_scheduler_algorithm | Interface of a block scheduling algorithm |
| ►Cblock_scheduler_algorithm_offline_lfd | Block scheduling algorithm caching via the longest forward distance policy (offline) |
| Cpriority | |
| ►Cblock_scheduler_algorithm_offline_lru_prefetching | |
| Cread_after_write | |
| Cscheduled_block_meta | |
| Cwrite_read_request | |
| Cblock_scheduler_algorithm_online_lru | Block scheduling algorithm caching via the least recently used policy (online) |
| Cblock_scheduler_algorithm_simulation | Pseudo block scheduling algorithm only recording the request sequence |
| Cbuf_istream | |
| Cbuf_istream_reverse | |
| Cbuf_ostream | |
| ►Cbuffered_writer | |
| Cbatch_entry | |
| Cbatch_entry_cmp | |
| CCASE | |
| Cconfig | |
| Cdisk_block_allocator | This class manages allocation of blocks onto a single disk |
| Cdisk_config | |
| Cdisk_queued_file | Implementation of some file methods based on serving_request |
| Cdisk_queues | |
| Cfake_timer | Class fake_timer is a drop-in replacement for timer, which does nothing |
| Cfile | |
| ►Cfile_stats | |
| Cscoped_read_timer | |
| Cscoped_read_write_timer | |
| Cscoped_write_timer | |
| Cfile_stats_data | |
| Cfileperblock_file | |
| Cfirst_disk_only | |
| Cfully_random | |
| Cinterleaved_alloc_traits | |
| Cinterleaved_alloc_traits< fully_random > | |
| Cinterleaved_alloc_traits< random_cyclic > | |
| Cinterleaved_alloc_traits< random_cyclic_disk > | |
| Cinterleaved_alloc_traits< random_cyclic_flash > | |
| Cinterleaved_alloc_traits< simple_random > | |
| Cinterleaved_alloc_traits< single_disk > | |
| Cinterleaved_alloc_traits< striping > | |
| Cinterleaved_fully_random | |
| Cinterleaved_random_cyclic | |
| Cinterleaved_simple_random | |
| Cinterleaved_striping | |
| Cio_error | |
| Cmemory_file | Implementation of file based on new[] and memcpy |
| ►Cnew_alloc | |
| Crebind | |
| Cnew_alloc_rebind | |
| Cnew_alloc_rebind< Type, Type > | |
| CNilCase | |
| Coffset_allocator | |
| Conoff_switch | |
| ►Cprefetch_pool | Implements dynamically resizable prefetching pool |
| Cbid_hash | |
| Crandom_cyclic | |
| Crandom_cyclic_disk | |
| Crandom_cyclic_flash | |
| Cread_write_pool | Implements dynamically resizable buffered writing and prefetched reading pool |
| Crequest | Request object encapsulating basic properties like file and offset |
| Crequest_interface | |
| Crequest_queue | Interface of a request_queue to which requests can be added and canceled |
| Crequest_queue_impl_1q | |
| Crequest_queue_impl_qwqr | |
| Crequest_queue_impl_worker | |
| Crequest_with_state | Request with completion shared_state |
| Crequest_with_waiters | Request that is aware of threads waiting for it to complete |
| Cresource_error | |
| Cscoped_print_iostats | Simple scoped iostats reporter which takes a message and reports the relative IO performance on destruction |
| Cscoped_print_timer | Simple scoped timer, which takes a text message and prints the duration until the scope is destroyed |
| Cserving_request | Request which serves an I/O by calling the synchronous routine of the file |
| Cset_switch_handler | |
| Cshared_state | |
| Csimple_random | |
| Csingle_disk | |
| Csingleton | |
| ►Cstats | |
| Cscoped_wait_timer | |
| ►Cstats_data | |
| Csummary | |
| Cstriping | |
| Cswappable_block | |
| CSWITCH | |
| CSWITCH< Tag, NilCase > | |
| Csyscall_file | Implementation of file based on UNIX syscalls |
| Ctimer | Class timer is a simple stop watch timer |
| Ctyped_block | |
| Cufs_file_base | Base for UNIX file system implementations |
| Cuint_pair | Construct an 40-bit or 48-bit unsigned integer stored in five or six bytes |
| Cunreachable | |
| ►Cwrite_pool | Implements dynamically resizable buffered writing pool |
| Cbusy_entry | |
| ►Nstd | STL namespace |
| Chash< Edge > | |
| Chash< tlx::StringView > | |
| Cnumeric_limits< foxxll::uint_pair< HighType > > | Template class providing some numeric_limits fields for uint_pair types |
| Cnumeric_limits< thrill::common::UIntPair< HighType > > | Template class providing some numeric_limits fields for UIntPair types |
| ►Nthrill | |
| ►Napi | |
| CActionNode | |
| CActionResultNode | |
| CAllGatherNode | |
| CAllReduceNode | |
| CArrayTag | Tag structure for ZipWindow() |
| CBaseWindowNode | |
| CBernoulliSampleNode | |
| CCacheNode | A DOpNode which caches all items in an external file |
| CCollapseNode | |
| CCollapseSwitch | Template switch to generate a CollapseNode if there is a non-empty Stack |
| CCollapseSwitch< ValueType, tlx::FunctionStack< ValueType > > | Template switch to NOT generate a CollapseNode if there is an empty Stack |
| ►CConcatNode | |
| CRegisterParent | |
| CConcatToDIANode | |
| CContext | The Context of a job is a unique instance per worker which holds references to all underlying parts of Thrill |
| CCutTag | Tag structure for Zip() |
| CDefaultReduceConfig | |
| CDefaultReduceToIndexConfig | |
| CDefaultSortAlgorithm | |
| CDefaultStableSortAlgorithm | |
| CDIA | DIA is the interface between the user and the Thrill framework |
| CDIABase | The DIABase is the untyped super class of DIANode |
| CDIAMemUse | Description of the amount of RAM the internal data structures of a DIANode require |
| ►CDIANode | A DIANode is a typed node representing and operation in Thrill |
| CChild | |
| CDisjointTag | Tag structure for Window() and FlatWindow() |
| CDisjointWindowNode | |
| CDistributeNode | |
| CDOpNode | A DOpNode is a typed node representing and distributed operations in Thrill |
| CDuplicateDetectionFlag | Tag structure for ReduceByKey() |
| CEqualToDIANode | |
| CFuture | The return type class for all ActionFutures |
| CFuture< void > | Specialized template class for ActionFuture which return void |
| CGatherNode | |
| CGenerateNode | A DIANode which performs a Generate operation |
| CGroupByIterator | |
| CGroupByMultiwayMergeIterator | |
| ►CGroupByNode | |
| CHashCount | |
| CValueComparator | |
| ►CGroupToIndexNode | |
| CValueComparator | |
| CHostContext | The HostContext contains all data structures shared among workers on the same host |
| CHyperLogLogNode | |
| ►CJoinNode | Performs an inner join between two DIAs |
| CHashCount | Hash counter used by LocationDetection |
| CLocalStorageTag | Tag structure for Read() |
| CLocationDetectionFlag | Tag structure for GroupByKey(), and InnerJoin() |
| CMemoryConfig | |
| ►CMergeNode | Implementation of Thrill's merge |
| CPivot | |
| CReducePivots | |
| CRegisterParent | |
| CStats | Stats holds timers for measuring merge performance, that supports accumulating the output and printing it to the standard out stream |
| CNoRebalanceTag | Tag structure for Zip() |
| COverlapWindowNode | |
| CPadTag | Tag structure for Zip() |
| CPrefixSumNode | |
| ►CReadBinaryNode | A DIANode which performs a line-based Read operation |
| CFileInfo | Structure to store info on what to read from files |
| CVfsFileBlockSource | |
| ►CReadLinesNode | A DIANode which performs a line-based Read operation |
| CInputLineIterator | |
| CInputLineIteratorCompressed | InputLineIterator gives you access to lines of a file |
| CInputLineIteratorUncompressed | InputLineIterator gives you access to lines of a file |
| CRebalanceNode | |
| ►CReduceNode | A DIANode which performs a Reduce operation |
| CEmitter | Emitter for PostPhase to push elements to next DIA object |
| ►CReduceToIndexNode | A DIANode which performs a ReduceToIndex operation |
| CEmitter | Emitter for PostPhase to push elements to next DIA object |
| CSampleNode | A DIANode which performs sampling without replacement |
| CSizeNode | |
| CSkipPreReducePhaseTag | Tag structure for ReduceToIndex() |
| ►CSortNode | A DIANode which performs a Sort operation |
| CMakeDefaultMultiwayMergeTree | Multiway merge tree creation depends on Stable flag |
| CMakeStableMultiwayMergeTree | |
| CTreeBuilder | |
| CSourceNode | |
| ►CUnionNode | Implements a Union operation by hooking any number of input DIANodes and forwarding the output immediately to all children |
| CRegisterParent | |
| CUnionChild | |
| CVolatileKeyFlag | Tag structure for ReduceByKey(), and ReduceToIndex() |
| ►CWriteBinaryNode | |
| CSysFileSink | Implements BlockSink class writing to files with size limit |
| CWriteLinesNode | |
| CWriteLinesOneNode | |
| ►CZipNode | A DIANode which performs a Zip operation |
| CReaderNext | Access CatReaders for different different parents |
| CRegisterParent | Register Parent PreOp Hooks, instantiated and called for each Zip parent |
| ►CZipWindowNode | |
| CRegisterParent | Register Parent PreOp Hooks, instantiated and called for each Zip parent |
| CZipWindowReader | |
| CZipWindowReader< ZipWindowNode, false > | Template specialization Reader which delivers std::vector<>s to ZipFunction |
| CZipWindowReader< ZipWindowNode, true > | Template specialization Reader which delivers std::array<>s to ZipFunction |
| CZipWindowTraits< ReturnType(*)(Args...)> | Specialize for function pointers |
| CZipWindowTraits< ReturnType(ClassType::*)(Args...) const > | Specialize for pointers to const member function |
| CZipWindowTraits< ReturnType(ClassType::*)(Args...)> | Specialize for pointers to mutable member function |
| CZipWithIndexNode | A DIANode which calculates the array index for each items and performs a Zip-like operation without extra rebalancing of the DIA data |
| ►Ncommon | Contains many common tools and helpers shared by higher layers. See common |
| Calias_cast_helper | |
| CAtomicMovable | This is a derivative of std::atomic which enables easier and less error-prone writing of move-only classes by implementing a move constructor |
| CBinaryHeap | |
| CComponentSum | Template for computing the component-wise sum of std::array or std::vector |
| CComponentSum< std::array< Type, N >, Operation > | Compute the component-wise sum of two std::array<T,N> of same sizes |
| CComponentSum< std::vector< Type >, Operation > | Compute the component-wise sum of two std::vector<T> of same sizes |
| CConcurrentBoundedQueue | This is a queue, similar to std::queue and tbb::concurrent_bounded_queue, except that it uses mutexes for synchronization |
| CConcurrentQueue | This is a queue, similar to std::queue and tbb::concurrent_queue, except that it uses mutexes for synchronization |
| CErrnoException | An Exception which is thrown on system errors and contains errno information |
| CFunctionTraits< ReturnType(*)(Args...)> | Specialize for function pointers |
| CFunctionTraits< ReturnType(ClassType::*)(Args...) const > | Specialize for pointers to const member function |
| CFunctionTraits< ReturnType(ClassType::*)(Args...)> | Specialize for pointers to mutable member function |
| CHashCrc32Fallback | |
| CHashDataSwitch | Hashing helper that decides what is hashed |
| CHashDataSwitch< std::string > | |
| Chypergeometric_distribution | |
| CIdentity | Identity functor, very useful for default parameters |
| CItemReaderToolsBase | CRTP class to enhance item/memory reader classes with Varint decoding and String decoding |
| CItemWriterToolsBase | CRTP class to enhance item/memory writer classes with Varint encoding and String encoding |
| CJsonBeginObj | A special class to output verbatim text |
| CJsonEndObj | A special class to output verbatim text |
| ►CJsonLine | JsonLine is an object used to aggregate a set of key:value pairs for output into a JSON log |
| CArrayTag | |
| CDictionaryTag | |
| CJsonLinePutSwitch | |
| CJsonLogger | JsonLogger is a receiver of JSON output objects for logging |
| CJsonVerbatim | A special class to output verbatim text |
| CMatrix | A simple m x n dense matrix for generating statistics |
| Cmaximum | |
| Cminimum | |
| CProfileTask | |
| CProfileTaskRegistration | |
| ►CProfileThread | |
| CTimer | Struct for timer callbacks |
| CRadixSort | SortAlgorithm class for use with api::Sort() which calls radix_sort_CI() if K is small enough |
| CRange | 1 dimensional range (interval) [begin,end) |
| CReservoirSampling | Implementation of reservoir sampling using Vitter's Algorithm R |
| CReservoirSamplingFast | Fast exact implementation of reservoir sampling using skip values |
| CReservoirSamplingGrow | Implementation of a fast approximation of adaptive reservoir sampling using http://erikerlandson.github.io/blog/2015/11/20/very-fast-reservoir-sampling/ The reservoir size grows logarithmically with the number given to the sampler, new items replace old ones such that all items in the stream are sampled with the same approximately uniform probability |
| CRunTimer | RIAA class for running the timer until destruction |
| CSampling | |
| CSharedState | |
| CSingleton | |
| CStatsCounter | This class provides a statistical counter that can easily be deactivated using a boolean template switch |
| CStatsCounter< ValueType_, false > | |
| CStatsCounter< ValueType_, true > | |
| CStatsTimerBase | This class provides a statistical stop watch timer that can easily be deactivated using a boolean template switch |
| CStatsTimerBase< false > | |
| CStatsTimerBase< true > | |
| CStatsTimerBaseStarted | |
| CStatsTimerBaseStopped | |
| CSystemException | An Exception which is thrown on system errors |
| CTabulationHashing | Tabulation Hashing, see https://en.wikipedia.org/wiki/Tabulation_hashing |
| CTimedCounter | |
| CUIntPair | Construct an 40-bit or 48-bit unsigned integer stored in five or six bytes |
| CVector | A compile-time fixed-length D-dimensional point with double precision |
| CVectorConcat | Compute the concatenation of two std::vector<T>s |
| CVVector | A variable-length D-dimensional point with double precision |
| CZipfDistribution | A class for producing random integers distributed according to the Zipf-Mandelbrot probability mass function: |
| ►Ncore | |
| CBitStreamReader | |
| CBitStreamWriter | |
| CBufferedMultiwayMergeTree | |
| CDefaultReduceConfig | Configuration class to define operational parameters of reduce hash tables and reduce phases |
| CDefaultReduceConfigSelect | DefaultReduceConfig with implementation type selection |
| CDeltaStreamReader | |
| CDeltaStreamWriter | |
| CDuplicateDetection | Duplicate detection to identify all elements occuring only on one worker |
| CGolombBitStreamReader | |
| CGolombBitStreamWriter | |
| CHyperLogLogRegisters | |
| ►CLocationDetection | |
| CExtractHash | |
| CGolombPairReader | |
| CMultiwayMergeTree | |
| ►CReduceBucketHashTable | A data structure which takes an arbitrary value and extracts a key using a key extractor function from that value |
| CBucketBlock | Block holding reduce key/value pairs |
| CBucketBlockPool | BucketBlockPool to stack allocated BucketBlocks |
| ►CReduceByHash | A reduce index function which returns a hash index and partition |
| CResult | |
| CReduceByHashPostPhase | |
| ►CReduceByIndex | A reduce index function, which determines a bucket depending on the current index range [begin,end) |
| CResult | |
| CReduceByIndexPostPhase | |
| CReduceMakeTableItem | |
| CReduceMakeTableItem< Value, TableItem, false > | |
| CReduceMakeTableItem< Value, TableItem, true > | |
| CReduceOldProbingHashTable | A data structure which takes an arbitrary value and extracts a key using a key extractor function from that value |
| CReducePostPhaseEmitter | |
| CReducePrePhase | |
| CReducePrePhase< TableItem, Key, Value, KeyExtractor, ReduceFunction, VolatileKey, BlockWriter, ReduceConfig, IndexFunction, EqualToFunction, HashFunction, true > | |
| CReducePrePhase< TableItem, Key, Value, KeyExtractor, ReduceFunction, VolatileKey, BlockWriter, ReduceConfig_, IndexFunction, KeyEqualFunction, HashFunction, false > | |
| CReducePrePhaseEmitter | |
| CReduceProbingHashTable | A data structure which takes an arbitrary value and extracts a key using a key extractor function from that value |
| CReduceTable | Common super-class for bucket and linear-probing hash/reduce tables |
| CReduceTableSelect | Type selection via ReduceTableImpl enum |
| CReduceTableSelect< ReduceTableImpl::BUCKET, TableItem, Key, Value, KeyExtractor, ReduceFunction, Emitter, VolatileKey, ReduceConfig, IndexFunction, KeyEqualFunction > | |
| CReduceTableSelect< ReduceTableImpl::OLD_PROBING, TableItem, Key, Value, KeyExtractor, ReduceFunction, Emitter, VolatileKey, ReduceConfig, IndexFunction, KeyEqualFunction > | |
| CReduceTableSelect< ReduceTableImpl::PROBING, TableItem, Key, Value, KeyExtractor, ReduceFunction, Emitter, VolatileKey, ReduceConfig, IndexFunction, KeyEqualFunction > | |
| CToVectorEmitter | Emitter for a ReduceTable, which emits all of its data into a vector of hash-counter-pairs |
| ►Ndata | |
| ►Ndetail | |
| CTupleDeserializer | |
| CTupleDeserializer< Archive, 0, std::tuple<> > | |
| CTupleDeserializer< Archive, RevIndex, std::tuple< T, Args... > > | |
| CTupleSerialization | |
| CTupleSerialization< Archive, 0, Args... > | |
| ►Nserialization_cereal | |
| CThrillInputArchive | An input archive designed to load data saved using ThrillOutputArchive |
| CThrillOutputArchive | An output archive designed to save data in a compact binary representation |
| CBlock | Block combines a reference to a read-only ByteBlock and book-keeping information |
| CBlockPool | Pool to allocate, keep, swap out/in, and free all ByteBlocks on the host |
| CBlockPoolMemoryHolder | RAII class for allocating memory from a BlockPool |
| CBlockQueue | A BlockQueue is a thread-safe queue used to hand-over Block objects between threads |
| CBlockQueueSink | BlockSink which interfaces to a File |
| CBlockReader | BlockReader takes Block objects from BlockSource and allows reading of a) serializable Items or b) arbitray data from the Block sequence |
| CBlockSink | Pure virtual base class for all things that can receive Blocks from a BlockWriter |
| CBlockWriter | BlockWriter contains a temporary Block object into which a) any serializable item can be stored or b) any arbitrary integral data can be appended |
| CBoundedBlockSink | Derivative BlockSink which counts and limits how many bytes it has delivered as ByteBlocks for writing |
| ►CByteBlock | A ByteBlock is the basic storage units of containers like File, BlockQueue, etc |
| CDeleter | Deleter for CountingPtr<ByteBlock> |
| CByteBlockPtr | A non-pinned counting pointer to a ByteBlock |
| CCacheBlockQueueSource | A BlockSource to read Blocks from a BlockQueue using a BlockReader, and at the same time CACHE all items received |
| CCatBlockSource | CatBlockSource is a BlockSource which concatenates all Blocks available from a vector of BlockSources |
| CCatStream | Ownership handle onto a CatStreamData |
| CCatStreamData | A Stream is a virtual set of connections to all other worker instances, hence a "Stream" bundles them to a logical communication context |
| CConsumeBlockQueueSource | A BlockSource to read Block from a BlockQueue using a BlockReader |
| CConsumeFileBlockSource | A BlockSource to read and simultaneously consume Blocks from a File |
| CDiscardSink | DiscardSink is an BlockSink that discards all Blocks delivered to it |
| CDynBlockSource | This is the actual BlockSource used to instantiate BlockReader |
| CDynBlockSourceAdapter | Adapter class to wrap any existing BlockSource concept class into a DynBlockSourceInterface |
| CDynBlockSourceInterface | This is a pure virtual base which will be used to fetch Blocks for the BlockReader from different sources |
| CFile | A File is an ordered sequence of Block objects for storing items |
| CFileBlockSink | BlockSink which interfaces to a File |
| CFullException | An Exception is thrown by BlockWriter when the underlying sink does not allow allocation of a new block, which is needed to serialize the item |
| CKeepFileBlockSource | A BlockSource to read Blocks from a File |
| ►CMixBlockQueue | Implements reading an unordered sequence of items from multiple workers, which sends Blocks |
| CSrcBlockPair | Pair of (source worker, Block) stored in the main mix queue |
| CMixBlockQueueReader | Reader to retrieve items in unordered sequence from a MixBlockQueue |
| CMixStream | Ownership handle onto a MixStream |
| CMixStreamData | A Stream is a virtual set of connections to all other worker instances, hence a "Stream" bundles them to a logical communication context |
| CMultiplexer | Multiplexes virtual Connections on Dispatcher |
| CMultiplexerHeader | |
| CPartitionMultiplexerHeader | |
| CPinnedBlock | A pinned / pin-counted derivative of a Block |
| CPinnedByteBlockPtr | A pinned / pin-counted pointer to a ByteBlock |
| CPinRequest | |
| CSerialization | |
| CSerialization< Archive, core::HyperLogLogRegisters< p > > | |
| CSerialization< Archive, std::array< T, N >, typename std::enable_if< !std::is_pod< std::array< T, N > >::value >::type > | |
| CSerialization< Archive, std::pair< U, V > > | |
| CSerialization< Archive, std::string > | |
| CSerialization< Archive, std::tuple< Args... > > | |
| CSerialization< Archive, std::vector< T > > | |
| CSerialization< Archive, T, typename std::enable_if< cereal::traits::is_input_serializable< T, Archive >::value &&!std::is_pod< T >::value &&!std::is_same< T, std::string >::value &&!tlx::is_std_pair< T >::value &&!tlx::is_std_array< T >::value &&!tlx::is_std_vector< T >::value &&!tlx::is_std_tuple< T >::value >::type > | |
| CSerialization< Archive, T, typename std::enable_if< has_member_thrill_is_fixed_size< T >::value >::type > | |
| CSerialization< Archive, T, typename std::enable_if< std::is_pod< T >::value &&!std::is_pointer< T >::value >::type > | |
| CStream | Stream - base class for CatStream and MixStream |
| ►CStreamData | Base class for common structures for ConcatStream and MixedStream |
| CWriters | An extra class derived from std::vector<> for delivery of the BlockWriters of a Stream |
| CStreamMultiplexerHeader | Block header is sent before a sequence of blocks it indicates the number of elements and their boundaries |
| CStreamSet | Simple structure that holds a all stream instances for the workers on the local host for a given stream id |
| CStreamSetBase | Base class for StreamSet |
| CStreamSink | StreamSink is an BlockSink that sends data via a network socket to the StreamData object on a different worker |
| ►Nmem | |
| ►CAlignedAllocator | |
| Crebind | Return allocator for different type |
| CAlignedAllocatorSettings | |
| ►CAllocator | |
| Crebind | Return allocator for different type |
| ►CAllocator< void > | |
| Crebind | |
| CDeleter | Std::default_deleter with Manager tracking |
| ►CFixedAllocator | |
| Crebind | Return allocator for different type |
| ►CFixedAllocator< void, manager_ > | |
| Crebind | |
| ►CFixedPoolAllocator | |
| Crebind | Return allocator for different type |
| CGPoolDeleter | Deleter for unique_ptr with memory from mem::g_pool |
| CManager | Object shared by allocators and other classes to track memory allocations |
| CPool | A simple memory allocation manager |
| ►CPoolAllocator | |
| Crebind | Return allocator for different type |
| ►Nnet | |
| ►Nmock | |
| CConnection | A virtual connection through the mock network: each Group has p Connections to its peers |
| CDispatcher | A virtual Dispatcher which waits for messages to arrive in the mock network |
| CGroup | The central object of a mock network: the Group containing links to other mock Group forming the network |
| ►Nmpi | |
| CAsyncRequest | |
| CConnection | Virtual MPI connection class |
| ►CDispatcher | |
| CMpiAsync | This is the big answer to what happens when an MPI async request is signaled as complete: it unifies all possible async requests, including the reference counts they hold on the appropriate buffers, and dispatches the correct callbacks when done |
| CWatch | Callback vectors per peer |
| CException | A derived exception class which looks up MPI error strings |
| CGroup | A net group backed by virtual MPI connection |
| ►Ntcp | |
| CConnection | Connection is a rich point-to-point socket connection to another client (worker, master, or whatever) |
| CGroup | Collection of NetConnections to workers, allows point-to-point client communication and simple collectives like MPI |
| CIPv4Address | IPv4 Subclass of SocketAddress for direct initialization from a known IPv4 address, known either in binary format, numerals, or as "ddd.ddd.ddd.ddd" format |
| CIPv6Address | IPv6 Subclass of SocketAddress for direct initialization from a known IPv6 address, known either in binary format, numerals, or in some IPv6 format |
| CSelect | Select is an object-oriented wrapper for select() |
| ►CSelectDispatcher | SelectDispatcher is a higher level wrapper for select() |
| CWatch | Callback vectors per watched file descriptor |
| CSocket | Socket is a light-weight wrapper around the BSD socket API |
| ►CSocketAddress | SocketAddress is a super class used to unify the two different IPv4 and IPv6 socket address representation |
| CSockAddrUnion | |
| CAsyncReadBuffer | |
| CAsyncReadByteBlock | |
| CAsyncWriteBlock | |
| CAsyncWriteBuffer | |
| CBuffer | Simple buffer of characters without initialization or growing functionality |
| CBufferBuilder | BufferBuilder represents a dynamically growable area of memory, which can be modified by appending integral data types via Put() and other basic operations |
| CBufferReader | BufferReader represents a BufferRef with an additional cursor with which the memory can be read incrementally |
| CBufferRef | BufferRef represents a reference to a memory area as pointer and valid length |
| CConnection | A Connection represents a link to another peer in a network group |
| ►CDispatcher | Dispatcher is a high level wrapper for asynchronous callback processing |
| CTimer | Struct for timer callbacks |
| CDispatcherThread | DispatcherThread contains a net::Dispatcher object and an associated thread that runs in the dispatching loop |
| CException | A Exception is thrown by Connection on all errors instead of returning error codes |
| CFixedBufferBuilder | Represents a FIXED length area of memory, which can be modified by appending integral data types via Put() and other basic operations |
| ►CFlowControlChannel | Provides a blocking collection for communication |
| CLocalData | |
| CFlowControlChannelManager | |
| CGroup | A network Group is a collection of enumerated communication links, which provides point-to-point communication and MPI-like collective primitives |
| CManager | Initializes communication channels, manages communication channels and handles errors |
| CTraffic | |
| ►Nvfs | |
| ►Nglob_local | |
| CCSimpleGlobTempl | Implementation of the SimpleGlob class |
| CSimpleGlobBase | Unix glob implementation |
| CSimpleGlobUtil | String manipulation functions |
| CFileInfo | General information of vfs file |
| CFileList | List of file info and additional overall info |
| CReadStream | Reader object from any source |
| CTemporaryDirectory | A class which creates a temporary directory in the current directory and returns it via get() |
| CWriteStream | Writer object to output data to any supported URI |
| ►Ntlx | |
| ►Nmeta_detail | |
| CCallForRangeImpl | Helper for call_for_range: general recursive case |
| CCallForRangeImpl< Index, 0, Functor > | Helper for call_for_range: base case |
| Cmake_index_sequence_helper | |
| Cmake_index_sequence_helper< 0, Indexes... > | |
| CVMapForRangeImpl | Helper for vmap_for_range: general recursive case |
| CVMapForRangeImpl< Index, 0, Functor > | Helper for vmap_for_range: base case |
| ►Nmultisequence_partition_detail | |
| Clexicographic | Compare a pair of types lexicographically, ascending |
| Clexicographic_rev | Compare a pair of types lexicographically, descending |
| ►Nmultisequence_selection_detail | |
| Clexicographic | Compare a pair of types lexicographically, ascending |
| Clexicographic_rev | Compare a pair of types lexicographically, descending |
| ►Nmultiway_merge_detail | |
| Cguarded_iterator | Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons |
| Cunguarded_iterator | |
| ►Nparallel_mergesort_detail | |
| CPMWMSPiece | Subsequence description |
| CPMWMSSortingData | Data accessed by all threads |
| ►Nradix_heap_detail | |
| CBitArray | A BitArray of fixed size supporting reading, setting, and clearing of individual bits |
| CBitArrayRecursive | |
| CBitArrayRecursive< Size, false > | |
| CBitArrayRecursive< Size, true > | |
| CBucketComputation | |
| CIntegerRank | Compute the rank of an integer x (i.e |
| CPairKeyExtract | Used as an adapter to implement RadixHeapPair on top of RadixHeap |
| ►Nsort_strings_detail | |
| CGenericCharStringSet | Class implementing StringSet concept for char* and unsigned char* strings |
| CGenericCharStringSetTraits | Traits class implementing StringSet concept for char* and unsigned char* strings |
| CPerfectTreeCalculations | Class to transform in-order to level-order indexes in a perfect binary tree |
| CPS5BigSortStep | PS5BigSortStep Out-of-Place Parallel Sample Sort with Separate Jobs |
| CPS5Context | Parallel Super Scalar String Sample Sort Context |
| CPS5ParametersDefault | Parallel Super Scalar String Sample Sort Parameter Struct |
| ►CPS5SmallsortJob | SampleSort: Non-Recursive In-Place Sequential Sample Sort for Small Sorts |
| CMKQSStep | |
| CSeqSampleSortStep | Stack of Recursive Sample Sort Steps |
| CPS5SortStep | PS5SortStep Top-Level Class to Keep Track of Substeps |
| CRadixStep_CE0 | |
| CRadixStep_CE2 | |
| CRadixStep_CE3 | |
| CRadixStep_CI2 | |
| CRadixStep_CI3 | |
| CSSClassifyEqualUnroll | Sample Sort Classification Tree Unrolled with Equal Comparisons |
| CSSClassifyTreeCalcUnrollInterleave | |
| CSSClassifyTreeUnrollInterleave | Sample Sort Classification Tree Unrolled and Interleaved |
| CSSTreeBuilderLevelOrder | |
| CSSTreeBuilderPreAndLevelOrder | |
| CStdStringSet | Class implementing StringSet concept for arrays of std::string objects |
| CStdStringSetTraits | Class implementing StringSet concept for a std::string objects |
| CStringLcpPtr | Objectified string and LCP array pointer arrays |
| CStringPtr | Objectified string array pointer array |
| CStringSetBase | Base class for common string set functions, included via CRTP |
| CStringShadowLcpPtr | |
| CStringShadowPtr | |
| CStringSuffixSet | Class implementing StringSet concept for suffix sorting indexes of a std::string text object |
| CStringSuffixSetTraits | Class implementing StringSet concept for suffix sorting indexes of a std::string text object |
| CUPtrStdStringSet | Class implementing StringSet concept for a std::vector containing std::string objects |
| CUPtrStdStringSetTraits | Class implementing StringSet concept for a std::unique_ptr<std::string objects, which are non-copyable |
| CAggregate | Calculate running aggregate statistics: feed it with values, and it will keep the minimum, the maximum, the average, the value number, and the standard deviation is values |
| CAggregateMinMax | Calculate running aggregate statistics: feed it with values, and it will keep the minimum and the maximum values |
| CAllocatorBase | |
| ►CBTree | Basic class implementing a B+ tree data structure in memory |
| Cconst_iterator | |
| Cconst_reverse_iterator | |
| CInnerNode | |
| Citerator | |
| CLeafNode | |
| Cnode | |
| Cresult_t | |
| Creverse_iterator | |
| Ctree_stats | A small struct containing basic statistics about the B+ tree |
| Cvalue_compare | Function class to compare value_type objects. Required by the STL |
| Cbtree_default_traits | Generates default traits for a B+ tree used as a set or map |
| ►Cbtree_map | Specialized B+ tree template class implementing STL's map container |
| Ckey_of_value | Key Extractor Struct |
| ►Cbtree_multimap | Specialized B+ tree template class implementing STL's multimap container |
| Ckey_of_value | Key Extractor Struct |
| ►Cbtree_multiset | Specialized B+ tree template class implementing STL's multiset container |
| Ckey_of_value | Key Extractor Struct |
| ►Cbtree_set | Specialized B+ tree template class implementing STL's set container |
| Ckey_of_value | Key Extractor Struct |
| CCmdlineParser | Command line parser which automatically fills variables and prints nice usage messages |
| CCountingPtr | High-performance smart pointer used as a wrapping reference counting pointer |
| CCountingPtrDefaultDeleter | Default deleter for CountingPtr |
| CCountingPtrNoOperationDeleter | Dummy deleter for CountingPtr |
| CDAryAddressableIntHeap | This class implements an addressable integer priority queue, precisely a d-ary heap |
| CDAryHeap | This class implements a d-ary comparison-based heap usable as a priority queue |
| CDelegate | |
| ►CDelegate< R(A...), Allocator > | This is a faster replacement than std::function |
| CIsConstMemberPair | Template for const class::function selector |
| CIsConstMemberPair< ConstMemberPair< C > > | Specialization for const class::function selector |
| CIsMemberPair | Template for class::function selector |
| CIsMemberPair< MemberPair< C > > | Specialization for class::function selector |
| CDieException | Exception thrown by die_with_message() if |
| Cenable_if | SFINAE enable_if – copy of std::enable_if<> with less extra cruft |
| Cenable_if< true, T > | |
| CFunctionChain | A FunctionChain is a chain of functors that can be folded to a single functors |
| CFunctionStack | A FunctionStack is a chain of functor that can be folded to a single functor (which is usually optimize by the compiler) |
| Chas_ostream_operator | SFINAE magic helper for wrap_unprintable() |
| Cdeclval< std::ostream & >()<< std::declval< Type const & >(), void())> | |
| Cindex_sequence | |
| Cis_std_array | Test if is std::array<T, N> |
| Cis_std_array< std::array< T, N > > | |
| Cis_std_pair | Test if is a std::pair<...> |
| Cis_std_pair< std::pair< S, T > > | |
| Cis_std_tuple | Test if is a std::tuple<...> |
| Cis_std_tuple< std::tuple< Ts... > > | |
| Cis_std_vector | Test if is std::vector<T> |
| Cis_std_vector< std::vector< T > > | |
| Cless_icase_asc | Case-insensitive less order relation functional class for std::map, etc |
| Cless_icase_desc | |
| CLevenshteinStandardICaseParameters | Standard parameters to Levenshtein distance function |
| CLevenshteinStandardParameters | Standard parameters to levenshtein distance function |
| CLog2 | |
| CLog2< 0 > | |
| CLog2< 1 > | |
| CLog2Floor | |
| CLog2Floor< 0 > | |
| CLog2Floor< 1 > | |
| CLogger | LOG and sLOG for development and debugging |
| CLoggerCollectOutput | Class to hook logger output in the local thread |
| CLoggerFormatter | Template class for formatting. contains a print() method |
| CLoggerFormatter< AnyType > | |
| CLoggerFormatter< std::array< T, N > > | |
| CLoggerFormatter< std::deque< T, A > > | |
| CLoggerFormatter< std::map< K, V, C, A > > | |
| CLoggerFormatter< std::multimap< K, V, C, A > > | |
| CLoggerFormatter< std::multiset< T, C, A > > | |
| CLoggerFormatter< std::pair< A, B > > | |
| CLoggerFormatter< std::set< T, C, A > > | |
| CLoggerFormatter< std::tuple< Args... > > | |
| CLoggerFormatter< std::tuple<> > | |
| CLoggerFormatter< std::unordered_map< K, V, H, E, A > > | |
| CLoggerFormatter< std::unordered_multimap< K, V, H, E, A > > | |
| CLoggerFormatter< std::unordered_multiset< T, H, E, A > > | |
| CLoggerFormatter< std::unordered_set< T, H, E, A > > | |
| CLoggerFormatter< std::vector< T, A > > | |
| CLoggerOutputHook | Abstract class to implement output hooks for logging |
| CLoggerPrefixHook | Abstract class to implement prefix output hooks for logging |
| CLoggerTupleFormatter | |
| CLoggerVoidify | |
| CLoserTreeCopy | Guarded loser tree/tournament tree, either copying the whole element into the tree structure, or looking up the element via the index |
| CLoserTreeCopy< true, ValueType, Comparator > | Guarded loser tree/tournament tree, either copying the whole element into the tree structure, or looking up the element via the index |
| ►CLoserTreeCopyBase | Guarded loser tree/tournament tree, either copying the whole element into the tree structure, or looking up the element via the index |
| CLoser | Internal representation of a loser tree player/node |
| CLoserTreeCopyUnguarded | |
| CLoserTreeCopyUnguarded< true, ValueType, Comparator > | |
| ►CLoserTreeCopyUnguardedBase | Unguarded loser tree, copying the whole element into the tree structure |
| CLoser | Internal representation of a loser tree player/node |
| CLoserTreePointer | Guarded loser tree, using pointers to the elements instead of copying them into the tree nodes |
| CLoserTreePointer< true, ValueType, Comparator > | Guarded loser tree, using pointers to the elements instead of copying them into the tree nodes |
| ►CLoserTreePointerBase | Guarded loser tree, using pointers to the elements instead of copying them into the tree nodes |
| CLoser | Internal representation of a loser tree player/node |
| CLoserTreePointerUnguarded | |
| CLoserTreePointerUnguarded< true, ValueType, Comparator > | |
| ►CLoserTreePointerUnguardedBase | Unguarded loser tree, keeping only pointers to the elements in the tree structure |
| CLoser | Internal representation of a loser tree player/node |
| CLoserTreeSwitch | |
| CLruCacheMap | This is an expected O(1) LRU cache which contains a map of (key -> value) elements |
| CLruCacheSet | This is an expected O(1) LRU cache which contains a set of key-only elements |
| Cmake_index_sequence | |
| CMD5 | MD-5 processor without external dependencies |
| CMultiTimer | MultiTimer can be used to measure time usage of different phases in a program or algorithm |
| CNoOperation | |
| CNoOperation< void > | Specialized noop functor which returns a void |
| ►CPolynomialRegression | Calculate the regression polynomial \( a_0+a_1x^1+a_2x^2+\cdots+a_nx^n \) from a list of 2D points |
| CCoefficients | |
| CPoint | 2D point |
| CRadixHeap | This class implements a monotonic integer min priority queue, more specific a multi-level radix heap |
| CReferenceCounter | Provides reference counting abilities for use with CountingPtr |
| CRingBuffer | A ring (circular) buffer of static (non-growing) size |
| CScopedMultiTimer | |
| CScopedMultiTimerSwitch | |
| CSemaphore | A simple semaphore implementation using C++11 synchronization methods |
| CSHA1 | SHA-1 processor without external dependencies |
| CSHA256 | SHA-256 processor without external dependencies |
| CSHA512 | SHA-512 processor without external dependencies |
| CSimpleVector | Simpler non-growing vector without initialization |
| CSpacingLogger | A logging class which outputs spaces between elements pushed via operator<< |
| ►CSplayTree | |
| CNode | Splay tree node, also seen as public iterator |
| ►CStackAllocator | |
| Crebind | Required rebind |
| ►CStackArena | Storage area allocated on the stack and usable by a StackAllocator |
| CAlignmentHelper | Union to enforce alignment of buffer area |
| CStaticIndex | |
| CStringView | StringView is a reference to a part of a string, consisting of only a char pointer and a length |
| CThreadBarrierMutex | Implements a thread barrier using mutex locking and condition variables that can be used to synchronize threads |
| CThreadBarrierSpin | Implements a thread barrier using atomics and a spin lock that can be used to synchronize threads |
| CThreadPool | ThreadPool starts a fixed number p of std::threads which process Jobs that are enqueued into a concurrent job queue |
1.8.13