Batching same-program instruction invocations to save on context-switch overhead

[jon-chuang]

Problem

Currently, if making multiple instruction invocations into the same program, a significant amount of overhead is required.

1. Copying data from bpf memory into keyed accounts.
2. Verification of intermediate account data against a reference (PreAccount).
3. Verification of resultant data from process_instruction against reference.
4. Copying data back into bpf memory.

The chosen number to reflect these costs is 1000 compute unit cost per CPI. That's not particularly high, but is about 20-25% of a typical Serum tx. Raydium TX, which typically call serum CPIs 10-20 times per TX, can save up to 20,000 CUs, bringing down median cost from 85,000 to 65,000, allowing greater composability with Raydium.

Proposed Solution

Allow batching of multiple instructions into a single syscall. This can get rid of extra data copies per CPI.

In this proposal, we ignore saving on verification - since verification even in between instructions executed for the same program may be a desirable property anyhow, while opening up the possibility of batching instructions from different programs.

Todo

Investigate just how much time-cost savings there could be in batching. It's probably on the order of 10s of microseconds per invoke. Which maybe isn't significant enough to justify the effort ...

[jon-chuang]

Some evidence where this would be of significant use:
Mango markets ForceCancelOrders instruction,
https://github.com/blockworks-foundation/mango/blob/5556f483f939bfd967dbc3d255a3d94e354f35f7/program/src/processor.rs#L1852
performing up to 128 invoke_signed

for cancel in cancels.iter() {
        let cancel_instruction = serum_dex::instruction::MarketInstruction::CancelOrderV2(cancel.clone());
        instruction.data = cancel_instruction.pack();
        solana_program::program::invoke_signed(&instruction, &account_infos, signers_seeds)?;
    }