Class FlowrAnalyzerGasContext

constructor

• new FlowrAnalyzerGasContext(
      ctx: FlowrAnalyzerContext,
      config: FlowrGasConfig | undefined,
      plugins: readonly FlowrAnalyzerGasPlugin[],
  ): FlowrAnalyzerGasContext

  Parameters

  • ctx: FlowrAnalyzerContext
  • config: FlowrGasConfig | undefined
  • plugins: readonly FlowrAnalyzerGasPlugin[]

  Returns FlowrAnalyzerGasContext

Readonlyname

budget

• budget(key: string): DataflowBudgetTracker | undefined

  The counted bounds of key, resolved once against the current contingent, or undefined when disabled or unbounded. Arming counterpart of checkGas for the dataflow fold, see GasFeatureKey.Dataflow.

  Parameters

  • key: string

  Returns DataflowBudgetTracker | undefined

checkEvery

• checkEvery(): number

  Returns number

  See

  ReadOnlyFlowrAnalyzerGasContext#checkEvery

checkGas

• checkGas(key: string): GasLevel

  Returns the resource-pressure level for key (config.gas.features[key]). Returns GasLevel.Normal with zero overhead when the feature factor is 0 or absent and no gas plugins are registered (plugins are always consulted and may escalate any key).

  Measured from the start of the enclosing contingent, against the thresholds configured for key (see GasThresholdSpec), not one allowance shared by everything the analyzer does.

  Parameters

  • key: string

  Returns GasLevel

receive

• receive(_event: InvalidationEvent): void

  A new analysis makes the spent contingent irrelevant.

  Parameters

  • _event: InvalidationEvent

  Returns void

reset

• reset(): void

  Restart the contingent, so what follows is measured from now. Supported API: call it between phases that should each get the full allowance (analyzer.context().gas.reset()).

  flowR calls it itself whenever a new analysis begins, so a caller only has to split its own phases. Operations in flight keep their contingent, as restarting a running traversal's clock would defeat the guard bounding it.

  Returns void

scope

• scope(overrides?: GasOverrides): ReadOnlyFlowrAnalyzerGasContext

  A view with a fresh contingent, measured from this call, for one operation to run against. The enclosing bounds still apply, overrides winning over them. Derives a new object rather than mutating this one, so it is safe for nested and concurrent work.

  Parameters

  • Optionaloverrides: GasOverrides

  Returns ReadOnlyFlowrAnalyzerGasContext

withFreshGas

• withFreshGas<T>(fn: () => Promise<T>): Promise<{ degraded: boolean; value: T }>

  Runs fn against a contingent of its own: the configured bounds only, none of the overrides of the operation asking, and a fresh start time. Reports whether any gas check during fn came back above normal, so a result meant to be shared (see FlowrAnalyzerCache#derive) is only kept when it is complete. Use it for work that outlives the operation asking, and FlowrAnalyzerGasContext#withGas for the work of the asking operation itself, since this one ignores the overrides in effect (so it does not inherit a tight bound of the caller). degraded is also set if a check inside a nested scope reported more than normal.

  Type Parameters

  • T

  Parameters

  • fn: () => Promise<T>

  Returns Promise<{ degraded: boolean; value: T }>

  Example

  const { value, degraded } = await analyzer.context().gas.withFreshGas(async() => await analyzer.dataflow());
  const kept = degraded ? undefined : value; // a degraded value may be incomplete, so do not store it
  Copy

withGas

• withGas<T>(overrides: GasOverrides | undefined, fn: () => T): T

  Run fn against a fresh contingent bounded by overrides, ending when it settles if fn is async. Every check while fn runs sees it, however deep, which is how the bounds reach sites that only ever get a context handed to them.

  Being ambient, concurrent operations on one analyzer see whichever started last, so prefer scope wherever the context can be threaded through.

  Type Parameters

  • T

  Parameters

  • overrides: GasOverrides | undefined
  • fn: () => T

  Returns T