<div id="readability-page-1" class="page"><div>
                <div id="SE-921bdf18-0478-4653-8111-bc5c90db0c93">
                                    <p id="SE-2cf270c1-c5d5-44fd-8c32-cb68d5395876"><span id="SE-d1b08bd6-3b00-4b39-b43c-6eac2de48944">최근 등록된 STL GitHub 이슈(&lt;shared_mutex&gt;: SRWLOCK can grant exclusive ownership when we requested shared ownership)에 링크를 보면 윈도의 shared_mutex에 버그가 있다는 리포트가 있습니다.</span></p><p id="SE-cf031d58-f2c3-41dd-ac5f-5a99adb10af2"><span id="SE-9447d0a9-e14d-4345-977f-b29cb6804ec3">​</span></p>
                            </div>                                <div id="SE-61223565-13f8-47c2-90cd-f0cd97d1b59e">
                            <p id="SE-e07645da-b366-41c3-90e5-bdb804c2295b"><span id="SE-a1f9606b-b3e2-4246-a4f8-4e024d70bcb8">리딧에 올라온 리포트는 아래에서 확인할 수 있습니다.</span></p>
                        </div>                                <div id="SE-e88636f7-689f-4407-ab10-dccd12cf41a8">
                                    <p id="SE-92376e54-0baa-47aa-bd92-52c7dcea840b"><span id="SE-9380ffcb-ccc7-4855-ad16-9861d907e0fc">​</span></p><p id="SE-7f15c5a5-05bc-4909-abc3-2b30c44c4851"><span id="SE-0a2069c4-784b-4048-ad87-e79021add862">먼저 레딧에 올라온 다음 코드를 MSVC로 릴리스 컴파일 한 다음 실행하면 중간에 멈추게 되는 것을 확인할 수 있습니다. 메인 스레드에서 exclusive lock을 건 상황에서 자식 스레드가 shared lock을 얻으려고 할 때, 한 개의 스레드만 shared lock을 얻고 나머지는 블록 됩니다. 수만 번의 루프 수행 내에 lock_shared()에서 데드락이 발생합니다.</span></p>
                            </div>                <div id="SE-d19034d6-6a6a-4cec-bd90-1680337365bb">
                                    <p>#include &lt;atomic&gt;
#include &lt;cstdint&gt;
#include &lt;iostream&gt;
#include &lt;memory&gt;
#include &lt;shared_mutex&gt;
#include &lt;thread&gt;
#include &lt;vector&gt;

struct ThreadTestData {
  int32_t numThreads = 0;
  std::shared_mutex sharedMutex = {};
  std::atomic&lt;int32_t&gt; readCounter;
};

int DoStuff(ThreadTestData* data) {
  // Acquire reader lock
  data-&gt;sharedMutex.lock_shared();

  // wait until all read threads have acquired their shared lock
  data-&gt;readCounter.fetch_add(1);
  while (data-&gt;readCounter.load() != data-&gt;numThreads) {
    std::this_thread::yield();
  }

  // Release reader lock
  data-&gt;sharedMutex.unlock_shared();

  return 0;
}

int main() {
  int count = 0;
  while (true) {
    ThreadTestData data = {};
    data.numThreads = 5;

    // Acquire write lock
    data.sharedMutex.lock();

    // Create N threads
    std::vector&lt;std::unique_ptr&lt;std::thread&gt;&gt; readerThreads;
    readerThreads.reserve(data.numThreads);
    for (int i = 0; i &lt; data.numThreads; ++i) {
      readerThreads.emplace_back(std::make_unique&lt;std::thread&gt;(DoStuff, &amp;data));
    }

    // Release write lock
    data.sharedMutex.unlock();

    // Wait for all readers to succeed
    for (auto&amp; thread : readerThreads) {
      thread-&gt;join();
    }

    // Cleanup
    readerThreads.clear();

    // Spew so we can tell when it's deadlocked
    count += 1;
    std::cout &lt;&lt; count &lt;&lt; std::endl;
  }

  return 0;
}</p>
                                </div>                <div id="SE-0db30d82-dfbd-43ac-9094-6f6c9edf5e5e">
                            <p id="SE-9f0b7e3c-5fba-47d6-96ed-763b7c23802f"><span id="SE-89c8fba7-e5da-43e7-a8d3-65ed1cf26883">MSVC는 std::shared_mutex 구현에 윈도 API가 제공하는 SRW(Slim Reader/Writer) Lock을 이용합니다. 따라서 SRWLOCK으로 포팅 한 다음의 코드도 동일한 결과가 나옵니다.</span></p>
                        </div>                <div id="SE-ad8815a3-bf54-4a91-967e-57ffb7ea9447">
                                    <p>#include &lt;Windows.h&gt;
