Avoiding Checking likely if

Question

Given the following:

class ReadWrite {
public:
    int Read(size_t address);
    void Write(size_t address, int val);
private:
    std::map<size_t, int> db;
}

In read function when accessing an address which no previous write was made to I want to either throw exception designating such error or allow that and return 0, in other words I would like to either use std::map<size_t, int>::operator[]() or std::map<size_t, int>::at(), depending on some bool value which user can set. So I add the following:

class ReadWrite {
public:
    int Read(size_t add) { if (allow) return db[add]; return db.at(add);}
    void Write(size_t add, int val) { db[add] = val; }
    void Allow() { allow = true; }
private:
    bool allow = false;
    std::map<size_t, int> db;
}

The problem with that is: Usually, the program will have one call of allow or none at the beginning of the program and then afterwards many accesses. So, performance wise, this code is bad because it every-time performs the check if (allow) where usually it's either always true or always false. So how would you solve such problem?

Edit:

While the described use case (one or none Allow() at first) of this class is very likely it's not definite and so I must allow user call Allow() dynamically.

Another Edit:

Solutions which use function pointer: What about the performance overhead incurred by using function pointer which is not able to make inline by the compiler? If we use std::function instead will that solve the issue?

Answer 1

Usually, the program will have one call of allow or none at the beginning of the program and then afterwards many accesses. So, performance wise, this code is bad because it every-time performs the check if (allow) where usually it's either always true or always false. So how would you solve such problem?

I won't, The CPU will.
the Branch Prediction will figure out that the answer is most likely to be same for some long time so it will able to optimize the branch in the hardware level very much. it will still incur some overhead, but very negligible.

If you really need to optimize your program, I think your better use std::unordered_map instead of std::map, or move to some faster map implementation, like google::dense_hash_map. the branch is insignificant compared to map-lookup.

Answer 2

If you want to decrease the time-cost, you have to increase the memory-cost. Accepting that, you can do this with a function pointer. Below is my answer:

class ReadWrite {
public:
   void Write(size_t add, int val) { db[add] = val; }
   // when allowed, make the function pointer point to read2
   void Allow() { Read = &ReadWrite::read2;}
   //function pointer that points to read1 by default
   int (ReadWrite::*Read)(size_t) = &ReadWrite::read1;
private: 
   int read1(size_t add){return db.at(add);}
   int read2(size_t add) {return db[add];}
   std::map<size_t, int> db;
};

The function pointer can be called as the other member functions. As an example:

ReadWrite rwObject;
//some code here
//...
rwObject.Read(5); //use of function pointer
//

Note that non-static data member initialization is available with c++11, so the int (ReadWrite::*Read)(size_t) = &ReadWrite::read1; may not compile with older versions. In that case, you have to explicitly declare one constructor, where the initialization of the function pointer can be done.

Answer 3

You can use a pointer to function.

class ReadWrite {
public:
    void Write(size_t add, int val) { db[add] = val; }
    int Read(size_t add) { (this->*Rfunc)(add); }
    void Allow() { Rfunc = &ReadWrite::Read2; }
private:
    std::map<size_t, int> db;
    int Read1(size_t add) { return db.at(add); }
    int Read2(size_t add) { return db[add]; }
    int (ReadWrite::*Rfunc)(size_t) = &ReadWrite::Read1;
}

Answer 4

If you want runtime dynamic behaviour you'll have to pay for it at runtime (at the point you want your logic to behave dynamically).

You want different behaviour at the point where you call Read depending on a runtime condition and you'll have to check that condition. No matter whether your overhad is a function pointer call or a branch, you'll find a jump or call to different places in your program depending on allow at the point Read is called by the client code.

Note: Profile and fix real bottlenecks - not suspected ones. (You'll learn more if you profile by either having your suspicion confirmed or by finding out why your assumption about the performance was wrong.)