Overfeeding memory consumption and performance

[maps]

Dear All,
my question is how "overfeeding" is defined. My understanding of overfeeding was that I feed more more cells than needed the aggregation. So there is an overhead on fed cells.

Now I had an discussion with another developer who told me that a cell could also be overfed if the cell is fed by several feeders. Means I can feed exactly all cells I need for aggregation which wouldn't be overfeeding in my first explanation above but the cells are feed by for example 3 different feeders.

Means that if I don't overfeed my cells considering the number of cells but the cells itself get feed multiple times. In the model I had in my mind it wouldn't make a difference how often I feed a cell because a cell could always be fed or not fed (1 or 0 flag). So it doesn't matter how often a cell is fed it will "cost" always the same memory because a cell can't be more than "fed". The question is now is that true? Or does it cost more memory if I feed the cell several times (using different feeders)?

The next question is now about performance. I could imagine that it could not cost more memory to feed a cell several times but decreases the performance if a cell is fed by several feeders (instead of only one). But then the question would be when does it cost the performance? I guess if the cell value (source cell for feeder) changes from 0 to a value. Because this is the time when the feeder fires. But to be hones I'm only guessing...

The following statemend of IBM doesn't help me a lot...

"Generally, the more FEEDERS that a rule has, the slower the performance will be."
http://www.ibm.com/developerworks/data/ ... ge620.html

I would really appreaciate it if someone could help me out to understand this...

[mvaspal]

Hi,

I think the second case, when feeding the same cell from more than one place will cause you a calculation overhead mainly when you recalculate the feeders - for example with a CubeProcessFeeders or a server restart after deleteing .feeder files. In these cases, also some memory may remain in the garbage that was used for calculating the feeders but are not needed anymore.
We have experienced cases when straight after the server restart 20-30% of the total memory used by the tm1 server was garbage memory (one thread load).

I think the possibility of manual data entry causing performance issues in such a scenario (one cell fed from different places) is minimal; manual data entry (unless it is a data spread on a very aggregated level of a huge cube) usually addresses just small amount of data at the same time.

Correct me please if I am wrong.

Thanks
Matyas

[Duncan P]

Hi maps,

So you are spot on the money. Feeding a cell multiple times has no effect on memory, but does affect performance on write, start-up and feeder processing.

The performance hit is taken when you first write to the source cell and it processes the feeder. Normally one feeder can trigger another and so on. If this is the case it will only happen the first time as the if the fed cell is already fed there is no need to follow the chain further, so that is not a worry to you. There is one exception to this however, if a consolidated cell is fed multiple times then that is equivalent to all of its leaf descendants being fed multiple times. This can be very time consuming. There is a way out though, discussed here.

There is a place where repeated feeding can really get you though and that is on rule save, when feeders are cleared and re-evaluated. If you are in iterative development of the rule and each save takes an hour then it's a bit of a pain.

Cheers,
Duncan.