Supervisor synthesis performance
There are several ways to altogether avoid performance and out-of-memory issues when applying supervisor synthesis:
Use the data-based synthesis tool rather than the event-based synthesis tool, as the former has much better performance.
Rather than synthesizing a single monolithic supervisor, employ non-monolithic synthesis to make use of the inherent structure of your system.
However, if you still suffer such issues, consider the following to resolve them:
See the page of the Eclipse ESCET general toolkit documentation on resolving performance and memory problems. In particular, make sure to give Java 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, State/event exclusion invariants and Invariant kinds sections of the CIF language tutorial.
Try to separate your requirements as much as possible, to keep them simple. Also, leave out any events from a requirement automaton that are not relevant to that specific requirement.
You can try to restrict more of the system, by adding more requirements, to get a smaller supervisor (with less behavior).
Avoid adding plants that you don’t at all use in the requirements. For instance, don’t add a button plant automaton if you don’t use the button.
Try to avoid duplicate requirements that enforce the same behavior in different ways.
Check out the performance section of the data-based synthesis tool documentation.