Developer forums (C::B DEVELOPMENT STRICTLY!) > CodeCompletion redesign
patch : from std::map replace to hashmap
Jenna:
--- Quote from: Loaden on March 21, 2010, 04:25:46 pm ---@ jens , Can you test this demo in linux?
--- End quote ---
I changed the code a little bit to get some more output on the console:
--- Code: ---#include <iostream>
#include <map>
#include <wx/hashmap.h>
#include <wx/string.h>
#include <wx/stopwatch.h>
WX_DECLARE_STRING_HASH_MAP(wxString, wxHashString);
int main()
{
wxHashString hashMap;
hashMap[_T("_GLIBCXX_STD")] = _T("std");
hashMap[_T("_GLIBCXX_BEGIN_NESTED_NAMESPACE")] = _T("+namespace");
hashMap[_T("_GLIBCXX_BEGIN_NAMESPACE")] = _T("+namespace");
hashMap[_T("_GLIBCXX_END_NESTED_NAMESPACE")] = _T("}");
hashMap[_T("_GLIBCXX_END_NAMESPACE")] = _T("}");
hashMap[_T("_GLIBCXX_END_NAMESPACE_TR1")] = _T("}");
hashMap[_T("_GLIBCXX_BEGIN_NAMESPACE_TR1")] = _T("-namespace tr1 {");
hashMap[_T("_GLIBCXX_STD2")] = _T("2std");
hashMap[_T("_GLIBCXX_BEGIN_NESTED_NAMESPACE2")] = _T("2+namespace");
hashMap[_T("_GLIBCXX_BEGIN_NAMESPACE2")] = _T("2+namespace");
hashMap[_T("_GLIBCXX_END_NESTED_NAMESPACE2")] = _T("2}");
hashMap[_T("_GLIBCXX_END_NAMESPACE2")] = _T("2}");
hashMap[_T("_GLIBCXX_END_NAMESPACE_TR12")] = _T("2}");
hashMap[_T("_GLIBCXX_BEGIN_NAMESPACE_TR12")] = _T("2-namespace tr1 {");
hashMap[_T("_CXX_STD")] = _T("std");
hashMap[_T("_CXX_BEGIN_NESTED_NAMESPACE")] = _T("+namespace");
hashMap[_T("_CXX_BEGIN_NAMESPACE")] = _T("+namespace");
hashMap[_T("_CXX_END_NESTED_NAMESPACE")] = _T("}");
hashMap[_T("_CXX_END_NAMESPACE")] = _T("}");
hashMap[_T("_CXX_END_NAMESPACE_TR1")] = _T("}");
hashMap[_T("_CXX_BEGIN_NAMESPACE_TR1")] = _T("-namespace tr1 {");
hashMap[_T("_CXX_STD2")] = _T("2std");
hashMap[_T("_CXX_BEGIN_NESTED_NAMESPACE2")] = _T("2+namespace");
hashMap[_T("_CXX_BEGIN_NAMESPACE2")] = _T("2+namespace");
hashMap[_T("_CXX_END_NESTED_NAMESPACE2")] = _T("2}");
hashMap[_T("_CXX_END_NAMESPACE2")] = _T("2}");
hashMap[_T("_CXX_END_NAMESPACE_TR12")] = _T("2}");
hashMap[_T("_CXX_BEGIN_NAMESPACE_TR12")] = _T("2-namespace tr1 {");
std::map<wxString, wxString> stdMap;
stdMap[_T("_GLIBCXX_STD")] = _T("std");
stdMap[_T("_GLIBCXX_BEGIN_NESTED_NAMESPACE")] = _T("+namespace");
stdMap[_T("_GLIBCXX_BEGIN_NAMESPACE")] = _T("+namespace");
stdMap[_T("_GLIBCXX_END_NESTED_NAMESPACE")] = _T("}");
stdMap[_T("_GLIBCXX_END_NAMESPACE")] = _T("}");
stdMap[_T("_GLIBCXX_END_NAMESPACE_TR1")] = _T("}");
stdMap[_T("_GLIBCXX_BEGIN_NAMESPACE_TR1")] = _T("-namespace tr1 {");
stdMap[_T("_GLIBCXX_STD2")] = _T("2std");
stdMap[_T("_GLIBCXX_BEGIN_NESTED_NAMESPACE2")] = _T("2+namespace");
stdMap[_T("_GLIBCXX_BEGIN_NAMESPACE2")] = _T("2+namespace");
stdMap[_T("_GLIBCXX_END_NESTED_NAMESPACE2")] = _T("2}");
stdMap[_T("_GLIBCXX_END_NAMESPACE2")] = _T("2}");
stdMap[_T("_GLIBCXX_END_NAMESPACE_TR12")] = _T("2}");
stdMap[_T("_GLIBCXX_BEGIN_NAMESPACE_TR12")] = _T("2-namespace tr1 {");
stdMap[_T("_CXX_STD")] = _T("std");
stdMap[_T("_CXX_BEGIN_NESTED_NAMESPACE")] = _T("+namespace");
stdMap[_T("_CXX_BEGIN_NAMESPACE")] = _T("+namespace");
stdMap[_T("_CXX_END_NESTED_NAMESPACE")] = _T("}");
stdMap[_T("_CXX_END_NAMESPACE")] = _T("}");
stdMap[_T("_CXX_END_NAMESPACE_TR1")] = _T("}");
stdMap[_T("_CXX_BEGIN_NAMESPACE_TR1")] = _T("-namespace tr1 {");
stdMap[_T("_CXX_STD2")] = _T("2std");
stdMap[_T("_CXX_BEGIN_NESTED_NAMESPACE2")] = _T("2+namespace");
stdMap[_T("_CXX_BEGIN_NAMESPACE2")] = _T("2+namespace");
stdMap[_T("_CXX_END_NESTED_NAMESPACE2")] = _T("2}");
stdMap[_T("_CXX_END_NAMESPACE2")] = _T("2}");
stdMap[_T("_CXX_END_NAMESPACE_TR12")] = _T("2}");
stdMap[_T("_CXX_BEGIN_NAMESPACE_TR12")] = _T("2-namespace tr1 {");
int stdMapTime=0;
int hashMapTime=0;
wxStopWatch sw;
for(int j = 0; j < 10 ; j++)
{
sw.Start();
for (int i = 0; i < 20000000; ++i)
{
stdMap.find(_T("testfindkey")); // you can switch to stdMap for test
}
stdMapTime+=sw.Time();
std::cout << "stdMap took " << sw.Time() << " ms" << std::endl;
sw.Start();
for (int i = 0; i < 20000000; ++i)
{
hashMap.find(_T("testfindkey")); // you can switch to stdMap for test
}
hashMapTime+=sw.Time();
std::cout << "hashMap took " << sw.Time() << " ms" << std::endl;
}
std::cout << "average (stdMap): " << stdMapTime / 10 << " ms" << std::endl;
std::cout << "average (hashMap): " << hashMapTime / 10 << " ms" << std::endl;
std::cout << "100 * (" << hashMapTime << "-" << stdMapTime << ") / " << hashMapTime << " = : " << 100 * (hashMapTime-stdMapTime) / hashMapTime << " %" << std::endl;
return 0;
}
--- End code ---
Here is the output from debug-version:
--- Code: ---stdMap took 6627 ms
hashMap took 5962 ms
stdMap took 6636 ms
hashMap took 5988 ms
stdMap took 6640 ms
hashMap took 6019 ms
stdMap took 6680 ms
hashMap took 6017 ms
stdMap took 6677 ms
hashMap took 6119 ms
stdMap took 6722 ms
hashMap took 6010 ms
stdMap took 6664 ms
hashMap took 6062 ms
stdMap took 6793 ms
hashMap took 6044 ms
stdMap took 6671 ms
hashMap took 6032 ms
stdMap took 6683 ms
hashMap took 6035 ms
average (stdMap): 6679 ms
average (hashMap): 6028 ms
100 * (60288-66793) / 60288 = : -10 %
Process returned 0 (0x0) execution time : 127.129 s
Press ENTER to continue.
--- End code ---
and here the output from the release-version with -O2 optimization:
--- Code: ---stdMap took 2599 ms
hashMap took 3312 ms
stdMap took 2624 ms
hashMap took 3320 ms
stdMap took 2590 ms
hashMap took 3315 ms
stdMap took 2585 ms
hashMap took 3318 ms
stdMap took 2580 ms
hashMap took 3310 ms
stdMap took 2577 ms
hashMap took 3297 ms
stdMap took 2614 ms
hashMap took 3298 ms
stdMap took 2577 ms
hashMap took 3302 ms
stdMap took 2573 ms
hashMap took 3304 ms
stdMap took 2568 ms
hashMap took 3303 ms
average (stdMap): 2588 ms
average (hashMap): 3307 ms
100 * (33079-25887) / 33079 = : 21 %
Process returned 0 (0x0) execution time : 59.013 s
Press ENTER to continue.
--- End code ---
It seems that the STL-map can be better optimized (at least on linux), maybe we should think about a real release-version of C::B (for windows), not just a stripped version.
MortenMacFly:
--- Quote from: jens on March 21, 2010, 08:18:43 pm ---It seems that the STL-map can be better optimized (at least on linux), maybe we should think about a real release-version of C::B (for windows), not just a stripped version.
--- End quote ---
What do you mean: compiling C::B with optimization flags enabled?
Jenna:
--- Quote from: MortenMacFly on March 21, 2010, 08:30:03 pm ---
--- Quote from: jens on March 21, 2010, 08:18:43 pm ---It seems that the STL-map can be better optimized (at least on linux), maybe we should think about a real release-version of C::B (for windows), not just a stripped version.
--- End quote ---
What do you mean: compiling C::B with optimization flags enabled?
--- End quote ---
Yes, if automake-system is used, C::B is compiled with -O2 and batch-parsing is significantly faster than without optimization.
You can see it in my first post in this thread (http://forums.codeblocks.org/index.php/topic,12235.msg83070.html#msg83070), batch-parsing of linux kernel-code is about 50 % faster, if C::B is build with automake-system, for Loadens sample code the speedup is nearly 70 %.
oBFusCATed:
Hah, you don't use optimizations on windows! :shock:
Keep in mind that gcc can generate wrong code in optimization mode lower that -O2 ... I've seen reports for -O0
Loaden:
Yes, I don't use -O2, because Code-Completion plugin not use -O2 too. :lol:
Here is another demo, I wonder is: gnu's hash_map is so efficient, even when use -O2.
--- Code: ---#include <iostream>
#include <map>
#include <string>
#ifdef __GNUC__
#include <ext/hash_map>
#else
#include <hash_map>
#endif
#include <wx/hashmap.h>
#include <wx/string.h>
#include <wx/timer.h>
namespace std
{
using namespace __gnu_cxx;
}
namespace __gnu_cxx
{
template<> struct hash< std::string >
{
size_t operator()( const std::string& x ) const
{
return hash< const char* >()( x.c_str() );
}
};
}
//namespace __gnu_cxx
//{
//template<> struct hash< wxString >
//{
// size_t operator()( const wxString& x ) const
// {
// return hash< const wxChar* >()( x.c_str() );
// }
//};
//}
WX_DECLARE_STRING_HASH_MAP(wxString, wxHashString);
int main()
{
wxHashString hashMap;
hashMap[_T("_GLIBCXX_STD")] = _T("std");
hashMap[_T("_GLIBCXX_BEGIN_NESTED_NAMESPACE")] = _T("+namespace");
hashMap[_T("_GLIBCXX_BEGIN_NAMESPACE")] = _T("+namespace");
hashMap[_T("_GLIBCXX_END_NESTED_NAMESPACE")] = _T("}");
hashMap[_T("_GLIBCXX_END_NAMESPACE")] = _T("}");
hashMap[_T("_GLIBCXX_END_NAMESPACE_TR1")] = _T("}");
hashMap[_T("_GLIBCXX_BEGIN_NAMESPACE_TR1")] = _T("-namespace tr1 {");
hashMap[_T("_GLIBCXX_STD2")] = _T("2std");
hashMap[_T("_GLIBCXX_BEGIN_NESTED_NAMESPACE2")] = _T("2+namespace");
hashMap[_T("_GLIBCXX_BEGIN_NAMESPACE2")] = _T("2+namespace");
hashMap[_T("_GLIBCXX_END_NESTED_NAMESPACE2")] = _T("2}");
hashMap[_T("_GLIBCXX_END_NAMESPACE2")] = _T("2}");
hashMap[_T("_GLIBCXX_END_NAMESPACE_TR12")] = _T("2}");
hashMap[_T("_GLIBCXX_BEGIN_NAMESPACE_TR12")] = _T("2-namespace tr1 {");
hashMap[_T("_XXGLIBCXX_END_NAMESPACE_TR12")] = _T("X2}");
hashMap[_T("_XXGLIBCXX_BEGIN_NAMESPACE_TR12")] = _T("X2-namespace tr1 {");
std::map<wxString, wxString> stdMap;
stdMap[_T("_GLIBCXX_STD")] = _T("std");
stdMap[_T("_GLIBCXX_BEGIN_NESTED_NAMESPACE")] = _T("+namespace");
stdMap[_T("_GLIBCXX_BEGIN_NAMESPACE")] = _T("+namespace");
stdMap[_T("_GLIBCXX_END_NESTED_NAMESPACE")] = _T("}");
stdMap[_T("_GLIBCXX_END_NAMESPACE")] = _T("}");
stdMap[_T("_GLIBCXX_END_NAMESPACE_TR1")] = _T("}");
stdMap[_T("_GLIBCXX_BEGIN_NAMESPACE_TR1")] = _T("-namespace tr1 {");
stdMap[_T("_GLIBCXX_STD2")] = _T("2std");
stdMap[_T("_GLIBCXX_BEGIN_NESTED_NAMESPACE2")] = _T("2+namespace");
stdMap[_T("_GLIBCXX_BEGIN_NAMESPACE2")] = _T("2+namespace");
stdMap[_T("_GLIBCXX_END_NESTED_NAMESPACE2")] = _T("2}");
stdMap[_T("_GLIBCXX_END_NAMESPACE2")] = _T("2}");
stdMap[_T("_GLIBCXX_END_NAMESPACE_TR12")] = _T("2}");
stdMap[_T("_GLIBCXX_BEGIN_NAMESPACE_TR12")] = _T("2-namespace tr1 {");
stdMap[_T("_XXGLIBCXX_END_NAMESPACE_TR12")] = _T("X2}");
stdMap[_T("_XXGLIBCXX_BEGIN_NAMESPACE_TR12")] = _T("X2-namespace tr1 {");
std::hash_map<std::string, std::string> hashMap2;
hashMap2["_GLIBCXX_STD"] = "std";
hashMap2["_GLIBCXX_BEGIN_NESTED_NAMESPACE"] = "+namespace";
hashMap2["_GLIBCXX_BEGIN_NAMESPACE"] = "+namespace";
hashMap2["_GLIBCXX_END_NESTED_NAMESPACE"] = "}";
hashMap2["_GLIBCXX_END_NAMESPACE"] = "}";
hashMap2["_GLIBCXX_END_NAMESPACE_TR1"] = "}";
hashMap2["_GLIBCXX_BEGIN_NAMESPACE_TR1"] = "-namespace tr1 {";
hashMap2["_GLIBCXX_STD2"] = "2std";
hashMap2["_GLIBCXX_BEGIN_NESTED_NAMESPACE2"] = "2+namespace";
hashMap2["_GLIBCXX_BEGIN_NAMESPACE2"] = "2+namespace";
hashMap2["_GLIBCXX_END_NESTED_NAMESPACE2"] = "2}";
hashMap2["_GLIBCXX_END_NAMESPACE2"] = "2}";
hashMap2["_GLIBCXX_END_NAMESPACE_TR12"] = "2}";
hashMap2["_GLIBCXX_BEGIN_NAMESPACE_TR12"] = "2-namespace tr1 {";
hashMap2["_XXGLIBCXX_END_NAMESPACE_TR12"] = "X2}";
hashMap2["_XXGLIBCXX_BEGIN_NAMESPACE_TR12"] = "X2-namespace tr1 {";
std::map<std::string, std::string> stdMap2;
stdMap2["_GLIBCXX_STD"] = "std";
stdMap2["_GLIBCXX_BEGIN_NESTED_NAMESPACE"] = "+namespace";
stdMap2["_GLIBCXX_BEGIN_NAMESPACE"] = "+namespace";
stdMap2["_GLIBCXX_END_NESTED_NAMESPACE"] = "}";
stdMap2["_GLIBCXX_END_NAMESPACE"] = "}";
stdMap2["_GLIBCXX_END_NAMESPACE_TR1"] = "}";
stdMap2["_GLIBCXX_BEGIN_NAMESPACE_TR1"] = "-namespace tr1 {";
stdMap2["_GLIBCXX_STD2"] = "2std";
stdMap2["_GLIBCXX_BEGIN_NESTED_NAMESPACE2"] = "2+namespace";
stdMap2["_GLIBCXX_BEGIN_NAMESPACE2"] = "2+namespace";
stdMap2["_GLIBCXX_END_NESTED_NAMESPACE2"] = "2}";
stdMap2["_GLIBCXX_END_NAMESPACE2"] = "2}";
stdMap2["_GLIBCXX_END_NAMESPACE_TR12"] = "2}";
stdMap2["_GLIBCXX_BEGIN_NAMESPACE_TR12"] = "2-namespace tr1 {";
stdMap2["_XXGLIBCXX_END_NAMESPACE_TR12"] = "X2}";
stdMap2["_XXGLIBCXX_BEGIN_NAMESPACE_TR12"] = "X2-namespace tr1 {";
for (int i = 0; i < 5; ++i)
{
wxStartTimer();
for (int j = 0; j < 10000000; ++j) stdMap.find(_T("testfindkey"));
std::cout << "stdMap " << i + 1 << " : " << wxGetElapsedTime() << std::endl;
}
std::cout << "\n---------------\n" << std::endl;
for (int i = 0; i < 5; ++i)
{
wxStartTimer();
for (int j = 0; j < 10000000; ++j) hashMap.find(_T("testfindkey"));
std::cout << "hashMap " << i + 1 << " : " << wxGetElapsedTime() << std::endl;
}
std::cout << "\n---------------\n" << std::endl;
for (int i = 0; i < 5; ++i)
{
wxStartTimer();
for (int j = 0; j < 10000000; ++j) stdMap2.find("testfindkey");
std::cout << "stdMap2 " << i + 1 << " : " << wxGetElapsedTime() << std::endl;
}
std::cout << "\n---------------\n" << std::endl;
for (int i = 0; i < 5; ++i)
{
wxStartTimer();
for (int j = 0; j < 10000000; ++j) hashMap2.find("testfindkey");
std::cout << "hashMap2 " << i + 1 << " : " << wxGetElapsedTime() << std::endl;
}
return 0;
}
--- End code ---
--- Code: ---stdMap 1 : 2281
stdMap 2 : 2266
stdMap 3 : 2281
stdMap 4 : 2266
stdMap 5 : 2265
---------------
hashMap 1 : 2375
hashMap 2 : 2360
hashMap 3 : 2359
hashMap 4 : 2359
hashMap 5 : 2360
---------------
stdMap2 1 : 3578
stdMap2 2 : 3578
stdMap2 3 : 3594
stdMap2 4 : 3578
stdMap2 5 : 3594
---------------
hashMap2 1 : 2421
hashMap2 2 : 2422
hashMap2 3 : 2422
hashMap2 4 : 2422
hashMap2 5 : 2422
Process returned 0 (0x0) execution time : 53.531 s
Press any key to continue.
--- End code ---
However, I can NOT compiled std::hash_map<wxString, wxString>, who knows how to solution?
Thanks!
[attachment deleted by admin]
Navigation
[0] Message Index
[#] Next page
[*] Previous page
Go to full version