Member Avatar for Ajay Raj

Hi can anny one help me out optimizing the follwing issue:
A C++ class has the following member:
int status_[75];
During performance analysis it was found out
that the class (its object) was performing unsatisfactorily
making it a necessary candidate for optimization.
The following additional information was also found out
*) Each element of the status_ array assumes only the
following 4 values: -1, 0, 1, 2
*) The bulk of the time was spent in loops like:
for(size_t i=0; i != 75; ++i) {
if(status_ == 1) {
// do something...
}
}
*) The set of elements of the status_ array that assume a particular
value is sparse making the above loop inefficient.
Assume that 0 is the default value.
*) The status_ array is updated at places scattered throughout the code
making it difficult to rewrite. However, a particular element
is updated only through a statement like
status = -1;


Please Code an algorithm if possible

Thanks & Regards

  • 2 Contributors
  • 1 Reply
  • 202 Views
  • 6 Hours Discussion Span
  • Latest Post Latest Post by andor

Dani AI

Generated

reported a hot loop that scans a small fixed-size status buffer where almost every element is the default, and updates to elements are scattered through the code. asked for runnable code — the least-intrusive, high-value change is to replace the raw array with a thin wrapper that (1) keeps array-like syntax at every call site and (2) keeps auxiliary index-sets for the non-default states so iteration is proportional to the number of matches rather than the full buffer size.

A practical, minimal-change approach: implement a small class (templated on the size) that stores the compact values and three per-value index containers (e.g., unordered_set for simplicity). Provide operator[] that returns a proxy object which intercepts assignments and updates those sets automatically. That lets all existing scattered [...] = value sites keep working without manual edits; hot loops can iterate only the relevant index container.

Example (concise implementation sketch):

template<std::size_t N>
struct StatusArray {
    struct Proxy { StatusArray& s; std::size_t i;
                   operator int() const { return s.data[i]; }
                   Proxy& operator=(int v) { s.set(i,v); return *this; } };
    std::array<int8_t,N> data{};
    std::unordered_set<std::size_t> idx1, idx2, idxNeg;
    Proxy operator[](std::size_t i) { return Proxy{*this,i}; }
    void set(std::size_t i, int v) {
        int old = data[i]; if (old==v) return;
        if (old==1) idx1.erase(i); else if (old==2) idx2.erase(i); else if (old==-1) idxNeg.erase(i);
        data[i]=v;
        if (v==1) idx1.insert(i); else if (v==2) idx2.insert(i); else if (v==-1) idxNeg.insert(i);
    }
    const std::unordered_set<std::size_t>& indices_for(int v) const {
        if (v==1) return idx1; if (v==2) return idx2; if (v==-1) return idxNeg;
        static const std::unordered_set<std::size_t> empty; return empty;
    }
};

Important notes: measure after the change — for very small N (like 75) an unordered_set’s overhead can outweigh savings, so benchmark both approaches. If you need faster removals and iteration order, use a vector+index-map (swap-remove) instead of unordered_set. For threaded code, protect sets/assignments with locks or use atomics. Replacing the raw array with this wrapper is usually the least invasive route when update sites are scattered.

Member Avatar for andor

Try to write it on your own and when you have some code than we'll help you about the optimisation

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.