void sh_memusg(char* params){ int bytes = getBytesAllocated(); int avail = getAvailableMemory(); ttprint("Allocated "); ttprintInt(bytes); ttprint(" of "); ttprintInt(avail); ttprintln(" bytes"); }
VMAllocator::~VMAllocator() { // This assertion indicates that not all allocated pages were deallocated. // In relation to LER-5976: in debug builds, each allocation is divided // into 3 sections (two guard pages surrounding the actual allocation). // The mprotect calls in allocate(int *) can fail in low memory situations // (the kernel may allocate private memory as it tracks a single mmap // region being split in three). When this occurs, subsequent munmap calls // (even on different regions) in deallocate sometimes fail, leading to a // failure of this assertion. This should not occur in release builds, // since no guard pages are allocated or protected. NOTE: On Ubuntu Edgy // Eft (2.6.17-12-generic SMP), the munmap calls in deallocate fails three // times, then inexplicably begin succeeding. Retrying the failed calls // then succeeds. assert(!getBytesAllocated()); }
BlockInputStreams StorageSystemDictionaries::read( const Names & column_names, const ASTPtr & query, const Context & context, QueryProcessingStage::Enum & processed_stage, const size_t max_block_size, const unsigned) { check(column_names); processed_stage = QueryProcessingStage::FetchColumns; ColumnWithTypeAndName col_name{std::make_shared<ColumnString>(), std::make_shared<DataTypeString>(), "name"}; ColumnWithTypeAndName col_origin{std::make_shared<ColumnString>(), std::make_shared<DataTypeString>(), "origin"}; ColumnWithTypeAndName col_type{std::make_shared<ColumnString>(), std::make_shared<DataTypeString>(), "type"}; ColumnWithTypeAndName col_key{std::make_shared<ColumnString>(), std::make_shared<DataTypeString>(), "key"}; ColumnWithTypeAndName col_attribute_names{ std::make_shared<ColumnArray>(std::make_shared<ColumnString>()), std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>()), "attribute.names" }; ColumnWithTypeAndName col_attribute_types{ std::make_shared<ColumnArray>(std::make_shared<ColumnString>()), std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>()), "attribute.types" }; ColumnWithTypeAndName col_has_hierarchy{std::make_shared<ColumnUInt8>(), std::make_shared<DataTypeUInt8>(), "has_hierarchy"}; ColumnWithTypeAndName col_bytes_allocated{std::make_shared<ColumnUInt64>(), std::make_shared<DataTypeUInt64>(), "bytes_allocated"}; ColumnWithTypeAndName col_query_count{std::make_shared<ColumnUInt64>(), std::make_shared<DataTypeUInt64>(), "query_count"}; ColumnWithTypeAndName col_hit_rate{std::make_shared<ColumnFloat64>(), std::make_shared<DataTypeFloat64>(), "hit_rate"}; ColumnWithTypeAndName col_element_count{std::make_shared<ColumnUInt64>(), std::make_shared<DataTypeUInt64>(), "element_count"}; ColumnWithTypeAndName col_load_factor{std::make_shared<ColumnFloat64>(), std::make_shared<DataTypeFloat64>(), "load_factor"}; ColumnWithTypeAndName col_creation_time{std::make_shared<ColumnUInt32>(), std::make_shared<DataTypeDateTime>(), "creation_time"}; ColumnWithTypeAndName col_last_exception{std::make_shared<ColumnString>(), std::make_shared<DataTypeString>(), "last_exception"}; ColumnWithTypeAndName col_source{std::make_shared<ColumnString>(), std::make_shared<DataTypeString>(), "source"}; const auto & external_dictionaries = context.getExternalDictionaries(); const std::lock_guard<std::mutex> lock{external_dictionaries.dictionaries_mutex}; for (const auto & dict_info : external_dictionaries.dictionaries) { col_name.column->insert(dict_info.first); col_origin.column->insert(dict_info.second.origin); if (dict_info.second.dict) { const auto dict_ptr = dict_info.second.dict->get(); col_type.column->insert(dict_ptr->getTypeName()); const auto & dict_struct = dict_ptr->getStructure(); col_key.column->insert(dict_struct.getKeyDescription()); col_attribute_names.column->insert(ext::map<Array>(dict_struct.attributes, [] (auto & attr) -> decltype(auto) { return attr.name; })); col_attribute_types.column->insert(ext::map<Array>(dict_struct.attributes, [] (auto & attr) -> decltype(auto) { return attr.type->getName(); })); col_bytes_allocated.column->insert(dict_ptr->getBytesAllocated()); col_query_count.column->insert(dict_ptr->getQueryCount()); col_hit_rate.column->insert(dict_ptr->getHitRate()); col_element_count.column->insert(dict_ptr->getElementCount()); col_load_factor.column->insert(dict_ptr->getLoadFactor()); col_creation_time.column->insert(std::chrono::system_clock::to_time_t(dict_ptr->getCreationTime())); col_source.column->insert(dict_ptr->getSource()->toString()); } else { col_type.column->insertDefault(); col_key.column->insertDefault(); col_attribute_names.column->insertDefault(); col_attribute_types.column->insertDefault(); col_bytes_allocated.column->insertDefault(); col_query_count.column->insertDefault(); col_hit_rate.column->insertDefault(); col_element_count.column->insertDefault(); col_load_factor.column->insertDefault(); col_creation_time.column->insertDefault(); col_source.column->insertDefault(); } if (dict_info.second.exception) { try { std::rethrow_exception(dict_info.second.exception); } catch (...) { col_last_exception.column->insert(getCurrentExceptionMessage(false)); } } else col_last_exception.column->insertDefault(); } Block block{ col_name, col_origin, col_type, col_key, col_attribute_names, col_attribute_types, col_bytes_allocated, col_query_count, col_hit_rate, col_element_count, col_load_factor, col_creation_time, col_last_exception, col_source }; return BlockInputStreams{1, std::make_shared<OneBlockInputStream>(block)}; }