#include &lt;atomic&gt;
#include &lt;cstdint&gt;
#include &lt;iostream&gt;
#include &lt;memory&gt;
#include &lt;thread&gt;
#include &lt;vector&gt;

struct ThreadTestData {
  int32_t numThreads = 0;
  SRWLOCK sharedMutex;
  std::atomic&lt;int32_t&gt; readCounter;
};

void InitializeThreadTestData(ThreadTestData* data, int numThreads) {
  data-&gt;numThreads = numThreads;
  InitializeSRWLock(&amp;(data-&gt;sharedMutex));
  data-&gt;readCounter = 0;
}

int DoStuff(ThreadTestData* data) {
  // Acquire reader lock
  AcquireSRWLockShared(&amp;(data-&gt;sharedMutex));

  // Wait until all read threads have acquired their shared lock
  data-&gt;readCounter.fetch_add(1);
  while (data-&gt;readCounter.load() != data-&gt;numThreads) {
    std::this_thread::yield();
  }

  // Release reader lock
  ReleaseSRWLockShared(&amp;(data-&gt;sharedMutex));

  return 0;
}

int main() {
  int count = 0;
  while (true) {
    ThreadTestData data;
    InitializeThreadTestData(&amp;data, 5);

    // Acquire write lock
    AcquireSRWLockExclusive(&amp;(data.sharedMutex));

    // Create N threads
    std::vector&lt;std::unique_ptr&lt;std::thread&gt;&gt; readerThreads;
    readerThreads.reserve(data.numThreads);
    for (int i = 0; i &lt; data.numThreads; ++i) {
      readerThreads.emplace_back(std::make_unique&lt;std::thread&gt;(DoStuff, &amp;data));
    }

    // Release write lock
    ReleaseSRWLockExclusive(&amp;(data.sharedMutex));

    // Wait for all readers to succeed
    for (auto&amp; thread : readerThreads) {
      thread-&gt;join();
    }

    // Cleanup
    readerThreads.clear();

    // Increment and print the count to detect deadlocks
    count += 1;
    std::cout &lt;&lt; count &lt;&lt; std::endl;
  }

  return 0;
}</p>
                                </div>                <div id="SE-7560deae-1729-405d-9692-eb453eb6d6d0">
                                    <p id="SE-4c2032bd-1c17-45f4-b6c3-02fb7611f991"><span id="SE-393b3a3f-947a-4587-96b3-5fa73fe7a556">​</span></p><p id="SE-63efcee1-58a6-4e91-827c-c45861b3a692"><span id="SE-863274c9-06bf-4106-b6c3-2028dcedb432">윈도 API의 의도치 않은 동작이기 때문에 다른 플랫폼이나 윈도 API를 사용하지 않는 STL의 구현체는 문제가 발생하지 않습니다. 래딧 글에 다르면 윈도 비스타 이전부터 발생했던 문제라고 하는데, SRWLOCK이 윈도 비스타 때 추가된 기능이고, shared_mutex는 C++ 17 기능이며, SWRLOCK 전까지 이런 기능은 크리티컬 섹션으로 구현되었습니다. SRWLOCK으로 포팅은 그 이후이니 아마도 윈도7/비주얼 스튜디오 2015부터 발생하지 않을까 추측됩니다. 이 버그는 Microsoft의 내부 버그 트래킹 시스템(OS-49268777, SRWLOCK can deadlock after an exclusive owner has released ownership and several reader threads are attempting to acquire shared ownership together)에 등록되었고, 공식 GitHub에도 이슈 등록이 되었으니 어떤 식으로든 패치가 될 것 같습니다.</span></p><p id="SE-c8685e52-6218-488b-861e-b40830243c35"><span id="SE-75023aec-fc73-49e9-9746-95e72bfdeeb8">패치되기 전에는 아래와 같이 우회가 가능합니다. std::chrono로 시간을 비교하여 일정 시간 동안만 기다립니다. 간헐적으로 "Timeout reached, releasing lock." 메시지가 튀는 것을 확인할 수 있습니다.</span></p>
                            </div>                <div id="SE-a4d28274-6b52-4c30-b296-a5886fac5309">
                                    <p>#include &lt;atomic&gt;
