CIF 3

Performance of the toolchainΒΆ

For larger systems, the state space of the uncontrolled system, and usually also the resulting supervisor, becomes larger.

For event-based synthesis, the size increases exponentially with the number of plants, and depending on how you model them, sometimes also the number of requirements. For data-based synthesis, the effect is usually less severe.

The larger the resulting supervisor, the more expensive the synthesis and subsequent steps in the toolchain become. Here are some hints on resolving such performance problems and out-of-memory errors:

  • See the Resolving performance and memory problems page of the Systems Engineering Software website for general information on resolving performance and memory problems. In particular, make sure to give Eclipse more memory. This should be the first thing you check.

  • If possible, use requirements that are pure restrictions, as they only make the supervisor smaller. If you introduce memory (e.g. counters), or other forms of sequencing (e.g. to specify the order of controllable events), that usually increases the size of the supervisor. If possible, use requirements with only one location, or even better, use requirement invariants. For more information, see the State (exclusion) invariants page, the State/event exclusion invariants page, and the Invariant kinds section of the Supervisory controller synthesis page.

  • Try to separate your requirements as much as possible, to keep them simple. Also, leave out any events that are not relevant to a specific requirement.

  • You can try to restrict more of the system, by adding more requirements, to get a smaller supervisor.

  • Avoid adding plants that you don’t at all use in the requirements. For instance, don’t add a button to the plant if you don’t use the button.

  • Try to avoid duplicate requirements that enforce the same behavior in different ways, especially for event-based synthesis.

  • See the Using multiple plants/requirements files section for information on how to split your system into parts. This allows you to synthesize supervisors for each of the parts, which usually results in much smaller supervisors.

  • If you follow the 4K420 course, you’ll likely use the G drive (network share) to store your files. This is convenient (and recommended), as generated PLC code immediately becomes available on the lab computer, if you’ve logged on to that computer using the same account.

    However, the G drive is often much slower than for instance a local disk. This is especially the case if multiple users use the same wireless network access point. Using a wired connection instead of a wireless connection may help a bit. However, to get maximum performance, you could move your projects to for instance a local disk or USB drive.

  • When using data-based synthesis, modify the value of the BDD library operation cache ratio option. You can change the cache size in the 1a_synthesize1.tooldef2, 1b_synthesize2.tooldef2, 1c_synthesize3.tooldef2, 1d_synthesize4.tooldef2, and 1e_synthesize5.tooldef2 files. Look for the line with --bdd-cache-ratio= and change the ratio after the =. For more information, see the BDD operation caches section of the Data-based supervisory controller synthesis page.