[
Date Prev][
Date Next][
Thread Prev][
Thread Next][
Date Index][
Thread Index]
[
List Home]
Re: [henshin-dev] Performance tweaks
|
Hi Felix,
I totally agree. The reason why I am saying that we need to improve the
performance is that the state space generation tool does not work as
efficient as it should (compared to other tools). Generating state
spaces of millions of states should be possible in reasonable amount of
time, but currently there are bottlenecks preventing that. I already
worked a lot on improving the effiency of the state space generator
itself. My feeling is though that we now need to optimize the
interpreter itself as well, because if there are bottlenecks there no
optimization in the state space generator will help.
For the state space generator, it is important that the matching and the
application of a single rule is fast. I think the interpreter performs
pretty well in this respect. The second point is that I need to perform
a large number of transformations in a short amount of time. So the
problem is not a single rule application, but a large number of them in
a short amount of time. This is what I need to do in order to make the
state space generator reasonable fast. And as I stated earlier already,
I believe that it is important to reduce the memory consumption for a
single rule application because when performing a large number of rule
applications, all the transient data that is necessary for a single rule
application must be garbage collected, which takes up a lot of time.
Cheers,
Christian
PS: IMHO using real-world examples for performance analysis can be very
difficult
On 25.04.2012 14:54, Riegerf@xxxxxxxxxxxxxxxxxxxxxxx wrote:
Hi Christian,
Quoting Christian Krause <henshin.ck@xxxxxxxxx>:
Sometimes the measured times vary a lot and it is not always possible
to say what caused the difference or whether a change in the
implementation improves the performance under different conditions.
Still, I think that we should try to improve the memory consumption
[...]
Thinking about optimizations is quite nice, but seeing you are getting
these insights from using a (on my first impression) rather
unrealistic and made-up example, wouldn't it be much more sensible to
use (i.e. either acquire from our users or come up with) realistic and
more real-world examples for trying to measure and optimize performance?
I suspect that usually models are rather smaller than the Sierpinski
example, so there might actually be no significant performance hit by
the current implementation w.r.t. memory consumption, but some other
aspect of the implementation could offer much better opportunities to
work on to improve the actual speed for real-world transformation tasks.
If we want to make an effort in optimizing the Henshin Interpreter,
actually identifying bottlenecks in the execution of the
transformations our current users and our target user group use might
lead to better results than just rewriting any code because of
possible improvements this brings when using unrealistic examples.
Sadly, I am not proficient in the way the interpreter works, so I can
not suggest anything to look at in particular. One approach may be to
look at transformations and models our users use and find out why
they're not as fast as they could be.
Felix
_______________________________________________
henshin-dev mailing list
henshin-dev@xxxxxxxxxxx
https://dev.eclipse.org/mailman/listinfo/henshin-dev