run method

  1. @override
Future<void> run(
  1. Phase phase
)
override

Executes this Component's activities related to running the test.

Overrides of run must call super.run in an unawaited fashion. For example:

@override
Future<void> run(Phase phase) async {
  unawaited(super.run(phase));
  // New code goes here!
}

Implementation

@override
Future<void> run(Phase phase) async {
  unawaited(super.run(phase));

  var cycle = 0;
  while (!Simulator.simulationHasEnded) {
    await clk.nextPosedge;
    if (Simulator.simulationHasEnded) {
      return;
    }

    final resetValue = reset.previousValue;
    final debitValues = debitCounts.map((signal) => signal.previousValue);
    final returnValues = returnCounts.map((signal) => signal.previousValue);
    if (resetValue == null ||
        debitValues.any((value) => value == null) ||
        returnValues.any((value) => value == null)) {
      cycle++;
      continue;
    }

    final inReset = (resetValue.isValid && resetValue.toBool()) ||
        reinitializationResets.any((signal) {
          final value = signal.previousValue;
          return value != null && value.isValid && value.toBool();
        });
    if (inReset) {
      _credits.setAll(0, configuration.initialCredits);
      _sharedCredits = configuration.sharedInitialCredits ??
          _credits.fold(0, (sum, credits) => sum + credits);
      cycle++;
      continue;
    }

    final allValues = [...debitValues, ...returnValues].cast<LogicValue>();
    if (allValues.any((value) => !value.isValid)) {
      _report('credit.counts_known', cycle,
          'Debit and return counts must be known after reset.', {
        'debitCounts': debitValues.toList(),
        'returnCounts': returnValues.toList(),
      });
      cycle++;
      continue;
    }

    final debits = debitValues
        .cast<LogicValue>()
        .map((value) => value.toInt())
        .toList(growable: false);
    final returns = returnValues
        .cast<LogicValue>()
        .map((value) => value.toInt())
        .toList(growable: false);
    if (configuration.sharedMaximumCredits == null) {
      for (var pool = 0; pool < _credits.length; pool++) {
        _credits[pool] = _applyCounts(
            current: _credits[pool],
            maximum: configuration.maximumCredits[pool],
            debit: debits[pool],
            creditReturn: returns[pool],
            pool: pool,
            cycle: cycle);
      }
    } else {
      _sharedCredits = _applyCounts(
          current: _sharedCredits,
          maximum: configuration.sharedMaximumCredits!,
          debit: debits.fold(0, (sum, value) => sum + value),
          creditReturn: returns.fold(0, (sum, value) => sum + value),
          pool: null,
          cycle: cycle);
    }
    cycle++;
  }
}