fix hash_* visualizer issue by fsb4000 · Pull Request #2784 · microsoft/STL

fsb4000 · 2022-06-12T09:37:49Z

test:

#define _SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS
#include <hash_set>
#include <hash_map>
using namespace std;
int main() {
	stdext::hash_set<int> hs = { 1,2,3 };
	stdext::hash_multiset<int> hms = { 1,1,2,3 };
	stdext::hash_map<int, char> hm = { {1, 'a'}, {2,'b'} };
	stdext::hash_multimap<int, char> hmm = { {1, 'a'}, {1, 'c'}, {2,'b'} };
}

_Traitsobj class:

STL/stl/inc/hash_map

Lines 41 to 110 in e178ea2

    
               class _Hmap_traits : public _Tr { // traits required to make _Hash behave like a map
 
               public:
 
                   using key_type            = _Kty;
 
                   using value_type          = pair<const _Kty, _Ty>;
 
                   using _Mutable_value_type = pair<_Kty, _Ty>;
 
                   using key_compare         = _Tr;
 
                   using allocator_type      = _Alloc;
 
           #if _HAS_CXX17
 
                   using node_type =
 
                       _STD _Node_handle<_STD _List_node<value_type, typename _STD allocator_traits<_Alloc>::void_pointer>, _Alloc,
 
                           _STD _Node_handle_map_base, _Kty, _Ty>;
 
           #endif // _HAS_CXX17
 
                   static constexpr bool _Multi    = _Mfl;
 
                   static constexpr bool _Standard = false;
 
                   template <class... _Args>
 
                   using _In_place_key_extractor = _STD _In_place_key_extract_map<_Kty, _Args...>;
 
                   template <class>
 
                   using _Deduce_key = const _Kty&;
 
                   using key_equal   = _Tr;
 
                   _Hmap_traits() = default;
 
                   _Hmap_traits(const _Tr& _Traits) noexcept(_STD is_nothrow_copy_constructible_v<_Tr>) : _Tr(_Traits) {}
 
                   class value_compare {
 
                   public:
 
                       using first_argument_type  = value_type;
 
                       using second_argument_type = value_type;
 
                       using result_type          = bool;
 
                       _NODISCARD bool operator()(const value_type& _Left, const value_type& _Right) const
 
                           noexcept(noexcept(_Keycompobj(_Left.first, _Right.first))) {
 
                           // test if _Left precedes _Right by comparing just keys
 
                           return _Keycompobj(_Left.first, _Right.first);
 
                       }
 
                       value_compare(const key_compare& _Keycomparg) noexcept(_STD is_nothrow_copy_constructible_v<key_compare>)
 
                           : _Keycompobj(_Keycomparg) {}
 
                       key_compare _Keycompobj;
 
                   };
 
                   template <class _Ty1, class _Ty2>
 
                   _NODISCARD static const _Kty& _Kfn(const pair<_Ty1, _Ty2>& _Val) noexcept { // extract key from element value
 
                       return _Val.first;
 
                   }
 
                   template <class _Ty1, class _Ty2>
 
                   _NODISCARD static const _Ty2& _Nonkfn(const pair<_Ty1, _Ty2>& _Val) noexcept {
 
                       // extract non-key from element value
 
                       return _Val.second;
 
                   }
 
                   _NODISCARD float& _Get_max_bucket_size() noexcept {
 
                       return _Max_buckets;
 
                   }
 
                   _NODISCARD const float& _Get_max_bucket_size() const noexcept {
 
                       return _Max_buckets;
 
                   }
 
                   void swap(_Hmap_traits& _Rhs) noexcept(_Is_nothrow_swappable<_Tr>::value) {
 
                       _Swap_adl(static_cast<_Tr&>(*this), static_cast<_Tr&>(_Rhs));
 
                       _STD swap(_Max_buckets, _Rhs._Max_buckets);
 
                   }
 
                   float _Max_buckets = 0.0F; // current maximum bucket size
 
               };

_Tr class:

STL/stl/inc/xhash

