CODEWITHSUNDEEP
c++qtsorting
andre
andre

Reputation: 7249

std::sort is slow with small amounts of data

I'm finding that std::sort is very slow with sorting only 1000 items.

In class template template <typename T> class TableModel : public QAbstractTableModel I have the following function to sort a table.

template<typename T>
void TableModel<T>::sort(int column, Qt::SortOrder order = Qt::AscendingOrder) {
    if(order == Qt::AscendingOrder) {
        qSort(m_list.begin(), m_list.end(), less<T>(column));
    } else {
        qSort(m_list.begin(), m_list.end(), greater<T>(column));
    }
    reset();
 }

I notice if I only have the randomly shuffle my table is shuffles then displays instantly. So this leads me to think that its sort that is slow. Can anyone help me speed up the sorting of a QTable?

Here is the less struct.

template<typename T>
struct less {
    int index;
    less(int index) : index(index) {}
    bool operator()(const T& first, const T& second) {
        return T::less(first, second, index);
    }
};

T::less is a function and all it does it the less than comparison based on the index given.

Slow is defined as a 5 seconds for only 1000 items when I need to handle about 100,000 items later on.

Upvotes: 2

Views: 1697

Answers (2)

bames53
bames53

Reputation: 88155

Since m_list is a QList it does not have the same interface or performance characteristics as a normal list. For example, apparently a QList stores an array of T* internally. This representation could be sorted without any copying if the sort algorithm is aware of this implementation detail. By contrast std::sort is probably deep copying the values around, or maybe moving them, which is going to be more work than sorting pointers in the QList array.

It's probably best to use Qt containers with Qt algorithms, since Qt algorithms are more likely to be specialized for Qt containers. Or you could avoid using Qt containers and just stick with the standard library.

Anyway, try using Qt's qSort algorithm:

template<typename T>
void TableModel<T>::sort(int column, Qt::SortOrder order = Qt::AscendingOrder) {
    if(order == Qt::AscendingOrder) {
        qSort(m_list.begin(), m_list.end(), less<T>(column));
    } else {
        qSort(m_list.begin(), m_list.end(), greater<T>(column));
    }
    reset();
}

Original answer

std::sort can't take advantage of the fact that nodes in the list can be moved around without copying the element. Assuming you're using std::list or something similar, use the sort member function.

template<typename T>
void TableModel<T>::sort(int column, Qt::SortOrder order = Qt::AscendingOrder) {
    std::random_shuffle(m_list.begin(), m_list.end());
    if(order == Qt::AscendingOrder) {
       m_list.sort(less<T>(column));
    } else {
       m_list.sort(greater<T>(column));
    }
    reset();
}

If you can't do that then you may be able to optimize all those copies by making sure that your elements are move-enabled if you're using C++11.

Upvotes: 1

Mark B
Mark B

Reputation: 96243

I suspect that m_list is storing the items by value and that swapping them is expensive. You could try to either implement a faster swap or store them in the container by smart pointer.

Of course a profiler could help you pinpoint the problem much more precisely.

Upvotes: 2

Related Questions