BLC에 사용하기 위해 약간 수정된 Loki 라이브러리

오리지널 Loki<library> 다운로드 링크: http://loki-lib.sourceforge.net/index.php?n=Main.Download

※ Loki 라이브러리 라이선스: MIT License

BLC에 사용하기 위해 약간 수정된 Loki 라이브러리는 BLC 라이브러리 압축파일에 포함되어 있습니다. 약간의 수정을 거쳐 BLC에 사용된 부분은 Loki 라이브러리의 일부분이고, 수정을 거치면서 기존 Loki 라이브러리의 다른 부분과는 호환되지 않는 부분이 있을 수 있습니다(특히, "Functor.h", "SmallObj.h", "SmartPtr.h" 이 세 헤더는 확실하게 호환되지 않을 것입니다).

Modern C++ Design 의 Loki 라이브러리를, BLC 라이브러리에 사용하기 위해 C++17를 적용하여 약간 수정을 했습니다. BLC에서는, Loki 라이브러리 중에서 "Threads.h"와 "Singleton.h", "TypeManip.h" 이 세 개의 헤더만 인클루드합니다. 해당 헤더의 구현 파일과, 헤더 내에서 인클루드하는, Loki 라이브러리의 다른 파일까지 모두 합치면 총 7개의 Loki 라이브러리 코드파일을 사용하게 됩니다.

변경된 파일들에 대해 유닛 테스트를 수행하긴 했으나, 미처 걸러지지 못한 버그가 있을 수 있습니다. 또한 Threads.h 헤더를 포함하는 기존 코드와 호환되지 않을 수 있습니다.

또한 실무 경험이 부족한 상태에서 짠 코드라 여러가지 미숙한 부분이 있을 수 있습니다. 이메일(ajw9105@hanmail.net)을 통해 개선해야 할 점이나 여러 의견들을 받고 있으니 관심 있으신 분들은 메일 보내주셨으면 좋겠습니다.

기반이 되는 소스 코드는 https://sourceforge.net/projects/loki-lib/files/Source%20Code/Modern%20C%2B%2B%20Design/ 의 소스 코드 중 Reference 폴더 내의 소스 코드 입니다.

지금부터 변경된 헤더 파일 및 추가된 구현 파일에 대해서 설명하겠습니다. 여기서 설명하지 않은 Loki 라이브러리의 사용법은 Modern C++ Design 를 참고하세요.

