imagedev/floppy: batch sequential flux writes

Some floppy controllers commit generated write flux in very small spans.
This is especially visible while formatting, where a controller can emit a
full track byte-by-byte and each byte-level commit previously edited the
persistent track vector immediately. That turns one logical sequential track
write into thousands of repeated track scans and insertions, making format
operations orders of magnitude slower than the emulated disk timing.

Keep the existing write path semantics by delaying only contiguous writes to
the same cylinder, side and subcylinder. The accumulated span is flushed
before any operation that can observe or depend on committed media state,
including cache fills, write-splice updates and image commit. Non-contiguous
writes or writes to another track also flush first, so existing callers that
issue isolated writes continue to take the same path with no behavioral
change beyond avoiding redundant intermediate vector edits.

The pending span stores the original start/end positions and concatenated
flux-change positions, then reuses the existing wspan_remove_damaged and
wspan_write helpers when flushed. This preserves the existing damaged-region
handling and track modification logic while making sequential write streams
behave like the single larger write they represent.

Author: RealDeuce

src/devices/imagedev/floppy.cpp

@@ -293,6 +293,12 @@ floppy_image_device::floppy_image_device(const machine_config &mconfig, device_t
 	m_amplifier_freakout_time(attotime::from_usec(16)),
 	m_image_dirty(false),
 	m_track_dirty(false),
+	m_pending_write(false),
+	m_pending_write_cyl(0),
+	m_pending_write_ss(0),
+	m_pending_write_subcyl(0),
+	m_pending_write_start(0),
+	m_pending_write_end(0),
 	m_ready_counter(0),
 	m_make_sound(false),
 	m_sound_out(*this, FLOPSND_TAG)
@@ -498,6 +504,7 @@ void floppy_image_device::setup_write(const floppy_image_format_t *_output_forma
 
 void floppy_image_device::commit_image()
 {
+	flush_pending_write();
 	m_image_dirty = false;
 	if(!m_output_format || !m_output_format->supports_save())
 		return;
@@ -649,6 +656,8 @@ std::pair<std::error_condition, const floppy_image_format_t *> floppy_image_devi
 void floppy_image_device::init_floppy_load(bool write_supported)
 {
 	cache_clear();
+	m_pending_write = false;
+	m_pending_write_flux_change_positions.clear();
 	m_revolution_start_time = m_mon ? attotime::never : machine().time();
 	m_revolution_count = 0;
 
@@ -1125,6 +1134,7 @@ void floppy_image_device::cache_clear()
 
 void floppy_image_device::cache_fill(const attotime &when)
 {
+	flush_pending_write();
 	std::vector<uint32_t> &buf = m_image->get_buffer(m_cyl, m_ss, m_subcyl);
 	uint32_t const cells = buf.size();
 	if(cells <= 1) {
@@ -1234,8 +1244,38 @@ void floppy_image_device::write_flux(const attotime &start, const attotime &end,
 
 	wspan_split_on_wrap(wspans);
 
-	std::vector<uint32_t> &buf = m_image->get_buffer(m_cyl, m_ss, m_subcyl);
+	for(const auto &ws : wspans) {
+		if(!m_pending_write || m_pending_write_cyl != m_cyl || m_pending_write_ss != m_ss || m_pending_write_subcyl != m_subcyl || m_pending_write_end != ws.start) {
+			flush_pending_write();
+			m_pending_write = true;
+			m_pending_write_cyl = m_cyl;
+			m_pending_write_ss = m_ss;
+			m_pending_write_subcyl = m_subcyl;
+			m_pending_write_start = ws.start;
+			m_pending_write_end = ws.start;
+			m_pending_write_flux_change_positions.clear();
+		}
+
+		m_pending_write_end = ws.end;
+		m_pending_write_flux_change_positions.insert(
+				m_pending_write_flux_change_positions.end(),
+				ws.flux_change_positions.begin(),
+				ws.flux_change_positions.end());
+	}
+}
+
+
+void floppy_image_device::flush_pending_write()
+{
+	if(!m_pending_write)
+		return;
+
+	std::vector<wspan> wspans(1);
+	wspans[0].start = m_pending_write_start;
+	wspans[0].end = m_pending_write_end;
+	wspans[0].flux_change_positions.swap(m_pending_write_flux_change_positions);
 
+	std::vector<uint32_t> &buf = m_image->get_buffer(m_pending_write_cyl, m_pending_write_ss, m_pending_write_subcyl);
 	if(buf.empty()) {
 		buf.push_back(floppy_image::MG_N);
 		buf.push_back(floppy_image::MG_E | 199999999);
@@ -1244,6 +1284,7 @@ void floppy_image_device::write_flux(const attotime &start, const attotime &end,
 	wspan_remove_damaged(wspans, buf);
 	wspan_write(wspans, buf);
 
+	m_pending_write = false;
 	cache_clear();
 }
 
@@ -1370,6 +1411,7 @@ void floppy_image_device::wspan_write(const std::vector<wspan> &wspans, std::vec
 void floppy_image_device::set_write_splice(const attotime &when)
 {
 	if(m_image && !m_mon) {
+		flush_pending_write();
 		m_image_dirty = true;
 		attotime base;
 		int splice_pos = find_position(base, when);

src/devices/imagedev/floppy.h

@@ -231,6 +231,10 @@ class floppy_image_device : public device_t,
 	bool m_cache_weak;
 
 	bool m_image_dirty, m_track_dirty;
+	bool m_pending_write;
+	int m_pending_write_cyl, m_pending_write_ss, m_pending_write_subcyl;
+	int m_pending_write_start, m_pending_write_end;
+	std::vector<int> m_pending_write_flux_change_positions;
 	int m_ready_counter;
 
 	load_cb m_cur_load_cb;
@@ -260,6 +264,7 @@ class floppy_image_device : public device_t,
 	attotime position_to_time(const attotime &base, int position) const;
 
 	void commit_image();
+	void flush_pending_write();
 
 	u32 hash32(u32 val) const;