为什么在C ++中复制无序映射比较慢？

Question

I'm writing code on a ARM cortex A9 for a real time robotics application. I'm experiencing some timing issues with my interrupts. I am copying a global variable into the interrupt which takes 20us on an interrupt at 20kHz. That leaves me about 40us for the idle.. Just copying takes 20us!

So my question is why copying an unordered map into another unordered map take so much time?

class Supervisor {
private:
    DispatchCommunication dispatchComm;
    DispatchLogic dispatchLogic;

    std::unordered_map<std::string, uint32_t> fetchedData;
public:
    void initialize(void);
    void communication(void);
    void logic(void);
};

inline void Supervisor::initialize(void) {
    dispatchComm.initialize();

    dispatchLogic.initialize();    
}

/**
 * Get all sensor data
 */
inline void Supervisor::communication(void) {

    // Create a map of the data we want to request from the communication dispatcher
    std::vector<std::string> requestMap = { "jointAngle", "motorAngle", "piggyback" };

    // Fetch the requested data
    fetchedData = dispatchComm.getDataVector(requestMap);


}

/**
 * Run all the logic
 */
inline void Supervisor::logic(void) {

    std::unordered_map<std::string, uint32_t> IRQFetchedData;

    // This part takes a whopping 20us!
    IRQFetchedData = fetchedData;

}

Answer 1

In your case, it's not just the copying of the map. It's the copying of the std::string s within the map. That means (potentially) lots of memory allocations. And even without those allocations (small-string optimization), it's still lots of copying of string data.

And that's all on top of the copying needed for the map itself, which involves its own series of allocations, based on bucket sizes, the various heap implementation strategies, etc.

If fast copying is something you need, then perhaps a sorted vector would be more appropriate, rather than an unordered_map . That won't help the string copying issue, but it can help the cost of copying the map itself. You can even speed that up by using a fixed-length string class, which could be trivially copyable. That could make copying the entire vector a single memory allocation followed by a single memcpy .

Of course, it is (theoretically) slower to access a value from a sorted vector than an unordered_map . But that's the give-and-take when it comes to performance. Fast copying or fast access; which matters to you? Though even fast access is theoretical, primarily mattering when such maps are large .