• 변경된 헤더 파일 목록

  1. Singleton.h

     Singleton.h 헤더는 수정된 Threads.h 파일과 호환되도록 스레딩 단위전략 관련 부분만이 수정되었습니다. 기본적인 사용법은 기존의 Loki 라이브러리와 동일합니다.

  2. Threads.h

     이 헤더 파일이 가장 많은 변경사항이 있는 헤더 파일입니다. 수정된 점을 하나씩 짚어 봅시다.
     • 우선 use_read_lock 이라는 비타입 템플릿 매개변수가 하나 추가되었습니다. 따라서 새로운 스레딩 단위전략 클래스 템플릿은 다음과 같이 선언됩니다.
       
       스레딩 단위전략 클래스 템플릿의 선언 예제 코드 보기
       
       
       

       1. template <class Host, bool use_read_lock = true>
       2. class SingleThreaded;
       3.  
       4. template <class Host, bool use_read_lock = true>
       5. class ObjectLevelLockable;
       6.  
       7. template <class Host, bool use_read_lock = true>
       8. class ClassLevelLockable;
       9.  

       
       
       스레딩 단위전략 클래스 템플릿의 선언 예제 코드 접기
       
       
       비타입 매개변수 use_read_lock이 true이고 ReadLock(조금 있다 설명합니다)을 사용하여 뮤텍스를 잠근 경우, std::shared_mutex::lock_shared / std::shared_mutex::unlock_shared 멤버 함수를 통해 잠금/해제를 하여 공유 자원을 읽기만 하는 스레드가 여렷일 경우에 성능상 이점이 생기게 됩니다.
       
       만일 ReadLock을 사용하여 뮤텍스를 잠궜더라도 use_read_lock이 false라면, std::shared_mutex::lock / std::shared_mutex::unlock 멤버 함수를 사용하여 일반적인 잠금/해제를 수행하게 됩니다.
       
       
     • VolatileType, AtomicType 별칭 템플릿이 추가되었습니다. 이 별칭 템플릿으로 스레딩 단위전략 클래스 템플릿과 임의 타입 T(단, AtomicType의 경우 std::atomic의 템플릿 인자로 넘겨줄 수 있는 타입이어야 함)를 넘겨주면, 넘겨받은 스레딩 단위전략 클래스 템플릿에 따라 적절한 타입을 정해줍니다.
       
       VolatileType, AtomicType 예제 코드 보기
       
       
       

       1. // Result0은 int와 동일
       2. using Result0 = VolatileType<SingleThreaded, int>;
       3.  
       4. // Result1은 volatile int와 동일
       5. using Result1 = VolatileType<ObjectLevelLockable, int>;
       6.  
       7. // Result2은 volatile int와 동일
       8. using Result2 = VolatileType<ClassLevelLockable, int>;
       9.  
       10.  
       11. // Result3은 int와 동일
       12. using Result3 = AtomicType<SingleThreaded, int>;
       13.  
       14. // Result4은 std::atomic<int>와 동일
       15. using Result4 = AtomicType<ObjectLevelLockable, int>;
       16.  
       17. // Result5은 std::atomic<int>와 동일
       18. using Result5 = AtomicType<ClassLevelLockable, int>;
       19.  

       
       
       VolatileType, AtomicType 예제 코드 접기
       
       
       
     • SafeLock 클래스 템플릿이 추가되었습니다. 이 클래스 템플릿은 세 종류의 특수화가 존재합니다. 첫 번째 특수화 버전은 템플릿 인자로 스레딩 단위전략 클래스 타입 하나를 받습니다. 그리고 생성자에서, 템플릿 인자로 받은 스레딩 단위전략 클래스를 상속받은 Host 클래스의 객체 하나를 받아 그 객체의 std::shared_mutex를 잠금/해제 합니다.
       
       만일 템플릿 인자로 받은 스레딩 단위전략 클래스 타입이 상수 타입인 경우에는, SafeLock의 생성자로 받을 수 있는 Host 클래스의 객체는 반드시 상수가 되어야 합니다. 이 때, use_read_lock이 true인 경우에는 잠금/해제 시 std::shared_mutex::lock_shared / std::shared_mutex::unlock_shared 멤버 함수가 사용됩니다.
       
       SafeLock 예제 코드 보기
       
       
       

       1. //-----------------------------------------------------------------------------
       2. // 쓰기 잠금이 사용되는 경우
       3.  
       4. // 이 예제에서는 두 번째의 비타입 인수가 false이라도 같은 동작을 한다.
       5. template <template <class, bool> class ThreadingModel>
       6. class Host : public ThreadingModel<Host, true>
       7. {
       8. public:
       10. // ThisThreadingModel은 스레딩 단위전략 클래스 템플릿의
       11. // public 영역에 선언되어 있습니다.
       12. using ThreadingModel::ThisThreadingModel;
       14. ...
       15. };
       16.  
       17. using WriteLock = SafeLock<Host::ThisThreadingModel>;
       18.  
       19. ...
       20.  
       21. Host host;
       22.  
       23. {
       24. // Host가 갖는 std::shared_mutex를 잠근다(std::shared_mutex::lock 사용).
       25. WriteLock lock(host);
       27. ...
       29. } // lock 객체가 소멸될 때 Host가 갖는 std::shared_mutex가 해제된다
       30. // (std::shared_mutex::unlock 사용).
       32. // 당연하지만 ThreadingModel이 SingleThreaded인 경우에는 Host가 std::shared_mutex를
       33. // 갖지 않고, 잠금/해제도 일어나지 않습니다(아래 예제들도 마찬가지).
       34.  
       35.  
       36.  
       37. //-----------------------------------------------------------------------------
       38. // 읽기 잠금이 사용되는 경우
       39.  
       40. template <template <class, bool> class ThreadingModel>
       41. class Host : public ThreadingModel<Host, true> // 비타입 인수가 true임에 주의!
       42. {
       43. public:
       44. using ThreadingModel::ThisThreadingModel;
       46. ...
       47. };
       48.  
       49. // 템플릿 인수가 상수(const) 타입인 것에 주의!!
       50. using ReadLock = SafeLock<const Host::ThisThreadingModel>;
       51.  
       52. ...
       53.  
       54. Host host;
       55. const Host const_host;
       56.  
       57. {
       58. // Host가 갖는 std::shared_mutex를 잠근다(std::shared_mutex::lock_shared 사용).
       59. ReadLock lock_error(host); // 컴파일 에러: 상수가 아닌 타입에 대해
       60. // 읽기 잠금을 사용할 수 없습니다!!
       62. ReadLock lock(const_host); // 문제 없음.
       64. ...
       66. } // lock 객체가 소멸될 때 Host가 갖는 std::shared_mutex가 해제된다
       67. // (std::shared_mutex::unlock_shared 사용).
       68.  
       69.  
       70.  
       71. //-----------------------------------------------------------------------------
       72. // 읽기 잠금을 사용했으나, 쓰기 잠금이 적용되는 경우
       73.  
       74. template <template <class, bool> class ThreadingModel>
       75. class Host : public ThreadingModel<Host, false> // 비타입 인수가 false임에 주의!
       76. {
       77. public:
       78. using ThreadingModel::ThisThreadingModel;
       80. ...
       81. };
       82.  
       83. // 템플릿 인수가 상수(const) 타입인 것에 주의!!
       84. using ReadLock = SafeLock<const Host::ThisThreadingModel>;
       85.  
       86. ...
       87.  
       88. Host host;
       89. const Host const_host;
       90.  
       91. {
       92. // Host가 갖는 std::shared_mutex를 잠근다(std::shared_mutex::lock 사용).
       93. ReadLock lock_error(host); // 컴파일 에러: 상수가 아닌 타입에 대해
       94. // 읽기 잠금을 사용할 수 없습니다!!
       96. ReadLock lock(const_host); // 문제 없음.
       98. ...
       100. } // lock 객체가 소멸될 때 Host가 갖는 std::shared_mutex가 해제된다
       101. // (std::shared_mutex::unlock 사용).
       102.  
       103.  
       104. // 두 번째 템플릿 인수가 false이므로 ReadLock(SafeLock의 템플릿 인수가 상수(const) 타입)을
       105. // 사용하더라도 쓰기 잠금/해제가 사용됩니다.
       106.  
       107. // 그러나 쓰기 잠금/해제가 사용되더라도, ReadLock은
       108. // 상수 Host 객체에 대해서만 사용할 수 있습니다.

       
       
       SafeLock 예제 코드 접기
       
       
       SafeLock의 두 번째 특수화 버전은 ClassLevelLockable 단위전략 클래스 템플릿 사용 시 static 함수에서 SafeLock을 사용하는 경우(SafeLock에 넘겨줄 객체가 없는 경우)에 사용할 수 있도록 만들어졌습니다. 이 특수화 버전은 템플릿 인수로 NullType을 받고, 생성자에 직접 사용할 shared_mutex와 읽기 잠금 사용 여부를 넘겨줘야 합니다.
       
       그러나 ClassLevelLockable의 std::shared_mutex는 private 영역에 숨겨져 있으므로, 여러분이 직접 이 특수화 버전을 사용할 일은 거의 없을 것입니다. 대신 ClassLevelLockable의 public 영역에 선언된 StaticWriteLock과 StaticReadLock의 내부에서 사용되었으므로, 이 두 타입을 사용하여 간접적으로 사용할 수 있습니다.
       
       한 가지 주의할 점은 StaticReadLock의 생성자는 객체를 받지 않으므로, 상수와 읽기 잠금에 대한 컴파일 오류를 받을 수 없다는 것입니다.
       
       StaticLock 예제 코드 보기
       
       
       

       1. //-----------------------------------------------------------------------------
       2. // 읽기/쓰기 잠금을 구분하는 경우
       3.  
       4. // 스레딩 단위전략 클래스 템플릿의 두 번째 템플릿 인수가
       5. // true라는 사실에 주의!!
       6. template <template <class, bool> class ThreadingModel>
       7. class Host : public ThreadingModel<Host, true>
       8. {
       9. public:
       11. // 아래의 두 타입은 스레딩 단위전략 클래스 템플릿인 SingleThreaded와
       12. // ClassLevelLockable의 public 영역에 선언되어 있습니다.
       13. using ThreadingModel::StaticWriteLock;
       14. using ThreadingModel::StaticReadLock;
       15.  
       16.  
       17. // 쓰기 잠금을 사용하는 static 함수
       18. static void FunctionWrite() {
       19.  
       20. // Host가 갖는 std::shared_mutex를 잠근다(std::shared_mutex::lock 사용).
       21. StaticWriteLock lock; // 생성자에 넘겨줄 객체(*this)가 없습니다.
       23. ...
       25. } // lock 객체가 소멸될 때 Host가 갖는 std::shared_mutex가 해제된다
       26. // (std::shared_mutex::unlock 사용).
       28.  
       29. // 읽기 잠금을 사용하는 static 함수
       30. static void FunctionRead() {
       31.  
       32. // Host가 갖는 std::shared_mutex를 잠근다(std::shared_mutex::lock_shared 사용).
       33. StaticReadLock lock; // 생성자에 넘겨줄 객체(*this)가 없습니다.
       34.  
       36. // 넘겨줄 객체(*this)가 없으므로, *this가 상수인 경우에만
       37. // StaticReadLock을 사용하도록 강제할 수도 없습니다.
       39. // 따라서 이 임계영역에서는 공유 데이터들을 읽기만 하는 코드만 작성하도록
       40. // 주의를 기울여야 합니다.
       42. ...
       44. } // lock 객체가 소멸될 때 Host가 갖는 std::shared_mutex가 해제된다
       45. // (std::shared_mutex::unlock_shared 사용).
       47. ...
       48. };
       49.  
       50. // 이 StaticReadLock/StaticWriteLock은 ObjectLevelLockable 단위전략 클래스 템플릿에는
       51. // 존재하지 않습니다.
       52.  
       53. // 따라서 StaticReadLock/StaticWriteLock은 SingleThreaded/ClassLevelLockable
       54. // 단위전략 클래스 템플릿을 사용할때만 사용할 수 있습니다.
       55. // 물론 SingleThreaded의 그것은 잠금/해제를 수행하지 않습니다.
       56.  
       57.  
       58.  
       59. //-----------------------------------------------------------------------------
       60. // 읽기/쓰기 잠금을 구분하지 않는 경우
       61.  
       62. // 스레딩 단위전략 클래스 템플릿의 두 번째 템플릿 인수가
       63. // false라는 사실에 주의!!
       64. template <template <class, bool> class ThreadingModel>
       65. class Host : public ThreadingModel<Host, false>
       66. {
       67. public:
       69. ...
       71. static void FunctionRead() {
       72. StaticReadLock lock; // 스레딩 단위전략 클래스 템플릿의
       73. // 두 번째 템플릿 인수가 false이므로
       74. // StaticReadLock은
       75. // StaticWriteLock과 동일하게 동작
       77. ...
       79. }
       81. ...
       82. };

       
       
       StaticLock 예제 코드 접기
       
       
       SafeLock의 마지막 특수화 버전은 첫 번째 특수화 타입의 목록(list) 버전입니다. 즉, 이 특수화 버전은 템플릿 인자로 스레딩 단위전략 클래스 타입들이 담긴 Typelist 하나를 받습니다. 그리고 생성자에서, 템플릿 인자로 받았던 스레딩 단위전략 클래스들을 각각 상속받은 Host 클래스들의 객체를 하나씩 받아 그 객체들의 std::shared_mutex를 잠금/해제 합니다. 이 때 std::shared_mutex의 주소(포인터)순으로 정렬하여 잠금/해제를 수행하므로, 데드락 걱정 없이 스레딩 단위전략을 사용하는 객체 여렷을 한꺼번에 잠금/해제 할 수 있습니다.
       
       첫 번째 특수화 버전과 마찬가지로, 템플릿 인자로 받은 스레딩 단위전략 클래스 타입이 상수(const) 타입이었다면 그 스레딩 단위전략 클래스를 상속받은 Host 클래스의 객체(SafeLock의 생성자로 넘겨줄)도 상수여야 합니다. 그렇지 않다면 컴파일 오류를 발생시키는 것도 같습니다.
       
       SafeLock 예제 코드 보기
       
       
       

       1. template <template <class, bool> class ThreadingModel>
       2. class Host1 : public ThreadingModel<Host1, true>
       3. {
       4. public:
       5.  
       6. // ThisThreadingModel은 스레딩 단위전략 클래스 템플릿의
       7. // public 영역에 선언되어 있습니다.
       8. using ThreadingModel::ThisThreadingModel;
       10. ...
       11. };
       12.  
       13. // 만일 Host2에 사용된 스레딩 단위전략 클래스 템플릿의 두 번째 템플릿 인수로
       14. // false를 넘겨주었다면, 아래의 예제에서 host1과 host2 모두
       15. // std::shared_mutex::lock/unlock을 사용하게 됩니다.
       16. template <template <class, bool> class ThreadingModel>
       17. class Host2 : public ThreadingModel<Host2, true>
       18. {
       19. public:
       20. using ThreadingModel::ThisThreadingModel;
       22. ...
       23. };
       24.  
       25. using TM1 = Host1::ThisThreadingModel;
       26. using TM2 = Host2::ThisThreadingModel;
       27.  
       28. // MakeTypelist_t는 Typelist.h 헤더 항목 참조.
       29. // MakeTypelist_t에 3개 이상의 인수를 넘겨줄 수도 있습니다.
       30. using WriteReadLock = SafeLock<TL::MakeTypelist_t<TM1, const TM2>>;
       31.  
       32. ...
       33.  
       34. Host1 host1;
       35. const Host2 host2;
       36.  
       37. {
       38. // host1과 host2가 갖는 std::shared_mutex를 한꺼번에 잠근다.
       39. // MakeTypelist_t에 넘겨준 템플릿 인수의 수만큼 그리고 순서를 맞춰,
       40. // 잠금/해제할 객체를 생성자에 넘겨준다.
       41. // host1은 std::shared_mutex::lock, host2는 std::shared_mutex::lock_shared 사용
       42. WriteReadLock lock(host1, host2); // 만일 host2가 비상수 객체였다면 컴파일 오류 발생
       44. // 이 영역은 host1에 대해서는 쓰기 잠금(lock)이,
       45. // host2에 대해서는 읽기 잠금(lock_shared)이
       46. // 적용됩니다.
       48. ...
       50. } // lock 객체가 소멸될 때 host1과 host2의 std::shared_mutex가 해제됨.
       51. // host1은 std::shared_mutex::unlock, host2는 std::shared_mutex::unlock_shared 사용

       
       
       SafeLock 예제 코드 접기
       
       
       
     • 자주 사용될 만한 SafeLock의 인스턴스 선언이, 각 스레딩 단위전략 클래스 템플릿의 public 영역에 추가되었습니다.
       
       예제 코드 보기
       
       
       

       1. //-----------------------------------------------------------------------------
       2. // 각 스레딩 단위전략 클래스 템플릿 내에 선언된
       3. // SafeLock의 인스턴스
       5. template <class Host, bool use_read_lock>
       6. class SingleThreaded
       7. {
       8. ...
       10. public:
       12. ...
       14. using ThisThreadingModel = SingleThreaded;
       16. // 싱글 스레드용이므로 아무 일도 하지 않음.
       17. struct StaticLock final : private Private::Uncopyable
       18. {
       19. StaticLock() noexcept = default;
       20. explicit StaticLock(const SingleThreaded&) noexcept {}
       21. };
       23. using StaticWriteLock = StaticLock;
       24. using StaticReadLock = StaticLock;
       25. using Lock = StaticLock;
       27. using WriteLock = SafeLock<SingleThreaded>;
       28. using ReadLock = SafeLock<const SingleThreaded>;
       30. // MakeTypelist_t는 Typelist.h 헤더 항목 참조.
       31. using WriteWriteLock = SafeLock<TL::MakeTypelist_t<SingleThreaded, SingleThreaded>>;
       32. using WriteReadLock = SafeLock<TL::MakeTypelist_t<SingleThreaded, const SingleThreaded>>;
       33. using ReadReadLock = SafeLock<TL::MakeTypelist_t<const SingleThreaded, const SingleThreaded>>;
       35. ...
       37. };
       40. template <class Host, bool use_read_lock>
       41. class ObjectLevelLockable
       42. {
       43. ...
       45. public:
       46. using ThisThreadingModel = ObjectLevelLockable;
       48. // ObjectLevelLockable에는 StaticLock이 없습니다.
       50. using WriteLock = SafeLock<ObjectLevelLockable>;
       51. using ReadLock = SafeLock<const ObjectLevelLockable>;
       52. using Lock = WriteLock;
       54. using WriteWriteLock = SafeLock<TL::MakeTypelist_t<ObjectLevelLockable, ObjectLevelLockable>>;
       55. using WriteReadLock = SafeLock<TL::MakeTypelist_t<ObjectLevelLockable, const ObjectLevelLockable>>;
       56. using ReadReadLock = SafeLock<TL::MakeTypelist_t<const ObjectLevelLockable, const ObjectLevelLockable>>;
       58. ...
       60. };
       63. template <class Host, bool use_read_lock>
       64. class ClassLevelLockable
       65. {
       66. ...
       68. public:
       69. using ThisThreadingModel = ClassLevelLockable;
       71. template <bool read_lock>
       72. class StaticLock final : private Private::Uncopyable
       73. {
       74. public:
       75. StaticLock() noexcept : lock_(*ClassLevelLockable::mtx(), read_lock && use_read_lock) {}
       76. explicit StaticLock(const ClassLevelLockable&) noexcept : StaticLock() {}
       78. private:
       79. SafeLock<NullType> lock_;
       80. };
       82. using StaticWriteLock = StaticLock<false>;
       83. using StaticReadLock = StaticLock<true>;
       84. using Lock = StaticWriteLock;
       86. using WriteLock = SafeLock<ClassLevelLockable>;
       87. using ReadLock = SafeLock<const ClassLevelLockable>;
       89. using WriteWriteLock = SafeLock<TL::MakeTypelist_t<ClassLevelLockable, ClassLevelLockable>>;
       90. using WriteReadLock = SafeLock<TL::MakeTypelist_t<ClassLevelLockable, const ClassLevelLockable>>;
       91. using ReadReadLock = SafeLock<TL::MakeTypelist_t<const ClassLevelLockable, const ClassLevelLockable>>;
       93. ...
       95. };
       99. //-----------------------------------------------------------------------------
       100. // 실 사용 예
       102. template <template <class, bool> class ThreadingModel>
       103. class Host : public ThreadingModel<Host, true>
       104. {
       105. ...
       107. public:
       109. // ThreadingModel이 ObjectLevelLockable이 아닌 경우이고
       110. // 정적 멤버를 읽고 쓰는 함수
       111. static void StaticReadAndWrite(...) {
       112. StaticWriteLock lock;
       114. ...
       115. }
       117. // ThreadingModel이 ObjectLevelLockable이 아닌 경우이고
       118. // 정적 멤버를 읽기만 하는 함수
       119. static void StaticReadOnly(...) {
       120. StaticReadLock lock;
       122. ...
       123. }
       125. // 비상수 멤버 함수
       126. void NonConstMemFn(...) {
       127. WriteLock lock(*this);
       129. ...
       130. }
       132. // 상수 멤버 함수
       133. // this가 상수 객체에 대한 포인터가 아닌 경우
       134. // (상수 멤버 함수가 아닌 경우)
       135. // 컴파일 오류 발생
       136. // 상수 멤버 함수라도 mutable 멤버 등에 접근하여 값을 수정한다면,
       137. // WriteLock을 써야 합니다.
       138. void ConstMemFn(...) const {
       139. ReadLock lock(*this);
       141. ...
       142. }
       144. // 두 개의 객체에 대해 동작하는 멤버 함수
       145. // rhs가 상수 객체에 대한 참조자가 아닌 경우
       146. // 컴파일 오류 발생
       147. Host& operator =(const Host& rhs) & {
       148. WriteReadLock lock(*this, rhs);
       150. ...
       151. }
       153. ...
       155. };
       156.  
       157.  
       158.  
       159. //-----------------------------------------------------------------------------
       160. // WriteWriteLock, WriteReadLock, ReadReadLock에 대해 추가설명
       161.  
       162. // 이 세 타입들은 같은 두 개의 타입에 대해서만 작동합니다.
       163. // 예제 코드를 봅시다.
       164.  
       165. template <template <class, bool> class ThreadingModel>
       166. class Host1 : public ThreadingModel<Host1, true>
       167. { ... };
       168.  
       169. template <template <class, bool> class ThreadingModel>
       170. class Host2 : public ThreadingModel<Host2, true>
       171. {
       172. ...
       174. public:
       175.  
       176. // 올바른 예
       177. Host2& operator =(const Host2& rhs) & {
       178. WriteReadLock lock(*this, rhs); // 문제 없음
       180. ...
       181. }
       182.  
       183. // 잘못된 예
       184. Host2& operator =(const Host1& rhs) & {
       185. WriteReadLock lock(*this, rhs); // 컴파일 오류!!
       186. // *this와 rhs의 타입이 다릅니다.
       187. ...
       188. }
       190. // 잘못된 예를 올바르게 고친 예
       191. Host2& operator =(const Host1& rhs) & {
       192. using TM2 = Host2::ThisThreadingModel;
       193. using TM1 = Host1::ThisThreadingModel;
       194. using WriteReadLockForDiffType = SafeLock<TL::MakeTypelist_t<TM2, const TM1>>;
       196. WriteReadLockForDiffType lock(*this, rhs); // 문제 없음
       198. ...
       199. }
       200. };

       
       
       예제 코드 접기
       
       
       
     • C++20에서 비권장으로 분류된 volatile관련 복합 대입 연산자들을 모두 수정하였습니다.
       
       예제 코드 보기
       
       
       

       1. //-----------------------------------------------------------------------------
       2. // 수정 전
       3.  
       4. template <class Host, bool use_read_lock>
       5. class SingleThreaded
       6. {
       7. ...
       9. public:
       11. ...
       13. static IntType AtomicAdd(volatile IntType& lval, IntType val)
       14. { return lval += val; }
       16. static IntType AtomicSubtract(volatile IntType& lval, IntType val)
       17. { return lval -= val; }
       18.  
       19. static IntType AtomicIncrement(volatile IntType& lval)
       20. { return ++lval; }
       22. static IntType AtomicDecrement(volatile IntType& lval)
       23. { return --lval; }
       25. ...
       27. };
       28.  
       29.  
       30. //-----------------------------------------------------------------------------
       31. // 수정 후(수정된 부분은 굵게 표시하였습니다)
       32.  
       33. template <class Host, bool use_read_lock>
       34. class SingleThreaded
       35. {
       36. ...
       38. public:
       40. ...
       42. static IntType AtomicAdd(volatile IntType& lval, IntType val)
       43. { return lval = lval + val; }
       45. static IntType AtomicSubtract(volatile IntType& lval, IntType val)
       46. { return lval = lval - val; }
       47.  
       48. static IntType AtomicIncrement(volatile IntType& lval)
       49. { return lval = lval + 1; }
       51. static IntType AtomicDecrement(volatile IntType& lval)
       52. { return lval = lval - 1; }
       54. ...
       56. };

       
       
       예제 코드 접기
       
       
       수정된 곳을 보면 멀티스레드 동기화가 전혀 되지 않는 코드란 것을 알 수 있지만, SingleThreaded 단위전략의 정적 멤버함수이기 때문에 문제가 없습니다.
       
       
     • 마지막으로 원자적 정수 연산이 std::atomic<int>를 사용하도록 변경되었습니다. std::atomic<int>는 복사 연산이 금지되어 있으므로, 원자적 연산 함수의 반환 타입과 매개변수 타입들이 값에 의한 전달에서 참조자(혹은 상수 참조자)에 의한 전달로 바뀌었습니다.

  3. Typelist.h

     MakeTypelist가 가변인자 템플릿을 사용하여 템플릿 인자의 개수에 제한이 없도록 수정되었습니다. 또한 MakeTypelist를 비롯한 여러 템플릿들의 별칭 템플릿이 추가되었습니다.
     
     MakeTypelist와 별칭 템플릿 예제 코드 보기
     
     
     

     1. // 이전의 Loki에서는 MakeTypelist에 템플릿 인수를
     2. // 최대 18개 까지만 넘겨줄 수 있었습니다.
     3.  
     4. // C++17을 적용한 Loki의 MakeTypelist는
     5. // 가변인자 템플릿을 적용하여 템플릿 인수의 개수에 제한이 없어졌습니다.
     6.  
     7. using MyTypelist = typename MakeTypelist<T1, T2, T3, .../* 제한 없음 */>::Result
     8.  
     9.  
     10. // 추가로 별칭 템플릿이 추가되어 편의성이 개선되었습니다.
     11. // 별칭 템플릿을 사용하면 위와 같은 작업을 하는 코드를
     12. // 다음처럼 간단하게 작성할 수 있습니다.
     13.  
     14. using MyTypelist = MakeTypelist_t<T1, T2, T3, .../* 제한 없음 */> // 위와 같습니다.

     
     
     MakeTypelist와 별칭 템플릿 예제 코드 접기
     
     
     다음은 새로 추가된 별칭 템플릿의 목록입니다. 순서는 헤더에 선언된 순서를 따릅니다.
     • MakeTypelist_t
     • TypeAt_t
     • TypeAtNonStrict_t
     • Append_t
     • Erase_t
     • EraseAll_t
     • NoDuplicates_t
     • Replace_t
     • ReplaceAll_t
     • Reverse_t
     • MostDerived_t
     • DerivedToFront_t
     별칭 템플릿에 대한 자세한 설명은 Effective Modern C++의 항목 9를 참고하세요.
     
     

  4. TypeManip.h

     Select 템플릿에 대한 별칭 템플릿 Select_t가 추가되었습니다.
     
     별칭 템플릿을 사용하는 예제 코드는 Typelist.h 헤더 항목 에서 찾으실 수 있습니다. 그리고, 별칭 템플릿에 대한 자세한 설명은 Effective Modern C++의 항목 9를 참고하세요.
     
     

• 추가된 구현 파일

  1. Threads.cpp

     Threads.h 헤더에 추가된 SafeLock 클래스 템플릿과 관련된 코드에서, 코드 부풀림을 최소화 하기 위해 중복되는 코드를 함수로 만들어 cpp파일에 따로 넣었습니다. 직접 이 파일에 접근해야 할 일은 거의 없을 것이므로, 크게 신경쓰지 않아도 되는 부분입니다.