Is there a way to estimate the performance of this model?

I'm not an engineer, I'm a PO.

This might be too complex of a question for a simple answer, but here goes.

I’m trying to understand performance estimation for some designs of a decision engine. The engine would run on a series of yes/no questions, with a model that represents a non-balanced binary tree where every node is a comparison – is object.x >= value? The processing would be something like:

1. Retrieve object
2. Start at top of the tree
3. Is object.x > y?
   3a. Yes, next node
   3b. No, next node
4. Repeat step 3 until the end of a branch
5. Outcome decided

There are frameworks that can solve this pretty easily, i.e Drools. Or, it can be solved with a model in a database, I think.

To keep things simple, here are some constraints / assumptions:

1. the maximum length of a branch is 16 nodes
2. this is not a binary search algorithm as the tree is not balanced / lowest to highest
   every node is a comparison
3. all relevant data to do the comparisons is already retrieved
4. at most, any calculation for a comparison node is 2 fields with any of the following operands: +, -, /, *
5. Written in java/postgres

How can I go about estimating the performance of this model? What’s the O notation? How long would a search of all 16 nodes take? Am I way off?

Thanks!

I have tried finding Drools performance estimates but could not find what I'm hoping to achieve.

> Is there a way to estimate the performance of this model?

Not at that level of abstraction, no. As I also wrote in comments, absolute performance depends on a wide range of machine, environmental, and implementation characteristics. It is extremely difficult to make accurate predictions about absolute performance when there are so many parameters in play.^*

You asked specifically about asymptotic complexity analysis (big O). This is aimed at predicting how computational costs (time, memory) scale with the size of the problem, but

1. To get from there to estimates of absolute performance requires preparing a working implementation and sampling its performance for some problem sizes.

2. The only scaling parameter I see is the number of objects processed through your decision engine, and I see no reason to think that performance of a decision engine such as you describe would scale other than linearly with the the number of input objects.

With respect to per-object decision performance, I would ordinarily expect the evaluation of 16 simple comparisons of primitive values to be extremely fast. Same if you add a few arithmetic operations on primitives, even several per comparison. Navigation of the tree according to the results of those comparisons should also be fast. Note well, however, that all these "fasts" are relative and intentionally vague.

The wildcard here is "Retrieve object". Since you are talking about Postgres, I'm inclined to suppose that you may be retrieving the objects you want to operate on from a database, which you can rely on being very slow, comparatively speaking. Enough so that if you have to include database retrieval time in the performance you want to estimate then you don't need to consider anything else.

Inasmuch as this presumably fits into some larger system, however, it may be that you don't have to account the full cost of object retrieval against the decision process. Perhaps it is more appropriate to attribute some or all of that cost to some other procedure upstream of, downstream of, or encompassing the decision engine.

As for any question of absolute performance, the usual answer to such questions is "what did your tests say?". You may be able to extrapolate test results to other conditions, but nothing presented in this particular question would support a different basic answer here.

^*Unless one is satisfied with extremely low precision. I'd be pretty comfortable in this case with "probably less than one minute", for example.

Of course, I can help you with that! Below is a simplified Node.js code snippet that models the described decision engine logic and provides an estimate of its performance. This code assumes that you have already obtained the object and the data needed for comparison.

function performComparison(node, object) {
    if (node.type === 'leaf') {
        // End of branch, return outcome
        return node.outcome;
    }

    const leftValue = performComparison(node.left, object);
    const rightValue = performComparison(node.right, object);

    switch (node.operator) {
        case '>':
            return leftValue > rightValue;
        case '>=':
            return leftValue >= rightValue;
        case '<':
            return leftValue < rightValue;
        case '<=':
            return leftValue <= rightValue;
        // Add more cases for other operators (+, -, /, *)
        default:
            throw new Error(`Unsupported operator: ${node.operator}`);
    }
}

// Example decision tree node
const decisionTree = {
    type: 'comparison',
    operator: '>=',
    left: { type: 'value', value: 'object.x' },
    right: { type: 'constant', value: 10 },
};

// Example object data
const object = { x: 15 };

const outcome = performComparison(decisionTree, object);
console.log('Outcome:', outcome);


Note that this code provides a basic implementation of the decision engine logic and should be adapted and extended for your specific use case and data structure.

In terms of performance and estimation of O notation, the time complexity of the decision engine is highly dependent on the depth of the decision tree. In this case the maximum branch length is 16 nodes, so in the worst case scenario he would have to traverse all 16 nodes, resulting in a time complexity of O(16) which is effectively constant time. Masu.

Note, however, that the actual performance may be affected by many factors, including computational complexity within the comparison node, hardware, and database performance. To get more accurate performance estimates, it may be necessary to implement a benchmarking mechanism and test the engine using representative data and scenarios.

Finally, if you are interested in considering performance optimizations, you can consider techniques such as memoization to avoid redundant computations and cache previously computed results.