Lines 59 to 87 in 37b5120

    
           class hash_compare { // traits class for hash containers
 
           public:
 
               enum { // parameters for hash table
 
                   bucket_size = 1 // 0 < bucket_size
 
               };
 
               hash_compare() = default;
 
               hash_compare(const _Pr& _Pred) noexcept(_STD is_nothrow_copy_constructible_v<_Pr>) : comp(_Pred) {}
 
               _NODISCARD size_t operator()(const _Kty& _Keyval) const noexcept(noexcept(hash_value(_Keyval))) {
 
                   long _Quot   = static_cast<long>(hash_value(_Keyval) & LONG_MAX); // TRANSITION, ADL?
 
                   ldiv_t _Qrem = _CSTD ldiv(_Quot, 127773);
 
                   _Qrem.rem = 16807 * _Qrem.rem - 2836 * _Qrem.quot;
 
                   if (_Qrem.rem < 0) {
 
                       _Qrem.rem += LONG_MAX;
 
                   }
 
                   return static_cast<size_t>(_Qrem.rem);
 
               }
 
               _NODISCARD bool operator()(const _Kty& _Keyval1, const _Kty& _Keyval2) const
 
                   noexcept(noexcept(comp(_Keyval1, _Keyval2))) {
 
                   // test if _Keyval1 ordered before _Keyval2
 
                   return comp(_Keyval1, _Keyval2);
 
               }
 
               _Pr comp{}; // the comparator object
 
           };

So we don't visualize [hash_function] and [key_eq], we could visualize [comp] but it doesn't seem useful...

StephanTLavavej · 2022-06-13T01:28:44Z

stl/debugger/STL.natvis

+      <AlternativeType Name="stdext::hash_set&lt;*&gt;" />
+      <AlternativeType Name="stdext::hash_multiset&lt;*&gt;" />
+      <DisplayString>{_List}</DisplayString>
+      <Expand>


No change requested: In theory, comp could be a function pointer worth visualizing. However, it seems likely that it would have to be paired with an ADL-customized hash_value and that seems quite rare (given the poorly-documented nature of this non-Standard extension). I'm okay with this as-is.

StephanTLavavej · 2022-06-25T00:05:00Z

I'm mirroring this to the MSVC-internal repo - please notify me if any further changes are pushed.

StephanTLavavej · 2022-06-25T23:04:51Z

Thanks for finding and fixing this visualizer bug - hash_set may be deprecated, but we should still visualize it properly! 🎉 🐈 👁️

fix hash_* visualizer issue

7bad586

fsb4000 requested a review from a team as a code owner June 12, 2022 09:37

StephanTLavavej added the visualizer How the VS debugger displays STL types label Jun 12, 2022

StephanTLavavej approved these changes Jun 13, 2022

View reviewed changes

CaseyCarter approved these changes Jun 13, 2022

View reviewed changes

StephanTLavavej self-assigned this Jun 25, 2022

StephanTLavavej merged commit b23ecba into microsoft:main Jun 25, 2022

fsb4000 deleted the fix2783 branch June 26, 2022 02:30

StephanTLavavej mentioned this pull request Jul 7, 2022

Adding mutex, ranges, functional, any and format visualizers #2191

Merged

fsb4000 added a commit to fsb4000/STL that referenced this pull request Aug 13, 2022

