Mutexes in Modelica

In the previous example, we saw how to manage simple counter state using atomic operations. For more complex state, we can use a mutex to safely access data across multiple threads.

model Mutexes
  import Modelica.Utilities.Streams.*;

  record Container
    Integer[String] counters;
  end Container;

  function inc
    input Container c;
    input String name;
    output Container result;
  algorithm
    result := c;
    result.counters[name] := c.counters[name] + 1;
  end inc;

  Container c;
initial equation
  c.counters = {"a" = 0, "b" = 0};

algorithm
  when terminal() then
    for i in 1:10000 loop
      c := inc(c, "a");
    end for;
    for i in 1:10000 loop
      c := inc(c, "a");
    end for;
    for i in 1:10000 loop
      c := inc(c, "b");
    end for;
    print("a: " + String(c.counters["a"]) + ", b: " + String(c.counters["b"]));
  end when;
end Mutexes;

In this Modelica example, we’ve created a Container record that holds a map of counters. The inc function is used to increment a named counter.

Note that Modelica doesn’t have built-in support for mutexes or concurrent programming like Go does. Instead, we’re using a sequential approach to simulate the increments. The when terminal() event is used to ensure that all increments are performed at the end of the simulation.

The for loops simulate the concurrent increments from the original Go code. We perform 10,000 increments for “a” twice and 10,000 increments for “b” once.

To run this program:

1. Save the code in a file named Mutexes.mo.
2. Use a Modelica simulation environment like OpenModelica or Dymola to compile and run the model.

The output should be similar to:

a: 20000, b: 10000

This shows that the counters were updated as expected, with “a” being incremented 20,000 times and “b” being incremented 10,000 times.

It’s important to note that this Modelica version is a simplified representation of the original concurrent Go code. Modelica’s primary focus is on modeling and simulating physical systems, and it doesn’t have native support for the kind of concurrent programming demonstrated in the Go example. In real-world applications requiring true concurrency in Modelica, you might need to use external C functions or other techniques specific to your Modelica environment.