[Bug c++/102962] New: shared locks / mutexes differ between linux and windows

[Marco.Mengelkoch1 at ibm dot com via Gcc-bugs]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102962

            Bug ID: 102962
           Summary: shared locks / mutexes differ between linux and
                    windows
           Product: gcc
           Version: unknown
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: Marco.Mengelkoch1 at ibm dot com
  Target Milestone: ---

I created some minimal example to investigate the issues and I have the same
application that runs 3 seconds on windows and returns properly but runs for
hours (I stopped watching after 20 minutes) on my linux system and never
finishes.
It seems that linux now prefers shared_locks over unique_locks. As long as
there are shared_locks that own the mutex, no unqiue_lock will be able to get
the mutex, while new shared locks still get the mutex. Windows still prefers
unique_locks instead.

I know that there might be differences between compilers, but as this is
basically both g++, I assumed that the application should work the same way.

Here is the application:
Runtime on windows 10, g++: 3s
Runtime on RHEL 8.4 / Ubuntu WSL with g++: both stopped watching after > 20
minutes



Code sample:

// mutex.cpp

// linux:
// g++ -g -O2 -o stlM  mutex.cpp -std=c++17 -pthread && ./stlM
// windows: 
// g++ -g -O2 -o stlM.exe  mutex.cpp -std=c++17 

#include <exception>
#include <iostream>
#include <chrono>
#include <thread>
#include <memory>
#include <shared_mutex>

typedef std::thread Thread;
typedef std::shared_mutex SharedMutex;
typedef std::unique_lock<SharedMutex> UniqueLock;
typedef std::shared_lock<SharedMutex> SharedLock;
#define MUTEX_STRING "STL"

SharedMutex myMutex;
const size_t maxIterations = 20000000;

int sharedLocking() {
        for (size_t i = 1; i < maxIterations; ++i) {
                SharedLock a(myMutex);
                if (i % 200 == 0) {
                        std::cout << "." << std::flush;
                }
                std::this_thread::sleep_for(std::chrono::milliseconds(5));
        }
        std::cout << "Finished local" << std::flush;
        return 0;
}

int uniqueLocking() {
        std::cout << "_" << std::flush;
        UniqueLock a(myMutex);
        std::cout << "|" << std::flush;
        std::cout << "Unique" << std::endl << std::flush;
        std::this_thread::sleep_for(std::chrono::seconds(2));
        exit(0);
        return 0;
}

int main(int argc, char **argv) {
        std::cout << "Using " << MUTEX_STRING << " mutexes" << std::endl;
        std::cout << " starting ..." << std::endl;
        for (int i = 0; i < 128; ++i) {
                std::shared_ptr<Thread> tmpThread =
std::make_shared<Thread>(&sharedLocking);
                tmpThread->detach();
        }
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::shared_ptr<Thread> myThread =
std::make_shared<Thread>(&uniqueLocking);
        std::shared_ptr<Thread> myThread2 =
std::make_shared<Thread>(&uniqueLocking);
        myThread->join();
        return 0;

}