#include &lt;cstdint&gt;
#include &lt;iostream&gt;
#include &lt;memory&gt;
#include &lt;shared_mutex&gt;
#include &lt;thread&gt;
#include &lt;vector&gt;
#include &lt;chrono&gt;

struct ThreadTestData {
  int32_t numThreads = 0;
  std::shared_mutex sharedMutex = {};
  std::atomic&lt;int32_t&gt; readCounter = 0;
};

int DoStuff(ThreadTestData* data) {
  // Acquire reader lock
  data-&gt;sharedMutex.lock_shared();

  // Increment the read counter
  data-&gt;readCounter.fetch_add(1);

  // Get the current time
  auto start = std::chrono::steady_clock::now();
  auto end = start + std::chrono::milliseconds(1000); // 1000 milliseconds timeout

  // Wait until all read threads have acquired their shared lock or timeout
  while (data-&gt;readCounter.load() != data-&gt;numThreads) {
    if (std::chrono::steady_clock::now() &gt;= end) {
      std::cout &lt;&lt; "Timeout reached, releasing lock." &lt;&lt; std::endl;
      break; // Exit the loop if timeout is reached
    }
    std::this_thread::yield();
  }

  // Release reader lock
  data-&gt;sharedMutex.unlock_shared();

  return 0;
}

int main() {
  int count = 0;
  while (true) {
    ThreadTestData data = {};
    data.numThreads = 5;

    // Acquire write lock
    data.sharedMutex.lock();

    // Create N threads
    std::vector&lt;std::unique_ptr&lt;std::thread&gt;&gt; readerThreads;
    readerThreads.reserve(data.numThreads);
    for (int i = 0; i &lt; data.numThreads; ++i) {
      readerThreads.emplace_back(std::make_unique&lt;std::thread&gt;(DoStuff, &amp;data));
    }

    // Release write lock
    data.sharedMutex.unlock();

    // Wait for all readers to succeed
    for (auto&amp; thread : readerThreads) {
      thread-&gt;join();
    }

    // Cleanup
    readerThreads.clear();

    // Increment and print the deadlock detection counter
    count += 1;
    if (0 == (count % 1000)) {
      std::cout &lt;&lt; count &lt;&lt; std::endl;
    }
  }

  return 0;
}</p>
                                </div>                <div id="SE-83509528-013b-4968-b506-3690e9ec2552">
                            <p id="SE-4e117b6d-5628-472c-8d22-14b21927ba72"><span id="SE-d2baf39f-9b94-44ed-92ea-3b82a7e69360">조금 더 우아하게 보이는 방법으로 아래와 같이 std::shared_timed_mutex를 사용하여 기다리는 시간을 설정해 줄 수 있습니다. 우아한 방법이 아닌 우아하기 보이는 방법인 이유는 std::shared_timed_mutex는 shared_mutex와 달리 SRWLOCK을 사용하지 않기 때문에 위 문제를 우회하는 것이 아닌 원래 문제가 없는 구현이기 때문입니다.</span></p>
                        </div>                <div id="SE-528cf6ff-7c54-4440-9db1-45e8cdafe9d9">
                                    <p>#include &lt;atomic&gt;
