Just to clarify that I also think the title is a bit silly. We all know that most built-in functions of the language are really well written and fast (there are ones even written by assembly). Though may be there still are some advices for my situation. I have a small project which demonstrates the work of a search engine. In the indexing phase, I have a filter method to filter out unnecessary things from the keywords. It's here:

```
bool Indexer::filter(string &keyword)
{
    // Remove all characters defined in isGarbage method
    keyword.resize(std::remove_if(keyword.begin(), keyword.end(), isGarbage) - keyword.begin());

    // Transform all characters to lower case
    std::transform(keyword.begin(), keyword.end(), keyword.begin(), ::tolower);

    // After filtering, if the keyword is empty or it is contained in stop words list, mark as invalid keyword
    if (keyword.size() == 0 || stopwords_.find(keyword) != stopwords_.end())
        return false;

    return true;
}

```

At first sign, these functions (alls are member functions of STL container or standard function) are supposed to be fast and not take many time in the indexing phase. But after profiling with Valgrind, the inclusive cost of this `filter` is ridiculous high: 33.4%. There are three standard functions of this filter take most of the time for that percentage: `std::remove_if` takes 6.53%, `std::set::find` takes 15.07% and `std::transform` takes 7.71%. 

So if there are any thing I can do (or change) to reduce the instruction times cost by this filter (like using parallellizing or something like that), please give me your advice. Thanks in advance. 

UPDATE: Thanks for all your suggestion. So in brief, I've summarize what I need to do is:
1) Merge `tolower` and `remove_if` into one by construct my own loop.
2) Use `unordered_set` instead of `set` for faster `find` method.
Thus I've chosen `Mark_B`'s as the right answer.