| Caddressable_fifo_queue< swappable_block_identifier_type > | |
| Caddressable_priority_queue< swappable_block_identifier_type, foxxll::block_scheduler_algorithm_offline_lfd::priority > | |
| ►CAllocatorBase< Byte > | |
| CAlignedAllocator< Byte, thrill::mem::Allocator< char > > | |
| ►CAllocatorBase< char > | |
| CAllocator< char > | |
| ►CAllocatorBase< T > | |
| CAllocator< T > | |
| CBID< raw_size > | |
| CBinaryHeap< Timer > | |
| CBitArray< num_buckets > | |
| CBTree< key_type, value_type, key_of_value, key_compare, traits, false, allocator_type > | |
| CBTree< key_type, value_type, key_of_value, key_compare, traits, true, allocator_type > | |
| CBucketComputation< Radix, ranked_key_type > | |
| Cbuffered_writer< block_type > | |
| CCentroidAccumulated< Vector< D, double > > | |
| ►CInputArchive | |
| CThrillInputArchive< Reader > | An input archive designed to load data saved using ThrillOutputArchive |
| ►COutputArchive | |
| CThrillOutputArchive< Writer > | An output archive designed to save data in a compact binary representation |
| CConcurrentBoundedQueue< thrill::data::Block > | |
| CConcurrentBoundedQueue< thrill::data::MixBlockQueue::SrcBlockPair > | |
| CConcurrentBoundedQueue< thrill::net::mock::Connection *> | |
| CConcurrentQueue< tlx::Delegate, thrill::mem::FixedPoolAllocator< tlx::Delegate > > | |
| CCountingPtr< ActionNode > | |
| CCountingPtr< ActionResultNode< ValueType > > | |
| CCountingPtr< base_file_type > | |
| CCountingPtr< CatStream > | |
| CCountingPtr< CatStreamData > | |
| CCountingPtr< DIABase > | |
| CCountingPtr< DIANode< StackInput > > | |
| CCountingPtr< file > | |
| CCountingPtr< File > | |
| CCountingPtr< MixStream > | |
| CCountingPtr< MixStreamData > | |
| CCountingPtr< ReadStream > | |
| CCountingPtr< request > | |
| CCountingPtr< StreamData > | |
| CCountingPtr< thrill::data::DynBlockSourceInterface > | |
| CCountingPtr< thrill::data::File > | |
| CCountingPtr< WriteStream > | |
| CDelegate< bool(), mem::GPoolAllocator< char > > | |
| CDelegate< void(BlockQueue &)> | |
| CDelegate< void(Connection &), mem::GPoolAllocator< char > > | |
| CDelegate< void(Connection &c, Buffer &&buffer), mem::GPoolAllocator< char > > | |
| CDelegate< void(Connection &c, data::PinnedByteBlockPtr &&bytes), mem::GPoolAllocator< char > > | |
| CDelegate< void(const ValueType &)> | |
| CDelegate< void(MPI_Status &), mem::GPoolAllocator< char > > | |
| CDelegate< void(request *r, bool success)> | |
| CDelegate< void(size_t)> | |
| CDIA< BfsNode > | |
| ►Celement_block< Type, Size > | |
| ►Cblock_w_bids< Type,((RawSize - sizeof(BID< RawSize >) *NBids - sizeof(MetaInfoType))/sizeof(Type)), RawSize, NBids > | |
| ►Cblock_w_info< Type, RawSize, NRef, MetaInfoType > | |
| ►Cadd_filler< mng_local::block_w_info< Type, RawSize, NRef, MetaInfoType >, RawSize - sizeof(mng_local::block_w_info< Type, RawSize, NRef, MetaInfoType >)> | |
| ►Cexpand_struct< mng_local::block_w_info< Type, RawSize, NRef, MetaInfoType >, RawSize > | |
| Ctyped_block< RawSize, Type, NRef, MetaInfoType > | |
| Cblock_w_info< Type, RawSize, NBids, MetaInfoType > | Contains per block information for foxxll::typed_block , not intended for direct use |
| ►Cblock_w_bids< Type,((RawSize - sizeof(BID< RawSize >) *NBids)/sizeof(Type)), RawSize, NBids > | |
| Cblock_w_info< Type, RawSize, NBids, void > | |
| Cblock_w_bids< Type, Size, RawSize, NBids > | Contains BID references for foxxll::typed_block , not intended for direct use |
| Cblock_w_bids< Type, Size, RawSize, 0 > | |
| CBfsNode | |
| CNodeParentPair | |
| CTreeInfo | |
| CCentroidAccumulated< Point > | A point which contains "count" accumulated vectors |
| CClosestCentroid< Point > | Assignment of a point to a cluster, which is the input to |
| CKMeansModel< Point > | Model returned by KMeans algorithm containing results |
| CPagePageLink | A pair (page source, page target) |
| CPageRankPair | A pair (page, rank) |
| CZipfGraphGen | |
| CDataPoint< Vector > | Model for one point consisting of a d-dimensional position and a label |
| CGradientResult< Vector > | |
| CLeastSquaresGradient< Vector > | |
| CStochasticGradientDescent< Vector > | |
| CSumResult< Vector > | |
| CIndexChar< Char, Index > | |
| CIndexFlag< Index > | |
| CIndexRank< Index > | A pair (index, rank) |
| CIndexRankFlag< Index > | |
| CHashWordHasher | |
| Cfiller_struct< FillSize > | |
| Caddressable_fifo_queue< KeyType > | |
| Caddressable_priority_queue< KeyType, PriorityType, Cmp > | |
| Caddressable_priority_queue< KeyType, PriorityType, Cmp >::cmp | |
| Caligned_alloc_settings< MustBeInt > | |
| Cbasic_allocation_strategy | |
| CBID< Size > | |
| CBID< 0 > | Specialization of block identifier class (BID) for variable size block size |
| Cblock_prefetcher< BlockType, BidIteratorType > | |
| Cblock_scheduler< SwappableBlockType > | |
| Cblock_scheduler< SwappableBlockType >::prediction_sequence_element | |
| ►Cblock_scheduler_algorithm< SwappableBlockType > | Interface of a block scheduling algorithm |
| Cblock_scheduler_algorithm_offline_lfd< SwappableBlockType > | Block scheduling algorithm caching via the longest forward distance policy (offline) |
| Cblock_scheduler_algorithm_offline_lru_prefetching< SwappableBlockType > | |
| Cblock_scheduler_algorithm_online_lru< SwappableBlockType > | Block scheduling algorithm caching via the least recently used policy (online) |
| Cblock_scheduler_algorithm_simulation< SwappableBlockType > | Pseudo block scheduling algorithm only recording the request sequence |
| Cblock_scheduler_algorithm_offline_lfd< SwappableBlockType >::priority | |
| Cblock_scheduler_algorithm_offline_lru_prefetching< SwappableBlockType >::read_after_write | |
| Cblock_scheduler_algorithm_offline_lru_prefetching< SwappableBlockType >::scheduled_block_meta | |
| Cblock_scheduler_algorithm_offline_lru_prefetching< SwappableBlockType >::write_read_request | |
| Cbuf_istream< BlockType, BidIteratorType > | |
| Cbuf_istream_reverse< BlockType, BidIteratorType > | |
| Cbuf_ostream< BlockType, BidIteratorType > | |
| Cbuffered_writer< BlockType > | |
| Cbuffered_writer< BlockType >::batch_entry | |
| Cbuffered_writer< BlockType >::batch_entry_cmp | |
| CCASE< Tag, Type_, Next_ > | |
| Cdisk_block_allocator | This class manages allocation of blocks onto a single disk |
| Cdisk_config | |
| Cfake_timer | Class fake_timer is a drop-in replacement for timer, which does nothing |
| Cfile_stats | |
| Cfile_stats::scoped_read_timer | |
| Cfile_stats::scoped_read_write_timer | |
| Cfile_stats::scoped_write_timer | |
| Cfile_stats_data | |
| Cinterleaved_alloc_traits< scheme > | |
| 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_striping | |
| Cfirst_disk_only | |
| Cinterleaved_fully_random | |
| Cinterleaved_random_cyclic | |
| Cinterleaved_simple_random | |
| Celement_block< Type, kSize > | Contains data elements for foxxll::typed_block , not intended for direct use |
| Cfiller_struct< Bytes > | |
| Cfiller_struct< 0 > | |
| Cnew_alloc< Type > | |
| Cnew_alloc< Type >::rebind< Rebind > | |
| Cnew_alloc_rebind< Type, Rebind > | |
| Cnew_alloc_rebind< Type, Type > | |
| CNilCase | |
| Coffset_allocator< BaseAllocator > | |
| Conoff_switch | |
| Cprefetch_pool< BlockType > | Implements dynamically resizable prefetching pool |
| Cprefetch_pool< BlockType >::bid_hash | |
| Cread_write_pool< BlockType > | Implements dynamically resizable buffered writing and prefetched reading pool |
| ►Crequest_interface | |
| ►Crequest | Request object encapsulating basic properties like file and offset |
| ►Crequest_with_waiters | Request that is aware of threads waiting for it to complete |
| ►Crequest_with_state | Request with completion shared_state |
| Cserving_request | Request which serves an I/O by calling the synchronous routine of the file |
| ►Crequest_queue | Interface of a request_queue to which requests can be added and canceled |
| ►Crequest_queue_impl_worker | |
| Crequest_queue_impl_1q | |
| Crequest_queue_impl_qwqr | |
| 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 |
| Cset_switch_handler | |
| Cshared_state< ValueType > | |
| Csingle_disk | |
| Csingleton< InstanceType, destroy_on_exit > | |
| Cstats::scoped_wait_timer | |
| Cstats_data | |
| Cstats_data::summary< T > | |
| ►Cstriping | |
| Cfully_random | |
| ►Crandom_cyclic | |
| Crandom_cyclic_disk | |
| Crandom_cyclic_flash | |
| Csimple_random | |
| Cswappable_block< ValueType, BlockSize > | |
| CSWITCH< Tag, Case > | |
| CSWITCH< Tag, NilCase > | |
| Ctimer | Class timer is a simple stop watch timer |
| Cuint_pair< HighType > | Construct an 40-bit or 48-bit unsigned integer stored in five or six bytes |
| Cwrite_pool< BlockType > | Implements dynamically resizable buffered writing pool |
| Cwrite_pool< BlockType >::busy_entry | |
| CFunctionStack< BfsNode > | |
| CGradientResult< thrill::common::Vector > | |
| Chypergeometric_distribution<> | |
| ►CItemReaderToolsBase< BlockReader< BlockSource > > | |
| CBlockReader< BlockSource > | BlockReader takes Block objects from BlockSource and allows reading of a) serializable Items or b) arbitray data from the Block sequence |
| ►CItemReaderToolsBase< BlockReader< CatBlockSource > > | |
| CBlockReader< CatBlockSource > | |
| ►CItemReaderToolsBase< BufferReader > | |
| CBufferReader | BufferReader represents a BufferRef with an additional cursor with which the memory can be read incrementally |
| CItemReaderToolsBase< SparseListIterator< ForwardIt > > | |
| ►CItemWriterToolsBase< BlockWriter< BlockSink > > | |
| CBlockWriter< BlockSink > | BlockWriter contains a temporary Block object into which a) any serializable item can be stored or b) any arbitrary integral data can be appended |
| ►CItemWriterToolsBase< BufferBuilder > | |
| CBufferBuilder | BufferBuilder represents a dynamically growable area of memory, which can be modified by appending integral data types via Put() and other basic operations |
| ►CItemWriterToolsBase< FixedBufferBuilder< Capacity > > | |
| CFixedBufferBuilder< Capacity > | Represents a FIXED length area of memory, which can be modified by appending integral data types via Put() and other basic operations |
| CItemWriterToolsBase< VectorWriter > | |
| CLocationDetection< thrill::api::GroupByNode::HashCount > | |
| CLocationDetection< thrill::api::JoinNode::HashCount > | |
| CLruCacheSet< thrill::data::ByteBlock *, thrill::mem::FixedPoolAllocator< thrill::data::ByteBlock *> > | |
| ►Ctype | |
| Cmake_index_sequence< Size > | |
| ►CParameters | |
| CPS5Context< Parameters > | Parallel Super Scalar String Sample Sort Context |
| CReduceByHashPostPhase< TableItem, Key, ValueType, KeyExtractor, ReduceFunction, thrill::api::ReduceNode::Emitter, VolatileKey, ReduceConfig, thrill::core::ReduceByHash, KeyEqualFunction > | |
| CReduceByIndexPostPhase< TableItem, Key, ValueType, KeyExtractor, ReduceFunction, thrill::api::ReduceToIndexNode::Emitter, VolatileKey, ReduceConfig > | |
| CReducePostPhaseEmitter< TableItem, ValueType, thrill::api::ReduceNode::Emitter, VolatileKey > | |
| CReducePostPhaseEmitter< TableItem, ValueType, thrill::api::ReduceToIndexNode::Emitter, VolatileKey > | |
| ►CReducePrePhase< TableItem, Key, Value, KeyExtractor, ReduceFunction, VolatileKey, BlockWriter, ReduceConfig, IndexFunction, EqualToFunction, HashFunction, false > | |
| CReducePrePhase< TableItem, Key, Value, KeyExtractor, ReduceFunction, VolatileKey, BlockWriter, ReduceConfig, IndexFunction, EqualToFunction, HashFunction, true > | |
| CReducePrePhase< TableItem, Key, ValueType, KeyExtractor, ReduceFunction, VolatileKey, thrill::data::BlockWriter, ReduceConfig, thrill::core::ReduceByHash, KeyEqualFunction, KeyHashFunction, UseDuplicateDetection > | |
| CReducePrePhase< TableItem, Key, ValueType, KeyExtractor, ReduceFunction, VolatileKey, thrill::data::BlockWriter, ReduceConfig, thrill::core::ReduceByIndex< Key > > | |
| ►CReduceTable< TableItem, Key, Value, KeyExtractor, ReduceFunction, Emitter, VolatileKey, ReduceConfig, IndexFunction, KeyEqualFunction > | |
| CReduceBucketHashTable< TableItem, Key, Value, KeyExtractor, ReduceFunction, Emitter, VolatileKey, ReduceConfig, IndexFunction, KeyEqualFunction > | A data structure which takes an arbitrary value and extracts a key using a key extractor function from that value |
| ►CReduceTable< TableItem, Key, Value, KeyExtractor, ReduceFunction, Emitter, VolatileKey, ReduceConfig_, IndexFunction, KeyEqualFunction > | |
| CReduceOldProbingHashTable< TableItem, Key, Value, KeyExtractor, ReduceFunction, Emitter, VolatileKey, ReduceConfig_, IndexFunction, KeyEqualFunction > | A data structure which takes an arbitrary value and extracts a key using a key extractor function from that value |
| CReduceProbingHashTable< TableItem, Key, Value, KeyExtractor, ReduceFunction, Emitter, VolatileKey, ReduceConfig_, IndexFunction, KeyEqualFunction > | A data structure which takes an arbitrary value and extracts a key using a key extractor function from that value |
| CReduceTableSelect< ReduceConfig::table_impl_, HashCount, typename HashCount::HashType, HashCount, ExtractHash, std::plus< HashCount >, Emitter, false, ReduceConfig > | |
| CReduceTableSelect< ReduceConfig::table_impl_, TableItem, Key, Value, KeyExtractor, ReduceFunction, Emitter, VolatileKey, ReduceConfig, IndexFunction, KeyEqualFunction > | |
| CReduceTableSelect< ReduceConfig::table_impl_, TableItem, Key, Value, KeyExtractor, ReduceFunction, PhaseEmitter, VolatileKey, ReduceConfig, IndexFunction, KeyEqualFunction > | |
| CReduceTableSelect< ReduceConfig::table_impl_, TableItem, Key, ValueType, KeyExtractor, ReduceFunction, PhaseEmitter, VolatileKey, ReduceConfig, thrill::core::ReduceByHash, KeyEqualFunction > | |
| CReduceTableSelect< ReduceConfig::table_impl_, thrill::api::GroupByNode::HashCount, typename thrill::api::GroupByNode::HashCount ::HashType, thrill::api::GroupByNode::HashCount, ExtractHash, std::plus< thrill::api::GroupByNode::HashCount >, Emitter, false, ReduceConfig > | |
| CReduceTableSelect< ReduceConfig::table_impl_, thrill::api::JoinNode::HashCount, typename thrill::api::JoinNode::HashCount ::HashType, thrill::api::JoinNode::HashCount, ExtractHash, std::plus< thrill::api::JoinNode::HashCount >, Emitter, false, ReduceConfig > | |
| CReservoirSamplingFast< ValueType, decltype(rng_)> | |
| CReservoirSamplingGrow< SampleIndexPair > | |
| CRingBuffer< Input > | |
| Cshared_state< request_state > | |
| Cshared_state< thread_state > | |
| CSimpleVector< block_type::raw_size > | |
| CSimpleVector< DiffType > | |
| CSimpleVector< foxxll::disk_block_allocator *> | |
| CSimpleVector< std::thread > | |
| CSimpleVector< tlx::CountingPtr > | |
| CSimpleVector< tlx::LoserTreeCopyBase::Loser > | |
| CSimpleVector< tlx::LoserTreeCopyUnguardedBase::Loser > | |
| CSimpleVector< tlx::LoserTreePointerBase::Loser > | |
| CSimpleVector< tlx::LoserTreePointerUnguardedBase::Loser > | |
| CSimpleVector< tlx::SimpleVector< size_t > > | |
| CSimpleVector< tlx::SimpleVector< tlx::parallel_mergesort_detail::PMWMSPiece< DiffType > > > | |
| CSimpleVector< tlx::SimpleVector< uint16_t > > | |
| CSimpleVector< uint8_t > | |
| CSimpleVector< ValueType *> | |
| CSimpleVector< ValueType > | |
| ►Csingleton< block_manager > | |
| Cblock_manager | Block manager class |
| ►Csingleton< config > | |
| Cconfig | |
| ►Csingleton< disk_queues > | |
| Cdisk_queues | |
| ►Csingleton< stats > | |
| Cstats | |
| ►Catomic | |
| CAtomicMovable< bool > | |
| CAtomicMovable< size_t > | |
| CAtomicMovable< T > | This is a derivative of std::atomic which enables easier and less error-prone writing of move-only classes by implementing a move constructor |
| ►Cbinary_function | |
| 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 |
| Cmaximum< T > | |
| Cminimum< T > | |
| CVectorConcat< Type > | Compute the concatenation of two std::vector<T>s |
| ►Cexception | STL class |
| ►Cios_base::failure | STL class |
| Cio_error | |
| ►Cruntime_error | STL class |
| Cbad_ext_alloc | |
| Cbad_parameter | |
| Cresource_error | |
| Cunreachable | |
| ►CSystemException | An Exception which is thrown on system errors |
| CErrnoException | An Exception which is thrown on system errors and contains errno information |
| ►CException | A Exception is thrown by Connection on all errors instead of returning error codes |
| CException | A derived exception class which looks up MPI error strings |
| CDieException | Exception thrown by die_with_message() if |
| 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 |
| ►Cfalse_type | |
| CDelegate< R(A...), Allocator >::IsConstMemberPair< typename > | Template for const class::function selector |
| CDelegate< R(A...), Allocator >::IsMemberPair< typename > | Template for class::function selector |
| Cis_std_array< T > | Test if is std::array<T, N> |
| Cis_std_pair< T > | Test if is a std::pair<...> |
| Cis_std_tuple< T > | Test if is a std::tuple<...> |
| Cis_std_vector< T > | Test if is std::vector<T> |
| 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 |
| ►Ctrue_type | |
| CDelegate< R(A...), Allocator >::IsConstMemberPair< ConstMemberPair< C > > | Specialization for const class::function selector |
| CDelegate< R(A...), Allocator >::IsMemberPair< MemberPair< C > > | Specialization for class::function selector |
| Cis_std_array< std::array< T, N > > | |
| Cis_std_pair< std::pair< S, T > > | |
| Cis_std_tuple< std::tuple< Ts... > > | |
| Cis_std_vector< std::vector< T > > | |
| ►Cvector< T > | STL class |
| CStreamData::Writers | An extra class derived from std::vector<> for delivery of the BlockWriters of a Stream |
| CFileList | List of file info and additional overall info |
| CPolynomialRegression< Type, WithStore >::Coefficients | |
| ►CStringSetBase< GenericCharStringSet< CharType >, GenericCharStringSetTraits< CharType > > | |
| CGenericCharStringSet< CharType > | Class implementing StringSet concept for char* and unsigned char* strings |
| ►CStringSetBase< StdStringSet, StdStringSetTraits > | |
| CStdStringSet | Class implementing StringSet concept for arrays of std::string objects |
| ►CStringSetBase< StringSuffixSet, StringSuffixSetTraits > | |
| CStringSuffixSet | Class implementing StringSet concept for suffix sorting indexes of a std::string text object |
| ►CStringSetBase< UPtrStdStringSet, UPtrStdStringSetTraits > | |
| CUPtrStdStringSet | Class implementing StringSet concept for a std::vector containing std::string objects |
| CArrayTag | Tag structure for ZipWindow() |
| CBernoulliSampleNode< ValueType > | |
| CCollapseSwitch< ValueType, Stack > | 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< ValueType >::RegisterParent | |
| 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() |
| CDefaultSortAlgorithm | |
| CDefaultStableSortAlgorithm | |
| CDIA< ValueType_, Stack_ > | DIA is the interface between the user and the Thrill framework |
| CDIAMemUse | Description of the amount of RAM the internal data structures of a DIANode require |
| CDIANode< ValueType >::Child | |
| CDisjointTag | Tag structure for Window() and FlatWindow() |
| CDuplicateDetectionFlag< Value > | Tag structure for ReduceByKey() |
| CFuture< ValueType > | The return type class for all ActionFutures |
| CFuture< void > | Specialized template class for ActionFuture which return void |
| CGroupByIterator< ValueType, KeyExtractor, Comparator > | |
| CGroupByMultiwayMergeIterator< ValueType, KeyExtractor, Comparator > | |
| CGroupByNode< ValueType, KeyExtractor, GroupFunction, HashFunction, UseLocationDetection >::HashCount | |
| CGroupByNode< ValueType, KeyExtractor, GroupFunction, HashFunction, UseLocationDetection >::ValueComparator | |
| CGroupToIndexNode< ValueType, KeyExtractor, GroupFunction >::ValueComparator | |
| CHostContext | The HostContext contains all data structures shared among workers on the same host |
| CJoinNode< ValueType, FirstDIA, SecondDIA, KeyExtractor1, KeyExtractor2, JoinFunction, HashFunction, UseLocationDetection >::HashCount | Hash counter used by LocationDetection |
| CLocalStorageTag | Tag structure for Read() |
| CLocationDetectionFlag< Value > | Tag structure for GroupByKey(), and InnerJoin() |
| CMemoryConfig | |
| CMergeNode< ValueType, Comparator, kNumInputs >::Pivot | |
| CMergeNode< ValueType, Comparator, kNumInputs >::ReducePivots | |
| CMergeNode< ValueType, Comparator, kNumInputs >::RegisterParent | |
| CMergeNode< ValueType, Comparator, kNumInputs >::Stats | 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() |
| CPadTag | Tag structure for Zip() |
| CReadBinaryNode< ValueType >::FileInfo | Structure to store info on what to read from files |
| CReadBinaryNode< ValueType >::VfsFileBlockSource | |
| ►CReadLinesNode::InputLineIterator | |
| CReadLinesNode::InputLineIteratorCompressed | InputLineIterator gives you access to lines of a file |
| CReadLinesNode::InputLineIteratorUncompressed | InputLineIterator gives you access to lines of a file |
| CReduceNode< ValueType, KeyExtractor, ReduceFunction, ReduceConfig, KeyHashFunction, KeyEqualFunction, VolatileKey, UseDuplicateDetection >::Emitter | Emitter for PostPhase to push elements to next DIA object |
| CReduceToIndexNode< ValueType, KeyExtractor, ReduceFunction, ReduceConfig, VolatileKey, SkipPreReducePhase >::Emitter | Emitter for PostPhase to push elements to next DIA object |
| CSkipPreReducePhaseTag | Tag structure for ReduceToIndex() |
| CSortNode< ValueType, CompareFunction, SortAlgorithm, Stable >::MakeDefaultMultiwayMergeTree | Multiway merge tree creation depends on Stable flag |
| CSortNode< ValueType, CompareFunction, SortAlgorithm, Stable >::MakeStableMultiwayMergeTree | |
| CSortNode< ValueType, CompareFunction, SortAlgorithm, Stable >::TreeBuilder | |
| CUnionNode< ValueType >::RegisterParent | |
| CUnionNode< ValueType >::UnionChild | |
| CVolatileKeyFlag< Value > | Tag structure for ReduceByKey(), and ReduceToIndex() |
| CZipNode< ValueType, ZipFunction, Pad, UnequalCheck, NoRebalance, kNumInputs >::ReaderNext< Reader > | Access CatReaders for different different parents |
| CZipNode< ValueType, ZipFunction, Pad, UnequalCheck, NoRebalance, kNumInputs >::RegisterParent | Register Parent PreOp Hooks, instantiated and called for each Zip parent |
| CZipWindowNode< ValueType, ZipFunction_, Pad_, UnequalCheck, UseStdArray, kNumInputs_ >::RegisterParent | Register Parent PreOp Hooks, instantiated and called for each Zip parent |
| CZipWindowReader< ZipWindowNode, UseArray > | |
| 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 |
| Calias_cast_helper< To, From > | |
| CBinaryHeap< Type, Compare > | |
| CComponentSum< ArrayType, Operation > | Template for computing the component-wise sum of std::array or std::vector |
| CConcurrentBoundedQueue< T > | This is a queue, similar to std::queue and tbb::concurrent_bounded_queue, except that it uses mutexes for synchronization |
| CConcurrentQueue< T, Allocator > | This is a queue, similar to std::queue and tbb::concurrent_queue, except that it uses mutexes for synchronization |
| 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< ValueType > | |
| CHashDataSwitch< T > | Hashing helper that decides what is hashed |
| CHashDataSwitch< std::string > | |
| Chypergeometric_distribution< int_t, fp_t > | |
| CIdentity | Identity functor, very useful for default parameters |
| CItemReaderToolsBase< Reader > | CRTP class to enhance item/memory reader classes with Varint decoding and String decoding |
| CItemWriterToolsBase< Writer > | 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 |
| CJsonLine::ArrayTag | |
| CJsonLine::DictionaryTag | |
| CJsonLinePutSwitch< Type > | |
| CJsonLogger | JsonLogger is a receiver of JSON output objects for logging |
| CJsonVerbatim | A special class to output verbatim text |
| CMatrix< Type > | A simple m x n dense matrix for generating statistics |
| ►CProfileTask | |
| CBlockPool | Pool to allocate, keep, swap out/in, and free all ByteBlocks on the host |
| CManager | Initializes communication channels, manages communication channels and handles errors |
| CProfileTaskRegistration | |
| CProfileThread | |
| CProfileThread::Timer | Struct for timer callbacks |
| CRadixSort< Type, MaxDepth > | 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< Type, RNG > | Implementation of reservoir sampling using Vitter's Algorithm R |
| CReservoirSamplingFast< Type, RNG > | Fast exact implementation of reservoir sampling using skip values |
| CReservoirSamplingGrow< Type, RNG > | 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< Timer > | RIAA class for running the timer until destruction |
| CSampling< RNG > | |
| CSharedState< ValueType > | |
| CSingleton< Instance, destroy_on_exit > | |
| CStatsCounter< ValueType_, Active > | This class provides a statistical counter that can easily be deactivated using a boolean template switch |
| CStatsCounter< ValueType_, false > | |
| CStatsCounter< ValueType_, true > | |
| ►CStatsTimerBase< Active > | This class provides a statistical stop watch timer that can easily be deactivated using a boolean template switch |
| CStatsTimerBaseStopped< enable_stats > | |
| CStatsTimerBaseStopped< stats_enabled > | |
| CStatsTimerBaseStarted< Active > | |
| CStatsTimerBaseStopped< Active > | |
| CStatsTimerBase< false > | |
| CStatsTimerBase< true > | |
| CTabulationHashing< size, hash_t, prng_t > | Tabulation Hashing, see https://en.wikipedia.org/wiki/Tabulation_hashing |
| CTimedCounter | |
| CUIntPair< High_ > | Construct an 40-bit or 48-bit unsigned integer stored in five or six bytes |
| CVector< D, Type > | A compile-time fixed-length D-dimensional point with double precision |
| CVVector< Type > | 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: |
| ►CBitStreamReader< BlockReader > | |
| CGolombBitStreamReader< BlockReader > | |
| ►CBitStreamWriter< BlockWriter > | |
| CGolombBitStreamWriter< BlockWriter > | |
| CBufferedMultiwayMergeTree< ValueType, ReaderIterator, Comparator > | |
| ►CDefaultReduceConfig | Configuration class to define operational parameters of reduce hash tables and reduce phases |
| CDefaultReduceConfig | |
| CDefaultReduceToIndexConfig | |
| CDefaultReduceConfigSelect< table_impl > | DefaultReduceConfig with implementation type selection |
| CDeltaStreamReader< StreamReader, Type, offset_ > | |
| CDeltaStreamWriter< StreamWriter, Type, offset_ > | |
| CDuplicateDetection | Duplicate detection to identify all elements occuring only on one worker |
| CHyperLogLogRegisters< p > | |
| CLocationDetection< HashCount > | |
| CLocationDetection< HashCount >::ExtractHash | |
| CLocationDetection< HashCount >::GolombPairReader | |
| CMultiwayMergeTree< ValueType, ReaderIterator, Comparator, Stable > | |
| CReduceBucketHashTable< TableItem, Key, Value, KeyExtractor, ReduceFunction, Emitter, VolatileKey, ReduceConfig, IndexFunction, KeyEqualFunction >::BucketBlock | Block holding reduce key/value pairs |
| CReduceBucketHashTable< TableItem, Key, Value, KeyExtractor, ReduceFunction, Emitter, VolatileKey, ReduceConfig, IndexFunction, KeyEqualFunction >::BucketBlockPool | BucketBlockPool to stack allocated BucketBlocks |
| CReduceByHash< Key, HashFunction > | A reduce index function which returns a hash index and partition |
| CReduceByHash< Key, HashFunction >::Result | |
| CReduceByHashPostPhase< TableItem, Key, Value, KeyExtractor, ReduceFunction, Emitter, VolatileKey, ReduceConfig_, IndexFunction, KeyEqualFunction > | |
| CReduceByIndex< Key > | A reduce index function, which determines a bucket depending on the current index range [begin,end) |
| CReduceByIndex< Key >::Result | |
| CReduceByIndexPostPhase< TableItem, Key, Value, KeyExtractor, ReduceFunction, Emitter, VolatileKey, ReduceConfig_ > | |
| CReduceMakeTableItem< Value, TableItem, VolatileKey > | |
| CReduceMakeTableItem< Value, TableItem, false > | |
| CReduceMakeTableItem< Value, TableItem, true > | |
| CReducePostPhaseEmitter< TableItem, Value, Emitter, VolatileKey > | |
| CReducePrePhase< TableItem, Key, Value, KeyExtractor, ReduceFunction, VolatileKey, BlockWriter, ReduceConfig_, IndexFunction, KeyEqualFunction, HashFunction, UseDuplicateDetection > | |
| CReducePrePhase< TableItem, Key, Value, KeyExtractor, ReduceFunction, VolatileKey, BlockWriter, ReduceConfig_, IndexFunction, KeyEqualFunction, HashFunction, false > | |
| CReducePrePhaseEmitter< TableItem, VolatileKey, BlockWriter > | |
| CReduceTable< ValueType, Key, Value, KeyExtractor, ReduceFunction, Emitter, VolatileKey, ReduceConfig_, IndexFunction, KeyEqualFunction > | Common super-class for bucket and linear-probing hash/reduce tables |
| CReduceTableSelect< ImplSelect, ValueType, Key, Value, KeyExtractor, ReduceFunction, Emitter, VolatileKey, ReduceConfig, IndexFunction, KeyEqualFunction > | 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< HashCount > | Emitter for a ReduceTable, which emits all of its data into a vector of hash-counter-pairs |
| ►CBlock | Block combines a reference to a read-only ByteBlock and book-keeping information |
| CPinnedBlock | A pinned / pin-counted derivative of a Block |
| CBlockPoolMemoryHolder | RAII class for allocating memory from a BlockPool |
| ►CBlockSink | Pure virtual base class for all things that can receive Blocks from a BlockWriter |
| CBlockQueue | A BlockQueue is a thread-safe queue used to hand-over Block objects between threads |
| CBlockQueueSink | BlockSink which interfaces to a File |
| ►CBoundedBlockSink | Derivative BlockSink which counts and limits how many bytes it has delivered as ByteBlocks for writing |
| CWriteBinaryNode< ValueType >::SysFileSink | Implements BlockSink class writing to files with size limit |
| CDiscardSink | DiscardSink is an BlockSink that discards all Blocks delivered to it |
| CFile | A File is an ordered sequence of Block objects for storing items |
| CFileBlockSink | BlockSink which interfaces to a File |
| CStreamSink | StreamSink is an BlockSink that sends data via a network socket to the StreamData object on a different worker |
| CByteBlock::Deleter | Deleter for CountingPtr<ByteBlock> |
| CCacheBlockQueueSource | A BlockSource to read Blocks from a BlockQueue using a BlockReader, and at the same time CACHE all items received |
| CCatBlockSource< BlockSource > | CatBlockSource is a BlockSource which concatenates all Blocks available from a vector of BlockSources |
| CConsumeBlockQueueSource | A BlockSource to read Block from a BlockQueue using a BlockReader |
| CConsumeFileBlockSource | A BlockSource to read and simultaneously consume Blocks from a File |
| CTupleDeserializer< Archive, RevIndex, T, Args > | |
| CTupleDeserializer< Archive, 0, std::tuple<> > | |
| CTupleDeserializer< Archive, RevIndex, std::tuple< T, Args... > > | |
| CTupleSerialization< Archive, RevIndex, Args > | |
| CTupleSerialization< Archive, 0, Args... > | |
| CDynBlockSource | This is the actual BlockSource used to instantiate BlockReader |
| CKeepFileBlockSource | A BlockSource to read Blocks from a File |
| CMixBlockQueue | Implements reading an unordered sequence of items from multiple workers, which sends Blocks |
| CMixBlockQueue::SrcBlockPair | Pair of (source worker, Block) stored in the main mix queue |
| CMixBlockQueueReader | Reader to retrieve items in unordered sequence from a MixBlockQueue |
| CMultiplexer | Multiplexes virtual Connections on Dispatcher |
| ►CMultiplexerHeader | |
| CPartitionMultiplexerHeader | |
| CStreamMultiplexerHeader | Block header is sent before a sequence of blocks it indicates the number of elements and their boundaries |
| CSerialization< Archive, T, Enable > | |
| 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 > | |
| CAlignedAllocator< Type, BaseAllocator, Alignment >::rebind< U > | Return allocator for different type |
| CAlignedAllocatorSettings< MustBeInt > | |
| CAllocator< Type >::rebind< U > | Return allocator for different type |
| CAllocator< void > | |
| CAllocator< void >::rebind< U > | |
| CDeleter< T > | Std::default_deleter with Manager tracking |
| CFixedAllocator< Type, manager_ >::rebind< U > | Return allocator for different type |
| CFixedAllocator< void, manager_ > | |
| CFixedAllocator< void, manager_ >::rebind< U > | |
| CFixedPoolAllocator< Type, pool_ >::rebind< U > | Return allocator for different type |
| CGPoolDeleter< T > | 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< Type >::rebind< U > | Return allocator for different type |
| CAsyncReadBuffer | |
| CAsyncReadByteBlock | |
| CAsyncWriteBlock | |
| CAsyncWriteBuffer | |
| CBuffer | Simple buffer of characters without initialization or growing functionality |
| ►CBufferRef | BufferRef represents a reference to a memory area as pointer and valid length |
| CBufferReader | BufferReader represents a BufferRef with an additional cursor with which the memory can be read incrementally |
| ►CConnection | A Connection represents a link to another peer in a network group |
| CConnection | A virtual connection through the mock network: each Group has p Connections to its peers |
| CConnection | Virtual MPI connection class |
| CConnection | Connection is a rich point-to-point socket connection to another client (worker, master, or whatever) |
| ►CDispatcher | Dispatcher is a high level wrapper for asynchronous callback processing |
| CDispatcher | A virtual Dispatcher which waits for messages to arrive in the mock network |
| CDispatcher | |
| CSelectDispatcher | SelectDispatcher is a higher level wrapper for select() |
| CDispatcher::Timer | Struct for timer callbacks |
| CDispatcherThread | DispatcherThread contains a net::Dispatcher object and an associated thread that runs in the dispatching loop |
| CFlowControlChannel | Provides a blocking collection for communication |
| CFlowControlChannel::LocalData | |
| CFlowControlChannelManager | |
| ►CGroup | A network Group is a collection of enumerated communication links, which provides point-to-point communication and MPI-like collective primitives |
| CGroup | The central object of a mock network: the Group containing links to other mock Group forming the network |
| CGroup | A net group backed by virtual MPI connection |
| CGroup | Collection of NetConnections to workers, allows point-to-point client communication and simple collectives like MPI |
| CAsyncRequest | |
| CDispatcher::MpiAsync | 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 |
| CDispatcher::Watch | Callback vectors per peer |
| CSelect | Select is an object-oriented wrapper for select() |
| CSelectDispatcher::Watch | 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 |
| 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 |
| CSocketAddress::SockAddrUnion | |
| CTraffic | |
| CFileInfo | General information of vfs file |
| ►CSimpleGlobBase< SOCHAR > | Unix glob implementation |
| CCSimpleGlobTempl< SOCHAR > | Implementation of the SimpleGlob class |
| CSimpleGlobUtil | String manipulation functions |
| CTemporaryDirectory | A class which creates a temporary directory in the current directory and returns it via get() |
| CAggregate< Type_ > | 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< Type_ > | Calculate running aggregate statistics: feed it with values, and it will keep the minimum and the maximum values |
| ►CAllocatorBase< Type > | |
| CAlignedAllocator< Type, BaseAllocator, Alignment > | |
| CAllocator< Type > | |
| CFixedAllocator< Type, manager_ > | |
| CFixedPoolAllocator< Type, pool_ > | |
| CPoolAllocator< Type > | |
| CStackAllocator< Type, Size > | |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator > | Basic class implementing a B+ tree data structure in memory |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::const_iterator | |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::const_reverse_iterator | |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::iterator | |
| ►CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::node | |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::InnerNode | |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::LeafNode | |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::result_t | |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::reverse_iterator | |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::tree_stats | A small struct containing basic statistics about the B+ tree |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::value_compare | Function class to compare value_type objects. Required by the STL |
| Cbtree_default_traits< Key, Value > | Generates default traits for a B+ tree used as a set or map |
| Cbtree_map< Key_, Data_, Compare_, Traits_, Alloc_ > | Specialized B+ tree template class implementing STL's map container |
| Cbtree_map< Key_, Data_, Compare_, Traits_, Alloc_ >::key_of_value | Key Extractor Struct |
| Cbtree_multimap< Key_, Data_, Compare_, Traits_, Alloc_ > | Specialized B+ tree template class implementing STL's multimap container |
| Cbtree_multimap< Key_, Data_, Compare_, Traits_, Alloc_ >::key_of_value | Key Extractor Struct |
| Cbtree_multiset< Key_, Compare_, Traits_, Alloc_ > | Specialized B+ tree template class implementing STL's multiset container |
| Cbtree_multiset< Key_, Compare_, Traits_, Alloc_ >::key_of_value | Key Extractor Struct |
| Cbtree_set< Key_, Compare_, Traits_, Alloc_ > | Specialized B+ tree template class implementing STL's set container |
| Cbtree_set< Key_, Compare_, Traits_, Alloc_ >::key_of_value | Key Extractor Struct |
| CCmdlineParser | Command line parser which automatically fills variables and prints nice usage messages |
| ►CCountingPtr< Type, Deleter > | High-performance smart pointer used as a wrapping reference counting pointer |
| ►CByteBlockPtr | A non-pinned counting pointer to a ByteBlock |
| CPinnedByteBlockPtr | A pinned / pin-counted pointer to a ByteBlock |
| CCountingPtrDefaultDeleter | Default deleter for CountingPtr |
| CCountingPtrNoOperationDeleter | Dummy deleter for CountingPtr |
| CDAryAddressableIntHeap< KeyType, Arity, Compare > | This class implements an addressable integer priority queue, precisely a d-ary heap |
| CDAryHeap< KeyType, Arity, Compare > | This class implements a d-ary comparison-based heap usable as a priority queue |
| CDelegate< T, Allocator > | |
| CDelegate< R(A...), Allocator > | This is a faster replacement than std::function |
| Cenable_if< bool, T > | SFINAE enable_if – copy of std::enable_if<> with less extra cruft |
| Cenable_if< true, T > | |
| CFunctionChain< Functors > | A FunctionChain is a chain of functors that can be folded to a single functors |
| CFunctionStack< Input_, Functors > | 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< typename, typename > | SFINAE magic helper for wrap_unprintable() |
| Cdeclval< std::ostream & >()<< std::declval< Type const & >(), void())> | |
| Cindex_sequence< Indexes > | |
| 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< Input > | |
| CLog2< 0 > | |
| CLog2< 1 > | |
| CLog2Floor< Input > | |
| CLog2Floor< 0 > | |
| CLog2Floor< 1 > | |
| CLogger | LOG and sLOG for development and debugging |
| CLoggerFormatter< AnyType, Enable > | 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 |
| CLoggerCollectOutput | Class to hook logger output in the local thread |
| CLoggerPrefixHook | Abstract class to implement prefix output hooks for logging |
| CLoggerTupleFormatter | |
| CLoggerVoidify | |
| ►CLoserTreeCopyBase< ValueType, Comparator > | Guarded loser tree/tournament tree, either copying the whole element into the tree structure, or looking up the element via the index |
| CLoserTreeCopy< Stable, ValueType, Comparator > | 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< ValueType, Comparator >::Loser | Internal representation of a loser tree player/node |
| ►CLoserTreeCopyUnguardedBase< ValueType, Comparator > | Unguarded loser tree, copying the whole element into the tree structure |
| CLoserTreeCopyUnguarded< Stable, ValueType, Comparator > | |
| CLoserTreeCopyUnguarded< true, ValueType, Comparator > | |
| CLoserTreeCopyUnguardedBase< ValueType, Comparator >::Loser | Internal representation of a loser tree player/node |
| ►CLoserTreePointerBase< ValueType, Comparator > | Guarded loser tree, using pointers to the elements instead of copying them into the tree nodes |
| CLoserTreePointer< Stable, ValueType, Comparator > | 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< ValueType, Comparator >::Loser | Internal representation of a loser tree player/node |
| ►CLoserTreePointerUnguardedBase< ValueType, Comparator > | Unguarded loser tree, keeping only pointers to the elements in the tree structure |
| CLoserTreePointerUnguarded< Stable, ValueType, Comparator > | |
| CLoserTreePointerUnguarded< true, ValueType, Comparator > | |
| CLoserTreePointerUnguardedBase< ValueType, Comparator >::Loser | Internal representation of a loser tree player/node |
| CLoserTreeSwitch< Stable, ValueType, Comparator, Enable > | |
| CLruCacheMap< Key, Value, Alloc > | This is an expected O(1) LRU cache which contains a map of (key -> value) elements |
| CLruCacheSet< Key, Alloc > | This is an expected O(1) LRU cache which contains a set of key-only elements |
| CMD5 | MD-5 processor without external dependencies |
| CCallForRangeImpl< Index, Size, Functor > | Helper for call_for_range: general recursive case |
| CCallForRangeImpl< Index, 0, Functor > | Helper for call_for_range: base case |
| Cmake_index_sequence_helper< CurrentIndex, Indexes > | |
| Cmake_index_sequence_helper< 0, Indexes... > | |
| CVMapForRangeImpl< Index, Size, Functor > | Helper for vmap_for_range: general recursive case |
| CVMapForRangeImpl< Index, 0, Functor > | Helper for vmap_for_range: base case |
| Clexicographic< T1, T2, Comparator > | Compare a pair of types lexicographically, ascending |
| Clexicographic_rev< T1, T2, Comparator > | Compare a pair of types lexicographically, descending |
| Clexicographic< T1, T2, Comparator > | Compare a pair of types lexicographically, ascending |
| Clexicographic_rev< T1, T2, Comparator > | Compare a pair of types lexicographically, descending |
| CMultiTimer | MultiTimer can be used to measure time usage of different phases in a program or algorithm |
| Cguarded_iterator< RandomAccessIterator, Comparator > | Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons |
| Cunguarded_iterator< RandomAccessIterator, Comparator > | |
| CNoOperation< ReturnType > | |
| CNoOperation< void > | Specialized noop functor which returns a void |
| CPMWMSPiece< DiffType > | Subsequence description |
| CPMWMSSortingData< RandomAccessIterator > | Data accessed by all threads |
| CPolynomialRegression< Type, WithStore > | Calculate the regression polynomial \( a_0+a_1x^1+a_2x^2+\cdots+a_nx^n \) from a list of 2D points |
| CPolynomialRegression< Type, WithStore >::Point | 2D point |
| CBitArray< Size > | A BitArray of fixed size supporting reading, setting, and clearing of individual bits |
| CBitArrayRecursive< Size, SizeIsAtmost64 > | |
| CBitArrayRecursive< Size, false > | |
| CBitArrayRecursive< Size, true > | |
| CBucketComputation< Radix, Int > | |
| CIntegerRank< Int > | Compute the rank of an integer x (i.e |
| CPairKeyExtract< KeyType, DataType > | Used as an adapter to implement RadixHeapPair on top of RadixHeap |
| CRadixHeap< ValueType, KeyExtract, KeyType, Radix > | 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 |
| ►Cfile | |
| ►Cdisk_queued_file | Implementation of some file methods based on serving_request |
| Cfileperblock_file< base_file_type > | |
| Cmemory_file | Implementation of file based on new[] and memcpy |
| Csyscall_file | Implementation of file based on UNIX syscalls |
| ►Cufs_file_base | Base for UNIX file system implementations |
| Csyscall_file | Implementation of file based on UNIX syscalls |
| Crequest | Request object encapsulating basic properties like file and offset |
| ►CDIABase | The DIABase is the untyped super class of DIANode |
| CDIANode< StackInput > | |
| ►CDIANode< std::string > | |
| ►CSourceNode< std::string > | |
| CReadLinesNode | A DIANode which performs a line-based Read operation |
| ►CActionNode | |
| ►CActionResultNode< core::HyperLogLogRegisters< p > > | |
| CHyperLogLogNode< p, ValueType > | |
| ►CActionResultNode< size_t > | |
| CSizeNode< ValueType > | |
| ►CActionResultNode< std::vector< ValueType > > | |
| CAllGatherNode< ValueType > | |
| CGatherNode< ValueType > | |
| ►CActionResultNode< ValueType > | |
| CAllReduceNode< ValueType, ReduceFunction > | |
| CActionResultNode< ResultType > | |
| CWriteBinaryNode< ValueType > | |
| CWriteLinesNode< ValueType > | |
| CWriteLinesOneNode< ValueType > | |
| ►CDIANode< ValueType > | A DIANode is a typed node representing and operation in Thrill |
| CCacheNode< ValueType > | A DOpNode which caches all items in an external file |
| CCollapseNode< ValueType > | |
| ►CDOpNode< ValueType > | A DOpNode is a typed node representing and distributed operations in Thrill |
| ►CBaseWindowNode< ValueType, Input, WindowFunction, PartialWindowFunction > | |
| CDisjointWindowNode< ValueType, Input, WindowFunction, PartialWindowFunction > | |
| COverlapWindowNode< ValueType, Input, WindowFunction, PartialWindowFunction > | |
| CConcatNode< ValueType > | |
| CGroupByNode< ValueType, KeyExtractor, GroupFunction, HashFunction, UseLocationDetection > | |
| CGroupToIndexNode< ValueType, KeyExtractor, GroupFunction > | |
| CJoinNode< ValueType, FirstDIA, SecondDIA, KeyExtractor1, KeyExtractor2, JoinFunction, HashFunction, UseLocationDetection > | Performs an inner join between two DIAs |
| CMergeNode< ValueType, Comparator, kNumInputs > | Implementation of Thrill's merge |
| CPrefixSumNode< ValueType, SumFunction, Inclusive > | |
| CRebalanceNode< ValueType > | |
| CReduceNode< ValueType, KeyExtractor, ReduceFunction, ReduceConfig, KeyHashFunction, KeyEqualFunction, VolatileKey, UseDuplicateDetection > | A DIANode which performs a Reduce operation |
| CReduceToIndexNode< ValueType, KeyExtractor, ReduceFunction, ReduceConfig, VolatileKey, SkipPreReducePhase > | A DIANode which performs a ReduceToIndex operation |
| CSampleNode< ValueType > | A DIANode which performs sampling without replacement |
| CSortNode< ValueType, CompareFunction, SortAlgorithm, Stable > | A DIANode which performs a Sort operation |
| CZipNode< ValueType, ZipFunction, Pad, UnequalCheck, NoRebalance, kNumInputs > | A DIANode which performs a Zip operation |
| CZipWindowNode< ValueType, ZipFunction_, Pad_, UnequalCheck, UseStdArray, kNumInputs_ > | |
| CZipWithIndexNode< ValueType, ZipFunction > | A DIANode which calculates the array index for each items and performs a Zip-like operation without extra rebalancing of the DIA data |
| ►CSourceNode< ValueType > | |
| CConcatToDIANode< ValueType > | |
| CDistributeNode< ValueType > | |
| CEqualToDIANode< ValueType > | |
| CGenerateNode< ValueType, GenerateFunction > | A DIANode which performs a Generate operation |
| CReadBinaryNode< ValueType > | A DIANode which performs a line-based Read operation |
| CUnionNode< ValueType > | Implements a Union operation by hooking any number of input DIANodes and forwarding the output immediately to all children |
| CByteBlock | A ByteBlock is the basic storage units of containers like File, BlockQueue, etc |
| ►CDynBlockSourceInterface | This is a pure virtual base which will be used to fetch Blocks for the BlockReader from different sources |
| CDynBlockSourceAdapter< BlockSource > | Adapter class to wrap any existing BlockSource concept class into a DynBlockSourceInterface |
| CFile | A File is an ordered sequence of Block objects for storing items |
| CPinRequest | |
| ►CStream | Stream - base class for CatStream and MixStream |
| CCatStream | Ownership handle onto a CatStreamData |
| CMixStream | Ownership handle onto a MixStream |
| ►CStreamData | Base class for common structures for ConcatStream and MixedStream |
| CCatStreamData | A Stream is a virtual set of connections to all other worker instances, hence a "Stream" bundles them to a logical communication context |
| CMixStreamData | A Stream is a virtual set of connections to all other worker instances, hence a "Stream" bundles them to a logical communication context |
| ►CStreamSetBase | Base class for StreamSet |
| CStreamSet< StreamData > | Simple structure that holds a all stream instances for the workers on the local host for a given stream id |
| CReadStream | Reader object from any source |
| CWriteStream | Writer object to output data to any supported URI |
| CRingBuffer< Type, Allocator > | 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< ValueType, Mode > | Simpler non-growing vector without initialization |
| ►CGenericCharStringSetTraits< CharType > | Traits class implementing StringSet concept for char* and unsigned char* strings |
| CGenericCharStringSet< CharType > | Class implementing StringSet concept for char* and unsigned char* strings |
| CPerfectTreeCalculations< TreeBits > | Class to transform in-order to level-order indexes in a perfect binary tree |
| CPS5ParametersDefault | Parallel Super Scalar String Sample Sort Parameter Struct |
| CPS5SmallsortJob< Context, StringPtr, BktSizeType >::MKQSStep | |
| CPS5SmallsortJob< Context, StringPtr, BktSizeType >::SeqSampleSortStep | Stack of Recursive Sample Sort Steps |
| ►CPS5SortStep | PS5SortStep Top-Level Class to Keep Track of Substeps |
| CPS5BigSortStep< Context, StringPtr > | PS5BigSortStep Out-of-Place Parallel Sample Sort with Separate Jobs |
| CPS5SmallsortJob< Context, StringPtr, BktSizeType > | SampleSort: Non-Recursive In-Place Sequential Sample Sort for Small Sorts |
| CRadixStep_CE0< StringShadowPtr > | |
| CRadixStep_CE2< StringShadowPtr > | |
| CRadixStep_CE3< StringShadowPtr > | |
| CRadixStep_CI2< StringPtr > | |
| CRadixStep_CI3< StringPtr > | |
| CSSClassifyEqualUnroll< key_type, TreeBits > | Sample Sort Classification Tree Unrolled with Equal Comparisons |
| CSSClassifyTreeCalcUnrollInterleave< key_type, TreeBits, Rollout > | |
| CSSClassifyTreeUnrollInterleave< key_type, TreeBits, Rollout > | Sample Sort Classification Tree Unrolled and Interleaved |
| CSSTreeBuilderLevelOrder< key_type, num_splitters > | |
| CSSTreeBuilderPreAndLevelOrder< key_type, num_splitters > | |
| ►CStdStringSetTraits | Class implementing StringSet concept for a std::string objects |
| CStdStringSet | Class implementing StringSet concept for arrays of std::string objects |
| CStringLcpPtr< StringSet_, LcpType_ > | Objectified string and LCP array pointer arrays |
| CStringPtr< StringSet_ > | Objectified string array pointer array |
| CStringSetBase< StringSet, Traits > | Base class for common string set functions, included via CRTP |
| CStringShadowLcpPtr< StringSet_, LcpType_ > | |
| CStringShadowPtr< StringSet_ > | |
| ►CStringSuffixSetTraits | Class implementing StringSet concept for suffix sorting indexes of a std::string text object |
| CStringSuffixSet | Class implementing StringSet concept for suffix sorting indexes of a std::string text object |
| ►CUPtrStdStringSetTraits | Class implementing StringSet concept for a std::unique_ptr<std::string objects, which are non-copyable |
| CUPtrStdStringSet | Class implementing StringSet concept for a std::vector containing std::string objects |
| CSpacingLogger | A logging class which outputs spaces between elements pushed via operator<< |
| CSplayTree< Key, Compare, Duplicates, Allocator > | |
| CSplayTree< Key, Compare, Duplicates, Allocator >::Node | Splay tree node, also seen as public iterator |
| CStackAllocator< Type, Size >::rebind< Other > | Required rebind |
| CStackArena< Size > | Storage area allocated on the stack and usable by a StackAllocator |
| CStackArena< Size >::AlignmentHelper | Union to enforce alignment of buffer area |
| CStaticIndex< Index > | |
| 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 |
| CToVectorEmitter< thrill::api::GroupByNode::HashCount > | |
| CToVectorEmitter< thrill::api::JoinNode::HashCount > | |
| CVector< D, double > | |
| ►CBaseType | |
| Cadd_filler< BaseType, FillSize > | Contains per block filler for foxxll::typed_block , not intended for direct use |
| Cadd_filler< BaseType, 0 > | |
| ►CType | |
| ►Cadd_filler< Type, RawSize - sizeof(Type)> | |
| Cexpand_struct< Type, RawSize > | Helper to compute the size of the filler , not intended for direct use |
1.8.13