#include &lt;chrono&gt;
#include &lt;cstdint&gt;
#include &lt;iostream&gt;
#include &lt;memory&gt;
#include &lt;shared_mutex&gt;
#include &lt;thread&gt;
#include &lt;vector&gt;

struct ThreadTestData {
    int32_t numThreads = 0;
    std::shared_timed_mutex sharedTimedMutex; // Using std::shared_timed_mutex
    std::atomic&lt;int32_t&gt; readCounter;
};

int DoStuff(ThreadTestData* data) {
    // Try to acquire reader lock with a timeout
    auto timeout = std::chrono::milliseconds(100); // Timeout of 100 milliseconds
    if (data-&gt;sharedTimedMutex.try_lock_shared_for(timeout)) {
        // Wait until all read threads have acquired their shared lock
        data-&gt;readCounter.fetch_add(1);
        while (data-&gt;readCounter.load() != data-&gt;numThreads) {
            std::this_thread::yield();
        }

        // Release reader lock
        data-&gt;sharedTimedMutex.unlock_shared();
    } else {
        // Timeout occurred, lock was not acquired
        std::cout &lt;&lt; "Timeout occurred, shared lock was not acquired." &lt;&lt; std::endl;
    }

    return 0;
}

int main() {
    int count = 0;
    while (true) {
        ThreadTestData data;
        data.numThreads = 5;
        data.readCounter = 0; // Initialize readCounter

        // Acquire write lock
        auto lockAcquired = data.sharedTimedMutex.try_lock_for(std::chrono::milliseconds(500)); // Trying to lock with timeout
        if (!lockAcquired) {
            std::cout &lt;&lt; "Failed to acquire write lock, skipping iteration." &lt;&lt; std::endl;
            continue; // Skip this iteration if write lock is not acquired
        }

        // Create N threads
        std::vector&lt;std::unique_ptr&lt;std::thread&gt;&gt; readerThreads;
        readerThreads.reserve(data.numThreads);
        for (int i = 0; i &lt; data.numThreads; ++i) {
            readerThreads.emplace_back(std::make_unique&lt;std::thread&gt;(DoStuff, &amp;data));
        }

        // Release write lock
        data.sharedTimedMutex.unlock();

        // Wait for all readers to succeed
        for (auto&amp; thread : readerThreads) {
            thread-&gt;join();
        }

        // Cleanup
        readerThreads.clear();

        // Increment and print the count to detect potential deadlocks
        count += 1;
        if (0 == (count % 1000)) {
		  std::cout &lt;&lt; count &lt;&lt; std::endl;
		}		
    }

    return 0;
}</p>
                                </div>                    </div></div>

내 성격 100% 활용하기 -上-

최근 등록된 STL GitHub 이슈(<shared_mutex>: SRWLOCK can grant exclusive ownership when we requested shared ownership)에 링크를 보면 윈도의 shared_mutex에 버그가 있다는 리포트가 있습니다. 리딧에 올라온 리포트는 아래에서 확인할 수 있습니다. 먼저 레딧에 올라온 다음 코드를 MSVC로 릴리스 컴파일 한 다음 실행하면 중간에 멈추게 되는 것을 확인할 수 있습니다. 메인 스레드에서 exclusive lock을 건 상황에서 자식 스레드가 shared lock을 얻으려고 할 때, 한 개의 스레드만 shared lock을 얻고 나머지는 블록 됩니다. 수만 번의 루프 수행 내에 lock_shared()에서 데드락이 발생합니다. MSVC는 std::shared_mutex 구현에.......

의도지 않은 SRW Lock(std::shared_mutex) API 동작

댓글