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]);
}
