args = [{...}, {...}, ...]
for arg in args:
   state = my_program.run(**arg)
   save_result(state, arg)

args = [{...}, {...}, ...]
states = my_program.run_batch(args)
# save results in the end
for arg, state in zip(args, states):
   save_result(state, arg)

args = [{...}, {...}, ...]
for arg, state in my_program.run_batch(args):
   save_result(state, arg)

def run_program_batch_generator(
    program,
    backend,
    batch_arguments,
    default_sampling_para,
    num_threads,
    progress_bar,
):
    if hasattr(backend, "endpoint"):
        backend = backend.endpoint

    # Extract prefix by tracing and cache it
    if len(batch_arguments) > 1:
        pin_program(program, backend)

    # Determine the number of threads to use
    if num_threads == "auto":
        num_threads = max(96, multiprocessing.cpu_count() * 16)
    num_threads = min(num_threads, len(batch_arguments))

    # Execute each run_program call and yield results as they become available
    if num_threads == 1:
        for arguments in batch_arguments:
            yield run_program(
                program,
                backend,
                (),
                arguments,
                default_sampling_para,
                False,
                True,
            )
    else:
        with concurrent.futures.ThreadPoolExecutor(num_threads) as executor:
            # Use a dictionary to map futures to their corresponding arguments
            future_to_arguments = {
                executor.submit(
                    run_program,
                    program,
                    backend,
                    (),
                    arguments,
                    default_sampling_para,
                    False,
                    True,
                ): arguments
                for arguments in batch_arguments
            }

            # Asynchronously yield results as they complete
            for future in concurrent.futures.as_completed(future_to_arguments):
                yield future_to_arguments[future], future.result()