Data Partition

Partition datasets across agents to avoid overlap and preserve coverage.

Partition Strategy

Each node can operate on an assigned shard of data for deterministic execution.

Feature Usage Samples

How to use snippets for Data Partition.

Switch between C#, Java, Python, TypeScript, and JavaScript to see the native SDK shape for this sample.

Licensing note: every runnable sample requires a valid runner key via WithRunnerKey("...") or config key LoadStrike:RunnerKey.

Partition Test Data by ScenarioPartition

var allUsers = Enumerable.Range(1, 10000).Select(i => $"user-{i}").ToArray();
var partitions = new ConcurrentDictionary<string, string[]>();

var scenario = LoadStrikeScenario.Create("partitioned-users", context =>
    {
        var shard = partitions[context.ScenarioInfo.InstanceId];
        var userId = shard[context.Random.Next(shard.Length)];
        return Task.FromResult(LoadStrikeResponse.Ok(message: userId));
    })
    .WithInit(init =>
    {
        var p = init.ScenarioPartition;
        partitions[init.ScenarioInfo.InstanceId] = allUsers.Where((_, i) => i % p.Count == p.Number).ToArray();
        return Task.CompletedTask;
    });

import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.IntStream;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeResponse;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeScenario;

var allUsers = IntStream.rangeClosed(1, 10_000).mapToObj(i -> "user-" + i).toList();
var partitions = new ConcurrentHashMap<String, java.util.List<String>>();

var scenario = LoadStrikeScenario.create("partitioned-users", context -> {
      var shard = partitions.get(context.ScenarioInfo.InstanceId);
      var userId = shard.get(context.Random.nextInt(shard.size()));
      return LoadStrikeResponse.ok(userId);
    })
    .withInit(init -> {
      int number = Integer.parseInt(String.valueOf(init.ScenarioPartition.get("Number")));
      int count = Integer.parseInt(String.valueOf(init.ScenarioPartition.get("Count")));
      var shard = IntStream.range(0, allUsers.size())
          .filter(index -> index % count == number)
          .mapToObj(allUsers::get)
          .toList();
      partitions.put(init.ScenarioInfo.InstanceId, shard);
    });

from loadstrike_sdk import LoadStrikeResponse, LoadStrikeScenario

all_users = [f"user-{index}" for index in range(1, 10001)]
partitions = {}

def init_partition(init_context):
    partition = init_context.scenario_partition
    shard = [user for index, user in enumerate(all_users) if index % partition.count == partition.number]
    partitions[init_context.scenario_info.instance_id] = shard

scenario = (
    LoadStrikeScenario.create(
        "partitioned-users",
        lambda context: LoadStrikeResponse.ok(
            message=partitions[context.scenario_info.instance_id][context.random.Next(0, len(partitions[context.scenario_info.instance_id]))]
        ),
    )
    .with_init(init_partition)
)

import { LoadStrikeResponse, LoadStrikeScenario } from "@loadstrike/loadstrike-sdk";

const allUsers = Array.from({ length: 10_000 }, (_, index) => `user-${index + 1}`);
const partitions = new Map<string, string[]>();

const scenario = LoadStrikeScenario
  .create("partitioned-users", async (context) => {
    const shard = partitions.get(context.scenarioInfo.instanceId) ?? [];
    const userId = shard[context.random.Next(0, shard.length)];
    return LoadStrikeResponse.ok(undefined, undefined, userId);
  })
  .withInit((initContext) => {
    const { Number, Count } = initContext.ScenarioPartition;
    const shard = allUsers.filter((_, index) => index % Count === Number);
    partitions.set(initContext.scenarioInfo.instanceId, shard);
  });

const { LoadStrikeResponse, LoadStrikeScenario } = require("@loadstrike/loadstrike-sdk");

const allUsers = Array.from({ length: 10_000 }, (_, index) => `user-${index + 1}`);
const partitions = new Map();

const scenario = LoadStrikeScenario
  .create("partitioned-users", async (context) => {
    const shard = partitions.get(context.scenarioInfo.instanceId) || [];
    const userId = shard[context.random.Next(0, shard.length)];
    return LoadStrikeResponse.ok(undefined, undefined, userId);
  })
  .withInit((initContext) => {
    const { Number, Count } = initContext.ScenarioPartition;
    const shard = allUsers.filter((_, index) => index % Count === Number);
    partitions.set(initContext.scenarioInfo.instanceId, shard);
  });

Partition Formula

partition.Count

Tells each node how many total shards exist for the current run.

partition.Number

Tells the current node which shard number it owns.

Modulo sharding

Uses a stable modulo rule so each item lands on exactly one partition without overlap.

shard(i) => i % partition.Count == partition.Number