ErrorStack LogReducer::dump_buffer_sort_storage_write( const LogBuffer &buffer, storage::StorageId storage_id, const BufferPosition* sorted_logs, uint32_t shortest_key_length, uint32_t longest_key_length, uint32_t log_count, fs::DirectIoFile *dump_file) { debugging::StopWatch write_watch; char* io_buffer = reinterpret_cast<char*>(dump_io_buffer_.get_block()); // we flush the IO buffer when we wrote out this number of bytes. // to keep it aligned, the bytes after this threshold have to be retained and copied over to // the beginning of the buffer. const uint64_t flush_threshold = dump_io_buffer_.get_size() - (1 << 16); uint64_t total_bytes = dump_block_header( buffer, storage_id, sorted_logs, shortest_key_length, longest_key_length, log_count, io_buffer); uint64_t total_written = 0; uint64_t current_pos = sizeof(FullBlockHeader); for (uint32_t i = 0; i < log_count; ++i) { const log::RecordLogType* record = buffer.resolve(sorted_logs[i]); ASSERT_ND(current_pos % 8 == 0); ASSERT_ND(record->header_.storage_id_ == storage_id); ASSERT_ND(record->header_.log_length_ > 0); ASSERT_ND(record->header_.log_length_ % 8 == 0); std::memcpy(io_buffer + current_pos, record, record->header_.log_length_); current_pos += record->header_.log_length_; if (current_pos >= flush_threshold) { WRAP_ERROR_CODE(dump_file->write(flush_threshold, dump_io_buffer_)); // move the fragment to beginning if (current_pos > flush_threshold) { std::memcpy(io_buffer, io_buffer + flush_threshold, current_pos - flush_threshold); } current_pos -= flush_threshold; total_written += flush_threshold; } } ASSERT_ND(total_bytes == total_written + current_pos); // now we went over all logs again if (current_pos > 0) { ASSERT_ND(current_pos < flush_threshold); // for aligned write, add a dummy storage block at the end. if (current_pos % (log::FillerLogType::kLogWriteUnitSize) != 0) { uint64_t upto = assorted::align<uint64_t, log::FillerLogType::kLogWriteUnitSize>(current_pos); ASSERT_ND(upto > current_pos); ASSERT_ND(upto < current_pos + log::FillerLogType::kLogWriteUnitSize); ASSERT_ND(upto % log::FillerLogType::kLogWriteUnitSize == 0); FillerBlockHeader* filler = reinterpret_cast<FillerBlockHeader*>(io_buffer + current_pos); filler->block_length_ = to_buffer_position(upto - current_pos); ASSERT_ND(filler->block_length_ < to_buffer_position(log::FillerLogType::kLogWriteUnitSize)); filler->magic_word_ = BlockHeaderBase::kFillerBlockHeaderMagicWord; if (upto - current_pos > sizeof(FillerBlockHeader)) { // fill it with zeros. not mandatory, but wouldn't hurt. it's just 4kb. std::memset( io_buffer + current_pos + sizeof(FillerBlockHeader), 0, upto - current_pos - sizeof(FillerBlockHeader)); } current_pos = upto; } ASSERT_ND(current_pos % log::FillerLogType::kLogWriteUnitSize == 0); WRAP_ERROR_CODE(dump_file->write(current_pos, dump_io_buffer_)); total_written += current_pos; } ASSERT_ND(total_written % log::FillerLogType::kLogWriteUnitSize == 0); write_watch.stop(); LOG(INFO) << to_string() << " Wrote out storage-" << storage_id << " which had " << log_count << " log records (" << total_written << " bytes) in "<< write_watch.elapsed_ms() << "ms"; return kRetOk; }
static void d71_layer_dump(struct komeda_component *c, struct seq_file *sf) { u32 v[15], i; bool rich, rgb2rgb; char *prefix; get_values_from_reg(c->reg, LAYER_INFO, 1, &v[14]); if (v[14] & 0x1) { rich = true; prefix = "LR_"; } else { rich = false; prefix = "LS_"; } rgb2rgb = !!(v[14] & L_INFO_CM); dump_block_header(sf, c->reg); seq_printf(sf, "%sLAYER_INFO:\t\t0x%X\n", prefix, v[14]); get_values_from_reg(c->reg, 0xD0, 1, v); seq_printf(sf, "%sCONTROL:\t\t0x%X\n", prefix, v[0]); if (rich) { get_values_from_reg(c->reg, 0xD4, 1, v); seq_printf(sf, "LR_RICH_CONTROL:\t0x%X\n", v[0]); } get_values_from_reg(c->reg, 0xD8, 4, v); seq_printf(sf, "%sFORMAT:\t\t0x%X\n", prefix, v[0]); seq_printf(sf, "%sIT_COEFFTAB:\t\t0x%X\n", prefix, v[1]); seq_printf(sf, "%sIN_SIZE:\t\t0x%X\n", prefix, v[2]); seq_printf(sf, "%sPALPHA:\t\t0x%X\n", prefix, v[3]); get_values_from_reg(c->reg, 0x100, 3, v); seq_printf(sf, "%sP0_PTR_LOW:\t\t0x%X\n", prefix, v[0]); seq_printf(sf, "%sP0_PTR_HIGH:\t\t0x%X\n", prefix, v[1]); seq_printf(sf, "%sP0_STRIDE:\t\t0x%X\n", prefix, v[2]); get_values_from_reg(c->reg, 0x110, 2, v); seq_printf(sf, "%sP1_PTR_LOW:\t\t0x%X\n", prefix, v[0]); seq_printf(sf, "%sP1_PTR_HIGH:\t\t0x%X\n", prefix, v[1]); if (rich) { get_values_from_reg(c->reg, 0x118, 1, v); seq_printf(sf, "LR_P1_STRIDE:\t\t0x%X\n", v[0]); get_values_from_reg(c->reg, 0x120, 2, v); seq_printf(sf, "LR_P2_PTR_LOW:\t\t0x%X\n", v[0]); seq_printf(sf, "LR_P2_PTR_HIGH:\t\t0x%X\n", v[1]); get_values_from_reg(c->reg, 0x130, 12, v); for (i = 0; i < 12; i++) seq_printf(sf, "LR_YUV_RGB_COEFF%u:\t0x%X\n", i, v[i]); } if (rgb2rgb) { get_values_from_reg(c->reg, LAYER_RGB_RGB_COEFF0, 12, v); for (i = 0; i < 12; i++) seq_printf(sf, "LS_RGB_RGB_COEFF%u:\t0x%X\n", i, v[i]); } get_values_from_reg(c->reg, 0x160, 3, v); seq_printf(sf, "%sAD_CONTROL:\t\t0x%X\n", prefix, v[0]); seq_printf(sf, "%sAD_H_CROP:\t\t0x%X\n", prefix, v[1]); seq_printf(sf, "%sAD_V_CROP:\t\t0x%X\n", prefix, v[2]); }