TM1 Forum

In our system we are getting quite some performance problems.

We use at this oment quite a lot the ATTRS function in IF functions in rules.

If we would setup the system with multiple trees and store a element in different parents we could use ELISANC, is thie faster.

Sample dimension Entity, attribute Country, attribute Currency

I could create a dimension

AllEnt
+Ent1
+Ent2
_AllEurEnt
+Ent1
_AllUSDEnt
+Ent2
_AllCountryUSEnt
+Ent1
_AllcountryBEent
+Ent2

HLEBOEUF wrote:If we would setup the system with multiple trees and store a element in different parents we could use ELISANC, is thie faster.

I've never tested the performance of ATTRS verus ELISANC but common sense would tell you that ELISANC would be much slower. Determing if an element is an ancestor of another in a hierarchy requires many more logical steps than just performing a one time indexed lookup. Think about it.

In a way yes, but a ATTRS is a lookup function that has to be interpreted everytime when used in a rule. (We use this to check if certain data has to be fetched or not).

A ELISANC is (to my knowledge) a structural function that works on a structure of a dimension. That kan only change by editing a dimension, at that moment TM1 will reverify any feeders that runs on that dimension anyway. So once this time-taking job is done the 'path' is know and should mayby not be interpreted anymore ...

It's just thinking how it could be, i'm just looking for somebody that could confirm it (positive or negative).

HLEBOEUF wrote:In a way yes, but a ATTRS is a lookup function that has to be interpreted everytime when used in a rule. (We use this to check if certain data has to be fetched or not).

A ELISANC is (to my knowledge) a structural function that works on a structure of a dimension. That kan only change by editing a dimension, at that moment TM1 will reverify any feeders that runs on that dimension anyway. So once this time-taking job is done the 'path' is know and should mayby not be interpreted anymore ...

It's just thinking how it could be, i'm just looking for somebody that could confirm it (positive or negative).

Why would you assume that one function (ATTRS) would need interpreting every time while another (ELISANC) would need to be interpreted only once? That is wrong. Every time a rule is evaluated the full statement is evaluated, regardless of what type of code you put in it. I can almost guarantee you that TM1 doesn't store a grid about each individual element and all the possible parent, ancestor, sibling, etc. properties of each dimension and all it's members. This would be a massive lookup table that would consume precious memory. It's just going to do that evaluation whenever it is asked.

I can just about guarantee you that ELISANC is going to be slower than ATTRS. IMO, ELISANC is probably one of the slowest rule functions out there, based on what it has to do logically to determine that.

Matey, don't send yourself on a wild goose chase - the difference between ATTRS and ELISANC is unlikely to give you a noticable boost to performance (especially given the time consuming nature of restructuring all your rules / TI's).

May be a bit obvious but the first thing you should look at is defining your rules and feeders to trim down on excess calc's / feeding. This is by far the most common task you should do to improve performance. I'd imagine you'll have scope to tighten them as there are very few production sized models out there that are 100% accurate in their feeders because there's always an argument to be made between performance improvement and development time.

The other obvious thing to look at is archiving old data if your system's starting to fill up a bit.

IMO, ATTRS / ELISANC differences are immaterial compared to these things.

EDIT: Btw, welcome to the forum.

Regards,
Garry