partially_populate_device: align span positions to block size for better performance

Add an optional `align` parameter (default: 4KiB) to align span positions
to a given block size. Only positions are aligned (rounded down); span sizes
are reduced if needed to avoid overlapping the next span's position. When
config.write_volume_cap is large enough, spans are contiguous and cover the
full device with no gaps. Without alignment, write throughput drops from
~700MiB/s to ~200MiB/s on large disks.

Signed-off-by: Gaëtan Lehmann <gaetan.lehmann@vates.tech>

Author: glehmann

conftest.py

@@ -118,12 +118,20 @@ def pytest_addoption(parser: pytest.Parser) -> None:
         help="Maximum amount of data written to a volume."
              " Accepts sizes like '1GiB', '2.5TiB', or symbolic values 'VHD_MAX', 'QCOW2_MAX'."
     )
+    parser.addoption(
+        "--write-volume-align",
+        action="store",
+        default="4KiB",
+        help="Block size to align span positions to in partially_populate_device."
+             " Accepts sizes like '512', '4KiB', '1MiB'."
+    )
 
 def pytest_configure(config: pytest.Config) -> None:
     global_config.ignore_ssh_banner = config.getoption('--ignore-ssh-banner')
     global_config.ssh_output_max_lines = int(config.getoption('--ssh-output-max-lines'))
     global_config.volume_size = parse_size(config.getoption('--volume-size'))
     global_config.write_volume_cap = parse_size(config.getoption('--write-volume-cap'))
+    global_config.write_volume_align = parse_size(config.getoption('--write-volume-align'))
 
 def pytest_generate_tests(metafunc: pytest.Metafunc) -> None:
     if "vm_ref" in metafunc.fixturenames:

lib/config.py

@@ -4,6 +4,7 @@
 ssh_output_max_lines = 20
 volume_size = 1 * GiB
 write_volume_cap = 2 * GiB
+write_volume_align = 1
 
 def sr_device_config(datakey: str, *, required: list[str] = []) -> dict[str, str]:
     import data  # import here to avoid depending on this user file for collecting tests

tests/storage/storage.py

@@ -369,6 +369,66 @@ def validate(self, vm: VM, dev: str) -> None:
         expected_flags = f'--expected-checksum {self.checksum}' if self.checksum is not None else ''
         randstream(vm, f'validate {expected_flags} --position {self.position} --size {self.size} {dev}')
 
+def compute_span_layout(dev_size: int, total_size: int, num_spans: int, align: int) -> list[tuple[int, int]]:
+    """
+    Compute the positions and sizes of spans across a device.
+
+    Spans are distributed such that the first span starts at 0 and the last
+    span ends at dev_size, with middle spans evenly distributed in between.
+    Positions are computed by evenly dividing total_size across num_spans,
+    then rounded down to the nearest multiple of align. Bytes that cannot be
+    written due to alignment rounding are carried over to subsequent spans,
+    so that the full device can be covered when total_size equals dev_size.
+
+    Args:
+        dev_size: Total device size in bytes
+        total_size: Total number of bytes to write across all spans.
+                    Use dev_size for full device coverage, or a smaller value
+                    to leave gaps between spans.
+        num_spans: Number of spans to create
+        align: Block size in bytes to align span positions to.
+               All span positions are rounded down to the nearest multiple of align.
+               Span sizes are reduced if necessary to avoid overlapping the next
+               span's position, with unwritten bytes carried forward to later spans.
+               When total_size equals dev_size, spans are contiguous and cover
+               the full device with no gaps.
+
+    Returns:
+        List of (position, size) tuples, one per span.
+        Spans are guaranteed to:
+        - Not overlap
+        - Have first span at position 0
+        - Have last span ending at dev_size
+        - Be evenly distributed across device
+    """
+    # Positions are computed by evenly dividing total_size, then aligned down.
+    # Using total_size * i // num_spans avoids losing the remainder that would
+    # occur if we divided total_size by num_spans first.
+    positions = [(total_size * i // num_spans // align) * align for i in range(num_spans)]
+
+    # Compute sizes with carry: bytes trimmed due to alignment are carried
+    # forward so later spans can make up the difference
+    result: list[tuple[int, int]] = []
+    carry = 0
+    per_span = total_size // num_spans
+    for i, position in enumerate(positions):
+        if i == len(positions) - 1:
+            size = dev_size - position
+        else:
+            budget = per_span + carry
+            size = min(budget, positions[i + 1] - position)
+            carry = budget - size
+        assert position + size <= dev_size, \
+            f"Span {i} at position={position} size={size} extends past dev_size={dev_size}"
+        if i > 0:
+            prev_pos, prev_size = result[-1]
+            assert position >= prev_pos + prev_size, \
+                f"Span {i} at position {position} overlaps with previous span ending at {prev_pos + prev_size}"
+        result.append((position, size))
+
+    return result
+
+
 def partially_populate_device(vm: VM, dev_path: str, dev_size: int, num_spans: int = 3, skip_spans: list[int] = []) \
         -> list[StreamSpan]:
     """
@@ -402,55 +462,25 @@ def partially_populate_device(vm: VM, dev_path: str, dev_size: int, num_spans: i
         skip_spans: List of span indices to skip (no data generated).
                    Skipped spans still exist in returned list with checksum=None.
                    (default: [])
+               Span alignment is controlled by the --write-volume-align pytest option.
 
     Returns:
         List of StreamSpan objects representing the generated spans.
-        Spans are guaranteed to:
-        - Not overlap
-        - Have first span at position 0
-        - Have last span ending at dev_size
-        - Be evenly distributed across device
     """
     logging.info(f"Generate {dev_path} content")
-    stream_size = min(dev_size, config.write_volume_cap) // num_spans
+    total_size = min(dev_size, config.write_volume_cap)
 
     # Validate skip_spans
     assert all(0 <= i < num_spans for i in skip_spans), \
         f"Invalid span index in skip_spans: must be 0 <= i < {num_spans}"
 
+    layout = compute_span_layout(dev_size, total_size, num_spans, config.write_volume_align)
     spans: list[StreamSpan] = []
-
-    # Calculate positions for regularly distributed spans
-    # First span always at position 0, last span always ends at dev_size
-    if num_spans == 1:
-        positions = [0]
-    elif num_spans == 2:
-        positions = [0, dev_size - stream_size]
-    else:
-        # For 3+ spans: distribute evenly across available space
-        # Available space is dev_size - size (last span can't extend past dev_size)
-        available_space = dev_size - stream_size
-        positions = [0]  # First span always at 0
-        # Distribute middle spans evenly
-        for i in range(1, num_spans - 1):
-            position = (available_space * i) // (num_spans - 1)
-            positions.append(position)
-        positions.append(dev_size - stream_size)  # Last span always ends at dev_size
-
-    # Generate spans with consistency checks
-    prev_end = -1
-    for i, position in enumerate(positions):
-        # Assert no overlap
-        assert position >= prev_end, f"Span {i} at position {position} overlaps with previous span ending at {prev_end}"
-        span = StreamSpan(position=position, size=stream_size)
+    for i, (position, size) in enumerate(layout):
+        span = StreamSpan(position=position, size=size)
         if i not in skip_spans:
             span.generate(vm, dev_path, seed=1000 + i)
         spans.append(span)
-        prev_end = position + stream_size
-
-    # Final assert: last span must not extend past dev_size
-    assert spans[-1].position + spans[-1].size <= dev_size, \
-        f"Last span extends past device: position={spans[-1].position}, size={spans[-1].size}, dev_size={dev_size}"
 
     return spans