Accelerator, Model, Monitor – what is an ACM monitor?
There is a blog by OCCT Software that is worth checking out. The author, Todd Epp, gave a talk on ACM monitoring at one of the recent Object Rendering Conferences. It is an active area of research. And since it is one that is really difficult to code. It is not surprising that it has been found difficult to get into in an efficient way. The Question What is an ACM monitor? is quite common.
Todd’s talk is well worth a look. And I will take it from here, and go through a few things he said:
Note this is no introduction to ACM. If you’re interested, follow the links and read the description on the OCCT Software blog.
This is basically what I see in OCS as I work with the project that I call ACM Monitor. Which is an implementation of OCS for the ARMA 2 language.
ACM is an idea that was first introduced in 2003 by Simon Donner, of Penn State. OCS and ACM share a number of ideas. Such as the virtual caller, dynamic passing, functional dependencies, resource management, reflection and emulation, and more.
The idea is that a real-time parallel application with extensive external dependencies should have the ability to simulate a program structure. That can effectively isolate the effects of external processes and resources.
It is a general principle in concurrent programming that code does not try to perform exactly the same operation. Every time but instead building one complex program component at a time, is more effective and less error-prone. An example of this is the best practice of “pass by value”. Where all values are immutable; there is no copying. In this model, there is only an IO, RT, and IOPL.
ACM monitors are an example of the internal simulation model. ACM models are designed to allow for easier design. Since designers don’t have to worry about how the user is going to manipulate the user interfaces or interact with the objects.
What is an ACM monitor?
We call this an external model, and it’s distinct from the idea of a simulation. Which uses a model of the external world. We define an external model as a model. That sits outside the code of the application itself, in the process server, or the operating system; it provides a different way of designing the external models.
One of the goals of an ACM monitor is that it should have the capability of designing an externally modeled object, given a description of an object. And a model of the internal state of the object.
ACM monitors are good. Because the internal state will not change in any way except for some minor modifications to the object after an external operation. A number of things make ACM monitors good. But mostly the idea of modeling an object externally, rather than inside the code.
You can imagine that an internal model of an object wouldn’t be very easy to communicate. Because it might change at any time. So to do an operation on the internal state it would have to put an additional copy of the object in the game space. Which isn’t an idea we’d like to have. I try to explain to you What is an ACM monitor?
Owing to this design, ACM monitors can be very very efficient because they model an external model. Which is much easier for the programmer to understand. And much easier for the compiler and linker to deal with.
What is an ACM monitor?
When we add external code to an object. We need to provide a protocol to tell the system how to treat it – we need to tell it, for example, how to handle cloning. Having an external model means that code that handles cloning is included in the definition of the external model.
Another good thing about ACM is that it models an externally modeled object. It’s much easier to add a subset of external dependencies and objects. We can add external dependencies to the model at runtime. And they can be shared freely with the object in the model.
The next thing that is good about ACM is that it avoids a lot of complications. ACM only models two kinds of effects: a task (i.e., it models external operations, not internal effects) and a resource (i.e., it models external resources, not internal states). You can model any effect that can be explained by a task and resource pair.
It might seem strange that we can add a thing called “user interface” into an external model. But it makes a lot of sense because as an external model, an object can have an internal state that you can only interact with by pointing at it. And not by interacting with the object directly. Now, What is an ACM monitor? is not difficult for you.
There are, of course, external models that have a user interface, like a game or chat window. But user interfaces tend to be very complex. And we don’t want to model those; we just want to have a model of them.
Finally, in the ACM model, there is a little bit of a shared state. It’s possible to create threads of code that check the state of the external model at different times during execution.
Hope You know the answer Now: What is an ACM monitor?
