std::map und performance, schneidende Sätze

Ich bin kreuzenden einige Sätze von zahlen, und tun dies durch das speichern einer Anzahl von jedes mal, wenn ich eine Zahl sehen, die in einer Karte.

Ich finde die Leistung sehr langsam.

Details:
- Eines der sets hat 150.000 zahlen
- Der Schnittpunkt der dass-Satz und ein weiterer Satz dauert etwa 300ms ersten mal, und über 5000ms zweiten mal
- Ich habe nicht getan, alle Profilerstellung noch, aber jedes mal, wenn ich Pause den debugger während der Kreuzung seine in malloc.c!

So, wie kann ich diese verbessern die Leistung? Schalten Sie auf eine andere Datenstruktur? Einige, wie die Verbesserung der Zuweisung von Speicher-performance der map?

Update:

Gibt es eine Möglichkeit, zu Fragen, std::map oder
boost::unordered_map zu pre-allocate
etwas Platz?
Oder gibt es irgendwelche Tipps, wie Sie mit diesen effizient?

Update2:

Sehen Schnelle C++ - container wie die C# HashSet<T> und Dictionary<K V>?

Update3:

Ich ein Benchmark set_intersection und bekam schreckliche Ergebnisse:

(set_intersection) Found 313 values in the intersection, in 11345ms
(set_intersection) Found 309 values in the intersection, in 12332ms

Code:

int runIntersectionTestAlgo()
{   

    set<int> set1;
    set<int> set2;
    set<int> intersection;


    //Create 100,000 values for set1
    for ( int i = 0; i < 100000; i++ )
    {
        int value = 1000000000 + i;
        set1.insert(value);
    }

    //Create 1,000 values for set2
    for ( int i = 0; i < 1000; i++ )
    {
        int random = rand() % 200000 + 1;
        random *= 10;

        int value = 1000000000 + random;
        set2.insert(value);
    }

    set_intersection(set1.begin(),set1.end(), set2.begin(), set2.end(), inserter(intersection, intersection.end()));

    return intersection.size(); 
}

Ich empfehle Sie profile erstellen, um mehr Informationen sammeln. Wenn Sie die große Datenstrukturen, die malloc-Sache ist eine Möglichkeit.
Wenn ich kommentieren die Einsätze und suchen in der Karte und drehen Sie einfach durch meine sets geht die Zeit Weg nach unten. 90% der Zeit damit verbracht wird, in der Karte. Ich habe versucht, schalten auf boost::unordered_map, Gleiches Ergebnis.
HI Alex, also, was war deine Finale version ? Immer noch mit std::set ? Oder eine sortierte Vektor ? [Interesse] Danke.

InformationsquelleAutor Alex Black | 2009-06-29

c++intersection map stl

3

Sollten Sie auf jeden Fall mit Feste Vektoren, die den Weg schneller. Das problem mit machen set Kreuzung mit der stl-sets ist, dass jedes mal, wenn Sie verschieben, um das nächste element, das Sie jagen einen dynamisch zugewiesenen Zeiger, das konnte einfach nicht sein, in Ihrer CPU-caches. Mit einem Vektor das nächste element wird oft im cache, weil es körperlich sehr nahe zu dem vorherigen element.

Den trick mit Vektoren, ist, dass wenn Sie nicht preallocate die Erinnerung für eine Aufgabe wie diese, werde es durchführen NOCH SCHLIMMER, denn es gehe auf die Neuzuweisung von Speicher, wie es ändert sich während Ihrer Initialisierung Schritt.

Versuchen, so etwas wie dieses, nur - es wird schneller.
```
int runIntersectionTestAlgo() { 

vector<char> vector1; vector1.reserve(100000);
vector<char> vector2; vector2.reserve(1000);

//Create 100,000 values for set1
for ( int i = 0; i < 100000; i++ )    {
    int value = 1000000000 + i;
    set1.push_back(value);
}

sort(vector1.begin(), vector1.end());

//Create 1,000 values for set2
for ( int i = 0; i < 1000; i++ )    {
    int random = rand() % 200000 + 1;
    random *= 10;
    int value = 1000000000 + random;
    set2.push_back(value);
}

sort(vector2.begin(), vector2.end());

//Reserve at most 1,000 spots for the intersection
vector<char> intersection; intersection.reserve(min(vector1.size(),vector2.size()));
set_intersection(vector1.begin(), vector1.end(),vector2.begin(), vector2.end(),back_inserter(intersection));

return intersection.size(); 
}
```
- Hi Chris, wie ist das anders als meinen aktuellen code? Der neueste code wird die reserve Platz in der Vektoren überschreitet, werden die Vektoren in set_intersection etc.
- sorry, siehe diesen thread: stackoverflow.com/questions/1060648/... es verwendet den Ansatz, den Sie beschrieben, und ist auf jeden Fall schneller.
InformationsquelleAutor Chris Harris
1