fix hash_* visualizer issue (microsoft#2784)

f77de88

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

fix hash_* visualizer issue#2784

fix hash_* visualizer issue#2784
StephanTLavavej merged 1 commit intomicrosoft:mainfrom
fsb4000:fix2783

fsb4000 commented Jun 12, 2022

Uh oh!

StephanTLavavej Jun 13, 2022

Uh oh!

StephanTLavavej commented Jun 25, 2022

Uh oh!

StephanTLavavej commented Jun 25, 2022

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

	class _Hmap_traits : public _Tr { // traits required to make _Hash behave like a map
	public:
	using key_type = _Kty;
	using value_type = pair<const _Kty, _Ty>;
	using _Mutable_value_type = pair<_Kty, _Ty>;
	using key_compare = _Tr;
	using allocator_type = _Alloc;
	#if _HAS_CXX17
	using node_type =
	_STD _Node_handle<_STD _List_node<value_type, typename _STD allocator_traits<_Alloc>::void_pointer>, _Alloc,
	_STD _Node_handle_map_base, _Kty, _Ty>;
	#endif // _HAS_CXX17

	static constexpr bool _Multi = _Mfl;
	static constexpr bool _Standard = false;

	template <class... _Args>
	using _In_place_key_extractor = _STD _In_place_key_extract_map<_Kty, _Args...>;
	template <class>
	using _Deduce_key = const _Kty&;
	using key_equal = _Tr;

	_Hmap_traits() = default;

	_Hmap_traits(const _Tr& _Traits) noexcept(_STD is_nothrow_copy_constructible_v<_Tr>) : _Tr(_Traits) {}

	class value_compare {
	public:
	using first_argument_type = value_type;
	using second_argument_type = value_type;
	using result_type = bool;

	_NODISCARD bool operator()(const value_type& _Left, const value_type& _Right) const
	noexcept(noexcept(_Keycompobj(_Left.first, _Right.first))) {
	// test if _Left precedes _Right by comparing just keys
	return _Keycompobj(_Left.first, _Right.first);
	}

	value_compare(const key_compare& _Keycomparg) noexcept(_STD is_nothrow_copy_constructible_v<key_compare>)
	: _Keycompobj(_Keycomparg) {}

	key_compare _Keycompobj;
	};

	template <class _Ty1, class _Ty2>
	_NODISCARD static const _Kty& _Kfn(const pair<_Ty1, _Ty2>& _Val) noexcept { // extract key from element value
	return _Val.first;
	}

	template <class _Ty1, class _Ty2>
	_NODISCARD static const _Ty2& _Nonkfn(const pair<_Ty1, _Ty2>& _Val) noexcept {
	// extract non-key from element value
	return _Val.second;
	}

	_NODISCARD float& _Get_max_bucket_size() noexcept {
	return _Max_buckets;
	}

	_NODISCARD const float& _Get_max_bucket_size() const noexcept {
	return _Max_buckets;
	}

	void swap(_Hmap_traits& _Rhs) noexcept(_Is_nothrow_swappable<_Tr>::value) {
	_Swap_adl(static_cast<_Tr&>(*this), static_cast<_Tr&>(_Rhs));
	_STD swap(_Max_buckets, _Rhs._Max_buckets);
	}

	float _Max_buckets = 0.0F; // current maximum bucket size
	};

	class hash_compare { // traits class for hash containers
	public:
	enum { // parameters for hash table
	bucket_size = 1 // 0 < bucket_size
	};

	hash_compare() = default;
	hash_compare(const _Pr& _Pred) noexcept(_STD is_nothrow_copy_constructible_v<_Pr>) : comp(_Pred) {}

	_NODISCARD size_t operator()(const _Kty& _Keyval) const noexcept(noexcept(hash_value(_Keyval))) {
	long _Quot = static_cast<long>(hash_value(_Keyval) & LONG_MAX); // TRANSITION, ADL?
	ldiv_t _Qrem = _CSTD ldiv(_Quot, 127773);

	_Qrem.rem = 16807 * _Qrem.rem - 2836 * _Qrem.quot;
	if (_Qrem.rem < 0) {
	_Qrem.rem += LONG_MAX;
	}

	return static_cast<size_t>(_Qrem.rem);
	}

	_NODISCARD bool operator()(const _Kty& _Keyval1, const _Kty& _Keyval2) const
	noexcept(noexcept(comp(_Keyval1, _Keyval2))) {
	// test if _Keyval1 ordered before _Keyval2
	return comp(_Keyval1, _Keyval2);
	}

	_Pr comp{}; // the comparator object
	};

Conversation

fsb4000 commented Jun 12, 2022

Uh oh!

StephanTLavavej Jun 13, 2022

Choose a reason for hiding this comment

Uh oh!

StephanTLavavej commented Jun 25, 2022

Uh oh!

StephanTLavavej commented Jun 25, 2022

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants