Question about possible race condition in compare_exchange

[trivigy]

Inside compare_exchange_weak function on line 1304 the logic decrements local temporary count by 1 to compensate for the increment that happened to the atomic local temporary at line 1291. As I understand this is necessary in order to keep the invariant of theorem 2 equation 1. However, this type of mutation implies a change to a non-atomic shared referenced value (i.e. the local temporary counter of 'expected'). If for instance, this same 'expected' sptr was passed in multiple compare_exchange calls across several threads, where the execution arrived at line 1304 at the same time, would it not be prone to a possible race condition during expected.cp_header_.counter()--;? Alternatively, what if, while execution compare_exchange_weak, another thread called reset on expected. Right at the same moment when line 1304 is being executed. Same memory location is being modified then. Is this not a possible race condition? I might be missing something in my logic and have not yet implemented a test to try and catch this race condition.

[trivigy]

Here is an idea that I had which is minimally invasive. It is basically using the same concept of what was done for the store method at 1215. Because this will create a temporary local shared_ptr<T> { expected }. It is then can be guaranteed that to not change in parallel until after the method is complete and dropped.

public:
    bool compare_exchange_weak( shared_ptr<T>& expected, const shared_ptr<T>& desired,
                                std::memory_order success, std::memory_order failure ) noexcept
    {
      return compare_exchange_weak( shared_ptr<T> { expected }, desired, success, failure);
    }

private:
    bool compare_exchange_weak( shared_ptr<T>&& expected, const shared_ptr<T>& desired,
                                std::memory_order success, std::memory_order failure ) noexcept
    {
        {
            const hdr_ptr_type desired_cptr = { desired.cp_header_.get_ptr() };
            const auto expected_ptr = expected.cp_header_.get_ptr();
            hdr_ptr_type exp_ctrl_ptr; //{ expected_ptr };
            bool acquired_des = false;
            goto start;

            for(;;) {
                // Do an optimistic cas
                if( cptr_hdr_.compare_exchange_weak( exp_ctrl_ptr, desired_cptr, success, failure )) {
                    if( expected_ptr )
                        expected_ptr->release( { exp_ctrl_ptr.get_ctr(), 1 }, std::memory_order_relaxed );
                    return true;
                }
                if( expected_ptr != exp_ctrl_ptr.get_ptr() ) {
start:
                    exp_ctrl_ptr = _enter( std::memory_order_relaxed );
                    if( expected_ptr != exp_ctrl_ptr.get_ptr() ) [[likely]] {
                        if( acquired_des ) {
                            if( desired_cptr.get_ptr()) [[likely]]
                                desired_cptr->release( { 0, 1 }, std::memory_order::relaxed );
                        }

                        if( exp_ctrl_ptr.get_ptr() ) [[likely]]
                            exp_ctrl_ptr->acquire( { 1, 1 }, std::memory_order_relaxed );
                        expected = shared_ptr<T>{ exp_ctrl_ptr.get_ptr() };
                        return false;
                    }

                    expected.cp_header_.counter()--;  // compensate the _enter() from above

                    // acquire new instance of *desired* before the cas might succeed!
                    if( !acquired_des ) {
                        if( desired_cptr.get_ptr()) [[likely]]
                            desired_cptr->acquire( { 0, 1 }, std::memory_order::relaxed );
                        acquired_des = true;
                    }
                }
            }
        }
    }