From: Silvius Rus Date: Sat, 3 Oct 2009 02:17:41 +0000 (+0000) Subject: merge branch profile-stdlib X-Git-Tag: releases/gcc-4.5.0~3127 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=1218d701f7de691254c06b4599abab6ca7361703;p=thirdparty%2Fgcc.git merge branch profile-stdlib From-SVN: r152431 --- diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 860b20002141..a68aec525e91 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,64 @@ +2009-10-02 Silvius Rus + * configure: Add check for execinfo.h. + * config.h.in: Add undef for HAVE_EXECINFO_H. + * include/Makefile.am: Add build support for profile mode. + * include/Makefile.in: Same. + * include/profile/base.h: New file. + * include/profile/bitset: Same. + * include/profile/deque: Same. + * include/profile/hashtable.h: Same. + * include/profile/list: Same. + * include/profile/map: Same. + * include/profile/map.h: Same. + * include/profile/multimap.h: Same. + * include/profile/multiset.h: Same. + * include/profile/set: Same. + * include/profile/set.h: Same. + * include/profile/unordered_map: Same. + * include/profile/unordered_set: Same. + * include/profile/vector: Same. + * include/profile/impl/profiler.h: Same. + * include/profile/impl/profiler_container_size.h: Same. + * include/profile/impl/profiler_hash_func.h: Same. + * include/profile/impl/profiler_hashtable_size.h: Same. + * include/profile/impl/profiler_map_to_unordered_map.h: Same. + * include/profile/impl/profiler_node.h: Same. + * include/profile/impl/profiler_state.h: Same. + * include/profile/impl/profiler_trace.h: Same. + * include/profile/impl/profiler_vector_size.h: Same. + * include/profile/impl/profiler_vector_to_list.h: Same. + * include/std/vector: Include corresponding profile header guarded by + _GLIBCXX_PROFILE. + * include/std/deque: Same. + * include/std/list: Same. + * include/std/map: Same. + * include/std/unordered_map: Same. + * include/std/bitset: Same. + * include/std/set: Same. + * include/std/unordered_set: Same. + * include/backward/hash_map: Same. + * include/backward/hash_set: Same. + * include/tr1_impl/hashtable (_Hashtable): Expose insert_return_type. + * include/bits/c++config: Define profile namespace. + * testsuite/Makefile.in: Add check-profile. + * testsuite/Makefile.am: Same. + * testsuite/ext/profile/all.cc: New file. + * testsuite/ext/profile/mh.cc: Same. + * testsuite/ext/profile/mutex_extensions.cc: Same. + * testsuite/23_containers/unordered_map/profile/hash_map.cc: Same. + * testsuite/23_containers/unordered_map/profile/unordered.cc: Same. + * testsuite/23_containers/vector/profile/vector.cc: Same. + * testsuite/23_containers/vector/resize/moveable.cc: Make it pass + in profile mode. + * testsuite/23_containers/deque/capacity/moveable.cc: Same. + * testsuite/23_containers/list/capacity/29134.cc: Same. + * doc/Makefile.in: Add reference to profile_mode.xml. + * doc/Makefile.am: Same. + * doc/xml/manual/profile_mode.xml: New file. + * doc/xml/manual/debug.xml: Add link to profile mode section. + * doc/xml/manual/extensions.xml: Add profile mode. Update numbering. + * doc/doxygen/user.cfg.in: Add profile mode files. + 2009-10-02 Johannes Singler * include/parallel/base.h: Take integer types from . diff --git a/libstdc++-v3/config.h.in b/libstdc++-v3/config.h.in index 41cf9679e4be..506b00e31b29 100644 --- a/libstdc++-v3/config.h.in +++ b/libstdc++-v3/config.h.in @@ -262,6 +262,9 @@ /* Define to 1 if you have the header file. */ #undef HAVE_MEMORY_H +/* Define to 1 if you have the header file. */ +#undef HAVE_EXECINFO_H + /* Define to 1 if you have the `modf' function. */ #undef HAVE_MODF diff --git a/libstdc++-v3/configure b/libstdc++-v3/configure index 1eb77d19193d..0ba287cec5ab 100755 --- a/libstdc++-v3/configure +++ b/libstdc++-v3/configure @@ -7926,7 +7926,7 @@ fi # On IRIX 5.3, sys/types and inttypes.h are conflicting. for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ - inttypes.h stdint.h unistd.h + inttypes.h stdint.h unistd.h execinfo.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default diff --git a/libstdc++-v3/doc/Makefile.am b/libstdc++-v3/doc/Makefile.am index d53ae229b8c8..22c549c9cfec 100644 --- a/libstdc++-v3/doc/Makefile.am +++ b/libstdc++-v3/doc/Makefile.am @@ -100,6 +100,7 @@ xml_sources = \ ${xml_srcdir}/manual/numerics.xml \ ${xml_srcdir}/manual/parallel_mode.xml \ ${xml_srcdir}/manual/prerequisites.xml \ + ${xml_srcdir}/manual/profile_mode.xml \ ${xml_srcdir}/manual/internals.xml \ ${xml_srcdir}/manual/shared_ptr.xml \ ${xml_srcdir}/manual/spine.xml \ diff --git a/libstdc++-v3/doc/Makefile.in b/libstdc++-v3/doc/Makefile.in index 6eccd899a35a..fd56f3c3e9d7 100644 --- a/libstdc++-v3/doc/Makefile.in +++ b/libstdc++-v3/doc/Makefile.in @@ -312,6 +312,7 @@ xml_sources = \ ${xml_srcdir}/manual/numerics.xml \ ${xml_srcdir}/manual/parallel_mode.xml \ ${xml_srcdir}/manual/prerequisites.xml \ + ${xml_srcdir}/manual/profile_mode.xml \ ${xml_srcdir}/manual/internals.xml \ ${xml_srcdir}/manual/shared_ptr.xml \ ${xml_srcdir}/manual/spine.xml \ diff --git a/libstdc++-v3/doc/doxygen/user.cfg.in b/libstdc++-v3/doc/doxygen/user.cfg.in index 9c4b6c9bf517..9ffcf1ef75c3 100644 --- a/libstdc++-v3/doc/doxygen/user.cfg.in +++ b/libstdc++-v3/doc/doxygen/user.cfg.in @@ -661,6 +661,25 @@ INPUT = @srcdir@/doc/doxygen/doxygroups.cc \ include/debug/unordered_map \ include/debug/unordered_set \ include/debug/vector \ + include/profile/bitset \ + include/profile/deque \ + include/profile/list \ + include/profile/map \ + include/profile/set \ + include/profile/unordered_map \ + include/profile/unordered_set \ + include/profile/vector \ + include/profile/base.h \ + include/profile/impl/profiler.h \ + include/profile/impl/profiler_container_size.h \ + include/profile/impl/profiler_hash_func.h \ + include/profile/impl/profiler_hashtable_size.h \ + include/profile/impl/profiler_map_to_unordered_map.h \ + include/profile/impl/profiler_node.h \ + include/profile/impl/profiler_state.h \ + include/profile/impl/profiler_trace.h \ + include/profile/impl/profiler_vector_size.h \ + include/profile/impl/profiler_vector_to_list.h \ include/ext/algorithm \ include/ext/functional \ include/ext/iterator \ @@ -715,6 +734,7 @@ INPUT = @srcdir@/doc/doxygen/doxygroups.cc \ include/bits/shared_ptr.h \ include/debug \ include/parallel \ + include/profile \ include/ext \ include/ext/pb_ds \ include/ext/pb_ds/detail diff --git a/libstdc++-v3/doc/xml/manual/debug.xml b/libstdc++-v3/doc/xml/manual/debug.xml index 273196ee1a59..8aa530703779 100644 --- a/libstdc++-v3/doc/xml/manual/debug.xml +++ b/libstdc++-v3/doc/xml/manual/debug.xml @@ -243,4 +243,12 @@ + +Profile-based Performance Analysis + The Profile-based + Performance Analysis Extension has performance checks for many + algorithms. + + + diff --git a/libstdc++-v3/doc/xml/manual/extensions.xml b/libstdc++-v3/doc/xml/manual/extensions.xml index 82e910023a48..889fe1db014d 100644 --- a/libstdc++-v3/doc/xml/manual/extensions.xml +++ b/libstdc++-v3/doc/xml/manual/extensions.xml @@ -113,7 +113,13 @@ extensions, be aware of two things: parse="xml" href="parallel_mode.xml"> - + + + + + + Allocators @@ -130,7 +136,7 @@ extensions, be aware of two things: - + Containers @@ -266,7 +272,7 @@ extensions, be aware of two things: - + Utilities @@ -336,7 +342,7 @@ get_temporary_buffer(5, (int*)0); - + Algorithms @@ -374,7 +380,7 @@ get_temporary_buffer(5, (int*)0); - + Numerics @@ -399,7 +405,7 @@ get_temporary_buffer(5, (int*)0); void iota(_ForwardIter first, _ForwardIter last, _Tp value); - + Iterators @@ -423,7 +429,7 @@ get_temporary_buffer(5, (int*)0); - + Input and Output @@ -493,7 +499,7 @@ get_temporary_buffer(5, (int*)0); - + Demangling @@ -579,7 +585,7 @@ int main() - + diff --git a/libstdc++-v3/doc/xml/manual/profile_mode.xml b/libstdc++-v3/doc/xml/manual/profile_mode.xml new file mode 100644 index 000000000000..5bf8eb132076 --- /dev/null +++ b/libstdc++-v3/doc/xml/manual/profile_mode.xml @@ -0,0 +1,1718 @@ + + + + + + + + + + C++ + + + library + + + profile + + + + +Profile Mode + + + + Intro + + Goal: Give performance improvement advice based on + recognition of suboptimal usage patterns of the standard library. + + + + Method: Wrap the standard library code. Insert + calls to an instrumentation library to record the internal state of + various components at interesting entry/exit points to/from the standard + library. Process trace, recognize suboptimal patterns, give advice. + For details, see + paper presented at + CGO 2009. + + + Strengths: + + + Unintrusive solution. The application code does not require any + modification. + + The advice is call context sensitive, thus capable of + identifying precisely interesting dynamic performance behavior. + + + The overhead model is pay-per-view. When you turn off a diagnostic class + at compile time, its overhead disappears. + + + + + Drawbacks: + + + You must recompile the application code with custom options. + + You must run the application on representative input. + The advice is input dependent. + + + The execution time will increase, in some cases by factors. + + + + + + + Using the Profile Mode + + + This is the anticipated common workflow for program foo.cc: + +$ cat foo.cc +#include <vector> +int main() { + vector<int> v; + for (int k = 0; k < 1024; ++k) v.insert(v.begin(), k); +} + +$ g++ -D_GLIBCXX_PROFILE foo.cc +$ ./a.out +$ cat libstdcxx-profile.txt +vector-to-list: improvement = 5: call stack = 0x804842c ... + : advice = change std::vector to std::list +vector-size: improvement = 3: call stack = 0x804842c ... + : advice = change initial container size from 0 to 1024 + + + + + Anatomy of a warning: + + + + Warning id. This is a short descriptive string for the class + that this warning belongs to. E.g., "vector-to-list". + + + + + Estimated improvement. This is an approximation of the benefit expected + from implementing the change suggested by the warning. It is given on + a log10 scale. Negative values mean that the alternative would actually + do worse than the current choice. + In the example above, 5 comes from the fact that the overhead of + inserting at the beginning of a vector vs. a list is around 1024 * 1024 / 2, + which is around 10e5. The improvement from setting the initial size to + 1024 is in the range of 10e3, since the overhead of dynamic resizing is + linear in this case. + + + + + Call stack. Currently, the addresses are printed without + symbol name or code location attribution. + Users are expected to postprocess the output using, for instance, addr2line. + + + + + The warning message. For some warnings, this is static text, e.g., + "change vector to list". For other warnings, such as the one above, + the message contains numeric advice, e.g., the suggested initial size + of the hashtable. + + + + + + Two files are generated. libstdcxx-profile.txt + contains human readable advice. libstdcxx-profile.raw + contains implementation specific data about each diagnostic. + Their format is not documented. They are sufficient to generate + all the advice given in libstdcxx-profile.txt. The advantage + of keeping this raw format is that traces from multiple executions can + be aggregated simply by concatenating the raw traces. We intend to + offer an external utility program that can issue advice from a trace. + + + Advice is given regardless whether the transformation is valid. + For instance, we advise changing a map to an unordered_map even if the + application semantics require that data be ordered. + We believe such warnings can help users understand the performance + behavior of their application better, which can lead to changes + at a higher abstraction level. + + + + + + Tuning the Profile Mode + + Compile time switches and environment variables (see also file + profiler.h). Unless specified otherwise, they can be set at compile time + using -D_<name> or by setting variable <name> + in the environment where the program is run, before starting execution. + + + [NO]_GLIBCXX_PROFILE_<diagnostic>: + enable/disable specific diagnostics. + See section Diagnostics for possible values. + (Environment variables not supported.) + + + GLIBCXX_PROFILE_TRACE_PATH_ROOT: set an alternative root + path for the output files. + + GLIBCXX_PROFILE_MAX_WARN_COUNT: set it to the maximum + number of warnings desired. The default value is 10. + + GLIBCXX_PROFILE_MAX_STACK_DEPTH: if set to 0, + the advice will + be collected and reported for the program as a whole, and not for each + call context. + This could also be used in continuous regression tests, where you + just need to know whether there is a regression or not. + The default value is 32. + + + GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC: + set a limit on how much memory to use for the accounting tables for each + diagnostic type. When this limit is reached, new events are ignored + until the memory usage decreases under the limit. Generally, this means + that newly created containers will not be instrumented until some + live containers are deleted. The default is 128 MB. + + + GLIBCXX_PROFILE_NOTHREADS: + Make the library not use threads. Otherwise, pthread mutexes are used + to protect access to internal data structures. This should be useful + only if the program is single threaded and you want to avoid the overhead + of aquiring/releasing locks unnecessarily. + (Environment variable not supported.) + + + HAVE_EXECINFO_H: + This name should be defined at library configuration time. + If your library was configured without execinfo.h, but + you have it in your include path, you can define it explicitly. Without + it, advice is collected for the program as a whole, and not for each + call context. + (Environment variable not supported.) + + + + + + + + + + + Design + + + + +Code Location + + + + + + + Code Location + Use + + + + + libstdc++-v3/include/std/* + Preprocessor code to redirect to profile extension headers. + + + libstdc++-v3/include/profile/* + Profile extension public headers (map, vector, ...). + + + libstdc++-v3/include/profile/impl/* + Profile extension internals. Implementation files are + only included from impl/profiler.h, which is the only + file included from the public headers. + + + +
+ + + + + +Wrapper Model + + In order to get our instrumented library version included instead of the + release one, + we use the same wrapper model as the debug mode. + We subclass entities from the release version. Wherever + _GLIBCXX_PROFILE is defined, the release namespace is + std::__norm, whereas the profile namespace is + std::__profile. Using plain std translates + into std::__profile. + + + Whenever possible, we try to wrap at the public interface level, e.g., + in unordered_set rather than in hashtable, + in order not to depend on implementation. + + + Mixing object files built with and without the profile mode must + not affect the program execution. However, there are no guarantees to + the accuracy of diagnostics when using even a single object not built with + -D_GLIBCXX_PROFILE. + Currently, mixing the profile mode with debug and parallel extensions is + not allowed. Mixing them at compile time will result in preprocessor errors. + Mixing them at link time is undefined. + + + + + +Instrumentation + + Instead of instrumenting every public entry and exit point, + we chose to add instrumentation on demand, as needed + by individual diagnostics. + The main reason is that some diagnostics require us to extract bits of + internal state that are particular only to that diagnostic. + We plan to formalize this later, after we learn more about the requirements + of several diagnostics. + + + All the instrumentation points can be switched on and off using + -D[_NO]_GLIBCXX_PROFILE_<diagnostic> options. + With all the instrumentation calls off, there should be negligible + overhead over the release version. This property is needed to support + diagnostics based on timing of internal operations. For such diagnostics, + we anticipate turning most of the instrumentation off in order to prevent + profiling overhead from polluting time measurements, and thus diagnostics. + + + All the instrumentation on/off compile time switches live in + include/profile/profiler.h. + + + + + +Run Time Behavior + + For practical reasons, the instrumentation library processes the trace + partially + rather than dumping it to disk in raw form. Each event is processed when + it occurs. It is usually attached a cost and it is aggregated into + the database of a specific diagnostic class. The cost model + is based largely on the standard performance guarantees, but in some + cases we use knowledge about GCC's standard library implementation. + + + Information is indexed by (1) call stack and (2) instance id or address + to be able to understand and summarize precise creation-use-destruction + dynamic chains. Although the analysis is sensitive to dynamic instances, + the reports are only sensitive to call context. Whenever a dynamic instance + is destroyed, we accumulate its effect to the corresponding entry for the + call stack of its constructor location. + + + + For details, see + paper presented at + CGO 2009. + + + + + +Analysis and Diagnostics + + Final analysis takes place offline, and it is based entirely on the + generated trace and debugging info in the application binary. + See section Diagnostics for a list of analysis types that we plan to support. + + + The input to the analysis is a table indexed by profile type and call stack. + The data type for each entry depends on the profile type. + + + + + +Cost Model + + While it is likely that cost models become complex as we get into + more sophisticated analysis, we will try to follow a simple set of rules + at the beginning. + + + Relative benefit estimation: + The idea is to estimate or measure the cost of all operations + in the original scenario versus the scenario we advise to switch to. + For instance, when advising to change a vector to a list, an occurrence + of the insert method will generally count as a benefit. + Its magnitude depends on (1) the number of elements that get shifted + and (2) whether it triggers a reallocation. + + Synthetic measurements: + We will measure the relative difference between similar operations on + different containers. We plan to write a battery of small tests that + compare the times of the executions of similar methods on different + containers. The idea is to run these tests on the target machine. + If this training phase is very quick, we may decide to perform it at + library initialization time. The results can be cached on disk and reused + across runs. + + Timers: + We plan to use timers for operations of larger granularity, such as sort. + For instance, we can switch between different sort methods on the fly + and report the one that performs best for each call context. + + Show stoppers: + We may decide that the presence of an operation nullifies the advice. + For instance, when considering switching from set to + unordered_set, if we detect use of operator ++, + we will simply not issue the advice, since this could signal that the use + care require a sorted container. + + + + + + +Reports + +There are two types of reports. First, if we recognize a pattern for which +we have a substitute that is likely to give better performance, we print +the advice and estimated performance gain. The advice is usually associated +to a code position and possibly a call stack. + + +Second, we report performance characteristics for which we do not have +a clear solution for improvement. For instance, we can point to the user +the top 10 multimap locations +which have the worst data locality in actual traversals. +Although this does not offer a solution, +it helps the user focus on the key problems and ignore the uninteresting ones. + + + + + +Testing + + First, we want to make sure we preserve the behavior of the release mode. + You can just type "make check-profile", which + builds and runs the whole test suite in profile mode. + + + Second, we want to test the correctness of each diagnostic. + We created a profile directory in the test suite. + Each diagnostic must come with at least two tests, one for false positives + and one for false negatives. + + + + + + +Extensions for Custom Containers + + + Many large projects use their own data structures instead of the ones in the + standard library. If these data structures are similar in functionality + to the standard library, they can be instrumented with the same hooks + that are used to instrument the standard library. + The instrumentation API is exposed in file + profiler.h (look for "Instrumentation hooks"). + + + + + + +Empirical Cost Model + + + Currently, the cost model uses formulas with predefined relative weights + for alternative containers or container implementations. For instance, + iterating through a vector is X times faster than iterating through a list. + + + (Under development.) + We are working on customizing this to a particular machine by providing + an automated way to compute the actual relative weights for operations + on the given machine. + + + (Under development.) + We plan to provide a performance parameter database format that can be + filled in either by hand or by an automated training mechanism. + The analysis module will then use this database instead of the built in. + generic parameters. + + + + + + +Implementation Issues + + + +Stack Traces + + Accurate stack traces are needed during profiling since we group events by + call context and dynamic instance. Without accurate traces, diagnostics + may be hard to interpret. For instance, when giving advice to the user + it is imperative to reference application code, not library code. + + + Currently we are using the libc backtrace routine to get + stack traces. + _GLIBCXX_PROFILE_STACK_DEPTH can be set + to 0 if you are willing to give up call context information, or to a small + positive value to reduce run time overhead. + + + + + +Symbolization of Instruction Addresses + + The profiling and analysis phases use only instruction addresses. + An external utility such as addr2line is needed to postprocess the result. + We do not plan to add symbolization support in the profile extension. + This would require access to symbol tables, debug information tables, + external programs or libraries and other system dependent information. + + + + + +Concurrency + + Our current model is simplistic, but precise. + We cannot afford to approximate because some of our diagnostics require + precise matching of operations to container instance and call context. + During profiling, we keep a single information table per diagnostic. + There is a single lock per information table. + + + + + +Using the Standard Library in the Instrumentation Implementation + + As much as we would like to avoid uses of stdlibc++ within our + instrumentation library, containers such as unordered_map are very + appealing. We plan to use them as long as they are named properly + to avoid ambiguity. + + + + + +Malloc Hooks + + User applications/libraries can provide malloc hooks. + When the implementation of the malloc hooks uses stdlibc++, there can + be an infinite cycle between the profile mode instrumentation and the + the malloc hook code. + + + We protect against reentrance to the profile mode instrumentation code, + which should avoid this problem in most cases. + The protection mechanism is thread safe and exception safe. + This mechanism does not prevent reentrance to the malloc hook itself, + which could still result in deadlock, if, for instance, the malloc hook + uses non-recursive locks. + XXX: A definitive solution to this problem would be for the profile extension + to use a custom allocator internally, and perhaps not to use libstdc++. + + + + + +Construction and Destruction of Global Objects + + The profiling library state is initialized at the first call to a profiling + method. This allows us to record the construction of all global objects. + However, we cannot do the same at destruction time. The trace is written + by a function registered by atexit, thus invoked by + exit. + + + + + + + +Developer Information + + +Big Picture + + The profile mode headers are included with + -D_GLIBCXX_PROFILE through preprocessor directives in + include/std/*. + + + Instrumented implementations are provided in + include/profile/*. All instrumentation hooks are macros + defined in include/profile/profiler.h. + + + All the implementation of the instrumentation hooks is in + include/profile/impl/*. Although all the code gets included, + thus is publicly visible, only a small number of functions are called from + outside this directory. All calls to hook implementations must be + done through macros defined in profiler.h. The macro + must ensure (1) that the call is guarded against reentrance and + (2) that the call can be turned off at compile time using a + -D_GLIBCXX_PROFILE_... compiler option. + + + + + +How To Add A Diagnostic + + Let's say the diagnostic name is "magic". + + + If you need to instrument a header not already under + include/profile/*, first edit the corresponding header + under include/std/ and add a preprocessor directive such + as the one in include/std/vector: + +#ifdef _GLIBCXX_PROFILE +# include <profile/vector> +#endif + + + + If the file you need to instrument is not yet under + include/profile/, make a copy of the one in + include/debug, or the main implementation. + You'll need to include the main implementation and inherit the classes + you want to instrument. Then define the methods you want to instrument, + define the instrumentation hooks and add calls to them. + Look at include/profile/vector for an example. + + + Add macros for the instrumentation hooks in + include/profile/impl/profiler.h. + Hook names must start with __profcxx_. + Make sure they transform + in no code with -D_NO_GLBICXX_PROFILE_MAGIC. + Make sure all calls to any method in namespace __cxxprof_impl + is protected against reentrance using macro + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD. + All names of methods in namespace __cxxprof_impl called from + profiler.h must start with __trace_magic_. + + + Add the implementation of the diagnostic. + + + Create new file include/profile/impl/profiler_magic.h. + + + Define class __magic_info: public __object_info_base. + This is the representation of a line in the object table. + The __merge method is used to aggregate information + across all dynamic instances created at the same call context. + The __magnitude must return the estimation of the benefit + as a number of small operations, e.g., number of words copied. + The __write method is used to produce the raw trace. + The __advice method is used to produce the advice string. + + + Define class __magic_stack_info: public __magic_info. + This defines the content of a line in the stack table. + + + Define class __trace_magic: public __trace_base<__magic_info, + __magic_stack_info>. + It defines the content of the trace associated with this diagnostic. + + + + + Add initialization and reporting calls in + include/profile/impl/profiler_trace.h. Use + __trace_vector_to_list as an example. + + + Add documentation in file doc/xml/manual/profile_mode.xml. + + + + + +Diagnostics + + + The table below presents all the diagnostics we intend to implement. + Each diagnostic has a corresponding compile time switch + -D_GLIBCXX_PROFILE_<diagnostic>. + Groups of related diagnostics can be turned on with a single switch. + For instance, -D_GLIBCXX_PROFILE_LOCALITY is equivalent to + -D_GLIBCXX_PROFILE_SOFTWARE_PREFETCH + -D_GLIBCXX_PROFILE_RBTREE_LOCALITY. + + + + The benefit, cost, expected frequency and accuracy of each diagnostic + was given a grade from 1 to 10, where 10 is highest. + A high benefit means that, if the diagnostic is accurate, the expected + performance improvement is high. + A high cost means that turning this diagnostic on leads to high slowdown. + A high frequency means that we expect this to occur relatively often. + A high accuracy means that the diagnostic is unlikely to be wrong. + These grades are not perfect. They are just meant to guide users with + specific needs or time budgets. + + + +Diagnostics + + + + + + + + + + + + Group + Flag + Benefit + Cost + Freq. + Implemented + + + + + + CONTAINERS + + HASHTABLE_TOO_SMALL + 10 + 1 + + 10 + yes + + + + + HASHTABLE_TOO_LARGE + 5 + 1 + + 10 + yes + + + + + INEFFICIENT_HASH + 7 + 3 + + 10 + yes + + + + + VECTOR_TOO_SMALL + 8 + 1 + + 10 + yes + + + + + VECTOR_TOO_LARGE + 5 + 1 + + 10 + yes + + + + + VECTOR_TO_HASHTABLE + 7 + 7 + + 10 + no + + + + + HASHTABLE_TO_VECTOR + 7 + 7 + + 10 + no + + + + + VECTOR_TO_LIST + 8 + 5 + + 10 + yes + + + + + LIST_TO_VECTOR + 10 + 5 + + 10 + no + + + + + ORDERED_TO_UNORDERED + 10 + 5 + + 10 + only map/unordered_map + + + + ALGORITHMS + + SORT + 7 + 8 + + 7 + no + + + + LOCALITY + + SOFTWARE_PREFETCH + 8 + 8 + + 5 + no + + + + + RBTREE_LOCALITY + 4 + 8 + + 5 + no + + + + + FALSE_SHARING + 8 + 10 + + 10 + no + + + +
+ + +Diagnostic Template + + Switch: + _GLIBCXX_PROFILE_<diagnostic>. + + Goal: What problem will it diagnose? + + Fundamentals:. + What is the fundamental reason why this is a problem + Sample runtime reduction: + Percentage reduction in execution time. When reduction is more than + a constant factor, describe the reduction rate formula. + + Recommendation: + What would the advise look like? + To instrument: + What stdlibc++ components need to be instrumented? + Analysis: + How do we decide when to issue the advice? + Cost model: + How do we measure benefits? Math goes here. + Example: + +program code +... +advice sample + + + + + + + +Containers + + +Switch: + _GLIBCXX_PROFILE_CONTAINERS. + + + +Hashtable Too Small + + Switch: + _GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL. + + Goal: Detect hashtables with many + rehash operations, small construction size and large destruction size. + + Fundamentals: Rehash is very expensive. + Read content, follow chains within bucket, evaluate hash function, place at + new location in different order. + Sample runtime reduction: 36%. + Code similar to example below. + + Recommendation: + Set initial size to N at construction site S. + + To instrument: + unordered_set, unordered_map constructor, destructor, rehash. + + Analysis: + For each dynamic instance of unordered_[multi]set|map, + record initial size and call context of the constructor. + Record size increase, if any, after each relevant operation such as insert. + Record the estimated rehash cost. + Cost model: + Number of individual rehash operations * cost per rehash. + Example: + +1 unordered_set<int> us; +2 for (int k = 0; k < 1000000; ++k) { +3 us.insert(k); +4 } + +foo.cc:1: advice: Changing initial unordered_set size from 10 to 1000000 saves 1025530 rehash operations. + + + + + + + +Hashtable Too Large + + Switch: + _GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE. + + Goal: Detect hashtables which are + never filled up because fewer elements than reserved are ever + inserted. + + Fundamentals: Save memory, which + is good in itself and may also improve memory reference performance through + fewer cache and TLB misses. + Sample runtime reduction: unknown. + + Recommendation: + Set initial size to N at construction site S. + + To instrument: + unordered_set, unordered_map constructor, destructor, rehash. + + Analysis: + For each dynamic instance of unordered_[multi]set|map, + record initial size and call context of the constructor, and correlate it + with its size at destruction time. + + Cost model: + Number of iteration operations + memory saved. + Example: + +1 vector<unordered_set<int>> v(100000, unordered_set<int>(100)) ; +2 for (int k = 0; k < 100000; ++k) { +3 for (int j = 0; j < 10; ++j) { +4 v[k].insert(k + j); +5 } +6 } + +foo.cc:1: advice: Changing initial unordered_set size from 100 to 10 saves N +bytes of memory and M iteration steps. + + + + + + +Inefficient Hash + + Switch: + _GLIBCXX_PROFILE_INEFFICIENT_HASH. + + Goal: Detect hashtables with polarized + distribution. + + Fundamentals: A non-uniform + distribution may lead to long chains, thus possibly increasing complexity + by a factor up to the number of elements. + + Sample runtime reduction: factor up + to container size. + + Recommendation: Change hash function + for container built at site S. Distribution score = N. Access score = S. + Longest chain = C, in bucket B. + + To instrument: + unordered_set, unordered_map constructor, destructor, [], + insert, iterator. + + Analysis: + Count the exact number of link traversals. + + Cost model: + Total number of links traversed. + Example: + +class dumb_hash { + public: + size_t operator() (int i) const { return 0; } +}; +... + unordered_set<int, dumb_hash> hs; + ... + for (int i = 0; i < COUNT; ++i) { + hs.find(i); + } + + + + + + +Vector Too Small + + Switch: + _GLIBCXX_PROFILE_VECTOR_TOO_SMALL. + + Goal:Detect vectors with many + resize operations, small construction size and large destruction size.. + + Fundamentals:Resizing can be expensive. + Copying large amounts of data takes time. Resizing many small vectors may + have allocation overhead and affect locality. + Sample runtime reduction:%. + + Recommendation: + Set initial size to N at construction site S. + To instrument:vector. + + Analysis: + For each dynamic instance of vector, + record initial size and call context of the constructor. + Record size increase, if any, after each relevant operation such as + push_back. Record the estimated resize cost. + + Cost model: + Total number of words copied * time to copy a word. + Example: + +1 vector<int> v; +2 for (int k = 0; k < 1000000; ++k) { +3 v.push_back(k); +4 } + +foo.cc:1: advice: Changing initial vector size from 10 to 1000000 saves +copying 4000000 bytes and 20 memory allocations and deallocations. + + + + + + +Vector Too Large + + Switch: + _GLIBCXX_PROFILE_VECTOR_TOO_LARGE + + Goal:Detect vectors which are + never filled up because fewer elements than reserved are ever + inserted. + + Fundamentals:Save memory, which + is good in itself and may also improve memory reference performance through + fewer cache and TLB misses. + Sample runtime reduction:%. + + Recommendation: + Set initial size to N at construction site S. + To instrument:vector. + + Analysis: + For each dynamic instance of vector, + record initial size and call context of the constructor, and correlate it + with its size at destruction time. + Cost model: + Total amount of memory saved. + Example: + +1 vector<vector<int>> v(100000, vector<int>(100)) ; +2 for (int k = 0; k < 100000; ++k) { +3 for (int j = 0; j < 10; ++j) { +4 v[k].insert(k + j); +5 } +6 } + +foo.cc:1: advice: Changing initial vector size from 100 to 10 saves N +bytes of memory and may reduce the number of cache and TLB misses. + + + + + + +Vector to Hashtable + + Switch: + _GLIBCXX_PROFILE_VECTOR_TO_HASHTABLE. + + Goal: Detect uses of + vector that can be substituted with unordered_set + to reduce execution time. + + Fundamentals: + Linear search in a vector is very expensive, whereas searching in a hashtable + is very quick. + Sample runtime reduction:factor up + to container size. + + Recommendation:Replace + vector with unordered_set at site S. + + To instrument:vector + operations and access methods. + Analysis: + For each dynamic instance of vector, + record call context of the constructor. Issue the advice only if the + only methods called on this vector are push_back, + insert and find. + + Cost model: + Cost(vector::push_back) + cost(vector::insert) + cost(find, vector) - + cost(unordered_set::insert) + cost(unordered_set::find). + + Example: + +1 vector<int> v; +... +2 for (int i = 0; i < 1000; ++i) { +3 find(v.begin(), v.end(), i); +4 } + +foo.cc:1: advice: Changing "vector" to "unordered_set" will save about 500,000 +comparisons. + + + + + + +Hashtable to Vector + + Switch: + _GLIBCXX_PROFILE_HASHTABLE_TO_VECTOR. + + Goal: Detect uses of + unordered_set that can be substituted with vector + to reduce execution time. + + Fundamentals: + Hashtable iterator is slower than vector iterator. + Sample runtime reduction:95%. + + Recommendation:Replace + unordered_set with vector at site S. + + To instrument:unordered_set + operations and access methods. + Analysis: + For each dynamic instance of unordered_set, + record call context of the constructor. Issue the advice only if the + number of find, insert and [] + operations on this unordered_set are small relative to the + number of elements, and methods begin or end + are invoked (suggesting iteration). + Cost model: + Number of . + Example: + +1 unordered_set<int> us; +... +2 int s = 0; +3 for (unordered_set<int>::iterator it = us.begin(); it != us.end(); ++it) { +4 s += *it; +5 } + +foo.cc:1: advice: Changing "unordered_set" to "vector" will save about N +indirections and may achieve better data locality. + + + + + + +Vector to List + + Switch: + _GLIBCXX_PROFILE_VECTOR_TO_LIST. + + Goal: Detect cases where + vector could be substituted with list for + better performance. + + Fundamentals: + Inserting in the middle of a vector is expensive compared to inserting in a + list. + + Sample runtime reduction:factor up to + container size. + + Recommendation:Replace vector with list + at site S. + To instrument:vector + operations and access methods. + Analysis: + For each dynamic instance of vector, + record the call context of the constructor. Record the overhead of each + insert operation based on current size and insert position. + Report instance with high insertion overhead. + + Cost model: + (Sum(cost(vector::method)) - Sum(cost(list::method)), for + method in [push_back, insert, erase]) + + (Cost(iterate vector) - Cost(iterate list)) + Example: + +1 vector<int> v; +2 for (int i = 0; i < 10000; ++i) { +3 v.insert(v.begin(), i); +4 } + +foo.cc:1: advice: Changing "vector" to "list" will save about 5,000,000 +operations. + + + + + + +List to Vector + + Switch: + _GLIBCXX_PROFILE_LIST_TO_VECTOR. + + Goal: Detect cases where + list could be substituted with vector for + better performance. + + Fundamentals: + Iterating through a vector is faster than through a list. + + Sample runtime reduction:64%. + + Recommendation:Replace list with vector + at site S. + To instrument:vector + operations and access methods. + Analysis: + Issue the advice if there are no insert operations. + + Cost model: + (Sum(cost(vector::method)) - Sum(cost(list::method)), for + method in [push_back, insert, erase]) + + (Cost(iterate vector) - Cost(iterate list)) + Example: + +1 list<int> l; +... +2 int sum = 0; +3 for (list<int>::iterator it = l.begin(); it != l.end(); ++it) { +4 sum += *it; +5 } + +foo.cc:1: advice: Changing "list" to "vector" will save about 1000000 indirect +memory references. + + + + + + +Ordered to Unordered Associative Container + + Switch: + _GLIBCXX_PROFILE_ORDERED_TO_UNORDERED. + + Goal: Detect cases where ordered + associative containers can be replaced with unordered ones. + + Fundamentals: + Insert and search are quicker in a hashtable than in + a red-black tree. + Sample runtime reduction:52%. + + Recommendation: + Replace set with unordered_set at site S. + To instrument: + set, multiset, map, + multimap methods. + Analysis: + Issue the advice only if we are not using operator ++ on any + iterator on a particular [multi]set|map. + + Cost model: + (Sum(cost(hashtable::method)) - Sum(cost(rbtree::method)), for + method in [insert, erase, find]) + + (Cost(iterate hashtable) - Cost(iterate rbtree)) + Example: + +1 set<int> s; +2 for (int i = 0; i < 100000; ++i) { +3 s.insert(i); +4 } +5 int sum = 0; +6 for (int i = 0; i < 100000; ++i) { +7 sum += *s.find(i); +8 } + + + + + + + + + + +Algorithms + + Switch: + _GLIBCXX_PROFILE_ALGORITHMS. + + + +Sort Algorithm Performance + + Switch: + _GLIBCXX_PROFILE_SORT. + + Goal: Give measure of sort algorithm + performance based on actual input. For instance, advise Radix Sort over + Quick Sort for a particular call context. + + Fundamentals: + See papers: + + A framework for adaptive algorithm selection in STAPL and + + Optimizing Sorting with Machine Learning Algorithms. + + Sample runtime reduction:60%. + + Recommendation: Change sort algorithm + at site S from X Sort to Y Sort. + To instrument: sort + algorithm. + Analysis: + Issue the advice if the cost model tells us that another sort algorithm + would do better on this input. Requires us to know what algorithm we + are using in our sort implementation in release mode. + Cost model: + Runtime(algo) for algo in [radix, quick, merge, ...] + Example: + + + + + + + + + + +Data Locality + + Switch: + _GLIBCXX_PROFILE_LOCALITY. + + + +Need Software Prefetch + + Switch: + _GLIBCXX_PROFILE_SOFTWARE_PREFETCH. + + Goal: Discover sequences of indirect + memory accesses that are not regular, thus cannot be predicted by + hardware prefetchers. + + Fundamentals: + Indirect references are hard to predict and are very expensive when they + miss in caches. + Sample runtime reduction:25%. + + Recommendation: Insert prefetch + instruction. + To instrument: Vector iterator and + access operator []. + + Analysis: + First, get cache line size and page size from system. + Then record iterator dereference sequences for which the value is a pointer. + For each sequence within a container, issue a warning if successive pointer + addresses are not within cache lines and do not form a linear pattern + (otherwise they may be prefetched by hardware). + If they also step across page boundaries, make the warning stronger. + + The same analysis applies to containers other than vector. + However, we cannot give the same advice for linked structures, such as list, + as there is no random access to the n-th element. The user may still be + able to benefit from this information, for instance by employing frays (user + level light weight threads) to hide the latency of chasing pointers. + + + This analysis is a little oversimplified. A better cost model could be + created by understanding the capability of the hardware prefetcher. + This model could be trained automatically by running a set of synthetic + cases. + + + Cost model: + Total distance between pointer values of successive elements in vectors + of pointers. + Example: + +1 int zero = 0; +2 vector<int*> v(10000000, &zero); +3 for (int k = 0; k < 10000000; ++k) { +4 v[random() % 10000000] = new int(k); +5 } +6 for (int j = 0; j < 10000000; ++j) { +7 count += (*v[j] == 0 ? 0 : 1); +8 } + +foo.cc:7: advice: Insert prefetch instruction. + + + + + + +Linked Structure Locality + + Switch: + _GLIBCXX_PROFILE_RBTREE_LOCALITY. + + Goal: Give measure of locality of + objects stored in linked structures (lists, red-black trees and hashtables) + with respect to their actual traversal patterns. + + Fundamentals:Allocation can be tuned + to a specific traversal pattern, to result in better data locality. + See paper: + + Custom Memory Allocation for Free. + + Sample runtime reduction:30%. + + Recommendation: + High scatter score N for container built at site S. + Consider changing allocation sequence or choosing a structure conscious + allocator. + To instrument: Methods of all + containers using linked structures. + Analysis: + First, get cache line size and page size from system. + Then record the number of successive elements that are on different line + or page, for each traversal method such as find. Give advice + only if the ratio between this number and the number of total node hops + is above a threshold. + Cost model: + Sum(same_cache_line(this,previous)) + Example: + + 1 set<int> s; + 2 for (int i = 0; i < 10000000; ++i) { + 3 s.insert(i); + 4 } + 5 set<int> s1, s2; + 6 for (int i = 0; i < 10000000; ++i) { + 7 s1.insert(i); + 8 s2.insert(i); + 9 } +... + // Fast, better locality. +10 for (set<int>::iterator it = s.begin(); it != s.end(); ++it) { +11 sum += *it; +12 } + // Slow, elements are further apart. +13 for (set<int>::iterator it = s1.begin(); it != s1.end(); ++it) { +14 sum += *it; +15 } + +foo.cc:5: advice: High scatter score NNN for set built here. Consider changing +the allocation sequence or switching to a structure conscious allocator. + + + + + + + + + +Multithreaded Data Access + + + The diagnostics in this group are not meant to be implemented short term. + They require compiler support to know when container elements are written + to. Instrumentation can only tell us when elements are referenced. + + + Switch: + _GLIBCXX_PROFILE_MULTITHREADED. + + + +Data Dependence Violations at Container Level + + Switch: + _GLIBCXX_PROFILE_DDTEST. + + Goal: Detect container elements + that are referenced from multiple threads in the parallel region or + across parallel regions. + + Fundamentals: + Sharing data between threads requires communication and perhaps locking, + which may be expensive. + + Sample runtime reduction:?%. + + Recommendation: Change data + distribution or parallel algorithm. + To instrument: Container access methods + and iterators. + + Analysis: + Keep a shadow for each container. Record iterator dereferences and + container member accesses. Issue advice for elements referenced by + multiple threads. + See paper: + The LRPD test: speculative run-time parallelization of loops with + privatization and reduction parallelization. + + Cost model: + Number of accesses to elements referenced from multiple threads + + Example: + + + + + + + +False Sharing + + Switch: + _GLIBCXX_PROFILE_FALSE_SHARING. + + Goal: Detect elements in the + same container which share a cache line, are written by at least one + thread, and accessed by different threads. + + Fundamentals: Under these assumptions, + cache protocols require + communication to invalidate lines, which may be expensive. + + Sample runtime reduction:68%. + + Recommendation: Reorganize container + or use padding to avoid false sharing. + To instrument: Container access methods + and iterators. + + Analysis: + First, get the cache line size. + For each shared container, record all the associated iterator dereferences + and member access methods with the thread id. Compare the address lists + across threads to detect references in two different threads to the same + cache line. Issue a warning only if the ratio to total references is + significant. Do the same for iterator dereference values if they are + pointers. + Cost model: + Number of accesses to same cache line from different threads. + + Example: + +1 vector<int> v(2, 0); +2 #pragma omp parallel for shared(v, SIZE) schedule(static, 1) +3 for (i = 0; i < SIZE; ++i) { +4 v[i % 2] += i; +5 } + +OMP_NUM_THREADS=2 ./a.out +foo.cc:1: advice: Change container structure or padding to avoid false +sharing in multithreaded access at foo.cc:4. Detected N shared cache lines. + + + + + + + + + +Statistics + + +Switch: + _GLIBCXX_PROFILE_STATISTICS. + + + + In some cases the cost model may not tell us anything because the costs + appear to offset the benefits. Consider the choice between a vector and + a list. When there are both inserts and iteration, an automatic advice + may not be issued. However, the programmer may still be able to make use + of this information in a different way. + + + This diagnostic will not issue any advice, but it will print statistics for + each container construction site. The statistics will contain the cost + of each operation actually performed on the container. + + + + + + + + + +Bibliography + + + + Perflint: A Context Sensitive Performance Advisor for C++ Programs + + + + Lixia + Liu + + + Silvius + Rus + + + + 2009 + + + + + + Proceedings of the 2009 International Symposium on Code Generation + and Optimization + + + + + + + diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index 55d02364d119..f3dcd19b79f1 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -1,4 +1,4 @@ -## Makefile for the include subdirectory of the GNU C++ Standard library. +#o# Makefile for the include subdirectory of the GNU C++ Standard library. ## ## Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 ## Free Software Foundation, Inc. @@ -771,6 +771,37 @@ else parallel_headers = endif +# Profile mode headers +profile_srcdir = ${glibcxx_srcdir}/include/profile +profile_builddir = ./profile +profile_headers = \ + ${profile_srcdir}/base.h \ + ${profile_srcdir}/unordered_map \ + ${profile_srcdir}/unordered_set \ + ${profile_srcdir}/vector \ + ${profile_srcdir}/bitset \ + ${profile_srcdir}/deque \ + ${profile_srcdir}/list \ + ${profile_srcdir}/map \ + ${profile_srcdir}/map.h \ + ${profile_srcdir}/multimap.h \ + ${profile_srcdir}/multiset.h \ + ${profile_srcdir}/set \ + ${profile_srcdir}/set.h \ + ${profile_srcdir}/hashtable.h +profile_impl_srcdir = ${glibcxx_srcdir}/include/profile/impl +profile_impl_builddir = ./profile/impl +profile_impl_headers = \ + ${profile_impl_srcdir}/profiler.h \ + ${profile_impl_srcdir}/profiler_container_size.h \ + ${profile_impl_srcdir}/profiler_hash_func.h \ + ${profile_impl_srcdir}/profiler_hashtable_size.h \ + ${profile_impl_srcdir}/profiler_map_to_unordered_map.h \ + ${profile_impl_srcdir}/profiler_node.h \ + ${profile_impl_srcdir}/profiler_state.h \ + ${profile_impl_srcdir}/profiler_trace.h \ + ${profile_impl_srcdir}/profiler_vector_size.h \ + ${profile_impl_srcdir}/profiler_vector_to_list.h # Some of the different "C" header models need extra files. # Some "C" header schemes require the "C" compatibility headers. @@ -865,7 +896,8 @@ endif allstamped = \ stamp-std stamp-bits stamp-c_base stamp-c_base_extra \ stamp-c_compatibility stamp-backward stamp-ext stamp-pb \ - stamp-tr1 stamp-tr1-impl stamp-debug stamp-parallel stamp-host + stamp-tr1 stamp-tr1-impl stamp-debug stamp-parallel stamp-host \ + stamp-profile stamp-profile-impl # List of all files that are created by explicit building, editing, or # catenation. @@ -989,6 +1021,16 @@ stamp-parallel: ${parallel_headers} @-cd ${parallel_builddir} && $(LN_S) $? . 2>/dev/null @$(STAMP) stamp-parallel +stamp-profile: ${profile_headers} + @-mkdir -p ${profile_builddir} + @-cd ${profile_builddir} && $(LN_S) $? . 2>/dev/null + @$(STAMP) stamp-profile + +stamp-profile-impl: ${profile_impl_headers} + @-mkdir -p ${profile_impl_builddir} + @-cd ${profile_impl_builddir} && $(LN_S) $? . 2>/dev/null + @$(STAMP) stamp-profile-impl + stamp-${host_alias}: @-mkdir -p ${host_builddir} @$(STAMP) stamp-${host_alias} @@ -1217,6 +1259,12 @@ install-headers: $(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${parallel_builddir};\ for file in $$parallel_headers_install; do \ $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${parallel_builddir}; done + $(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${profile_builddir} + for file in ${profile_headers}; do \ + $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${profile_builddir}; done + $(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${profile_impl_builddir} + for file in ${profile_impl_headers}; do \ + $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${profile_impl_builddir}; done $(mkinstalldirs) $(DESTDIR)${host_installdir} for file in ${host_headers} ${host_headers_extra} \ ${thread_host_headers}; do \ diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index 47995ef7d8f6..4c69a2be2880 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -1001,6 +1001,39 @@ parallel_builddir = ./parallel @ENABLE_PARALLEL_TRUE@ ${parallel_srcdir}/unique_copy.h \ @ENABLE_PARALLEL_TRUE@ ${parallel_srcdir}/workstealing.h + +# Profile mode headers +profile_srcdir = ${glibcxx_srcdir}/include/profile +profile_builddir = ./profile +profile_headers = \ + ${profile_srcdir}/base.h \ + ${profile_srcdir}/unordered_map \ + ${profile_srcdir}/unordered_set \ + ${profile_srcdir}/vector \ + ${profile_srcdir}/bitset \ + ${profile_srcdir}/deque \ + ${profile_srcdir}/list \ + ${profile_srcdir}/map \ + ${profile_srcdir}/map.h \ + ${profile_srcdir}/multimap.h \ + ${profile_srcdir}/multiset.h \ + ${profile_srcdir}/set \ + ${profile_srcdir}/set.h \ + ${profile_srcdir}/hashtable.h +profile_impl_srcdir = ${glibcxx_srcdir}/include/profile/impl +profile_impl_builddir = ./profile/impl +profile_impl_headers = \ + ${profile_impl_srcdir}/profiler.h \ + ${profile_impl_srcdir}/profiler_container_size.h \ + ${profile_impl_srcdir}/profiler_hash_func.h \ + ${profile_impl_srcdir}/profiler_hashtable_size.h \ + ${profile_impl_srcdir}/profiler_map_to_unordered_map.h \ + ${profile_impl_srcdir}/profiler_node.h \ + ${profile_impl_srcdir}/profiler_state.h \ + ${profile_impl_srcdir}/profiler_trace.h \ + ${profile_impl_srcdir}/profiler_vector_size.h \ + ${profile_impl_srcdir}/profiler_vector_to_list.h + @GLIBCXX_C_HEADERS_EXTRA_FALSE@c_base_headers_extra = # Some of the different "C" header models need extra files. @@ -1083,7 +1116,8 @@ PCHFLAGS = -x c++-header $(CXXFLAGS) allstamped = \ stamp-std stamp-bits stamp-c_base stamp-c_base_extra \ stamp-c_compatibility stamp-backward stamp-ext stamp-pb \ - stamp-tr1 stamp-tr1-impl stamp-debug stamp-parallel stamp-host + stamp-tr1 stamp-tr1-impl stamp-debug stamp-parallel stamp-host \ + stamp-profile stamp-profile-impl # List of all files that are created by explicit building, editing, or @@ -1400,6 +1434,16 @@ stamp-parallel: ${parallel_headers} @-cd ${parallel_builddir} && $(LN_S) $? . 2>/dev/null @$(STAMP) stamp-parallel +stamp-profile: ${profile_headers} + @-mkdir -p ${profile_builddir} + @-cd ${profile_builddir} && $(LN_S) $? . 2>/dev/null + @$(STAMP) stamp-profile + +stamp-profile-impl: ${profile_impl_headers} + @-mkdir -p ${profile_impl_builddir} + @-cd ${profile_impl_builddir} && $(LN_S) $? . 2>/dev/null + @$(STAMP) stamp-profile-impl + stamp-${host_alias}: @-mkdir -p ${host_builddir} @$(STAMP) stamp-${host_alias} @@ -1616,6 +1660,13 @@ install-headers: $(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${parallel_builddir};\ for file in $$parallel_headers_install; do \ $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${parallel_builddir}; done + $(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${profile_builddir} \ + $(DESTDIR)${gxx_include_dir}/${profile_builddir}/impl + for file in ${profile_headers}; do \ + $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${profile_builddir}; done + $(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${profile_impl_builddir} + for file in ${profile_impl_headers}; do \ + $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${profile_impl_builddir}; done $(mkinstalldirs) $(DESTDIR)${host_installdir} for file in ${host_headers} ${host_headers_extra} \ ${thread_host_headers}; do \ diff --git a/libstdc++-v3/include/backward/hash_map b/libstdc++-v3/include/backward/hash_map index 469429ccc24c..cb31687c0086 100644 --- a/libstdc++-v3/include/backward/hash_map +++ b/libstdc++-v3/include/backward/hash_map @@ -58,7 +58,11 @@ #include "backward_warning.h" #include +#ifdef _GLIBCXX_PROFILE +#include +#else #include +#endif #include _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) diff --git a/libstdc++-v3/include/backward/hash_set b/libstdc++-v3/include/backward/hash_set index 32fa2205eeab..d2bd03bb0b3d 100644 --- a/libstdc++-v3/include/backward/hash_set +++ b/libstdc++-v3/include/backward/hash_set @@ -58,7 +58,11 @@ #include "backward_warning.h" #include +#ifdef _GLIBCXX_PROFILE +#include +#else #include +#endif #include _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) diff --git a/libstdc++-v3/include/bits/c++config b/libstdc++-v3/include/bits/c++config index d5babc319595..724f373ebae8 100644 --- a/libstdc++-v3/include/bits/c++config +++ b/libstdc++-v3/include/bits/c++config @@ -85,11 +85,17 @@ # define _GLIBCXX_NAMESPACE_ASSOCIATION_PARALLEL 1 #endif +// Namespace association for profile +#ifdef _GLIBCXX_PROFILE +# define _GLIBCXX_NAMESPACE_ASSOCIATION_PROFILE 1 +#endif + #define _GLIBCXX_NAMESPACE_ASSOCIATION_VERSION // Defined if any namespace association modes are active. #if _GLIBCXX_NAMESPACE_ASSOCIATION_DEBUG \ || _GLIBCXX_NAMESPACE_ASSOCIATION_PARALLEL \ + || _GLIBCXX_NAMESPACE_ASSOCIATION_PROFILE \ || _GLIBCXX_NAMESPACE_ASSOCIATION_VERSION # define _GLIBCXX_USE_NAMESPACE_ASSOCIATION 1 #endif @@ -108,6 +114,7 @@ #ifndef _GLIBCXX_USE_NAMESPACE_ASSOCIATION # define _GLIBCXX_STD_D _GLIBCXX_STD # define _GLIBCXX_STD_P _GLIBCXX_STD +# define _GLIBCXX_STD_PR _GLIBCXX_STD # define _GLIBCXX_STD std # define _GLIBCXX_BEGIN_NESTED_NAMESPACE(X, Y) _GLIBCXX_BEGIN_NAMESPACE(X) # define _GLIBCXX_END_NESTED_NAMESPACE _GLIBCXX_END_NAMESPACE @@ -124,7 +131,7 @@ # endif // debug -# if _GLIBCXX_NAMESPACE_ASSOCIATION_DEBUG && !_GLIBCXX_NAMESPACE_ASSOCIATION_PARALLEL +# if _GLIBCXX_NAMESPACE_ASSOCIATION_DEBUG && !_GLIBCXX_NAMESPACE_ASSOCIATION_PARALLEL && !_GLIBCXX_NAMESPACE_ASSOCIATION_PROFILE # define _GLIBCXX_STD_D __norm # define _GLIBCXX_STD_P _GLIBCXX_STD # define _GLIBCXX_STD __cxx1998 @@ -134,7 +141,7 @@ # endif // parallel -# if _GLIBCXX_NAMESPACE_ASSOCIATION_PARALLEL && !_GLIBCXX_NAMESPACE_ASSOCIATION_DEBUG +# if _GLIBCXX_NAMESPACE_ASSOCIATION_PARALLEL && !_GLIBCXX_NAMESPACE_ASSOCIATION_DEBUG && !_GLIBCXX_NAMESPACE_ASSOCIATION_PROFILE # define _GLIBCXX_STD_D _GLIBCXX_STD # define _GLIBCXX_STD_P __norm # define _GLIBCXX_STD __cxx1998 @@ -144,7 +151,7 @@ # endif // debug + parallel -# if _GLIBCXX_NAMESPACE_ASSOCIATION_PARALLEL && _GLIBCXX_NAMESPACE_ASSOCIATION_DEBUG +# if _GLIBCXX_NAMESPACE_ASSOCIATION_PARALLEL && _GLIBCXX_NAMESPACE_ASSOCIATION_DEBUG && !_GLIBCXX_NAMESPACE_ASSOCIATION_PROFILE # define _GLIBCXX_STD_D __norm # define _GLIBCXX_STD_P __norm # define _GLIBCXX_STD __cxx1998 @@ -153,6 +160,21 @@ # define _GLIBCXX_EXTERN_TEMPLATE -1 # endif +// profile +# if _GLIBCXX_NAMESPACE_ASSOCIATION_PROFILE +# if _GLIBCXX_NAMESPACE_ASSOCIATION_PARALLEL || _GLIBCXX_NAMESPACE_ASSOCIATION_DEBUG +# error Cannot use -D_GLIBCXX_PROFILE with -D_GLIBCXX_DEBUG or \ + -D_GLIBCXX_PARALLEL +# endif +# define _GLIBCXX_STD_D __norm +# define _GLIBCXX_STD_P _GLIBCXX_STD +# define _GLIBCXX_STD_PR __norm +# define _GLIBCXX_STD __cxx1998 +# define _GLIBCXX_BEGIN_NAMESPACE(X) namespace X _GLIBCXX_VISIBILITY_ATTR(default) { +# define _GLIBCXX_END_NAMESPACE } +# define _GLIBCXX_EXTERN_TEMPLATE -1 +# endif + # if __NO_INLINE__ && !__GXX_WEAK__ # warning currently using namespace associated mode which may fail \ without inlining due to lack of weak symbols @@ -163,7 +185,7 @@ #endif // Namespace associations for debug mode. -#if _GLIBCXX_NAMESPACE_ASSOCIATION_DEBUG +#if _GLIBCXX_NAMESPACE_ASSOCIATION_DEBUG && !_GLIBCXX_NAMESPACE_ASSOCIATION_PROFILE namespace std { namespace __norm { } @@ -182,6 +204,16 @@ namespace std } #endif +// Namespace associations for profile mode +#if _GLIBCXX_NAMESPACE_ASSOCIATION_PROFILE +namespace std +{ + namespace __norm { } + inline namespace __profile { } + inline namespace __cxx1998 { } +} +#endif + // Namespace associations for versioning mode. #if _GLIBCXX_NAMESPACE_ASSOCIATION_VERSION namespace std diff --git a/libstdc++-v3/include/profile/base.h b/libstdc++-v3/include/profile/base.h new file mode 100644 index 000000000000..de7bfe9a56f8 --- /dev/null +++ b/libstdc++-v3/include/profile/base.h @@ -0,0 +1,68 @@ +// -*- C++ -*- + +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 2, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. + +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/** @file profile/base.h + * @brief Sequential helper functions. + * This file is a GNU profile extension to the Standard C++ Library. + */ + +// Written by Lixia Liu + +#ifndef _GLIBCXX_PROFILE_BASE_H +#define _GLIBCXX_PROFILE_BASE_H 1 + +#include +#include +#include +#include + +// Profiling mode namespaces. + +/** + * @namespace std::__profile + * @brief GNU profile code, replaces standard behavior with profile behavior. + */ +namespace std +{ + namespace __profile { } +} + +/** + * @namespace __gnu_profile + * @brief GNU profile code for public use. + */ +namespace __gnu_profile +{ + // Import all the profile versions of components in namespace std. + using namespace std::__profile; +} + + +#endif /* _GLIBCXX_PROFILE_BASE_H */ diff --git a/libstdc++-v3/include/profile/bitset b/libstdc++-v3/include/profile/bitset new file mode 100644 index 000000000000..96a59ea4ad99 --- /dev/null +++ b/libstdc++-v3/include/profile/bitset @@ -0,0 +1,345 @@ +// Profiling bitset implementation -*- C++ -*- + +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file profile/bitset + * This file is a GNU profile extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_PROFILE_BITSET +#define _GLIBCXX_PROFILE_BITSET + +#include + +namespace std +{ +namespace __profile +{ + /** @brief Bitset wrapper with performance instrumentation. */ + template + class bitset + : public _GLIBCXX_STD_D::bitset<_Nb> + { + typedef _GLIBCXX_STD_D::bitset<_Nb> _Base; + + public: + // bit reference: + class reference + : private _Base::reference + { + typedef typename _Base::reference _Base_ref; + + friend class bitset; + reference(); + + reference(const _Base_ref& __base, bitset* __seq) + : _Base_ref(__base) + { } + + public: + reference(const reference& __x) + : _Base_ref(__x) + { } + + reference& + operator=(bool __x) + { + *static_cast<_Base_ref*>(this) = __x; + return *this; + } + + reference& + operator=(const reference& __x) + { + *static_cast<_Base_ref*>(this) = __x; + return *this; + } + + bool + operator~() const + { + return ~(*static_cast(this)); + } + + operator bool() const + { + return *static_cast(this); + } + + reference& + flip() + { + _Base_ref::flip(); + return *this; + } + }; + + // 23.3.5.1 constructors: + bitset() : _Base() { } + + bitset(unsigned long __val) : _Base(__val) { } + + template + explicit + bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str, + typename std::basic_string<_CharT, _Traits, _Alloc>::size_type + __pos = 0, + typename std::basic_string<_CharT, _Traits, _Alloc>::size_type + __n = (std::basic_string<_CharT, _Traits, _Alloc>::npos)) + : _Base(__str, __pos, __n) { } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 396. what are characters zero and one. + template + bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str, + typename std::basic_string<_CharT, _Traits, _Alloc>::size_type + __pos, + typename std::basic_string<_CharT, _Traits, _Alloc>::size_type + __n, + _CharT __zero, _CharT __one = _CharT('1')) + : _Base(__str, __pos, __n, __zero, __one) { } + + bitset(const _Base& __x) : _Base(__x) { } + + // 23.3.5.2 bitset operations: + bitset<_Nb>& + operator&=(const bitset<_Nb>& __rhs) + { + _M_base() &= __rhs; + return *this; + } + + bitset<_Nb>& + operator|=(const bitset<_Nb>& __rhs) + { + _M_base() |= __rhs; + return *this; + } + + bitset<_Nb>& + operator^=(const bitset<_Nb>& __rhs) + { + _M_base() ^= __rhs; + return *this; + } + + bitset<_Nb>& + operator<<=(size_t __pos) + { + _M_base() <<= __pos; + return *this; + } + + bitset<_Nb>& + operator>>=(size_t __pos) + { + _M_base() >>= __pos; + return *this; + } + + bitset<_Nb>& + set() + { + _Base::set(); + return *this; + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 186. bitset::set() second parameter should be bool + bitset<_Nb>& + set(size_t __pos, bool __val = true) + { + _Base::set(__pos, __val); + return *this; + } + + bitset<_Nb>& + reset() + { + _Base::reset(); + return *this; + } + + bitset<_Nb>& + reset(size_t __pos) + { + _Base::reset(__pos); + return *this; + } + + bitset<_Nb> operator~() const { return bitset(~_M_base()); } + + bitset<_Nb>& + flip() + { + _Base::flip(); + return *this; + } + + bitset<_Nb>& + flip(size_t __pos) + { + _Base::flip(__pos); + return *this; + } + + // element access: + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 11. Bitset minor problems + reference + operator[](size_t __pos) + { + return reference(_M_base()[__pos], this); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 11. Bitset minor problems + bool + operator[](size_t __pos) const + { + return _M_base()[__pos]; + } + + using _Base::to_ulong; + + template + std::basic_string<_CharT, _Traits, _Alloc> + to_string() const + { return _M_base().template to_string<_CharT, _Traits, _Alloc>(); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 396. what are characters zero and one. + template + std::basic_string<_CharT, _Traits, _Alloc> + to_string(_CharT __zero, _CharT __one = _CharT('1')) const + { + return _M_base().template + to_string<_CharT, _Traits, _Alloc>(__zero, __one); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 434. bitset::to_string() hard to use. + template + std::basic_string<_CharT, _Traits, std::allocator<_CharT> > + to_string() const + { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 853. to_string needs updating with zero and one. + template + std::basic_string<_CharT, _Traits, std::allocator<_CharT> > + to_string(_CharT __zero, _CharT __one = _CharT('1')) const + { return to_string<_CharT, _Traits, + std::allocator<_CharT> >(__zero, __one); } + + template + std::basic_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> > + to_string() const + { + return to_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> >(); + } + + template + std::basic_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> > + to_string(_CharT __zero, _CharT __one = _CharT('1')) const + { + return to_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> >(__zero, __one); + } + + std::basic_string, std::allocator > + to_string() const + { + return to_string,std::allocator >(); + } + + std::basic_string, std::allocator > + to_string(char __zero, char __one = '1') const + { + return to_string, + std::allocator >(__zero, __one); + } + + using _Base::count; + using _Base::size; + + bool + operator==(const bitset<_Nb>& __rhs) const + { return _M_base() == __rhs; } + + bool + operator!=(const bitset<_Nb>& __rhs) const + { return _M_base() != __rhs; } + + using _Base::test; + using _Base::all; + using _Base::any; + using _Base::none; + + bitset<_Nb> + operator<<(size_t __pos) const + { return bitset<_Nb>(_M_base() << __pos); } + + bitset<_Nb> + operator>>(size_t __pos) const + { return bitset<_Nb>(_M_base() >> __pos); } + + _Base& + _M_base() { return *this; } + + const _Base& + _M_base() const { return *this; } + }; + + template + bitset<_Nb> + operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) + { return bitset<_Nb>(__x) &= __y; } + + template + bitset<_Nb> + operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) + { return bitset<_Nb>(__x) |= __y; } + + template + bitset<_Nb> + operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) + { return bitset<_Nb>(__x) ^= __y; } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x) + { return __is >> __x._M_base(); } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const bitset<_Nb>& __x) + { return __os << __x._M_base(); } +} // namespace __profile +} // namespace std + +#endif diff --git a/libstdc++-v3/include/profile/deque b/libstdc++-v3/include/profile/deque new file mode 100644 index 000000000000..6ba3679e0c63 --- /dev/null +++ b/libstdc++-v3/include/profile/deque @@ -0,0 +1,420 @@ +// Profiling deque implementation -*- C++ -*- + +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file profile/deque + * This file is a GNU profile extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_PROFILE_DEQUE +#define _GLIBCXX_PROFILE_DEQUE 1 + +#include + +namespace std +{ +namespace __profile +{ + /** @brief Deque wrapper with performance instrumentation. */ + template > + class deque + : public _GLIBCXX_STD_D::deque<_Tp, _Allocator> + { + typedef _GLIBCXX_STD_D::deque<_Tp, _Allocator> _Base; + + public: + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + typedef typename _Base::reverse_iterator reverse_iterator; + typedef typename _Base::const_reverse_iterator const_reverse_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + + typedef _Tp value_type; + typedef _Allocator allocator_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + + // 23.2.1.1 construct/copy/destroy: + explicit deque(const _Allocator& __a = _Allocator()) + : _Base(__a) { } + + explicit deque(size_type __n, const _Tp& __value = _Tp(), + const _Allocator& __a = _Allocator()) + : _Base(__n, __value, __a) { } + + template + deque(_InputIterator __first, _InputIterator __last, + const _Allocator& __a = _Allocator()) + : _Base(__first, __last, __a) + { } + + deque(const deque& __x) + : _Base(__x) { } + + deque(const _Base& __x) + : _Base(__x) { } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + deque(deque&& __x) + : _Base(std::forward(__x)) + { } + + deque(initializer_list __l, + const allocator_type& __a = allocator_type()) + : _Base(__l, __a) { } +#endif + + ~deque() { } + + deque& + operator=(const deque& __x) + { + *static_cast<_Base*>(this) = __x; + return *this; + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + deque& + operator=(deque&& __x) + { + // NB: DR 675. + this->clear(); + this->swap(__x); + return *this; + } + + deque& + operator=(initializer_list __l) + { + *static_cast<_Base*>(this) = __l; + return *this; + } +#endif + + template + void + assign(_InputIterator __first, _InputIterator __last) + { + _Base::assign(__first, __last); + } + + void + assign(size_type __n, const _Tp& __t) + { + _Base::assign(__n, __t); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + void + assign(initializer_list __l) + { + _Base::assign(__l); + } +#endif + + using _Base::get_allocator; + + // iterators: + iterator + begin() + { return iterator(_Base::begin()); } + + const_iterator + begin() const + { return const_iterator(_Base::begin()); } + + iterator + end() + { return iterator(_Base::end()); } + + const_iterator + end() const + { return const_iterator(_Base::end()); } + + reverse_iterator + rbegin() + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const + { return const_reverse_iterator(begin()); } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + const_iterator + cbegin() const + { return const_iterator(_Base::begin()); } + + const_iterator + cend() const + { return const_iterator(_Base::end()); } + + const_reverse_iterator + crbegin() const + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const + { return const_reverse_iterator(begin()); } +#endif + + // 23.2.1.2 capacity: + using _Base::size; + using _Base::max_size; + + void + resize(size_type __sz, _Tp __c = _Tp()) + { + _Base::resize(__sz, __c); + } + + using _Base::empty; + + // element access: + reference + operator[](size_type __n) + { + return _M_base()[__n]; + } + + const_reference + operator[](size_type __n) const + { + return _M_base()[__n]; + } + + using _Base::at; + + reference + front() + { + return _Base::front(); + } + + const_reference + front() const + { + return _Base::front(); + } + + reference + back() + { + return _Base::back(); + } + + const_reference + back() const + { + return _Base::back(); + } + + // 23.2.1.3 modifiers: + void + push_front(const _Tp& __x) + { + _Base::push_front(__x); + } + + void + push_back(const _Tp& __x) + { + _Base::push_back(__x); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + void + push_front(_Tp&& __x) + { emplace_front(std::move(__x)); } + + void + push_back(_Tp&& __x) + { emplace_back(std::move(__x)); } + + template + void + emplace_front(_Args&&... __args) + { + _Base::emplace_front(std::forward<_Args>(__args)...); + } + + template + void + emplace_back(_Args&&... __args) + { + _Base::emplace_back(std::forward<_Args>(__args)...); + } + + template + iterator + emplace(iterator __position, _Args&&... __args) + { + typename _Base::iterator __res = _Base::emplace(__position, + std::forward<_Args>(__args)...); + return iterator(__res); + } +#endif + + iterator + insert(iterator __position, const _Tp& __x) + { + typename _Base::iterator __res = _Base::insert(__position, __x); + return iterator(__res); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + iterator + insert(iterator __position, _Tp&& __x) + { return emplace(__position, std::move(__x)); } + + void + insert(iterator __p, initializer_list __l) + { + _Base::insert(__p, __l); + } +#endif + + void + insert(iterator __position, size_type __n, const _Tp& __x) + { + _Base::insert(__position, __n, __x); + } + + template + void + insert(iterator __position, + _InputIterator __first, _InputIterator __last) + { + _Base::insert(__position, __first, __last); + } + + void + pop_front() + { + _Base::pop_front(); + } + + void + pop_back() + { + _Base::pop_back(); + } + + iterator + erase(iterator __position) + { + if (__position == begin() || __position == end()-1) + { + return iterator(_Base::erase(__position)); + } + else + { + typename _Base::iterator __res = _Base::erase(__position); + return iterator(__res); + } + } + + iterator + erase(iterator __first, iterator __last) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + return iterator(_Base::erase(__first, __last)); + } + + void + swap(deque& __x) + { + _Base::swap(__x); + } + + void + clear() + { + _Base::clear(); + } + + _Base& + _M_base() { return *this; } + + const _Base& + _M_base() const { return *this; } + }; + + template + inline bool + operator==(const deque<_Tp, _Alloc>& __lhs, + const deque<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() == __rhs._M_base(); } + + template + inline bool + operator!=(const deque<_Tp, _Alloc>& __lhs, + const deque<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() != __rhs._M_base(); } + + template + inline bool + operator<(const deque<_Tp, _Alloc>& __lhs, + const deque<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() < __rhs._M_base(); } + + template + inline bool + operator<=(const deque<_Tp, _Alloc>& __lhs, + const deque<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() <= __rhs._M_base(); } + + template + inline bool + operator>=(const deque<_Tp, _Alloc>& __lhs, + const deque<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() >= __rhs._M_base(); } + + template + inline bool + operator>(const deque<_Tp, _Alloc>& __lhs, + const deque<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() > __rhs._M_base(); } + + template + inline void + swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs) + { __lhs.swap(__rhs); } + +} // namespace __profile +} // namespace std + +#endif diff --git a/libstdc++-v3/include/profile/hashtable.h b/libstdc++-v3/include/profile/hashtable.h new file mode 100644 index 000000000000..208918771212 --- /dev/null +++ b/libstdc++-v3/include/profile/hashtable.h @@ -0,0 +1,1151 @@ +// Hashtable implementation used by containers -*- C++ -*- + +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 +// Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +/* + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + */ + +/** @file profile/hashtable.h copied from backward/hashtable.h + * This file is a GNU extension to the Standard C++ Library (possibly + * containing extensions from the HP/SGI STL subset). + */ + +#ifndef _HASHTABLE_H +#define _HASHTABLE_H 1 + +// Hashtable class, used to implement the hashed associative containers +// hash_set, hash_map, hash_multiset, and hash_multimap. +// Skip instrumentation on vector. +#include +#include +#include +#include +#include +#include + +_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) + + using std::size_t; + using std::ptrdiff_t; + using std::forward_iterator_tag; + using std::input_iterator_tag; + using std::_Construct; + using std::_Destroy; + using std::distance; + using std::_GLIBCXX_STD_D::vector; + using std::pair; + using std::__iterator_category; + + template + struct _Hashtable_node + { + _Hashtable_node* _M_next; + _Val _M_val; + }; + + template > + class hashtable; + + template + struct _Hashtable_iterator; + + template + struct _Hashtable_const_iterator; + + template + struct _Hashtable_iterator + { + typedef hashtable<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc> + _Hashtable; + typedef _Hashtable_iterator<_Val, _Key, _HashFcn, + _ExtractKey, _EqualKey, _Alloc> + iterator; + typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn, + _ExtractKey, _EqualKey, _Alloc> + const_iterator; + typedef _Hashtable_node<_Val> _Node; + typedef forward_iterator_tag iterator_category; + typedef _Val value_type; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + typedef _Val& reference; + typedef _Val* pointer; + + _Node* _M_cur; + _Hashtable* _M_ht; + + _Hashtable_iterator(_Node* __n, _Hashtable* __tab) + : _M_cur(__n), _M_ht(__tab) { } + + _Hashtable_iterator() { } + + reference + operator*() const + { return _M_cur->_M_val; } + + pointer + operator->() const + { return &(operator*()); } + + iterator& + operator++(); + + iterator + operator++(int); + + bool + operator==(const iterator& __it) const + { return _M_cur == __it._M_cur; } + + bool + operator!=(const iterator& __it) const + { return _M_cur != __it._M_cur; } + }; + + template + struct _Hashtable_const_iterator + { + typedef hashtable<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc> + _Hashtable; + typedef _Hashtable_iterator<_Val,_Key,_HashFcn, + _ExtractKey,_EqualKey,_Alloc> + iterator; + typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn, + _ExtractKey, _EqualKey, _Alloc> + const_iterator; + typedef _Hashtable_node<_Val> _Node; + + typedef forward_iterator_tag iterator_category; + typedef _Val value_type; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + typedef const _Val& reference; + typedef const _Val* pointer; + + const _Node* _M_cur; + const _Hashtable* _M_ht; + + _Hashtable_const_iterator(const _Node* __n, const _Hashtable* __tab) + : _M_cur(__n), _M_ht(__tab) { } + + _Hashtable_const_iterator() { } + + _Hashtable_const_iterator(const iterator& __it) + : _M_cur(__it._M_cur), _M_ht(__it._M_ht) { } + + reference + operator*() const + { return _M_cur->_M_val; } + + pointer + operator->() const + { return &(operator*()); } + + const_iterator& + operator++(); + + const_iterator + operator++(int); + + bool + operator==(const const_iterator& __it) const + { return _M_cur == __it._M_cur; } + + bool + operator!=(const const_iterator& __it) const + { return _M_cur != __it._M_cur; } + }; + + // Note: assumes long is at least 32 bits. + enum { _S_num_primes = 28 }; + + static const unsigned long __stl_prime_list[_S_num_primes] = + { + 53ul, 97ul, 193ul, 389ul, 769ul, + 1543ul, 3079ul, 6151ul, 12289ul, 24593ul, + 49157ul, 98317ul, 196613ul, 393241ul, 786433ul, + 1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul, + 50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul, + 1610612741ul, 3221225473ul, 4294967291ul + }; + + inline unsigned long + __stl_next_prime(unsigned long __n) + { + const unsigned long* __first = __stl_prime_list; + const unsigned long* __last = __stl_prime_list + (int)_S_num_primes; + const unsigned long* pos = std::lower_bound(__first, __last, __n); + return pos == __last ? *(__last - 1) : *pos; + } + + // Forward declaration of operator==. + template + class hashtable; + + template + bool + operator==(const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht1, + const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht2); + + // Hashtables handle allocators a bit differently than other + // containers do. If we're using standard-conforming allocators, then + // a hashtable unconditionally has a member variable to hold its + // allocator, even if it so happens that all instances of the + // allocator type are identical. This is because, for hashtables, + // this extra storage is negligible. Additionally, a base class + // wouldn't serve any other purposes; it wouldn't, for example, + // simplify the exception-handling code. + template + class hashtable + { + public: + typedef _Key key_type; + typedef _Val value_type; + typedef _HashFcn hasher; + typedef _EqualKey key_equal; + + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + + hasher + hash_funct() const + { return _M_hash; } + + key_equal + key_eq() const + { return _M_equals; } + + private: + typedef _Hashtable_node<_Val> _Node; + + public: + typedef typename _Alloc::template rebind::other allocator_type; + allocator_type + get_allocator() const + { return _M_node_allocator; } + + private: + typedef typename _Alloc::template rebind<_Node>::other _Node_Alloc; + typedef typename _Alloc::template rebind<_Node*>::other _Nodeptr_Alloc; + typedef vector<_Node*, _Nodeptr_Alloc> _Vector_type; + + _Node_Alloc _M_node_allocator; + + _Node* + _M_get_node() + { return _M_node_allocator.allocate(1); } + + void + _M_put_node(_Node* __p) + { _M_node_allocator.deallocate(__p, 1); } + + private: + hasher _M_hash; + key_equal _M_equals; + _ExtractKey _M_get_key; + _Vector_type _M_buckets; + size_type _M_num_elements; + + public: + typedef _Hashtable_iterator<_Val, _Key, _HashFcn, _ExtractKey, + _EqualKey, _Alloc> + iterator; + typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn, _ExtractKey, + _EqualKey, _Alloc> + const_iterator; + + friend struct + _Hashtable_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>; + + friend struct + _Hashtable_const_iterator<_Val, _Key, _HashFcn, _ExtractKey, + _EqualKey, _Alloc>; + + public: + hashtable(size_type __n, const _HashFcn& __hf, + const _EqualKey& __eql, const _ExtractKey& __ext, + const allocator_type& __a = allocator_type()) + : _M_node_allocator(__a), _M_hash(__hf), _M_equals(__eql), + _M_get_key(__ext), _M_buckets(__a), _M_num_elements(0) + { _M_initialize_buckets(__n); } + + hashtable(size_type __n, const _HashFcn& __hf, + const _EqualKey& __eql, + const allocator_type& __a = allocator_type()) + : _M_node_allocator(__a), _M_hash(__hf), _M_equals(__eql), + _M_get_key(_ExtractKey()), _M_buckets(__a), _M_num_elements(0) + { _M_initialize_buckets(__n); } + + hashtable(const hashtable& __ht) + : _M_node_allocator(__ht.get_allocator()), _M_hash(__ht._M_hash), + _M_equals(__ht._M_equals), _M_get_key(__ht._M_get_key), + _M_buckets(__ht.get_allocator()), _M_num_elements(0) + { _M_copy_from(__ht); } + + hashtable& + operator= (const hashtable& __ht) + { + if (&__ht != this) + { + clear(); + _M_hash = __ht._M_hash; + _M_equals = __ht._M_equals; + _M_get_key = __ht._M_get_key; + _M_copy_from(__ht); + } + return *this; + } + + ~hashtable() + { clear(); } + + size_type + size() const + { return _M_num_elements; } + + size_type + max_size() const + { return size_type(-1); } + + bool + empty() const + { return size() == 0; } + + void + swap(hashtable& __ht) + { + std::swap(_M_hash, __ht._M_hash); + std::swap(_M_equals, __ht._M_equals); + std::swap(_M_get_key, __ht._M_get_key); + _M_buckets.swap(__ht._M_buckets); + std::swap(_M_num_elements, __ht._M_num_elements); + } + + iterator + begin() + { + for (size_type __n = 0; __n < _M_buckets.size(); ++__n) + if (_M_buckets[__n]) + return iterator(_M_buckets[__n], this); + return end(); + } + + iterator + end() + { return iterator(0, this); } + + const_iterator + begin() const + { + for (size_type __n = 0; __n < _M_buckets.size(); ++__n) + if (_M_buckets[__n]) + return const_iterator(_M_buckets[__n], this); + return end(); + } + + const_iterator + end() const + { return const_iterator(0, this); } + + template + friend bool + operator==(const hashtable<_Vl, _Ky, _HF, _Ex, _Eq, _Al>&, + const hashtable<_Vl, _Ky, _HF, _Ex, _Eq, _Al>&); + + public: + size_type + bucket_count() const + { return _M_buckets.size(); } + + size_type + max_bucket_count() const + { return __stl_prime_list[(int)_S_num_primes - 1]; } + + size_type + elems_in_bucket(size_type __bucket) const + { + size_type __result = 0; + for (_Node* __n = _M_buckets[__bucket]; __n; __n = __n->_M_next) + __result += 1; + return __result; + } + + pair + insert_unique(const value_type& __obj) + { + resize(_M_num_elements + 1); + return insert_unique_noresize(__obj); + } + + iterator + insert_equal(const value_type& __obj) + { + resize(_M_num_elements + 1); + return insert_equal_noresize(__obj); + } + + pair + insert_unique_noresize(const value_type& __obj); + + iterator + insert_equal_noresize(const value_type& __obj); + + template + void + insert_unique(_InputIterator __f, _InputIterator __l) + { insert_unique(__f, __l, __iterator_category(__f)); } + + template + void + insert_equal(_InputIterator __f, _InputIterator __l) + { insert_equal(__f, __l, __iterator_category(__f)); } + + template + void + insert_unique(_InputIterator __f, _InputIterator __l, + input_iterator_tag) + { + for ( ; __f != __l; ++__f) + insert_unique(*__f); + } + + template + void + insert_equal(_InputIterator __f, _InputIterator __l, + input_iterator_tag) + { + for ( ; __f != __l; ++__f) + insert_equal(*__f); + } + + template + void + insert_unique(_ForwardIterator __f, _ForwardIterator __l, + forward_iterator_tag) + { + size_type __n = distance(__f, __l); + resize(_M_num_elements + __n); + for ( ; __n > 0; --__n, ++__f) + insert_unique_noresize(*__f); + } + + template + void + insert_equal(_ForwardIterator __f, _ForwardIterator __l, + forward_iterator_tag) + { + size_type __n = distance(__f, __l); + resize(_M_num_elements + __n); + for ( ; __n > 0; --__n, ++__f) + insert_equal_noresize(*__f); + } + + reference + find_or_insert(const value_type& __obj); + + iterator + find(const key_type& __key) + { + size_type __n = _M_bkt_num_key(__key); + _Node* __first; + for (__first = _M_buckets[__n]; + __first && !_M_equals(_M_get_key(__first->_M_val), __key); + __first = __first->_M_next) + { } + return iterator(__first, this); + } + + const_iterator + find(const key_type& __key) const + { + size_type __n = _M_bkt_num_key(__key); + const _Node* __first; + for (__first = _M_buckets[__n]; + __first && !_M_equals(_M_get_key(__first->_M_val), __key); + __first = __first->_M_next) + { } + return const_iterator(__first, this); + } + + size_type + count(const key_type& __key) const + { + const size_type __n = _M_bkt_num_key(__key); + size_type __result = 0; + + for (const _Node* __cur = _M_buckets[__n]; __cur; + __cur = __cur->_M_next) + if (_M_equals(_M_get_key(__cur->_M_val), __key)) + ++__result; + return __result; + } + + pair + equal_range(const key_type& __key); + + pair + equal_range(const key_type& __key) const; + + size_type + erase(const key_type& __key); + + void + erase(const iterator& __it); + + void + erase(iterator __first, iterator __last); + + void + erase(const const_iterator& __it); + + void + erase(const_iterator __first, const_iterator __last); + + void + resize(size_type __num_elements_hint); + + void + clear(); + + private: + size_type + _M_next_size(size_type __n) const + { return __stl_next_prime(__n); } + + void + _M_initialize_buckets(size_type __n) + { + const size_type __n_buckets = _M_next_size(__n); + _M_buckets.reserve(__n_buckets); + _M_buckets.insert(_M_buckets.end(), __n_buckets, (_Node*) 0); + _M_num_elements = 0; + __profcxx_hashtable_construct(this, __n_buckets); + __profcxx_hashtable_construct2(this); + } + + size_type + _M_bkt_num_key(const key_type& __key) const + { return _M_bkt_num_key(__key, _M_buckets.size()); } + + size_type + _M_bkt_num(const value_type& __obj) const + { return _M_bkt_num_key(_M_get_key(__obj)); } + + size_type + _M_bkt_num_key(const key_type& __key, size_t __n) const + { return _M_hash(__key) % __n; } + + size_type + _M_bkt_num(const value_type& __obj, size_t __n) const + { return _M_bkt_num_key(_M_get_key(__obj), __n); } + + _Node* + _M_new_node(const value_type& __obj) + { + _Node* __n = _M_get_node(); + __n->_M_next = 0; + try + { + this->get_allocator().construct(&__n->_M_val, __obj); + return __n; + } + catch(...) + { + _M_put_node(__n); + __throw_exception_again; + } + } + + void + _M_delete_node(_Node* __n) + { + this->get_allocator().destroy(&__n->_M_val); + _M_put_node(__n); + } + + void + _M_erase_bucket(const size_type __n, _Node* __first, _Node* __last); + + void + _M_erase_bucket(const size_type __n, _Node* __last); + + void + _M_copy_from(const hashtable& __ht); + }; + + template + _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>& + _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>:: + operator++() + { + const _Node* __old = _M_cur; + _M_cur = _M_cur->_M_next; + if (!_M_cur) + { + size_type __bucket = _M_ht->_M_bkt_num(__old->_M_val); + while (!_M_cur && ++__bucket < _M_ht->_M_buckets.size()) + _M_cur = _M_ht->_M_buckets[__bucket]; + } + return *this; + } + + template + inline _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All> + _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>:: + operator++(int) + { + iterator __tmp = *this; + ++*this; + return __tmp; + } + + template + _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>& + _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>:: + operator++() + { + const _Node* __old = _M_cur; + _M_cur = _M_cur->_M_next; + if (!_M_cur) + { + size_type __bucket = _M_ht->_M_bkt_num(__old->_M_val); + while (!_M_cur && ++__bucket < _M_ht->_M_buckets.size()) + _M_cur = _M_ht->_M_buckets[__bucket]; + } + return *this; + } + + template + inline _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All> + _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>:: + operator++(int) + { + const_iterator __tmp = *this; + ++*this; + return __tmp; + } + + template + bool + operator==(const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht1, + const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht2) + { + typedef typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::_Node _Node; + + if (__ht1._M_buckets.size() != __ht2._M_buckets.size()) + return false; + + for (size_t __n = 0; __n < __ht1._M_buckets.size(); ++__n) + { + _Node* __cur1 = __ht1._M_buckets[__n]; + _Node* __cur2 = __ht2._M_buckets[__n]; + // Check same length of lists + for (; __cur1 && __cur2; + __cur1 = __cur1->_M_next, __cur2 = __cur2->_M_next) + { } + if (__cur1 || __cur2) + return false; + // Now check one's elements are in the other + for (__cur1 = __ht1._M_buckets[__n] ; __cur1; + __cur1 = __cur1->_M_next) + { + bool _found__cur1 = false; + for (__cur2 = __ht2._M_buckets[__n]; + __cur2; __cur2 = __cur2->_M_next) + { + if (__cur1->_M_val == __cur2->_M_val) + { + _found__cur1 = true; + break; + } + } + if (!_found__cur1) + return false; + } + } + return true; + } + + template + inline bool + operator!=(const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht1, + const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht2) + { return !(__ht1 == __ht2); } + + template + inline void + swap(hashtable<_Val, _Key, _HF, _Extract, _EqKey, _All>& __ht1, + hashtable<_Val, _Key, _HF, _Extract, _EqKey, _All>& __ht2) + { __ht1.swap(__ht2); } + + template + pair::iterator, bool> + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + insert_unique_noresize(const value_type& __obj) + { + const size_type __n = _M_bkt_num(__obj); + _Node* __first = _M_buckets[__n]; + + for (_Node* __cur = __first; __cur; __cur = __cur->_M_next) + if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj))) + return pair(iterator(__cur, this), false); + + _Node* __tmp = _M_new_node(__obj); + __tmp->_M_next = __first; + _M_buckets[__n] = __tmp; + ++_M_num_elements; + return pair(iterator(__tmp, this), true); + } + + template + typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::iterator + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + insert_equal_noresize(const value_type& __obj) + { + const size_type __n = _M_bkt_num(__obj); + _Node* __first = _M_buckets[__n]; + + for (_Node* __cur = __first; __cur; __cur = __cur->_M_next) + if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj))) + { + _Node* __tmp = _M_new_node(__obj); + __tmp->_M_next = __cur->_M_next; + __cur->_M_next = __tmp; + ++_M_num_elements; + return iterator(__tmp, this); + } + + _Node* __tmp = _M_new_node(__obj); + __tmp->_M_next = __first; + _M_buckets[__n] = __tmp; + ++_M_num_elements; + return iterator(__tmp, this); + } + + template + typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::reference + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + find_or_insert(const value_type& __obj) + { + resize(_M_num_elements + 1); + + size_type __n = _M_bkt_num(__obj); + _Node* __first = _M_buckets[__n]; + + for (_Node* __cur = __first; __cur; __cur = __cur->_M_next) + if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj))) + return __cur->_M_val; + + _Node* __tmp = _M_new_node(__obj); + __tmp->_M_next = __first; + _M_buckets[__n] = __tmp; + ++_M_num_elements; + return __tmp->_M_val; + } + + template + pair::iterator, + typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::iterator> + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + equal_range(const key_type& __key) + { + typedef pair _Pii; + const size_type __n = _M_bkt_num_key(__key); + + for (_Node* __first = _M_buckets[__n]; __first; + __first = __first->_M_next) + if (_M_equals(_M_get_key(__first->_M_val), __key)) + { + for (_Node* __cur = __first->_M_next; __cur; + __cur = __cur->_M_next) + if (!_M_equals(_M_get_key(__cur->_M_val), __key)) + return _Pii(iterator(__first, this), iterator(__cur, this)); + for (size_type __m = __n + 1; __m < _M_buckets.size(); ++__m) + if (_M_buckets[__m]) + return _Pii(iterator(__first, this), + iterator(_M_buckets[__m], this)); + return _Pii(iterator(__first, this), end()); + } + return _Pii(end(), end()); + } + + template + pair::const_iterator, + typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::const_iterator> + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + equal_range(const key_type& __key) const + { + typedef pair _Pii; + const size_type __n = _M_bkt_num_key(__key); + + for (const _Node* __first = _M_buckets[__n]; __first; + __first = __first->_M_next) + { + if (_M_equals(_M_get_key(__first->_M_val), __key)) + { + for (const _Node* __cur = __first->_M_next; __cur; + __cur = __cur->_M_next) + if (!_M_equals(_M_get_key(__cur->_M_val), __key)) + return _Pii(const_iterator(__first, this), + const_iterator(__cur, this)); + for (size_type __m = __n + 1; __m < _M_buckets.size(); ++__m) + if (_M_buckets[__m]) + return _Pii(const_iterator(__first, this), + const_iterator(_M_buckets[__m], this)); + return _Pii(const_iterator(__first, this), end()); + } + } + return _Pii(end(), end()); + } + + template + typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::size_type + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + erase(const key_type& __key) + { + const size_type __n = _M_bkt_num_key(__key); + _Node* __first = _M_buckets[__n]; + size_type __erased = 0; + + if (__first) + { + _Node* __cur = __first; + _Node* __next = __cur->_M_next; + while (__next) + { + if (_M_equals(_M_get_key(__next->_M_val), __key)) + { + __cur->_M_next = __next->_M_next; + _M_delete_node(__next); + __next = __cur->_M_next; + ++__erased; + --_M_num_elements; + } + else + { + __cur = __next; + __next = __cur->_M_next; + } + } + if (_M_equals(_M_get_key(__first->_M_val), __key)) + { + _M_buckets[__n] = __first->_M_next; + _M_delete_node(__first); + ++__erased; + --_M_num_elements; + } + } + return __erased; + } + + template + void hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + erase(const iterator& __it) + { + _Node* __p = __it._M_cur; + if (__p) + { + const size_type __n = _M_bkt_num(__p->_M_val); + _Node* __cur = _M_buckets[__n]; + + if (__cur == __p) + { + _M_buckets[__n] = __cur->_M_next; + _M_delete_node(__cur); + --_M_num_elements; + } + else + { + _Node* __next = __cur->_M_next; + while (__next) + { + if (__next == __p) + { + __cur->_M_next = __next->_M_next; + _M_delete_node(__next); + --_M_num_elements; + break; + } + else + { + __cur = __next; + __next = __cur->_M_next; + } + } + } + } + } + + template + void + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + erase(iterator __first, iterator __last) + { + size_type __f_bucket = __first._M_cur ? _M_bkt_num(__first._M_cur->_M_val) + : _M_buckets.size(); + + size_type __l_bucket = __last._M_cur ? _M_bkt_num(__last._M_cur->_M_val) + : _M_buckets.size(); + + if (__first._M_cur == __last._M_cur) + return; + else if (__f_bucket == __l_bucket) + _M_erase_bucket(__f_bucket, __first._M_cur, __last._M_cur); + else + { + _M_erase_bucket(__f_bucket, __first._M_cur, 0); + for (size_type __n = __f_bucket + 1; __n < __l_bucket; ++__n) + _M_erase_bucket(__n, 0); + if (__l_bucket != _M_buckets.size()) + _M_erase_bucket(__l_bucket, __last._M_cur); + } + } + + template + inline void + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + erase(const_iterator __first, const_iterator __last) + { + erase(iterator(const_cast<_Node*>(__first._M_cur), + const_cast(__first._M_ht)), + iterator(const_cast<_Node*>(__last._M_cur), + const_cast(__last._M_ht))); + } + + template + inline void + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + erase(const const_iterator& __it) + { erase(iterator(const_cast<_Node*>(__it._M_cur), + const_cast(__it._M_ht))); } + + template + void + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + resize(size_type __num_elements_hint) + { + const size_type __old_n = _M_buckets.size(); + if (__num_elements_hint > __old_n) + { + const size_type __n = _M_next_size(__num_elements_hint); + if (__n > __old_n) + { + _Vector_type __tmp(__n, (_Node*)(0), _M_buckets.get_allocator()); + try + { + for (size_type __bucket = 0; __bucket < __old_n; ++__bucket) + { + _Node* __first = _M_buckets[__bucket]; + while (__first) + { + size_type __new_bucket = _M_bkt_num(__first->_M_val, + __n); + _M_buckets[__bucket] = __first->_M_next; + __first->_M_next = __tmp[__new_bucket]; + __tmp[__new_bucket] = __first; + __first = _M_buckets[__bucket]; + } + } + _M_buckets.swap(__tmp); + } + catch(...) + { + for (size_type __bucket = 0; __bucket < __tmp.size(); + ++__bucket) + { + while (__tmp[__bucket]) + { + _Node* __next = __tmp[__bucket]->_M_next; + _M_delete_node(__tmp[__bucket]); + __tmp[__bucket] = __next; + } + } + __throw_exception_again; + } + __profcxx_hashtable_resize(this, __num_elements_hint, __n); + } + } + } + + template + void + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + _M_erase_bucket(const size_type __n, _Node* __first, _Node* __last) + { + _Node* __cur = _M_buckets[__n]; + if (__cur == __first) + _M_erase_bucket(__n, __last); + else + { + _Node* __next; + for (__next = __cur->_M_next; + __next != __first; + __cur = __next, __next = __cur->_M_next) + ; + while (__next != __last) + { + __cur->_M_next = __next->_M_next; + _M_delete_node(__next); + __next = __cur->_M_next; + --_M_num_elements; + } + } + } + + template + void + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + _M_erase_bucket(const size_type __n, _Node* __last) + { + _Node* __cur = _M_buckets[__n]; + while (__cur != __last) + { + _Node* __next = __cur->_M_next; + _M_delete_node(__cur); + __cur = __next; + _M_buckets[__n] = __cur; + --_M_num_elements; + } + } + + template + void + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + clear() + { + size_type __hops=0, __lc = 0, __chain = 0; + if (_M_num_elements != 0) + __profcxx_hashtable_destruct(this, _M_buckets.size(), _M_num_elements); + + for (size_type __i = 0; __i < _M_buckets.size(); ++__i) + { + _Node* __cur = _M_buckets[__i]; + while (__cur != 0) + { + _Node* __next = __cur->_M_next; + _M_delete_node(__cur); + __cur = __next; + + // Compute the longest chain count. + __chain++; + } + _M_buckets[__i] = 0; + + // Collect number of hops. + if (__chain > 1) { + __lc = __lc > __chain ? __lc : __chain; + __hops += (__chain-1) * __chain / 2; + } + __chain = 0; + } + if (_M_num_elements) { + __profcxx_hashtable_destruct2(this, __lc, _M_num_elements, __hops); + } + _M_num_elements = 0; + } + + template + void + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + _M_copy_from(const hashtable& __ht) + { + _M_buckets.clear(); + _M_buckets.reserve(__ht._M_buckets.size()); + _M_buckets.insert(_M_buckets.end(), __ht._M_buckets.size(), (_Node*) 0); + try + { + for (size_type __i = 0; __i < __ht._M_buckets.size(); ++__i) { + const _Node* __cur = __ht._M_buckets[__i]; + if (__cur) + { + _Node* __local_copy = _M_new_node(__cur->_M_val); + _M_buckets[__i] = __local_copy; + + for (_Node* __next = __cur->_M_next; + __next; + __cur = __next, __next = __cur->_M_next) + { + __local_copy->_M_next = _M_new_node(__next->_M_val); + __local_copy = __local_copy->_M_next; + } + } + } + _M_num_elements = __ht._M_num_elements; + } + catch(...) + { + clear(); + __throw_exception_again; + } + } + +_GLIBCXX_END_NAMESPACE + +#endif diff --git a/libstdc++-v3/include/profile/impl/profiler.h b/libstdc++-v3/include/profile/impl/profiler.h new file mode 100644 index 000000000000..f86920344fcd --- /dev/null +++ b/libstdc++-v3/include/profile/impl/profiler.h @@ -0,0 +1,326 @@ +// -*- C++ -*- +// +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 2, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. + +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/** @file profile/impl/profiler.h + * @brief Interface of the profiling runtime library. + */ + +// Written by Lixia Liu and Silvius Rus. + +#ifndef PROFCXX_PROFILER_H__ +#define PROFCXX_PROFILER_H__ 1 + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include +#else +#include +#endif + +/** + * @namespace std::__cxxprof_guard + * @brief Mechanism to protect all __cxxprof_impl operations against + * multithreaded and exception reentrance. + */ +namespace __cxxprof_guard +{ + +/** @brief Reentrance guard. + * + * Mechanism to protect all __cxxprof_impl operations against recursion, + * multithreaded and exception reentrance. + */ +template +class __reentrance_guard +{ + public: + static __thread bool __inside_cxxprof_impl; + static bool __get_in(); + __reentrance_guard() {} + ~__reentrance_guard() { __inside_cxxprof_impl = false; } +}; + +template +__thread bool __reentrance_guard<_Unused>::__inside_cxxprof_impl = false; + +template +bool __reentrance_guard<_Unused>::__get_in() +{ + if (__inside_cxxprof_impl) { + return false; + } else { + __inside_cxxprof_impl = true; + return true; + } +} + +} // namespace __cxxprof_guard + +#define _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__x...) \ + { \ + if (__cxxprof_guard::__reentrance_guard<0>::__get_in()) \ + { \ + __cxxprof_guard::__reentrance_guard<0> __auto_get_out; \ + __x; \ + } \ + } + +/** + * @namespace std::__cxxprof_impl + * @brief Implementation of profile extension. + */ +namespace __cxxprof_impl +{ +// Forward declarations of implementation functions. +// Don't use any __cxxprof_impl:: in user code. +// Instead, use the __profcxx... macros, which offer guarded access. +void __turn_on(); +void __turn_off(); +bool __is_invalid(); +bool __is_on(); +bool __is_off(); +void __report(void); +void __trace_hashtable_size_resize(const void*, size_t, size_t); +void __trace_hashtable_size_destruct(const void*, size_t, size_t); +void __trace_hashtable_size_construct(const void*, size_t); +void __trace_vector_size_resize(const void*, size_t, size_t); +void __trace_vector_size_destruct(const void*, size_t, size_t); +void __trace_vector_size_construct(const void*, size_t); +void __trace_hash_func_destruct(const void*, size_t, size_t, size_t); +void __trace_hash_func_construct(const void*); +void __trace_vector_to_list_destruct(const void*); +void __trace_vector_to_list_construct(const void*); +void __trace_vector_to_list_insert(const void*, size_t, size_t); +void __trace_vector_to_list_iterate(const void*, size_t); +void __trace_vector_to_list_invalid_operator(const void*); +void __trace_vector_to_list_resize(const void*, size_t, size_t); +void __trace_map_to_unordered_map_construct(const void*); +void __trace_map_to_unordered_map_invalidate(const void*); +void __trace_map_to_unordered_map_insert(const void*, size_t, size_t); +void __trace_map_to_unordered_map_erase(const void*, size_t, size_t); +void __trace_map_to_unordered_map_iterate(const void*, size_t); +void __trace_map_to_unordered_map_find(const void*, size_t); +void __trace_map_to_unordered_map_destruct(const void*); +} // namespace __cxxprof_impl + +// Master switch turns on all diagnostics. +#ifdef _GLIBCXX_PROFILE +#define _GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL +#define _GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE +#define _GLIBCXX_PROFILE_VECTOR_TOO_SMALL +#define _GLIBCXX_PROFILE_VECTOR_TOO_LARGE +#define _GLIBCXX_PROFILE_INEFFICIENT_HASH +#define _GLIBCXX_PROFILE_VECTOR_TO_LIST +#define _GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP +#endif + +// Expose global management routines to user code. +#ifdef _GLIBCXX_PROFILE +#define __profcxx_report() \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__report()) +#define __profcxx_turn_on() \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__turn_on()) +#define __profcxx_turn_off() \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__turn_off()) +#define __profcxx_is_invalid() \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__is_invalid()) +#define __profcxx_is_on() \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__is_on()) +#define __profcxx__is_off() \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__is_off()) +#else +#define __profcxx_report() +#define __profcxx_turn_on() +#define __profcxx_turn_off() +#define __profcxx_is_invalid() +#define __profcxx_is_on() +#define __profcxx_is_off() +#endif + +// Turn on/off instrumentation for HASHTABLE_TOO_SMALL and HASHTABLE_TOO_LARGE. +#if ((defined(_GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL) \ + && !defined(_NO_GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL)) \ + || (defined(_GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE) \ + && !defined(_NO_GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE))) +#define __profcxx_hashtable_resize(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_hashtable_size_resize(__x)) +#define __profcxx_hashtable_destruct(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_hashtable_size_destruct(__x)) +#define __profcxx_hashtable_construct(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_hashtable_size_construct(__x)) +#else +#define __profcxx_hashtable_resize(__x...) +#define __profcxx_hashtable_destruct(__x...) +#define __profcxx_hashtable_construct(__x...) +#endif + +// Turn on/off instrumentation for VECTOR_TOO_SMALL and VECTOR_TOO_LARGE. +#if ((defined(_GLIBCXX_PROFILE_VECTOR_TOO_SMALL) \ + && !defined(_NO_GLIBCXX_PROFILE_VECTOR_TOO_SMALL)) \ + || (defined(_GLIBCXX_PROFILE_VECTOR_TOO_LARGE) \ + && !defined(_NO_GLIBCXX_PROFILE_VECTOR_TOO_LARGE))) +#define __profcxx_vector_resize(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_vector_size_resize(__x)) +#define __profcxx_vector_destruct(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_vector_size_destruct(__x)) +#define __profcxx_vector_construct(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_vector_size_construct(__x)) +#else +#define __profcxx_vector_resize(__x...) +#define __profcxx_vector_destruct(__x...) +#define __profcxx_vector_construct(__x...) +#endif + +// Turn on/off instrumentation for INEFFICIENT_HASH. +#if (defined(_GLIBCXX_PROFILE_INEFFICIENT_HASH) \ + && !defined(_NO_GLIBCXX_PROFILE_INEFFICIENT_HASH)) +#define __profcxx_hashtable_construct2(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_hash_func_construct(__x)) +#define __profcxx_hashtable_destruct2(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_hash_func_destruct(__x)) +#else +#define __profcxx_hashtable_destruct2(__x...) +#define __profcxx_hashtable_construct2(__x...) +#endif + +// Turn on/off instrumentation for VECTOR_TO_LIST. +#if (defined(_GLIBCXX_PROFILE_VECTOR_TO_LIST) \ + && !defined(_NO_GLIBCXX_PROFILE_VECTOR_TO_LIST)) +#define __profcxx_vector_construct2(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_vector_to_list_construct(__x)) +#define __profcxx_vector_destruct2(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_vector_to_list_destruct(__x)) +#define __profcxx_vector_insert(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_vector_to_list_insert(__x)) +#define __profcxx_vector_iterate(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_vector_to_list_iterate(__x)) +#define __profcxx_vector_invalid_operator(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_vector_to_list_invalid_operator(__x)) +#define __profcxx_vector_resize2(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_vector_to_list_resize(__x)) +#else +#define __profcxx_vector_destruct2(__x...) +#define __profcxx_vector_construct2(__x...) +#define __profcxx_vector_insert(__x...) +#define __profcxx_vector_iterate(__x...) +#define __profcxx_vector_invalid_operator(__x...) +#define __profcxx_vector_resize2(__x...) +#endif + +// Turn on/off instrumentation for MAP_TO_UNORDERED_MAP. +#if (defined(_GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP) \ + && !defined(_NO_GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP)) +#define __profcxx_map_to_unordered_map_construct(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_map_to_unordered_map_construct(__x)) +#define __profcxx_map_to_unordered_map_destruct(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_map_to_unordered_map_destruct(__x)) +#define __profcxx_map_to_unordered_map_insert(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_map_to_unordered_map_insert(__x)) +#define __profcxx_map_to_unordered_map_erase(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_map_to_unordered_map_erase(__x)) +#define __profcxx_map_to_unordered_map_iterate(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_map_to_unordered_map_iterate(__x)) +#define __profcxx_map_to_unordered_map_invalidate(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_map_to_unordered_map_invalidate(__x)) +#define __profcxx_map_to_unordered_map_find(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_map_to_unordered_map_find(__x)) +#else +#define __profcxx_map_to_unordered_map_construct(__x...) \ + +#define __profcxx_map_to_unordered_map_destruct(__x...) +#define __profcxx_map_to_unordered_map_insert(__x...) +#define __profcxx_map_to_unordered_map_erase(__x...) +#define __profcxx_map_to_unordered_map_iterate(__x...) +#define __profcxx_map_to_unordered_map_invalidate(__x...) +#define __profcxx_map_to_unordered_map_find(__x...) +#endif + +// Run multithreaded unless instructed not to do so. +#ifndef _GLIBCXX_PROFILE_NOTHREADS +#define _GLIBCXX_PROFILE_THREADS +#endif + +// Set default values for compile-time customizable variables. +#ifndef _GLIBCXX_PROFILE_TRACE_PATH_ROOT +#define _GLIBCXX_PROFILE_TRACE_PATH_ROOT "libstdcxx-profile" +#endif +#ifndef _GLIBCXX_PROFILE_TRACE_ENV_VAR +#define _GLIBCXX_PROFILE_TRACE_ENV_VAR "GLIBCXX_PROFILE_TRACE_PATH_ROOT" +#endif +#ifndef _GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR +#define _GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR \ + "GLIBCXX_PROFILE_MAX_WARN_COUNT" +#endif +#ifndef _GLIBCXX_PROFILE_MAX_WARN_COUNT +#define _GLIBCXX_PROFILE_MAX_WARN_COUNT 10 +#endif +#ifndef _GLIBCXX_PROFILE_MAX_STACK_DEPTH +#define _GLIBCXX_PROFILE_MAX_STACK_DEPTH 32 +#endif +#ifndef _GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR +#define _GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR \ + "GLIBCXX_PROFILE_MAX_STACK_DEPTH" +#endif +#ifndef _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC +#define _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC 2 << 27 +#endif +#ifndef _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR +#define _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR \ + "GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC" +#endif + +// Instrumentation hook implementations. +#include "profile/impl/profiler_hash_func.h" +#include "profile/impl/profiler_hashtable_size.h" +#include "profile/impl/profiler_map_to_unordered_map.h" +#include "profile/impl/profiler_vector_size.h" +#include "profile/impl/profiler_vector_to_list.h" + +#endif // PROFCXX_PROFILER_H__ diff --git a/libstdc++-v3/include/profile/impl/profiler_container_size.h b/libstdc++-v3/include/profile/impl/profiler_container_size.h new file mode 100644 index 000000000000..330afc5ba794 --- /dev/null +++ b/libstdc++-v3/include/profile/impl/profiler_container_size.h @@ -0,0 +1,250 @@ +// -*- C++ -*- +// +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 2, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. + +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/** @file profile/impl/profiler_trace.h + * @brief Diagnostics for container sizes. + */ + +// Written by Lixia Liu and Silvius Rus. + +#ifndef PROFCXX_PROFILER_CONTAINER_SIZE_H__ +#define PROFCXX_PROFILER_CONTAINER_SIZE_H__ 1 + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include +#include +#include +#else +#include +#include +#include +#endif + +#include "profile/impl/profiler.h" +#include "profile/impl/profiler_node.h" +#include "profile/impl/profiler_trace.h" + +namespace __cxxprof_impl +{ + +/** @brief A container size instrumentation line in the object table. */ +class __container_size_info: public __object_info_base +{ + public: + __container_size_info(); + __container_size_info(const __container_size_info& __o); + __container_size_info(__stack_t __stack, size_t __num); + virtual ~__container_size_info() {} + + void __write(FILE* f) const; + float __magnitude() const { return static_cast(_M_cost); } + const char* __advice() const; + + void __merge(const __container_size_info& __o); + // Call if a container is destructed or cleaned. + void __destruct(size_t __num, size_t __inum); + // Estimate the cost of resize/rehash. + float __resize_cost(size_t __from, size_t __to) { return __from; } + // Call if container is resized. + void __resize(size_t __from, size_t __to); + + private: + size_t _M_init; + size_t _M_max; // range of # buckets + size_t _M_min; + size_t _M_total; + size_t _M_item_min; // range of # items + size_t _M_item_max; + size_t _M_item_total; + size_t _M_count; + size_t _M_resize; + size_t _M_cost; +}; + +inline const char* __container_size_info::__advice() const +{ + const size_t __max_chars_size_t_printed = 20; + const char* __message_pattern = + "change initial container size from %d to %d"; + size_t __message_size = (strlen(__message_pattern) + + 2 * __max_chars_size_t_printed + - 2 * 2); + char* __message = new char[__message_size + 1]; + + if (_M_init < _M_item_max) + snprintf(__message, __message_size, __message_pattern, _M_init, + _M_item_max); + else + snprintf(__message, __message_size, __message_pattern, _M_init, + _M_item_max); + + return __message; +} + +inline void __container_size_info::__destruct(size_t __num, size_t __inum) +{ + _M_max = __max(_M_max, __num); + _M_item_max = __max(_M_item_max, __inum); + if (_M_min == 0) { + _M_min = __num; + _M_item_min = __inum; + } else { + _M_min = __min(_M_min, __num); + _M_item_min = __min(_M_item_min, __inum); + } + _M_total += __num; + _M_item_total += __inum; + _M_count += 1; +} + +inline void __container_size_info::__resize(size_t __from, size_t __to) +{ + _M_cost += this->__resize_cost(__from, __to); + _M_resize += 1; + _M_max = __max(_M_max, __to); +} + +inline __container_size_info::__container_size_info(__stack_t __stack, + size_t __num) + : __object_info_base(__stack), _M_init(0), _M_max(0), _M_item_max(0), + _M_min(0), _M_item_min(0), _M_total(0), _M_item_total(0), _M_cost(0), + _M_count(0), _M_resize(0) +{ + _M_init = _M_max = __num; + _M_item_min = _M_item_max = _M_item_total = _M_total = 0; + _M_min = 0; + _M_count = 0; + _M_resize = 0; +} + +inline void __container_size_info::__merge(const __container_size_info& __o) +{ + _M_init = __max(_M_init, __o._M_init); + _M_max = __max(_M_max, __o._M_max); + _M_item_max = __max(_M_item_max, __o._M_item_max); + _M_min = __min(_M_min, __o._M_min); + _M_item_min = __min(_M_item_min, __o._M_item_min); + _M_total += __o._M_total; + _M_item_total += __o._M_item_total; + _M_count += __o._M_count; + _M_cost += __o._M_cost; + _M_resize += __o._M_resize; +} + +inline __container_size_info::__container_size_info() + : _M_init(0), _M_max(0), _M_item_max(0), _M_min(0), _M_item_min(0), + _M_total(0), _M_item_total(0), _M_cost(0), _M_count(0), _M_resize(0) +{ +} + +inline __container_size_info::__container_size_info( + const __container_size_info& __o) + : __object_info_base(__o) +{ + _M_init = __o._M_init; + _M_max = __o._M_max; + _M_item_max = __o._M_item_max; + _M_min = __o._M_min; + _M_item_min = __o._M_item_min; + _M_total = __o._M_total; + _M_item_total = __o._M_item_total; + _M_cost = __o._M_cost; + _M_count = __o._M_count; + _M_resize = __o._M_resize; +} + +/** @brief A container size instrumentation line in the stack table. */ +class __container_size_stack_info: public __container_size_info +{ + public: + __container_size_stack_info(const __container_size_info& __o) + : __container_size_info(__o) {} +}; + +/** @brief Container size instrumentation trace producer. */ +class __trace_container_size + : public __trace_base<__container_size_info, __container_size_stack_info> +{ + public: + ~__trace_container_size() {} + __trace_container_size() + : __trace_base<__container_size_info, __container_size_stack_info>() {}; + + // Insert a new node at construct with object, callstack and initial size. + void __insert(const __object_t __obj, __stack_t __stack, size_t __num); + // Call at destruction/clean to set container final size. + void __destruct(const void* __obj, size_t __num, size_t __inum); + void __construct(const void* __obj, size_t __inum); + // Call at resize to set resize/cost information. + void __resize(const void* __obj, int __from, int __to); +}; + +inline void __trace_container_size::__insert(const __object_t __obj, + __stack_t __stack, size_t __num) +{ + __add_object(__obj, __container_size_info(__stack, __num)); +} + +inline void __container_size_info::__write(FILE* __f) const +{ + fprintf(__f, "%Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu\n", + _M_init, _M_count, _M_cost, _M_resize, _M_min, _M_max, _M_total, + _M_item_min, _M_item_max, _M_item_total); +} + +inline void __trace_container_size::__destruct(const void* __obj, + size_t __num, size_t __inum) +{ + if (!__is_on()) return; + + __object_t __obj_handle = static_cast<__object_t>(__obj); + + __container_size_info* __object_info = __get_object_info(__obj_handle); + if (!__object_info) + return; + + __object_info->__destruct(__num, __inum); + __retire_object(__obj_handle); +} + +inline void __trace_container_size::__resize(const void* __obj, int __from, + int __to) +{ + if (!__is_on()) return; + + __container_size_info* __object_info = __get_object_info(__obj); + if (!__object_info) + return; + + __object_info->__resize(__from, __to); +} + +} // namespace __cxxprof_impl +#endif /* PROFCXX_PROFILER_CONTAINER_SIZE_H__ */ diff --git a/libstdc++-v3/include/profile/impl/profiler_hash_func.h b/libstdc++-v3/include/profile/impl/profiler_hash_func.h new file mode 100644 index 000000000000..cf6395451635 --- /dev/null +++ b/libstdc++-v3/include/profile/impl/profiler_hash_func.h @@ -0,0 +1,192 @@ +// -*- C++ -*- +// +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 2, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. + +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/** @file profile/impl/profiler_trace.h + * @brief Data structures to represent profiling traces. + */ + +// Written by Lixia Liu and Silvius Rus. + +#ifndef PROFCXX_PROFILER_HASH_FUNC_H__ +#define PROFCXX_PROFILER_HASH_FUNC_H__ 1 + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include +#include +#include +#else +#include +#include +#include +#endif +#include "profile/impl/profiler.h" +#include "profile/impl/profiler_node.h" +#include "profile/impl/profiler_trace.h" + +namespace __cxxprof_impl +{ + +/** @brief A hash performance instrumentation line in the object table. */ +class __hashfunc_info: public __object_info_base +{ + public: + __hashfunc_info() + :_M_longest_chain(0), _M_accesses(0), _M_hops(0) {} + __hashfunc_info(const __hashfunc_info& o); + __hashfunc_info(__stack_t __stack) + : __object_info_base(__stack), + _M_longest_chain(0), _M_accesses(0), _M_hops(0){} + virtual ~__hashfunc_info() {} + + void __merge(const __hashfunc_info& __o); + void __destruct(size_t __chain, size_t __accesses, size_t __hops); + void __write(FILE* __f) const; + float __magnitude() const { return static_cast(_M_hops); } + const char* __advice() const { return "change hash function"; } + +private: + size_t _M_longest_chain; + size_t _M_accesses; + size_t _M_hops; +}; + +inline __hashfunc_info::__hashfunc_info(const __hashfunc_info& __o) + : __object_info_base(__o) +{ + _M_longest_chain = __o._M_longest_chain; + _M_accesses = __o._M_accesses; + _M_hops = __o._M_hops; +} + +inline void __hashfunc_info::__merge(const __hashfunc_info& __o) +{ + _M_longest_chain = __max(_M_longest_chain, __o._M_longest_chain); + _M_accesses += __o._M_accesses; + _M_hops += __o._M_hops; +} + +inline void __hashfunc_info::__destruct(size_t __chain, size_t __accesses, + size_t __hops) +{ + _M_longest_chain = __max(_M_longest_chain, __chain); + _M_accesses += __accesses; + _M_hops += __hops; +} + +/** @brief A hash performance instrumentation line in the stack table. */ +class __hashfunc_stack_info: public __hashfunc_info { + public: + __hashfunc_stack_info(const __hashfunc_info& __o) : __hashfunc_info(__o) {} +}; + +/** @brief Hash performance instrumentation producer. */ +class __trace_hash_func + : public __trace_base<__hashfunc_info, __hashfunc_stack_info> +{ + public: + __trace_hash_func(); + ~__trace_hash_func() {} + + // Insert a new node at construct with object, callstack and initial size. + void __insert(__object_t __obj, __stack_t __stack); + // Call at destruction/clean to set container final size. + void __destruct(const void* __obj, size_t __chain, + size_t __accesses, size_t __hops); +}; + +inline __trace_hash_func::__trace_hash_func() + : __trace_base<__hashfunc_info, __hashfunc_stack_info>() +{ + __id = "hash-distr"; +} + +inline void __trace_hash_func::__insert(__object_t __obj, __stack_t __stack) +{ + __add_object(__obj, __hashfunc_info(__stack)); +} + +inline void __hashfunc_info::__write(FILE* __f) const +{ + fprintf(__f, "%Zu %Zu %Zu\n", _M_hops, _M_accesses, _M_longest_chain); +} + +inline void __trace_hash_func::__destruct(const void* __obj, size_t __chain, + size_t __accesses, size_t __hops) +{ + if (!__is_on()) return; + + // First find the item from the live objects and update the informations. + __hashfunc_info* __objs = __get_object_info(__obj); + if (!__objs) + return; + + __objs->__destruct(__chain, __accesses, __hops); + __retire_object(__obj); +} + +////////////////////////////////////////////////////////////////////////////// +// Initialization and report. +////////////////////////////////////////////////////////////////////////////// + +inline void __trace_hash_func_init() +{ + __tables<0>::_S_hash_func = new __trace_hash_func(); +} + +inline void __trace_hash_func_report(FILE* __f, + __warning_vector_t& __warnings) +{ + if (__tables<0>::_S_hash_func) { + __tables<0>::_S_hash_func->__collect_warnings(__warnings); + __tables<0>::_S_hash_func->__write(__f); + } +} + +////////////////////////////////////////////////////////////////////////////// +// Implementations of instrumentation hooks. +////////////////////////////////////////////////////////////////////////////// + +inline void __trace_hash_func_construct(const void* __obj) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_hash_func->__insert(__obj, __get_stack()); +} + +inline void __trace_hash_func_destruct(const void* __obj, size_t __chain, + size_t __accesses, size_t __hops) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_hash_func->__destruct(__obj, __chain, __accesses, __hops); +} + +} // namespace __cxxprof_impl +#endif /* PROFCXX_PROFILER_HASH_FUNC_H__ */ diff --git a/libstdc++-v3/include/profile/impl/profiler_hashtable_size.h b/libstdc++-v3/include/profile/impl/profiler_hashtable_size.h new file mode 100644 index 000000000000..2192879325eb --- /dev/null +++ b/libstdc++-v3/include/profile/impl/profiler_hashtable_size.h @@ -0,0 +1,115 @@ +// -*- C++ -*- +// +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 2, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. + +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/** @file profile/impl/profiler_hashtable_size.cc + * @brief Collection of hashtable size traces. + */ + +// Written by Lixia Liu and Silvius Rus. + +#ifndef PROFCXX_PROFILER_HASHTABLE_SIZE_H__ +#define PROFCXX_PROFILER_HASHTABLE_SIZE_H__ 1 + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include +#include +#include +#else +#include +#include +#include +#endif +#include "profile/impl/profiler.h" +#include "profile/impl/profiler_node.h" +#include "profile/impl/profiler_trace.h" +#include "profile/impl/profiler_state.h" +#include "profile/impl/profiler_container_size.h" + +namespace __cxxprof_impl +{ + +/** @brief Hashtable size instrumentation trace producer. */ +class __trace_hashtable_size : public __trace_container_size +{ + public: + __trace_hashtable_size() : __trace_container_size() + { + __id = "hashtable-size"; + } +}; + +////////////////////////////////////////////////////////////////////////////// +// Initialization and report. +////////////////////////////////////////////////////////////////////////////// + +inline void __trace_hashtable_size_init() +{ + __tables<0>::_S_hashtable_size = new __trace_hashtable_size(); +} + +inline void __trace_hashtable_size_report(FILE* __f, + __warning_vector_t& __warnings) +{ + if (__tables<0>::_S_hashtable_size) { + __tables<0>::_S_hashtable_size->__collect_warnings(__warnings); + __tables<0>::_S_hashtable_size->__write(__f); + } +} + +////////////////////////////////////////////////////////////////////////////// +// Implementations of instrumentation hooks. +////////////////////////////////////////////////////////////////////////////// + +inline void __trace_hashtable_size_construct(const void* __obj, size_t __num) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_hashtable_size->__insert(__obj, __get_stack(), __num); +} + +inline void __trace_hashtable_size_destruct(const void* __obj, size_t __num, + size_t __inum) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_hashtable_size->__destruct(__obj, __num, __inum); +} + +inline void __trace_hashtable_size_resize(const void* __obj, size_t __from, + size_t __to) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_hashtable_size->__resize(__obj, __from, __to); +} + +} // namespace __cxxprof_impl + +#endif /* PROFCXX_PROFILER_HASHTABLE_SIZE_H__ */ diff --git a/libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h b/libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h new file mode 100644 index 000000000000..cdb88a86bcb7 --- /dev/null +++ b/libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h @@ -0,0 +1,305 @@ +// -*- C++ -*- +// +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 2, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. + +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/** @file profile/impl/profiler_map_to_unordered_map.h + * @brief Diagnostics for map to unordered_map. + */ + +// Written by Silvius Rus. + +#ifndef PROFCXX_PROFILER_MAP_TO_UNORDERED_MAP_H__ +#define PROFCXX_PROFILER_MAP_TO_UNORDERED_MAP_H__ 1 + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include +#include +#include +#else +#include +#include +#include +#endif +#include "profile/impl/profiler.h" +#include "profile/impl/profiler_node.h" +#include "profile/impl/profiler_trace.h" + +namespace __cxxprof_impl +{ + +// Cost model. XXX: this must be taken from the machine model instead. +// Map operations: +// - insert: 1.5 * log(size) +// - erase: 1.5 * log(size) +// - find: log(size) +// - iterate: 2.3 +// Unordered map operations: +// - insert: 12 +// - erase: 12 +// - find: 10 +// - iterate: 1.7 + +const float __map_insert_cost_factor = 1.5; +const float __map_erase_cost_factor = 1.5; +const float __map_find_cost_factor = 1; +const float __map_iterate_cost = 2.3; + +const float __umap_insert_cost = 12.0; +const float __umap_erase_cost = 12.0; +const float __umap_find_cost = 10.0; +const float __umap_iterate_cost = 1.7; + +inline int __log2(size_t __size) +{ + for (int __bit_count = sizeof(size_t) - 1; __bit_count >= 0; --__bit_count) { + if ((2 << __bit_count) & __size) { + return __bit_count; + } + } + return 0; +} + +inline float __map_insert_cost(size_t __size) +{ + return __map_insert_cost_factor * static_cast(__log2(__size)); +} + +inline float __map_erase_cost(size_t __size) +{ + return __map_erase_cost_factor * static_cast(__log2(__size)); +} + +inline float __map_find_cost(size_t __size) +{ + return __map_find_cost_factor * static_cast(__log2(__size)); +} + +/** @brief A map-to-unordered_map instrumentation line in the object table. */ +class __map2umap_info: public __object_info_base +{ + public: + __map2umap_info() + : _M_insert(0), _M_erase(0), _M_find(0), _M_iterate(0), + _M_map_cost(0.0), _M_umap_cost(0.0), _M_valid(true) {} + __map2umap_info(__stack_t __stack) + : __object_info_base(__stack), _M_insert(0), _M_erase(0), _M_find(0), + _M_iterate(0), _M_map_cost(0.0), _M_umap_cost(0.0), _M_valid(true) {} + virtual ~__map2umap_info() {} + __map2umap_info(const __map2umap_info& o); + void __merge(const __map2umap_info& o); + void __write(FILE* __f) const; + float __magnitude() const { return _M_map_cost - _M_umap_cost; } + const char* __advice() const; + + void __record_insert(size_t __size, size_t __count); + void __record_erase(size_t __size, size_t __count); + void __record_find(size_t __size); + void __record_iterate(size_t __count); + void __record_invalidate(); + + private: + size_t _M_insert; + size_t _M_erase; + size_t _M_find; + size_t _M_iterate; + float _M_umap_cost; + float _M_map_cost; + bool _M_valid; +}; + +inline const char* __map2umap_info::__advice() const +{ + return "change std::map to std::unordered_map"; +} + +inline __map2umap_info::__map2umap_info(const __map2umap_info& __o) + : __object_info_base(__o), + _M_insert(__o._M_insert), + _M_erase(__o._M_erase), + _M_find(__o._M_find), + _M_iterate(__o._M_iterate), + _M_map_cost(__o._M_map_cost), + _M_umap_cost(__o._M_umap_cost), + _M_valid(__o._M_valid) +{} + +inline void __map2umap_info::__merge(const __map2umap_info& __o) +{ + _M_insert += __o._M_insert; + _M_erase += __o._M_erase; + _M_find += __o._M_find; + _M_map_cost += __o._M_map_cost; + _M_umap_cost += __o._M_umap_cost; + _M_valid &= __o._M_valid; +} + +inline void __map2umap_info:: __record_insert(size_t __size, size_t __count) +{ + _M_insert += __count; + _M_map_cost += __count * __map_insert_cost(__size); + _M_umap_cost += __count * __umap_insert_cost; +} + +inline void __map2umap_info:: __record_erase(size_t __size, size_t __count) +{ + _M_erase += __count; + _M_map_cost += __count * __map_erase_cost(__size); + _M_umap_cost += __count * __umap_erase_cost; +} + +inline void __map2umap_info:: __record_find(size_t __size) +{ + _M_find += 1; + _M_map_cost += __map_find_cost(__size); + _M_umap_cost += __umap_find_cost; +} + +inline void __map2umap_info:: __record_iterate(size_t __count) +{ + _M_iterate += __count; + _M_map_cost += __count * __map_iterate_cost; + _M_umap_cost += __count * __umap_iterate_cost; +} + +inline void __map2umap_info:: __record_invalidate() +{ + _M_valid = false; +} + +inline void __map2umap_info::__write(FILE* __f) const +{ + fprintf(__f, "%Zu %Zu %Zu %Zu %.0f %.0f %s\n", + _M_insert, _M_erase, _M_find, _M_iterate, _M_map_cost, _M_umap_cost, + _M_valid ? "valid" : "invalid"); +} + +/** @brief A map-to-unordered_map instrumentation line in the stack table. */ +class __map2umap_stack_info: public __map2umap_info +{ + public: + __map2umap_stack_info(const __map2umap_info& o) : __map2umap_info(o) {} +}; + +/** @brief Map-to-unordered_map instrumentation producer. */ +class __trace_map2umap + : public __trace_base<__map2umap_info, __map2umap_stack_info> +{ + public: + __trace_map2umap(); +}; + +inline __trace_map2umap::__trace_map2umap() + : __trace_base<__map2umap_info, __map2umap_stack_info>() +{ + __id = "map-to-unordered-map"; +} + +inline void __trace_map_to_unordered_map_init() +{ + __tables<0>::_S_map2umap = new __trace_map2umap(); +} + +inline void __trace_map_to_unordered_map_report( + FILE* __f, __warning_vector_t& __warnings) +{ + if (__tables<0>::_S_map2umap) { + __tables<0>::_S_map2umap->__collect_warnings(__warnings); + __tables<0>::_S_map2umap->__write(__f); + } +} + +////////////////////////////////////////////////////////////////////////////// +// Implementations of instrumentation hooks. +////////////////////////////////////////////////////////////////////////////// + +inline void __trace_map_to_unordered_map_construct(const void* __obj) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_map2umap->__add_object(__obj, + __map2umap_info(__get_stack())); +} + +inline void __trace_map_to_unordered_map_destruct(const void* __obj) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_map2umap->__retire_object(__obj); +} + +inline void __trace_map_to_unordered_map_insert(const void* __obj, + size_t __size, size_t __count) +{ + if (!__profcxx_init()) return; + + __map2umap_info* __info = __tables<0>::_S_map2umap->__get_object_info(__obj); + + if (__info) __info->__record_insert(__size, __count); +} + +inline void __trace_map_to_unordered_map_erase(const void* __obj, + size_t __size, size_t __count) +{ + if (!__profcxx_init()) return; + + __map2umap_info* __info = __tables<0>::_S_map2umap->__get_object_info(__obj); + + if (__info) __info->__record_erase(__size, __count); +} + +inline void __trace_map_to_unordered_map_find(const void* __obj, size_t __size) +{ + if (!__profcxx_init()) return; + + __map2umap_info* __info = __tables<0>::_S_map2umap->__get_object_info(__obj); + + if (__info) __info->__record_find(__size); +} + +inline void __trace_map_to_unordered_map_iterate(const void* __obj, + size_t __count) +{ + if (!__profcxx_init()) return; + + __map2umap_info* __info = __tables<0>::_S_map2umap->__get_object_info(__obj); + + if (__info) __info->__record_iterate(__count); +} + +inline void __trace_map_to_unordered_map_invalidate(const void* __obj) +{ + if (!__profcxx_init()) return; + + __map2umap_info* __info = __tables<0>::_S_map2umap->__get_object_info(__obj); + + if (__info) __info->__record_invalidate(); +} + +} // namespace __cxxprof_impl +#endif /* PROFCXX_PROFILER_MAP_TO_UNORDERED_MAP_H__ */ diff --git a/libstdc++-v3/include/profile/impl/profiler_node.h b/libstdc++-v3/include/profile/impl/profiler_node.h new file mode 100644 index 000000000000..cd2b9ab20162 --- /dev/null +++ b/libstdc++-v3/include/profile/impl/profiler_node.h @@ -0,0 +1,172 @@ +// -*- C++ -*- +// +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 2, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. + +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/** @file profile/impl/profiler_node.h + * @brief Data structures to represent a single profiling event. + */ + +// Written by Lixia Liu and Silvius Rus. + +#ifndef PROFCXX_PROFILER_NODE_H__ +#define PROFCXX_PROFILER_NODE_H__ 1 + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include +#include +#include +#else +#include +#include +#include +#endif +#include +#if defined HAVE_EXECINFO_H +#include +#endif + +namespace __cxxprof_impl +{ +typedef const void* __object_t; +typedef void* __instruction_address_t; +typedef std::_GLIBCXX_STD_PR::vector<__instruction_address_t> __stack_npt; +typedef __stack_npt* __stack_t; + +size_t __stack_max_depth(); + +inline __stack_t __get_stack() +{ +#if defined HAVE_EXECINFO_H + size_t __max_depth = __stack_max_depth(); + if (__max_depth == 0) + return NULL; + __stack_npt __buffer(__max_depth); + int __depth = backtrace(&__buffer[0], __max_depth); + __stack_t __stack = new __stack_npt(__depth); + memcpy(&(*__stack)[0], &__buffer[0], __depth * sizeof(__object_t)); + return __stack; +#else + return NULL; +#endif +} + +inline __size(const __stack_t& __stack) +{ + if (!__stack) { + return 0; + } else { + return __stack->size(); + } +} + +inline void __write(FILE* __f, const __stack_t __stack) +{ + if (!__stack) { + return; + } + + __stack_npt::const_iterator __it; + for (__it = __stack->begin(); __it != __stack->end(); ++__it) { + fprintf(__f, "%p ", *__it); + } +} + +/** @brief Hash function for summary trace using call stack as index. */ +class __stack_hash +{ + public: + size_t operator()(const __stack_t __s) const + { + if (!__s) { + return 0; + } + + uintptr_t __index = 0; + __stack_npt::const_iterator __it; + for (__it = __s->begin(); __it != __s->end(); ++__it) { + __index += reinterpret_cast(*__it); + } + return __index; + } + + bool operator() (const __stack_t __stack1, const __stack_t __stack2) const + { + if (!__stack1 && !__stack2) return true; + if (!__stack1 || !__stack2) return false; + if (__stack1->size() != __stack2->size()) return false; + + size_t __byte_size = __stack1->size() * sizeof(__stack_npt::value_type); + return memcmp(&(*__stack1)[0], &(*__stack2)[0], __byte_size) == 0; + } +}; + +/** @brief Base class for a line in the object table. */ +class __object_info_base +{ + public: + __object_info_base() {} + __object_info_base(__stack_t __stack); + __object_info_base(const __object_info_base& o); + virtual ~__object_info_base() {} + bool __is_valid() const { return _M_valid; } + __stack_t __stack() const { return _M_stack; } + virtual void __write(FILE* f) const = 0; + + protected: + __stack_t _M_stack; + bool _M_valid; +}; + +inline __object_info_base::__object_info_base(__stack_t __stack) +{ + _M_stack = __stack; + _M_valid = true; +} + +inline __object_info_base::__object_info_base(const __object_info_base& __o) +{ + _M_stack = __o._M_stack; + _M_valid = __o._M_valid; +} + +/** @brief Base class for a line in the stack table. */ +template +class __stack_info_base +{ + public: + __stack_info_base() {} + __stack_info_base(const __object_info& __info) = 0; + virtual ~__stack_info_base() {} + void __merge(const __object_info& __info) = 0; + virtual float __magnitude() const = 0; + virtual const char* __get_id() const = 0; +}; + +} // namespace __cxxprof_impl +#endif /* PROFCXX_PROFILER_NODE_H__ */ diff --git a/libstdc++-v3/include/profile/impl/profiler_state.h b/libstdc++-v3/include/profile/impl/profiler_state.h new file mode 100644 index 000000000000..64c10db616c3 --- /dev/null +++ b/libstdc++-v3/include/profile/impl/profiler_state.h @@ -0,0 +1,107 @@ +// -*- C++ -*- +// +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 2, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. + +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/** @file profile/impl/profiler_state.cc + * @brief Global profiler state. + */ + +// Written by Lixia Liu and Silvius Rus. + +#ifndef PROFCXX_PROFILER_STATE_H__ +#define PROFCXX_PROFILER_STATE_H__ 1 + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include +#else +#include +#endif + +namespace __cxxprof_impl +{ + +/** @brief Profiling mode on/off state. */ +template +class __state +{ + public: + + static __state<_Unused>* _S_diag_state; + + __state() : _M_state(__INVALID) {} + ~__state() {} + + bool __is_on() { return _M_state == __ON; } + bool __is_off() { return _M_state == __OFF; } + bool __is_invalid() { return _M_state == __INVALID; } + void __turn_on() { _M_state = __ON; } + void __turn_off() { _M_state = __OFF; } + + private: + enum __state_type { __ON, __OFF, __INVALID }; + __state_type _M_state; +}; + +template +__state<_Unused>* __state<_Unused>::_S_diag_state = NULL; + +inline bool __is_on() +{ + return __state<0>::_S_diag_state && __state<0>::_S_diag_state->__is_on(); +} + +inline bool __is_off() +{ + return __state<0>::_S_diag_state && __state<0>::_S_diag_state->__is_off(); +} + +inline bool __is_invalid() +{ + return (!__state<0>::_S_diag_state + || __state<0>::_S_diag_state->__is_invalid()); +} + +inline void __turn_on() +{ + if (!__state<0>::_S_diag_state) { + __state<0>::_S_diag_state = new __state<0>(); + } + __state<0>::_S_diag_state->__turn_on(); +} + +inline void __turn_off() +{ + if (!__state<0>::_S_diag_state) { + __state<0>::_S_diag_state = new __state<0>(); + } + __state<0>::_S_diag_state->__turn_off(); +} + +} // end namespace __cxxprof_impl +#endif /* PROFCXX_PROFILER_STATE_H__ */ diff --git a/libstdc++-v3/include/profile/impl/profiler_trace.h b/libstdc++-v3/include/profile/impl/profiler_trace.h new file mode 100644 index 000000000000..37bcb6436e53 --- /dev/null +++ b/libstdc++-v3/include/profile/impl/profiler_trace.h @@ -0,0 +1,564 @@ +// -*- C++ -*- +// +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 2, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. + +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/** @file profile/impl/profiler_trace.h + * @brief Data structures to represent profiling traces. + */ + +// Written by Lixia Liu and Silvius Rus. + +#ifndef PROFCXX_PROFILER_TRACE_H__ +#define PROFCXX_PROFILER_TRACE_H__ 1 + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include +#include +#include +#include +#define _GLIBCXX_IMPL_UNORDERED_MAP std::_GLIBCXX_STD_PR::unordered_map +#include +#else +#include +#include +#include +#include +#include +#define _GLIBCXX_IMPL_UNORDERED_MAP std::tr1::unordered_map +#endif + +#include +#include + +#if defined _GLIBCXX_PROFILE_THREADS && defined HAVE_TLS +#include +#endif + +#include "profile/impl/profiler_state.h" +#include "profile/impl/profiler_node.h" + +namespace __cxxprof_impl +{ + +#if defined _GLIBCXX_PROFILE_THREADS && defined HAVE_TLS +#define _GLIBCXX_IMPL_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER +typedef pthread_mutex_t __mutex_t; +/** @brief Pthread mutex wrapper. */ +template +class __mutex { + public: + static __mutex_t __global_lock; + static void __lock(__mutex_t& __m) { pthread_mutex_lock(&__m); } + static void __unlock(__mutex_t& __m) { pthread_mutex_unlock(&__m); } +}; +#else +#define _GLIBCXX_IMPL_MUTEX_INITIALIZER 0 +typedef int __mutex_t; +/** @brief Mock mutex interface. */ +template +class __mutex { + public: + static __mutex_t __global_lock; + static void __lock(__mutex_t& __m) {} + static void __unlock(__mutex_t& __m) {} +}; +#endif + +template +__mutex_t __mutex<_Unused>::__global_lock = _GLIBCXX_IMPL_MUTEX_INITIALIZER; + +/** @brief Representation of a warning. */ +struct __warning_data +{ + float __magnitude; + __stack_t __context; + const char* __warning_id; + const char* __warning_message; + __warning_data(); + __warning_data(float __m, __stack_t __c, const char* __id, + const char* __msg); + bool operator>(const struct __warning_data& other) const; +}; + +inline __warning_data::__warning_data() + : __magnitude(0.0), __context(NULL), __warning_id(NULL), + __warning_message(NULL) +{ +} + +inline __warning_data::__warning_data(float __m, __stack_t __c, + const char* __id, const char* __msg) + : __magnitude(__m), __context(__c), __warning_id(__id), + __warning_message(__msg) +{ +} + +inline bool __warning_data::operator>(const struct __warning_data& other) const +{ + return __magnitude > other.__magnitude; +} + +typedef std::_GLIBCXX_STD_PR::vector<__warning_data> __warning_vector_t; + +// Defined in profiler_.h. +class __trace_hash_func; +class __trace_hashtable_size; +class __trace_map2umap; +class __trace_vector_size; +class __trace_vector_to_list; +void __trace_vector_size_init(); +void __trace_hashtable_size_init(); +void __trace_hash_func_init(); +void __trace_vector_to_list_init(); +void __trace_map_to_unordered_map_init(); +void __trace_vector_size_report(FILE*, __warning_vector_t&); +void __trace_hashtable_size_report(FILE*, __warning_vector_t&); +void __trace_hash_func_report(FILE*, __warning_vector_t&); +void __trace_vector_to_list_report(FILE*, __warning_vector_t&); +void __trace_map_to_unordered_map_report(FILE*, __warning_vector_t&); + +// Utility functions. +inline size_t __max(size_t __a, size_t __b) +{ + return __a >= __b ? __a : __b; +} + +inline size_t __min(size_t __a, size_t __b) +{ + return __a <= __b ? __a : __b; +} + +/** @brief Storage for diagnostic table entries. Has only static fields. */ +template +class __tables +{ + public: + static __trace_hash_func* _S_hash_func; + static __trace_hashtable_size* _S_hashtable_size; + static __trace_map2umap* _S_map2umap; + static __trace_vector_size* _S_vector_size; + static __trace_vector_to_list* _S_vector_to_list; +}; + +template +__trace_hash_func* __tables<_Unused>::_S_hash_func = NULL; +template +__trace_hashtable_size* __tables<_Unused>::_S_hashtable_size = NULL; +template +__trace_map2umap* __tables<_Unused>::_S_map2umap = NULL; +template +__trace_vector_size* __tables<_Unused>::_S_vector_size = NULL; +template +__trace_vector_to_list* __tables<_Unused>::_S_vector_to_list = NULL; + +/** @brief Storage for user defined parameters. Has only static fields. */ +template +class __settings { + public: + static const char* _S_trace_file_name; + static size_t _S_max_warn_count; + static size_t _S_max_stack_depth; + static size_t _S_max_mem; +}; + +template +const char* __settings<_Unused>::_S_trace_file_name = + _GLIBCXX_PROFILE_TRACE_PATH_ROOT; +template +size_t __settings<_Unused>::_S_max_warn_count = + _GLIBCXX_PROFILE_MAX_WARN_COUNT; +template +size_t __settings<_Unused>::_S_max_stack_depth = + _GLIBCXX_PROFILE_MAX_STACK_DEPTH; +template +size_t __settings<_Unused>::_S_max_mem = + _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC; + +inline size_t __stack_max_depth() +{ + return __settings<0>::_S_max_stack_depth; +} + +inline size_t __max_mem() +{ + return __settings<0>::_S_max_mem; +} + +/** @brief Base class for all trace producers. */ +template +class __trace_base +{ + public: + __trace_base(); + virtual ~__trace_base() {} + + void __add_object(__object_t object, __object_info __info); + __object_info* __get_object_info(__object_t __object); + void __retire_object(__object_t __object); + void __write(FILE* f); + void __collect_warnings(__warning_vector_t& warnings); + + void __lock_object_table(); + void __lock_stack_table(); + void __unlock_object_table(); + void __unlock_stack_table(); + + private: + __mutex_t __object_table_lock; + __mutex_t __stack_table_lock; + typedef _GLIBCXX_IMPL_UNORDERED_MAP<__object_t, + __object_info> __object_table_t; + typedef _GLIBCXX_IMPL_UNORDERED_MAP<__stack_t, __stack_info, __stack_hash, + __stack_hash> __stack_table_t; + __object_table_t __object_table; + __stack_table_t __stack_table; + size_t __stack_table_byte_size; + + protected: + const char* __id; +}; + +template +void __trace_base<__object_info, __stack_info>::__collect_warnings( + __warning_vector_t& warnings) +{ + typename __stack_table_t::iterator __i = __stack_table.begin(); + for ( ; __i != __stack_table.end(); ++__i ) + { + warnings.push_back(__warning_data((*__i).second.__magnitude(), + (*__i).first, + __id, + (*__i).second.__advice())); + } +} + +template +void __trace_base<__object_info, __stack_info>::__lock_object_table() +{ + __mutex<0>::__lock(this->__object_table_lock); +} + +template +void __trace_base<__object_info, __stack_info>::__lock_stack_table() +{ + __mutex<0>::__lock(this->__stack_table_lock); +} + +template +void __trace_base<__object_info, __stack_info>::__unlock_object_table() +{ + __mutex<0>::__unlock(this->__object_table_lock); +} + +template +void __trace_base<__object_info, __stack_info>::__unlock_stack_table() +{ + __mutex<0>::__unlock(this->__stack_table_lock); +} + +template +__trace_base<__object_info, __stack_info>::__trace_base() +{ + // Do not pick the initial size too large, as we don't know which diagnostics + // are more active. + __object_table.rehash(10000); + __stack_table.rehash(10000); + __stack_table_byte_size = 0; + __id = NULL; + __object_table_lock = __stack_table_lock = _GLIBCXX_IMPL_MUTEX_INITIALIZER; +} + +template +void __trace_base<__object_info, __stack_info>::__add_object( + __object_t __object, __object_info __info) +{ + if (__max_mem() == 0 + || __object_table.size() * sizeof(__object_info) <= __max_mem()) { + __lock_object_table(); + __object_table.insert( + typename __object_table_t::value_type(__object, __info)); + __unlock_object_table(); + } +} + +template +__object_info* __trace_base<__object_info, __stack_info>::__get_object_info( + __object_t __object) +{ + // XXX: Revisit this to see if we can decrease mutex spans. + // Without this mutex, the object table could be rehashed during an + // insertion on another thread, which could result in a segfault. + __lock_object_table(); + typename __object_table_t::iterator __object_it = + __object_table.find(__object); + if (__object_it == __object_table.end()){ + __unlock_object_table(); + return NULL; + } else { + __unlock_object_table(); + return &__object_it->second; + } +} + +template +void __trace_base<__object_info, __stack_info>::__retire_object( + __object_t __object) +{ + __lock_object_table(); + __lock_stack_table(); + typename __object_table_t::iterator __object_it = + __object_table.find(__object); + if (__object_it != __object_table.end()){ + const __object_info& __info = __object_it->second; + const __stack_t& __stack = __info.__stack(); + typename __stack_table_t::iterator __stack_it = + __stack_table.find(__stack); + if (__stack_it == __stack_table.end()) { + // First occurence of this call context. + if (__max_mem() == 0 || __stack_table_byte_size < __max_mem()) { + __stack_table_byte_size += + (sizeof(__instruction_address_t) * __size(__stack) + + sizeof(__stack) + sizeof(__stack_info)); + __stack_table.insert(make_pair(__stack, __stack_info(__info))); + } + } else { + // Merge object info into info summary for this call context. + __stack_it->second.__merge(__info); + delete __stack; + } + __object_table.erase(__object); + } + __unlock_stack_table(); + __unlock_object_table(); +} + +template +void __trace_base<__object_info, __stack_info>::__write(FILE* __f) +{ + typename __stack_table_t::iterator __it; + + for (__it = __stack_table.begin(); __it != __stack_table.end(); __it++) { + if (__it->second.__is_valid()) { + fprintf(__f, __id); + fprintf(__f, "|"); + __cxxprof_impl::__write(__f, __it->first); + fprintf(__f, "|"); + __it->second.__write(__f); + } + } +} + +inline size_t __env_to_size_t(const char* __env_var, size_t __default_value) +{ + char* __env_value = getenv(__env_var); + if (__env_value) { + long int __converted_value = strtol(__env_value, NULL, 10); + if (errno || __converted_value < 0) { + fprintf(stderr, "Bad value for environment variable '%s'.", __env_var); + abort(); + } else { + return static_cast(__converted_value); + } + } else { + return __default_value; + } +} + +inline void __set_max_stack_trace_depth() +{ + __settings<0>::_S_max_stack_depth = __env_to_size_t( + _GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR, + __settings<0>::_S_max_stack_depth); +} + +inline void __set_max_mem() +{ + __settings<0>::_S_max_mem = __env_to_size_t( + _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR, __settings<0>::_S_max_mem); +} + +inline int __log_magnitude(float f) +{ + const float log_base = 10.0; + int result = 0; + int sign = 1; + if (f < 0) { + f = -f; + sign = -1; + } + while (f > log_base) { + ++result; + f /= 10.0; + } + return sign * result; +} + +struct __warn +{ + FILE* __file; + __warn(FILE* __f) { __file = __f; } + void operator() (const __warning_data& __info) + { + fprintf(__file, __info.__warning_id); + fprintf(__file, ": improvement = %d", __log_magnitude(__info.__magnitude)); + fprintf(__file, ": call stack = "); + __cxxprof_impl::__write(__file, __info.__context); + fprintf(__file, ": advice = %s\n", __info.__warning_message); + } +}; + +inline FILE* __open_output_file(const char* extension) +{ + // The path is made of _S_trace_file_name + "." + extension. + size_t root_len = strlen(__settings<0>::_S_trace_file_name); + size_t ext_len = strlen(extension); + char* file_name = new char[root_len + 1 + ext_len + 1]; + char* p = file_name; + memcpy(file_name, __settings<0>::_S_trace_file_name, root_len); + *(file_name + root_len) = '.'; + memcpy(file_name + root_len + 1, extension, ext_len + 1); + FILE* out_file = fopen(file_name, "w"); + if (out_file) { + return out_file; + } else { + fprintf(stderr, "Could not open trace file '%s'.", file_name); + abort(); + } +} + +/** @brief Final report method, registered with "atexit". + * + * This can also be called directly by user code, including signal handlers. + * It is protected against deadlocks by the reentrance guard in profiler.h. + * However, when called from a signal handler that triggers while within + * __cxxprof_impl (under the guarded zone), no output will be produced. + */ +inline void __report(void) +{ + __mutex<0>::__lock(__mutex<0>::__global_lock); + + __warning_vector_t __warnings; + + FILE* __raw_file = __open_output_file("raw"); + __trace_vector_size_report(__raw_file, __warnings); + __trace_hashtable_size_report(__raw_file, __warnings); + __trace_hash_func_report(__raw_file, __warnings); + __trace_vector_to_list_report(__raw_file, __warnings); + __trace_map_to_unordered_map_report(__raw_file, __warnings); + fclose(__raw_file); + + // Sort data by magnitude. + // XXX: instead of sorting, should collect only top N for better performance. + size_t __cutoff = __min(__settings<0>::_S_max_warn_count, + __warnings.size()); + + std::sort(__warnings.begin(), __warnings.end(), + std::greater<__warning_vector_t::value_type>()); + __warnings.resize(__cutoff); + + FILE* __warn_file = __open_output_file("txt"); + std::for_each(__warnings.begin(), __warnings.end(), __warn(__warn_file)); + fclose(__warn_file); + + __mutex<0>::__unlock(__mutex<0>::__global_lock); +} + +inline void __set_trace_path() +{ + char* __env_trace_file_name = getenv(_GLIBCXX_PROFILE_TRACE_ENV_VAR); + + if (__env_trace_file_name) { + __settings<0>::_S_trace_file_name = __env_trace_file_name; + } + + // Make sure early that we can create the trace file. + fclose(__open_output_file("txt")); +} + +inline void __set_max_warn_count() +{ + char* __env_max_warn_count_str = getenv( + _GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR); + + if (__env_max_warn_count_str) { + __settings<0>::_S_max_warn_count = static_cast( + atoi(__env_max_warn_count_str)); + } +} + +inline void __profcxx_init_unconditional() +{ + __mutex<0>::__lock(__mutex<0>::__global_lock); + + __set_max_warn_count(); + + if (__is_invalid()) { + + if (__settings<0>::_S_max_warn_count == 0) { + + __turn_off(); + + } else { + + __set_max_stack_trace_depth(); + __set_max_mem(); + __set_trace_path(); + + __trace_vector_size_init(); + __trace_hashtable_size_init(); + __trace_hash_func_init(); + __trace_vector_to_list_init(); + __trace_map_to_unordered_map_init(); + + atexit(__report); + + __turn_on(); + + } + } + + __mutex<0>::__unlock(__mutex<0>::__global_lock); +} + +/** @brief This function must be called by each instrumentation point. + * + * The common path is inlined fully. + */ +inline bool __profcxx_init(void) +{ + if (__is_invalid()) { + __profcxx_init_unconditional(); + } + + return __is_on(); +} + +} // namespace __cxxprof_impl + +#endif /* PROFCXX_PROFILER_TRACE_H__ */ diff --git a/libstdc++-v3/include/profile/impl/profiler_vector_size.h b/libstdc++-v3/include/profile/impl/profiler_vector_size.h new file mode 100644 index 000000000000..dd42959825f2 --- /dev/null +++ b/libstdc++-v3/include/profile/impl/profiler_vector_size.h @@ -0,0 +1,112 @@ +// -*- C++ -*- +// +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 2, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. + +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/** @file profile/impl/profiler_vector_size.h + * @brief Collection of vector size traces. + */ + +// Written by Lixia Liu and Silvius Rus. + +#ifndef PROFCXX_PROFILER_VECTOR_SIZE_H__ +#define PROFCXX_PROFILER_VECTOR_SIZE_H__ 1 + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include +#include +#include +#else +#include +#include +#include +#endif +#include "profile/impl/profiler.h" +#include "profile/impl/profiler_node.h" +#include "profile/impl/profiler_trace.h" +#include "profile/impl/profiler_state.h" +#include "profile/impl/profiler_container_size.h" + +namespace __cxxprof_impl +{ + +/** @brief Hashtable size instrumentation trace producer. */ +class __trace_vector_size : public __trace_container_size +{ + public: + __trace_vector_size() : __trace_container_size() { __id = "vector-size"; } +}; + +////////////////////////////////////////////////////////////////////////////// +// Initialization and report. +////////////////////////////////////////////////////////////////////////////// + +inline void __trace_vector_size_init() +{ + __tables<0>::_S_vector_size = new __trace_vector_size(); +} + +inline void __trace_vector_size_report(FILE* __f, + __warning_vector_t& __warnings) +{ + if (__tables<0>::_S_vector_size) { + __tables<0>::_S_vector_size->__collect_warnings(__warnings); + __tables<0>::_S_vector_size->__write(__f); + } +} + +////////////////////////////////////////////////////////////////////////////// +// Implementations of instrumentation hooks. +////////////////////////////////////////////////////////////////////////////// + +inline void __trace_vector_size_construct(const void* __obj, size_t __num) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_vector_size->__insert(__obj, __get_stack(), __num); +} + +inline void __trace_vector_size_destruct(const void* __obj, size_t __num, + size_t __inum) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_vector_size->__destruct(__obj, __num, __inum); +} + +inline void __trace_vector_size_resize(const void* __obj, size_t __from, + size_t __to) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_vector_size->__resize(__obj, __from, __to); +} + +} // namespace __cxxprof_impl + +#endif /* PROFCXX_PROFILER_VECTOR_SIZE_H__ */ diff --git a/libstdc++-v3/include/profile/impl/profiler_vector_to_list.h b/libstdc++-v3/include/profile/impl/profiler_vector_to_list.h new file mode 100644 index 000000000000..ec3dfbcfb863 --- /dev/null +++ b/libstdc++-v3/include/profile/impl/profiler_vector_to_list.h @@ -0,0 +1,318 @@ +// -*- C++ -*- +// +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 2, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. + +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/** @file profile/impl/profiler_trace.h + * @brief Data structures to represent profiling traces. + */ + +// Written by Lixia Liu and Silvius Rus. + +#ifndef PROFCXX_PROFILER_VECTOR_TO_LIST_H__ +#define PROFCXX_PROFILER_VECTOR_TO_LIST_H__ 1 + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include +#include +#include +#else +#include +#include +#include +#endif +#include "profile/impl/profiler.h" +#include "profile/impl/profiler_node.h" +#include "profile/impl/profiler_trace.h" + +namespace __cxxprof_impl +{ + +/** @brief A vector-to-list instrumentation line in the object table. */ +class __vector2list_info: public __object_info_base +{ + public: + __vector2list_info() + :_M_shift_count(0), _M_iterate(0), _M_resize(0), _M_list_cost(0), + _M_vector_cost(0), _M_valid(true) {} + __vector2list_info(__stack_t __stack) + : __object_info_base(__stack), _M_shift_count(0), _M_iterate(0), + _M_resize(0), _M_list_cost(0), _M_vector_cost(0), _M_valid(true) {} + virtual ~__vector2list_info() {} + __vector2list_info(const __vector2list_info& __o); + void __merge(const __vector2list_info& __o); + void __write(FILE* __f) const; + float __magnitude() const { return _M_vector_cost - _M_list_cost; } + const char* __advice() const { return "change std::vector to std::list"; } + + size_t __shift_count() { return _M_shift_count; } + size_t __iterate() { return _M_iterate; } + float __list_cost() { return _M_list_cost; } + size_t __resize() { return _M_resize; } + void __set_list_cost(float __lc) { _M_list_cost = __lc; } + void __set_vector_cost(float __vc) { _M_vector_cost = __vc; } + bool __is_valid() { return _M_valid; } + void __set_invalid() { _M_valid = false; } + + void __opr_insert(size_t __pos, size_t __num); + void __opr_iterate(size_t __num) { _M_iterate += __num; } + void __resize(size_t __from, size_t __to); + +private: + size_t _M_shift_count; + size_t _M_iterate; + size_t _M_resize; + float _M_list_cost; + float _M_vector_cost; + bool _M_valid; +}; + +inline __vector2list_info::__vector2list_info(const __vector2list_info& __o) + : __object_info_base(__o) +{ + _M_shift_count = __o._M_shift_count; + _M_iterate = __o._M_iterate; + _M_vector_cost = __o._M_vector_cost; + _M_list_cost = __o._M_list_cost; + _M_valid = __o._M_valid; + _M_resize = __o._M_resize; +} + +inline void __vector2list_info::__merge(const __vector2list_info& __o) +{ + _M_shift_count += __o._M_shift_count; + _M_iterate += __o._M_iterate; + _M_vector_cost += __o._M_vector_cost; + _M_list_cost += __o._M_list_cost; + _M_valid &= __o._M_valid; + _M_resize += __o._M_resize; +} + +inline void __vector2list_info::__opr_insert(size_t __pos, size_t __num) +{ + _M_shift_count += __num - __pos; +} + +inline void __vector2list_info::__resize(size_t __from, size_t __to) +{ + _M_resize += __from; +} + +/** @brief A vector-to-list instrumentation line in the stack table. */ +class __vector2list_stack_info: public __vector2list_info { + public: + __vector2list_stack_info(const __vector2list_info& __o) + : __vector2list_info(__o) {} +}; + +/** @brief Vector-to-list instrumentation producer. */ +class __trace_vector_to_list + : public __trace_base<__vector2list_info, __vector2list_stack_info> +{ + public: + __trace_vector_to_list(); + ~__trace_vector_to_list() {} + + // Insert a new node at construct with object, callstack and initial size. + void __insert(__object_t __obj, __stack_t __stack); + // Call at destruction/clean to set container final size. + void __destruct(const void* __obj); + + // Find the node in the live map. + __vector2list_info* __find(const void* __obj); + + // Collect cost of operations. + void __opr_insert(const void* __obj, size_t __pos, size_t __num); + void __opr_iterate(const void* __obj, size_t __num); + void __invalid_operator(const void* __obj); + void __resize(const void* __obj, size_t __from, size_t __to); + float __vector_cost(size_t __shift, size_t __iterate, size_t __resize); + float __list_cost(size_t __shift, size_t __iterate, size_t __resize); +}; + +inline __trace_vector_to_list::__trace_vector_to_list() + : __trace_base<__vector2list_info, __vector2list_stack_info>() +{ + __id = "vector-to-list"; +} + +inline void __trace_vector_to_list::__insert(__object_t __obj, + __stack_t __stack) +{ + __add_object(__obj, __vector2list_info(__stack)); +} + +inline void __vector2list_info::__write(FILE* __f) const +{ + fprintf(__f, "%Zu %Zu %Zu %.0f %.0f\n", + _M_shift_count, _M_resize, _M_iterate, _M_vector_cost, _M_list_cost); +} + +// Cost model. XXX: get this from the cost model database instead. +// Vector operation cost: +// - Cost per shift: 1 +// - Cost per access: 1 +// - Cost per resize: 1 +// List operation cost: +// - Cost per shift: 0 +// - Cost per access: 10 +// - Cost per resize: 0 + +inline float __trace_vector_to_list::__vector_cost(size_t __shift, + size_t __iterate, + size_t __resize) +{ + return __shift * 1 + __iterate * 1 + __resize * 1; +} + +inline float __trace_vector_to_list::__list_cost(size_t __shift, + size_t __iterate, + size_t __resize) +{ + return __shift * 0 + __iterate * 10 + __resize * 0; +} + +inline void __trace_vector_to_list::__destruct(const void* __obj) +{ + if (!__is_on()) + return; + + __vector2list_info* __res = __get_object_info(__obj); + if (!__res) + return; + + float __vc = __vector_cost(__res->__shift_count(), __res->__iterate(), + __res->__resize()); + float __lc = __list_cost(__res->__shift_count(), __res->__iterate(), + __res->__resize()); + __res->__set_vector_cost(__vc); + __res->__set_list_cost(__lc); + + __retire_object(__obj); +} + +inline void __trace_vector_to_list::__opr_insert(const void* __obj, + size_t __pos, size_t __num) +{ + __vector2list_info* __res = __get_object_info(__obj); + if (__res) + __res->__opr_insert(__pos, __num); +} + +inline void __trace_vector_to_list::__opr_iterate(const void* __obj, + size_t __num) +{ + __vector2list_info* __res = __get_object_info(__obj); + if (__res) + __res->__opr_iterate(__num); +} + +inline void __trace_vector_to_list::__invalid_operator(const void* __obj) +{ + __vector2list_info* __res = __get_object_info(__obj); + if (__res) + __res->__set_invalid(); +} + +inline void __trace_vector_to_list::__resize(const void* __obj, size_t __from, + size_t __to) +{ + __vector2list_info* __res = __get_object_info(__obj); + if (__res) + __res->__resize(__from, __to); +} + +////////////////////////////////////////////////////////////////////////////// +// Initialization and report. +////////////////////////////////////////////////////////////////////////////// + +inline void __trace_vector_to_list_init() +{ + __tables<0>::_S_vector_to_list = new __trace_vector_to_list(); +} + +inline void __trace_vector_to_list_report(FILE* __f, + __warning_vector_t& __warnings) +{ + if (__tables<0>::_S_vector_to_list) { + __tables<0>::_S_vector_to_list->__collect_warnings(__warnings); + __tables<0>::_S_vector_to_list->__write(__f); + } +} + +////////////////////////////////////////////////////////////////////////////// +// Implementations of instrumentation hooks. +////////////////////////////////////////////////////////////////////////////// + +inline void __trace_vector_to_list_construct(const void* __obj) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_vector_to_list->__insert(__obj, __get_stack()); +} + +inline void __trace_vector_to_list_destruct(const void* __obj) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_vector_to_list->__destruct(__obj); +} + +inline void __trace_vector_to_list_insert(const void* __obj, + size_t __pos, size_t __num) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_vector_to_list->__opr_insert(__obj, __pos, __num); +} + + +inline void __trace_vector_to_list_iterate(const void* __obj, size_t __num) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_vector_to_list->__opr_iterate(__obj, __num); +} + +inline void __trace_vector_to_list_invalid_operator(const void* __obj) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_vector_to_list->__invalid_operator(__obj); +} + +inline void __trace_vector_to_list_resize(const void* __obj, + size_t __from, size_t __to) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_vector_to_list->__resize(__obj, __from, __to); +} + +} // namespace __cxxprof_impl +#endif /* PROFCXX_PROFILER_VECTOR_TO_LIST_H__ */ diff --git a/libstdc++-v3/include/profile/list b/libstdc++-v3/include/profile/list new file mode 100644 index 000000000000..061c50658263 --- /dev/null +++ b/libstdc++-v3/include/profile/list @@ -0,0 +1,520 @@ +// Profiling list implementation -*- C++ -*- + +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file profile/list + * This file is a GNU profile extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_PROFILE_LIST +#define _GLIBCXX_PROFILE_LIST 1 + +#include + +namespace std +{ +namespace __profile +{ + /** @brief List wrapper with performance instrumentation. */ + template > + class list + : public _GLIBCXX_STD_D::list<_Tp, _Allocator> + { + typedef _GLIBCXX_STD_D::list<_Tp, _Allocator> _Base; + + public: + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + + typedef _Tp value_type; + typedef _Allocator allocator_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + // 23.2.2.1 construct/copy/destroy: + explicit list(const _Allocator& __a = _Allocator()) + : _Base(__a) { } + + explicit list(size_type __n, const _Tp& __value = _Tp(), + const _Allocator& __a = _Allocator()) + : _Base(__n, __value, __a) { } + + template + list(_InputIterator __first, _InputIterator __last, + const _Allocator& __a = _Allocator()) + : _Base(__first, __last, __a) + { } + + + list(const list& __x) + : _Base(__x) { } + + list(const _Base& __x) + : _Base(__x) { } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + list(list&& __x) + : _Base(std::forward(__x)) + { } + + list(initializer_list __l, + const allocator_type& __a = allocator_type()) + : _Base(__l, __a) { } +#endif + + ~list() { } + + list& + operator=(const list& __x) + { + static_cast<_Base&>(*this) = __x; + return *this; + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + list& + operator=(list&& __x) + { + // NB: DR 675. + this->clear(); + this->swap(__x); + return *this; + } + + list& + operator=(initializer_list __l) + { + static_cast<_Base&>(*this) = __l; + return *this; + } + + void + assign(initializer_list __l) + { + _Base::assign(__l); + } +#endif + + template + void + assign(_InputIterator __first, _InputIterator __last) + { + _Base::assign(__first, __last); + } + + void + assign(size_type __n, const _Tp& __t) + { + _Base::assign(__n, __t); + } + + using _Base::get_allocator; + + // iterators: + iterator + begin() + { return iterator(_Base::begin()); } + + const_iterator + begin() const + { return const_iterator(_Base::begin()); } + + iterator + end() + { return iterator(_Base::end()); } + + const_iterator + end() const + { return const_iterator(_Base::end()); } + + reverse_iterator + rbegin() + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const + { return const_reverse_iterator(begin()); } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + const_iterator + cbegin() const + { return const_iterator(_Base::begin()); } + + const_iterator + cend() const + { return const_iterator(_Base::end()); } + + const_reverse_iterator + crbegin() const + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const + { return const_reverse_iterator(begin()); } +#endif + + // 23.2.2.2 capacity: + using _Base::empty; + using _Base::size; + using _Base::max_size; + + void + resize(size_type __sz, _Tp __c = _Tp()) + { + _Base::resize(__sz, __c); + } + + // element access: + reference + front() + { + return _Base::front(); + } + + const_reference + front() const + { + return _Base::front(); + } + + reference + back() + { + return _Base::back(); + } + + const_reference + back() const + { + return _Base::back(); + } + + // 23.2.2.3 modifiers: + using _Base::push_front; + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + using _Base::emplace_front; +#endif + + void + pop_front() + { + iterator __victim = begin(); + _Base::pop_front(); + } + + using _Base::push_back; + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + using _Base::emplace_back; +#endif + + void + pop_back() + { + iterator __victim = end(); + --__victim; + _Base::pop_back(); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template + iterator + emplace(iterator __position, _Args&&... __args) + { + return iterator(_Base::emplace(__position, + std::forward<_Args>(__args)...)); + } +#endif + + iterator + insert(iterator __position, const _Tp& __x) + { + return iterator(_Base::insert(__position, __x)); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + iterator + insert(iterator __position, _Tp&& __x) + { return emplace(__position, std::move(__x)); } + + void + insert(iterator __p, initializer_list __l) + { + _Base::insert(__p, __l); + } +#endif + + void + insert(iterator __position, size_type __n, const _Tp& __x) + { + _Base::insert(__position, __n, __x); + } + + template + void + insert(iterator __position, _InputIterator __first, + _InputIterator __last) + { + _Base::insert(__position, __first, __last); + } + + iterator + erase(iterator __position) + { + return iterator(_Base::erase(__position)); + } + + iterator + erase(iterator __position, iterator __last) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + return iterator(_Base::erase(__position, __last)); + } + + void + swap(list& __x) + { + _Base::swap(__x); + } + + void + clear() + { + _Base::clear(); + } + + // 23.2.2.4 list operations: + void +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + splice(iterator __position, list&& __x) +#else + splice(iterator __position, list& __x) +#endif + { + this->splice(__position, _GLIBCXX_MOVE(__x), __x.begin(), __x.end()); + } + + void +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + splice(iterator __position, list&& __x, iterator __i) +#else + splice(iterator __position, list& __x, iterator __i) +#endif + { + // We used to perform the splice_alloc check: not anymore, redundant + // after implementing the relevant bits of N1599. + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + _Base::splice(__position, _GLIBCXX_MOVE(__x._M_base()), + __i); + } + + void +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + splice(iterator __position, list&& __x, iterator __first, + iterator __last) +#else + splice(iterator __position, list& __x, iterator __first, + iterator __last) +#endif + { + // We used to perform the splice_alloc check: not anymore, redundant + // after implementing the relevant bits of N1599. + + _Base::splice(__position, _GLIBCXX_MOVE(__x._M_base()), + __first, __last); + } + + void + remove(const _Tp& __value) + { + for (iterator __x = begin(); __x != _Base::end(); ) + { + if (*__x == __value) + __x = erase(__x); + else + ++__x; + } + } + + template + void + remove_if(_Predicate __pred) + { + for (iterator __x = begin(); __x != _Base::end(); ) + { + if (__pred(*__x)) + __x = erase(__x); + else + ++__x; + } + } + + void + unique() + { + iterator __first = begin(); + iterator __last = end(); + if (__first == __last) + return; + iterator __next = __first; + while (++__next != __last) + { + if (*__first == *__next) + erase(__next); + else + __first = __next; + __next = __first; + } + } + + template + void + unique(_BinaryPredicate __binary_pred) + { + iterator __first = begin(); + iterator __last = end(); + if (__first == __last) + return; + iterator __next = __first; + while (++__next != __last) + { + if (__binary_pred(*__first, *__next)) + erase(__next); + else + __first = __next; + __next = __first; + } + } + + void +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + merge(list&& __x) +#else + merge(list& __x) +#endif + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 300. list::merge() specification incomplete + if (this != &__x) + { + _Base::merge(_GLIBCXX_MOVE(__x._M_base())); + } + } + + template + void +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + merge(list&& __x, _Compare __comp) +#else + merge(list& __x, _Compare __comp) +#endif + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 300. list::merge() specification incomplete + if (this != &__x) + { + _Base::merge(_GLIBCXX_MOVE(__x._M_base()), __comp); + } + } + + void + sort() { _Base::sort(); } + + template + void + sort(_StrictWeakOrdering __pred) { _Base::sort(__pred); } + + using _Base::reverse; + + _Base& + _M_base() { return *this; } + + const _Base& + _M_base() const { return *this; } + + }; + + template + inline bool + operator==(const list<_Tp, _Alloc>& __lhs, + const list<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() == __rhs._M_base(); } + + template + inline bool + operator!=(const list<_Tp, _Alloc>& __lhs, + const list<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() != __rhs._M_base(); } + + template + inline bool + operator<(const list<_Tp, _Alloc>& __lhs, + const list<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() < __rhs._M_base(); } + + template + inline bool + operator<=(const list<_Tp, _Alloc>& __lhs, + const list<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() <= __rhs._M_base(); } + + template + inline bool + operator>=(const list<_Tp, _Alloc>& __lhs, + const list<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() >= __rhs._M_base(); } + + template + inline bool + operator>(const list<_Tp, _Alloc>& __lhs, + const list<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() > __rhs._M_base(); } + + template + inline void + swap(list<_Tp, _Alloc>& __lhs, list<_Tp, _Alloc>& __rhs) + { __lhs.swap(__rhs); } + +} // namespace __profile +} // namespace std + +#endif diff --git a/libstdc++-v3/include/profile/map b/libstdc++-v3/include/profile/map new file mode 100644 index 000000000000..e396b852398d --- /dev/null +++ b/libstdc++-v3/include/profile/map @@ -0,0 +1,41 @@ +// Profiling map/multimap implementation -*- C++ -*- + +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +/** @file profile/map + * This file is a GNU profile extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_PROFILE_MAP +#define _GLIBCXX_PROFILE_MAP 1 + +#include +#include +#include + +#endif diff --git a/libstdc++-v3/include/profile/map.h b/libstdc++-v3/include/profile/map.h new file mode 100644 index 000000000000..aa9e535a1e4f --- /dev/null +++ b/libstdc++-v3/include/profile/map.h @@ -0,0 +1,489 @@ +// Profiling map implementation -*- C++ -*- + +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +/** @file profile/map.h + * This file is a GNU profile extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_PROFILE_MAP_H +#define _GLIBCXX_PROFILE_MAP_H 1 + +#include +#include + +namespace std +{ +namespace __profile +{ + /** @brief Map wrapper with performance instrumentation. */ + template, + typename _Allocator = std::allocator > > + class map + : public _GLIBCXX_STD_D::map<_Key, _Tp, _Compare, _Allocator> + { + typedef _GLIBCXX_STD_D::map<_Key, _Tp, _Compare, _Allocator> _Base; + + public: + // types: + typedef _Key key_type; + typedef _Tp mapped_type; + typedef std::pair value_type; + typedef _Compare key_compare; + typedef _Allocator allocator_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + using _Base::value_compare; + + // 23.3.1.1 construct/copy/destroy: + explicit map(const _Compare& __comp = _Compare(), + const _Allocator& __a = _Allocator()) + : _Base(__comp, __a) { + __profcxx_map_to_unordered_map_construct(this); + } + + template + map(_InputIterator __first, _InputIterator __last, + const _Compare& __comp = _Compare(), + const _Allocator& __a = _Allocator()) + : _Base(__first, __last, __comp, __a) { + __profcxx_map_to_unordered_map_construct(this); + } + + map(const map& __x) + : _Base(__x) { + __profcxx_map_to_unordered_map_construct(this); + } + + map(const _Base& __x) + : _Base(__x) { + __profcxx_map_to_unordered_map_construct(this); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + map(map&& __x) + : _Base(std::forward(__x)) + { } + + map(initializer_list __l, + const _Compare& __c = _Compare(), + const allocator_type& __a = allocator_type()) + : _Base(__l, __c, __a) { } +#endif + + ~map() { + __profcxx_map_to_unordered_map_destruct(this); + } + + map& + operator=(const map& __x) + { + *static_cast<_Base*>(this) = __x; + return *this; + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + map& + operator=(map&& __x) + { + // NB: DR 675. + this->clear(); + this->swap(__x); + return *this; + } + + map& + operator=(initializer_list __l) + { + this->clear(); + this->insert(__l); + return *this; + } +#endif + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 133. map missing get_allocator() + using _Base::get_allocator; + + // iterators: + iterator + begin() + { return _Base::begin(); } + + const_iterator + begin() const + { return _Base::begin(); } + + iterator + end() + { return _Base::end(); } + + const_iterator + end() const + { return _Base::end(); } + + reverse_iterator + rbegin() + { + __profcxx_map_to_unordered_map_invalidate(this); + return reverse_iterator(end()); + } + + const_reverse_iterator + rbegin() const + { + __profcxx_map_to_unordered_map_invalidate(this); + return const_reverse_iterator(end()); + } + + reverse_iterator + rend() + { + __profcxx_map_to_unordered_map_invalidate(this); + return reverse_iterator(begin()); + } + + const_reverse_iterator + rend() const + { + __profcxx_map_to_unordered_map_invalidate(this); + return const_reverse_iterator(begin()); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + const_iterator + cbegin() const + { return const_iterator(_Base::begin()); } + + const_iterator + cend() const + { return const_iterator(_Base::end()); } + + const_reverse_iterator + crbegin() const + { + __profcxx_map_to_unordered_map_invalidate(this); + return const_reverse_iterator(end()); + } + + const_reverse_iterator + crend() const + { + __profcxx_map_to_unordered_map_invalidate(this); + return const_reverse_iterator(begin()); + } +#endif + + // capacity: + using _Base::empty; + using _Base::size; + using _Base::max_size; + + // 23.3.1.2 element access: + mapped_type& + operator[](const key_type& __k) + { + __profcxx_map_to_unordered_map_find(this, size()); + return _Base::operator[](__k); + } + + mapped_type& + at(const key_type& __k) + { + __profcxx_map_to_unordered_map_find(this, size()); + return _Base::at(__k); + } + + const mapped_type& + at(const key_type& __k) const + { + __profcxx_map_to_unordered_map_find(this, size()); + return _Base::at(__k); + } + + // modifiers: + std::pair + insert(const value_type& __x) + { + __profcxx_map_to_unordered_map_insert(this, size(), 1); + typedef typename _Base::iterator _Base_iterator; + std::pair<_Base_iterator, bool> __res = _Base::insert(__x); + return std::pair(iterator(__res.first), + __res.second); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + void + insert(std::initializer_list __list) + { + size_type size_before = size(); + _Base::insert(__list); + __profcxx_map_to_unordered_map_insert(this, size_before, + size() - size_before); + } +#endif + + iterator + insert(iterator __position, const value_type& __x) + { + size_type size_before = size(); + return iterator(_Base::insert(__position, __x)); + __profcxx_map_to_unordered_map_insert(this, size_before, + size() - size_before); + } + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + size_type size_before = size(); + _Base::insert(__first, __last); + __profcxx_map_to_unordered_map_insert(this, size_before, + size() - size_before); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + iterator + erase(iterator __position) + { + iterator __i = _Base::erase(__position); + __profcxx_map_to_unordered_map_erase(this, size(), 1); + return __i; + } +#else + void + erase(iterator __position) + { + _Base::erase(__position); + __profcxx_map_to_unordered_map_erase(this, size(), 1); + } +#endif + + size_type + erase(const key_type& __x) + { + iterator __victim = find(__x); + if (__victim == end()) + return 0; + else + { + _Base::erase(__victim); + return 1; + } + } + + void + erase(iterator __first, iterator __last) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + while (__first != __last) + this->erase(__first++); + } + + void + + swap(map& __x) + { + _Base::swap(__x); + } + + void + clear() + { this->erase(begin(), end()); } + + // observers: + using _Base::key_comp; + using _Base::value_comp; + + // 23.3.1.3 map operations: + iterator + find(const key_type& __x) + { + __profcxx_map_to_unordered_map_find(this, size()); + return iterator(_Base::find(__x)); + } + + const_iterator + find(const key_type& __x) const + { + __profcxx_map_to_unordered_map_find(this, size()); + return const_iterator(_Base::find(__x)); + } + + size_type + count(const key_type& __x) const + { + __profcxx_map_to_unordered_map_find(this, size()); + return _Base::count(__x); + } + + iterator + lower_bound(const key_type& __x) + { + __profcxx_map_to_unordered_map_invalidate(this); + return iterator(_Base::lower_bound(__x)); + } + + const_iterator + lower_bound(const key_type& __x) const + { + __profcxx_map_to_unordered_map_invalidate(this); + return const_iterator(_Base::lower_bound(__x)); + } + + iterator + upper_bound(const key_type& __x) + { + __profcxx_map_to_unordered_map_invalidate(this); + return iterator(_Base::upper_bound(__x)); + } + + const_iterator + upper_bound(const key_type& __x) const + { + __profcxx_map_to_unordered_map_invalidate(this); + return const_iterator(_Base::upper_bound(__x)); + } + + std::pair + equal_range(const key_type& __x) + { + typedef typename _Base::iterator _Base_iterator; + std::pair<_Base_iterator, _Base_iterator> __res = + _Base::equal_range(__x); + return std::make_pair(iterator(__res.first), + iterator(__res.second)); + } + + std::pair + equal_range(const key_type& __x) const + { + __profcxx_map_to_unordered_map_find(this, size()); + typedef typename _Base::const_iterator _Base_const_iterator; + std::pair<_Base_const_iterator, _Base_const_iterator> __res = + _Base::equal_range(__x); + return std::make_pair(const_iterator(__res.first), + const_iterator(__res.second)); + } + + _Base& + _M_base() { return *this; } + + const _Base& + _M_base() const { return *this; } + + }; + + template + inline bool + operator==(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, + const map<_Key, _Tp, _Compare, _Allocator>& __rhs) + { + __profcxx_map_to_unordered_map_invalidate(&__lhs); + __profcxx_map_to_unordered_map_invalidate(&__rhs); + return __lhs._M_base() == __rhs._M_base(); + } + + template + inline bool + operator!=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, + const map<_Key, _Tp, _Compare, _Allocator>& __rhs) + { + __profcxx_map_to_unordered_map_invalidate(&__lhs); + __profcxx_map_to_unordered_map_invalidate(&__rhs); + return __lhs._M_base() != __rhs._M_base(); + } + + template + inline bool + operator<(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, + const map<_Key, _Tp, _Compare, _Allocator>& __rhs) + { + __profcxx_map_to_unordered_map_invalidate(&__lhs); + __profcxx_map_to_unordered_map_invalidate(&__rhs); + return __lhs._M_base() < __rhs._M_base(); + } + + template + inline bool + operator<=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, + const map<_Key, _Tp, _Compare, _Allocator>& __rhs) + { + __profcxx_map_to_unordered_map_invalidate(&__lhs); + __profcxx_map_to_unordered_map_invalidate(&__rhs); + return __lhs._M_base() <= __rhs._M_base(); + } + + template + inline bool + operator>=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, + const map<_Key, _Tp, _Compare, _Allocator>& __rhs) + { + __profcxx_map_to_unordered_map_invalidate(&__lhs); + __profcxx_map_to_unordered_map_invalidate(&__rhs); + return __lhs._M_base() >= __rhs._M_base(); + } + + template + inline bool + operator>(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, + const map<_Key, _Tp, _Compare, _Allocator>& __rhs) + { + __profcxx_map_to_unordered_map_invalidate(&__lhs); + __profcxx_map_to_unordered_map_invalidate(&__rhs); + return __lhs._M_base() > __rhs._M_base(); + } + + template + inline void + swap(map<_Key, _Tp, _Compare, _Allocator>& __lhs, + map<_Key, _Tp, _Compare, _Allocator>& __rhs) + { __lhs.swap(__rhs); } + +} // namespace __profile +} // namespace std + +#endif diff --git a/libstdc++-v3/include/profile/multimap.h b/libstdc++-v3/include/profile/multimap.h new file mode 100644 index 000000000000..b1fc70b63b2f --- /dev/null +++ b/libstdc++-v3/include/profile/multimap.h @@ -0,0 +1,363 @@ +// Profiling multimap implementation -*- C++ -*- + +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file profile/multimap.h + * This file is a GNU profile extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_PROFILE_MULTIMAP_H +#define _GLIBCXX_PROFILE_MULTIMAP_H 1 + +#include + +namespace std +{ +namespace __profile +{ + /** @brief Multimap wrapper with performance instrumentation. */ + template, + typename _Allocator = std::allocator > > + class multimap + : public _GLIBCXX_STD_D::multimap<_Key, _Tp, _Compare, _Allocator> + { + typedef _GLIBCXX_STD_D::multimap<_Key, _Tp, _Compare, _Allocator> _Base; + + public: + // types: + typedef _Key key_type; + typedef _Tp mapped_type; + typedef std::pair value_type; + typedef _Compare key_compare; + typedef _Allocator allocator_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + typedef typename _Base::reverse_iterator reverse_iterator; + typedef typename _Base::const_reverse_iterator const_reverse_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + + using _Base::value_compare; + + // 23.3.1.1 construct/copy/destroy: + explicit multimap(const _Compare& __comp = _Compare(), + const _Allocator& __a = _Allocator()) + : _Base(__comp, __a) { } + + template + multimap(_InputIterator __first, _InputIterator __last, + const _Compare& __comp = _Compare(), + const _Allocator& __a = _Allocator()) + : _Base(__first, __last, __comp, __a) { } + + multimap(const multimap& __x) + : _Base(__x) { } + + multimap(const _Base& __x) + : _Base(__x) { } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + multimap(multimap&& __x) + : _Base(std::forward(__x)) + { } + + multimap(initializer_list __l, + const _Compare& __c = _Compare(), + const allocator_type& __a = allocator_type()) + : _Base(__l, __c, __a) { } +#endif + + ~multimap() { } + + multimap& + operator=(const multimap& __x) + { + *static_cast<_Base*>(this) = __x; + return *this; + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + multimap& + operator=(multimap&& __x) + { + // NB: DR 675. + this->clear(); + this->swap(__x); + return *this; + } + + multimap& + operator=(initializer_list __l) + { + this->clear(); + this->insert(__l); + return *this; + } +#endif + + using _Base::get_allocator; + + // iterators: + iterator + begin() + { return iterator(_Base::begin()); } + + const_iterator + begin() const + { return const_iterator(_Base::begin()); } + + iterator + end() + { return iterator(_Base::end()); } + + const_iterator + end() const + { return const_iterator(_Base::end()); } + + reverse_iterator + rbegin() + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const + { return const_reverse_iterator(begin()); } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + const_iterator + cbegin() const + { return const_iterator(_Base::begin()); } + + const_iterator + cend() const + { return const_iterator(_Base::end()); } + + const_reverse_iterator + crbegin() const + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const + { return const_reverse_iterator(begin()); } +#endif + + // capacity: + using _Base::empty; + using _Base::size; + using _Base::max_size; + + // modifiers: + iterator + insert(const value_type& __x) + { return iterator(_Base::insert(__x)); } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + void + insert(std::initializer_list __list) + { _Base::insert(__list); } +#endif + + iterator + insert(iterator __position, const value_type& __x) + { + return iterator(_Base::insert(__position, __x)); + } + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + _Base::insert(__first, __last); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + iterator + erase(iterator __position) + { + return _Base::erase(__position); + } +#else + void + erase(iterator __position) + { + _Base::erase(__position); + } +#endif + + size_type + erase(const key_type& __x) + { + std::pair __victims = this->equal_range(__x); + size_type __count = 0; + while (__victims.first != __victims.second) + { + iterator __victim = __victims.first++; + _Base::erase(__victim); + ++__count; + } + return __count; + } + + void + erase(iterator __first, iterator __last) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + while (__first != __last) + this->erase(__first++); + } + + void + swap(multimap& __x) + { + _Base::swap(__x); + } + + void + clear() + { this->erase(begin(), end()); } + + // observers: + using _Base::key_comp; + using _Base::value_comp; + + // 23.3.1.3 multimap operations: + iterator + find(const key_type& __x) + { return iterator(_Base::find(__x)); } + + const_iterator + find(const key_type& __x) const + { return const_iterator(_Base::find(__x)); } + + using _Base::count; + + iterator + lower_bound(const key_type& __x) + { return iterator(_Base::lower_bound(__x)); } + + const_iterator + lower_bound(const key_type& __x) const + { return const_iterator(_Base::lower_bound(__x)); } + + iterator + upper_bound(const key_type& __x) + { return iterator(_Base::upper_bound(__x)); } + + const_iterator + upper_bound(const key_type& __x) const + { return const_iterator(_Base::upper_bound(__x)); } + + std::pair + equal_range(const key_type& __x) + { + typedef typename _Base::iterator _Base_iterator; + std::pair<_Base_iterator, _Base_iterator> __res = + _Base::equal_range(__x); + return std::make_pair(iterator(__res.first), + iterator(__res.second)); + } + + std::pair + equal_range(const key_type& __x) const + { + typedef typename _Base::const_iterator _Base_const_iterator; + std::pair<_Base_const_iterator, _Base_const_iterator> __res = + _Base::equal_range(__x); + return std::make_pair(const_iterator(__res.first), + const_iterator(__res.second)); + } + + _Base& + _M_base() { return *this; } + + const _Base& + _M_base() const { return *this; } + }; + + template + inline bool + operator==(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, + const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() == __rhs._M_base(); } + + template + inline bool + operator!=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, + const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() != __rhs._M_base(); } + + template + inline bool + operator<(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, + const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() < __rhs._M_base(); } + + template + inline bool + operator<=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, + const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() <= __rhs._M_base(); } + + template + inline bool + operator>=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, + const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() >= __rhs._M_base(); } + + template + inline bool + operator>(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, + const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() > __rhs._M_base(); } + + template + inline void + swap(multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, + multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) + { __lhs.swap(__rhs); } + +} // namespace __profile +} // namespace std + +#endif diff --git a/libstdc++-v3/include/profile/multiset.h b/libstdc++-v3/include/profile/multiset.h new file mode 100644 index 000000000000..759761bd52cc --- /dev/null +++ b/libstdc++-v3/include/profile/multiset.h @@ -0,0 +1,363 @@ +// Profiling multiset implementation -*- C++ -*- + +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file profile/multiset.h + * This file is a GNU profile extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_PROFILE_MULTISET_H +#define _GLIBCXX_PROFILE_MULTISET_H 1 + +#include + +namespace std +{ +namespace __profile +{ + /** @brief Multiset wrapper with performance instrumentation. */ + template, + typename _Allocator = std::allocator<_Key> > + class multiset + : public _GLIBCXX_STD_D::multiset<_Key, _Compare, _Allocator> + { + typedef _GLIBCXX_STD_D::multiset<_Key, _Compare, _Allocator> _Base; + + public: + // types: + typedef _Key key_type; + typedef _Key value_type; + typedef _Compare key_compare; + typedef _Compare value_compare; + typedef _Allocator allocator_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + typedef typename _Base::reverse_iterator reverse_iterator; + typedef typename _Base::const_reverse_iterator const_reverse_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + + // 23.3.3.1 construct/copy/destroy: + explicit multiset(const _Compare& __comp = _Compare(), + const _Allocator& __a = _Allocator()) + : _Base(__comp, __a) { } + + template + multiset(_InputIterator __first, _InputIterator __last, + const _Compare& __comp = _Compare(), + const _Allocator& __a = _Allocator()) + : _Base(__first, __last, __comp, __a) { } + + multiset(const multiset& __x) + : _Base(__x) { } + + multiset(const _Base& __x) + : _Base(__x) { } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + multiset(multiset&& __x) + : _Base(std::forward(__x)) + { } + + multiset(initializer_list __l, + const _Compare& __comp = _Compare(), + const allocator_type& __a = allocator_type()) + : _Base(__l, __comp, __a) { } +#endif + + ~multiset() { } + + multiset& + operator=(const multiset& __x) + { + *static_cast<_Base*>(this) = __x; + return *this; + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + multiset& + operator=(multiset&& __x) + { + // NB: DR 675. + this->clear(); + this->swap(__x); + return *this; + } + + multiset& + operator=(initializer_list __l) + { + this->clear(); + this->insert(__l); + return *this; + } +#endif + + using _Base::get_allocator; + + // iterators: + iterator + begin() + { return iterator(_Base::begin()); } + + const_iterator + begin() const + { return const_iterator(_Base::begin()); } + + iterator + end() + { return iterator(_Base::end()); } + + const_iterator + end() const + { return const_iterator(_Base::end()); } + + reverse_iterator + rbegin() + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const + { return const_reverse_iterator(begin()); } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + const_iterator + cbegin() const + { return const_iterator(_Base::begin()); } + + const_iterator + cend() const + { return const_iterator(_Base::end()); } + + const_reverse_iterator + crbegin() const + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const + { return const_reverse_iterator(begin()); } +#endif + + // capacity: + using _Base::empty; + using _Base::size; + using _Base::max_size; + + // modifiers: + iterator + insert(const value_type& __x) + { return iterator(_Base::insert(__x)); } + + iterator + insert(iterator __position, const value_type& __x) + { + return iterator(_Base::insert(__position, __x)); + } + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + _Base::insert(__first, __last); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + void + insert(initializer_list __l) + { _Base::insert(__l); } +#endif + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + iterator + erase(iterator __position) + { + return _Base::erase(__position); + } +#else + void + erase(iterator __position) + { + _Base::erase(__position); + } +#endif + + size_type + erase(const key_type& __x) + { + std::pair __victims = this->equal_range(__x); + size_type __count = 0; + while (__victims.first != __victims.second) + { + iterator __victim = __victims.first++; + _Base::erase(__victim); + ++__count; + } + return __count; + } + + void + erase(iterator __first, iterator __last) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + while (__first != __last) + this->erase(__first++); + } + + void + swap(multiset& __x) + { + _Base::swap(__x); + } + + void + clear() + { this->erase(begin(), end()); } + + // observers: + using _Base::key_comp; + using _Base::value_comp; + + // multiset operations: + iterator + find(const key_type& __x) + { return iterator(_Base::find(__x)); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + const_iterator + find(const key_type& __x) const + { return const_iterator(_Base::find(__x)); } + + using _Base::count; + + iterator + lower_bound(const key_type& __x) + { return iterator(_Base::lower_bound(__x)); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + const_iterator + lower_bound(const key_type& __x) const + { return const_iterator(_Base::lower_bound(__x)); } + + iterator + upper_bound(const key_type& __x) + { return iterator(_Base::upper_bound(__x)); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + const_iterator + upper_bound(const key_type& __x) const + { return const_iterator(_Base::upper_bound(__x)); } + + std::pair + equal_range(const key_type& __x) + { + typedef typename _Base::iterator _Base_iterator; + std::pair<_Base_iterator, _Base_iterator> __res = + _Base::equal_range(__x); + return std::make_pair(iterator(__res.first), + iterator(__res.second)); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + std::pair + equal_range(const key_type& __x) const + { + typedef typename _Base::const_iterator _Base_iterator; + std::pair<_Base_iterator, _Base_iterator> __res = + _Base::equal_range(__x); + return std::make_pair(const_iterator(__res.first), + const_iterator(__res.second)); + } + + _Base& + _M_base() { return *this; } + + const _Base& + _M_base() const { return *this; } + + }; + + template + inline bool + operator==(const multiset<_Key, _Compare, _Allocator>& __lhs, + const multiset<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() == __rhs._M_base(); } + + template + inline bool + operator!=(const multiset<_Key, _Compare, _Allocator>& __lhs, + const multiset<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() != __rhs._M_base(); } + + template + inline bool + operator<(const multiset<_Key, _Compare, _Allocator>& __lhs, + const multiset<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() < __rhs._M_base(); } + + template + inline bool + operator<=(const multiset<_Key, _Compare, _Allocator>& __lhs, + const multiset<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() <= __rhs._M_base(); } + + template + inline bool + operator>=(const multiset<_Key, _Compare, _Allocator>& __lhs, + const multiset<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() >= __rhs._M_base(); } + + template + inline bool + operator>(const multiset<_Key, _Compare, _Allocator>& __lhs, + const multiset<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() > __rhs._M_base(); } + + template + void + swap(multiset<_Key, _Compare, _Allocator>& __x, + multiset<_Key, _Compare, _Allocator>& __y) + { return __x.swap(__y); } + +} // namespace __profile +} // namespace std + +#endif diff --git a/libstdc++-v3/include/profile/set b/libstdc++-v3/include/profile/set new file mode 100644 index 000000000000..11603a848588 --- /dev/null +++ b/libstdc++-v3/include/profile/set @@ -0,0 +1,41 @@ +// Profiling set/multiset implementation -*- C++ -*- + +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +/** @file profile/set + * This file is a GNU profile extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_PROFILE_SET +#define _GLIBCXX_PROFILE_SET 1 + +#include +#include +#include + +#endif diff --git a/libstdc++-v3/include/profile/set.h b/libstdc++-v3/include/profile/set.h new file mode 100644 index 000000000000..50fb16faf37e --- /dev/null +++ b/libstdc++-v3/include/profile/set.h @@ -0,0 +1,367 @@ +// Profiling set implementation -*- C++ -*- + +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file profile/set.h + * This file is a GNU profile extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_PROFILE_SET_H +#define _GLIBCXX_PROFILE_SET_H 1 + +#include + +namespace std +{ +namespace __profile +{ + /** @brief Set wrapper with performance instrumentation. */ + template, + typename _Allocator = std::allocator<_Key> > + class set + : public _GLIBCXX_STD_D::set<_Key,_Compare,_Allocator> + { + typedef _GLIBCXX_STD_D::set<_Key, _Compare, _Allocator> _Base; + + public: + // types: + typedef _Key key_type; + typedef _Key value_type; + typedef _Compare key_compare; + typedef _Compare value_compare; + typedef _Allocator allocator_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + typedef typename _Base::reverse_iterator reverse_iterator; + typedef typename _Base::const_reverse_iterator const_reverse_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + + // 23.3.3.1 construct/copy/destroy: + explicit set(const _Compare& __comp = _Compare(), + const _Allocator& __a = _Allocator()) + : _Base(__comp, __a) { } + + template + set(_InputIterator __first, _InputIterator __last, + const _Compare& __comp = _Compare(), + const _Allocator& __a = _Allocator()) + : _Base(__first, __last, __comp, __a) { } + + set(const set& __x) + : _Base(__x) { } + + set(const _Base& __x) + : _Base(__x) { } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + set(set&& __x) + : _Base(std::forward(__x)) + { } + + set(initializer_list __l, + const _Compare& __comp = _Compare(), + const allocator_type& __a = allocator_type()) + : _Base(__l, __comp, __a) { } +#endif + + ~set() { } + + set& + operator=(const set& __x) + { + *static_cast<_Base*>(this) = __x; + return *this; + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + set& + operator=(set&& __x) + { + // NB: DR 675. + this->clear(); + this->swap(__x); + return *this; + } + + set& + operator=(initializer_list __l) + { + this->clear(); + this->insert(__l); + return *this; + } +#endif + + using _Base::get_allocator; + + // iterators: + iterator + begin() + { return iterator(_Base::begin()); } + + const_iterator + begin() const + { return const_iterator(_Base::begin()); } + + iterator + end() + { return iterator(_Base::end()); } + + const_iterator + end() const + { return const_iterator(_Base::end()); } + + reverse_iterator + rbegin() + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const + { return const_reverse_iterator(begin()); } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + const_iterator + cbegin() const + { return const_iterator(_Base::begin()); } + + const_iterator + cend() const + { return const_iterator(_Base::end()); } + + const_reverse_iterator + crbegin() const + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const + { return const_reverse_iterator(begin()); } +#endif + + // capacity: + using _Base::empty; + using _Base::size; + using _Base::max_size; + + // modifiers: + std::pair + insert(const value_type& __x) + { + typedef typename _Base::iterator _Base_iterator; + std::pair<_Base_iterator, bool> __res = _Base::insert(__x); + return std::pair(iterator(__res.first), + __res.second); + } + + iterator + insert(iterator __position, const value_type& __x) + { + return iterator(_Base::insert(__position, __x)); + } + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + _Base::insert(__first, __last); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + void + insert(initializer_list __l) + { _Base::insert(__l); } +#endif + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + iterator + erase(iterator __position) + { + return _Base::erase(__position); + } +#else + void + erase(iterator __position) + { + _Base::erase(__position); + } +#endif + + size_type + erase(const key_type& __x) + { + iterator __victim = find(__x); + if (__victim == end()) + return 0; + else + { + _Base::erase(__victim); + return 1; + } + } + + void + erase(iterator __first, iterator __last) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + while (__first != __last) + this->erase(__first++); + } + + void + swap(set& __x) + { + _Base::swap(__x); + } + + void + clear() + { this->erase(begin(), end()); } + + // observers: + using _Base::key_comp; + using _Base::value_comp; + + // set operations: + iterator + find(const key_type& __x) + { return iterator(_Base::find(__x)); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + const_iterator + find(const key_type& __x) const + { return const_iterator(_Base::find(__x)); } + + using _Base::count; + + iterator + lower_bound(const key_type& __x) + { return iterator(_Base::lower_bound(__x)); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + const_iterator + lower_bound(const key_type& __x) const + { return const_iterator(_Base::lower_bound(__x)); } + + iterator + upper_bound(const key_type& __x) + { return iterator(_Base::upper_bound(__x)); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + const_iterator + upper_bound(const key_type& __x) const + { return const_iterator(_Base::upper_bound(__x)); } + + std::pair + equal_range(const key_type& __x) + { + typedef typename _Base::iterator _Base_iterator; + std::pair<_Base_iterator, _Base_iterator> __res = + _Base::equal_range(__x); + return std::make_pair(iterator(__res.first), + iterator(__res.second)); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + std::pair + equal_range(const key_type& __x) const + { + typedef typename _Base::const_iterator _Base_iterator; + std::pair<_Base_iterator, _Base_iterator> __res = + _Base::equal_range(__x); + return std::make_pair(const_iterator(__res.first), + const_iterator(__res.second)); + } + + _Base& + _M_base() { return *this; } + + const _Base& + _M_base() const { return *this; } + + }; + + template + inline bool + operator==(const set<_Key, _Compare, _Allocator>& __lhs, + const set<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() == __rhs._M_base(); } + + template + inline bool + operator!=(const set<_Key, _Compare, _Allocator>& __lhs, + const set<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() != __rhs._M_base(); } + + template + inline bool + operator<(const set<_Key, _Compare, _Allocator>& __lhs, + const set<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() < __rhs._M_base(); } + + template + inline bool + operator<=(const set<_Key, _Compare, _Allocator>& __lhs, + const set<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() <= __rhs._M_base(); } + + template + inline bool + operator>=(const set<_Key, _Compare, _Allocator>& __lhs, + const set<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() >= __rhs._M_base(); } + + template + inline bool + operator>(const set<_Key, _Compare, _Allocator>& __lhs, + const set<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() > __rhs._M_base(); } + + template + void + swap(set<_Key, _Compare, _Allocator>& __x, + set<_Key, _Compare, _Allocator>& __y) + { return __x.swap(__y); } + +} // namespace __profile +} // namespace std + +#endif diff --git a/libstdc++-v3/include/profile/unordered_map b/libstdc++-v3/include/profile/unordered_map new file mode 100644 index 000000000000..d1cb9217d23e --- /dev/null +++ b/libstdc++-v3/include/profile/unordered_map @@ -0,0 +1,498 @@ +// Profiling unordered_map/unordered_multimap implementation -*- C++ -*- + +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +/** @file profile/unordered_map + * This file is a GNU profile extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_PROFILE_UNORDERED_MAP +#define _GLIBCXX_PROFILE_UNORDERED_MAP 1 + +#include + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +# include +#else +# include +#endif + +#include + +#define _GLIBCXX_BASE unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc> +#define _GLIBCXX_STD_BASE _GLIBCXX_STD_PR::_GLIBCXX_BASE + +namespace std +{ +namespace __profile +{ + /** @brief Unordered_map wrapper with performance instrumentation. */ + template, + typename _Pred = std::equal_to<_Key>, + typename _Alloc = std::allocator<_Key> > + class unordered_map + : public _GLIBCXX_STD_BASE + { + typedef typename _GLIBCXX_STD_BASE _Base; + + public: + typedef typename _Base::size_type size_type; + typedef typename _Base::hasher hasher; + typedef typename _Base::key_equal key_equal; + typedef typename _Base::allocator_type allocator_type; + typedef typename _Base::key_type key_type; + typedef typename _Base::value_type value_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + typedef typename _Base::mapped_type mapped_type; + typedef std::pair pair_type; + typedef typename _Base::insert_return_type insert_return_type; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + + explicit + unordered_map(size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__n, __hf, __eql, __a) + { + __profcxx_hashtable_construct(this, _Base::bucket_count()); + __profcxx_hashtable_construct2(this); + } + + template + unordered_map(_InputIterator __f, _InputIterator __l, + size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__f, __l, __n, __hf, __eql, __a) + { + __profcxx_hashtable_construct(this, _Base::bucket_count()); + __profcxx_hashtable_construct2(this); + } + + unordered_map(const _Base& __x) + : _Base(__x) + { + __profcxx_hashtable_construct(this, _Base::bucket_count()); + __profcxx_hashtable_construct2(this); + } + + unordered_map(unordered_map&& __x) + : _Base(std::forward<_Base>(__x)) + { + __profcxx_hashtable_construct(this, _Base::bucket_count()); + __profcxx_hashtable_construct2(this); + } + + unordered_map(initializer_list __l, + size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__l, __n, __hf, __eql, __a) { } + + unordered_map& + operator=(const unordered_map& __x) + { + *static_cast<_Base*>(this) = __x; + return *this; + } + + unordered_map& + operator=(unordered_map&& __x) + { + // NB: DR 675. + this->clear(); + this->swap(__x); + return *this; + } + + unordered_map& + operator=(initializer_list __l) + { + this->clear(); + this->insert(__l); + return *this; + } + + ~unordered_map() + { + __profcxx_hashtable_destruct(this, _Base::bucket_count(), _Base::size()); + _M_profile_destruct(); + } + + _Base& + _M_base() { return *this; } + + const _Base& + _M_base() const { return *this; } + + + void + clear() + { + __profcxx_hashtable_destruct(this, _Base::bucket_count(), _Base::size()); + _M_profile_destruct(); + _Base::clear(); + } + + void + insert(std::initializer_list __l) + { + size_type __old_size = _Base::bucket_count(); + _Base::insert(__l); + _M_profile_resize(__old_size, _Base::bucket_count()); + } + + insert_return_type + insert(const value_type& __obj) + { + size_type __old_size = _Base::bucket_count(); + insert_return_type __res = _Base::insert(__obj); + _M_profile_resize(__old_size, _Base::bucket_count()); + return __res; + } + iterator + insert(iterator __iter, const value_type& __v) + { + size_type __old_size = _Base::bucket_count(); + iterator res = _Base::insert(__iter, __v); + _M_profile_resize(__old_size, _Base::bucket_count()); + return res; + } + + const_iterator + insert(const_iterator __iter, const value_type& __v) + { + size_type __old_size = _Base::bucket_count(); + const_iterator res =_Base::insert(__iter, __v); + _M_profile_resize(__old_size, _Base::bucket_count()); + return res; + } + + template + void + insert(_InputIter __first, _InputIter __last) + { + size_type __old_size = _Base::bucket_count(); + _Base::insert(__first.base(), __last.base()); + _M_profile_resize(__old_size, _Base::bucket_count()); + } + + void + insert(const value_type* __first, const value_type* __last) + { + size_type __old_size = _Base::bucket_count(); + _Base::insert(__first, __last); + _M_profile_resize(__old_size, _Base::bucket_count()); + } + + // operator [] + mapped_type& + operator[](const _Key& _k) + { + size_type __old_size = _Base::bucket_count(); + mapped_type& __res = _M_base()[_k]; + size_type __new_size = _Base::bucket_count(); + _M_profile_resize(__old_size, _Base::bucket_count()); + return __res; + } + + void + swap(unordered_map& __x) + { + _Base::swap(__x); + } + + void rehash(size_type __n) + { + size_type __old_size = _Base::bucket_count(); + _Base::rehash(__n); + _M_profile_resize(__old_size, _Base::bucket_count()); + } + private: + void _M_profile_resize(size_type __old_size, size_type __new_size) + { + if (__old_size != __new_size) + { + __profcxx_hashtable_resize(this, __old_size, __new_size); + } + } + void _M_profile_destruct() + { + size_type __hops = 0, __lc = 0, __chain = 0; + for (iterator it = _M_base().begin(); it != _M_base().end(); it++) + { + while (it._M_cur_node->_M_next) { + __chain++; + it++; + } + if (__chain) { + __chain++; + __lc = __lc > __chain ? __lc : __chain; + __hops += __chain * (__chain - 1) / 2; + __chain = 0; + } + } + __profcxx_hashtable_destruct2(this, __lc, _Base::size(), __hops); + } + }; + template + inline void + swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { __x.swap(__y); } + +#undef _GLIBCXX_BASE +#undef _GLIBCXX_STD_BASE +#define _GLIBCXX_BASE unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc> +#define _GLIBCXX_STD_BASE _GLIBCXX_STD_PR::_GLIBCXX_BASE + + /** @brief Unordered_multimap wrapper with performance instrumentation. */ + template, + typename _Pred = std::equal_to<_Key>, + typename _Alloc = std::allocator<_Key> > + class unordered_multimap + : public _GLIBCXX_STD_BASE + { + typedef typename _GLIBCXX_STD_BASE _Base; + + public: + typedef typename _Base::size_type size_type; + typedef typename _Base::hasher hasher; + typedef typename _Base::key_equal key_equal; + typedef typename _Base::allocator_type allocator_type; + typedef typename _Base::key_type key_type; + typedef typename _Base::value_type value_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + typedef std::pair pair_type; + typedef typename _Base::insert_return_type insert_return_type; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + + explicit + unordered_multimap(size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__n, __hf, __eql, __a) + { + __profcxx_hashtable_construct(this, _Base::bucket_count()); + } + template + unordered_multimap(_InputIterator __f, _InputIterator __l, + size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__f, __l, __n, __hf, __eql, __a) + { + __profcxx_hashtable_construct(this, _Base::bucket_count()); + } + + unordered_multimap(const _Base& __x) + : _Base(__x) + { + __profcxx_hashtable_construct(this, _Base::bucket_count()); + } + + unordered_multimap(unordered_multimap&& __x) + : _Base(std::forward<_Base>(__x)) + { + __profcxx_hashtable_construct(this, _Base::bucket_count()); + } + + unordered_multimap(initializer_list __l, + size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__l, __n, __hf, __eql, __a) { } + + unordered_multimap& + operator=(const unordered_multimap& __x) + { + *static_cast<_Base*>(this) = __x; + return *this; + } + + unordered_multimap& + operator=(unordered_multimap&& __x) + { + // NB: DR 675. + this->clear(); + this->swap(__x); + return *this; + } + + unordered_multimap& + operator=(initializer_list __l) + { + this->clear(); + this->insert(__l); + return *this; + } + + ~unordered_multimap() + { + __profcxx_hashtable_destruct(this, _Base::bucket_count(), _Base::size()); + _M_profile_destruct(); + } + + _Base& + _M_base() { return *this; } + + const _Base& + _M_base() const { return *this; } + + + void + clear() + { + __profcxx_hashtable_destruct(this, _Base::bucket_count(), _Base::size()); + _M_profile_destruct(); + _Base::clear(); + } + + void + insert(std::initializer_list __l) + { + size_type __old_size = _Base::bucket_count(); + _Base::insert(__l); + _M_profile_resize(__old_size, _Base::bucket_count()); + } + + insert_return_type + insert(const value_type& __obj) + { + size_type __old_size = _Base::bucket_count(); + insert_return_type __res = _Base::insert(__obj); + _M_profile_resize(__old_size, _Base::bucket_count()); + return __res; + } + iterator + insert(iterator __iter, const value_type& __v) + { + size_type __old_size = _Base::bucket_count(); + iterator res = _Base::insert(__iter, __v); + _M_profile_resize(__old_size, _Base::bucket_count()); + return res; + } + + const_iterator + insert(const_iterator __iter, const value_type& __v) + { + size_type __old_size = _Base::bucket_count(); + const_iterator res =_Base::insert(__iter, __v); + _M_profile_resize(__old_size, _Base::bucket_count()); + return res; + } + + template + void + insert(_InputIter __first, _InputIter __last) + { + size_type __old_size = _Base::bucket_count(); + _Base::insert(__first.base(), __last.base()); + _M_profile_resize(__old_size, _Base::bucket_count()); + } + + void + insert(const value_type* __first, const value_type* __last) + { + size_type __old_size = _Base::bucket_count(); + _Base::insert(__first, __last); + _M_profile_resize(__old_size, _Base::bucket_count()); + } + + void + swap(unordered_multimap& __x) + { + _Base::swap(__x); + } + + void rehash(size_type __n) + { + size_type __old_size = _Base::bucket_count(); + _Base::rehash(__n); + _M_profile_resize(__old_size, _Base::bucket_count()); + } + private: + void _M_profile_resize(size_type __old_size, size_type __new_size) + { + if (__old_size != __new_size) + { + __profcxx_hashtable_resize(this, __old_size, __new_size); + } + } + + void _M_profile_destruct() + { + size_type __hops = 0, __lc = 0, __chain = 0; + for (iterator it = _M_base().begin(); it != _M_base().end(); it++) + { + while (it._M_cur_node->_M_next) { + __chain++; + it++; + } + if (__chain) { + __chain++; + __lc = __lc > __chain ? __lc : __chain; + __hops += __chain * (__chain - 1) / 2; + __chain = 0; + } + } + __profcxx_hashtable_destruct2(this, __lc, _Base::size(), __hops); + } + + }; + template + inline void + swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { __x.swap(__y); } + +} // namespace __profile +} // namespace std + +#undef _GLIBCXX_BASE +#undef _GLIBCXX_STD_BASE + +#endif diff --git a/libstdc++-v3/include/profile/unordered_set b/libstdc++-v3/include/profile/unordered_set new file mode 100644 index 000000000000..6c2dd77cb5fe --- /dev/null +++ b/libstdc++-v3/include/profile/unordered_set @@ -0,0 +1,480 @@ +// Profiling unordered_set/unordered_multiset implementation -*- C++ -*- + +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +/** @file profile/unordered_set + * This file is a GNU profile extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_PROFILE_UNORDERED_SET +#define _GLIBCXX_PROFILE_UNORDERED_SET 1 + +#include + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +# include +#else +# include +#endif + +#include + +#define _GLIBCXX_BASE unordered_set<_Key, _Hash, _Pred, _Alloc> +#define _GLIBCXX_STD_BASE _GLIBCXX_STD_PR::_GLIBCXX_BASE + +namespace std +{ +namespace __profile +{ + /** @brief Unordered_set wrapper with performance instrumentation. */ + template, + typename _Pred = std::equal_to<_Key>, + typename _Alloc = std::allocator<_Key> > + class unordered_set + : public _GLIBCXX_STD_BASE + { + typedef typename _GLIBCXX_STD_BASE _Base; + + public: + typedef typename _Base::size_type size_type; + typedef typename _Base::hasher hasher; + typedef typename _Base::key_equal key_equal; + typedef typename _Base::allocator_type allocator_type; + typedef typename _Base::key_type key_type; + typedef typename _Base::value_type value_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + typedef typename _Base::insert_return_type insert_return_type; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + + explicit + unordered_set(size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__n, __hf, __eql, __a) + { + __profcxx_hashtable_construct(this, _Base::bucket_count()); + __profcxx_hashtable_construct2(this); + } + + template + unordered_set(_InputIterator __f, _InputIterator __l, + size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__f, __l, __n, __hf, __eql, __a) + { + __profcxx_hashtable_construct(this, _Base::bucket_count()); + __profcxx_hashtable_construct2(this); + } + + unordered_set(const _Base& __x) + : _Base(__x) + { + __profcxx_hashtable_construct(this, _Base::bucket_count()); + __profcxx_hashtable_construct2(this); + } + + unordered_set(unordered_set&& __x) + : _Base(std::forward<_Base>(__x)) + { + __profcxx_hashtable_construct(this, _Base::bucket_count()); + __profcxx_hashtable_construct2(this); + } + + unordered_set(initializer_list __l, + size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__l, __n, __hf, __eql, __a) { } + + unordered_set& + operator=(const unordered_set& __x) + { + *static_cast<_Base*>(this) = __x; + return *this; + } + + unordered_set& + operator=(unordered_set&& __x) + { + // NB: DR 675. + this->clear(); + this->swap(__x); + return *this; + } + + unordered_set& + operator=(initializer_list __l) + { + this->clear(); + this->insert(__l); + return *this; + } + + ~unordered_set() + { + __profcxx_hashtable_destruct(this, _Base::bucket_count(), + _Base::size()); + _M_profile_destruct(); + } + + void + swap(unordered_set& __x) + { + _Base::swap(__x); + } + + void + clear() + { + __profcxx_hashtable_destruct(this, _Base::bucket_count(), + _Base::size()); + _M_profile_destruct(); + _Base::clear(); + } + void + insert(std::initializer_list __l) + { + size_type __old_size = _Base::bucket_count(); + _Base::insert(__l); + _M_profile_resize(__old_size, _Base::bucket_count()); + } + insert_return_type insert(const value_type& __obj) + { + size_type __old_size = _Base::bucket_count(); + insert_return_type __res = _Base::insert(__obj); + _M_profile_resize(__old_size, _Base::bucket_count()); + return __res; + } + iterator + insert(iterator __iter, const value_type& __v) + { + size_type __old_size = _Base::bucket_count(); + iterator res = _Base::insert(__iter, __v); + _M_profile_resize(__old_size, _Base::bucket_count()); + return res; + } + + const_iterator + insert(const_iterator __iter, const value_type& __v) + { + size_type __old_size = _Base::bucket_count(); + const_iterator res =_Base::insert(__iter, __v); + _M_profile_resize(__old_size, _Base::bucket_count()); + return res; + } + + template + void + insert(_InputIter __first, _InputIter __last) + { + size_type __old_size = _Base::bucket_count(); + _Base::insert(__first, __last); + _M_profile_resize(__old_size, _Base::bucket_count()); + } + + void + insert(const value_type* __first, const value_type* __last) + { + size_type __old_size = _Base::bucket_count(); + _Base::insert(__first, __last); + _M_profile_resize(__old_size, _Base::bucket_count()); + } + + void rehash(size_type __n) + { + size_type __old_size = _Base::bucket_count(); + _Base::rehash(__n); + _M_profile_resize(__old_size, _Base::bucket_count()); + } + private: + _Base& + _M_base() { return *this; } + + const _Base& + _M_base() const { return *this; } + + void _M_profile_resize(size_type __old_size, size_type __new_size) + { + if (__old_size != __new_size) + { + __profcxx_hashtable_resize(this, __old_size, __new_size); + } + } + void _M_profile_destruct() + { + size_type __hops = 0, __lc = 0, __chain = 0; + for (iterator it = _M_base().begin(); it != _M_base().end(); it++) + { + while (it._M_cur_node->_M_next) { + __chain++; + it++; + } + if (__chain) { + __chain++; + __lc = __lc > __chain ? __lc : __chain; + __hops += __chain * (__chain - 1) / 2; + __chain = 0; + } + } + __profcxx_hashtable_destruct2(this, __lc, _Base::size(), __hops); + } + + }; + template + inline void + swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, + unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) + { __x.swap(__y); } + +#undef _GLIBCXX_BASE +#undef _GLIBCXX_STD_BASE +#define _GLIBCXX_STD_BASE _GLIBCXX_STD_PR::_GLIBCXX_BASE +#define _GLIBCXX_BASE unordered_multiset<_Value, _Hash, _Pred, _Alloc> + + /** @brief Unordered_multiset wrapper with performance instrumentation. */ + template, + typename _Pred = std::equal_to<_Value>, + typename _Alloc = std::allocator<_Value> > + class unordered_multiset + : public _GLIBCXX_STD_BASE + { + typedef typename _GLIBCXX_STD_BASE _Base; + + public: + typedef typename _Base::size_type size_type; + typedef typename _Base::hasher hasher; + typedef typename _Base::key_equal key_equal; + typedef typename _Base::allocator_type allocator_type; + typedef typename _Base::key_type key_type; + typedef typename _Base::value_type value_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + typedef typename _Base::insert_return_type insert_return_type; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + + explicit + unordered_multiset(size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__n, __hf, __eql, __a) + { + __profcxx_hashtable_construct(this, _Base::bucket_count()); + } + + template + unordered_multiset(_InputIterator __f, _InputIterator __l, + size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__f, __l, __n, __hf, __eql, __a) + { + __profcxx_hashtable_construct(this, _Base::bucket_count()); + } + + unordered_multiset(const _Base& __x) + : _Base(__x) + { + __profcxx_hashtable_construct(this, _Base::bucket_count()); + } + + unordered_multiset(unordered_multiset&& __x) + : _Base(std::forward<_Base>(__x)) + { + __profcxx_hashtable_construct(this, _Base::bucket_count()); + } + + unordered_multiset(initializer_list __l, + size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__l, __n, __hf, __eql, __a) { } + + unordered_multiset& + operator=(const unordered_multiset& __x) + { + *static_cast<_Base*>(this) = __x; + return *this; + } + + unordered_multiset& + operator=(unordered_multiset&& __x) + { + // NB: DR 675. + this->clear(); + this->swap(__x); + return *this; + } + + unordered_multiset& + operator=(initializer_list __l) + { + this->clear(); + this->insert(__l); + return *this; + } + + ~unordered_multiset() + { + __profcxx_hashtable_destruct(this, _Base::bucket_count(), + _Base::size()); + _M_profile_destruct(); + } + + void + swap(unordered_multiset& __x) + { + _Base::swap(__x); + } + + void + clear() + { + __profcxx_hashtable_destruct(this, _Base::bucket_count(), + _Base::size()); + _M_profile_destruct(); + _Base::clear(); + } + void + insert(std::initializer_list __l) + { + size_type __old_size = _Base::bucket_count(); + _Base::insert(__l); + _M_profile_resize(__old_size, _Base::bucket_count()); + } + insert_return_type insert(const value_type& __obj) + { + size_type __old_size = _Base::bucket_count(); + insert_return_type __res = _Base::insert(__obj); + _M_profile_resize(__old_size, _Base::bucket_count()); + return __res; + } + iterator + insert(iterator __iter, const value_type& __v) + { + size_type __old_size = _Base::bucket_count(); + iterator res = _Base::insert(__iter, __v); + _M_profile_resize(__old_size, _Base::bucket_count()); + return res; + } + + const_iterator + insert(const_iterator __iter, const value_type& __v) + { + size_type __old_size = _Base::bucket_count(); + const_iterator res =_Base::insert(__iter, __v); + _M_profile_resize(__old_size, _Base::bucket_count()); + return res; + } + + template + void + insert(_InputIter __first, _InputIter __last) + { + size_type __old_size = _Base::bucket_count(); + _Base::insert(__first, __last); + _M_profile_resize(__old_size, _Base::bucket_count()); + } + + void + insert(const value_type* __first, const value_type* __last) + { + size_type __old_size = _Base::bucket_count(); + _Base::insert(__first, __last); + _M_profile_resize(__old_size, _Base::bucket_count()); + } + + void rehash(size_type __n) + { + size_type __old_size = _Base::bucket_count(); + _Base::rehash(__n); + _M_profile_resize(__old_size, _Base::bucket_count()); + } + private: + _Base& + _M_base() { return *this; } + + const _Base& + _M_base() const { return *this; } + + void _M_profile_resize(size_type __old_size, size_type __new_size) + { + if (__old_size != __new_size) + { + __profcxx_hashtable_resize(this, __old_size, __new_size); + } + } + + void _M_profile_destruct() + { + size_type __hops = 0, __lc = 0, __chain = 0; + for (iterator it = _M_base().begin(); it != _M_base().end(); it++) + { + while (it._M_cur_node->_M_next) { + __chain++; + it++; + } + if (__chain) { + __chain++; + __lc = __lc > __chain ? __lc : __chain; + __hops += __chain * (__chain - 1) / 2; + __chain = 0; + } + } + __profcxx_hashtable_destruct2(this, __lc, _Base::size(), __hops); + } + + }; + template + inline void + swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, + unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) + { __x.swap(__y); } + +} // namespace __profile +} // namespace std + +#undef _GLIBCXX_BASE +#undef _GLIBCXX_STD_BASE + +#endif diff --git a/libstdc++-v3/include/profile/vector b/libstdc++-v3/include/profile/vector new file mode 100644 index 000000000000..e6aeb686a7a1 --- /dev/null +++ b/libstdc++-v3/include/profile/vector @@ -0,0 +1,369 @@ +// Profiling vector implementation -*- C++ -*- + +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +/** @file profile/vector + * This file is a GNU profile extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_PROFILE_VECTOR +#define _GLIBCXX_PROFILE_VECTOR 1 + +#include +#include +#include + +namespace std +{ +namespace __profile +{ + /** @brief Vector wrapper with performance instrumentation. */ + template > + class vector + : public _GLIBCXX_STD_PR::vector<_Tp, _Allocator> + { + typedef _GLIBCXX_STD_PR::vector<_Tp, _Allocator> _Base; + + public: + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + + typedef _Tp value_type; + typedef _Allocator allocator_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + + _Base& + _M_base() { return *this; } + + const _Base& + _M_base() const { return *this; } + + // 23.2.4.1 construct/copy/destroy: + explicit vector(const _Allocator& __a = _Allocator()) + : _Base(__a) + { + __profcxx_vector_construct(this, this->capacity()); + __profcxx_vector_construct2(this); + } + + explicit vector(size_type __n, const _Tp& __value = _Tp(), + const _Allocator& __a = _Allocator()) + : _Base(__n, __value, __a) + { + __profcxx_vector_construct(this, this->capacity()); + __profcxx_vector_construct2(this); + } + + template + vector(_InputIterator __first, _InputIterator __last, + const _Allocator& __a = _Allocator()) + : _Base(__first, __last, __a) + { + __profcxx_vector_construct(this, this->capacity()); + __profcxx_vector_construct2(this); + } + + vector(const vector& __x) + : _Base(__x) + { + __profcxx_vector_construct(this, this->capacity()); + __profcxx_vector_construct2(this); + } + + /// Construction from a release-mode vector + vector(const _Base& __x) + : _Base(__x) + { + __profcxx_vector_construct(this, this->capacity()); + __profcxx_vector_construct2(this); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + vector(vector&& __x) + : _Base(std::forward(__x)) + { + __profcxx_vector_construct(this, this->capacity()); + __profcxx_vector_construct2(this); + } + + vector(initializer_list __l, + const allocator_type& __a = allocator_type()) + : _Base(__l, __a) { } +#endif + + ~vector() { + __profcxx_vector_destruct(this, this->capacity(), this->size()); + __profcxx_vector_destruct2(this); + } + + vector& + operator=(const vector& __x) + { + static_cast<_Base&>(*this) = __x; + return *this; + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + vector& + operator=(vector&& __x) + { + // NB: DR 675. + this->clear(); + this->swap(__x); + return *this; + } + + vector& + operator=(initializer_list __l) + { + static_cast<_Base&>(*this) = __l; + return *this; + } +#endif + + using _Base::assign; + using _Base::get_allocator; + + // 23.2.4.2 capacity: + using _Base::size; + using _Base::max_size; + + void + resize(size_type __sz, _Tp __c = _Tp()) + { + __profcxx_vector_invalid_operator(this); + _M_profile_resize(this, this->capacity(), __sz); + _Base::resize(__sz, __c); + } + + using _Base::empty; + + // element access: + reference + operator[](size_type __n) + { + __profcxx_vector_invalid_operator(this); + return _M_base()[__n]; + } + const_reference + operator[](size_type __n) const + { + __profcxx_vector_invalid_operator(this); + return _M_base()[__n]; + } + + using _Base::at; + + reference + front() + { + return _Base::front(); + } + + const_reference + front() const + { + return _Base::front(); + } + + reference + back() + { + return _Base::back(); + } + + const_reference + back() const + { + return _Base::back(); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 464. Suggestion for new member functions in standard containers. + using _Base::data; + + // 23.2.4.3 modifiers: + void + push_back(const _Tp& __x) + { + size_type __old_size = this->capacity(); + _Base::push_back(__x); + _M_profile_resize(this, __old_size, this->capacity()); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + void + push_back(_Tp&& __x) + { + size_type __old_size = this->capacity(); + _Base::push_back(__x); + _M_profile_resize(this, __old_size, this->capacity()); + } + +#endif + + iterator + insert(iterator __position, const _Tp& __x) + { + __profcxx_vector_insert(this, __position-_Base::begin(), this->size()); + size_type __old_size = this->capacity(); + typename _Base::iterator __res = _Base::insert(__position,__x); + _M_profile_resize(this, __old_size, this->capacity()); + return __res; + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + iterator + insert(iterator __position, _Tp&& __x) + { + __profcxx_vector_insert(this, __position-_Base::begin(), this->size()); + size_type __old_size = this->capacity(); + typename _Base::iterator __res = _Base::insert(__position,__x); + _M_profile_resize(this, __old_size, this->capacity()); + return __res; + } + + void + insert(iterator __position, initializer_list __l) + { this->insert(__position, __l.begin(), __l.end()); } +#endif + + void + + swap(vector& __x) + { + _Base::swap(__x); + } + + + void + insert(iterator __position, size_type __n, const _Tp& __x) + { + __profcxx_vector_insert(this, __position-_Base::begin(), this->size()); + size_type __old_size = this->capacity(); + _Base::insert(__position, __n, __x); + _M_profile_resize(this, __old_size, this->capacity()); + } + + template + void + insert(iterator __position, + _InputIterator __first, _InputIterator __last) + { + __profcxx_vector_insert(this, __position-_Base::begin(), this->size()); + size_type __old_size = this->capacity(); + _Base::insert(__position, __first, __last); + _M_profile_resize(this, __old_size, this->capacity()); + } + + void + clear() + { + __profcxx_vector_destruct(this, this->capacity(), this->size()); + __profcxx_vector_destruct2(this); + _Base::clear(); + } + + // iterators: + iterator + begin() + { + return _Base::begin(); + } + + const_iterator + begin() const + { + return _Base::begin(); + } + + private: + void _M_profile_resize(void* obj, size_type __old_size, + size_type __new_size) + { + if (__old_size < __new_size) { + __profcxx_vector_resize(this, this->size(), __new_size); + __profcxx_vector_resize2(this, this->size(), __new_size); + } + } + }; + + template + inline bool + operator==(const vector<_Tp, _Alloc>& __lhs, + const vector<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() == __rhs._M_base(); } + + template + inline bool + operator!=(const vector<_Tp, _Alloc>& __lhs, + const vector<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() != __rhs._M_base(); } + + template + inline bool + operator<(const vector<_Tp, _Alloc>& __lhs, + const vector<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() < __rhs._M_base(); } + + template + inline bool + operator<=(const vector<_Tp, _Alloc>& __lhs, + const vector<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() <= __rhs._M_base(); } + + template + inline bool + operator>=(const vector<_Tp, _Alloc>& __lhs, + const vector<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() >= __rhs._M_base(); } + + template + inline bool + operator>(const vector<_Tp, _Alloc>& __lhs, + const vector<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() > __rhs._M_base(); } + + template + inline void + swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>& __rhs) + { __lhs.swap(__rhs); } + +} // namespace __profile + using _GLIBCXX_STD_D::_S_word_bit; +} // namespace std + +#endif diff --git a/libstdc++-v3/include/std/bitset b/libstdc++-v3/include/std/bitset index 5ca442989aa5..131fe56de2da 100644 --- a/libstdc++-v3/include/std/bitset +++ b/libstdc++-v3/include/std/bitset @@ -1393,4 +1393,8 @@ _GLIBCXX_END_NESTED_NAMESPACE # include #endif +#ifdef _GLIBCXX_PROFILE +# include +#endif + #endif /* _GLIBCXX_BITSET */ diff --git a/libstdc++-v3/include/std/deque b/libstdc++-v3/include/std/deque index 8f64b005ccf2..f8a55f721652 100644 --- a/libstdc++-v3/include/std/deque +++ b/libstdc++-v3/include/std/deque @@ -72,4 +72,8 @@ # include #endif +#ifdef _GLIBCXX_PROFILE +# include +#endif + #endif /* _GLIBCXX_DEQUE */ diff --git a/libstdc++-v3/include/std/list b/libstdc++-v3/include/std/list index d199802d736c..fcf164b4bd56 100644 --- a/libstdc++-v3/include/std/list +++ b/libstdc++-v3/include/std/list @@ -70,5 +70,9 @@ # include #endif +#ifdef _GLIBCXX_PROFILE +# include +#endif + #endif /* _GLIBCXX_LIST */ diff --git a/libstdc++-v3/include/std/map b/libstdc++-v3/include/std/map index 159bfb3d040f..25f86df69767 100644 --- a/libstdc++-v3/include/std/map +++ b/libstdc++-v3/include/std/map @@ -65,4 +65,8 @@ # include #endif +#ifdef _GLIBCXX_PROFILE +# include +#endif + #endif /* _GLIBCXX_MAP */ diff --git a/libstdc++-v3/include/std/set b/libstdc++-v3/include/std/set index 21e3f5a8a1ef..0b7805cabece 100644 --- a/libstdc++-v3/include/std/set +++ b/libstdc++-v3/include/std/set @@ -65,4 +65,8 @@ # include #endif +#ifdef _GLIBCXX_PROFILE +# include +#endif + #endif /* _GLIBCXX_SET */ diff --git a/libstdc++-v3/include/std/unordered_map b/libstdc++-v3/include/std/unordered_map index 56906d28b5f4..f8cd5459787e 100644 --- a/libstdc++-v3/include/std/unordered_map +++ b/libstdc++-v3/include/std/unordered_map @@ -53,7 +53,7 @@ # include #else # define _GLIBCXX_INCLUDE_AS_CXX0X -#if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL) +#if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL) || defined(_GLIBCXX_PROFILE) # define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace _GLIBCXX_STD_D { # define _GLIBCXX_END_NAMESPACE_TR1 } # define _GLIBCXX_TR1 _GLIBCXX_STD_D @@ -73,6 +73,10 @@ # include #endif +#ifdef _GLIBCXX_PROFILE +# include +#endif + #endif // __GXX_EXPERIMENTAL_CXX0X__ #endif // _GLIBCXX_UNORDERED_MAP diff --git a/libstdc++-v3/include/std/unordered_set b/libstdc++-v3/include/std/unordered_set index 880f3bef4ec6..b5b4f1089808 100644 --- a/libstdc++-v3/include/std/unordered_set +++ b/libstdc++-v3/include/std/unordered_set @@ -53,7 +53,7 @@ # include #else # define _GLIBCXX_INCLUDE_AS_CXX0X -#if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL) +#if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL) || defined(_GLIBCXX_PROFILE) # define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace _GLIBCXX_STD_D { # define _GLIBCXX_END_NAMESPACE_TR1 } # define _GLIBCXX_TR1 _GLIBCXX_STD_D @@ -73,6 +73,9 @@ # include #endif +#ifdef _GLIBCXX_PROFILE +# include +#endif #endif // __GXX_EXPERIMENTAL_CXX0X__ #endif // _GLIBCXX_UNORDERED_SET diff --git a/libstdc++-v3/include/std/vector b/libstdc++-v3/include/std/vector index 114665b6c964..41ecdde6c7be 100644 --- a/libstdc++-v3/include/std/vector +++ b/libstdc++-v3/include/std/vector @@ -34,7 +34,7 @@ * that both that copyright notice and this permission notice appear * in supporting documentation. Hewlett-Packard Company makes no * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. + ded "as is" without express or implied warranty. * * * Copyright (c) 1996 @@ -73,5 +73,9 @@ # include #endif +#ifdef _GLIBCXX_PROFILE +# include +#endif + #endif /* _GLIBCXX_VECTOR */ diff --git a/libstdc++-v3/include/tr1_impl/hashtable b/libstdc++-v3/include/tr1_impl/hashtable index bce550ff1f14..c47769823348 100644 --- a/libstdc++-v3/include/tr1_impl/hashtable +++ b/libstdc++-v3/include/tr1_impl/hashtable @@ -409,6 +409,9 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1 _M_erase_node(_Node*, _Node**); public: + // Expose insert_return_type for profiling mode. + typedef _Insert_Return_Type insert_return_type; + // Insert and erase _Insert_Return_Type insert(const value_type& __v) diff --git a/libstdc++-v3/testsuite/23_containers/deque/capacity/moveable.cc b/libstdc++-v3/testsuite/23_containers/deque/capacity/moveable.cc index 88ea5098f8e4..089b10b83a61 100644 --- a/libstdc++-v3/testsuite/23_containers/deque/capacity/moveable.cc +++ b/libstdc++-v3/testsuite/23_containers/deque/capacity/moveable.cc @@ -38,26 +38,26 @@ test01() a.resize(98); a.resize(99); a.resize(100); -#ifndef _GLIBCXX_DEBUG +#if ! defined _GLIBCXX_DEBUG && ! defined _GLIBCXX_PROFILE VERIFY( copycounter::copycount == 100 ); #else VERIFY( copycounter::copycount == 100 + 4 ); #endif a.resize(99); a.resize(0); -#ifndef _GLIBCXX_DEBUG +#if ! defined _GLIBCXX_DEBUG && ! defined _GLIBCXX_PROFILE VERIFY( copycounter::copycount == 100 ); #else VERIFY( copycounter::copycount == 100 + 6 ); #endif a.resize(100); -#ifndef _GLIBCXX_DEBUG +#if ! defined _GLIBCXX_DEBUG && ! defined _GLIBCXX_PROFILE VERIFY( copycounter::copycount == 200 ); #else VERIFY( copycounter::copycount == 200 + 7 ); #endif a.clear(); -#ifndef _GLIBCXX_DEBUG +#if ! defined _GLIBCXX_DEBUG && ! defined _GLIBCXX_PROFILE VERIFY( copycounter::copycount == 200 ); #else VERIFY( copycounter::copycount == 200 + 7 ); diff --git a/libstdc++-v3/testsuite/23_containers/list/capacity/29134.cc b/libstdc++-v3/testsuite/23_containers/list/capacity/29134.cc index 48394079750f..d51fc3bb6628 100644 --- a/libstdc++-v3/testsuite/23_containers/list/capacity/29134.cc +++ b/libstdc++-v3/testsuite/23_containers/list/capacity/29134.cc @@ -28,7 +28,7 @@ void test01() typedef std::list list_type; list_type l; -#ifndef _GLIBCXX_DEBUG +#if ! defined _GLIBCXX_DEBUG && ! defined _GLIBCXX_PROFILE using std::_List_node; #else using std::_GLIBCXX_STD_D::_List_node; diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/profile/hash_map.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/profile/hash_map.cc new file mode 100644 index 000000000000..7939a35e3ef1 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_map/profile/hash_map.cc @@ -0,0 +1,22 @@ +// { dg-options "-Wno-deprecated" } +/* testing the gcc instrumented */ + +#include +using namespace std; +using __gnu_cxx::hash_map; + +int main() +{ + hash_map *tmp; + + for (int j=1; j<=10; j++) + { + tmp = new hash_map; + // Insert more than default item + for (int i=0; i<10000*j; i++) { + (*tmp)[i]= i; + } + delete tmp; + } +} + diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/profile/unordered.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/profile/unordered.cc new file mode 100644 index 000000000000..93b506e9832e --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_map/profile/unordered.cc @@ -0,0 +1,47 @@ +// { dg-options "-std=gnu++0x" } +/* testing the gcc instrumented */ + +#include +#include +using std::unordered_map; +using std::unordered_set; + +void test_unordered_set() +{ + // Test for unordered set + unordered_set *tmp2; + tmp2 = new unordered_set; + tmp2->insert(1); + delete tmp2; +} +void test_unordered_map() +{ + unordered_map *tmp; + for (int i=0; i<20; i++) + { + tmp = new unordered_map(i+2); + // Insert more than default item + for (int j=0; j<10000; j++) { + (*tmp)[j]= j; + } + + delete tmp; + } + + tmp = new unordered_map; + + // Insert more than default item + for (int i=0; i<150000; i++) { +// (*tmp)[i] = i; + (*tmp).insert(unordered_map::value_type(i, i)); + } + + (*tmp).erase(1); + delete tmp; +} +int main() +{ + test_unordered_set(); + test_unordered_map(); +} + diff --git a/libstdc++-v3/testsuite/23_containers/vector/profile/vector.cc b/libstdc++-v3/testsuite/23_containers/vector/profile/vector.cc new file mode 100644 index 000000000000..1e9d01afec59 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/vector/profile/vector.cc @@ -0,0 +1,18 @@ +// Test vector: performance difference 25% (0.444s vs 0.539s) +// Advice: set tmp as 10000 + +#include + +using std::vector; + +int main() +{ + vector tmp; + + for (int j=0; j<2000; j++) + // Insert more than default item + for (int i=0; i<10000; i++) { + tmp.push_back(i); + } +} + diff --git a/libstdc++-v3/testsuite/23_containers/vector/resize/moveable.cc b/libstdc++-v3/testsuite/23_containers/vector/resize/moveable.cc index 407f6ed390bb..47fdf8fcafa8 100644 --- a/libstdc++-v3/testsuite/23_containers/vector/resize/moveable.cc +++ b/libstdc++-v3/testsuite/23_containers/vector/resize/moveable.cc @@ -41,26 +41,26 @@ test01() a.resize(98); a.resize(99); a.resize(100); -#ifndef _GLIBCXX_DEBUG +#if !defined(_GLIBCXX_DEBUG) && !defined(_GLIBCXX_PROFILE) VERIFY( copycounter::copycount == 100 + 1 ); #else VERIFY( copycounter::copycount == 100 + 1 + 4 ); #endif a.resize(99); a.resize(0); -#ifndef _GLIBCXX_DEBUG +#if !defined(_GLIBCXX_DEBUG) && !defined(_GLIBCXX_PROFILE) VERIFY( copycounter::copycount == 100 + 1 ); #else VERIFY( copycounter::copycount == 100 + 1 + 6 ); #endif a.resize(100); -#ifndef _GLIBCXX_DEBUG +#if !defined(_GLIBCXX_DEBUG) && !defined(_GLIBCXX_PROFILE) VERIFY( copycounter::copycount == 200 + 2 ); #else VERIFY( copycounter::copycount == 200 + 2 + 7 ); #endif a.clear(); -#ifndef _GLIBCXX_DEBUG +#if !defined(_GLIBCXX_DEBUG) && !defined(_GLIBCXX_PROFILE) VERIFY( copycounter::copycount == 200 + 2 ); #else VERIFY( copycounter::copycount == 200 + 2 + 7 ); diff --git a/libstdc++-v3/testsuite/Makefile.am b/libstdc++-v3/testsuite/Makefile.am index 73c913b869a9..c8176072326f 100644 --- a/libstdc++-v3/testsuite/Makefile.am +++ b/libstdc++-v3/testsuite/Makefile.am @@ -196,6 +196,9 @@ libgomp_flags=-B${glibcxx_builddir}/../libgomp \ atomic_flags=$(ATOMIC_FLAGS) parallel_flags="unix/-D_GLIBCXX_PARALLEL/-fopenmp" +# Runs the testsuite in profile mode. +profile_flags = "unix/-D_GLIBCXX_PROFILE" + check-parallel: site.exp -@(if test ! -d $${libgomp_dir}; then \ echo "Testing parallel mode failed as libgomp not present."; \ @@ -214,8 +217,17 @@ check-performance-parallel: testsuite_files_performance ${performance_script} CXXFLAGS="-D_GLIBCXX_PARALLEL -fopenmp $(atomic_flags) $(libgomp_flags)"; export CXXFLAGS; \ ${check_performance_script} ${glibcxx_srcdir} ${glibcxx_builddir}) +check-profile: site.exp + -@(outputdir=profile; export outputdir; \ + if test ! -d $${outputdir}; then \ + mkdir $${outputdir}; \ + fi; \ + srcdir=`$(am__cd) $(srcdir) && pwd`; export srcdir; \ + EXPECT=$(EXPECT); export EXPECT; \ + $(MAKE) CXXFLAGS="$(atomic_flags) " RUNTESTFLAGS="$(RUNTESTFLAGS) conformance.exp --outdir $${outputdir} --objdir $${outputdir} --target_board=$(profile_flags)" check-DEJAGNU; ) + .PHONY: baseline_symbols new-abi-baseline \ - check-abi check-compile check-performance check-parallel + check-abi check-compile check-performance check-parallel check-profile # By adding these files here, automake will remove them for 'make clean' CLEANFILES = *.txt *.tst *.exe core* filebuf_* tmp* ostream_* *.log *.sum \ @@ -224,4 +236,4 @@ CLEANFILES = *.txt *.tst *.exe core* filebuf_* tmp* ostream_* *.log *.sum \ # To remove directories. clean-local: - rm -rf parallel + rm -rf parallel profile diff --git a/libstdc++-v3/testsuite/Makefile.in b/libstdc++-v3/testsuite/Makefile.in index 6ee34ae94003..da2a59ad8bca 100644 --- a/libstdc++-v3/testsuite/Makefile.in +++ b/libstdc++-v3/testsuite/Makefile.in @@ -299,6 +299,9 @@ libgomp_flags = -B${glibcxx_builddir}/../libgomp \ atomic_flags = $(ATOMIC_FLAGS) parallel_flags = "unix/-D_GLIBCXX_PARALLEL/-fopenmp" +# Runs the testsuite in profile +profile_flags = "unix/-D_GLIBCXX_PROFILE" + # By adding these files here, automake will remove them for 'make clean' CLEANFILES = *.txt *.tst *.exe core* filebuf_* tmp* ostream_* *.log *.sum \ testsuite_* site.exp abi_check baseline_symbols *TEST* *.dat \ @@ -642,12 +645,21 @@ check-performance-parallel: testsuite_files_performance ${performance_script} CXXFLAGS="-D_GLIBCXX_PARALLEL -fopenmp $(atomic_flags) $(libgomp_flags)"; export CXXFLAGS; \ ${check_performance_script} ${glibcxx_srcdir} ${glibcxx_builddir}) +check-profile: site.exp + -@(outputdir=profile; export outputdir; \ + if test ! -d $${outputdir}; then \ + mkdir $${outputdir}; \ + fi; \ + srcdir=`$(am__cd) $(srcdir) && pwd`; export srcdir; \ + EXPECT=$(EXPECT); export EXPECT; \ + $(MAKE) CXXFLAGS="$(atomic_flags)" RUNTESTFLAGS="$(RUNTESTFLAGS) conformance.exp --outdir $${outputdir} --objdir $${outputdir} --target_board=$(profile_flags)" check-DEJAGNU; ) + .PHONY: baseline_symbols new-abi-baseline \ - check-abi check-compile check-performance check-parallel + check-abi check-compile check-performance check-parallel check-profile # To remove directories. clean-local: - rm -rf parallel + rm -rf parallel profile # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. diff --git a/libstdc++-v3/testsuite/ext/profile/all.cc b/libstdc++-v3/testsuite/ext/profile/all.cc new file mode 100644 index 000000000000..0a1f97962085 --- /dev/null +++ b/libstdc++-v3/testsuite/ext/profile/all.cc @@ -0,0 +1,50 @@ +// { dg-options "-std=gnu++0x -O0 -D_GLIBCXX_PROFILE" } +// { dg-do compile } + +// -*- C++ -*- + +// Copyright (C) 2006, 2007, 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include +#include +#include + +using std::map; +using std::vector; +using std::unordered_map; + +struct dumb_hash { + size_t operator()(int x) const {return 0;} + size_t operator()(int x, int y) const {return x == y;} +}; + +int main() { + map m_to_umap; + vector v_to_list; + unordered_map um_too_small; + unordered_map um_too_large(1000000); + unordered_map um_dumb_hash; + + for (int i = 0; i < 10000; ++i) { + m_to_umap[i] = i; + v_to_list.insert(v_to_list.begin(), i); + um_too_small[i] = i; + um_too_small[i] = i; + um_dumb_hash[i] = i; + } +} diff --git a/libstdc++-v3/testsuite/ext/profile/mh.cc b/libstdc++-v3/testsuite/ext/profile/mh.cc new file mode 100644 index 000000000000..dc9109498678 --- /dev/null +++ b/libstdc++-v3/testsuite/ext/profile/mh.cc @@ -0,0 +1,65 @@ +// -*- C++ -*- + +// Copyright (C) 2006, 2007, 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +// { dg-options "-D_GLIBCXX_PROFILE" } +// { dg-do compile } + +#include +#include +#include + +using std::vector; + +static void my_init_hook (void); +static void *my_malloc_hook (size_t, const void *); +typedef void* (*malloc_hook) (size_t, const void *); + +malloc_hook old_malloc_hook; + +void (*__malloc_initialize_hook) (void) = my_init_hook; + +static void +my_init_hook (void) +{ + old_malloc_hook = __malloc_hook; + __malloc_hook = my_malloc_hook; +} + +static void * +my_malloc_hook (size_t size, const void *caller) +{ + void *result; + __malloc_hook = old_malloc_hook; + result = malloc (size); + old_malloc_hook = __malloc_hook; + + // With _GLIBCXX_PROFILE, the instrumentation of the vector constructor + // will call back into malloc. + vector v; + + __malloc_hook = my_malloc_hook; + return result; +} + + +int main() { + int* test = (int*) malloc(sizeof(int)); + *test = 1; + return *test; +} diff --git a/libstdc++-v3/testsuite/ext/profile/mutex_extensions.cc b/libstdc++-v3/testsuite/ext/profile/mutex_extensions.cc new file mode 100644 index 000000000000..c8bcf720e1d6 --- /dev/null +++ b/libstdc++-v3/testsuite/ext/profile/mutex_extensions.cc @@ -0,0 +1,26 @@ +// { dg-options "-D_GLIBCXX_DEBUG -D_GLIBCXX_PROFILE" } +// { dg-do compile } + +// -*- C++ -*- + +// Copyright (C) 2006, 2007, 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include + +// { dg-error "Cannot use -D_GLIBCXX_PROFILE with " "" { target *-*-* } 166 } +// { dg-excess-errors "In file included from" }