Method program

source/devices/memory/BlockDeviceToMemoryTechnologyDevice.cpp:151–195

}

int BlockDeviceToMemoryTechnologyDevice::program(const uint64_t address, const void* const buffer, const size_t size)
{
	const std::lock_guard<BlockDeviceToMemoryTechnologyDevice> lockGuard {*this};

	assert(openCount_ != 0);
	assert(buffer != nullptr);

	const auto blockSize = blockDevice_.getBlockSize();
	assert(address % blockSize == 0 && size % blockSize == 0);
	assert(address + size <= blockDevice_.getSize());

	if (size == 0)
		return {};

	if (pendingEraseSize_ != 0 && address > pendingEraseAddress_ &&
			address + size < pendingEraseAddress_ + pendingEraseSize_)
	{
		// Data should be written in the middle of the pending erase range, so the erase range would have to be split in
		// two separate parts, which is not possible. Flush part of the pending erase which is below the written data,
		// based on assumption that the part above is more likely to be written soon.

		const auto eraseSize = address - pendingEraseAddress_;
		const auto ret = blockDevice_.erase(pendingEraseAddress_, eraseSize);
		if (ret != 0)
			return ret;

		pendingEraseAddress_ += eraseSize;
		pendingEraseSize_ -= eraseSize;
	}

	const auto ret = blockDevice_.write(address, buffer, size);
	if (ret != 0)
		return ret;

	const auto overlapBegin = std::max(address, pendingEraseAddress_);
	const auto overlapEnd = std::min(address + size, pendingEraseAddress_ + pendingEraseSize_);
	if (overlapBegin < overlapEnd)
	{
		if (pendingEraseAddress_ == overlapBegin)
			pendingEraseAddress_ = overlapEnd;
		pendingEraseSize_ -= overlapEnd - overlapBegin;
	}

	return {};
}

int BlockDeviceToMemoryTechnologyDevice::read(const uint64_t address, void* const buffer, const size_t size)
{