Ohne zu wissen, mehr über Ihr problem, "check mit eine gute profiler" ist der beste general beraten, ich geben kann. Darüber hinaus...

Wenn der Speicher dein problem ist, wechseln Sie zu einer Art von Pool-Zuweisung, reduziert Aufrufe von malloc. Boost hat eine Reihe von benutzerdefinierten allocators, der sollte kompatibel sein mit std::allocator<T>. In der Tat, Sie können sogar versuchen, diese vor-profiling, wenn Sie haben bereits bemerkt debug-break-Proben, an deren Ende immer in malloc.

Wenn Ihre Zahl-Raum ist bekannt, dicht sein, können Sie wechseln, um mit einem vector- oder bitset-basierte Implementierung, Verwendung der zahlen als Indizes im Vektor.

Wenn Ihre Zahl-Raum ist meist karg, aber hat einige Natürliche clustering (dies ist ein großer wenn), Sie können wechseln, um ein map-of-Vektoren. Verwenden höherwertigen bits für die map-Indizierung, und lower-order bits für die Vektor-Indizierung. Dies ist funktionell sehr ähnlich einfach mit einem Pool-Zuweisung, aber es ist wahrscheinlich, um Ihnen eine bessere caching-Verhalten. Dies macht Sinn, da Sie die Bereitstellung von mehr Informationen, um die Maschine (clustering ist die explizite und cache-freundlich, eher als eine zufällige Verteilung, die man erwarten würde von der pool-Zuweisung).

InformationsquelleAutor Tom
1

Ich würde den zweiten Vorschlag, um Sie zu Sortieren. Es gibt bereits STL-set-algorithmen arbeiten auf sortierten Bereichen (wie set_intersection, set_union, etc):

set_intersection
- Ich könnte das versuchen, aber das erfordert, dass ich erhalten jeden Satz zuerst, und Sie zu Sortieren. Ich habe die Anwendung dieser gleichen Algorithmus in C# mit HashSet<int> und es ist rasend schnell.
- Die C# - Algorithmus ausgeführt wird, gegen die gleichen Daten zu. Ist C# memory allocation schneller? Oder ist HashSet schneller als Karte/hash_map/unordered_map?
InformationsquelleAutor
1

Ich verstehe nicht, warum Sie noch auf der Karte zu tun, Kreuzung. Wie die Leute gesagt haben, Sie könnten die Sätze in std::set's, und verwenden Sie dann std::set_intersection().

Oder Sie können Sie in hash_set's. Aber dann müsste man zur Umsetzung Kreuzung manuell: technisch Sie müssen nur eines der sets in einer hash_set, und dann eine Schleife durch die andere, und zu testen, wenn jedes element enthalten ist, in der hash_set.
- Ich habe versucht, set_intersection, bekam schreckliche Ergebnisse.
InformationsquelleAutor newacct
0

Kreuzung mit der Karten sind langsam, versuchen Sie, einen hash_map. (dies ist jedoch nicht in allen STL-Implementierung.

Alternativ Sortieren Sie die beiden anzeigen, und tun es in einer merge-sort-wie Weg.
- Ich habe versucht, hash_map und boost::unordered_map, die ähnliche schlechte Leistung.
InformationsquelleAutor J-16 SDiZ
0

Was ist Ihr Schnittpunkt-Algorithmus? Vielleicht gibt es einige Verbesserungen gemacht werden?

Hier ist eine Alternative Methode

Ich weiß es nicht schneller oder langsamer, aber es könnte sein, etwas zu versuchen. Bevor Sie dies tun, empfehle ich auch mit einem profiler, um sicherzustellen, Sie arbeiten wirklich auf den hotspot. Ändern Sie die Sätze von zahlen, die Sie werden verschneiden zu verwenden std::set<int> statt. Dann Durchlaufen Sie die kleinsten sucht bei jedem Wert, den Sie finden. Für jeden Wert in den kleinsten Satz, verwenden Sie die find Methode, um festzustellen, ob die Anzahl in jedem der anderen Sätze (für die Leistung, Suche vom kleinsten zum größten).

Dieser ist optimiert in dem Fall, dass die Nummer nicht gefunden in all den sets, also wenn die Schnittmenge ist relativ klein, kann es schnell sein.

Speichern Sie dann die Kreuzung in std::vector<int> statt - insertion mit push_back ist auch sehr schnell.

Hier ist eine weitere Alternative Methode

Ändern Sie die Sätze von zahlen zu std::vector<int> und verwenden std::sort Sortieren vom kleinsten zum größten. verwenden Sie Dann std::binary_search zu finden, die Werte, mit ungefähr der gleichen Methode wie oben. Dies kann schneller sein als die Suche nach einem std::set da das array mehr dicht gepackt in den Speicher. Eigentlich nie daran, dass Sie können Sie dann einfach Durchlaufen und die Werte in lock-step, Blick auf diejenigen, die mit dem gleichen Wert. Inkrement nur die Iteratoren, die kleiner sind als der minimale Wert, den Sie sah, die Sie im vorhergehenden Schritt (wenn die Werte unterschiedlich waren).
- Ich habe N-Iteratoren, eine für jeden Satz. Jedes mal, wenn durch eine Schleife, die ich vorher jeden iterator, erhöht die Anzahl der Zeiten ich habe gesehen, jeden Wert, einmal einen Wert der Zähler bei N habe ich dann gefunden, ein Wert, der vorhanden ist in allen sets. Ich verwende einen std:map<int,int> zu verfolgen, zählt jeder Wert.
- Für deine zweite Sache, das ist genau das, was std::set_intersection bereits tut. Und für dein erstes, es dauert wie O(m*log(n)), was nicht effizient ist, wenn Sie bereits std::sets (sortiert Behälter), so dass Sie konnte einfach std::set_intersection, was O(m+n).
- set_intersection entwickelte sich sehr langsam in meinem benchmark.
- mit set_intersection mit tatsächlichen std::set ist wahrscheinlich, schlecht zu sein. Ich würde versuchen, mit Vektoren anstelle sortiert
- Der neueste code verwendet sortierte Vektoren.
- Sind Sie immer noch einsetzen in ein set? Oder ein Vektor? Ich denke, Sie wollen sich einsetzen in ein Vektor - Sie können die Größe des Vektors, bevor Sie laufen, so dass der Speicher für den Vektor muss nicht neu vergeben werden. Sind Sie immer noch verbringen die meiste Zeit in malloc? Wenn dem so ist, dann preallocating den Vektor, den Sie einfügen, wird in schneller
InformationsquelleAutor 1800 INFORMATION
0

Könnte Ihr Algorithmus. Wie ich es verstehe, Sie sind Spinnen über jeden Satz (was ich hoffe, ist ein standard-set), und wirft Sie in noch eine weitere Karte. Dies macht eine Menge Arbeit, Sie brauchen nicht zu tun, da die Tasten einer standard-set sind in sortierter Reihenfolge schon. Stattdessen nehmen Sie eine "merge-sort" wie Ansatz. Spin über jede iter, array-Dereferenzierung zu finden, die min. Zählen Sie die Zahl haben, die min, und erhöhen diese. Wenn die Zählung N, fügen Sie es zu der Kreuzung. Wiederholen Sie dies, bis die erste Karte, die trifft es am Ende (Wenn Sie vergleichen Sie die Größen, bevor Sie beginnen, werden Sie nicht haben, um zu überprüfen, jede Karte, die end-jeder Zeit).

Reagieren zu aktualisieren: Es existieren die Fakultäten, speed up memory allocation durch die vor-Reservierung von Raum, wie boost::pool_alloc. So etwas wie:
```
std::map<int, int, std::less<int>, boost::pool_allocator< std::pair<int const, int> > > m;
```
Aber ehrlich gesagt, malloc ist ziemlich gut in dem, was es tut; ich würde das Profil, bevor Sie etwas zu extrem.
- Das ist eine gute Idee... aber jetzt meine sets nicht sortiert. Ich könnte versuchen, Sortieren Sie zuerst.
- Ein paar mehr Informationen auf was diese "Sätze" Sie sind intersectioning hilfreich sein könnten - sind Sie wie Vektoren?
- Sie werden in ein in-memory-Datenbank, Sie sind Listen von zahlen, ich hatte gehofft, nicht zu haben, um den gesamten Satz in einer Datenstruktur und sortiert, bevor Sie schneiden Sie.
- Ich werde versuchen heraus boost::pool_alloc nur um zu sehen, ob es einen Unterschied macht.
- Ich versuchte es mit boost::pool_alloc und boost::fast_pool_alloc auf mein boost:: unordered_map und Leistung VIEL langsamer.
InformationsquelleAutor Todd Gardner
0

Blick auf Ihre algorithmen, dann wählen Sie den richtigen Datentyp. Wenn Sie gehen, um set Verhalten, und wollen zu tun, Kreuzungen und dergleichen, std::set ist der container zu verwenden.

Da es Elemente gespeichert sind, in einer geordneten Art und Weise, einsetzen kann, kostet Sie O(log N), aber Kreuzung mit einem anderen (nicht sortiert!) std::set getan werden kann in linearer Zeit.

InformationsquelleAutor xtofl
0

Ich etwas herausgefunden: wenn ich den debugger, um entweder zu RELEASE oder DEBUG-builds (z.B. F5 in der IDE), dann bekomme ich schreckliche Zeiten.

InformationsquelleAutor Alex Black

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Hier ist eine Alternative Methode

Hier ist eine weitere Alternative Methode