Budget de calcul

Limite d'unités de calcul

Chaque instruction se voit allouer par défaut 200 000 CUs, et chaque transaction est plafonnée à 1 400 000 CUs. Lorsqu'aucune instruction SetComputeUnitLimit explicite n'est présente, la valeur par défaut est calculée en fonction du type d'instruction :

default_cu_limit = (num_non_migratable_builtin_instructions * 3,000)
                 + (num_not_migrated_builtin_instructions * 3,000)
                 + (num_non_builtin_instructions * 200,000)
                 + (num_migrated_builtin_instructions * 200,000)

• Instructions intégrées (System Program, Stake, Vote, etc. qui n'ont pas été migrées vers SBF) : chacune se voit allouer MAX_BUILTIN_ALLOCATION_COMPUTE_UNIT_LIMIT = 3 000 CUs (selon SIMD-0170).
• Instructions non intégrées (programmes SBF déployés par l'utilisateur) : chacune se voit allouer DEFAULT_INSTRUCTION_COMPUTE_UNIT_LIMIT = 200 000 CUs.
• Intégrées en cours de migration ayant terminé la migration vers SBF (contrôlées par feature gate) : traitées comme non intégrées (200 000 CUs chacune).

Le résultat est plafonné à MAX_COMPUTE_UNIT_LIMIT (1 400 000).

Vous pouvez remplacer cette valeur par défaut en incluant une instruction SetComputeUnitLimit dans votre transaction.

Pour déterminer la limite de CUs appropriée :

1. Simulez la transaction pour mesurer la consommation de CUs.
2. Ajoutez une marge de sécurité de 10 % à la valeur simulée.

Instructions du budget de calcul

Le programme de budget de calcul (ComputeBudget111111111111111111111111111111) comporte quatre instructions.

Source : énumération ComputeBudgetInstruction

Contraintes et conditions d'erreur

Les règles suivantes s'appliquent lors du traitement des instructions de budget de calcul :

• Une par type : une seule instruction de chaque variante est autorisée par transaction. L'inclusion de doublons provoque une erreur DuplicateInstruction (la transaction entière échoue).
• RequestHeapFrame : la valeur doit être comprise entre MIN_HEAP_FRAME_BYTES (32 Kio) et MAX_HEAP_FRAME_BYTES (256 Kio), et doit être un multiple de 1 024. Sinon, la transaction échoue avec InvalidInstructionData. La taille du tas s'applique à chaque programme invoqué dans la transaction (y compris les CPI).
• SetComputeUnitLimit : toute valeur u32 est acceptée. La limite effective est plafonnée à MAX_COMPUTE_UNIT_LIMIT (1 400 000).
• SetComputeUnitPrice : toute valeur u64 est acceptée (0 à u64::MAX).
• SetLoadedAccountsDataSizeLimit : la valeur doit être supérieure à 0 (NonZeroU32). Une valeur de 0 provoque InvalidLoadedAccountsDataSizeLimit. La limite effective est plafonnée à MAX_LOADED_ACCOUNTS_DATA_SIZE_BYTES (64 Mio).
• Données non reconnues : toute instruction envoyée au programme de budget de calcul qui ne se désérialise pas en une variante connue échoue avec InvalidInstructionData.

Modèle de coût du planificateur

Le planificateur du validateur utilise un modèle de coût pour estimer l'utilisation des ressources de la transaction avant l'exécution. Ces estimations de coût de pré-exécution déterminent si une transaction correspond à la capacité restante du bloc. Elles sont distinctes de la mesure des CU qui se produit pendant l'exécution.

Le coût total du planificateur est la somme de cinq composants (UsageCostDetails::sum) :

total_cost = signature_cost
           + write_lock_cost
           + data_bytes_cost
           + programs_execution_cost
           + loaded_accounts_data_size_cost

Composants de coût

Toutes les valeurs sont en unités de calcul.

Constantes de coût du planificateur

Coût de transaction de vote

Les transactions de vote utilisent un coût statique de 3 428 CU indépendamment de leur contenu réel.

Limites de bloc

Le planificateur applique des limites par bloc. Si l'ajout d'une transaction dépassait l'une des limites, elle n'est pas incluse dans le bloc.

Constantes du budget d'exécution

Les constantes suivantes de execution_budget.rs définissent les limites d'exécution lors de l'exécution des transactions :