From: khizmax Date: Thu, 17 Mar 2016 17:49:33 +0000 (+0300) Subject: Split unit set project to intrusive and non-intrusive ones X-Git-Tag: v2.2.0~342 X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=006e374d9d4cb806741c6a25505466c02f8ccc11;p=libcds.git Split unit set project to intrusive and non-intrusive ones --- diff --git a/projects/Win/vc14/cds.sln b/projects/Win/vc14/cds.sln index a21acd60..e201294d 100644 --- a/projects/Win/vc14/cds.sln +++ b/projects/Win/vc14/cds.sln @@ -210,6 +210,8 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest-set", "gtest-set.vcxp {408FE9BC-44F0-4E6A-89FA-D6F952584239} = {408FE9BC-44F0-4E6A-89FA-D6F952584239} EndProjectSection EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest-intrusive-set", "gtest-intrusive-set.vcxproj", "{EC1EF263-7E34-4867-9ED9-77AA7963CD4A}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Win32 = Debug|Win32 @@ -532,6 +534,18 @@ Global {A589D3F1-A749-4268-ADEC-D0CE13D1E359}.Release|Win32.Build.0 = Release|Win32 {A589D3F1-A749-4268-ADEC-D0CE13D1E359}.Release|x64.ActiveCfg = Release|x64 {A589D3F1-A749-4268-ADEC-D0CE13D1E359}.Release|x64.Build.0 = Release|x64 + {EC1EF263-7E34-4867-9ED9-77AA7963CD4A}.Debug|Win32.ActiveCfg = Debug|Win32 + {EC1EF263-7E34-4867-9ED9-77AA7963CD4A}.Debug|Win32.Build.0 = Debug|Win32 + {EC1EF263-7E34-4867-9ED9-77AA7963CD4A}.Debug|x64.ActiveCfg = Debug|x64 + {EC1EF263-7E34-4867-9ED9-77AA7963CD4A}.Debug|x64.Build.0 = Debug|x64 + {EC1EF263-7E34-4867-9ED9-77AA7963CD4A}.DebugVLD|Win32.ActiveCfg = DebugVLD|Win32 + {EC1EF263-7E34-4867-9ED9-77AA7963CD4A}.DebugVLD|Win32.Build.0 = DebugVLD|Win32 + {EC1EF263-7E34-4867-9ED9-77AA7963CD4A}.DebugVLD|x64.ActiveCfg = DebugVLD|x64 + {EC1EF263-7E34-4867-9ED9-77AA7963CD4A}.DebugVLD|x64.Build.0 = DebugVLD|x64 + {EC1EF263-7E34-4867-9ED9-77AA7963CD4A}.Release|Win32.ActiveCfg = Release|Win32 + {EC1EF263-7E34-4867-9ED9-77AA7963CD4A}.Release|Win32.Build.0 = Release|Win32 + {EC1EF263-7E34-4867-9ED9-77AA7963CD4A}.Release|x64.ActiveCfg = Release|x64 + {EC1EF263-7E34-4867-9ED9-77AA7963CD4A}.Release|x64.Build.0 = Release|x64 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -564,6 +578,7 @@ Global {50B2EC4B-A118-4E7B-ABC7-2EA8B685A58C} = {10E1FAF2-904D-405E-8AB5-6878A1B03346} {51AC349E-B365-4FCF-8778-17A1534E4584} = {10E1FAF2-904D-405E-8AB5-6878A1B03346} {A589D3F1-A749-4268-ADEC-D0CE13D1E359} = {810490B7-31E5-49AE-8455-CAF99A9658B6} + {EC1EF263-7E34-4867-9ED9-77AA7963CD4A} = {810490B7-31E5-49AE-8455-CAF99A9658B6} EndGlobalSection GlobalSection(DPCodeReviewSolutionGUID) = preSolution DPCodeReviewSolutionGUID = {00000000-0000-0000-0000-000000000000} diff --git a/projects/Win/vc14/gtest-intrusive-set.vcxproj b/projects/Win/vc14/gtest-intrusive-set.vcxproj new file mode 100644 index 00000000..ab777d22 --- /dev/null +++ b/projects/Win/vc14/gtest-intrusive-set.vcxproj @@ -0,0 +1,417 @@ + + + + + DebugVLD + Win32 + + + DebugVLD + x64 + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + + + + + + + + + + + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + + + + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + + + + + + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + + + + + + + + + + + + + + + + + + + {EC1EF263-7E34-4867-9ED9-77AA7963CD4A} + Win32Proj + intrusive_set + 8.1 + + + + Application + true + v140 + Unicode + + + Application + true + v140 + Unicode + + + Application + false + v140 + true + Unicode + + + Application + true + v140 + Unicode + + + Application + true + v140 + Unicode + + + Application + false + v140 + true + Unicode + + + + + + + + + + + + + + + + + + + + + + + + + + + true + $(SolutionDir)..\..\..\bin\vc.$(PlatformToolset)\$(Platform)\ + $(SolutionDir)..\..\..\obj\vc.$(PlatformToolset)\$(Platform)\$(ProjectName)\$(Configuration)\ + $(ProjectName)_d + + + true + $(SolutionDir)..\..\..\bin\vc.$(PlatformToolset)\$(Platform)\ + $(SolutionDir)..\..\..\obj\vc.$(PlatformToolset)\$(Platform)\$(ProjectName)\$(Configuration)\ + $(ProjectName)_d + + + true + $(SolutionDir)..\..\..\bin\vc.$(PlatformToolset)\$(Platform)\ + $(SolutionDir)..\..\..\obj\vc.$(PlatformToolset)\$(Platform)\$(ProjectName)\$(Configuration)\ + $(ProjectName)_d + + + true + $(SolutionDir)..\..\..\bin\vc.$(PlatformToolset)\$(Platform)\ + $(SolutionDir)..\..\..\obj\vc.$(PlatformToolset)\$(Platform)\$(ProjectName)\$(Configuration)\ + $(ProjectName)_d + + + false + $(SolutionDir)..\..\..\bin\vc.$(PlatformToolset)\$(Platform)-release\ + $(SolutionDir)..\..\..\obj\vc.$(PlatformToolset)\$(Platform)\$(ProjectName)\$(Configuration)\ + + + false + $(SolutionDir)..\..\..\bin\vc.$(PlatformToolset)\$(Platform)-release\ + $(SolutionDir)..\..\..\obj\vc.$(PlatformToolset)\$(Platform)\$(ProjectName)\$(Configuration)\ + + + + NotUsing + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + $(SolutionDir)..\..\..;$(GTEST_ROOT)/include;$(SolutionDir)..\..\..\test\include;$(BOOST_PATH);%(AdditionalIncludeDirectories) + + + Console + true + $(GTEST_LIB32);$(GTEST_ROOT)/lib/x86;$(BOOST_PATH)/stage32/lib;$(BOOST_PATH)/stage/lib;$(BOOST_PATH)/bin;%(AdditionalLibraryDirectories);$(OutDir) + gtestd.lib;%(AdditionalDependencies) + + + + + NotUsing + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + $(SolutionDir)..\..\..;$(GTEST_ROOT)/include;$(SolutionDir)..\..\..\test\include;$(BOOST_PATH);%(AdditionalIncludeDirectories) + + + Console + true + $(GTEST_LIB32);$(GTEST_ROOT)/lib/x86;$(BOOST_PATH)/stage32/lib;$(BOOST_PATH)/stage/lib;$(BOOST_PATH)/bin;%(AdditionalLibraryDirectories);$(OutDir) + gtestd.lib;%(AdditionalDependencies) + + + + + NotUsing + Level3 + Disabled + _DEBUG;_CONSOLE;%(PreprocessorDefinitions) + $(SolutionDir)..\..\..;$(GTEST_ROOT)/include;$(SolutionDir)..\..\..\test\include;$(BOOST_PATH);%(AdditionalIncludeDirectories) + + + Console + true + $(GTEST_LIB64);$(GTEST_ROOT)/lib/x64;$(BOOST_PATH)/stage64/lib;$(BOOST_PATH)/bin;%(AdditionalLibraryDirectories);$(OutDir) + gtestd.lib;%(AdditionalDependencies) + + + + + NotUsing + Level3 + Disabled + _DEBUG;_CONSOLE;%(PreprocessorDefinitions) + $(SolutionDir)..\..\..;$(GTEST_ROOT)/include;$(SolutionDir)..\..\..\test\include;$(BOOST_PATH);%(AdditionalIncludeDirectories) + + + Console + true + $(GTEST_LIB64);$(GTEST_ROOT)/lib/x64;$(BOOST_PATH)/stage64/lib;$(BOOST_PATH)/bin;%(AdditionalLibraryDirectories);$(OutDir) + gtestd.lib;%(AdditionalDependencies) + + + + + Level3 + NotUsing + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + $(SolutionDir)..\..\..;$(GTEST_ROOT)/include;$(SolutionDir)..\..\..\test\include;$(BOOST_PATH);%(AdditionalIncludeDirectories) + + + Console + true + true + true + $(GTEST_LIB32);$(GTEST_ROOT)/lib/x86;$(BOOST_PATH)/stage32/lib;$(BOOST_PATH)/stage/lib;$(BOOST_PATH)/bin;%(AdditionalLibraryDirectories);$(OutDir) + gtest.lib;%(AdditionalDependencies) + + + + + Level3 + NotUsing + MaxSpeed + true + true + NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + $(SolutionDir)..\..\..;$(GTEST_ROOT)/include;$(SolutionDir)..\..\..\test\include;$(BOOST_PATH);%(AdditionalIncludeDirectories) + + + Console + true + true + true + $(GTEST_LIB64);$(GTEST_ROOT)/lib/x64;$(BOOST_PATH)/stage64/lib;$(BOOST_PATH)/bin;%(AdditionalLibraryDirectories);$(OutDir) + gtest.lib;%(AdditionalDependencies) + + + + + + \ No newline at end of file diff --git a/projects/Win/vc14/gtest-intrusive-set.vcxproj.filters b/projects/Win/vc14/gtest-intrusive-set.vcxproj.filters new file mode 100644 index 00000000..b1946eca --- /dev/null +++ b/projects/Win/vc14/gtest-intrusive-set.vcxproj.filters @@ -0,0 +1,216 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {9f3cc5d8-7142-4a8e-a520-512911312b13} + + + {9c07e86e-bd5b-4ae1-a730-c768234ba9f0} + + + {852d2603-551b-460b-b17f-f370d91f79e7} + + + {619a4db2-c9a0-44eb-bbcf-842ed42d4172} + + + + + Source Files + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\SplitList + + + Source Files\SplitList + + + Source Files\SplitList + + + Source Files\SplitList + + + Source Files\SplitList + + + Source Files\SplitList + + + Source Files\SplitList + + + Source Files\SplitList + + + Source Files\SplitList + + + Source Files\SplitList + + + Source Files\SplitList + + + Source Files\SplitList + + + Source Files\SplitList + + + Source Files\SplitList + + + Source Files\SplitList + + + Source Files\SplitList + + + Source Files\SkipList + + + Source Files\SkipList + + + Source Files\SkipList + + + Source Files\SkipList + + + Source Files\SkipList + + + Source Files\SkipList + + + Source Files\SkipList + + + Source Files\SkipList + + + Source Files\FeldmanHashSet + + + Source Files\FeldmanHashSet + + + Source Files\FeldmanHashSet + + + Source Files\FeldmanHashSet + + + Source Files\FeldmanHashSet + + + Source Files\FeldmanHashSet + + + Source Files\FeldmanHashSet + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + \ No newline at end of file diff --git a/projects/Win/vc14/gtest-set.vcxproj b/projects/Win/vc14/gtest-set.vcxproj index ff2d3cba..c7bdd9a9 100644 --- a/projects/Win/vc14/gtest-set.vcxproj +++ b/projects/Win/vc14/gtest-set.vcxproj @@ -28,17 +28,10 @@ - - - - - - - - - - - + + + + 4503 4503 4503 @@ -46,8 +39,8 @@ 4503 4503 - - + + 4503 4503 4503 @@ -55,186 +48,14 @@ 4503 4503 - - - - - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - - - - - - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - - - - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - - 4503 - 4503 - 4503 - 4503 - 4503 - 4503 - - - + + - - - - - - - - - - - - - - - - - + + + + {A589D3F1-A749-4268-ADEC-D0CE13D1E359} diff --git a/projects/Win/vc14/gtest-set.vcxproj.filters b/projects/Win/vc14/gtest-set.vcxproj.filters index f968bd71..258217f1 100644 --- a/projects/Win/vc14/gtest-set.vcxproj.filters +++ b/projects/Win/vc14/gtest-set.vcxproj.filters @@ -13,18 +13,6 @@ {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms - - {9f3cc5d8-7142-4a8e-a520-512911312b13} - - - {619a4db2-c9a0-44eb-bbcf-842ed42d4172} - - - {9c07e86e-bd5b-4ae1-a730-c768234ba9f0} - - - {852d2603-551b-460b-b17f-f370d91f79e7} - {4c75be9d-6104-435d-b08f-09fa33b2bfcc} @@ -33,222 +21,42 @@ Source Files - - Source Files\intrsive:MichaelSet - - - Source Files\intrsive:MichaelSet - - - Source Files\intrsive:MichaelSet - - - Source Files\intrsive:MichaelSet - - - Source Files\intrsive:MichaelSet - - - Source Files\intrsive:MichaelSet - - - Source Files\intrsive:MichaelSet - - - Source Files\intrsive:MichaelSet - - - Source Files\intrsive:MichaelSet - - - Source Files\intrsive:MichaelSet - - - Source Files\intrsive:MichaelSet - - - Source Files\intrsive:MichaelSet - - - Source Files\intrsive:MichaelSet - - - Source Files\intrsive:MichaelSet - - - Source Files\intrsive:MichaelSet - - - Source Files\intrsive:MichaelSet - - - Source Files\intrusive:SplitList - - - Source Files\intrusive:SplitList - - - Source Files\intrusive:SplitList - - - Source Files\intrusive:SplitList - - - Source Files\intrusive:SplitList - - - Source Files\intrusive:SplitList - - - Source Files\intrusive:SplitList - - - Source Files\intrusive:SplitList - - - Source Files\intrusive:SplitList - - - Source Files\intrusive:SplitList - - - Source Files\intrusive:SplitList - - - Source Files\intrusive:SplitList - - - Source Files\intrusive:SplitList - - - Source Files\intrusive:SplitList - - - Source Files\intrusive:SplitList - - - Source Files\intrusive:SplitList - - - Source Files\intrusive::SkipList - - - Source Files\intrusive::SkipList - - - Source Files\intrusive::SkipList - - - Source Files\intrusive::SkipList - - - Source Files\intrusive::SkipList - - - Source Files\intrusive::SkipList - - - Source Files\intrusive::SkipList - - - Source Files\intrusive::SkipList - - - Source Files\intrusive:FeldmanHashSet - - - Source Files\intrusive:FeldmanHashSet - - - Source Files\intrusive:FeldmanHashSet - - - Source Files\intrusive:FeldmanHashSet - - - Source Files\intrusive:FeldmanHashSet - - - Source Files\intrusive:FeldmanHashSet - - - Source Files\intrusive:FeldmanHashSet - - + Source Files\MichaelSet - + Source Files\MichaelSet - + Source Files\MichaelSet - + Source Files\MichaelSet - + Source Files\MichaelSet - + Source Files\MichaelSet - + Source Files\MichaelSet - + Source Files\MichaelSet - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - + Header Files - + Header Files - + Header Files - + Header Files diff --git a/test/unit/CMakeLists.txt b/test/unit/CMakeLists.txt index 8be50916..fb88bf81 100644 --- a/test/unit/CMakeLists.txt +++ b/test/unit/CMakeLists.txt @@ -2,5 +2,6 @@ add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/deque) add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/list) add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/pqueue) add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/queue) +add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/intrusive-set) add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/set) add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/stack) diff --git a/test/unit/intrusive-set/CMakeLists.txt b/test/unit/intrusive-set/CMakeLists.txt new file mode 100644 index 00000000..c01513ef --- /dev/null +++ b/test/unit/intrusive-set/CMakeLists.txt @@ -0,0 +1,77 @@ +set(PACKAGE_NAME unit-intrusive-set) + +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-invalid-offsetof") + +set(CDSGTEST_SET_SOURCES + ../main.cpp + intrusive_feldman_hashset_hp.cpp + intrusive_feldman_hashset_dhp.cpp + intrusive_feldman_hashset_rcu_gpb.cpp + intrusive_feldman_hashset_rcu_gpi.cpp + intrusive_feldman_hashset_rcu_gpt.cpp + intrusive_feldman_hashset_rcu_shb.cpp + intrusive_feldman_hashset_rcu_sht.cpp + intrusive_michael_lazy_hp.cpp + intrusive_michael_lazy_dhp.cpp + intrusive_michael_lazy_nogc.cpp + intrusive_michael_lazy_rcu_gpb.cpp + intrusive_michael_lazy_rcu_gpi.cpp + intrusive_michael_lazy_rcu_gpt.cpp + intrusive_michael_lazy_rcu_shb.cpp + intrusive_michael_lazy_rcu_sht.cpp + intrusive_michael_michael_hp.cpp + intrusive_michael_michael_dhp.cpp + intrusive_michael_michael_nogc.cpp + intrusive_michael_michael_rcu_gpb.cpp + intrusive_michael_michael_rcu_gpi.cpp + intrusive_michael_michael_rcu_gpt.cpp + intrusive_michael_michael_rcu_shb.cpp + intrusive_michael_michael_rcu_sht.cpp + intrusive_skiplist_hp.cpp + intrusive_skiplist_dhp.cpp + intrusive_skiplist_nogc.cpp + intrusive_skiplist_rcu_gpb.cpp + intrusive_skiplist_rcu_gpi.cpp + intrusive_skiplist_rcu_gpt.cpp + intrusive_skiplist_rcu_shb.cpp + intrusive_skiplist_rcu_sht.cpp + intrusive_split_lazy_hp.cpp + intrusive_split_lazy_dhp.cpp + intrusive_split_lazy_nogc.cpp + intrusive_split_lazy_rcu_gpb.cpp + intrusive_split_lazy_rcu_gpi.cpp + intrusive_split_lazy_rcu_gpt.cpp + intrusive_split_lazy_rcu_shb.cpp + intrusive_split_lazy_rcu_sht.cpp + intrusive_split_michael_hp.cpp + intrusive_split_michael_dhp.cpp + intrusive_split_michael_nogc.cpp + intrusive_split_michael_rcu_gpb.cpp + intrusive_split_michael_rcu_gpi.cpp + intrusive_split_michael_rcu_gpt.cpp + intrusive_split_michael_rcu_shb.cpp + intrusive_split_michael_rcu_sht.cpp + michael_michael_hp.cpp + michael_michael_dhp.cpp + michael_michael_nogc.cpp + michael_michael_rcu_gpb.cpp + michael_michael_rcu_gpi.cpp + michael_michael_rcu_gpt.cpp + michael_michael_rcu_shb.cpp + michael_michael_rcu_sht.cpp +) + +include_directories( + ${CMAKE_CURRENT_SOURCE_DIR} +) + +add_executable(${PACKAGE_NAME} ${CDSGTEST_SET_SOURCES}) +target_link_libraries(${PACKAGE_NAME} + ${CDS_SHARED_LIBRARY} + ${GTEST_LIBRARY} + ${Boost_THREAD_LIBRARY} + ${Boost_SYSTEM_LIBRARY} + ${CMAKE_THREAD_LIBS_INIT} +) + +add_test(NAME ${PACKAGE_NAME} COMMAND ${PACKAGE_NAME} WORKING_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}) \ No newline at end of file diff --git a/test/unit/intrusive-set/intrusive_feldman_hashset_dhp.cpp b/test/unit/intrusive-set/intrusive_feldman_hashset_dhp.cpp new file mode 100644 index 00000000..c2e6a6b7 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_feldman_hashset_dhp.cpp @@ -0,0 +1,146 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_feldman_hashset_hp.h" + +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::DHP gc_type; + + class IntrusiveFeldmanHashSet_DHP : public cds_test::intrusive_feldman_hashset_hp + { + protected: + typedef cds_test::intrusive_feldman_hashset_hp base_class; + + protected: + + void SetUp() + { + typedef ci::FeldmanHashSet< gc_type, int_item, + typename ci::feldman_hashset::make_traits< + ci::feldman_hashset::hash_accessor< hash_accessor > + ,ci::opt::less< std::less> + ,ci::opt::disposer + >::type + > set_type; + + cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::dhp::GarbageCollector::Destruct(); + } + }; + + TEST_F( IntrusiveFeldmanHashSet_DHP, compare ) + { + struct traits : public ci::feldman_hashset::traits + { + typedef base_class::hash_accessor hash_accessor; + typedef cmp compare; + typedef mock_disposer disposer; + }; + + typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveFeldmanHashSet_DHP, less ) + { + typedef ci::FeldmanHashSet< gc_type, int_item, + typename ci::feldman_hashset::make_traits< + ci::feldman_hashset::hash_accessor< hash_accessor > + , ci::opt::less< std::less> + , ci::opt::disposer + >::type + > set_type; + + set_type s( 5, 2 ); + test( s ); + } + + TEST_F( IntrusiveFeldmanHashSet_DHP, cmpmix ) + { + struct traits : public ci::feldman_hashset::traits + { + typedef base_class::hash_accessor hash_accessor; + typedef cmp compare; + typedef std::less less; + typedef mock_disposer disposer; + typedef simple_item_counter item_counter; + }; + + typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type; + + set_type s( 3, 4 ); + test( s ); + } + + TEST_F( IntrusiveFeldmanHashSet_DHP, backoff ) + { + struct traits : public ci::feldman_hashset::traits + { + typedef base_class::hash_accessor hash_accessor; + typedef cmp compare; + typedef mock_disposer disposer; + typedef cds::backoff::empty back_off; + typedef ci::opt::v::sequential_consistent memory_model; + }; + + typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type; + + set_type s( 8, 3 ); + test( s ); + } + + TEST_F( IntrusiveFeldmanHashSet_DHP, stat ) + { + struct traits : public ci::feldman_hashset::traits + { + typedef base_class::hash_accessor hash_accessor; + typedef cmp compare; + typedef mock_disposer disposer; + typedef ci::feldman_hashset::stat<> stat; + }; + + typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type; + + set_type s( 8, 3 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_feldman_hashset_hp.cpp b/test/unit/intrusive-set/intrusive_feldman_hashset_hp.cpp new file mode 100644 index 00000000..e9ca7b5e --- /dev/null +++ b/test/unit/intrusive-set/intrusive_feldman_hashset_hp.cpp @@ -0,0 +1,147 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_feldman_hashset_hp.h" + +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::HP gc_type; + + class IntrusiveFeldmanHashSet_HP : public cds_test::intrusive_feldman_hashset_hp + { + protected: + typedef cds_test::intrusive_feldman_hashset_hp base_class; + + protected: + + void SetUp() + { + typedef ci::FeldmanHashSet< gc_type, int_item, + typename ci::feldman_hashset::make_traits< + ci::feldman_hashset::hash_accessor< hash_accessor > + ,ci::opt::less< std::less> + ,ci::opt::disposer + >::type + > set_type; + + // +1 - for guarded_ptr + cds::gc::hp::GarbageCollector::Construct( set_type::c_nHazardPtrCount + 1, 1, 16 ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::hp::GarbageCollector::Destruct( true ); + } + }; + + TEST_F( IntrusiveFeldmanHashSet_HP, compare ) + { + struct traits : public ci::feldman_hashset::traits + { + typedef base_class::hash_accessor hash_accessor; + typedef cmp compare; + typedef mock_disposer disposer; + }; + + typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveFeldmanHashSet_HP, less ) + { + typedef ci::FeldmanHashSet< gc_type, int_item, + typename ci::feldman_hashset::make_traits< + ci::feldman_hashset::hash_accessor< hash_accessor > + , ci::opt::less< std::less> + , ci::opt::disposer + >::type + > set_type; + + set_type s( 5, 2 ); + test( s ); + } + + TEST_F( IntrusiveFeldmanHashSet_HP, cmpmix ) + { + struct traits : public ci::feldman_hashset::traits + { + typedef base_class::hash_accessor hash_accessor; + typedef cmp compare; + typedef std::less less; + typedef mock_disposer disposer; + typedef simple_item_counter item_counter; + }; + + typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type; + + set_type s( 3, 4 ); + test( s ); + } + + TEST_F( IntrusiveFeldmanHashSet_HP, backoff ) + { + struct traits : public ci::feldman_hashset::traits + { + typedef base_class::hash_accessor hash_accessor; + typedef cmp compare; + typedef mock_disposer disposer; + typedef cds::backoff::empty back_off; + typedef ci::opt::v::sequential_consistent memory_model; + }; + + typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type; + + set_type s( 8, 3 ); + test( s ); + } + + TEST_F( IntrusiveFeldmanHashSet_HP, stat ) + { + struct traits : public ci::feldman_hashset::traits + { + typedef base_class::hash_accessor hash_accessor; + typedef cmp compare; + typedef mock_disposer disposer; + typedef ci::feldman_hashset::stat<> stat; + }; + + typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type; + + set_type s( 8, 3 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_feldman_hashset_rcu_gpb.cpp b/test/unit/intrusive-set/intrusive_feldman_hashset_rcu_gpb.cpp new file mode 100644 index 00000000..35c432e7 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_feldman_hashset_rcu_gpb.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_feldman_hashset_rcu.h" + +namespace { + + typedef cds::urcu::general_buffered<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPB, IntrusiveFeldmanHashSet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_feldman_hashset_rcu_gpi.cpp b/test/unit/intrusive-set/intrusive_feldman_hashset_rcu_gpi.cpp new file mode 100644 index 00000000..e0114f8e --- /dev/null +++ b/test/unit/intrusive-set/intrusive_feldman_hashset_rcu_gpi.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_feldman_hashset_rcu.h" + +namespace { + + typedef cds::urcu::general_instant<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPI, IntrusiveFeldmanHashSet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_feldman_hashset_rcu_gpt.cpp b/test/unit/intrusive-set/intrusive_feldman_hashset_rcu_gpt.cpp new file mode 100644 index 00000000..a152be57 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_feldman_hashset_rcu_gpt.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_feldman_hashset_rcu.h" + +namespace { + + typedef cds::urcu::general_threaded<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPT, IntrusiveFeldmanHashSet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_feldman_hashset_rcu_shb.cpp b/test/unit/intrusive-set/intrusive_feldman_hashset_rcu_shb.cpp new file mode 100644 index 00000000..93e357da --- /dev/null +++ b/test/unit/intrusive-set/intrusive_feldman_hashset_rcu_shb.cpp @@ -0,0 +1,45 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + +#include "test_intrusive_feldman_hashset_rcu.h" + +namespace { + + typedef cds::urcu::signal_buffered<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHB, IntrusiveFeldmanHashSet, rcu_implementation ); + +#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/intrusive-set/intrusive_feldman_hashset_rcu_sht.cpp b/test/unit/intrusive-set/intrusive_feldman_hashset_rcu_sht.cpp new file mode 100644 index 00000000..ecd281af --- /dev/null +++ b/test/unit/intrusive-set/intrusive_feldman_hashset_rcu_sht.cpp @@ -0,0 +1,45 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + +#include "test_intrusive_feldman_hashset_rcu.h" + +namespace { + + typedef cds::urcu::signal_threaded<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHT, IntrusiveFeldmanHashSet, rcu_implementation ); + +#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/intrusive-set/intrusive_michael_lazy_dhp.cpp b/test/unit/intrusive-set/intrusive_michael_lazy_dhp.cpp new file mode 100644 index 00000000..633001a0 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_michael_lazy_dhp.cpp @@ -0,0 +1,254 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_set_hp.h" + +#include +#include + +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::DHP gc_type; + + class IntrusiveMichaelLazySet_DHP : public cds_test::intrusive_set_hp + { + protected: + typedef cds_test::intrusive_set_hp base_class; + + protected: + typedef typename base_class::base_int_item< ci::lazy_list::node> base_item_type; + typedef typename base_class::base_int_item< ci::lazy_list::node> base_mutex_item_type; + typedef typename base_class::member_int_item< ci::lazy_list::node> member_item_type; + typedef typename base_class::member_int_item< ci::lazy_list::node> member_mutex_item_type; + + void SetUp() + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc> hook; + }; + typedef ci::LazyList< gc_type, base_item_type, list_traits > list_type; + typedef ci::MichaelHashSet< gc_type, list_type > set_type; + + cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::dhp::GarbageCollector::Destruct(); + } + }; + + + TEST_F( IntrusiveMichaelLazySet_DHP, base_cmp ) + { + typedef ci::LazyList< gc_type + , base_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type > > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + ,ci::opt::back_off< cds::backoff::pause > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_DHP, base_less ) + { + typedef ci::LazyList< gc_type + , base_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type >>> + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_DHP, base_cmpmix ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, base_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_DHP, base_mutex ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc, ci::opt::lock_type> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, base_mutex_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + + TEST_F( IntrusiveMichaelLazySet_DHP, member_cmp ) + { + typedef ci::LazyList< gc_type + ,member_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_DHP, member_less ) + { + typedef ci::LazyList< gc_type + , member_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_DHP, member_cmpmix ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, member_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_DHP, member_mutex ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc, ci::opt::lock_type> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, member_mutex_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_michael_lazy_hp.cpp b/test/unit/intrusive-set/intrusive_michael_lazy_hp.cpp new file mode 100644 index 00000000..6583d32d --- /dev/null +++ b/test/unit/intrusive-set/intrusive_michael_lazy_hp.cpp @@ -0,0 +1,255 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_set_hp.h" + +#include +#include + +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::HP gc_type; + + class IntrusiveMichaelLazySet_HP : public cds_test::intrusive_set_hp + { + protected: + typedef cds_test::intrusive_set_hp base_class; + + protected: + typedef typename base_class::base_int_item< ci::lazy_list::node> base_item_type; + typedef typename base_class::base_int_item< ci::lazy_list::node> base_mutex_item_type; + typedef typename base_class::member_int_item< ci::lazy_list::node> member_item_type; + typedef typename base_class::member_int_item< ci::lazy_list::node> member_mutex_item_type; + + void SetUp() + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc> hook; + }; + typedef ci::LazyList< gc_type, base_item_type, list_traits > list_type; + typedef ci::MichaelHashSet< gc_type, list_type > set_type; + + // +1 - for guarded_ptr + cds::gc::hp::GarbageCollector::Construct( set_type::c_nHazardPtrCount + 1, 1, 16 ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::hp::GarbageCollector::Destruct( true ); + } + }; + + + TEST_F( IntrusiveMichaelLazySet_HP, base_cmp ) + { + typedef ci::LazyList< gc_type + , base_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type > > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + ,ci::opt::back_off< cds::backoff::pause > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_HP, base_less ) + { + typedef ci::LazyList< gc_type + , base_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type >>> + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_HP, base_cmpmix ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, base_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_HP, base_mutex ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc, ci::opt::lock_type> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, base_mutex_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + + TEST_F( IntrusiveMichaelLazySet_HP, member_cmp ) + { + typedef ci::LazyList< gc_type + ,member_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_HP, member_less ) + { + typedef ci::LazyList< gc_type + , member_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_HP, member_cmpmix ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, member_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_HP, member_mutex ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc, ci::opt::lock_type> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, member_mutex_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_michael_lazy_nogc.cpp b/test/unit/intrusive-set/intrusive_michael_lazy_nogc.cpp new file mode 100644 index 00000000..c183de4f --- /dev/null +++ b/test/unit/intrusive-set/intrusive_michael_lazy_nogc.cpp @@ -0,0 +1,241 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_set_nogc.h" + +#include +#include + +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::nogc gc_type; + + class IntrusiveMichaelLazySet_NoGC : public cds_test::intrusive_set_nogc + { + protected: + typedef cds_test::intrusive_set_nogc base_class; + + protected: + typedef typename base_class::base_int_item< ci::lazy_list::node> base_item_type; + typedef typename base_class::base_int_item< ci::lazy_list::node> base_mutex_item_type; + typedef typename base_class::member_int_item< ci::lazy_list::node> member_item_type; + typedef typename base_class::member_int_item< ci::lazy_list::node> member_mutex_item_type; + + //void SetUp() + //{} + + //void TearDown() + //{} + }; + + + TEST_F( IntrusiveMichaelLazySet_NoGC, base_cmp ) + { + typedef ci::LazyList< gc_type + , base_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type > > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + ,ci::opt::back_off< cds::backoff::pause > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_NoGC, base_less ) + { + typedef ci::LazyList< gc_type + , base_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type >>> + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_NoGC, base_cmpmix ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, base_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_NoGC, base_mutex ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc, ci::opt::lock_type> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, base_mutex_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + + TEST_F( IntrusiveMichaelLazySet_NoGC, member_cmp ) + { + typedef ci::LazyList< gc_type + ,member_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_NoGC, member_less ) + { + typedef ci::LazyList< gc_type + , member_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_NoGC, member_cmpmix ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, member_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelLazySet_NoGC, member_mutex ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc, ci::opt::lock_type> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, member_mutex_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_michael_lazy_rcu_gpb.cpp b/test/unit/intrusive-set/intrusive_michael_lazy_rcu_gpb.cpp new file mode 100644 index 00000000..f2662d23 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_michael_lazy_rcu_gpb.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_michael_lazy_rcu.h" + +namespace { + + typedef cds::urcu::general_buffered<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPB, IntrusiveMichaelLazySet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_michael_lazy_rcu_gpi.cpp b/test/unit/intrusive-set/intrusive_michael_lazy_rcu_gpi.cpp new file mode 100644 index 00000000..b35171ae --- /dev/null +++ b/test/unit/intrusive-set/intrusive_michael_lazy_rcu_gpi.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_michael_lazy_rcu.h" + +namespace { + + typedef cds::urcu::general_instant<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPI, IntrusiveMichaelLazySet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_michael_lazy_rcu_gpt.cpp b/test/unit/intrusive-set/intrusive_michael_lazy_rcu_gpt.cpp new file mode 100644 index 00000000..76ff2f07 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_michael_lazy_rcu_gpt.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_michael_lazy_rcu.h" + +namespace { + + typedef cds::urcu::general_threaded<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPT, IntrusiveMichaelLazySet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_michael_lazy_rcu_shb.cpp b/test/unit/intrusive-set/intrusive_michael_lazy_rcu_shb.cpp new file mode 100644 index 00000000..a7728a2e --- /dev/null +++ b/test/unit/intrusive-set/intrusive_michael_lazy_rcu_shb.cpp @@ -0,0 +1,46 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + +#include "test_intrusive_michael_lazy_rcu.h" + +namespace { + + typedef cds::urcu::signal_buffered<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHB, IntrusiveMichaelLazySet, rcu_implementation ); + +#endif // #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + diff --git a/test/unit/intrusive-set/intrusive_michael_lazy_rcu_sht.cpp b/test/unit/intrusive-set/intrusive_michael_lazy_rcu_sht.cpp new file mode 100644 index 00000000..16c00ba1 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_michael_lazy_rcu_sht.cpp @@ -0,0 +1,46 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + +#include "test_intrusive_michael_lazy_rcu.h" + +namespace { + + typedef cds::urcu::signal_threaded<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHT, IntrusiveMichaelLazySet, rcu_implementation ); + +#endif // #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + diff --git a/test/unit/intrusive-set/intrusive_michael_michael_dhp.cpp b/test/unit/intrusive-set/intrusive_michael_michael_dhp.cpp new file mode 100644 index 00000000..035c21f1 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_michael_michael_dhp.cpp @@ -0,0 +1,205 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_set_hp.h" + +#include +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::DHP gc_type; + + class IntrusiveMichaelSet_DHP : public cds_test::intrusive_set_hp + { + protected: + typedef cds_test::intrusive_set_hp base_class; + + protected: + typedef typename base_class::base_int_item< ci::michael_list::node> base_item_type; + typedef typename base_class::member_int_item< ci::michael_list::node> member_item_type; + + void SetUp() + { + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::base_hook< ci::opt::gc> hook; + }; + typedef ci::MichaelList< gc_type, base_item_type, list_traits > list_type; + typedef ci::MichaelHashSet< gc_type, list_type > set_type; + + cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::dhp::GarbageCollector::Destruct(); + } + }; + + + TEST_F( IntrusiveMichaelSet_DHP, base_cmp ) + { + typedef ci::MichaelList< gc_type + , base_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type >>> + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelSet_DHP, base_less ) + { + typedef ci::MichaelList< gc_type + , base_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type >>> + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelSet_DHP, base_cmpmix ) + { + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::base_hook< ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::MichaelList< gc_type, base_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + + TEST_F( IntrusiveMichaelSet_DHP, member_cmp ) + { + typedef ci::MichaelList< gc_type + ,member_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelSet_DHP, member_less ) + { + typedef ci::MichaelList< gc_type + , member_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelSet_DHP, member_cmpmix ) + { + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::MichaelList< gc_type, member_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_michael_michael_hp.cpp b/test/unit/intrusive-set/intrusive_michael_michael_hp.cpp new file mode 100644 index 00000000..a97824d3 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_michael_michael_hp.cpp @@ -0,0 +1,206 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_set_hp.h" + +#include +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::HP gc_type; + + class IntrusiveMichaelSet_HP : public cds_test::intrusive_set_hp + { + protected: + typedef cds_test::intrusive_set_hp base_class; + + protected: + typedef typename base_class::base_int_item< ci::michael_list::node> base_item_type; + typedef typename base_class::member_int_item< ci::michael_list::node> member_item_type; + + void SetUp() + { + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::base_hook< ci::opt::gc> hook; + }; + typedef ci::MichaelList< gc_type, base_item_type, list_traits > list_type; + typedef ci::MichaelHashSet< gc_type, list_type > set_type; + + // +1 - for guarded_ptr + cds::gc::hp::GarbageCollector::Construct( set_type::c_nHazardPtrCount + 1, 1, 16 ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::hp::GarbageCollector::Destruct( true ); + } + }; + + + TEST_F( IntrusiveMichaelSet_HP, base_cmp ) + { + typedef ci::MichaelList< gc_type + , base_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type > > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelSet_HP, base_less ) + { + typedef ci::MichaelList< gc_type + , base_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type >>> + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelSet_HP, base_cmpmix ) + { + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::base_hook< ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::MichaelList< gc_type, base_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + + TEST_F( IntrusiveMichaelSet_HP, member_cmp ) + { + typedef ci::MichaelList< gc_type + ,member_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelSet_HP, member_less ) + { + typedef ci::MichaelList< gc_type + , member_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelSet_HP, member_cmpmix ) + { + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::MichaelList< gc_type, member_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_michael_michael_nogc.cpp b/test/unit/intrusive-set/intrusive_michael_michael_nogc.cpp new file mode 100644 index 00000000..2ce9e2b2 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_michael_michael_nogc.cpp @@ -0,0 +1,192 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_set_nogc.h" + +#include +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::nogc gc_type; + + class IntrusiveMichaelSet_NoGC : public cds_test::intrusive_set_nogc + { + protected: + typedef cds_test::intrusive_set_nogc base_class; + + protected: + typedef typename base_class::base_int_item< ci::michael_list::node> base_item_type; + typedef typename base_class::member_int_item< ci::michael_list::node> member_item_type; + + //void SetUp() + //{} + + //void TearDown() + //{} + }; + + + TEST_F( IntrusiveMichaelSet_NoGC, base_cmp ) + { + typedef ci::MichaelList< gc_type + , base_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type > > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelSet_NoGC, base_less ) + { + typedef ci::MichaelList< gc_type + , base_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type >>> + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelSet_NoGC, base_cmpmix ) + { + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::base_hook< ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::MichaelList< gc_type, base_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + + TEST_F( IntrusiveMichaelSet_NoGC, member_cmp ) + { + typedef ci::MichaelList< gc_type + ,member_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelSet_NoGC, member_less ) + { + typedef ci::MichaelList< gc_type + , member_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< gc_type, bucket_type, + ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveMichaelSet_NoGC, member_cmpmix ) + { + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::MichaelList< gc_type, member_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_michael_michael_rcu_gpb.cpp b/test/unit/intrusive-set/intrusive_michael_michael_rcu_gpb.cpp new file mode 100644 index 00000000..e8d6f68d --- /dev/null +++ b/test/unit/intrusive-set/intrusive_michael_michael_rcu_gpb.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_michael_michael_rcu.h" + +namespace { + + typedef cds::urcu::general_buffered<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPB, IntrusiveMichaelSet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_michael_michael_rcu_gpi.cpp b/test/unit/intrusive-set/intrusive_michael_michael_rcu_gpi.cpp new file mode 100644 index 00000000..3e65ce11 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_michael_michael_rcu_gpi.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_michael_michael_rcu.h" + +namespace { + + typedef cds::urcu::general_instant<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPI, IntrusiveMichaelSet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_michael_michael_rcu_gpt.cpp b/test/unit/intrusive-set/intrusive_michael_michael_rcu_gpt.cpp new file mode 100644 index 00000000..b397529a --- /dev/null +++ b/test/unit/intrusive-set/intrusive_michael_michael_rcu_gpt.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_michael_michael_rcu.h" + +namespace { + + typedef cds::urcu::general_threaded<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPT, IntrusiveMichaelSet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_michael_michael_rcu_shb.cpp b/test/unit/intrusive-set/intrusive_michael_michael_rcu_shb.cpp new file mode 100644 index 00000000..6f5be5a9 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_michael_michael_rcu_shb.cpp @@ -0,0 +1,46 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + +#include "test_intrusive_michael_michael_rcu.h" + +namespace { + + typedef cds::urcu::signal_buffered<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHB, IntrusiveMichaelSet, rcu_implementation ); + +#endif // #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + diff --git a/test/unit/intrusive-set/intrusive_michael_michael_rcu_sht.cpp b/test/unit/intrusive-set/intrusive_michael_michael_rcu_sht.cpp new file mode 100644 index 00000000..a2e76b5f --- /dev/null +++ b/test/unit/intrusive-set/intrusive_michael_michael_rcu_sht.cpp @@ -0,0 +1,46 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + +#include "test_intrusive_michael_michael_rcu.h" + +namespace { + + typedef cds::urcu::signal_threaded<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHT, IntrusiveMichaelSet, rcu_implementation ); + +#endif // #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + diff --git a/test/unit/intrusive-set/intrusive_skiplist_dhp.cpp b/test/unit/intrusive-set/intrusive_skiplist_dhp.cpp new file mode 100644 index 00000000..555e5958 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_skiplist_dhp.cpp @@ -0,0 +1,200 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_set_hp.h" + +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::DHP gc_type; + + class IntrusiveSkipListSet_DHP : public cds_test::intrusive_set_hp + { + protected: + typedef cds_test::intrusive_set_hp base_class; + + protected: + typedef typename base_class::base_int_item< ci::skip_list::node< gc_type>> base_item_type; + typedef typename base_class::member_int_item< ci::skip_list::node< gc_type>> member_item_type; + + void SetUp() + { + typedef ci::SkipListSet< gc_type, base_item_type, + typename ci::skip_list::make_traits< + ci::opt::hook>> + ,ci::opt::disposer + ,ci::opt::compare + >::type + > set_type; + + cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::dhp::GarbageCollector::Destruct(); + } + }; + + + TEST_F( IntrusiveSkipListSet_DHP, base_cmp ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + }; + + typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_DHP, base_less ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef base_class::less less; + typedef cds::atomicity::item_counter item_counter; + }; + + typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_DHP, base_cmpmix ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + typedef base_class::less less; + typedef ci::skip_list::stat<> stat; + }; + + typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_DHP, base_xorshift ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + typedef ci::skip_list::xorshift random_level_generator; + }; + + typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; + + set_type s; + test( s ); + } + + + TEST_F( IntrusiveSkipListSet_DHP, member_cmp ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::member_hook< offsetof(member_item_type, hMember), ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + }; + + typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_DHP, member_less ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef base_class::less less; + typedef cds::atomicity::item_counter item_counter; + typedef ci::opt::v::sequential_consistent memory_model; + }; + + typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_DHP, member_cmpmix ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + typedef base_class::less less; + typedef ci::skip_list::stat<> stat; + }; + + typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_DHP, member_xorshift ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + typedef ci::skip_list::xorshift random_level_generator; + }; + + typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; + + set_type s; + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_skiplist_hp.cpp b/test/unit/intrusive-set/intrusive_skiplist_hp.cpp new file mode 100644 index 00000000..c3f40e2d --- /dev/null +++ b/test/unit/intrusive-set/intrusive_skiplist_hp.cpp @@ -0,0 +1,201 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_set_hp.h" + +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::HP gc_type; + + class IntrusiveSkipListSet_HP : public cds_test::intrusive_set_hp + { + protected: + typedef cds_test::intrusive_set_hp base_class; + + protected: + typedef typename base_class::base_int_item< ci::skip_list::node< gc_type>> base_item_type; + typedef typename base_class::member_int_item< ci::skip_list::node< gc_type>> member_item_type; + + void SetUp() + { + typedef ci::SkipListSet< gc_type, base_item_type, + typename ci::skip_list::make_traits< + ci::opt::hook>> + ,ci::opt::disposer + ,ci::opt::compare + >::type + > set_type; + + // +1 - for guarded_ptr + cds::gc::hp::GarbageCollector::Construct( set_type::c_nHazardPtrCount + 1, 1, 16 ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::hp::GarbageCollector::Destruct( true ); + } + }; + + + TEST_F( IntrusiveSkipListSet_HP, base_cmp ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + }; + + typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_HP, base_less ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef base_class::less less; + typedef cds::atomicity::item_counter item_counter; + }; + + typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_HP, base_cmpmix ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + typedef base_class::less less; + typedef ci::skip_list::stat<> stat; + }; + + typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_HP, base_xorshift ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + typedef ci::skip_list::xorshift random_level_generator; + }; + + typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; + + set_type s; + test( s ); + } + + + TEST_F( IntrusiveSkipListSet_HP, member_cmp ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::member_hook< offsetof(member_item_type, hMember), ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + }; + + typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_HP, member_less ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef base_class::less less; + typedef cds::atomicity::item_counter item_counter; + typedef ci::opt::v::sequential_consistent memory_model; + }; + + typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_HP, member_cmpmix ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + typedef base_class::less less; + typedef ci::skip_list::stat<> stat; + }; + + typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_HP, member_xorshift ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + typedef ci::skip_list::xorshift random_level_generator; + }; + + typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; + + set_type s; + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_skiplist_nogc.cpp b/test/unit/intrusive-set/intrusive_skiplist_nogc.cpp new file mode 100644 index 00000000..e2c7ec7d --- /dev/null +++ b/test/unit/intrusive-set/intrusive_skiplist_nogc.cpp @@ -0,0 +1,186 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_set_nogc.h" + +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::nogc gc_type; + + class IntrusiveSkipListSet_NoGC : public cds_test::intrusive_set_nogc + { + protected: + typedef cds_test::intrusive_set_nogc base_class; + + protected: + typedef typename base_class::base_int_item< ci::skip_list::node< gc_type>> base_item_type; + typedef typename base_class::member_int_item< ci::skip_list::node< gc_type>> member_item_type; + + //void SetUp() + //{} + + //void TearDown() + //{} + }; + + + TEST_F( IntrusiveSkipListSet_NoGC, base_cmp ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + }; + + typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_NoGC, base_less ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef base_class::less less; + typedef cds::atomicity::item_counter item_counter; + }; + + typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_NoGC, base_cmpmix ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + typedef base_class::less less; + typedef ci::skip_list::stat<> stat; + }; + + typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_NoGC, base_xorshift ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + typedef ci::skip_list::xorshift random_level_generator; + }; + + typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; + + set_type s; + test( s ); + } + + + TEST_F( IntrusiveSkipListSet_NoGC, member_cmp ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::member_hook< offsetof(member_item_type, hMember), ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + }; + + typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_NoGC, member_less ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef base_class::less less; + typedef cds::atomicity::item_counter item_counter; + typedef ci::opt::v::sequential_consistent memory_model; + }; + + typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_NoGC, member_cmpmix ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + typedef base_class::less less; + typedef ci::skip_list::stat<> stat; + }; + + typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; + + set_type s; + test( s ); + } + + TEST_F( IntrusiveSkipListSet_NoGC, member_xorshift ) + { + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + typedef ci::skip_list::xorshift random_level_generator; + }; + + typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; + + set_type s; + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_skiplist_rcu_gpb.cpp b/test/unit/intrusive-set/intrusive_skiplist_rcu_gpb.cpp new file mode 100644 index 00000000..a80370b9 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_skiplist_rcu_gpb.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_skiplist_rcu.h" + +namespace { + + typedef cds::urcu::general_buffered<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPB, IntrusiveSkipListSet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_skiplist_rcu_gpi.cpp b/test/unit/intrusive-set/intrusive_skiplist_rcu_gpi.cpp new file mode 100644 index 00000000..e8b97158 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_skiplist_rcu_gpi.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_skiplist_rcu.h" + +namespace { + + typedef cds::urcu::general_instant<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPI, IntrusiveSkipListSet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_skiplist_rcu_gpt.cpp b/test/unit/intrusive-set/intrusive_skiplist_rcu_gpt.cpp new file mode 100644 index 00000000..beeeca01 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_skiplist_rcu_gpt.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_skiplist_rcu.h" + +namespace { + + typedef cds::urcu::general_threaded<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPT, IntrusiveSkipListSet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_skiplist_rcu_shb.cpp b/test/unit/intrusive-set/intrusive_skiplist_rcu_shb.cpp new file mode 100644 index 00000000..334cf99d --- /dev/null +++ b/test/unit/intrusive-set/intrusive_skiplist_rcu_shb.cpp @@ -0,0 +1,45 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + +#include "test_intrusive_skiplist_rcu.h" + +namespace { + + typedef cds::urcu::signal_buffered<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHB, IntrusiveSkipListSet, rcu_implementation ); + +#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/intrusive-set/intrusive_skiplist_rcu_sht.cpp b/test/unit/intrusive-set/intrusive_skiplist_rcu_sht.cpp new file mode 100644 index 00000000..04a52d6c --- /dev/null +++ b/test/unit/intrusive-set/intrusive_skiplist_rcu_sht.cpp @@ -0,0 +1,45 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + +#include "test_intrusive_skiplist_rcu.h" + +namespace { + + typedef cds::urcu::signal_threaded<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHT, IntrusiveSkipListSet, rcu_implementation ); + +#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/intrusive-set/intrusive_split_lazy_dhp.cpp b/test/unit/intrusive-set/intrusive_split_lazy_dhp.cpp new file mode 100644 index 00000000..aad82073 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_split_lazy_dhp.cpp @@ -0,0 +1,258 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_set_hp.h" + +#include +#include + +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::DHP gc_type; + + class IntrusiveSplitListLazySet_DHP : public cds_test::intrusive_set_hp + { + protected: + typedef cds_test::intrusive_set_hp base_class; + + protected: + typedef typename base_class::base_int_item< ci::split_list::node< ci::lazy_list::node>> base_item_type; + typedef typename base_class::base_int_item< ci::split_list::node< ci::lazy_list::node>> base_mutex_item_type; + typedef typename base_class::member_int_item< ci::split_list::node< ci::lazy_list::node>> member_item_type; + typedef typename base_class::member_int_item< ci::split_list::node< ci::lazy_list::node>> member_mutex_item_type; + + void SetUp() + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc> hook; + }; + typedef ci::LazyList< gc_type, base_item_type, list_traits > list_type; + typedef ci::SplitListSet< gc_type, list_type > set_type; + + cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::dhp::GarbageCollector::Destruct(); + } + }; + + + TEST_F( IntrusiveSplitListLazySet_DHP, base_cmp ) + { + typedef ci::LazyList< gc_type + , base_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type > > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + ,ci::opt::back_off< cds::backoff::pause > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_DHP, base_less ) + { + typedef ci::LazyList< gc_type + , base_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type >>> + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + , ci::opt::item_counter< cds::atomicity::item_counter > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_DHP, base_cmpmix ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, base_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + typedef ci::split_list::stat<> stat; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_DHP, base_mutex ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc, ci::opt::lock_type> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, base_mutex_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + typedef cds::backoff::empty back_off; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + + TEST_F( IntrusiveSplitListLazySet_DHP, member_cmp ) + { + typedef ci::LazyList< gc_type + ,member_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_DHP, member_less ) + { + typedef ci::LazyList< gc_type + , member_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + , ci::opt::back_off< cds::backoff::pause > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_DHP, member_cmpmix ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, member_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_DHP, member_mutex ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc, ci::opt::lock_type> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, member_mutex_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_split_lazy_hp.cpp b/test/unit/intrusive-set/intrusive_split_lazy_hp.cpp new file mode 100644 index 00000000..eadc0232 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_split_lazy_hp.cpp @@ -0,0 +1,259 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_set_hp.h" + +#include +#include + +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::HP gc_type; + + class IntrusiveSplitListLazySet_HP : public cds_test::intrusive_set_hp + { + protected: + typedef cds_test::intrusive_set_hp base_class; + + protected: + typedef typename base_class::base_int_item< ci::split_list::node< ci::lazy_list::node>> base_item_type; + typedef typename base_class::base_int_item< ci::split_list::node< ci::lazy_list::node>> base_mutex_item_type; + typedef typename base_class::member_int_item< ci::split_list::node< ci::lazy_list::node>> member_item_type; + typedef typename base_class::member_int_item< ci::split_list::node< ci::lazy_list::node>> member_mutex_item_type; + + void SetUp() + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc> hook; + }; + typedef ci::LazyList< gc_type, base_item_type, list_traits > list_type; + typedef ci::SplitListSet< gc_type, list_type > set_type; + + // +1 - for guarded_ptr + cds::gc::hp::GarbageCollector::Construct( set_type::c_nHazardPtrCount + 1, 1, 16 ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::hp::GarbageCollector::Destruct( true ); + } + }; + + + TEST_F( IntrusiveSplitListLazySet_HP, base_cmp ) + { + typedef ci::LazyList< gc_type + , base_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type > > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + ,ci::opt::back_off< cds::backoff::pause > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_HP, base_less ) + { + typedef ci::LazyList< gc_type + , base_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type >>> + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + , ci::opt::item_counter< cds::atomicity::item_counter > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_HP, base_cmpmix ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, base_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + typedef ci::split_list::stat<> stat; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_HP, base_mutex ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc, ci::opt::lock_type> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, base_mutex_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + typedef cds::backoff::empty back_off; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + + TEST_F( IntrusiveSplitListLazySet_HP, member_cmp ) + { + typedef ci::LazyList< gc_type + ,member_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_HP, member_less ) + { + typedef ci::LazyList< gc_type + , member_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + , ci::opt::back_off< cds::backoff::pause > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_HP, member_cmpmix ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, member_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_HP, member_mutex ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc, ci::opt::lock_type> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, member_mutex_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_split_lazy_nogc.cpp b/test/unit/intrusive-set/intrusive_split_lazy_nogc.cpp new file mode 100644 index 00000000..a832f383 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_split_lazy_nogc.cpp @@ -0,0 +1,245 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_set_nogc.h" + +#include +#include + +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::nogc gc_type; + + class IntrusiveSplitListLazySet_NoGC : public cds_test::intrusive_set_nogc + { + protected: + typedef cds_test::intrusive_set_nogc base_class; + + protected: + typedef typename base_class::base_int_item< ci::split_list::node< ci::lazy_list::node>> base_item_type; + typedef typename base_class::base_int_item< ci::split_list::node< ci::lazy_list::node>> base_mutex_item_type; + typedef typename base_class::member_int_item< ci::split_list::node< ci::lazy_list::node>> member_item_type; + typedef typename base_class::member_int_item< ci::split_list::node< ci::lazy_list::node>> member_mutex_item_type; + + //void SetUp() + //{} + + //void TearDown() + //{} + }; + + + TEST_F( IntrusiveSplitListLazySet_NoGC, base_cmp ) + { + typedef ci::LazyList< gc_type + , base_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type > > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + ,ci::opt::back_off< cds::backoff::pause > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_NoGC, base_less ) + { + typedef ci::LazyList< gc_type + , base_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type >>> + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + , ci::opt::item_counter< cds::atomicity::item_counter > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_NoGC, base_cmpmix ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, base_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + typedef ci::split_list::stat<> stat; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_NoGC, base_mutex ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc, ci::opt::lock_type> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, base_mutex_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + typedef cds::backoff::empty back_off; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + + TEST_F( IntrusiveSplitListLazySet_NoGC, member_cmp ) + { + typedef ci::LazyList< gc_type + ,member_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_NoGC, member_less ) + { + typedef ci::LazyList< gc_type + , member_item_type + ,ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + , ci::opt::back_off< cds::backoff::pause > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_NoGC, member_cmpmix ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, member_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListLazySet_NoGC, member_mutex ) + { + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc, ci::opt::lock_type> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< gc_type, member_mutex_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_split_lazy_rcu_gpb.cpp b/test/unit/intrusive-set/intrusive_split_lazy_rcu_gpb.cpp new file mode 100644 index 00000000..5bdac588 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_split_lazy_rcu_gpb.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_split_lazy_rcu.h" + +namespace { + + typedef cds::urcu::general_buffered<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPB, IntrusiveSplitLazySet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_split_lazy_rcu_gpi.cpp b/test/unit/intrusive-set/intrusive_split_lazy_rcu_gpi.cpp new file mode 100644 index 00000000..2008d870 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_split_lazy_rcu_gpi.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_split_lazy_rcu.h" + +namespace { + + typedef cds::urcu::general_instant<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPI, IntrusiveSplitLazySet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_split_lazy_rcu_gpt.cpp b/test/unit/intrusive-set/intrusive_split_lazy_rcu_gpt.cpp new file mode 100644 index 00000000..ae833f13 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_split_lazy_rcu_gpt.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_split_lazy_rcu.h" + +namespace { + + typedef cds::urcu::general_threaded<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPT, IntrusiveSplitLazySet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_split_lazy_rcu_shb.cpp b/test/unit/intrusive-set/intrusive_split_lazy_rcu_shb.cpp new file mode 100644 index 00000000..3968e5d7 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_split_lazy_rcu_shb.cpp @@ -0,0 +1,45 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + +#include "test_intrusive_split_lazy_rcu.h" + +namespace { + + typedef cds::urcu::signal_buffered<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHB, IntrusiveSplitLazySet, rcu_implementation ); + +#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/intrusive-set/intrusive_split_lazy_rcu_sht.cpp b/test/unit/intrusive-set/intrusive_split_lazy_rcu_sht.cpp new file mode 100644 index 00000000..afa910c3 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_split_lazy_rcu_sht.cpp @@ -0,0 +1,45 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + +#include "test_intrusive_split_lazy_rcu.h" + +namespace { + + typedef cds::urcu::signal_threaded<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHT, IntrusiveSplitLazySet, rcu_implementation ); + +#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/intrusive-set/intrusive_split_michael_dhp.cpp b/test/unit/intrusive-set/intrusive_split_michael_dhp.cpp new file mode 100644 index 00000000..5d067b79 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_split_michael_dhp.cpp @@ -0,0 +1,208 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_set_hp.h" + +#include +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::DHP gc_type; + + class IntrusiveSplitListSet_DHP : public cds_test::intrusive_set_hp + { + protected: + typedef cds_test::intrusive_set_hp base_class; + + protected: + typedef typename base_class::base_int_item< ci::split_list::node< ci::michael_list::node>> base_item_type; + typedef typename base_class::member_int_item< ci::split_list::node< ci::michael_list::node>> member_item_type; + + void SetUp() + { + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::base_hook< ci::opt::gc> hook; + }; + typedef ci::MichaelList< gc_type, base_item_type, list_traits > list_type; + typedef ci::SplitListSet< gc_type, list_type > set_type; + + cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::dhp::GarbageCollector::Destruct(); + } + }; + + + TEST_F( IntrusiveSplitListSet_DHP, base_cmp ) + { + typedef ci::MichaelList< gc_type + , base_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type > > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListSet_DHP, base_less ) + { + typedef ci::MichaelList< gc_type + , base_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type >>> + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + ,ci::opt::item_counter< cds::atomicity::item_counter > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListSet_DHP, base_cmpmix ) + { + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::base_hook< ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::MichaelList< gc_type, base_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + typedef ci::split_list::stat<> stat; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + + TEST_F( IntrusiveSplitListSet_DHP, member_cmp ) + { + typedef ci::MichaelList< gc_type + ,member_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListSet_DHP, member_less ) + { + typedef ci::MichaelList< gc_type + , member_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + ,ci::opt::back_off< cds::backoff::pause > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListSet_DHP, member_cmpmix ) + { + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::MichaelList< gc_type, member_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_split_michael_hp.cpp b/test/unit/intrusive-set/intrusive_split_michael_hp.cpp new file mode 100644 index 00000000..c904eeb3 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_split_michael_hp.cpp @@ -0,0 +1,209 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_set_hp.h" + +#include +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::HP gc_type; + + class IntrusiveSplitListSet_HP : public cds_test::intrusive_set_hp + { + protected: + typedef cds_test::intrusive_set_hp base_class; + + protected: + typedef typename base_class::base_int_item< ci::split_list::node< ci::michael_list::node>> base_item_type; + typedef typename base_class::member_int_item< ci::split_list::node< ci::michael_list::node>> member_item_type; + + void SetUp() + { + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::base_hook< ci::opt::gc> hook; + }; + typedef ci::MichaelList< gc_type, base_item_type, list_traits > list_type; + typedef ci::SplitListSet< gc_type, list_type > set_type; + + // +1 - for guarded_ptr + cds::gc::hp::GarbageCollector::Construct( set_type::c_nHazardPtrCount + 1, 1, 16 ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::hp::GarbageCollector::Destruct( true ); + } + }; + + + TEST_F( IntrusiveSplitListSet_HP, base_cmp ) + { + typedef ci::MichaelList< gc_type + , base_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type > > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListSet_HP, base_less ) + { + typedef ci::MichaelList< gc_type + , base_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type >>> + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + ,ci::opt::item_counter< cds::atomicity::item_counter > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListSet_HP, base_cmpmix ) + { + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::base_hook< ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::MichaelList< gc_type, base_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + typedef ci::split_list::stat<> stat; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + + TEST_F( IntrusiveSplitListSet_HP, member_cmp ) + { + typedef ci::MichaelList< gc_type + ,member_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListSet_HP, member_less ) + { + typedef ci::MichaelList< gc_type + , member_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + ,ci::opt::back_off< cds::backoff::pause > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListSet_HP, member_cmpmix ) + { + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::MichaelList< gc_type, member_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_split_michael_nogc.cpp b/test/unit/intrusive-set/intrusive_split_michael_nogc.cpp new file mode 100644 index 00000000..ed7c0c3b --- /dev/null +++ b/test/unit/intrusive-set/intrusive_split_michael_nogc.cpp @@ -0,0 +1,195 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_intrusive_set_nogc.h" + +#include +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::nogc gc_type; + + class IntrusiveSplitListSet_NoGC : public cds_test::intrusive_set_nogc + { + protected: + typedef cds_test::intrusive_set_nogc base_class; + + protected: + typedef typename base_class::base_int_item< ci::split_list::node< ci::michael_list::node>> base_item_type; + typedef typename base_class::member_int_item< ci::split_list::node< ci::michael_list::node>> member_item_type; + + //void SetUp() + //{} + + //void TearDown() + //{} + }; + + + TEST_F( IntrusiveSplitListSet_NoGC, base_cmp ) + { + typedef ci::MichaelList< gc_type + , base_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type > > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListSet_NoGC, base_less ) + { + typedef ci::MichaelList< gc_type + , base_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type >>> + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + , ci::opt::item_counter< cds::atomicity::item_counter > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListSet_NoGC, base_cmpmix ) + { + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::base_hook< ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::MichaelList< gc_type, base_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + typedef ci::split_list::stat<> stat; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + + TEST_F( IntrusiveSplitListSet_NoGC, member_cmp ) + { + typedef ci::MichaelList< gc_type + ,member_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::compare< cmp > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListSet_NoGC, member_less ) + { + typedef ci::MichaelList< gc_type + , member_item_type + ,ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + ,ci::opt::less< less > + ,ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< gc_type, bucket_type, + ci::split_list::make_traits< + ci::opt::hash< hash_int > + , ci::opt::back_off< cds::backoff::pause > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( IntrusiveSplitListSet_NoGC, member_cmpmix ) + { + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; + typedef base_class::less less; + typedef cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::MichaelList< gc_type, member_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/intrusive_split_michael_rcu_gpb.cpp b/test/unit/intrusive-set/intrusive_split_michael_rcu_gpb.cpp new file mode 100644 index 00000000..bf923960 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_split_michael_rcu_gpb.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_split_michael_rcu.h" + +namespace { + + typedef cds::urcu::general_buffered<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPB, IntrusiveSplitMichaelSet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_split_michael_rcu_gpi.cpp b/test/unit/intrusive-set/intrusive_split_michael_rcu_gpi.cpp new file mode 100644 index 00000000..a62aa084 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_split_michael_rcu_gpi.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_split_michael_rcu.h" + +namespace { + + typedef cds::urcu::general_instant<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPI, IntrusiveSplitMichaelSet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_split_michael_rcu_gpt.cpp b/test/unit/intrusive-set/intrusive_split_michael_rcu_gpt.cpp new file mode 100644 index 00000000..56a7bc16 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_split_michael_rcu_gpt.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_intrusive_split_michael_rcu.h" + +namespace { + + typedef cds::urcu::general_threaded<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPT, IntrusiveSplitMichaelSet, rcu_implementation ); diff --git a/test/unit/intrusive-set/intrusive_split_michael_rcu_shb.cpp b/test/unit/intrusive-set/intrusive_split_michael_rcu_shb.cpp new file mode 100644 index 00000000..81f45389 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_split_michael_rcu_shb.cpp @@ -0,0 +1,45 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + +#include "test_intrusive_split_michael_rcu.h" + +namespace { + + typedef cds::urcu::signal_buffered<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHB, IntrusiveSplitMichaelSet, rcu_implementation ); + +#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/intrusive-set/intrusive_split_michael_rcu_sht.cpp b/test/unit/intrusive-set/intrusive_split_michael_rcu_sht.cpp new file mode 100644 index 00000000..cb646b92 --- /dev/null +++ b/test/unit/intrusive-set/intrusive_split_michael_rcu_sht.cpp @@ -0,0 +1,45 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + +#include "test_intrusive_split_michael_rcu.h" + +namespace { + + typedef cds::urcu::signal_threaded<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHT, IntrusiveSplitMichaelSet, rcu_implementation ); + +#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/intrusive-set/michael_michael_dhp.cpp b/test/unit/intrusive-set/michael_michael_dhp.cpp new file mode 100644 index 00000000..fa386635 --- /dev/null +++ b/test/unit/intrusive-set/michael_michael_dhp.cpp @@ -0,0 +1,177 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_set_hp.h" + +#include +#include + +namespace { + namespace cc = cds::container; + typedef cds::gc::DHP gc_type; + + class MichaelSet_DHP : public cds_test::container_set_hp + { + protected: + typedef cds_test::container_set_hp base_class; + + void SetUp() + { + typedef cc::MichaelList< gc_type, int_item > list_type; + typedef cc::MichaelHashSet< gc_type, list_type > set_type; + + // +1 - for guarded_ptr + cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::dhp::GarbageCollector::Destruct(); + } + }; + + TEST_F( MichaelSet_DHP, compare ) + { + typedef cc::MichaelList< gc_type, int_item, + typename cc::michael_list::make_traits< + cds::opt::compare< cmp > + >::type + > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelSet_DHP, less ) + { + typedef cc::MichaelList< gc_type, int_item, + typename cc::michael_list::make_traits< + cds::opt::less< base_class::less > + >::type + > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelSet_DHP, cmpmix ) + { + struct list_traits : public cc::michael_list::traits + { + typedef base_class::less less; + typedef cmp compare; + }; + typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelSet_DHP, item_counting ) + { + struct list_traits : public cc::michael_list::traits + { + typedef cmp compare; + }; + typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; + + struct set_traits: public cc::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 3 ); + test( s ); + } + + TEST_F( MichaelSet_DHP, backoff ) + { + struct list_traits : public cc::michael_list::traits + { + typedef cmp compare; + typedef cds::backoff::exponential back_off; + }; + typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 4 ); + test( s ); + } + + TEST_F( MichaelSet_DHP, seq_cst ) + { + struct list_traits : public cc::michael_list::traits + { + typedef base_class::less less; + typedef cds::backoff::pause back_off; + typedef cds::opt::v::sequential_consistent memory_model; + }; + typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 4 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/michael_michael_hp.cpp b/test/unit/intrusive-set/michael_michael_hp.cpp new file mode 100644 index 00000000..3483b8f9 --- /dev/null +++ b/test/unit/intrusive-set/michael_michael_hp.cpp @@ -0,0 +1,177 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_set_hp.h" + +#include +#include + +namespace { + namespace cc = cds::container; + typedef cds::gc::HP gc_type; + + class MichaelSet_HP : public cds_test::container_set_hp + { + protected: + typedef cds_test::container_set_hp base_class; + + void SetUp() + { + typedef cc::MichaelList< gc_type, int_item > list_type; + typedef cc::MichaelHashSet< gc_type, list_type > set_type; + + // +1 - for guarded_ptr + cds::gc::hp::GarbageCollector::Construct( set_type::c_nHazardPtrCount + 1, 1, 16 ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::hp::GarbageCollector::Destruct( true ); + } + }; + + TEST_F( MichaelSet_HP, compare ) + { + typedef cc::MichaelList< gc_type, int_item, + typename cc::michael_list::make_traits< + cds::opt::compare< cmp > + >::type + > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelSet_HP, less ) + { + typedef cc::MichaelList< gc_type, int_item, + typename cc::michael_list::make_traits< + cds::opt::less< base_class::less > + >::type + > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelSet_HP, cmpmix ) + { + struct list_traits : public cc::michael_list::traits + { + typedef base_class::less less; + typedef cmp compare; + }; + typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelSet_HP, item_counting ) + { + struct list_traits : public cc::michael_list::traits + { + typedef cmp compare; + }; + typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; + + struct set_traits: public cc::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 3 ); + test( s ); + } + + TEST_F( MichaelSet_HP, backoff ) + { + struct list_traits : public cc::michael_list::traits + { + typedef cmp compare; + typedef cds::backoff::exponential back_off; + }; + typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 4 ); + test( s ); + } + + TEST_F( MichaelSet_HP, seq_cst ) + { + struct list_traits : public cc::michael_list::traits + { + typedef base_class::less less; + typedef cds::backoff::pause back_off; + typedef cds::opt::v::sequential_consistent memory_model; + }; + typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 4 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/michael_michael_nogc.cpp b/test/unit/intrusive-set/michael_michael_nogc.cpp new file mode 100644 index 00000000..0f493ff0 --- /dev/null +++ b/test/unit/intrusive-set/michael_michael_nogc.cpp @@ -0,0 +1,167 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_set_nogc.h" + +#include +#include + +namespace { + namespace cc = cds::container; + typedef cds::gc::nogc gc_type; + + class MichaelSet_NoGC : public cds_test::container_set_nogc + { + protected: + typedef cds_test::container_set_nogc base_class; + + //void SetUp() + //{} + + //void TearDown() + //{} + }; + + TEST_F( MichaelSet_NoGC, compare ) + { + typedef cc::MichaelList< gc_type, int_item, + typename cc::michael_list::make_traits< + cds::opt::compare< cmp > + >::type + > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelSet_NoGC, less ) + { + typedef cc::MichaelList< gc_type, int_item, + typename cc::michael_list::make_traits< + cds::opt::less< base_class::less > + >::type + > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelSet_NoGC, cmpmix ) + { + struct list_traits : public cc::michael_list::traits + { + typedef base_class::less less; + typedef cmp compare; + }; + typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelSet_NoGC, item_counting ) + { + struct list_traits : public cc::michael_list::traits + { + typedef cmp compare; + }; + typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; + + struct set_traits: public cc::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 3 ); + test( s ); + } + + TEST_F( MichaelSet_NoGC, backoff ) + { + struct list_traits : public cc::michael_list::traits + { + typedef cmp compare; + typedef cds::backoff::exponential back_off; + }; + typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 4 ); + test( s ); + } + + TEST_F( MichaelSet_NoGC, seq_cst ) + { + struct list_traits : public cc::michael_list::traits + { + typedef base_class::less less; + typedef cds::backoff::pause back_off; + typedef cds::opt::v::sequential_consistent memory_model; + }; + typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 4 ); + test( s ); + } + +} // namespace diff --git a/test/unit/intrusive-set/michael_michael_rcu_gpb.cpp b/test/unit/intrusive-set/michael_michael_rcu_gpb.cpp new file mode 100644 index 00000000..9b2a1881 --- /dev/null +++ b/test/unit/intrusive-set/michael_michael_rcu_gpb.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_michael_michael_rcu.h" + +namespace { + + typedef cds::urcu::general_buffered<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPB, MichaelSet, rcu_implementation ); diff --git a/test/unit/intrusive-set/michael_michael_rcu_gpi.cpp b/test/unit/intrusive-set/michael_michael_rcu_gpi.cpp new file mode 100644 index 00000000..a907d591 --- /dev/null +++ b/test/unit/intrusive-set/michael_michael_rcu_gpi.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_michael_michael_rcu.h" + +namespace { + + typedef cds::urcu::general_instant<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPI, MichaelSet, rcu_implementation ); diff --git a/test/unit/intrusive-set/michael_michael_rcu_gpt.cpp b/test/unit/intrusive-set/michael_michael_rcu_gpt.cpp new file mode 100644 index 00000000..f2a61a68 --- /dev/null +++ b/test/unit/intrusive-set/michael_michael_rcu_gpt.cpp @@ -0,0 +1,41 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#include "test_michael_michael_rcu.h" + +namespace { + + typedef cds::urcu::general_threaded<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPT, MichaelSet, rcu_implementation ); diff --git a/test/unit/intrusive-set/michael_michael_rcu_shb.cpp b/test/unit/intrusive-set/michael_michael_rcu_shb.cpp new file mode 100644 index 00000000..be796351 --- /dev/null +++ b/test/unit/intrusive-set/michael_michael_rcu_shb.cpp @@ -0,0 +1,45 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + +#include "test_michael_michael_rcu.h" + +namespace { + + typedef cds::urcu::signal_buffered<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHB, MichaelSet, rcu_implementation ); + +#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/intrusive-set/michael_michael_rcu_sht.cpp b/test/unit/intrusive-set/michael_michael_rcu_sht.cpp new file mode 100644 index 00000000..58cf7f69 --- /dev/null +++ b/test/unit/intrusive-set/michael_michael_rcu_sht.cpp @@ -0,0 +1,45 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + +#include "test_michael_michael_rcu.h" + +namespace { + + typedef cds::urcu::signal_threaded<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHT, MichaelSet, rcu_implementation ); + +#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/intrusive-set/test_intrusive_feldman_hashset.h b/test/unit/intrusive-set/test_intrusive_feldman_hashset.h new file mode 100644 index 00000000..bb3ae721 --- /dev/null +++ b/test/unit/intrusive-set/test_intrusive_feldman_hashset.h @@ -0,0 +1,313 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_H +#define CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_H + +#include +#include + +#include +#include // ref + +// forward declaration +namespace cds { namespace intrusive {}} +namespace ci = cds::intrusive; + +namespace cds_test { + class intrusive_feldman_hashset: public fixture + { + public: + struct stat + { + unsigned int nDisposeCount ; // count of disposer calling + unsigned int nFindCount ; // count of find-functor calling + unsigned int nInsertCount ; + mutable unsigned int nEraseCount; + + stat() + { + clear_stat(); + } + + void clear_stat() + { + memset( this, 0, sizeof( *this ) ); + } + }; + + struct int_item: public stat + { + int nKey; + int nVal; + + int_item() + {} + + explicit int_item( int key ) + : nKey( key ) + , nVal( key ) + {} + + int_item(int key, int val) + : nKey( key ) + , nVal(val) + {} + + int_item( int_item const& v ) + : stat() + , nKey( v.nKey ) + , nVal( v.nVal ) + {} + + int key() const + { + return nKey; + } + }; + + struct hash_accessor { + int operator()( int_item const& v ) const + { + return v.key(); + } + }; + + struct simple_item_counter { + size_t m_nCount; + + simple_item_counter() + : m_nCount(0) + {} + + size_t operator ++() + { + return ++m_nCount; + } + + size_t operator --() + { + return --m_nCount; + } + + void reset() + { + m_nCount = 0; + } + + operator size_t() const + { + return m_nCount; + } + }; + + struct cmp { + int operator ()( int lhs, int rhs ) const + { + if ( lhs < rhs ) + return -1; + return lhs > rhs ? 1 : 0; + } + }; + + struct mock_disposer + { + template + void operator ()( T * p ) + { + ++p->nDisposeCount; + } + }; + + protected: + template + void test( Set& s ) + { + // Precondition: set is empty + // Postcondition: set is empty + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + size_t const nSetSize = std::max( s.head_size() * 2, static_cast(100) ); + + typedef typename Set::value_type value_type; + + std::vector< value_type > data; + std::vector< size_t> indices; + data.reserve( nSetSize ); + indices.reserve( nSetSize ); + for ( size_t key = 0; key < nSetSize; ++key ) { + data.push_back( value_type( static_cast( key ))); + indices.push_back( key ); + } + shuffle( indices.begin(), indices.end() ); + + // insert/find + for ( auto idx : indices ) { + auto& i = data[ idx ]; + + ASSERT_FALSE( s.contains( i.nKey )); + ASSERT_FALSE( s.find( i.nKey, []( value_type& ) {} )); + + std::pair updResult; + + updResult = s.update( i, false ); + EXPECT_FALSE( updResult.first ); + EXPECT_FALSE( updResult.second ); + + switch ( i.key() % 3 ) { + case 0: + ASSERT_TRUE( s.insert( i )); + ASSERT_FALSE( s.insert( i )); + updResult = s.update( i, false ); + EXPECT_TRUE( updResult.first ); + EXPECT_FALSE( updResult.second ); + break; + case 1: + EXPECT_EQ( i.nInsertCount, 0 ); + ASSERT_TRUE( s.insert( i, []( value_type& v ) { ++v.nInsertCount;} )); + EXPECT_EQ( i.nInsertCount, 1 ); + ASSERT_FALSE( s.insert( i, []( value_type& v ) { ++v.nInsertCount;} ) ); + EXPECT_EQ( i.nInsertCount, 1 ); + i.nInsertCount = 0; + break; + case 2: + updResult = s.update( i ); + EXPECT_TRUE( updResult.first ); + EXPECT_TRUE( updResult.second ); + break; + } + + ASSERT_TRUE( s.contains( i.nKey ) ); + EXPECT_EQ( i.nFindCount, 0 ); + ASSERT_TRUE( s.find( i.nKey, []( value_type& v ) { ++v.nFindCount; } )); + EXPECT_EQ( i.nFindCount, 1 ); + } + ASSERT_FALSE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, nSetSize ); + + std::for_each( data.begin(), data.end(), []( value_type& v ) { v.clear_stat(); }); + + // get_level_statistics + { + std::vector< typename Set::level_statistics > level_stat; + s.get_level_statistics( level_stat ); + EXPECT_GT( level_stat.size(), 0 ); + } + + // erase + shuffle( indices.begin(), indices.end() ); + for ( auto idx : indices ) { + auto& i = data[ idx ]; + + ASSERT_TRUE( s.contains( i.nKey ) ); + EXPECT_EQ( i.nFindCount, 0 ); + ASSERT_TRUE( s.find( i.nKey, []( value_type& v ) { ++v.nFindCount; } ) ); + EXPECT_EQ( i.nFindCount, 1 ); + + value_type v( i ); + switch ( i.key() % 3 ) { + case 0: + ASSERT_FALSE( s.unlink( v )); + ASSERT_TRUE( s.unlink( i )); + ASSERT_FALSE( s.unlink( i ) ); + break; + case 1: + ASSERT_TRUE( s.erase( i.key())); + ASSERT_FALSE( s.erase( i.key() ) ); + break; + case 2: + EXPECT_EQ( i.nEraseCount, 0 ); + ASSERT_TRUE( s.erase( v.key(), []( value_type& val ) { ++val.nEraseCount; } )); + EXPECT_EQ( i.nEraseCount, 1 ); + ASSERT_FALSE( s.erase( v.key(), []( value_type& val ) { ++val.nEraseCount; } )); + EXPECT_EQ( i.nEraseCount, 1 ); + break; + } + + ASSERT_FALSE( s.contains( i.nKey )); + ASSERT_FALSE( s.find( i.nKey, []( value_type const& ) {} )); + } + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + // Force retiring cycle + Set::gc::force_dispose(); + for ( auto& i : data ) { + EXPECT_EQ( i.nDisposeCount, 1 ); + } + + // clear + for ( auto& i : data ) { + i.clear_stat(); + ASSERT_TRUE( s.insert( i )); + } + ASSERT_FALSE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, nSetSize ); + + // Forward iterator test + for ( auto it = s.begin(); it != s.end(); ++it ) { + ++it->nFindCount; + } + for ( auto it = s.cbegin(); it != s.cend(); ++it ) { + EXPECT_EQ( it->nFindCount, 1 ); + } + + // Reverse iterator test + for ( auto it = s.rbegin(); it != s.rend(); ++it ) { + ++it->nFindCount; + } + for ( auto it = s.crbegin(); it != s.crend(); ++it ) { + EXPECT_EQ( it->nFindCount, 2 ); + } + + for ( auto& i : data ) { + EXPECT_EQ( i.nFindCount, 2 ); + } + + // clear test + s.clear(); + + ASSERT_TRUE( s.empty()); + ASSERT_CONTAINER_SIZE( s, 0 ); + ASSERT_TRUE( s.begin() == s.end() ); + ASSERT_TRUE( s.cbegin() == s.cend() ); + + // Force retiring cycle + Set::gc::force_dispose(); + for ( auto& i : data ) { + EXPECT_EQ( i.nDisposeCount, 1 ); + } + } + }; + +} // namespace cds_test + +#endif // #ifndef CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_H diff --git a/test/unit/intrusive-set/test_intrusive_feldman_hashset_hp.h b/test/unit/intrusive-set/test_intrusive_feldman_hashset_hp.h new file mode 100644 index 00000000..17dd9ec9 --- /dev/null +++ b/test/unit/intrusive-set/test_intrusive_feldman_hashset_hp.h @@ -0,0 +1,165 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_HP_H +#define CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_HP_H + +#include "test_intrusive_feldman_hashset.h" + +namespace cds_test { + + class intrusive_feldman_hashset_hp: public intrusive_feldman_hashset + { + typedef intrusive_feldman_hashset base_class; + + protected: + + template + void test( Set& s ) + { + // Precondition: set is empty + // Postcondition: set is empty + + base_class::test( s ); + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + typedef typename Set::value_type value_type; + size_t const nSetSize = std::max( s.head_size() * 2, static_cast( 100 )); + + std::vector< value_type > data; + std::vector< size_t> indices; + data.reserve( nSetSize ); + indices.reserve( nSetSize ); + for ( size_t key = 0; key < nSetSize; ++key ) { + data.push_back( value_type( static_cast(key) ) ); + indices.push_back( key ); + } + shuffle( indices.begin(), indices.end() ); + + typename Set::guarded_ptr gp; + + // get/extract from empty set + for ( auto idx : indices ) { + auto& i = data[idx]; + + gp = s.get( i.key() ); + ASSERT_TRUE( !gp ); + + gp = s.extract( i.key()); + ASSERT_TRUE( !gp ); + } + + // fill set + for ( auto& i : data ) { + i.nDisposeCount = 0; + ASSERT_TRUE( s.insert( i ) ); + } + + // get/extract + for ( auto idx : indices ) { + auto& i = data[idx]; + + EXPECT_EQ( i.nFindCount, 0 ); + gp = s.get( i.key() ); + ASSERT_FALSE( !gp ); + ++gp->nFindCount; + EXPECT_EQ( i.nFindCount, 1 ); + + gp = s.extract( i.key()); + ASSERT_FALSE( !gp ); + ++gp->nEraseCount; + EXPECT_EQ( i.nEraseCount, 1 ); + + gp = s.extract( i.key() ); + ASSERT_TRUE( !gp ); + + gp = s.get( i.key() ); + ASSERT_TRUE( !gp ); + } + gp.release(); + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + // Force retiring cycle + Set::gc::force_dispose(); + for ( auto& i : data ) { + EXPECT_EQ( i.nDisposeCount, 1 ); + } + + // erase_at( iterator ) + for ( auto& i : data ) { + i.clear_stat(); + ASSERT_TRUE( s.insert( i ) ); + } + ASSERT_FALSE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, nSetSize ); + + for ( auto it = s.begin(); it != s.end(); ++it ) { + ASSERT_TRUE( s.erase_at( it ) ); + ASSERT_FALSE( s.erase_at( it ) ); + } + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + // Force retiring cycle + Set::gc::force_dispose(); + for ( auto& i : data ) { + EXPECT_EQ( i.nDisposeCount, 1 ); + } + + // erase_at( reverse_iterator ) + for ( auto& i : data ) { + i.clear_stat(); + ASSERT_TRUE( s.insert( i ) ); + } + ASSERT_FALSE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, nSetSize ); + + for ( auto it = s.rbegin(); it != s.rend(); ++it ) { + ASSERT_TRUE( s.erase_at( it ) ); + ASSERT_FALSE( s.erase_at( it ) ); + } + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + // Force retiring cycle + Set::gc::force_dispose(); + for ( auto& i : data ) { + EXPECT_EQ( i.nDisposeCount, 1 ); + } + } + }; + +} // namespace cds_test + +#endif // #ifndef CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_HP_H diff --git a/test/unit/intrusive-set/test_intrusive_feldman_hashset_rcu.h b/test/unit/intrusive-set/test_intrusive_feldman_hashset_rcu.h new file mode 100644 index 00000000..a8db5437 --- /dev/null +++ b/test/unit/intrusive-set/test_intrusive_feldman_hashset_rcu.h @@ -0,0 +1,233 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_RCU_H +#define CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_RCU_H + +#include "test_intrusive_feldman_hashset.h" + +#include + +namespace ci = cds::intrusive; +namespace co = cds::opt; + +template +class IntrusiveFeldmanHashSet : public cds_test::intrusive_feldman_hashset +{ + typedef cds_test::intrusive_feldman_hashset base_class; + +protected: + typedef cds::urcu::gc rcu_type; + + template + void test( Set& s ) + { + // Precondition: set is empty + // Postcondition: set is empty + + base_class::test( s ); + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + typedef typename Set::value_type value_type; + size_t const nSetSize = std::max( s.head_size() * 2, static_cast(100) ); + + std::vector< value_type > data; + std::vector< size_t> indices; + data.reserve( nSetSize ); + indices.reserve( nSetSize ); + for ( size_t key = 0; key < nSetSize; ++key ) { + data.push_back( value_type( static_cast(key) ) ); + indices.push_back( key ); + } + shuffle( indices.begin(), indices.end() ); + + typename Set::exempt_ptr xp; + value_type * rp; + typedef typename Set::rcu_lock rcu_lock; + + // get/extract from empty set + for ( auto idx : indices ) { + auto& i = data[idx]; + + { + rcu_lock l; + rp = s.get( i.key() ); + ASSERT_TRUE( !rp ); + } + + xp = s.extract( i.key() ); + ASSERT_TRUE( !xp ); + } + + // fill set + for ( auto& i : data ) { + i.nDisposeCount = 0; + ASSERT_TRUE( s.insert( i ) ); + } + + // get/extract + for ( auto idx : indices ) { + auto& i = data[idx]; + + { + rcu_lock l; + EXPECT_EQ( i.nFindCount, 0 ); + rp = s.get( i.key() ); + ASSERT_FALSE( !rp ); + ++rp->nFindCount; + EXPECT_EQ( i.nFindCount, 1 ); + } + + EXPECT_EQ( i.nEraseCount, 0 ); + xp = s.extract( i.key()); + ASSERT_FALSE( !xp ); + ++xp->nEraseCount; + EXPECT_EQ( i.nEraseCount, 1 ); + + xp = s.extract( i.key() ); + ASSERT_TRUE( !xp ); + } + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + // Force retiring cycle + Set::gc::force_dispose(); + for ( auto& i : data ) { + EXPECT_EQ( i.nDisposeCount, 1 ); + } + } + + void SetUp() + { + RCU::Construct(); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + RCU::Destruct(); + } +}; + +TYPED_TEST_CASE_P( IntrusiveFeldmanHashSet ); + +TYPED_TEST_P( IntrusiveFeldmanHashSet, compare ) +{ + typedef typename TestFixture::rcu_type rcu_type; + + struct traits : public ci::feldman_hashset::traits + { + typedef typename TestFixture::hash_accessor hash_accessor; + typedef typename TestFixture::cmp compare; + typedef typename TestFixture::mock_disposer disposer; + }; + + typedef ci::FeldmanHashSet< rcu_type, typename TestFixture::int_item, traits > set_type; + + set_type s; + this->test( s ); +} + +TYPED_TEST_P( IntrusiveFeldmanHashSet, less ) +{ + typedef ci::FeldmanHashSet< typename TestFixture::rcu_type, typename TestFixture::int_item, + typename ci::feldman_hashset::make_traits< + ci::feldman_hashset::hash_accessor< typename TestFixture::hash_accessor > + , ci::opt::less< std::less> + , ci::opt::disposer< typename TestFixture::mock_disposer> + >::type + > set_type; + + set_type s( 5, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveFeldmanHashSet, cmpmix ) +{ + struct traits : public ci::feldman_hashset::traits + { + typedef typename TestFixture::hash_accessor hash_accessor; + typedef typename TestFixture::cmp compare; + typedef std::less less; + typedef typename TestFixture::mock_disposer disposer; + typedef typename TestFixture::simple_item_counter item_counter; + }; + + typedef ci::FeldmanHashSet< typename TestFixture::rcu_type, typename TestFixture::int_item, traits > set_type; + + set_type s( 3, 4 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveFeldmanHashSet, backoff ) +{ + struct traits : public ci::feldman_hashset::traits + { + typedef typename TestFixture::hash_accessor hash_accessor; + typedef typename TestFixture::cmp compare; + typedef typename TestFixture::mock_disposer disposer; + typedef cds::backoff::empty back_off; + typedef ci::opt::v::sequential_consistent memory_model; + }; + + typedef ci::FeldmanHashSet< typename TestFixture::rcu_type, typename TestFixture::int_item, traits > set_type; + + set_type s( 8, 3 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveFeldmanHashSet, stat ) +{ + struct traits : public ci::feldman_hashset::traits + { + typedef typename TestFixture::hash_accessor hash_accessor; + typedef typename TestFixture::cmp compare; + typedef typename TestFixture::mock_disposer disposer; + typedef ci::feldman_hashset::stat<> stat; + }; + + typedef ci::FeldmanHashSet< typename TestFixture::rcu_type, typename TestFixture::int_item, traits > set_type; + + set_type s( 8, 3 ); + this->test( s ); +} + +// GCC 5: All test names should be written on single line, otherwise a runtime error will be encountered like as +// "No test named can be found in this test case" +REGISTER_TYPED_TEST_CASE_P( IntrusiveFeldmanHashSet, + compare, less, cmpmix, backoff, stat + ); + + +#endif // #ifndef CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_RCU_H diff --git a/test/unit/intrusive-set/test_intrusive_michael_lazy_rcu.h b/test/unit/intrusive-set/test_intrusive_michael_lazy_rcu.h new file mode 100644 index 00000000..c32fdb65 --- /dev/null +++ b/test/unit/intrusive-set/test_intrusive_michael_lazy_rcu.h @@ -0,0 +1,298 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +#ifndef CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_LAZY_RCU_H +#define CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_LAZY_RCU_H + +#include "test_intrusive_set_rcu.h" +#include +#include + +namespace ci = cds::intrusive; + +template +class IntrusiveMichaelLazySet: public cds_test::intrusive_set_rcu +{ + typedef cds_test::intrusive_set_rcu base_class; +public: + typedef cds::urcu::gc rcu_type; + typedef typename base_class::base_int_item< ci::lazy_list::node> base_item_type; + typedef typename base_class::base_int_item< ci::lazy_list::node> base_mutex_item_type; + typedef typename base_class::member_int_item< ci::lazy_list::node> member_item_type; + typedef typename base_class::member_int_item< ci::lazy_list::node> member_mutex_item_type; + +protected: + void SetUp() + { + RCU::Construct(); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + RCU::Destruct(); + } +}; + +TYPED_TEST_CASE_P( IntrusiveMichaelLazySet ); + +TYPED_TEST_P( IntrusiveMichaelLazySet, base_cmp ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_item_type base_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template cmp cmp; + typedef typename TestFixture::hash_int hash_int; + + typedef ci::LazyList< rcu_type + , base_item_type + , typename ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< rcu_type > > > + , ci::opt::compare< cmp > + , ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< rcu_type, bucket_type, + typename ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveMichaelLazySet, base_less ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_item_type base_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template less less; + typedef typename TestFixture::hash_int hash_int; + + typedef ci::LazyList< rcu_type + , base_item_type + , typename ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< rcu_type >>> + , ci::opt::less< less > + , ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< rcu_type, bucket_type, + typename ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveMichaelLazySet, base_cmpmix ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_item_type base_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::hash_int hash_int; + + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc> hook; + typedef typename TestFixture::template less less; + typedef typename TestFixture::template cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< rcu_type, base_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef typename TestFixture::simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< rcu_type, bucket_type, set_traits > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveMichaelLazySet, base_mutex ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_mutex_item_type base_mutex_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::hash_int hash_int; + + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc, ci::opt::lock_type> hook; + typedef typename TestFixture::template less less; + typedef typename TestFixture::template cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< rcu_type, base_mutex_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef typename TestFixture::simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< rcu_type, bucket_type, set_traits > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + + +TYPED_TEST_P( IntrusiveMichaelLazySet, member_cmp ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_item_type member_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template cmp cmp; + typedef typename TestFixture::hash_int hash_int; + + typedef ci::LazyList< rcu_type + , member_item_type + , typename ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + >> + , ci::opt::compare< cmp > + , ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< rcu_type, bucket_type, + typename ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveMichaelLazySet, member_less ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_item_type member_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template less less; + typedef typename TestFixture::hash_int hash_int; + + typedef ci::LazyList< rcu_type + , member_item_type + , typename ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + , ci::opt::less< less > + , ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< rcu_type, bucket_type, + typename ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveMichaelLazySet, member_cmpmix ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_item_type member_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::hash_int hash_int; + + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; + typedef typename TestFixture::template less less; + typedef typename TestFixture::template cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< rcu_type, member_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef typename TestFixture::simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< rcu_type, bucket_type, set_traits > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveMichaelLazySet, member_mutex ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_mutex_item_type member_mutex_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::hash_int hash_int; + + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc, ci::opt::lock_type> hook; + typedef typename TestFixture::template less less; + typedef typename TestFixture::template cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< rcu_type, member_mutex_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef typename TestFixture::simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< rcu_type, bucket_type, set_traits > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + + +// GCC 5: All test names should be written on single line, otherwise a runtime error will be encountered like as +// "No test named can be found in this test case" +REGISTER_TYPED_TEST_CASE_P( IntrusiveMichaelLazySet, + base_cmp, base_less, base_cmpmix, base_mutex, member_cmp, member_less, member_cmpmix, member_mutex +); + + +#endif // CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_LAZY_RCU_H + \ No newline at end of file diff --git a/test/unit/intrusive-set/test_intrusive_michael_michael_rcu.h b/test/unit/intrusive-set/test_intrusive_michael_michael_rcu.h new file mode 100644 index 00000000..199fef5c --- /dev/null +++ b/test/unit/intrusive-set/test_intrusive_michael_michael_rcu.h @@ -0,0 +1,243 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +#ifndef CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_MICHAEL_RCU_H +#define CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_MICHAEL_RCU_H + +#include "test_intrusive_set_rcu.h" +#include +#include + +namespace ci = cds::intrusive; + +template +class IntrusiveMichaelSet: public cds_test::intrusive_set_rcu +{ + typedef cds_test::intrusive_set_rcu base_class; +public: + typedef cds::urcu::gc rcu_type; + typedef typename base_class::base_int_item< ci::michael_list::node> base_item_type; + typedef typename base_class::member_int_item< ci::michael_list::node> member_item_type; + +protected: + void SetUp() + { + RCU::Construct(); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + RCU::Destruct(); + } +}; + +TYPED_TEST_CASE_P( IntrusiveMichaelSet ); + +TYPED_TEST_P( IntrusiveMichaelSet, base_cmp ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_item_type base_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template cmp cmp; + typedef typename TestFixture::hash_int hash_int; + + typedef ci::MichaelList< rcu_type + , base_item_type + , typename ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< rcu_type > > > + , ci::opt::compare< cmp > + , ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< rcu_type, bucket_type, + typename ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveMichaelSet, base_less ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_item_type base_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template less less; + typedef typename TestFixture::hash_int hash_int; + + typedef ci::MichaelList< rcu_type + , base_item_type + , typename ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< rcu_type >>> + , ci::opt::less< less > + , ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< rcu_type, bucket_type, + typename ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveMichaelSet, base_cmpmix ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_item_type base_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::hash_int hash_int; + + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::base_hook< ci::opt::gc> hook; + typedef typename TestFixture::template less less; + typedef typename TestFixture::template cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::MichaelList< rcu_type, base_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef typename TestFixture::simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< rcu_type, bucket_type, set_traits > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + + +TYPED_TEST_P( IntrusiveMichaelSet, member_cmp ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_item_type member_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template cmp cmp; + typedef typename TestFixture::hash_int hash_int; + + typedef ci::MichaelList< rcu_type + , member_item_type + , typename ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + >> + , ci::opt::compare< cmp > + , ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< rcu_type, bucket_type, + typename ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveMichaelSet, member_less ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_item_type member_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template less less; + typedef typename TestFixture::hash_int hash_int; + + typedef ci::MichaelList< rcu_type + , member_item_type + , typename ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + , ci::opt::less< less > + , ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::MichaelHashSet< rcu_type, bucket_type, + typename ci::michael_set::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveMichaelSet, member_cmpmix ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_item_type member_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::hash_int hash_int; + + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; + typedef typename TestFixture::template less less; + typedef typename TestFixture::template cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::MichaelList< rcu_type, member_item_type, list_traits > bucket_type; + + struct set_traits : public ci::michael_set::traits + { + typedef hash_int hash; + typedef typename TestFixture::simple_item_counter item_counter; + }; + typedef ci::MichaelHashSet< rcu_type, bucket_type, set_traits > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + + + +// GCC 5: All test names should be written on single line, otherwise a runtime error will be encountered like as +// "No test named can be found in this test case" +REGISTER_TYPED_TEST_CASE_P( IntrusiveMichaelSet, + base_cmp, base_less, base_cmpmix, member_cmp, member_less, member_cmpmix +); + + +#endif // CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_MICHAEL_RCU_H + \ No newline at end of file diff --git a/test/unit/intrusive-set/test_intrusive_set.h b/test/unit/intrusive-set/test_intrusive_set.h new file mode 100644 index 00000000..d4ed3035 --- /dev/null +++ b/test/unit/intrusive-set/test_intrusive_set.h @@ -0,0 +1,450 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef CDSUNIT_SET_TEST_INTRUSIVE_SET_H +#define CDSUNIT_SET_TEST_INTRUSIVE_SET_H + +#include +#include + +#include +#include // ref + +// forward declaration +namespace cds { namespace intrusive {}} + +namespace cds_test { + + namespace ci = cds::intrusive; + namespace co = cds::opt; + + class intrusive_set: public fixture + { + public: + static size_t const kSize = 100; + + struct stat + { + unsigned int nDisposeCount ; // count of disposer calling + unsigned int nFindCount ; // count of find-functor calling + unsigned int nUpdateNewCount; + unsigned int nUpdateCount; + mutable unsigned int nEraseCount; + + stat() + { + clear_stat(); + } + + void clear_stat() + { + memset( this, 0, sizeof( *this ) ); + } + }; + + template + struct base_int_item + : public Node + , public stat + + { + int nKey; + int nVal; + + base_int_item() + {} + + explicit base_int_item( int key ) + : nKey( key ) + , nVal( key ) + {} + + base_int_item(int key, int val) + : nKey( key ) + , nVal(val) + {} + + base_int_item( base_int_item const& v ) + : Node() + , stat() + , nKey( v.nKey ) + , nVal( v.nVal ) + {} + + int key() const + { + return nKey; + } + }; + + template + struct member_int_item: public stat + { + int nKey; + int nVal; + + Node hMember; + + stat s; + + member_int_item() + {} + + explicit member_int_item( int key ) + : nKey( key ) + , nVal( key ) + {} + + member_int_item(int key, int val) + : nKey( key ) + , nVal(val) + {} + + member_int_item(member_int_item const& v ) + : stat() + , nKey( v.nKey ) + , nVal( v.nVal ) + {} + + int key() const + { + return nKey; + } + }; + + struct hash_int { + size_t operator()( int i ) const + { + return co::v::hash()( i ); + } + template + size_t operator()( const Item& i ) const + { + return (*this)( i.key() ); + } + }; + + struct simple_item_counter { + size_t m_nCount; + + simple_item_counter() + : m_nCount(0) + {} + + size_t operator ++() + { + return ++m_nCount; + } + + size_t operator --() + { + return --m_nCount; + } + + void reset() + { + m_nCount = 0; + } + + operator size_t() const + { + return m_nCount; + } + + }; + + + template + struct less + { + bool operator ()(const T& v1, const T& v2 ) const + { + return v1.key() < v2.key(); + } + + template + bool operator ()(const T& v1, const Q& v2 ) const + { + return v1.key() < v2; + } + + template + bool operator ()(const Q& v1, const T& v2 ) const + { + return v1 < v2.key(); + } + }; + + template + struct cmp { + int operator ()(const T& v1, const T& v2 ) const + { + if ( v1.key() < v2.key() ) + return -1; + return v1.key() > v2.key() ? 1 : 0; + } + + template + int operator ()(const T& v1, const Q& v2 ) const + { + if ( v1.key() < v2 ) + return -1; + return v1.key() > v2 ? 1 : 0; + } + + template + int operator ()(const Q& v1, const T& v2 ) const + { + if ( v1 < v2.key() ) + return -1; + return v1 > v2.key() ? 1 : 0; + } + }; + + struct other_item { + int nKey; + + explicit other_item( int k ) + : nKey( k ) + {} + + int key() const + { + return nKey; + } + }; + + struct other_less { + template + bool operator()( Q const& lhs, T const& rhs ) const + { + return lhs.key() < rhs.key(); + } + }; + + struct mock_disposer + { + template + void operator ()( T * p ) + { + ++p->nDisposeCount; + } + }; + + protected: + template + void test( Set& s ) + { + // Precondition: set is empty + // Postcondition: set is empty + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + size_t const nSetSize = kSize; + + typedef typename Set::value_type value_type; + + std::vector< value_type > data; + std::vector< size_t> indices; + data.reserve( kSize ); + indices.reserve( kSize ); + for ( size_t key = 0; key < kSize; ++key ) { + data.push_back( value_type( static_cast( key ))); + indices.push_back( key ); + } + shuffle( indices.begin(), indices.end() ); + + // insert/find + for ( auto idx : indices ) { + auto& i = data[ idx ]; + + ASSERT_FALSE( s.contains( i.nKey )); + ASSERT_FALSE( s.contains( i )); + ASSERT_FALSE( s.contains( other_item( i.key()), other_less())); + ASSERT_FALSE( s.find( i.nKey, []( value_type&, int ) {} )); + ASSERT_FALSE( s.find_with( other_item( i.key()), other_less(), []( value_type&, other_item const& ) {} )); + + std::pair updResult; + + updResult = s.update( i, []( bool bNew, value_type&, value_type& ) + { + ASSERT_TRUE( false ); + }, false ); + EXPECT_FALSE( updResult.first ); + EXPECT_FALSE( updResult.second ); + + switch ( i.key() % 3 ) { + case 0: + ASSERT_TRUE( s.insert( i )); + ASSERT_FALSE( s.insert( i )); + updResult = s.update( i, []( bool bNew, value_type& val, value_type& arg) + { + EXPECT_FALSE( bNew ); + EXPECT_EQ( &val, &arg ); + }, false ); + EXPECT_TRUE( updResult.first ); + EXPECT_FALSE( updResult.second ); + break; + case 1: + EXPECT_EQ( i.nUpdateNewCount, 0 ); + ASSERT_TRUE( s.insert( i, []( value_type& v ) { ++v.nUpdateNewCount;} )); + EXPECT_EQ( i.nUpdateNewCount, 1 ); + ASSERT_FALSE( s.insert( i, []( value_type& v ) { ++v.nUpdateNewCount;} ) ); + EXPECT_EQ( i.nUpdateNewCount, 1 ); + i.nUpdateNewCount = 0; + break; + case 2: + updResult = s.update( i, []( bool bNew, value_type& val, value_type& arg ) + { + EXPECT_TRUE( bNew ); + EXPECT_EQ( &val, &arg ); + }); + EXPECT_TRUE( updResult.first ); + EXPECT_TRUE( updResult.second ); + break; + } + + ASSERT_TRUE( s.contains( i.nKey ) ); + ASSERT_TRUE( s.contains( i ) ); + ASSERT_TRUE( s.contains( other_item( i.key() ), other_less())); + EXPECT_EQ( i.nFindCount, 0 ); + ASSERT_TRUE( s.find( i.nKey, []( value_type& v, int ) { ++v.nFindCount; } )); + EXPECT_EQ( i.nFindCount, 1 ); + ASSERT_TRUE( s.find_with( other_item( i.key() ), other_less(), []( value_type& v, other_item const& ) { ++v.nFindCount; } )); + EXPECT_EQ( i.nFindCount, 2 ); + } + ASSERT_FALSE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, nSetSize ); + + std::for_each( data.begin(), data.end(), []( value_type& v ) { v.clear_stat(); }); + + // erase + shuffle( indices.begin(), indices.end() ); + for ( auto idx : indices ) { + auto& i = data[ idx ]; + + ASSERT_TRUE( s.contains( i.nKey ) ); + ASSERT_TRUE( s.contains( i ) ); + ASSERT_TRUE( s.contains( other_item( i.key() ), other_less() ) ); + EXPECT_EQ( i.nFindCount, 0 ); + ASSERT_TRUE( s.find( i.nKey, []( value_type& v, int ) { ++v.nFindCount; } ) ); + EXPECT_EQ( i.nFindCount, 1 ); + ASSERT_TRUE( s.find_with( other_item( i.key() ), other_less(), []( value_type& v, other_item const& ) { ++v.nFindCount; } ) ); + EXPECT_EQ( i.nFindCount, 2 ); + + value_type v( i ); + switch ( i.key() % 6 ) { + case 0: + ASSERT_FALSE( s.unlink( v )); + ASSERT_TRUE( s.unlink( i )); + ASSERT_FALSE( s.unlink( i ) ); + break; + case 1: + ASSERT_TRUE( s.erase( i.key())); + ASSERT_FALSE( s.erase( i.key() ) ); + break; + case 2: + ASSERT_TRUE( s.erase( v )); + ASSERT_FALSE( s.erase( v ) ); + break; + case 3: + ASSERT_TRUE( s.erase_with( other_item( i.key()), other_less())); + ASSERT_FALSE( s.erase_with( other_item( i.key() ), other_less() ) ); + break; + case 4: + EXPECT_EQ( i.nEraseCount, 0 ); + ASSERT_TRUE( s.erase( v, []( value_type& val ) { ++val.nEraseCount; } )); + EXPECT_EQ( i.nEraseCount, 1 ); + ASSERT_FALSE( s.erase( v, []( value_type& val ) { ++val.nEraseCount; } )); + EXPECT_EQ( i.nEraseCount, 1 ); + break; + case 5: + EXPECT_EQ( i.nEraseCount, 0 ); + ASSERT_TRUE( s.erase_with( other_item( i.key() ), other_less(), []( value_type& val ) { ++val.nEraseCount; } )); + EXPECT_EQ( i.nEraseCount, 1 ); + ASSERT_FALSE( s.erase_with( other_item( i.key() ), other_less(), []( value_type& val ) { ++val.nEraseCount; } )); + EXPECT_EQ( i.nEraseCount, 1 ); + break; + } + + ASSERT_FALSE( s.contains( i.nKey )); + ASSERT_FALSE( s.contains( i )); + ASSERT_FALSE( s.contains( other_item( i.key()), other_less())); + ASSERT_FALSE( s.find( i.nKey, []( value_type&, int ) {} )); + ASSERT_FALSE( s.find_with( other_item( i.key()), other_less(), []( value_type&, other_item const& ) {} )); + } + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + // Force retiring cycle + Set::gc::force_dispose(); + for ( auto& i : data ) { + EXPECT_EQ( i.nDisposeCount, 1 ); + } + + // clear + for ( auto& i : data ) { + i.clear_stat(); + ASSERT_TRUE( s.insert( i )); + } + ASSERT_FALSE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, nSetSize ); + + // Iterator test + for ( auto it = s.begin(); it != s.end(); ++it ) { + ++it->nFindCount; + } + for ( auto it = s.cbegin(); it != s.cend(); ++it ) { + EXPECT_EQ( it->nFindCount, 1 ); + } + for ( auto& i : data ) { + EXPECT_EQ( i.nFindCount, 1 ); + } + + // clear test + s.clear(); + + ASSERT_TRUE( s.empty()); + ASSERT_CONTAINER_SIZE( s, 0 ); + ASSERT_TRUE( s.begin() == s.end() ); + ASSERT_TRUE( s.cbegin() == s.cend() ); + + // Force retiring cycle + Set::gc::force_dispose(); + for ( auto& i : data ) { + EXPECT_EQ( i.nDisposeCount, 1 ); + } + + } + }; + +} // namespace cds_test + +#endif // #ifndef CDSUNIT_SET_TEST_INTRUSIVE_SET_H diff --git a/test/unit/intrusive-set/test_intrusive_set_hp.h b/test/unit/intrusive-set/test_intrusive_set_hp.h new file mode 100644 index 00000000..7ae09c73 --- /dev/null +++ b/test/unit/intrusive-set/test_intrusive_set_hp.h @@ -0,0 +1,160 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef CDSUNIT_SET_TEST_INTRUSIVE_SET_HP_H +#define CDSUNIT_SET_TEST_INTRUSIVE_SET_HP_H + +#include "test_intrusive_set.h" + +// forward declaration +namespace cds { namespace intrusive {}} + +namespace cds_test { + + namespace ci = cds::intrusive; + namespace co = cds::opt; + + class intrusive_set_hp: public intrusive_set + { + typedef intrusive_set base_class; + + protected: + + template + void test( Set& s ) + { + // Precondition: set is empty + // Postcondition: set is empty + + base_class::test( s ); + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + typedef typename Set::value_type value_type; + + std::vector< value_type > data; + std::vector< size_t> indices; + data.reserve( kSize ); + indices.reserve( kSize ); + for ( size_t key = 0; key < kSize; ++key ) { + data.push_back( value_type( static_cast(key) ) ); + indices.push_back( key ); + } + shuffle( indices.begin(), indices.end() ); + + typename Set::guarded_ptr gp; + + // get/extract from empty set + for ( auto idx : indices ) { + auto& i = data[idx]; + + gp = s.get( i ); + ASSERT_TRUE( !gp ); + gp = s.get( i.key() ); + ASSERT_TRUE( !gp ); + gp = s.get_with( other_item( i.key()), other_less()); + ASSERT_TRUE( !gp ); + + gp = s.extract( i ); + ASSERT_TRUE( !gp ); + gp = s.extract( i.key()); + ASSERT_TRUE( !gp ); + gp = s.extract_with( other_item( i.key()), other_less()); + ASSERT_TRUE( !gp ); + } + + // fill set + for ( auto& i : data ) { + i.nDisposeCount = 0; + ASSERT_TRUE( s.insert( i ) ); + } + + // get/extract + for ( auto idx : indices ) { + auto& i = data[idx]; + + EXPECT_EQ( i.nFindCount, 0 ); + gp = s.get( i ); + ASSERT_FALSE( !gp ); + ++gp->nFindCount; + EXPECT_EQ( i.nFindCount, 1 ); + + gp = s.get( i.key() ); + ASSERT_FALSE( !gp ); + ++gp->nFindCount; + EXPECT_EQ( i.nFindCount, 2 ); + + gp = s.get_with( other_item( i.key()), other_less()); + ASSERT_FALSE( !gp ); + ++gp->nFindCount; + EXPECT_EQ( i.nFindCount, 3 ); + + EXPECT_EQ( i.nEraseCount, 0 ); + switch ( i.key() % 3 ) { + case 0: + gp = s.extract( i.key()); + break; + case 1: + gp = s.extract( i ); + break; + case 2: + gp = s.extract_with( other_item( i.key() ), other_less() ); + break; + } + ASSERT_FALSE( !gp ); + ++gp->nEraseCount; + EXPECT_EQ( i.nEraseCount, 1 ); + + gp = s.extract( i ); + ASSERT_TRUE( !gp ); + gp = s.extract( i.key() ); + ASSERT_TRUE( !gp ); + gp = s.extract_with( other_item( i.key() ), other_less() ); + ASSERT_TRUE( !gp ); + } + + gp.release(); + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + // Force retiring cycle + Set::gc::force_dispose(); + for ( auto& i : data ) { + EXPECT_EQ( i.nDisposeCount, 1 ); + } + + } + }; + +} // namespace cds_test + +#endif // #ifndef CDSUNIT_SET_TEST_INTRUSIVE_SET_HP_H diff --git a/test/unit/intrusive-set/test_intrusive_set_nogc.h b/test/unit/intrusive-set/test_intrusive_set_nogc.h new file mode 100644 index 00000000..46e06a55 --- /dev/null +++ b/test/unit/intrusive-set/test_intrusive_set_nogc.h @@ -0,0 +1,374 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef CDSUNIT_SET_TEST_INTRUSIVE_SET_NOGC_H +#define CDSUNIT_SET_TEST_INTRUSIVE_SET_NOGC_H + +#include +#include + +#include +#include // ref + +// forward declaration +namespace cds { namespace intrusive {}} + +namespace cds_test { + + namespace ci = cds::intrusive; + namespace co = cds::opt; + + class intrusive_set_nogc: public fixture + { + public: + static size_t const kSize = 100; + + struct stat + { + unsigned int nFindCount ; // count of find-functor calling + unsigned int nUpdateNewCount; + unsigned int nUpdateCount; + unsigned int nDisposeCount; + + stat() + { + clear_stat(); + } + + void clear_stat() + { + memset( this, 0, sizeof( *this ) ); + } + }; + + template + struct base_int_item + : public Node + , public stat + + { + int nKey; + int nVal; + + base_int_item() + {} + + explicit base_int_item( int key ) + : nKey( key ) + , nVal( key ) + {} + + base_int_item(int key, int val) + : nKey( key ) + , nVal(val) + {} + + base_int_item( base_int_item const& v ) + : Node() + , stat() + , nKey( v.nKey ) + , nVal( v.nVal ) + {} + + int key() const + { + return nKey; + } + }; + + template + struct member_int_item: public stat + { + int nKey; + int nVal; + + Node hMember; + + stat s; + + member_int_item() + {} + + explicit member_int_item( int key ) + : nKey( key ) + , nVal( key ) + {} + + member_int_item(int key, int val) + : nKey( key ) + , nVal(val) + {} + + member_int_item(member_int_item const& v ) + : stat() + , nKey( v.nKey ) + , nVal( v.nVal ) + {} + + int key() const + { + return nKey; + } + }; + + struct hash_int { + size_t operator()( int i ) const + { + return co::v::hash()( i ); + } + template + size_t operator()( const Item& i ) const + { + return (*this)( i.key() ); + } + }; + + struct simple_item_counter { + size_t m_nCount; + + simple_item_counter() + : m_nCount(0) + {} + + size_t operator ++() + { + return ++m_nCount; + } + + size_t operator --() + { + return --m_nCount; + } + + void reset() + { + m_nCount = 0; + } + + operator size_t() const + { + return m_nCount; + } + + }; + + + template + struct less + { + bool operator ()(const T& v1, const T& v2 ) const + { + return v1.key() < v2.key(); + } + + template + bool operator ()(const T& v1, const Q& v2 ) const + { + return v1.key() < v2; + } + + template + bool operator ()(const Q& v1, const T& v2 ) const + { + return v1 < v2.key(); + } + }; + + template + struct cmp { + int operator ()(const T& v1, const T& v2 ) const + { + if ( v1.key() < v2.key() ) + return -1; + return v1.key() > v2.key() ? 1 : 0; + } + + template + int operator ()(const T& v1, const Q& v2 ) const + { + if ( v1.key() < v2 ) + return -1; + return v1.key() > v2 ? 1 : 0; + } + + template + int operator ()(const Q& v1, const T& v2 ) const + { + if ( v1 < v2.key() ) + return -1; + return v1 > v2.key() ? 1 : 0; + } + }; + + struct other_item { + int nKey; + + explicit other_item( int k ) + : nKey( k ) + {} + + int key() const + { + return nKey; + } + }; + + struct other_less { + template + bool operator()( Q const& lhs, T const& rhs ) const + { + return lhs.key() < rhs.key(); + } + }; + + struct mock_disposer + { + template + void operator ()( T * p ) + { + ++p->nDisposeCount; + } + }; + + protected: + template + void test( Set& s ) + { + // Precondition: set is empty + // Postcondition: set is empty + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + size_t const nSetSize = kSize; + + typedef typename Set::value_type value_type; + + std::vector< value_type > data; + std::vector< size_t> indices; + data.reserve( kSize ); + indices.reserve( kSize ); + for ( size_t key = 0; key < kSize; ++key ) { + data.push_back( value_type( static_cast( key ))); + indices.push_back( key ); + } + shuffle( indices.begin(), indices.end() ); + + // insert/find + for ( auto idx : indices ) { + auto& i = data[ idx ]; + + ASSERT_TRUE( s.contains( i.nKey ) == nullptr ); + ASSERT_TRUE( s.contains( i ) == nullptr ); + ASSERT_TRUE( s.contains( other_item( i.key()), other_less()) == nullptr ); + ASSERT_FALSE( s.find( i.nKey, []( value_type&, int ) {} )); + ASSERT_FALSE( s.find_with( other_item( i.key()), other_less(), []( value_type&, other_item const& ) {} )); + + std::pair updResult; + + updResult = s.update( i, []( bool bNew, value_type&, value_type& ) + { + ASSERT_TRUE( false ); + }, false ); + EXPECT_FALSE( updResult.first ); + EXPECT_FALSE( updResult.second ); + + switch ( i.key() % 2 ) { + case 0: + ASSERT_TRUE( s.insert( i )); + ASSERT_FALSE( s.insert( i )); + EXPECT_EQ( i.nUpdateCount, 0 ); + updResult = s.update( i, []( bool bNew, value_type& val, value_type& arg) + { + EXPECT_FALSE( bNew ); + EXPECT_EQ( &val, &arg ); + ++val.nUpdateCount; + }, false ); + EXPECT_TRUE( updResult.first ); + EXPECT_FALSE( updResult.second ); + EXPECT_EQ( i.nUpdateCount, 1 ); + break; + case 1: + EXPECT_EQ( i.nUpdateNewCount, 0 ); + updResult = s.update( i, []( bool bNew, value_type& val, value_type& arg ) + { + EXPECT_TRUE( bNew ); + EXPECT_EQ( &val, &arg ); + ++val.nUpdateNewCount; + }); + EXPECT_TRUE( updResult.first ); + EXPECT_TRUE( updResult.second ); + EXPECT_EQ( i.nUpdateNewCount, 1 ); + break; + } + + ASSERT_TRUE( s.contains( i.nKey ) == &i ); + ASSERT_TRUE( s.contains( i ) == &i ); + ASSERT_TRUE( s.contains( other_item( i.key() ), other_less()) == &i ); + EXPECT_EQ( i.nFindCount, 0 ); + ASSERT_TRUE( s.find( i.nKey, []( value_type& v, int ) { ++v.nFindCount; } )); + EXPECT_EQ( i.nFindCount, 1 ); + ASSERT_TRUE( s.find_with( other_item( i.key() ), other_less(), []( value_type& v, other_item const& ) { ++v.nFindCount; } )); + EXPECT_EQ( i.nFindCount, 2 ); + } + ASSERT_FALSE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, nSetSize ); + + std::for_each( data.begin(), data.end(), []( value_type& v ) { v.clear_stat(); }); + + // Iterator test + for ( auto it = s.begin(); it != s.end(); ++it ) { + ++it->nFindCount; + } + for ( auto it = s.cbegin(); it != s.cend(); ++it ) { + EXPECT_EQ( it->nFindCount, 1 ); + } + for ( auto& i : data ) { + EXPECT_EQ( i.nFindCount, 1 ); + } + + // clear test + for ( auto& i : data ) { + EXPECT_EQ( i.nDisposeCount, 0 ); + } + s.clear(); + for ( auto& i : data ) { + EXPECT_EQ( i.nDisposeCount, 1 ); + } + + ASSERT_TRUE( s.empty()); + ASSERT_CONTAINER_SIZE( s, 0 ); + ASSERT_TRUE( s.begin() == s.end() ); + ASSERT_TRUE( s.cbegin() == s.cend() ); + } + }; + +} // namespace cds_test + +#endif // #ifndef CDSUNIT_SET_TEST_INTRUSIVE_SET_NOGC_H diff --git a/test/unit/intrusive-set/test_intrusive_set_rcu.h b/test/unit/intrusive-set/test_intrusive_set_rcu.h new file mode 100644 index 00000000..ff28bef3 --- /dev/null +++ b/test/unit/intrusive-set/test_intrusive_set_rcu.h @@ -0,0 +1,212 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef CDSUNIT_SET_TEST_INTRUSIVE_SET_RCU_H +#define CDSUNIT_SET_TEST_INTRUSIVE_SET_RCU_H + +#include "test_intrusive_set.h" + +// forward declaration +namespace cds { namespace intrusive {}} + +namespace cds_test { + + namespace ci = cds::intrusive; + namespace co = cds::opt; + + class intrusive_set_rcu: public intrusive_set + { + typedef intrusive_set base_class; + + protected: + + template + void test( Set& s ) + { + // Precondition: set is empty + // Postcondition: set is empty + + base_class::test( s ); + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + typedef typename Set::value_type value_type; + + std::vector< value_type > data; + std::vector< size_t> indices; + data.reserve( kSize ); + indices.reserve( kSize ); + for ( size_t key = 0; key < kSize; ++key ) { + data.push_back( value_type( static_cast(key) ) ); + indices.push_back( key ); + } + shuffle( indices.begin(), indices.end() ); + + typename Set::exempt_ptr xp; + typename Set::raw_ptr rp; + typedef typename Set::rcu_lock rcu_lock; + + // get/extract from empty set + for ( auto idx : indices ) { + auto& i = data[idx]; + + { + rcu_lock l; + rp = s.get( i ); + ASSERT_TRUE( !rp ); + rp = s.get( i.key() ); + ASSERT_TRUE( !rp ); + rp = s.get_with( other_item( i.key()), other_less()); + ASSERT_TRUE( !rp ); + } + + if ( Set::c_bExtractLockExternal ) { + rcu_lock l; + + xp = s.extract( i ); + ASSERT_TRUE( !xp ); + xp = s.extract( i.key() ); + ASSERT_TRUE( !xp ); + xp = s.extract_with( other_item( i.key() ), other_less() ); + ASSERT_TRUE( !xp ); + } + else { + xp = s.extract( i ); + ASSERT_TRUE( !xp ); + xp = s.extract( i.key() ); + ASSERT_TRUE( !xp ); + xp = s.extract_with( other_item( i.key() ), other_less() ); + ASSERT_TRUE( !xp ); + } + } + + // fill set + for ( auto& i : data ) { + i.nDisposeCount = 0; + ASSERT_TRUE( s.insert( i ) ); + } + + // get/extract + for ( auto idx : indices ) { + auto& i = data[idx]; + + { + rcu_lock l; + EXPECT_EQ( i.nFindCount, 0 ); + rp = s.get( i ); + ASSERT_FALSE( !rp ); + ++rp->nFindCount; + EXPECT_EQ( i.nFindCount, 1 ); + + rp = s.get( i.key() ); + ASSERT_FALSE( !rp ); + ++rp->nFindCount; + EXPECT_EQ( i.nFindCount, 2 ); + + rp = s.get_with( other_item( i.key()), other_less()); + ASSERT_FALSE( !rp ); + ++rp->nFindCount; + EXPECT_EQ( i.nFindCount, 3 ); + } + + if ( Set::c_bExtractLockExternal ) { + { + rcu_lock l; + + EXPECT_EQ( i.nEraseCount, 0 ); + switch ( i.key() % 3 ) { + case 0: + xp = s.extract( i.key()); + break; + case 1: + xp = s.extract( i ); + break; + case 2: + xp = s.extract_with( other_item( i.key() ), other_less() ); + break; + } + ASSERT_FALSE( !xp ); + ++xp->nEraseCount; + } + EXPECT_EQ( i.nEraseCount, 1 ); + xp.release(); + + { + rcu_lock l; + + xp = s.extract( i ); + ASSERT_TRUE( !xp ); + xp = s.extract( i.key() ); + ASSERT_TRUE( !xp ); + xp = s.extract_with( other_item( i.key() ), other_less() ); + ASSERT_TRUE( !xp ); + } + } + else { + EXPECT_EQ( i.nEraseCount, 0 ); + switch ( i.key() % 3 ) { + case 0: + xp = s.extract( i.key()); + break; + case 1: + xp = s.extract( i ); + break; + case 2: + xp = s.extract_with( other_item( i.key() ), other_less() ); + break; + } + ASSERT_FALSE( !xp ); + ++xp->nEraseCount; + EXPECT_EQ( i.nEraseCount, 1 ); + + xp = s.extract( i ); + ASSERT_TRUE( !xp ); + xp = s.extract( i.key() ); + ASSERT_TRUE( !xp ); + xp = s.extract_with( other_item( i.key() ), other_less() ); + ASSERT_TRUE( !xp ); + } + } + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + // Force retiring cycle + Set::gc::force_dispose(); + for ( auto& i : data ) { + EXPECT_EQ( i.nDisposeCount, 1 ); + } + } + }; + +} // namespace cds_test + +#endif // #ifndef CDSUNIT_SET_TEST_INTRUSIVE_SET_RCU_H diff --git a/test/unit/intrusive-set/test_intrusive_skiplist_rcu.h b/test/unit/intrusive-set/test_intrusive_skiplist_rcu.h new file mode 100644 index 00000000..ddaa8dd1 --- /dev/null +++ b/test/unit/intrusive-set/test_intrusive_skiplist_rcu.h @@ -0,0 +1,248 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +#ifndef CDSUNIT_SET_TEST_INTRUSIVE_SKIPLIST_RCU_H +#define CDSUNIT_SET_TEST_INTRUSIVE_SKIPLIST_RCU_H + +#include "test_intrusive_set_rcu.h" +#include + +namespace ci = cds::intrusive; + +template +class IntrusiveSkipListSet: public cds_test::intrusive_set_rcu +{ + typedef cds_test::intrusive_set_rcu base_class; +public: + typedef cds::urcu::gc rcu_type; + typedef typename base_class::base_int_item< ci::skip_list::node> base_item_type; + typedef typename base_class::member_int_item< ci::skip_list::node> member_item_type; + +protected: + void SetUp() + { + RCU::Construct(); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + RCU::Destruct(); + } +}; + +TYPED_TEST_CASE_P( IntrusiveSkipListSet ); + +TYPED_TEST_P( IntrusiveSkipListSet, base_cmp ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_item_type base_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template cmp cmp; + + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + }; + + typedef ci::SkipListSet< rcu_type, base_item_type, traits > set_type; + + set_type s; + this->test( s ); +} + +TYPED_TEST_P( IntrusiveSkipListSet, base_less ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_item_type base_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template less less_predicate; + + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook; + typedef mock_disposer disposer; + typedef less_predicate less; + typedef cds::atomicity::item_counter item_counter; + }; + + typedef ci::SkipListSet< rcu_type, base_item_type, traits > set_type; + + set_type s; + this->test( s ); +} + +TYPED_TEST_P( IntrusiveSkipListSet, base_cmpmix ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_item_type base_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template cmp cmp; + typedef typename TestFixture::template less less_predicate; + + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + typedef less_predicate less; + typedef ci::skip_list::stat<> stat; + }; + + typedef ci::SkipListSet< rcu_type, base_item_type, traits > set_type; + + set_type s; + this->test( s ); +} + +TYPED_TEST_P( IntrusiveSkipListSet, base_xorshift ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_item_type base_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template cmp cmp; + + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + typedef ci::skip_list::xorshift random_level_generator; + }; + + typedef ci::SkipListSet< rcu_type, base_item_type, traits > set_type; + + set_type s; + this->test( s ); +} + + +TYPED_TEST_P( IntrusiveSkipListSet, member_cmp ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_item_type member_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template cmp cmp; + + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + }; + + typedef ci::SkipListSet< rcu_type, member_item_type, traits > set_type; + + set_type s; + this->test( s ); +} + +TYPED_TEST_P( IntrusiveSkipListSet, member_less ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_item_type member_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template less less_predicate; + typedef typename TestFixture::hash_int hash_int; + + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook; + typedef mock_disposer disposer; + typedef less_predicate less; + typedef cds::atomicity::item_counter item_counter; + typedef ci::opt::v::sequential_consistent memory_model; + }; + + typedef ci::SkipListSet< rcu_type, member_item_type, traits > set_type; + + set_type s; + this->test( s ); +} + +TYPED_TEST_P( IntrusiveSkipListSet, member_cmpmix ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_item_type member_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template less less_predicate; + typedef typename TestFixture::template cmp cmp; + + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + typedef less_predicate less; + typedef ci::skip_list::stat<> stat; + }; + + typedef ci::SkipListSet< rcu_type, member_item_type, traits > set_type; + + set_type s; + this->test( s ); +} + +TYPED_TEST_P( IntrusiveSkipListSet, member_xorshift ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_item_type member_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template less less_predicate; + typedef typename TestFixture::template cmp cmp; + + struct traits : public ci::skip_list::traits + { + typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook; + typedef mock_disposer disposer; + typedef cmp compare; + typedef less_predicate less; + typedef ci::skip_list::stat<> stat; + typedef ci::skip_list::xorshift random_level_generator; + }; + + typedef ci::SkipListSet< rcu_type, member_item_type, traits > set_type; + + set_type s; + this->test( s ); +} + + +// GCC 5: All test names should be written on single line, otherwise a runtime error will be encountered like as +// "No test named can be found in this test case" +REGISTER_TYPED_TEST_CASE_P( IntrusiveSkipListSet, + base_cmp, base_less, base_cmpmix, base_xorshift, member_cmp, member_less, member_cmpmix, member_xorshift +); + + +#endif // CDSUNIT_SET_TEST_INTRUSIVE_SKIPLIST_RCU_H + \ No newline at end of file diff --git a/test/unit/intrusive-set/test_intrusive_split_lazy_rcu.h b/test/unit/intrusive-set/test_intrusive_split_lazy_rcu.h new file mode 100644 index 00000000..33ab6fd5 --- /dev/null +++ b/test/unit/intrusive-set/test_intrusive_split_lazy_rcu.h @@ -0,0 +1,302 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +#ifndef CDSUNIT_SET_TEST_INTRUSIVE_SPLIT_LAZY_RCU_H +#define CDSUNIT_SET_TEST_INTRUSIVE_SPLIT_LAZY_RCU_H + +#include "test_intrusive_set_rcu.h" +#include +#include + +namespace ci = cds::intrusive; + +template +class IntrusiveSplitLazySet: public cds_test::intrusive_set_rcu +{ + typedef cds_test::intrusive_set_rcu base_class; +public: + typedef cds::urcu::gc rcu_type; + typedef typename base_class::base_int_item< ci::split_list::node>> base_item_type; + typedef typename base_class::base_int_item< ci::split_list::node>> base_mutex_item_type; + typedef typename base_class::member_int_item< ci::split_list::node>> member_item_type; + typedef typename base_class::member_int_item< ci::split_list::node>> member_mutex_item_type; + +protected: + void SetUp() + { + RCU::Construct(); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + RCU::Destruct(); + } +}; + +TYPED_TEST_CASE_P( IntrusiveSplitLazySet ); + +TYPED_TEST_P( IntrusiveSplitLazySet, base_cmp ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_item_type base_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template cmp cmp; + typedef typename TestFixture::hash_int hash_int; + + typedef ci::LazyList< rcu_type + , base_item_type + , typename ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< rcu_type > > > + , ci::opt::compare< cmp > + , ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< rcu_type, bucket_type, + typename ci::split_list::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveSplitLazySet, base_less ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_item_type base_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template less less; + typedef typename TestFixture::hash_int hash_int; + + typedef ci::LazyList< rcu_type + , base_item_type + , typename ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< rcu_type >>> + , ci::opt::less< less > + , ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< rcu_type, bucket_type, + typename ci::split_list::make_traits< + ci::opt::hash< hash_int > + , ci::opt::item_counter< cds::atomicity::item_counter > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveSplitLazySet, base_cmpmix ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_item_type base_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::hash_int hash_int; + + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc> hook; + typedef typename TestFixture::template less less; + typedef typename TestFixture::template cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< rcu_type, base_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef typename TestFixture::simple_item_counter item_counter; + typedef ci::split_list::stat<> stat; + }; + typedef ci::SplitListSet< rcu_type, bucket_type, set_traits > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveSplitLazySet, base_mutex ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_mutex_item_type base_mutex_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::hash_int hash_int; + + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< ci::opt::gc, ci::opt::lock_type> hook; + typedef typename TestFixture::template less less; + typedef typename TestFixture::template cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< rcu_type, base_mutex_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef typename TestFixture::simple_item_counter item_counter; + typedef cds::backoff::empty back_off; + }; + typedef ci::SplitListSet< rcu_type, bucket_type, set_traits > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + + +TYPED_TEST_P( IntrusiveSplitLazySet, member_cmp ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_item_type member_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template cmp cmp; + typedef typename TestFixture::hash_int hash_int; + + typedef ci::LazyList< rcu_type + , member_item_type + , typename ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + >> + , ci::opt::compare< cmp > + , ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< rcu_type, bucket_type, + typename ci::split_list::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveSplitLazySet, member_less ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_item_type member_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template less less; + typedef typename TestFixture::hash_int hash_int; + + typedef ci::LazyList< rcu_type + , member_item_type + , typename ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + , ci::opt::less< less > + , ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< rcu_type, bucket_type, + typename ci::split_list::make_traits< + ci::opt::hash< hash_int > + , ci::opt::back_off< cds::backoff::pause > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveSplitLazySet, member_cmpmix ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_item_type member_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::hash_int hash_int; + + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; + typedef typename TestFixture::template less less; + typedef typename TestFixture::template cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< rcu_type, member_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef typename TestFixture::simple_item_counter item_counter; + }; + typedef ci::SplitListSet< rcu_type, bucket_type, set_traits > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveSplitLazySet, member_mutex ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_mutex_item_type member_mutex_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::hash_int hash_int; + + struct list_traits : public ci::lazy_list::traits + { + typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc, ci::opt::lock_type> hook; + typedef typename TestFixture::template less less; + typedef typename TestFixture::template cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::LazyList< rcu_type, member_mutex_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef typename TestFixture::simple_item_counter item_counter; + }; + typedef ci::SplitListSet< rcu_type, bucket_type, set_traits > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + + +// GCC 5: All test names should be written on single line, otherwise a runtime error will be encountered like as +// "No test named can be found in this test case" +REGISTER_TYPED_TEST_CASE_P( IntrusiveSplitLazySet, + base_cmp, base_less, base_cmpmix, base_mutex, member_cmp, member_less, member_cmpmix, member_mutex +); + + +#endif // CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_LAZY_RCU_H + \ No newline at end of file diff --git a/test/unit/intrusive-set/test_intrusive_split_michael_rcu.h b/test/unit/intrusive-set/test_intrusive_split_michael_rcu.h new file mode 100644 index 00000000..e67097f7 --- /dev/null +++ b/test/unit/intrusive-set/test_intrusive_split_michael_rcu.h @@ -0,0 +1,246 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +#ifndef CDSUNIT_SET_TEST_INTRUSIVE_SPLIT_MICHAEL_RCU_H +#define CDSUNIT_SET_TEST_INTRUSIVE_SPLIT_MICHAEL_RCU_H + +#include "test_intrusive_set_rcu.h" +#include +#include + +namespace ci = cds::intrusive; + +template +class IntrusiveSplitMichaelSet: public cds_test::intrusive_set_rcu +{ + typedef cds_test::intrusive_set_rcu base_class; +public: + typedef cds::urcu::gc rcu_type; + typedef typename base_class::base_int_item< ci::split_list::node>> base_item_type; + typedef typename base_class::member_int_item< ci::split_list::node>> member_item_type; + +protected: + void SetUp() + { + RCU::Construct(); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + RCU::Destruct(); + } +}; + +TYPED_TEST_CASE_P( IntrusiveSplitMichaelSet ); + +TYPED_TEST_P( IntrusiveSplitMichaelSet, base_cmp ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_item_type base_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template cmp cmp; + typedef typename TestFixture::hash_int hash_int; + + typedef ci::MichaelList< rcu_type + , base_item_type + , typename ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< rcu_type > > > + , ci::opt::compare< cmp > + , ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< rcu_type, bucket_type, + typename ci::split_list::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveSplitMichaelSet, base_less ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_item_type base_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template less less; + typedef typename TestFixture::hash_int hash_int; + + typedef ci::MichaelList< rcu_type + , base_item_type + , typename ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< rcu_type >>> + , ci::opt::less< less > + , ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< rcu_type, bucket_type, + typename ci::split_list::make_traits< + ci::opt::hash< hash_int > + , ci::opt::item_counter< cds::atomicity::item_counter > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveSplitMichaelSet, base_cmpmix ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::base_item_type base_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::hash_int hash_int; + + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::base_hook< ci::opt::gc> hook; + typedef typename TestFixture::template less less; + typedef typename TestFixture::template cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::MichaelList< rcu_type, base_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef typename TestFixture::simple_item_counter item_counter; + typedef ci::split_list::stat<> stat; + }; + typedef ci::SplitListSet< rcu_type, bucket_type, set_traits > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + + +TYPED_TEST_P( IntrusiveSplitMichaelSet, member_cmp ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_item_type member_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template cmp cmp; + typedef typename TestFixture::hash_int hash_int; + + typedef ci::MichaelList< rcu_type + , member_item_type + , typename ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + >> + , ci::opt::compare< cmp > + , ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< rcu_type, bucket_type, + typename ci::split_list::make_traits< + ci::opt::hash< hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveSplitMichaelSet, member_less ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_item_type member_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::template less less; + typedef typename TestFixture::hash_int hash_int; + + typedef ci::MichaelList< rcu_type + , member_item_type + , typename ci::michael_list::make_traits< + ci::opt::hook< ci::michael_list::member_hook< + offsetof( member_item_type, hMember ), + ci::opt::gc + > > + , ci::opt::less< less > + , ci::opt::disposer< mock_disposer > + >::type + > bucket_type; + + typedef ci::SplitListSet< rcu_type, bucket_type, + typename ci::split_list::make_traits< + ci::opt::hash< hash_int > + , ci::opt::back_off< cds::backoff::pause > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( IntrusiveSplitMichaelSet, member_cmpmix ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::member_item_type member_item_type; + typedef typename TestFixture::mock_disposer mock_disposer; + typedef typename TestFixture::hash_int hash_int; + + struct list_traits : public ci::michael_list::traits + { + typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; + typedef typename TestFixture::template less less; + typedef typename TestFixture::template cmp compare; + typedef mock_disposer disposer; + }; + typedef ci::MichaelList< rcu_type, member_item_type, list_traits > bucket_type; + + struct set_traits : public ci::split_list::traits + { + typedef hash_int hash; + typedef typename TestFixture::simple_item_counter item_counter; + }; + typedef ci::SplitListSet< rcu_type, bucket_type, set_traits > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + + + +// GCC 5: All test names should be written on single line, otherwise a runtime error will be encountered like as +// "No test named can be found in this test case" +REGISTER_TYPED_TEST_CASE_P( IntrusiveSplitMichaelSet, + base_cmp, base_less, base_cmpmix, member_cmp, member_less, member_cmpmix +); + + +#endif // CDSUNIT_SET_TEST_INTRUSIVE_SPLIT_MICHAEL_RCU_H + \ No newline at end of file diff --git a/test/unit/intrusive-set/test_michael_michael_rcu.h b/test/unit/intrusive-set/test_michael_michael_rcu.h new file mode 100644 index 00000000..99f75ee6 --- /dev/null +++ b/test/unit/intrusive-set/test_michael_michael_rcu.h @@ -0,0 +1,204 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +#ifndef CDSUNIT_SET_TEST_MICHAEL_MICHAEL_RCU_H +#define CDSUNIT_SET_TEST_MICHAEL_MICHAEL_RCU_H + +#include "test_set_rcu.h" +#include +#include + +namespace cc = cds::container; + +template +class MichaelSet: public cds_test::container_set_rcu +{ + typedef cds_test::container_set_rcu base_class; +public: + typedef cds::urcu::gc rcu_type; + +protected: + void SetUp() + { + RCU::Construct(); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + RCU::Destruct(); + } +}; + +TYPED_TEST_CASE_P( MichaelSet ); + +TYPED_TEST_P( MichaelSet, compare ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::int_item int_item; + + typedef cc::MichaelList< rcu_type, int_item, + typename cc::michael_list::make_traits< + cds::opt::compare< typename TestFixture::cmp > + >::type + > list_type; + + typedef cc::MichaelHashSet< rcu_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< typename TestFixture::hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( MichaelSet, less ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::int_item int_item; + + typedef cc::MichaelList< rcu_type, int_item, + typename cc::michael_list::make_traits< + cds::opt::less< typename TestFixture::less > + >::type + > list_type; + + typedef cc::MichaelHashSet< rcu_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< typename TestFixture::hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( MichaelSet, cmpmix ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::int_item int_item; + + struct list_traits : public cc::michael_list::traits + { + typedef typename TestFixture::less less; + typedef typename TestFixture::cmp compare; + }; + typedef cc::MichaelList< rcu_type, int_item, list_traits > list_type; + + typedef cc::MichaelHashSet< rcu_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< typename TestFixture::hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( MichaelSet, item_counting ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::int_item int_item; + + struct list_traits : public cc::michael_list::traits + { + typedef typename TestFixture::cmp compare; + }; + typedef cc::MichaelList< rcu_type, int_item, list_traits > list_type; + + struct set_traits: public cc::michael_set::traits + { + typedef typename TestFixture::hash_int hash; + typedef typename TestFixture::simple_item_counter item_counter; + }; + typedef cc::MichaelHashSet< rcu_type, list_type, set_traits >set_type; + + set_type s( TestFixture::kSize, 3 ); + this->test( s ); +} + +TYPED_TEST_P( MichaelSet, backoff ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::int_item int_item; + + struct list_traits : public cc::michael_list::traits + { + typedef typename TestFixture::cmp compare; + typedef cds::backoff::exponential back_off; + }; + typedef cc::MichaelList< rcu_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef typename TestFixture::hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< rcu_type, list_type, set_traits >set_type; + + set_type s( TestFixture::kSize, 4 ); + this->test( s ); +} + +TYPED_TEST_P( MichaelSet, seq_cst ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::int_item int_item; + + struct list_traits : public cc::michael_list::traits + { + typedef typename TestFixture::less less; + typedef cds::backoff::pause back_off; + typedef cds::opt::v::sequential_consistent memory_model; + }; + typedef cc::MichaelList< rcu_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef typename TestFixture::hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< rcu_type, list_type, set_traits >set_type; + + set_type s( TestFixture::kSize, 4 ); + this->test( s ); +} + + +// GCC 5: All test names should be written on single line, otherwise a runtime error will be encountered like as +// "No test named can be found in this test case" +REGISTER_TYPED_TEST_CASE_P( MichaelSet, + compare, less, cmpmix, item_counting, backoff, seq_cst +); + + +#endif // CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_MICHAEL_RCU_H + \ No newline at end of file diff --git a/test/unit/intrusive-set/test_set.h b/test/unit/intrusive-set/test_set.h new file mode 100644 index 00000000..1f6e142a --- /dev/null +++ b/test/unit/intrusive-set/test_set.h @@ -0,0 +1,507 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef CDSUNIT_SET_TEST_SET_H +#define CDSUNIT_SET_TEST_SET_H + +#include +#include + +#include +#include // ref + +// forward declaration +namespace cds { namespace container {}} + +namespace cds_test { + namespace co = cds::opt; + + class container_set : public fixture + { + public: + static size_t const kSize = 100; + + struct stat + { + unsigned int nFindCount; + unsigned int nUpdateNewCount; + unsigned int nUpdateCount; + mutable unsigned int nEraseCount; + + stat() + { + clear_stat(); + } + + void clear_stat() + { + memset( this, 0, sizeof( *this ) ); + } + }; + + struct other_item { + int nKey; + + explicit other_item( int k ) + : nKey( k ) + {} + + int key() const + { + return nKey; + } + }; + + struct int_item: public stat + { + int nKey; + int nVal; + std::string strVal; + + int_item() + : nKey( 0 ) + , nVal( 0 ) + {} + + explicit int_item( int k ) + : nKey( k ) + , nVal( k * 2 ) + {} + + template + explicit int_item( Q const& src ) + : nKey( src.key() ) + , nVal( 0 ) + {} + + int_item( int_item const& src ) + : nKey( src.nKey ) + , nVal( src.nVal ) + , strVal( src.strVal ) + {} + + int_item( int_item&& src ) + : nKey( src.nKey ) + , nVal( src.nVal ) + , strVal( std::move( src.strVal ) ) + {} + + int_item( int k, std::string&& s ) + : nKey( k ) + , nVal( k * 2 ) + , strVal( std::move( s ) ) + {} + + explicit int_item( other_item const& s ) + : nKey( s.key() ) + , nVal( s.key() * 2 ) + {} + + int key() const + { + return nKey; + } + }; + + struct hash_int { + size_t operator()( int i ) const + { + return co::v::hash()(i); + } + template + size_t operator()( const Item& i ) const + { + return (*this)(i.key()); + } + }; + + struct simple_item_counter { + size_t m_nCount; + + simple_item_counter() + : m_nCount( 0 ) + {} + + size_t operator ++() + { + return ++m_nCount; + } + + size_t operator --() + { + return --m_nCount; + } + + void reset() + { + m_nCount = 0; + } + + operator size_t() const + { + return m_nCount; + } + + }; + + struct less + { + bool operator ()( int_item const& v1, int_item const& v2 ) const + { + return v1.key() < v2.key(); + } + + template + bool operator ()( int_item const& v1, const Q& v2 ) const + { + return v1.key() < v2; + } + + template + bool operator ()( const Q& v1, int_item const& v2 ) const + { + return v1 < v2.key(); + } + }; + + struct cmp { + int operator ()( int_item const& v1, int_item const& v2 ) const + { + if ( v1.key() < v2.key() ) + return -1; + return v1.key() > v2.key() ? 1 : 0; + } + + template + int operator ()( T const& v1, int v2 ) const + { + if ( v1.key() < v2 ) + return -1; + return v1.key() > v2 ? 1 : 0; + } + + template + int operator ()( int v1, T const& v2 ) const + { + if ( v1 < v2.key() ) + return -1; + return v1 > v2.key() ? 1 : 0; + } + }; + + struct other_less { + template + bool operator()( Q const& lhs, T const& rhs ) const + { + return lhs.key() < rhs.key(); + } + }; + + protected: + template + void test( Set& s ) + { + // Precondition: set is empty + // Postcondition: set is empty + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + size_t const nSetSize = kSize; + + typedef typename Set::value_type value_type; + + std::vector< value_type > data; + std::vector< size_t> indices; + data.reserve( kSize ); + indices.reserve( kSize ); + for ( size_t key = 0; key < kSize; ++key ) { + data.push_back( value_type( static_cast(key) ) ); + indices.push_back( key ); + } + shuffle( indices.begin(), indices.end() ); + + // insert/find + for ( auto idx : indices ) { + auto& i = data[idx]; + + ASSERT_FALSE( s.contains( i.nKey ) ); + ASSERT_FALSE( s.contains( i ) ); + ASSERT_FALSE( s.contains( other_item( i.key() ), other_less())); + ASSERT_FALSE( s.find( i.nKey, []( value_type&, int ) {} )); + ASSERT_FALSE( s.find( i, []( value_type&, value_type const& ) {} )); + ASSERT_FALSE( s.find_with( other_item( i.key()), other_less(), []( value_type&, other_item const& ) {} )); + + std::pair updResult; + + std::string str; + updResult = s.update( i.key(), []( bool bNew, value_type&, int ) + { + ASSERT_TRUE( false ); + }, false ); + EXPECT_FALSE( updResult.first ); + EXPECT_FALSE( updResult.second ); + + switch ( idx % 8 ) { + case 0: + ASSERT_TRUE( s.insert( i )); + ASSERT_FALSE( s.insert( i )); + updResult = s.update( i, []( bool bNew, value_type& val, value_type const& arg) + { + EXPECT_FALSE( bNew ); + EXPECT_EQ( val.key(), arg.key() ); + }, false ); + EXPECT_TRUE( updResult.first ); + EXPECT_FALSE( updResult.second ); + break; + case 1: + ASSERT_TRUE( s.insert( i.key() )); + ASSERT_FALSE( s.insert( i.key() )); + updResult = s.update( i.key(), []( bool bNew, value_type& val, int arg) + { + EXPECT_FALSE( bNew ); + EXPECT_EQ( val.key(), arg ); + }, false ); + EXPECT_TRUE( updResult.first ); + EXPECT_FALSE( updResult.second ); + break; + case 2: + ASSERT_TRUE( s.insert( i, []( value_type& v ) { ++v.nFindCount; } )); + ASSERT_FALSE( s.insert( i, []( value_type& v ) { ++v.nFindCount; } )); + ASSERT_TRUE( s.find( i.nKey, []( value_type const& v, int key ) + { + EXPECT_EQ( v.key(), key ); + EXPECT_EQ( v.nFindCount, 1 ); + })); + break; + case 3: + ASSERT_TRUE( s.insert( i.key(), []( value_type& v ) { ++v.nFindCount; } )); + ASSERT_FALSE( s.insert( i.key(), []( value_type& v ) { ++v.nFindCount; } )); + ASSERT_TRUE( s.find( i.nKey, []( value_type const& v, int key ) + { + EXPECT_EQ( v.key(), key ); + EXPECT_EQ( v.nFindCount, 1 ); + })); + break; + case 4: + updResult = s.update( i, []( bool bNew, value_type& v, value_type const& arg ) + { + EXPECT_TRUE( bNew ); + EXPECT_EQ( v.key(), arg.key() ); + ++v.nUpdateNewCount; + }); + EXPECT_TRUE( updResult.first ); + EXPECT_TRUE( updResult.second ); + + updResult = s.update( i, []( bool bNew, value_type& v, value_type const& arg ) + { + EXPECT_FALSE( bNew ); + EXPECT_EQ( v.key(), arg.key() ); + ++v.nUpdateNewCount; + }, false ); + EXPECT_TRUE( updResult.first ); + EXPECT_FALSE( updResult.second ); + + ASSERT_TRUE( s.find( i.nKey, []( value_type const& v, int key ) + { + EXPECT_EQ( v.key(), key ); + EXPECT_EQ( v.nUpdateNewCount, 2 ); + })); + break; + case 5: + updResult = s.update( i.key(), []( bool bNew, value_type& v, int arg ) + { + EXPECT_TRUE( bNew ); + EXPECT_EQ( v.key(), arg ); + ++v.nUpdateNewCount; + }); + EXPECT_TRUE( updResult.first ); + EXPECT_TRUE( updResult.second ); + + updResult = s.update( i.key(), []( bool bNew, value_type& v, int arg ) + { + EXPECT_FALSE( bNew ); + EXPECT_EQ( v.key(), arg ); + ++v.nUpdateNewCount; + }, false ); + EXPECT_TRUE( updResult.first ); + EXPECT_FALSE( updResult.second ); + + ASSERT_TRUE( s.find( i, []( value_type const& v, value_type const& arg ) + { + EXPECT_EQ( v.key(), arg.key() ); + EXPECT_EQ( v.nUpdateNewCount, 2 ); + })); + break; + case 6: + ASSERT_TRUE( s.emplace( i.key())); + ASSERT_TRUE( s.find( i, []( value_type const& v, value_type const& arg ) + { + EXPECT_EQ( v.key(), arg.key() ); + EXPECT_EQ( v.nVal, arg.nVal ); + })); + break; + case 7: + str = "Hello!"; + ASSERT_TRUE( s.emplace( i.key(), std::move( str ))); + EXPECT_TRUE( str.empty()); + ASSERT_TRUE( s.find( i, []( value_type const& v, value_type const& arg ) + { + EXPECT_EQ( v.key(), arg.key() ); + EXPECT_EQ( v.nVal, arg.nVal ); + EXPECT_EQ( v.strVal, std::string( "Hello!" )); + } ) ); + break; + default: + // forgot anything?.. + ASSERT_TRUE( false ); + } + + ASSERT_TRUE( s.contains( i.nKey ) ); + ASSERT_TRUE( s.contains( i ) ); + ASSERT_TRUE( s.contains( other_item( i.key() ), other_less() ) ); + ASSERT_TRUE( s.find( i.nKey, []( value_type&, int ) {} ) ); + ASSERT_TRUE( s.find( i, []( value_type&, value_type const& ) {} ) ); + ASSERT_TRUE( s.find_with( other_item( i.key() ), other_less(), []( value_type&, other_item const& ) {} ) ); + } + + ASSERT_FALSE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, nSetSize ); + + // erase + shuffle( indices.begin(), indices.end() ); + for ( auto idx : indices ) { + auto& i = data[idx]; + + ASSERT_TRUE( s.contains( i.nKey ) ); + ASSERT_TRUE( s.contains( i ) ); + ASSERT_TRUE( s.contains( other_item( i.key() ), other_less() ) ); + ASSERT_TRUE( s.find( i.nKey, []( value_type& v, int ) + { + v.nFindCount = 1; + })); + ASSERT_TRUE( s.find( i, []( value_type& v, value_type const& ) + { + EXPECT_EQ( ++v.nFindCount, 2 ); + })); + ASSERT_TRUE( s.find_with( other_item( i.key() ), other_less(), []( value_type& v, other_item const& ) + { + EXPECT_EQ( ++v.nFindCount, 3 ); + })); + + int nKey = i.key() - 1; + switch ( idx % 6 ) { + case 0: + ASSERT_TRUE( s.erase( i.key())); + ASSERT_FALSE( s.erase( i.key())); + break; + case 1: + ASSERT_TRUE( s.erase( i )); + ASSERT_FALSE( s.erase( i )); + break; + case 2: + ASSERT_TRUE( s.erase_with( other_item( i.key()), other_less())); + ASSERT_FALSE( s.erase_with( other_item( i.key() ), other_less() ) ); + break; + case 3: + ASSERT_TRUE( s.erase( i.key(), [&nKey]( value_type const& v ) + { + nKey = v.key(); + } )); + EXPECT_EQ( i.key(), nKey ); + + nKey = i.key() - 1; + ASSERT_FALSE( s.erase( i.key(), [&nKey]( value_type const& v ) + { + nKey = v.key(); + } )); + EXPECT_EQ( i.key(), nKey + 1 ); + break; + case 4: + ASSERT_TRUE( s.erase( i, [&nKey]( value_type const& v ) + { + nKey = v.key(); + } )); + EXPECT_EQ( i.key(), nKey ); + + nKey = i.key() - 1; + ASSERT_FALSE( s.erase( i, [&nKey]( value_type const& v ) + { + nKey = v.key(); + } )); + EXPECT_EQ( i.key(), nKey + 1 ); + break; + case 5: + ASSERT_TRUE( s.erase_with( other_item( i.key()), other_less(), [&nKey]( value_type const& v ) + { + nKey = v.key(); + } )); + EXPECT_EQ( i.key(), nKey ); + + nKey = i.key() - 1; + ASSERT_FALSE( s.erase_with( other_item( i.key()), other_less(), [&nKey]( value_type const& v ) + { + nKey = v.key(); + } )); + EXPECT_EQ( i.key(), nKey + 1 ); + break; + } + + ASSERT_FALSE( s.contains( i.nKey ) ); + ASSERT_FALSE( s.contains( i ) ); + ASSERT_FALSE( s.contains( other_item( i.key() ), other_less())); + ASSERT_FALSE( s.find( i.nKey, []( value_type&, int ) {} )); + ASSERT_FALSE( s.find( i, []( value_type&, value_type const& ) {} )); + ASSERT_FALSE( s.find_with( other_item( i.key()), other_less(), []( value_type&, other_item const& ) {} )); + } + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + + // clear + for ( auto& i : data ) { + ASSERT_TRUE( s.insert( i ) ); + } + + ASSERT_FALSE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, nSetSize ); + + s.clear(); + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + ASSERT_TRUE( s.begin() == s.end() ); + ASSERT_TRUE( s.cbegin() == s.cend() ); + } + }; + +} // namespace cds_test + +#endif // CDSUNIT_SET_TEST_SET_H diff --git a/test/unit/intrusive-set/test_set_hp.h b/test/unit/intrusive-set/test_set_hp.h new file mode 100644 index 00000000..dd5b3513 --- /dev/null +++ b/test/unit/intrusive-set/test_set_hp.h @@ -0,0 +1,153 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef CDSUNIT_SET_TEST_SET_HP_H +#define CDSUNIT_SET_TEST_SET_HP_H + +#include "test_set.h" + +namespace cds_test { + + class container_set_hp: public container_set + { + typedef container_set base_class; + + protected: + template + void test( Set& s ) + { + // Precondition: set is empty + // Postcondition: set is empty + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + base_class::test( s ); + + typedef typename Set::value_type value_type; + + size_t const nSetSize = kSize; + std::vector< value_type > data; + std::vector< size_t> indices; + data.reserve( kSize ); + indices.reserve( kSize ); + for ( size_t key = 0; key < kSize; ++key ) { + data.push_back( value_type( static_cast(key) ) ); + indices.push_back( key ); + } + shuffle( indices.begin(), indices.end() ); + + for ( auto& i : data ) { + ASSERT_TRUE( s.insert( i ) ); + } + ASSERT_FALSE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, nSetSize ); + + // iterator test + for ( auto it = s.begin(); it != s.end(); ++it ) { + it->nFindCount = it->key() * 3; + } + + for ( auto it = s.cbegin(); it != s.cend(); ++it ) { + EXPECT_EQ( it->nFindCount, it->key() * 3 ); + } + + typedef typename Set::guarded_ptr guarded_ptr; + guarded_ptr gp; + + // get() + for ( auto idx : indices ) { + auto& i = data[idx]; + + ASSERT_TRUE( !gp ); + switch ( idx % 3 ) { + case 0: + gp = s.get( i.key() ); + ASSERT_FALSE( !gp ); + break; + case 1: + gp = s.get( i ); + ASSERT_FALSE( !gp ); + break; + case 2: + gp = s.get_with( other_item( i.key() ), other_less() ); + ASSERT_FALSE( !gp ); + } + EXPECT_EQ( gp->key(), i.key() ); + EXPECT_EQ( gp->nFindCount, i.key() * 3 ); + gp->nFindCount *= 2; + + gp.release(); + } + + // extract() + for ( auto idx : indices ) { + auto& i = data[idx]; + + ASSERT_TRUE( !gp ); + switch ( idx % 3 ) { + case 0: + gp = s.extract( i.key() ); + ASSERT_FALSE( !gp ); + break; + case 1: + gp = s.extract( i ); + ASSERT_FALSE( !gp ); + break; + case 2: + gp = s.extract_with( other_item( i.key() ), other_less() ); + ASSERT_FALSE( !gp ); + break; + } + EXPECT_EQ( gp->key(), i.key() ); + EXPECT_EQ( gp->nFindCount, i.key() * 6 ); + + switch ( idx % 3 ) { + case 0: + gp = s.extract( i.key() ); + break; + case 1: + gp = s.extract( i ); + break; + case 2: + gp = s.extract_with( other_item( i.key() ), other_less() ); + break; + } + ASSERT_TRUE( !gp ); + } + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + } + + }; +} // namespace cds_test + +#endif // CDSUNIT_SET_TEST_SET_HP_H diff --git a/test/unit/intrusive-set/test_set_nogc.h b/test/unit/intrusive-set/test_set_nogc.h new file mode 100644 index 00000000..8fbcbdfb --- /dev/null +++ b/test/unit/intrusive-set/test_set_nogc.h @@ -0,0 +1,349 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef CDSUNIT_SET_TEST_SET_NOGC_H +#define CDSUNIT_SET_TEST_SET_NOGC_H + +#include +#include + +#include + +// forward declaration +namespace cds { namespace container {}} + +namespace cds_test { + namespace co = cds::opt; + + class container_set_nogc : public fixture + { + public: + static size_t const kSize = 100; + + struct stat + { + unsigned int nFindCount; + unsigned int nUpdateNewCount; + unsigned int nUpdateCount; + + stat() + { + clear_stat(); + } + + void clear_stat() + { + memset( this, 0, sizeof( *this ) ); + } + }; + + struct other_item { + int nKey; + + explicit other_item( int k ) + : nKey( k ) + {} + + int key() const + { + return nKey; + } + }; + + struct int_item: public stat + { + int nKey; + int nVal; + std::string strVal; + + int_item() + : nKey( 0 ) + , nVal( 0 ) + {} + + explicit int_item( int k ) + : nKey( k ) + , nVal( k * 2 ) + {} + + template + explicit int_item( Q const& src ) + : nKey( src.key() ) + , nVal( 0 ) + {} + + int_item( int_item const& src ) + : nKey( src.nKey ) + , nVal( src.nVal ) + , strVal( src.strVal ) + {} + + int_item( int_item&& src ) + : nKey( src.nKey ) + , nVal( src.nVal ) + , strVal( std::move( src.strVal ) ) + {} + + int_item( int k, std::string&& s ) + : nKey( k ) + , nVal( k * 2 ) + , strVal( std::move( s ) ) + {} + + explicit int_item( other_item const& s ) + : nKey( s.key() ) + , nVal( s.key() * 2 ) + {} + + int key() const + { + return nKey; + } + }; + + struct hash_int { + size_t operator()( int i ) const + { + return co::v::hash()(i); + } + template + size_t operator()( const Item& i ) const + { + return (*this)(i.key()); + } + }; + + struct simple_item_counter { + size_t m_nCount; + + simple_item_counter() + : m_nCount( 0 ) + {} + + size_t operator ++() + { + return ++m_nCount; + } + + size_t operator --() + { + return --m_nCount; + } + + void reset() + { + m_nCount = 0; + } + + operator size_t() const + { + return m_nCount; + } + + }; + + struct less + { + bool operator ()( int_item const& v1, int_item const& v2 ) const + { + return v1.key() < v2.key(); + } + + template + bool operator ()( int_item const& v1, const Q& v2 ) const + { + return v1.key() < v2; + } + + template + bool operator ()( const Q& v1, int_item const& v2 ) const + { + return v1 < v2.key(); + } + }; + + struct cmp { + int operator ()( int_item const& v1, int_item const& v2 ) const + { + if ( v1.key() < v2.key() ) + return -1; + return v1.key() > v2.key() ? 1 : 0; + } + + template + int operator ()( T const& v1, int v2 ) const + { + if ( v1.key() < v2 ) + return -1; + return v1.key() > v2 ? 1 : 0; + } + + template + int operator ()( int v1, T const& v2 ) const + { + if ( v1 < v2.key() ) + return -1; + return v1 > v2.key() ? 1 : 0; + } + }; + + struct other_less { + template + bool operator()( Q const& lhs, T const& rhs ) const + { + return lhs.key() < rhs.key(); + } + }; + + protected: + template + void test( Set& s ) + { + // Precondition: set is empty + // Postcondition: set is empty + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + size_t const nSetSize = kSize; + + typedef typename Set::value_type value_type; + + std::vector< value_type > data; + std::vector< size_t> indices; + data.reserve( kSize ); + indices.reserve( kSize ); + for ( size_t key = 0; key < kSize; ++key ) { + data.push_back( value_type( static_cast(key) ) ); + indices.push_back( key ); + } + shuffle( indices.begin(), indices.end() ); + + // insert/find + for ( auto idx : indices ) { + auto& i = data[idx]; + + ASSERT_FALSE( s.contains( i.nKey ) != s.end() ); + ASSERT_FALSE( s.contains( i ) != s.end() ); + ASSERT_FALSE( s.contains( other_item( i.key() ), other_less()) != s.end()); + + std::pair updResult; + + std::string str; + updResult = s.update( i.key(), false ); + EXPECT_TRUE( updResult.first == s.end()); + EXPECT_FALSE( updResult.second ); + + typename Set::iterator it; + switch ( idx % 6 ) { + case 0: + it = s.insert( i ); + ASSERT_TRUE( it != s.end() ); + it->nFindCount = it->nKey; + ASSERT_TRUE( s.insert( i ) == s.end()); + updResult = s.update( i, false ); + EXPECT_TRUE( updResult.first == it ); + EXPECT_FALSE( updResult.second ); + break; + case 1: + it = s.insert( i.key() ); + ASSERT_TRUE( it != s.end()); + ASSERT_TRUE( s.insert( i.key() ) == s.end()); + it->nFindCount = it->nKey; + updResult = s.update( i.key(), false ); + EXPECT_TRUE( updResult.first == it ); + EXPECT_FALSE( updResult.second ); + break; + case 2: + updResult = s.update( i ); + EXPECT_TRUE( updResult.first != s.end()); + EXPECT_TRUE( updResult.second ); + updResult.first->nFindCount = updResult.first->nKey; + break; + case 3: + updResult = s.update( i.key()); + EXPECT_TRUE( updResult.first != s.end() ); + EXPECT_TRUE( updResult.second ); + updResult.first->nFindCount = updResult.first->nKey; + break; + case 4: + it = s.emplace( i.key()); + ASSERT_TRUE( it != s.end()); + it->nFindCount = it->nKey; + ASSERT_FALSE( s.emplace( i.key() ) != s.end()); + break; + case 5: + str = "Hello!"; + it = s.emplace( i.key(), std::move( str )); + ASSERT_TRUE( it != s.end() ); + EXPECT_TRUE( str.empty()); + it->nFindCount = it->nKey; + str = "Hello!"; + ASSERT_TRUE( s.emplace( i.key(), std::move( str )) == s.end()); + EXPECT_TRUE( str.empty() ); // yes, that's is :( + break; + default: + // forgot anything?.. + ASSERT_TRUE( false ); + } + + it = s.contains( i.nKey ); + ASSERT_TRUE( it != s.end() ); + EXPECT_EQ( it->nFindCount, it->nKey ); + ASSERT_TRUE( s.contains( i ) != s.end() ); + ASSERT_TRUE( s.contains( other_item( i.key() ), other_less() ) != s.end()); + } + + ASSERT_FALSE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, nSetSize ); + + // iterators + for ( auto it = s.begin(); it != s.end(); ++it ) { + it->nFindCount = it->key() * 3; + } + + for ( auto it = s.cbegin(); it != s.cend(); ++it ) { + EXPECT_EQ( it->nFindCount, it->key() * 3 ); + } + + // clear + + s.clear(); + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + ASSERT_TRUE( s.begin() == s.end() ); + ASSERT_TRUE( s.cbegin() == s.cend() ); + } + }; + +} // namespace cds_test + +#endif // CDSUNIT_SET_TEST_SET_NOGC_H diff --git a/test/unit/intrusive-set/test_set_rcu.h b/test/unit/intrusive-set/test_set_rcu.h new file mode 100644 index 00000000..d819278a --- /dev/null +++ b/test/unit/intrusive-set/test_set_rcu.h @@ -0,0 +1,192 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef CDSUNIT_SET_TEST_SET_RCU_H +#define CDSUNIT_SET_TEST_SET_RCU_H + +#include "test_set.h" + +namespace cds_test { + + class container_set_rcu: public container_set + { + typedef container_set base_class; + + protected: + template + void test( Set& s ) + { + // Precondition: set is empty + // Postcondition: set is empty + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + + base_class::test( s ); + + typedef typename Set::value_type value_type; + + size_t const nSetSize = kSize; + std::vector< value_type > data; + std::vector< size_t> indices; + data.reserve( kSize ); + indices.reserve( kSize ); + for ( size_t key = 0; key < kSize; ++key ) { + data.push_back( value_type( static_cast(key) ) ); + indices.push_back( key ); + } + shuffle( indices.begin(), indices.end() ); + + for ( auto& i : data ) { + ASSERT_TRUE( s.insert( i ) ); + } + ASSERT_FALSE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, nSetSize ); + + // iterator test + for ( auto it = s.begin(); it != s.end(); ++it ) { + it->nFindCount = it->key() * 3; + } + + for ( auto it = s.cbegin(); it != s.cend(); ++it ) { + EXPECT_EQ( it->nFindCount, it->key() * 3 ); + } + + typedef typename Set::exempt_ptr exempt_ptr; + typedef typename Set::raw_ptr raw_ptr; + typedef typename Set::rcu_lock rcu_lock; + + // get() + for ( auto idx : indices ) { + auto& i = data[idx]; + + { + rcu_lock l; + raw_ptr rp; + ASSERT_TRUE( !rp ); + switch ( idx % 3 ) { + case 0: + rp = s.get( i.key() ); + ASSERT_FALSE( !rp ); + break; + case 1: + rp = s.get( i ); + ASSERT_FALSE( !rp ); + break; + case 2: + rp = s.get_with( other_item( i.key() ), other_less() ); + ASSERT_FALSE( !rp ); + } + EXPECT_EQ( rp->key(), i.key() ); + EXPECT_EQ( rp->nFindCount, i.key() * 3 ); + rp->nFindCount *= 2; + } + } + + // extract() + exempt_ptr xp; + for ( auto idx : indices ) { + auto& i = data[idx]; + + ASSERT_TRUE( !xp ); + if ( Set::c_bExtractLockExternal ) { + rcu_lock l; + + switch ( idx % 3 ) { + case 0: + xp = s.extract( i.key() ); + ASSERT_FALSE( !xp ); + break; + case 1: + xp = s.extract( i ); + ASSERT_FALSE( !xp ); + break; + case 2: + xp = s.extract_with( other_item( i.key() ), other_less() ); + ASSERT_FALSE( !xp ); + break; + } + EXPECT_EQ( xp->key(), i.key() ); + EXPECT_EQ( xp->nFindCount, i.key() * 6 ); + + switch ( idx % 3 ) { + case 0: + xp = s.extract( i.key() ); + break; + case 1: + xp = s.extract( i ); + break; + case 2: + xp = s.extract_with( other_item( i.key() ), other_less() ); + break; + } + ASSERT_TRUE( !xp ); + } + else { + switch ( idx % 3 ) { + case 0: + xp = s.extract( i.key() ); + ASSERT_FALSE( !xp ); + break; + case 1: + xp = s.extract( i ); + ASSERT_FALSE( !xp ); + break; + case 2: + xp = s.extract_with( other_item( i.key() ), other_less() ); + ASSERT_FALSE( !xp ); + break; + } + EXPECT_EQ( xp->key(), i.key() ); + EXPECT_EQ( xp->nFindCount, i.key() * 6 ); + + switch ( idx % 3 ) { + case 0: + xp = s.extract( i.key() ); + break; + case 1: + xp = s.extract( i ); + break; + case 2: + xp = s.extract_with( other_item( i.key() ), other_less() ); + break; + } + ASSERT_TRUE( !xp ); + } + } + + ASSERT_TRUE( s.empty() ); + ASSERT_CONTAINER_SIZE( s, 0 ); + } + + }; +} // namespace cds_test + +#endif // CDSUNIT_SET_TEST_SET_RCU_H diff --git a/test/unit/set/CMakeLists.txt b/test/unit/set/CMakeLists.txt deleted file mode 100644 index bfc7c455..00000000 --- a/test/unit/set/CMakeLists.txt +++ /dev/null @@ -1,77 +0,0 @@ -set(PACKAGE_NAME unit-set) - -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-invalid-offsetof") - -set(CDSGTEST_SET_SOURCES - ../main.cpp - intrusive_feldman_hashset_hp.cpp - intrusive_feldman_hashset_dhp.cpp - intrusive_feldman_hashset_rcu_gpb.cpp - intrusive_feldman_hashset_rcu_gpi.cpp - intrusive_feldman_hashset_rcu_gpt.cpp - intrusive_feldman_hashset_rcu_shb.cpp - intrusive_feldman_hashset_rcu_sht.cpp - intrusive_michael_lazy_hp.cpp - intrusive_michael_lazy_dhp.cpp - intrusive_michael_lazy_nogc.cpp - intrusive_michael_lazy_rcu_gpb.cpp - intrusive_michael_lazy_rcu_gpi.cpp - intrusive_michael_lazy_rcu_gpt.cpp - intrusive_michael_lazy_rcu_shb.cpp - intrusive_michael_lazy_rcu_sht.cpp - intrusive_michael_michael_hp.cpp - intrusive_michael_michael_dhp.cpp - intrusive_michael_michael_nogc.cpp - intrusive_michael_michael_rcu_gpb.cpp - intrusive_michael_michael_rcu_gpi.cpp - intrusive_michael_michael_rcu_gpt.cpp - intrusive_michael_michael_rcu_shb.cpp - intrusive_michael_michael_rcu_sht.cpp - intrusive_skiplist_hp.cpp - intrusive_skiplist_dhp.cpp - intrusive_skiplist_nogc.cpp - intrusive_skiplist_rcu_gpb.cpp - intrusive_skiplist_rcu_gpi.cpp - intrusive_skiplist_rcu_gpt.cpp - intrusive_skiplist_rcu_shb.cpp - intrusive_skiplist_rcu_sht.cpp - intrusive_split_lazy_hp.cpp - intrusive_split_lazy_dhp.cpp - intrusive_split_lazy_nogc.cpp - intrusive_split_lazy_rcu_gpb.cpp - intrusive_split_lazy_rcu_gpi.cpp - intrusive_split_lazy_rcu_gpt.cpp - intrusive_split_lazy_rcu_shb.cpp - intrusive_split_lazy_rcu_sht.cpp - intrusive_split_michael_hp.cpp - intrusive_split_michael_dhp.cpp - intrusive_split_michael_nogc.cpp - intrusive_split_michael_rcu_gpb.cpp - intrusive_split_michael_rcu_gpi.cpp - intrusive_split_michael_rcu_gpt.cpp - intrusive_split_michael_rcu_shb.cpp - intrusive_split_michael_rcu_sht.cpp - michael_michael_hp.cpp - michael_michael_dhp.cpp - michael_michael_nogc.cpp - michael_michael_rcu_gpb.cpp - michael_michael_rcu_gpi.cpp - michael_michael_rcu_gpt.cpp - michael_michael_rcu_shb.cpp - michael_michael_rcu_sht.cpp -) - -include_directories( - ${CMAKE_CURRENT_SOURCE_DIR} -) - -add_executable(${PACKAGE_NAME} ${CDSGTEST_SET_SOURCES}) -target_link_libraries(${PACKAGE_NAME} - ${CDS_SHARED_LIBRARY} - ${GTEST_LIBRARY} - ${Boost_THREAD_LIBRARY} - ${Boost_SYSTEM_LIBRARY} - ${CMAKE_THREAD_LIBS_INIT} -) - -add_test(NAME ${PACKAGE_NAME} COMMAND ${PACKAGE_NAME} WORKING_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}) \ No newline at end of file diff --git a/test/unit/set/intrusive_feldman_hashset_dhp.cpp b/test/unit/set/intrusive_feldman_hashset_dhp.cpp deleted file mode 100644 index c2e6a6b7..00000000 --- a/test/unit/set/intrusive_feldman_hashset_dhp.cpp +++ /dev/null @@ -1,146 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_feldman_hashset_hp.h" - -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::DHP gc_type; - - class IntrusiveFeldmanHashSet_DHP : public cds_test::intrusive_feldman_hashset_hp - { - protected: - typedef cds_test::intrusive_feldman_hashset_hp base_class; - - protected: - - void SetUp() - { - typedef ci::FeldmanHashSet< gc_type, int_item, - typename ci::feldman_hashset::make_traits< - ci::feldman_hashset::hash_accessor< hash_accessor > - ,ci::opt::less< std::less> - ,ci::opt::disposer - >::type - > set_type; - - cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount ); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - cds::gc::dhp::GarbageCollector::Destruct(); - } - }; - - TEST_F( IntrusiveFeldmanHashSet_DHP, compare ) - { - struct traits : public ci::feldman_hashset::traits - { - typedef base_class::hash_accessor hash_accessor; - typedef cmp compare; - typedef mock_disposer disposer; - }; - - typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveFeldmanHashSet_DHP, less ) - { - typedef ci::FeldmanHashSet< gc_type, int_item, - typename ci::feldman_hashset::make_traits< - ci::feldman_hashset::hash_accessor< hash_accessor > - , ci::opt::less< std::less> - , ci::opt::disposer - >::type - > set_type; - - set_type s( 5, 2 ); - test( s ); - } - - TEST_F( IntrusiveFeldmanHashSet_DHP, cmpmix ) - { - struct traits : public ci::feldman_hashset::traits - { - typedef base_class::hash_accessor hash_accessor; - typedef cmp compare; - typedef std::less less; - typedef mock_disposer disposer; - typedef simple_item_counter item_counter; - }; - - typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type; - - set_type s( 3, 4 ); - test( s ); - } - - TEST_F( IntrusiveFeldmanHashSet_DHP, backoff ) - { - struct traits : public ci::feldman_hashset::traits - { - typedef base_class::hash_accessor hash_accessor; - typedef cmp compare; - typedef mock_disposer disposer; - typedef cds::backoff::empty back_off; - typedef ci::opt::v::sequential_consistent memory_model; - }; - - typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type; - - set_type s( 8, 3 ); - test( s ); - } - - TEST_F( IntrusiveFeldmanHashSet_DHP, stat ) - { - struct traits : public ci::feldman_hashset::traits - { - typedef base_class::hash_accessor hash_accessor; - typedef cmp compare; - typedef mock_disposer disposer; - typedef ci::feldman_hashset::stat<> stat; - }; - - typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type; - - set_type s( 8, 3 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_feldman_hashset_hp.cpp b/test/unit/set/intrusive_feldman_hashset_hp.cpp deleted file mode 100644 index e9ca7b5e..00000000 --- a/test/unit/set/intrusive_feldman_hashset_hp.cpp +++ /dev/null @@ -1,147 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_feldman_hashset_hp.h" - -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::HP gc_type; - - class IntrusiveFeldmanHashSet_HP : public cds_test::intrusive_feldman_hashset_hp - { - protected: - typedef cds_test::intrusive_feldman_hashset_hp base_class; - - protected: - - void SetUp() - { - typedef ci::FeldmanHashSet< gc_type, int_item, - typename ci::feldman_hashset::make_traits< - ci::feldman_hashset::hash_accessor< hash_accessor > - ,ci::opt::less< std::less> - ,ci::opt::disposer - >::type - > set_type; - - // +1 - for guarded_ptr - cds::gc::hp::GarbageCollector::Construct( set_type::c_nHazardPtrCount + 1, 1, 16 ); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - cds::gc::hp::GarbageCollector::Destruct( true ); - } - }; - - TEST_F( IntrusiveFeldmanHashSet_HP, compare ) - { - struct traits : public ci::feldman_hashset::traits - { - typedef base_class::hash_accessor hash_accessor; - typedef cmp compare; - typedef mock_disposer disposer; - }; - - typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveFeldmanHashSet_HP, less ) - { - typedef ci::FeldmanHashSet< gc_type, int_item, - typename ci::feldman_hashset::make_traits< - ci::feldman_hashset::hash_accessor< hash_accessor > - , ci::opt::less< std::less> - , ci::opt::disposer - >::type - > set_type; - - set_type s( 5, 2 ); - test( s ); - } - - TEST_F( IntrusiveFeldmanHashSet_HP, cmpmix ) - { - struct traits : public ci::feldman_hashset::traits - { - typedef base_class::hash_accessor hash_accessor; - typedef cmp compare; - typedef std::less less; - typedef mock_disposer disposer; - typedef simple_item_counter item_counter; - }; - - typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type; - - set_type s( 3, 4 ); - test( s ); - } - - TEST_F( IntrusiveFeldmanHashSet_HP, backoff ) - { - struct traits : public ci::feldman_hashset::traits - { - typedef base_class::hash_accessor hash_accessor; - typedef cmp compare; - typedef mock_disposer disposer; - typedef cds::backoff::empty back_off; - typedef ci::opt::v::sequential_consistent memory_model; - }; - - typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type; - - set_type s( 8, 3 ); - test( s ); - } - - TEST_F( IntrusiveFeldmanHashSet_HP, stat ) - { - struct traits : public ci::feldman_hashset::traits - { - typedef base_class::hash_accessor hash_accessor; - typedef cmp compare; - typedef mock_disposer disposer; - typedef ci::feldman_hashset::stat<> stat; - }; - - typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type; - - set_type s( 8, 3 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_feldman_hashset_rcu_gpb.cpp b/test/unit/set/intrusive_feldman_hashset_rcu_gpb.cpp deleted file mode 100644 index 35c432e7..00000000 --- a/test/unit/set/intrusive_feldman_hashset_rcu_gpb.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_feldman_hashset_rcu.h" - -namespace { - - typedef cds::urcu::general_buffered<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPB, IntrusiveFeldmanHashSet, rcu_implementation ); diff --git a/test/unit/set/intrusive_feldman_hashset_rcu_gpi.cpp b/test/unit/set/intrusive_feldman_hashset_rcu_gpi.cpp deleted file mode 100644 index e0114f8e..00000000 --- a/test/unit/set/intrusive_feldman_hashset_rcu_gpi.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_feldman_hashset_rcu.h" - -namespace { - - typedef cds::urcu::general_instant<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPI, IntrusiveFeldmanHashSet, rcu_implementation ); diff --git a/test/unit/set/intrusive_feldman_hashset_rcu_gpt.cpp b/test/unit/set/intrusive_feldman_hashset_rcu_gpt.cpp deleted file mode 100644 index a152be57..00000000 --- a/test/unit/set/intrusive_feldman_hashset_rcu_gpt.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_feldman_hashset_rcu.h" - -namespace { - - typedef cds::urcu::general_threaded<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPT, IntrusiveFeldmanHashSet, rcu_implementation ); diff --git a/test/unit/set/intrusive_feldman_hashset_rcu_shb.cpp b/test/unit/set/intrusive_feldman_hashset_rcu_shb.cpp deleted file mode 100644 index 93e357da..00000000 --- a/test/unit/set/intrusive_feldman_hashset_rcu_shb.cpp +++ /dev/null @@ -1,45 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - -#include "test_intrusive_feldman_hashset_rcu.h" - -namespace { - - typedef cds::urcu::signal_buffered<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHB, IntrusiveFeldmanHashSet, rcu_implementation ); - -#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/set/intrusive_feldman_hashset_rcu_sht.cpp b/test/unit/set/intrusive_feldman_hashset_rcu_sht.cpp deleted file mode 100644 index ecd281af..00000000 --- a/test/unit/set/intrusive_feldman_hashset_rcu_sht.cpp +++ /dev/null @@ -1,45 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - -#include "test_intrusive_feldman_hashset_rcu.h" - -namespace { - - typedef cds::urcu::signal_threaded<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHT, IntrusiveFeldmanHashSet, rcu_implementation ); - -#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/set/intrusive_michael_lazy_dhp.cpp b/test/unit/set/intrusive_michael_lazy_dhp.cpp deleted file mode 100644 index 633001a0..00000000 --- a/test/unit/set/intrusive_michael_lazy_dhp.cpp +++ /dev/null @@ -1,254 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_set_hp.h" - -#include -#include - -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::DHP gc_type; - - class IntrusiveMichaelLazySet_DHP : public cds_test::intrusive_set_hp - { - protected: - typedef cds_test::intrusive_set_hp base_class; - - protected: - typedef typename base_class::base_int_item< ci::lazy_list::node> base_item_type; - typedef typename base_class::base_int_item< ci::lazy_list::node> base_mutex_item_type; - typedef typename base_class::member_int_item< ci::lazy_list::node> member_item_type; - typedef typename base_class::member_int_item< ci::lazy_list::node> member_mutex_item_type; - - void SetUp() - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc> hook; - }; - typedef ci::LazyList< gc_type, base_item_type, list_traits > list_type; - typedef ci::MichaelHashSet< gc_type, list_type > set_type; - - cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount ); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - cds::gc::dhp::GarbageCollector::Destruct(); - } - }; - - - TEST_F( IntrusiveMichaelLazySet_DHP, base_cmp ) - { - typedef ci::LazyList< gc_type - , base_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type > > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - ,ci::opt::back_off< cds::backoff::pause > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_DHP, base_less ) - { - typedef ci::LazyList< gc_type - , base_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type >>> - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_DHP, base_cmpmix ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, base_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_DHP, base_mutex ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc, ci::opt::lock_type> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, base_mutex_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - - TEST_F( IntrusiveMichaelLazySet_DHP, member_cmp ) - { - typedef ci::LazyList< gc_type - ,member_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_DHP, member_less ) - { - typedef ci::LazyList< gc_type - , member_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_DHP, member_cmpmix ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, member_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_DHP, member_mutex ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc, ci::opt::lock_type> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, member_mutex_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_michael_lazy_hp.cpp b/test/unit/set/intrusive_michael_lazy_hp.cpp deleted file mode 100644 index 6583d32d..00000000 --- a/test/unit/set/intrusive_michael_lazy_hp.cpp +++ /dev/null @@ -1,255 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_set_hp.h" - -#include -#include - -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::HP gc_type; - - class IntrusiveMichaelLazySet_HP : public cds_test::intrusive_set_hp - { - protected: - typedef cds_test::intrusive_set_hp base_class; - - protected: - typedef typename base_class::base_int_item< ci::lazy_list::node> base_item_type; - typedef typename base_class::base_int_item< ci::lazy_list::node> base_mutex_item_type; - typedef typename base_class::member_int_item< ci::lazy_list::node> member_item_type; - typedef typename base_class::member_int_item< ci::lazy_list::node> member_mutex_item_type; - - void SetUp() - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc> hook; - }; - typedef ci::LazyList< gc_type, base_item_type, list_traits > list_type; - typedef ci::MichaelHashSet< gc_type, list_type > set_type; - - // +1 - for guarded_ptr - cds::gc::hp::GarbageCollector::Construct( set_type::c_nHazardPtrCount + 1, 1, 16 ); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - cds::gc::hp::GarbageCollector::Destruct( true ); - } - }; - - - TEST_F( IntrusiveMichaelLazySet_HP, base_cmp ) - { - typedef ci::LazyList< gc_type - , base_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type > > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - ,ci::opt::back_off< cds::backoff::pause > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_HP, base_less ) - { - typedef ci::LazyList< gc_type - , base_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type >>> - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_HP, base_cmpmix ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, base_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_HP, base_mutex ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc, ci::opt::lock_type> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, base_mutex_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - - TEST_F( IntrusiveMichaelLazySet_HP, member_cmp ) - { - typedef ci::LazyList< gc_type - ,member_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_HP, member_less ) - { - typedef ci::LazyList< gc_type - , member_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_HP, member_cmpmix ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, member_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_HP, member_mutex ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc, ci::opt::lock_type> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, member_mutex_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_michael_lazy_nogc.cpp b/test/unit/set/intrusive_michael_lazy_nogc.cpp deleted file mode 100644 index c183de4f..00000000 --- a/test/unit/set/intrusive_michael_lazy_nogc.cpp +++ /dev/null @@ -1,241 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_set_nogc.h" - -#include -#include - -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::nogc gc_type; - - class IntrusiveMichaelLazySet_NoGC : public cds_test::intrusive_set_nogc - { - protected: - typedef cds_test::intrusive_set_nogc base_class; - - protected: - typedef typename base_class::base_int_item< ci::lazy_list::node> base_item_type; - typedef typename base_class::base_int_item< ci::lazy_list::node> base_mutex_item_type; - typedef typename base_class::member_int_item< ci::lazy_list::node> member_item_type; - typedef typename base_class::member_int_item< ci::lazy_list::node> member_mutex_item_type; - - //void SetUp() - //{} - - //void TearDown() - //{} - }; - - - TEST_F( IntrusiveMichaelLazySet_NoGC, base_cmp ) - { - typedef ci::LazyList< gc_type - , base_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type > > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - ,ci::opt::back_off< cds::backoff::pause > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_NoGC, base_less ) - { - typedef ci::LazyList< gc_type - , base_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type >>> - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_NoGC, base_cmpmix ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, base_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_NoGC, base_mutex ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc, ci::opt::lock_type> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, base_mutex_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - - TEST_F( IntrusiveMichaelLazySet_NoGC, member_cmp ) - { - typedef ci::LazyList< gc_type - ,member_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_NoGC, member_less ) - { - typedef ci::LazyList< gc_type - , member_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_NoGC, member_cmpmix ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, member_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelLazySet_NoGC, member_mutex ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc, ci::opt::lock_type> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, member_mutex_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_michael_lazy_rcu_gpb.cpp b/test/unit/set/intrusive_michael_lazy_rcu_gpb.cpp deleted file mode 100644 index f2662d23..00000000 --- a/test/unit/set/intrusive_michael_lazy_rcu_gpb.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_michael_lazy_rcu.h" - -namespace { - - typedef cds::urcu::general_buffered<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPB, IntrusiveMichaelLazySet, rcu_implementation ); diff --git a/test/unit/set/intrusive_michael_lazy_rcu_gpi.cpp b/test/unit/set/intrusive_michael_lazy_rcu_gpi.cpp deleted file mode 100644 index b35171ae..00000000 --- a/test/unit/set/intrusive_michael_lazy_rcu_gpi.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_michael_lazy_rcu.h" - -namespace { - - typedef cds::urcu::general_instant<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPI, IntrusiveMichaelLazySet, rcu_implementation ); diff --git a/test/unit/set/intrusive_michael_lazy_rcu_gpt.cpp b/test/unit/set/intrusive_michael_lazy_rcu_gpt.cpp deleted file mode 100644 index 76ff2f07..00000000 --- a/test/unit/set/intrusive_michael_lazy_rcu_gpt.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_michael_lazy_rcu.h" - -namespace { - - typedef cds::urcu::general_threaded<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPT, IntrusiveMichaelLazySet, rcu_implementation ); diff --git a/test/unit/set/intrusive_michael_lazy_rcu_shb.cpp b/test/unit/set/intrusive_michael_lazy_rcu_shb.cpp deleted file mode 100644 index a7728a2e..00000000 --- a/test/unit/set/intrusive_michael_lazy_rcu_shb.cpp +++ /dev/null @@ -1,46 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - -#include "test_intrusive_michael_lazy_rcu.h" - -namespace { - - typedef cds::urcu::signal_buffered<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHB, IntrusiveMichaelLazySet, rcu_implementation ); - -#endif // #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - diff --git a/test/unit/set/intrusive_michael_lazy_rcu_sht.cpp b/test/unit/set/intrusive_michael_lazy_rcu_sht.cpp deleted file mode 100644 index 16c00ba1..00000000 --- a/test/unit/set/intrusive_michael_lazy_rcu_sht.cpp +++ /dev/null @@ -1,46 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - -#include "test_intrusive_michael_lazy_rcu.h" - -namespace { - - typedef cds::urcu::signal_threaded<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHT, IntrusiveMichaelLazySet, rcu_implementation ); - -#endif // #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - diff --git a/test/unit/set/intrusive_michael_michael_dhp.cpp b/test/unit/set/intrusive_michael_michael_dhp.cpp deleted file mode 100644 index 035c21f1..00000000 --- a/test/unit/set/intrusive_michael_michael_dhp.cpp +++ /dev/null @@ -1,205 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_set_hp.h" - -#include -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::DHP gc_type; - - class IntrusiveMichaelSet_DHP : public cds_test::intrusive_set_hp - { - protected: - typedef cds_test::intrusive_set_hp base_class; - - protected: - typedef typename base_class::base_int_item< ci::michael_list::node> base_item_type; - typedef typename base_class::member_int_item< ci::michael_list::node> member_item_type; - - void SetUp() - { - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::base_hook< ci::opt::gc> hook; - }; - typedef ci::MichaelList< gc_type, base_item_type, list_traits > list_type; - typedef ci::MichaelHashSet< gc_type, list_type > set_type; - - cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount ); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - cds::gc::dhp::GarbageCollector::Destruct(); - } - }; - - - TEST_F( IntrusiveMichaelSet_DHP, base_cmp ) - { - typedef ci::MichaelList< gc_type - , base_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type >>> - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelSet_DHP, base_less ) - { - typedef ci::MichaelList< gc_type - , base_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type >>> - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelSet_DHP, base_cmpmix ) - { - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::base_hook< ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::MichaelList< gc_type, base_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - - TEST_F( IntrusiveMichaelSet_DHP, member_cmp ) - { - typedef ci::MichaelList< gc_type - ,member_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelSet_DHP, member_less ) - { - typedef ci::MichaelList< gc_type - , member_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelSet_DHP, member_cmpmix ) - { - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::MichaelList< gc_type, member_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_michael_michael_hp.cpp b/test/unit/set/intrusive_michael_michael_hp.cpp deleted file mode 100644 index a97824d3..00000000 --- a/test/unit/set/intrusive_michael_michael_hp.cpp +++ /dev/null @@ -1,206 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_set_hp.h" - -#include -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::HP gc_type; - - class IntrusiveMichaelSet_HP : public cds_test::intrusive_set_hp - { - protected: - typedef cds_test::intrusive_set_hp base_class; - - protected: - typedef typename base_class::base_int_item< ci::michael_list::node> base_item_type; - typedef typename base_class::member_int_item< ci::michael_list::node> member_item_type; - - void SetUp() - { - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::base_hook< ci::opt::gc> hook; - }; - typedef ci::MichaelList< gc_type, base_item_type, list_traits > list_type; - typedef ci::MichaelHashSet< gc_type, list_type > set_type; - - // +1 - for guarded_ptr - cds::gc::hp::GarbageCollector::Construct( set_type::c_nHazardPtrCount + 1, 1, 16 ); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - cds::gc::hp::GarbageCollector::Destruct( true ); - } - }; - - - TEST_F( IntrusiveMichaelSet_HP, base_cmp ) - { - typedef ci::MichaelList< gc_type - , base_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type > > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelSet_HP, base_less ) - { - typedef ci::MichaelList< gc_type - , base_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type >>> - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelSet_HP, base_cmpmix ) - { - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::base_hook< ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::MichaelList< gc_type, base_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - - TEST_F( IntrusiveMichaelSet_HP, member_cmp ) - { - typedef ci::MichaelList< gc_type - ,member_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelSet_HP, member_less ) - { - typedef ci::MichaelList< gc_type - , member_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelSet_HP, member_cmpmix ) - { - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::MichaelList< gc_type, member_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_michael_michael_nogc.cpp b/test/unit/set/intrusive_michael_michael_nogc.cpp deleted file mode 100644 index 2ce9e2b2..00000000 --- a/test/unit/set/intrusive_michael_michael_nogc.cpp +++ /dev/null @@ -1,192 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_set_nogc.h" - -#include -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::nogc gc_type; - - class IntrusiveMichaelSet_NoGC : public cds_test::intrusive_set_nogc - { - protected: - typedef cds_test::intrusive_set_nogc base_class; - - protected: - typedef typename base_class::base_int_item< ci::michael_list::node> base_item_type; - typedef typename base_class::member_int_item< ci::michael_list::node> member_item_type; - - //void SetUp() - //{} - - //void TearDown() - //{} - }; - - - TEST_F( IntrusiveMichaelSet_NoGC, base_cmp ) - { - typedef ci::MichaelList< gc_type - , base_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type > > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelSet_NoGC, base_less ) - { - typedef ci::MichaelList< gc_type - , base_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type >>> - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelSet_NoGC, base_cmpmix ) - { - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::base_hook< ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::MichaelList< gc_type, base_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - - TEST_F( IntrusiveMichaelSet_NoGC, member_cmp ) - { - typedef ci::MichaelList< gc_type - ,member_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelSet_NoGC, member_less ) - { - typedef ci::MichaelList< gc_type - , member_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< gc_type, bucket_type, - ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveMichaelSet_NoGC, member_cmpmix ) - { - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::MichaelList< gc_type, member_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_michael_michael_rcu_gpb.cpp b/test/unit/set/intrusive_michael_michael_rcu_gpb.cpp deleted file mode 100644 index e8d6f68d..00000000 --- a/test/unit/set/intrusive_michael_michael_rcu_gpb.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_michael_michael_rcu.h" - -namespace { - - typedef cds::urcu::general_buffered<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPB, IntrusiveMichaelSet, rcu_implementation ); diff --git a/test/unit/set/intrusive_michael_michael_rcu_gpi.cpp b/test/unit/set/intrusive_michael_michael_rcu_gpi.cpp deleted file mode 100644 index 3e65ce11..00000000 --- a/test/unit/set/intrusive_michael_michael_rcu_gpi.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_michael_michael_rcu.h" - -namespace { - - typedef cds::urcu::general_instant<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPI, IntrusiveMichaelSet, rcu_implementation ); diff --git a/test/unit/set/intrusive_michael_michael_rcu_gpt.cpp b/test/unit/set/intrusive_michael_michael_rcu_gpt.cpp deleted file mode 100644 index b397529a..00000000 --- a/test/unit/set/intrusive_michael_michael_rcu_gpt.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_michael_michael_rcu.h" - -namespace { - - typedef cds::urcu::general_threaded<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPT, IntrusiveMichaelSet, rcu_implementation ); diff --git a/test/unit/set/intrusive_michael_michael_rcu_shb.cpp b/test/unit/set/intrusive_michael_michael_rcu_shb.cpp deleted file mode 100644 index 6f5be5a9..00000000 --- a/test/unit/set/intrusive_michael_michael_rcu_shb.cpp +++ /dev/null @@ -1,46 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - -#include "test_intrusive_michael_michael_rcu.h" - -namespace { - - typedef cds::urcu::signal_buffered<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHB, IntrusiveMichaelSet, rcu_implementation ); - -#endif // #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - diff --git a/test/unit/set/intrusive_michael_michael_rcu_sht.cpp b/test/unit/set/intrusive_michael_michael_rcu_sht.cpp deleted file mode 100644 index a2e76b5f..00000000 --- a/test/unit/set/intrusive_michael_michael_rcu_sht.cpp +++ /dev/null @@ -1,46 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - -#include "test_intrusive_michael_michael_rcu.h" - -namespace { - - typedef cds::urcu::signal_threaded<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHT, IntrusiveMichaelSet, rcu_implementation ); - -#endif // #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - diff --git a/test/unit/set/intrusive_skiplist_dhp.cpp b/test/unit/set/intrusive_skiplist_dhp.cpp deleted file mode 100644 index 555e5958..00000000 --- a/test/unit/set/intrusive_skiplist_dhp.cpp +++ /dev/null @@ -1,200 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_set_hp.h" - -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::DHP gc_type; - - class IntrusiveSkipListSet_DHP : public cds_test::intrusive_set_hp - { - protected: - typedef cds_test::intrusive_set_hp base_class; - - protected: - typedef typename base_class::base_int_item< ci::skip_list::node< gc_type>> base_item_type; - typedef typename base_class::member_int_item< ci::skip_list::node< gc_type>> member_item_type; - - void SetUp() - { - typedef ci::SkipListSet< gc_type, base_item_type, - typename ci::skip_list::make_traits< - ci::opt::hook>> - ,ci::opt::disposer - ,ci::opt::compare - >::type - > set_type; - - cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount ); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - cds::gc::dhp::GarbageCollector::Destruct(); - } - }; - - - TEST_F( IntrusiveSkipListSet_DHP, base_cmp ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - }; - - typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_DHP, base_less ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef base_class::less less; - typedef cds::atomicity::item_counter item_counter; - }; - - typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_DHP, base_cmpmix ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - typedef base_class::less less; - typedef ci::skip_list::stat<> stat; - }; - - typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_DHP, base_xorshift ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - typedef ci::skip_list::xorshift random_level_generator; - }; - - typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; - - set_type s; - test( s ); - } - - - TEST_F( IntrusiveSkipListSet_DHP, member_cmp ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::member_hook< offsetof(member_item_type, hMember), ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - }; - - typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_DHP, member_less ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef base_class::less less; - typedef cds::atomicity::item_counter item_counter; - typedef ci::opt::v::sequential_consistent memory_model; - }; - - typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_DHP, member_cmpmix ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - typedef base_class::less less; - typedef ci::skip_list::stat<> stat; - }; - - typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_DHP, member_xorshift ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - typedef ci::skip_list::xorshift random_level_generator; - }; - - typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; - - set_type s; - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_skiplist_hp.cpp b/test/unit/set/intrusive_skiplist_hp.cpp deleted file mode 100644 index c3f40e2d..00000000 --- a/test/unit/set/intrusive_skiplist_hp.cpp +++ /dev/null @@ -1,201 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_set_hp.h" - -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::HP gc_type; - - class IntrusiveSkipListSet_HP : public cds_test::intrusive_set_hp - { - protected: - typedef cds_test::intrusive_set_hp base_class; - - protected: - typedef typename base_class::base_int_item< ci::skip_list::node< gc_type>> base_item_type; - typedef typename base_class::member_int_item< ci::skip_list::node< gc_type>> member_item_type; - - void SetUp() - { - typedef ci::SkipListSet< gc_type, base_item_type, - typename ci::skip_list::make_traits< - ci::opt::hook>> - ,ci::opt::disposer - ,ci::opt::compare - >::type - > set_type; - - // +1 - for guarded_ptr - cds::gc::hp::GarbageCollector::Construct( set_type::c_nHazardPtrCount + 1, 1, 16 ); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - cds::gc::hp::GarbageCollector::Destruct( true ); - } - }; - - - TEST_F( IntrusiveSkipListSet_HP, base_cmp ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - }; - - typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_HP, base_less ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef base_class::less less; - typedef cds::atomicity::item_counter item_counter; - }; - - typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_HP, base_cmpmix ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - typedef base_class::less less; - typedef ci::skip_list::stat<> stat; - }; - - typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_HP, base_xorshift ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - typedef ci::skip_list::xorshift random_level_generator; - }; - - typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; - - set_type s; - test( s ); - } - - - TEST_F( IntrusiveSkipListSet_HP, member_cmp ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::member_hook< offsetof(member_item_type, hMember), ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - }; - - typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_HP, member_less ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef base_class::less less; - typedef cds::atomicity::item_counter item_counter; - typedef ci::opt::v::sequential_consistent memory_model; - }; - - typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_HP, member_cmpmix ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - typedef base_class::less less; - typedef ci::skip_list::stat<> stat; - }; - - typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_HP, member_xorshift ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - typedef ci::skip_list::xorshift random_level_generator; - }; - - typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; - - set_type s; - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_skiplist_nogc.cpp b/test/unit/set/intrusive_skiplist_nogc.cpp deleted file mode 100644 index e2c7ec7d..00000000 --- a/test/unit/set/intrusive_skiplist_nogc.cpp +++ /dev/null @@ -1,186 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_set_nogc.h" - -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::nogc gc_type; - - class IntrusiveSkipListSet_NoGC : public cds_test::intrusive_set_nogc - { - protected: - typedef cds_test::intrusive_set_nogc base_class; - - protected: - typedef typename base_class::base_int_item< ci::skip_list::node< gc_type>> base_item_type; - typedef typename base_class::member_int_item< ci::skip_list::node< gc_type>> member_item_type; - - //void SetUp() - //{} - - //void TearDown() - //{} - }; - - - TEST_F( IntrusiveSkipListSet_NoGC, base_cmp ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - }; - - typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_NoGC, base_less ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef base_class::less less; - typedef cds::atomicity::item_counter item_counter; - }; - - typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_NoGC, base_cmpmix ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - typedef base_class::less less; - typedef ci::skip_list::stat<> stat; - }; - - typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_NoGC, base_xorshift ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::base_hook< ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - typedef ci::skip_list::xorshift random_level_generator; - }; - - typedef ci::SkipListSet< gc_type, base_item_type, traits > set_type; - - set_type s; - test( s ); - } - - - TEST_F( IntrusiveSkipListSet_NoGC, member_cmp ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::member_hook< offsetof(member_item_type, hMember), ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - }; - - typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_NoGC, member_less ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef base_class::less less; - typedef cds::atomicity::item_counter item_counter; - typedef ci::opt::v::sequential_consistent memory_model; - }; - - typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_NoGC, member_cmpmix ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - typedef base_class::less less; - typedef ci::skip_list::stat<> stat; - }; - - typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; - - set_type s; - test( s ); - } - - TEST_F( IntrusiveSkipListSet_NoGC, member_xorshift ) - { - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - typedef ci::skip_list::xorshift random_level_generator; - }; - - typedef ci::SkipListSet< gc_type, member_item_type, traits > set_type; - - set_type s; - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_skiplist_rcu_gpb.cpp b/test/unit/set/intrusive_skiplist_rcu_gpb.cpp deleted file mode 100644 index a80370b9..00000000 --- a/test/unit/set/intrusive_skiplist_rcu_gpb.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_skiplist_rcu.h" - -namespace { - - typedef cds::urcu::general_buffered<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPB, IntrusiveSkipListSet, rcu_implementation ); diff --git a/test/unit/set/intrusive_skiplist_rcu_gpi.cpp b/test/unit/set/intrusive_skiplist_rcu_gpi.cpp deleted file mode 100644 index e8b97158..00000000 --- a/test/unit/set/intrusive_skiplist_rcu_gpi.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_skiplist_rcu.h" - -namespace { - - typedef cds::urcu::general_instant<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPI, IntrusiveSkipListSet, rcu_implementation ); diff --git a/test/unit/set/intrusive_skiplist_rcu_gpt.cpp b/test/unit/set/intrusive_skiplist_rcu_gpt.cpp deleted file mode 100644 index beeeca01..00000000 --- a/test/unit/set/intrusive_skiplist_rcu_gpt.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_skiplist_rcu.h" - -namespace { - - typedef cds::urcu::general_threaded<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPT, IntrusiveSkipListSet, rcu_implementation ); diff --git a/test/unit/set/intrusive_skiplist_rcu_shb.cpp b/test/unit/set/intrusive_skiplist_rcu_shb.cpp deleted file mode 100644 index 334cf99d..00000000 --- a/test/unit/set/intrusive_skiplist_rcu_shb.cpp +++ /dev/null @@ -1,45 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - -#include "test_intrusive_skiplist_rcu.h" - -namespace { - - typedef cds::urcu::signal_buffered<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHB, IntrusiveSkipListSet, rcu_implementation ); - -#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/set/intrusive_skiplist_rcu_sht.cpp b/test/unit/set/intrusive_skiplist_rcu_sht.cpp deleted file mode 100644 index 04a52d6c..00000000 --- a/test/unit/set/intrusive_skiplist_rcu_sht.cpp +++ /dev/null @@ -1,45 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - -#include "test_intrusive_skiplist_rcu.h" - -namespace { - - typedef cds::urcu::signal_threaded<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHT, IntrusiveSkipListSet, rcu_implementation ); - -#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/set/intrusive_split_lazy_dhp.cpp b/test/unit/set/intrusive_split_lazy_dhp.cpp deleted file mode 100644 index aad82073..00000000 --- a/test/unit/set/intrusive_split_lazy_dhp.cpp +++ /dev/null @@ -1,258 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_set_hp.h" - -#include -#include - -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::DHP gc_type; - - class IntrusiveSplitListLazySet_DHP : public cds_test::intrusive_set_hp - { - protected: - typedef cds_test::intrusive_set_hp base_class; - - protected: - typedef typename base_class::base_int_item< ci::split_list::node< ci::lazy_list::node>> base_item_type; - typedef typename base_class::base_int_item< ci::split_list::node< ci::lazy_list::node>> base_mutex_item_type; - typedef typename base_class::member_int_item< ci::split_list::node< ci::lazy_list::node>> member_item_type; - typedef typename base_class::member_int_item< ci::split_list::node< ci::lazy_list::node>> member_mutex_item_type; - - void SetUp() - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc> hook; - }; - typedef ci::LazyList< gc_type, base_item_type, list_traits > list_type; - typedef ci::SplitListSet< gc_type, list_type > set_type; - - cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount ); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - cds::gc::dhp::GarbageCollector::Destruct(); - } - }; - - - TEST_F( IntrusiveSplitListLazySet_DHP, base_cmp ) - { - typedef ci::LazyList< gc_type - , base_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type > > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - ,ci::opt::back_off< cds::backoff::pause > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_DHP, base_less ) - { - typedef ci::LazyList< gc_type - , base_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type >>> - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - , ci::opt::item_counter< cds::atomicity::item_counter > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_DHP, base_cmpmix ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, base_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - typedef ci::split_list::stat<> stat; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_DHP, base_mutex ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc, ci::opt::lock_type> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, base_mutex_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - typedef cds::backoff::empty back_off; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - - TEST_F( IntrusiveSplitListLazySet_DHP, member_cmp ) - { - typedef ci::LazyList< gc_type - ,member_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_DHP, member_less ) - { - typedef ci::LazyList< gc_type - , member_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - , ci::opt::back_off< cds::backoff::pause > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_DHP, member_cmpmix ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, member_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_DHP, member_mutex ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc, ci::opt::lock_type> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, member_mutex_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_split_lazy_hp.cpp b/test/unit/set/intrusive_split_lazy_hp.cpp deleted file mode 100644 index eadc0232..00000000 --- a/test/unit/set/intrusive_split_lazy_hp.cpp +++ /dev/null @@ -1,259 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_set_hp.h" - -#include -#include - -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::HP gc_type; - - class IntrusiveSplitListLazySet_HP : public cds_test::intrusive_set_hp - { - protected: - typedef cds_test::intrusive_set_hp base_class; - - protected: - typedef typename base_class::base_int_item< ci::split_list::node< ci::lazy_list::node>> base_item_type; - typedef typename base_class::base_int_item< ci::split_list::node< ci::lazy_list::node>> base_mutex_item_type; - typedef typename base_class::member_int_item< ci::split_list::node< ci::lazy_list::node>> member_item_type; - typedef typename base_class::member_int_item< ci::split_list::node< ci::lazy_list::node>> member_mutex_item_type; - - void SetUp() - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc> hook; - }; - typedef ci::LazyList< gc_type, base_item_type, list_traits > list_type; - typedef ci::SplitListSet< gc_type, list_type > set_type; - - // +1 - for guarded_ptr - cds::gc::hp::GarbageCollector::Construct( set_type::c_nHazardPtrCount + 1, 1, 16 ); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - cds::gc::hp::GarbageCollector::Destruct( true ); - } - }; - - - TEST_F( IntrusiveSplitListLazySet_HP, base_cmp ) - { - typedef ci::LazyList< gc_type - , base_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type > > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - ,ci::opt::back_off< cds::backoff::pause > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_HP, base_less ) - { - typedef ci::LazyList< gc_type - , base_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type >>> - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - , ci::opt::item_counter< cds::atomicity::item_counter > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_HP, base_cmpmix ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, base_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - typedef ci::split_list::stat<> stat; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_HP, base_mutex ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc, ci::opt::lock_type> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, base_mutex_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - typedef cds::backoff::empty back_off; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - - TEST_F( IntrusiveSplitListLazySet_HP, member_cmp ) - { - typedef ci::LazyList< gc_type - ,member_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_HP, member_less ) - { - typedef ci::LazyList< gc_type - , member_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - , ci::opt::back_off< cds::backoff::pause > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_HP, member_cmpmix ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, member_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_HP, member_mutex ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc, ci::opt::lock_type> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, member_mutex_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_split_lazy_nogc.cpp b/test/unit/set/intrusive_split_lazy_nogc.cpp deleted file mode 100644 index a832f383..00000000 --- a/test/unit/set/intrusive_split_lazy_nogc.cpp +++ /dev/null @@ -1,245 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_set_nogc.h" - -#include -#include - -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::nogc gc_type; - - class IntrusiveSplitListLazySet_NoGC : public cds_test::intrusive_set_nogc - { - protected: - typedef cds_test::intrusive_set_nogc base_class; - - protected: - typedef typename base_class::base_int_item< ci::split_list::node< ci::lazy_list::node>> base_item_type; - typedef typename base_class::base_int_item< ci::split_list::node< ci::lazy_list::node>> base_mutex_item_type; - typedef typename base_class::member_int_item< ci::split_list::node< ci::lazy_list::node>> member_item_type; - typedef typename base_class::member_int_item< ci::split_list::node< ci::lazy_list::node>> member_mutex_item_type; - - //void SetUp() - //{} - - //void TearDown() - //{} - }; - - - TEST_F( IntrusiveSplitListLazySet_NoGC, base_cmp ) - { - typedef ci::LazyList< gc_type - , base_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type > > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - ,ci::opt::back_off< cds::backoff::pause > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_NoGC, base_less ) - { - typedef ci::LazyList< gc_type - , base_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type >>> - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - , ci::opt::item_counter< cds::atomicity::item_counter > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_NoGC, base_cmpmix ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, base_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - typedef ci::split_list::stat<> stat; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_NoGC, base_mutex ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc, ci::opt::lock_type> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, base_mutex_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - typedef cds::backoff::empty back_off; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - - TEST_F( IntrusiveSplitListLazySet_NoGC, member_cmp ) - { - typedef ci::LazyList< gc_type - ,member_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_NoGC, member_less ) - { - typedef ci::LazyList< gc_type - , member_item_type - ,ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - , ci::opt::back_off< cds::backoff::pause > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_NoGC, member_cmpmix ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, member_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListLazySet_NoGC, member_mutex ) - { - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc, ci::opt::lock_type> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< gc_type, member_mutex_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_split_lazy_rcu_gpb.cpp b/test/unit/set/intrusive_split_lazy_rcu_gpb.cpp deleted file mode 100644 index 5bdac588..00000000 --- a/test/unit/set/intrusive_split_lazy_rcu_gpb.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_split_lazy_rcu.h" - -namespace { - - typedef cds::urcu::general_buffered<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPB, IntrusiveSplitLazySet, rcu_implementation ); diff --git a/test/unit/set/intrusive_split_lazy_rcu_gpi.cpp b/test/unit/set/intrusive_split_lazy_rcu_gpi.cpp deleted file mode 100644 index 2008d870..00000000 --- a/test/unit/set/intrusive_split_lazy_rcu_gpi.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_split_lazy_rcu.h" - -namespace { - - typedef cds::urcu::general_instant<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPI, IntrusiveSplitLazySet, rcu_implementation ); diff --git a/test/unit/set/intrusive_split_lazy_rcu_gpt.cpp b/test/unit/set/intrusive_split_lazy_rcu_gpt.cpp deleted file mode 100644 index ae833f13..00000000 --- a/test/unit/set/intrusive_split_lazy_rcu_gpt.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_split_lazy_rcu.h" - -namespace { - - typedef cds::urcu::general_threaded<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPT, IntrusiveSplitLazySet, rcu_implementation ); diff --git a/test/unit/set/intrusive_split_lazy_rcu_shb.cpp b/test/unit/set/intrusive_split_lazy_rcu_shb.cpp deleted file mode 100644 index 3968e5d7..00000000 --- a/test/unit/set/intrusive_split_lazy_rcu_shb.cpp +++ /dev/null @@ -1,45 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - -#include "test_intrusive_split_lazy_rcu.h" - -namespace { - - typedef cds::urcu::signal_buffered<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHB, IntrusiveSplitLazySet, rcu_implementation ); - -#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/set/intrusive_split_lazy_rcu_sht.cpp b/test/unit/set/intrusive_split_lazy_rcu_sht.cpp deleted file mode 100644 index afa910c3..00000000 --- a/test/unit/set/intrusive_split_lazy_rcu_sht.cpp +++ /dev/null @@ -1,45 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - -#include "test_intrusive_split_lazy_rcu.h" - -namespace { - - typedef cds::urcu::signal_threaded<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHT, IntrusiveSplitLazySet, rcu_implementation ); - -#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/set/intrusive_split_michael_dhp.cpp b/test/unit/set/intrusive_split_michael_dhp.cpp deleted file mode 100644 index 5d067b79..00000000 --- a/test/unit/set/intrusive_split_michael_dhp.cpp +++ /dev/null @@ -1,208 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_set_hp.h" - -#include -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::DHP gc_type; - - class IntrusiveSplitListSet_DHP : public cds_test::intrusive_set_hp - { - protected: - typedef cds_test::intrusive_set_hp base_class; - - protected: - typedef typename base_class::base_int_item< ci::split_list::node< ci::michael_list::node>> base_item_type; - typedef typename base_class::member_int_item< ci::split_list::node< ci::michael_list::node>> member_item_type; - - void SetUp() - { - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::base_hook< ci::opt::gc> hook; - }; - typedef ci::MichaelList< gc_type, base_item_type, list_traits > list_type; - typedef ci::SplitListSet< gc_type, list_type > set_type; - - cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount ); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - cds::gc::dhp::GarbageCollector::Destruct(); - } - }; - - - TEST_F( IntrusiveSplitListSet_DHP, base_cmp ) - { - typedef ci::MichaelList< gc_type - , base_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type > > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListSet_DHP, base_less ) - { - typedef ci::MichaelList< gc_type - , base_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type >>> - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - ,ci::opt::item_counter< cds::atomicity::item_counter > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListSet_DHP, base_cmpmix ) - { - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::base_hook< ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::MichaelList< gc_type, base_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - typedef ci::split_list::stat<> stat; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - - TEST_F( IntrusiveSplitListSet_DHP, member_cmp ) - { - typedef ci::MichaelList< gc_type - ,member_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListSet_DHP, member_less ) - { - typedef ci::MichaelList< gc_type - , member_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - ,ci::opt::back_off< cds::backoff::pause > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListSet_DHP, member_cmpmix ) - { - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::MichaelList< gc_type, member_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_split_michael_hp.cpp b/test/unit/set/intrusive_split_michael_hp.cpp deleted file mode 100644 index c904eeb3..00000000 --- a/test/unit/set/intrusive_split_michael_hp.cpp +++ /dev/null @@ -1,209 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_set_hp.h" - -#include -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::HP gc_type; - - class IntrusiveSplitListSet_HP : public cds_test::intrusive_set_hp - { - protected: - typedef cds_test::intrusive_set_hp base_class; - - protected: - typedef typename base_class::base_int_item< ci::split_list::node< ci::michael_list::node>> base_item_type; - typedef typename base_class::member_int_item< ci::split_list::node< ci::michael_list::node>> member_item_type; - - void SetUp() - { - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::base_hook< ci::opt::gc> hook; - }; - typedef ci::MichaelList< gc_type, base_item_type, list_traits > list_type; - typedef ci::SplitListSet< gc_type, list_type > set_type; - - // +1 - for guarded_ptr - cds::gc::hp::GarbageCollector::Construct( set_type::c_nHazardPtrCount + 1, 1, 16 ); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - cds::gc::hp::GarbageCollector::Destruct( true ); - } - }; - - - TEST_F( IntrusiveSplitListSet_HP, base_cmp ) - { - typedef ci::MichaelList< gc_type - , base_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type > > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListSet_HP, base_less ) - { - typedef ci::MichaelList< gc_type - , base_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type >>> - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - ,ci::opt::item_counter< cds::atomicity::item_counter > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListSet_HP, base_cmpmix ) - { - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::base_hook< ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::MichaelList< gc_type, base_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - typedef ci::split_list::stat<> stat; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - - TEST_F( IntrusiveSplitListSet_HP, member_cmp ) - { - typedef ci::MichaelList< gc_type - ,member_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListSet_HP, member_less ) - { - typedef ci::MichaelList< gc_type - , member_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - ,ci::opt::back_off< cds::backoff::pause > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListSet_HP, member_cmpmix ) - { - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::MichaelList< gc_type, member_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_split_michael_nogc.cpp b/test/unit/set/intrusive_split_michael_nogc.cpp deleted file mode 100644 index ed7c0c3b..00000000 --- a/test/unit/set/intrusive_split_michael_nogc.cpp +++ /dev/null @@ -1,195 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_intrusive_set_nogc.h" - -#include -#include - -namespace { - namespace ci = cds::intrusive; - typedef cds::gc::nogc gc_type; - - class IntrusiveSplitListSet_NoGC : public cds_test::intrusive_set_nogc - { - protected: - typedef cds_test::intrusive_set_nogc base_class; - - protected: - typedef typename base_class::base_int_item< ci::split_list::node< ci::michael_list::node>> base_item_type; - typedef typename base_class::member_int_item< ci::split_list::node< ci::michael_list::node>> member_item_type; - - //void SetUp() - //{} - - //void TearDown() - //{} - }; - - - TEST_F( IntrusiveSplitListSet_NoGC, base_cmp ) - { - typedef ci::MichaelList< gc_type - , base_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type > > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListSet_NoGC, base_less ) - { - typedef ci::MichaelList< gc_type - , base_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type >>> - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - , ci::opt::item_counter< cds::atomicity::item_counter > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListSet_NoGC, base_cmpmix ) - { - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::base_hook< ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::MichaelList< gc_type, base_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - typedef ci::split_list::stat<> stat; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - - TEST_F( IntrusiveSplitListSet_NoGC, member_cmp ) - { - typedef ci::MichaelList< gc_type - ,member_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::compare< cmp > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListSet_NoGC, member_less ) - { - typedef ci::MichaelList< gc_type - , member_item_type - ,ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - ,ci::opt::less< less > - ,ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< gc_type, bucket_type, - ci::split_list::make_traits< - ci::opt::hash< hash_int > - , ci::opt::back_off< cds::backoff::pause > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( IntrusiveSplitListSet_NoGC, member_cmpmix ) - { - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; - typedef base_class::less less; - typedef cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::MichaelList< gc_type, member_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef ci::SplitListSet< gc_type, bucket_type, set_traits > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/intrusive_split_michael_rcu_gpb.cpp b/test/unit/set/intrusive_split_michael_rcu_gpb.cpp deleted file mode 100644 index bf923960..00000000 --- a/test/unit/set/intrusive_split_michael_rcu_gpb.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_split_michael_rcu.h" - -namespace { - - typedef cds::urcu::general_buffered<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPB, IntrusiveSplitMichaelSet, rcu_implementation ); diff --git a/test/unit/set/intrusive_split_michael_rcu_gpi.cpp b/test/unit/set/intrusive_split_michael_rcu_gpi.cpp deleted file mode 100644 index a62aa084..00000000 --- a/test/unit/set/intrusive_split_michael_rcu_gpi.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_split_michael_rcu.h" - -namespace { - - typedef cds::urcu::general_instant<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPI, IntrusiveSplitMichaelSet, rcu_implementation ); diff --git a/test/unit/set/intrusive_split_michael_rcu_gpt.cpp b/test/unit/set/intrusive_split_michael_rcu_gpt.cpp deleted file mode 100644 index 56a7bc16..00000000 --- a/test/unit/set/intrusive_split_michael_rcu_gpt.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_intrusive_split_michael_rcu.h" - -namespace { - - typedef cds::urcu::general_threaded<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPT, IntrusiveSplitMichaelSet, rcu_implementation ); diff --git a/test/unit/set/intrusive_split_michael_rcu_shb.cpp b/test/unit/set/intrusive_split_michael_rcu_shb.cpp deleted file mode 100644 index 81f45389..00000000 --- a/test/unit/set/intrusive_split_michael_rcu_shb.cpp +++ /dev/null @@ -1,45 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - -#include "test_intrusive_split_michael_rcu.h" - -namespace { - - typedef cds::urcu::signal_buffered<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHB, IntrusiveSplitMichaelSet, rcu_implementation ); - -#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/set/intrusive_split_michael_rcu_sht.cpp b/test/unit/set/intrusive_split_michael_rcu_sht.cpp deleted file mode 100644 index cb646b92..00000000 --- a/test/unit/set/intrusive_split_michael_rcu_sht.cpp +++ /dev/null @@ -1,45 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - -#include "test_intrusive_split_michael_rcu.h" - -namespace { - - typedef cds::urcu::signal_threaded<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHT, IntrusiveSplitMichaelSet, rcu_implementation ); - -#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/set/michael_michael_dhp.cpp b/test/unit/set/michael_michael_dhp.cpp deleted file mode 100644 index fa386635..00000000 --- a/test/unit/set/michael_michael_dhp.cpp +++ /dev/null @@ -1,177 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_set_hp.h" - -#include -#include - -namespace { - namespace cc = cds::container; - typedef cds::gc::DHP gc_type; - - class MichaelSet_DHP : public cds_test::container_set_hp - { - protected: - typedef cds_test::container_set_hp base_class; - - void SetUp() - { - typedef cc::MichaelList< gc_type, int_item > list_type; - typedef cc::MichaelHashSet< gc_type, list_type > set_type; - - // +1 - for guarded_ptr - cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount ); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - cds::gc::dhp::GarbageCollector::Destruct(); - } - }; - - TEST_F( MichaelSet_DHP, compare ) - { - typedef cc::MichaelList< gc_type, int_item, - typename cc::michael_list::make_traits< - cds::opt::compare< cmp > - >::type - > list_type; - - typedef cc::MichaelHashSet< gc_type, list_type, - typename cc::michael_set::make_traits< - cds::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( MichaelSet_DHP, less ) - { - typedef cc::MichaelList< gc_type, int_item, - typename cc::michael_list::make_traits< - cds::opt::less< base_class::less > - >::type - > list_type; - - typedef cc::MichaelHashSet< gc_type, list_type, - typename cc::michael_set::make_traits< - cds::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( MichaelSet_DHP, cmpmix ) - { - struct list_traits : public cc::michael_list::traits - { - typedef base_class::less less; - typedef cmp compare; - }; - typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; - - typedef cc::MichaelHashSet< gc_type, list_type, - typename cc::michael_set::make_traits< - cds::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( MichaelSet_DHP, item_counting ) - { - struct list_traits : public cc::michael_list::traits - { - typedef cmp compare; - }; - typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; - - struct set_traits: public cc::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; - - set_type s( kSize, 3 ); - test( s ); - } - - TEST_F( MichaelSet_DHP, backoff ) - { - struct list_traits : public cc::michael_list::traits - { - typedef cmp compare; - typedef cds::backoff::exponential back_off; - }; - typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; - - struct set_traits : public cc::michael_set::traits - { - typedef hash_int hash; - typedef cds::atomicity::item_counter item_counter; - }; - typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; - - set_type s( kSize, 4 ); - test( s ); - } - - TEST_F( MichaelSet_DHP, seq_cst ) - { - struct list_traits : public cc::michael_list::traits - { - typedef base_class::less less; - typedef cds::backoff::pause back_off; - typedef cds::opt::v::sequential_consistent memory_model; - }; - typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; - - struct set_traits : public cc::michael_set::traits - { - typedef hash_int hash; - typedef cds::atomicity::item_counter item_counter; - }; - typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; - - set_type s( kSize, 4 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/michael_michael_hp.cpp b/test/unit/set/michael_michael_hp.cpp deleted file mode 100644 index 3483b8f9..00000000 --- a/test/unit/set/michael_michael_hp.cpp +++ /dev/null @@ -1,177 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_set_hp.h" - -#include -#include - -namespace { - namespace cc = cds::container; - typedef cds::gc::HP gc_type; - - class MichaelSet_HP : public cds_test::container_set_hp - { - protected: - typedef cds_test::container_set_hp base_class; - - void SetUp() - { - typedef cc::MichaelList< gc_type, int_item > list_type; - typedef cc::MichaelHashSet< gc_type, list_type > set_type; - - // +1 - for guarded_ptr - cds::gc::hp::GarbageCollector::Construct( set_type::c_nHazardPtrCount + 1, 1, 16 ); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - cds::gc::hp::GarbageCollector::Destruct( true ); - } - }; - - TEST_F( MichaelSet_HP, compare ) - { - typedef cc::MichaelList< gc_type, int_item, - typename cc::michael_list::make_traits< - cds::opt::compare< cmp > - >::type - > list_type; - - typedef cc::MichaelHashSet< gc_type, list_type, - typename cc::michael_set::make_traits< - cds::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( MichaelSet_HP, less ) - { - typedef cc::MichaelList< gc_type, int_item, - typename cc::michael_list::make_traits< - cds::opt::less< base_class::less > - >::type - > list_type; - - typedef cc::MichaelHashSet< gc_type, list_type, - typename cc::michael_set::make_traits< - cds::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( MichaelSet_HP, cmpmix ) - { - struct list_traits : public cc::michael_list::traits - { - typedef base_class::less less; - typedef cmp compare; - }; - typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; - - typedef cc::MichaelHashSet< gc_type, list_type, - typename cc::michael_set::make_traits< - cds::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( MichaelSet_HP, item_counting ) - { - struct list_traits : public cc::michael_list::traits - { - typedef cmp compare; - }; - typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; - - struct set_traits: public cc::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; - - set_type s( kSize, 3 ); - test( s ); - } - - TEST_F( MichaelSet_HP, backoff ) - { - struct list_traits : public cc::michael_list::traits - { - typedef cmp compare; - typedef cds::backoff::exponential back_off; - }; - typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; - - struct set_traits : public cc::michael_set::traits - { - typedef hash_int hash; - typedef cds::atomicity::item_counter item_counter; - }; - typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; - - set_type s( kSize, 4 ); - test( s ); - } - - TEST_F( MichaelSet_HP, seq_cst ) - { - struct list_traits : public cc::michael_list::traits - { - typedef base_class::less less; - typedef cds::backoff::pause back_off; - typedef cds::opt::v::sequential_consistent memory_model; - }; - typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; - - struct set_traits : public cc::michael_set::traits - { - typedef hash_int hash; - typedef cds::atomicity::item_counter item_counter; - }; - typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; - - set_type s( kSize, 4 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/michael_michael_nogc.cpp b/test/unit/set/michael_michael_nogc.cpp deleted file mode 100644 index 0f493ff0..00000000 --- a/test/unit/set/michael_michael_nogc.cpp +++ /dev/null @@ -1,167 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "test_set_nogc.h" - -#include -#include - -namespace { - namespace cc = cds::container; - typedef cds::gc::nogc gc_type; - - class MichaelSet_NoGC : public cds_test::container_set_nogc - { - protected: - typedef cds_test::container_set_nogc base_class; - - //void SetUp() - //{} - - //void TearDown() - //{} - }; - - TEST_F( MichaelSet_NoGC, compare ) - { - typedef cc::MichaelList< gc_type, int_item, - typename cc::michael_list::make_traits< - cds::opt::compare< cmp > - >::type - > list_type; - - typedef cc::MichaelHashSet< gc_type, list_type, - typename cc::michael_set::make_traits< - cds::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( MichaelSet_NoGC, less ) - { - typedef cc::MichaelList< gc_type, int_item, - typename cc::michael_list::make_traits< - cds::opt::less< base_class::less > - >::type - > list_type; - - typedef cc::MichaelHashSet< gc_type, list_type, - typename cc::michael_set::make_traits< - cds::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( MichaelSet_NoGC, cmpmix ) - { - struct list_traits : public cc::michael_list::traits - { - typedef base_class::less less; - typedef cmp compare; - }; - typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; - - typedef cc::MichaelHashSet< gc_type, list_type, - typename cc::michael_set::make_traits< - cds::opt::hash< hash_int > - >::type - > set_type; - - set_type s( kSize, 2 ); - test( s ); - } - - TEST_F( MichaelSet_NoGC, item_counting ) - { - struct list_traits : public cc::michael_list::traits - { - typedef cmp compare; - }; - typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; - - struct set_traits: public cc::michael_set::traits - { - typedef hash_int hash; - typedef simple_item_counter item_counter; - }; - typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; - - set_type s( kSize, 3 ); - test( s ); - } - - TEST_F( MichaelSet_NoGC, backoff ) - { - struct list_traits : public cc::michael_list::traits - { - typedef cmp compare; - typedef cds::backoff::exponential back_off; - }; - typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; - - struct set_traits : public cc::michael_set::traits - { - typedef hash_int hash; - typedef cds::atomicity::item_counter item_counter; - }; - typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; - - set_type s( kSize, 4 ); - test( s ); - } - - TEST_F( MichaelSet_NoGC, seq_cst ) - { - struct list_traits : public cc::michael_list::traits - { - typedef base_class::less less; - typedef cds::backoff::pause back_off; - typedef cds::opt::v::sequential_consistent memory_model; - }; - typedef cc::MichaelList< gc_type, int_item, list_traits > list_type; - - struct set_traits : public cc::michael_set::traits - { - typedef hash_int hash; - typedef cds::atomicity::item_counter item_counter; - }; - typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; - - set_type s( kSize, 4 ); - test( s ); - } - -} // namespace diff --git a/test/unit/set/michael_michael_rcu_gpb.cpp b/test/unit/set/michael_michael_rcu_gpb.cpp deleted file mode 100644 index 9b2a1881..00000000 --- a/test/unit/set/michael_michael_rcu_gpb.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_michael_michael_rcu.h" - -namespace { - - typedef cds::urcu::general_buffered<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPB, MichaelSet, rcu_implementation ); diff --git a/test/unit/set/michael_michael_rcu_gpi.cpp b/test/unit/set/michael_michael_rcu_gpi.cpp deleted file mode 100644 index a907d591..00000000 --- a/test/unit/set/michael_michael_rcu_gpi.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_michael_michael_rcu.h" - -namespace { - - typedef cds::urcu::general_instant<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPI, MichaelSet, rcu_implementation ); diff --git a/test/unit/set/michael_michael_rcu_gpt.cpp b/test/unit/set/michael_michael_rcu_gpt.cpp deleted file mode 100644 index f2a61a68..00000000 --- a/test/unit/set/michael_michael_rcu_gpt.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#include "test_michael_michael_rcu.h" - -namespace { - - typedef cds::urcu::general_threaded<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPT, MichaelSet, rcu_implementation ); diff --git a/test/unit/set/michael_michael_rcu_shb.cpp b/test/unit/set/michael_michael_rcu_shb.cpp deleted file mode 100644 index be796351..00000000 --- a/test/unit/set/michael_michael_rcu_shb.cpp +++ /dev/null @@ -1,45 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - -#include "test_michael_michael_rcu.h" - -namespace { - - typedef cds::urcu::signal_buffered<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHB, MichaelSet, rcu_implementation ); - -#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/set/michael_michael_rcu_sht.cpp b/test/unit/set/michael_michael_rcu_sht.cpp deleted file mode 100644 index 58cf7f69..00000000 --- a/test/unit/set/michael_michael_rcu_sht.cpp +++ /dev/null @@ -1,45 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#include - -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - -#include "test_michael_michael_rcu.h" - -namespace { - - typedef cds::urcu::signal_threaded<> rcu_implementation; - -} // namespace - -INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHT, MichaelSet, rcu_implementation ); - -#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/set/test_intrusive_feldman_hashset.h b/test/unit/set/test_intrusive_feldman_hashset.h deleted file mode 100644 index bb3ae721..00000000 --- a/test/unit/set/test_intrusive_feldman_hashset.h +++ /dev/null @@ -1,313 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#ifndef CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_H -#define CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_H - -#include -#include - -#include -#include // ref - -// forward declaration -namespace cds { namespace intrusive {}} -namespace ci = cds::intrusive; - -namespace cds_test { - class intrusive_feldman_hashset: public fixture - { - public: - struct stat - { - unsigned int nDisposeCount ; // count of disposer calling - unsigned int nFindCount ; // count of find-functor calling - unsigned int nInsertCount ; - mutable unsigned int nEraseCount; - - stat() - { - clear_stat(); - } - - void clear_stat() - { - memset( this, 0, sizeof( *this ) ); - } - }; - - struct int_item: public stat - { - int nKey; - int nVal; - - int_item() - {} - - explicit int_item( int key ) - : nKey( key ) - , nVal( key ) - {} - - int_item(int key, int val) - : nKey( key ) - , nVal(val) - {} - - int_item( int_item const& v ) - : stat() - , nKey( v.nKey ) - , nVal( v.nVal ) - {} - - int key() const - { - return nKey; - } - }; - - struct hash_accessor { - int operator()( int_item const& v ) const - { - return v.key(); - } - }; - - struct simple_item_counter { - size_t m_nCount; - - simple_item_counter() - : m_nCount(0) - {} - - size_t operator ++() - { - return ++m_nCount; - } - - size_t operator --() - { - return --m_nCount; - } - - void reset() - { - m_nCount = 0; - } - - operator size_t() const - { - return m_nCount; - } - }; - - struct cmp { - int operator ()( int lhs, int rhs ) const - { - if ( lhs < rhs ) - return -1; - return lhs > rhs ? 1 : 0; - } - }; - - struct mock_disposer - { - template - void operator ()( T * p ) - { - ++p->nDisposeCount; - } - }; - - protected: - template - void test( Set& s ) - { - // Precondition: set is empty - // Postcondition: set is empty - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - size_t const nSetSize = std::max( s.head_size() * 2, static_cast(100) ); - - typedef typename Set::value_type value_type; - - std::vector< value_type > data; - std::vector< size_t> indices; - data.reserve( nSetSize ); - indices.reserve( nSetSize ); - for ( size_t key = 0; key < nSetSize; ++key ) { - data.push_back( value_type( static_cast( key ))); - indices.push_back( key ); - } - shuffle( indices.begin(), indices.end() ); - - // insert/find - for ( auto idx : indices ) { - auto& i = data[ idx ]; - - ASSERT_FALSE( s.contains( i.nKey )); - ASSERT_FALSE( s.find( i.nKey, []( value_type& ) {} )); - - std::pair updResult; - - updResult = s.update( i, false ); - EXPECT_FALSE( updResult.first ); - EXPECT_FALSE( updResult.second ); - - switch ( i.key() % 3 ) { - case 0: - ASSERT_TRUE( s.insert( i )); - ASSERT_FALSE( s.insert( i )); - updResult = s.update( i, false ); - EXPECT_TRUE( updResult.first ); - EXPECT_FALSE( updResult.second ); - break; - case 1: - EXPECT_EQ( i.nInsertCount, 0 ); - ASSERT_TRUE( s.insert( i, []( value_type& v ) { ++v.nInsertCount;} )); - EXPECT_EQ( i.nInsertCount, 1 ); - ASSERT_FALSE( s.insert( i, []( value_type& v ) { ++v.nInsertCount;} ) ); - EXPECT_EQ( i.nInsertCount, 1 ); - i.nInsertCount = 0; - break; - case 2: - updResult = s.update( i ); - EXPECT_TRUE( updResult.first ); - EXPECT_TRUE( updResult.second ); - break; - } - - ASSERT_TRUE( s.contains( i.nKey ) ); - EXPECT_EQ( i.nFindCount, 0 ); - ASSERT_TRUE( s.find( i.nKey, []( value_type& v ) { ++v.nFindCount; } )); - EXPECT_EQ( i.nFindCount, 1 ); - } - ASSERT_FALSE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, nSetSize ); - - std::for_each( data.begin(), data.end(), []( value_type& v ) { v.clear_stat(); }); - - // get_level_statistics - { - std::vector< typename Set::level_statistics > level_stat; - s.get_level_statistics( level_stat ); - EXPECT_GT( level_stat.size(), 0 ); - } - - // erase - shuffle( indices.begin(), indices.end() ); - for ( auto idx : indices ) { - auto& i = data[ idx ]; - - ASSERT_TRUE( s.contains( i.nKey ) ); - EXPECT_EQ( i.nFindCount, 0 ); - ASSERT_TRUE( s.find( i.nKey, []( value_type& v ) { ++v.nFindCount; } ) ); - EXPECT_EQ( i.nFindCount, 1 ); - - value_type v( i ); - switch ( i.key() % 3 ) { - case 0: - ASSERT_FALSE( s.unlink( v )); - ASSERT_TRUE( s.unlink( i )); - ASSERT_FALSE( s.unlink( i ) ); - break; - case 1: - ASSERT_TRUE( s.erase( i.key())); - ASSERT_FALSE( s.erase( i.key() ) ); - break; - case 2: - EXPECT_EQ( i.nEraseCount, 0 ); - ASSERT_TRUE( s.erase( v.key(), []( value_type& val ) { ++val.nEraseCount; } )); - EXPECT_EQ( i.nEraseCount, 1 ); - ASSERT_FALSE( s.erase( v.key(), []( value_type& val ) { ++val.nEraseCount; } )); - EXPECT_EQ( i.nEraseCount, 1 ); - break; - } - - ASSERT_FALSE( s.contains( i.nKey )); - ASSERT_FALSE( s.find( i.nKey, []( value_type const& ) {} )); - } - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - // Force retiring cycle - Set::gc::force_dispose(); - for ( auto& i : data ) { - EXPECT_EQ( i.nDisposeCount, 1 ); - } - - // clear - for ( auto& i : data ) { - i.clear_stat(); - ASSERT_TRUE( s.insert( i )); - } - ASSERT_FALSE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, nSetSize ); - - // Forward iterator test - for ( auto it = s.begin(); it != s.end(); ++it ) { - ++it->nFindCount; - } - for ( auto it = s.cbegin(); it != s.cend(); ++it ) { - EXPECT_EQ( it->nFindCount, 1 ); - } - - // Reverse iterator test - for ( auto it = s.rbegin(); it != s.rend(); ++it ) { - ++it->nFindCount; - } - for ( auto it = s.crbegin(); it != s.crend(); ++it ) { - EXPECT_EQ( it->nFindCount, 2 ); - } - - for ( auto& i : data ) { - EXPECT_EQ( i.nFindCount, 2 ); - } - - // clear test - s.clear(); - - ASSERT_TRUE( s.empty()); - ASSERT_CONTAINER_SIZE( s, 0 ); - ASSERT_TRUE( s.begin() == s.end() ); - ASSERT_TRUE( s.cbegin() == s.cend() ); - - // Force retiring cycle - Set::gc::force_dispose(); - for ( auto& i : data ) { - EXPECT_EQ( i.nDisposeCount, 1 ); - } - } - }; - -} // namespace cds_test - -#endif // #ifndef CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_H diff --git a/test/unit/set/test_intrusive_feldman_hashset_hp.h b/test/unit/set/test_intrusive_feldman_hashset_hp.h deleted file mode 100644 index 17dd9ec9..00000000 --- a/test/unit/set/test_intrusive_feldman_hashset_hp.h +++ /dev/null @@ -1,165 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#ifndef CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_HP_H -#define CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_HP_H - -#include "test_intrusive_feldman_hashset.h" - -namespace cds_test { - - class intrusive_feldman_hashset_hp: public intrusive_feldman_hashset - { - typedef intrusive_feldman_hashset base_class; - - protected: - - template - void test( Set& s ) - { - // Precondition: set is empty - // Postcondition: set is empty - - base_class::test( s ); - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - typedef typename Set::value_type value_type; - size_t const nSetSize = std::max( s.head_size() * 2, static_cast( 100 )); - - std::vector< value_type > data; - std::vector< size_t> indices; - data.reserve( nSetSize ); - indices.reserve( nSetSize ); - for ( size_t key = 0; key < nSetSize; ++key ) { - data.push_back( value_type( static_cast(key) ) ); - indices.push_back( key ); - } - shuffle( indices.begin(), indices.end() ); - - typename Set::guarded_ptr gp; - - // get/extract from empty set - for ( auto idx : indices ) { - auto& i = data[idx]; - - gp = s.get( i.key() ); - ASSERT_TRUE( !gp ); - - gp = s.extract( i.key()); - ASSERT_TRUE( !gp ); - } - - // fill set - for ( auto& i : data ) { - i.nDisposeCount = 0; - ASSERT_TRUE( s.insert( i ) ); - } - - // get/extract - for ( auto idx : indices ) { - auto& i = data[idx]; - - EXPECT_EQ( i.nFindCount, 0 ); - gp = s.get( i.key() ); - ASSERT_FALSE( !gp ); - ++gp->nFindCount; - EXPECT_EQ( i.nFindCount, 1 ); - - gp = s.extract( i.key()); - ASSERT_FALSE( !gp ); - ++gp->nEraseCount; - EXPECT_EQ( i.nEraseCount, 1 ); - - gp = s.extract( i.key() ); - ASSERT_TRUE( !gp ); - - gp = s.get( i.key() ); - ASSERT_TRUE( !gp ); - } - gp.release(); - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - // Force retiring cycle - Set::gc::force_dispose(); - for ( auto& i : data ) { - EXPECT_EQ( i.nDisposeCount, 1 ); - } - - // erase_at( iterator ) - for ( auto& i : data ) { - i.clear_stat(); - ASSERT_TRUE( s.insert( i ) ); - } - ASSERT_FALSE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, nSetSize ); - - for ( auto it = s.begin(); it != s.end(); ++it ) { - ASSERT_TRUE( s.erase_at( it ) ); - ASSERT_FALSE( s.erase_at( it ) ); - } - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - // Force retiring cycle - Set::gc::force_dispose(); - for ( auto& i : data ) { - EXPECT_EQ( i.nDisposeCount, 1 ); - } - - // erase_at( reverse_iterator ) - for ( auto& i : data ) { - i.clear_stat(); - ASSERT_TRUE( s.insert( i ) ); - } - ASSERT_FALSE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, nSetSize ); - - for ( auto it = s.rbegin(); it != s.rend(); ++it ) { - ASSERT_TRUE( s.erase_at( it ) ); - ASSERT_FALSE( s.erase_at( it ) ); - } - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - // Force retiring cycle - Set::gc::force_dispose(); - for ( auto& i : data ) { - EXPECT_EQ( i.nDisposeCount, 1 ); - } - } - }; - -} // namespace cds_test - -#endif // #ifndef CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_HP_H diff --git a/test/unit/set/test_intrusive_feldman_hashset_rcu.h b/test/unit/set/test_intrusive_feldman_hashset_rcu.h deleted file mode 100644 index a8db5437..00000000 --- a/test/unit/set/test_intrusive_feldman_hashset_rcu.h +++ /dev/null @@ -1,233 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#ifndef CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_RCU_H -#define CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_RCU_H - -#include "test_intrusive_feldman_hashset.h" - -#include - -namespace ci = cds::intrusive; -namespace co = cds::opt; - -template -class IntrusiveFeldmanHashSet : public cds_test::intrusive_feldman_hashset -{ - typedef cds_test::intrusive_feldman_hashset base_class; - -protected: - typedef cds::urcu::gc rcu_type; - - template - void test( Set& s ) - { - // Precondition: set is empty - // Postcondition: set is empty - - base_class::test( s ); - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - typedef typename Set::value_type value_type; - size_t const nSetSize = std::max( s.head_size() * 2, static_cast(100) ); - - std::vector< value_type > data; - std::vector< size_t> indices; - data.reserve( nSetSize ); - indices.reserve( nSetSize ); - for ( size_t key = 0; key < nSetSize; ++key ) { - data.push_back( value_type( static_cast(key) ) ); - indices.push_back( key ); - } - shuffle( indices.begin(), indices.end() ); - - typename Set::exempt_ptr xp; - value_type * rp; - typedef typename Set::rcu_lock rcu_lock; - - // get/extract from empty set - for ( auto idx : indices ) { - auto& i = data[idx]; - - { - rcu_lock l; - rp = s.get( i.key() ); - ASSERT_TRUE( !rp ); - } - - xp = s.extract( i.key() ); - ASSERT_TRUE( !xp ); - } - - // fill set - for ( auto& i : data ) { - i.nDisposeCount = 0; - ASSERT_TRUE( s.insert( i ) ); - } - - // get/extract - for ( auto idx : indices ) { - auto& i = data[idx]; - - { - rcu_lock l; - EXPECT_EQ( i.nFindCount, 0 ); - rp = s.get( i.key() ); - ASSERT_FALSE( !rp ); - ++rp->nFindCount; - EXPECT_EQ( i.nFindCount, 1 ); - } - - EXPECT_EQ( i.nEraseCount, 0 ); - xp = s.extract( i.key()); - ASSERT_FALSE( !xp ); - ++xp->nEraseCount; - EXPECT_EQ( i.nEraseCount, 1 ); - - xp = s.extract( i.key() ); - ASSERT_TRUE( !xp ); - } - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - // Force retiring cycle - Set::gc::force_dispose(); - for ( auto& i : data ) { - EXPECT_EQ( i.nDisposeCount, 1 ); - } - } - - void SetUp() - { - RCU::Construct(); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - RCU::Destruct(); - } -}; - -TYPED_TEST_CASE_P( IntrusiveFeldmanHashSet ); - -TYPED_TEST_P( IntrusiveFeldmanHashSet, compare ) -{ - typedef typename TestFixture::rcu_type rcu_type; - - struct traits : public ci::feldman_hashset::traits - { - typedef typename TestFixture::hash_accessor hash_accessor; - typedef typename TestFixture::cmp compare; - typedef typename TestFixture::mock_disposer disposer; - }; - - typedef ci::FeldmanHashSet< rcu_type, typename TestFixture::int_item, traits > set_type; - - set_type s; - this->test( s ); -} - -TYPED_TEST_P( IntrusiveFeldmanHashSet, less ) -{ - typedef ci::FeldmanHashSet< typename TestFixture::rcu_type, typename TestFixture::int_item, - typename ci::feldman_hashset::make_traits< - ci::feldman_hashset::hash_accessor< typename TestFixture::hash_accessor > - , ci::opt::less< std::less> - , ci::opt::disposer< typename TestFixture::mock_disposer> - >::type - > set_type; - - set_type s( 5, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveFeldmanHashSet, cmpmix ) -{ - struct traits : public ci::feldman_hashset::traits - { - typedef typename TestFixture::hash_accessor hash_accessor; - typedef typename TestFixture::cmp compare; - typedef std::less less; - typedef typename TestFixture::mock_disposer disposer; - typedef typename TestFixture::simple_item_counter item_counter; - }; - - typedef ci::FeldmanHashSet< typename TestFixture::rcu_type, typename TestFixture::int_item, traits > set_type; - - set_type s( 3, 4 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveFeldmanHashSet, backoff ) -{ - struct traits : public ci::feldman_hashset::traits - { - typedef typename TestFixture::hash_accessor hash_accessor; - typedef typename TestFixture::cmp compare; - typedef typename TestFixture::mock_disposer disposer; - typedef cds::backoff::empty back_off; - typedef ci::opt::v::sequential_consistent memory_model; - }; - - typedef ci::FeldmanHashSet< typename TestFixture::rcu_type, typename TestFixture::int_item, traits > set_type; - - set_type s( 8, 3 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveFeldmanHashSet, stat ) -{ - struct traits : public ci::feldman_hashset::traits - { - typedef typename TestFixture::hash_accessor hash_accessor; - typedef typename TestFixture::cmp compare; - typedef typename TestFixture::mock_disposer disposer; - typedef ci::feldman_hashset::stat<> stat; - }; - - typedef ci::FeldmanHashSet< typename TestFixture::rcu_type, typename TestFixture::int_item, traits > set_type; - - set_type s( 8, 3 ); - this->test( s ); -} - -// GCC 5: All test names should be written on single line, otherwise a runtime error will be encountered like as -// "No test named can be found in this test case" -REGISTER_TYPED_TEST_CASE_P( IntrusiveFeldmanHashSet, - compare, less, cmpmix, backoff, stat - ); - - -#endif // #ifndef CDSUNIT_SET_TEST_INTRUSIVE_FELDMAN_HASHSET_RCU_H diff --git a/test/unit/set/test_intrusive_michael_lazy_rcu.h b/test/unit/set/test_intrusive_michael_lazy_rcu.h deleted file mode 100644 index c32fdb65..00000000 --- a/test/unit/set/test_intrusive_michael_lazy_rcu.h +++ /dev/null @@ -1,298 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -#ifndef CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_LAZY_RCU_H -#define CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_LAZY_RCU_H - -#include "test_intrusive_set_rcu.h" -#include -#include - -namespace ci = cds::intrusive; - -template -class IntrusiveMichaelLazySet: public cds_test::intrusive_set_rcu -{ - typedef cds_test::intrusive_set_rcu base_class; -public: - typedef cds::urcu::gc rcu_type; - typedef typename base_class::base_int_item< ci::lazy_list::node> base_item_type; - typedef typename base_class::base_int_item< ci::lazy_list::node> base_mutex_item_type; - typedef typename base_class::member_int_item< ci::lazy_list::node> member_item_type; - typedef typename base_class::member_int_item< ci::lazy_list::node> member_mutex_item_type; - -protected: - void SetUp() - { - RCU::Construct(); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - RCU::Destruct(); - } -}; - -TYPED_TEST_CASE_P( IntrusiveMichaelLazySet ); - -TYPED_TEST_P( IntrusiveMichaelLazySet, base_cmp ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_item_type base_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template cmp cmp; - typedef typename TestFixture::hash_int hash_int; - - typedef ci::LazyList< rcu_type - , base_item_type - , typename ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< rcu_type > > > - , ci::opt::compare< cmp > - , ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< rcu_type, bucket_type, - typename ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveMichaelLazySet, base_less ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_item_type base_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template less less; - typedef typename TestFixture::hash_int hash_int; - - typedef ci::LazyList< rcu_type - , base_item_type - , typename ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< rcu_type >>> - , ci::opt::less< less > - , ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< rcu_type, bucket_type, - typename ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveMichaelLazySet, base_cmpmix ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_item_type base_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::hash_int hash_int; - - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc> hook; - typedef typename TestFixture::template less less; - typedef typename TestFixture::template cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< rcu_type, base_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef typename TestFixture::simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< rcu_type, bucket_type, set_traits > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveMichaelLazySet, base_mutex ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_mutex_item_type base_mutex_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::hash_int hash_int; - - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc, ci::opt::lock_type> hook; - typedef typename TestFixture::template less less; - typedef typename TestFixture::template cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< rcu_type, base_mutex_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef typename TestFixture::simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< rcu_type, bucket_type, set_traits > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - - -TYPED_TEST_P( IntrusiveMichaelLazySet, member_cmp ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_item_type member_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template cmp cmp; - typedef typename TestFixture::hash_int hash_int; - - typedef ci::LazyList< rcu_type - , member_item_type - , typename ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - >> - , ci::opt::compare< cmp > - , ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< rcu_type, bucket_type, - typename ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveMichaelLazySet, member_less ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_item_type member_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template less less; - typedef typename TestFixture::hash_int hash_int; - - typedef ci::LazyList< rcu_type - , member_item_type - , typename ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - , ci::opt::less< less > - , ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< rcu_type, bucket_type, - typename ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveMichaelLazySet, member_cmpmix ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_item_type member_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::hash_int hash_int; - - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; - typedef typename TestFixture::template less less; - typedef typename TestFixture::template cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< rcu_type, member_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef typename TestFixture::simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< rcu_type, bucket_type, set_traits > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveMichaelLazySet, member_mutex ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_mutex_item_type member_mutex_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::hash_int hash_int; - - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc, ci::opt::lock_type> hook; - typedef typename TestFixture::template less less; - typedef typename TestFixture::template cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< rcu_type, member_mutex_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef typename TestFixture::simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< rcu_type, bucket_type, set_traits > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - - -// GCC 5: All test names should be written on single line, otherwise a runtime error will be encountered like as -// "No test named can be found in this test case" -REGISTER_TYPED_TEST_CASE_P( IntrusiveMichaelLazySet, - base_cmp, base_less, base_cmpmix, base_mutex, member_cmp, member_less, member_cmpmix, member_mutex -); - - -#endif // CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_LAZY_RCU_H - \ No newline at end of file diff --git a/test/unit/set/test_intrusive_michael_michael_rcu.h b/test/unit/set/test_intrusive_michael_michael_rcu.h deleted file mode 100644 index 199fef5c..00000000 --- a/test/unit/set/test_intrusive_michael_michael_rcu.h +++ /dev/null @@ -1,243 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -#ifndef CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_MICHAEL_RCU_H -#define CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_MICHAEL_RCU_H - -#include "test_intrusive_set_rcu.h" -#include -#include - -namespace ci = cds::intrusive; - -template -class IntrusiveMichaelSet: public cds_test::intrusive_set_rcu -{ - typedef cds_test::intrusive_set_rcu base_class; -public: - typedef cds::urcu::gc rcu_type; - typedef typename base_class::base_int_item< ci::michael_list::node> base_item_type; - typedef typename base_class::member_int_item< ci::michael_list::node> member_item_type; - -protected: - void SetUp() - { - RCU::Construct(); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - RCU::Destruct(); - } -}; - -TYPED_TEST_CASE_P( IntrusiveMichaelSet ); - -TYPED_TEST_P( IntrusiveMichaelSet, base_cmp ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_item_type base_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template cmp cmp; - typedef typename TestFixture::hash_int hash_int; - - typedef ci::MichaelList< rcu_type - , base_item_type - , typename ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< rcu_type > > > - , ci::opt::compare< cmp > - , ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< rcu_type, bucket_type, - typename ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveMichaelSet, base_less ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_item_type base_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template less less; - typedef typename TestFixture::hash_int hash_int; - - typedef ci::MichaelList< rcu_type - , base_item_type - , typename ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< rcu_type >>> - , ci::opt::less< less > - , ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< rcu_type, bucket_type, - typename ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveMichaelSet, base_cmpmix ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_item_type base_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::hash_int hash_int; - - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::base_hook< ci::opt::gc> hook; - typedef typename TestFixture::template less less; - typedef typename TestFixture::template cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::MichaelList< rcu_type, base_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef typename TestFixture::simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< rcu_type, bucket_type, set_traits > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - - -TYPED_TEST_P( IntrusiveMichaelSet, member_cmp ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_item_type member_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template cmp cmp; - typedef typename TestFixture::hash_int hash_int; - - typedef ci::MichaelList< rcu_type - , member_item_type - , typename ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - >> - , ci::opt::compare< cmp > - , ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< rcu_type, bucket_type, - typename ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveMichaelSet, member_less ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_item_type member_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template less less; - typedef typename TestFixture::hash_int hash_int; - - typedef ci::MichaelList< rcu_type - , member_item_type - , typename ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - , ci::opt::less< less > - , ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::MichaelHashSet< rcu_type, bucket_type, - typename ci::michael_set::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveMichaelSet, member_cmpmix ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_item_type member_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::hash_int hash_int; - - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; - typedef typename TestFixture::template less less; - typedef typename TestFixture::template cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::MichaelList< rcu_type, member_item_type, list_traits > bucket_type; - - struct set_traits : public ci::michael_set::traits - { - typedef hash_int hash; - typedef typename TestFixture::simple_item_counter item_counter; - }; - typedef ci::MichaelHashSet< rcu_type, bucket_type, set_traits > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - - - -// GCC 5: All test names should be written on single line, otherwise a runtime error will be encountered like as -// "No test named can be found in this test case" -REGISTER_TYPED_TEST_CASE_P( IntrusiveMichaelSet, - base_cmp, base_less, base_cmpmix, member_cmp, member_less, member_cmpmix -); - - -#endif // CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_MICHAEL_RCU_H - \ No newline at end of file diff --git a/test/unit/set/test_intrusive_set.h b/test/unit/set/test_intrusive_set.h deleted file mode 100644 index d4ed3035..00000000 --- a/test/unit/set/test_intrusive_set.h +++ /dev/null @@ -1,450 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#ifndef CDSUNIT_SET_TEST_INTRUSIVE_SET_H -#define CDSUNIT_SET_TEST_INTRUSIVE_SET_H - -#include -#include - -#include -#include // ref - -// forward declaration -namespace cds { namespace intrusive {}} - -namespace cds_test { - - namespace ci = cds::intrusive; - namespace co = cds::opt; - - class intrusive_set: public fixture - { - public: - static size_t const kSize = 100; - - struct stat - { - unsigned int nDisposeCount ; // count of disposer calling - unsigned int nFindCount ; // count of find-functor calling - unsigned int nUpdateNewCount; - unsigned int nUpdateCount; - mutable unsigned int nEraseCount; - - stat() - { - clear_stat(); - } - - void clear_stat() - { - memset( this, 0, sizeof( *this ) ); - } - }; - - template - struct base_int_item - : public Node - , public stat - - { - int nKey; - int nVal; - - base_int_item() - {} - - explicit base_int_item( int key ) - : nKey( key ) - , nVal( key ) - {} - - base_int_item(int key, int val) - : nKey( key ) - , nVal(val) - {} - - base_int_item( base_int_item const& v ) - : Node() - , stat() - , nKey( v.nKey ) - , nVal( v.nVal ) - {} - - int key() const - { - return nKey; - } - }; - - template - struct member_int_item: public stat - { - int nKey; - int nVal; - - Node hMember; - - stat s; - - member_int_item() - {} - - explicit member_int_item( int key ) - : nKey( key ) - , nVal( key ) - {} - - member_int_item(int key, int val) - : nKey( key ) - , nVal(val) - {} - - member_int_item(member_int_item const& v ) - : stat() - , nKey( v.nKey ) - , nVal( v.nVal ) - {} - - int key() const - { - return nKey; - } - }; - - struct hash_int { - size_t operator()( int i ) const - { - return co::v::hash()( i ); - } - template - size_t operator()( const Item& i ) const - { - return (*this)( i.key() ); - } - }; - - struct simple_item_counter { - size_t m_nCount; - - simple_item_counter() - : m_nCount(0) - {} - - size_t operator ++() - { - return ++m_nCount; - } - - size_t operator --() - { - return --m_nCount; - } - - void reset() - { - m_nCount = 0; - } - - operator size_t() const - { - return m_nCount; - } - - }; - - - template - struct less - { - bool operator ()(const T& v1, const T& v2 ) const - { - return v1.key() < v2.key(); - } - - template - bool operator ()(const T& v1, const Q& v2 ) const - { - return v1.key() < v2; - } - - template - bool operator ()(const Q& v1, const T& v2 ) const - { - return v1 < v2.key(); - } - }; - - template - struct cmp { - int operator ()(const T& v1, const T& v2 ) const - { - if ( v1.key() < v2.key() ) - return -1; - return v1.key() > v2.key() ? 1 : 0; - } - - template - int operator ()(const T& v1, const Q& v2 ) const - { - if ( v1.key() < v2 ) - return -1; - return v1.key() > v2 ? 1 : 0; - } - - template - int operator ()(const Q& v1, const T& v2 ) const - { - if ( v1 < v2.key() ) - return -1; - return v1 > v2.key() ? 1 : 0; - } - }; - - struct other_item { - int nKey; - - explicit other_item( int k ) - : nKey( k ) - {} - - int key() const - { - return nKey; - } - }; - - struct other_less { - template - bool operator()( Q const& lhs, T const& rhs ) const - { - return lhs.key() < rhs.key(); - } - }; - - struct mock_disposer - { - template - void operator ()( T * p ) - { - ++p->nDisposeCount; - } - }; - - protected: - template - void test( Set& s ) - { - // Precondition: set is empty - // Postcondition: set is empty - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - size_t const nSetSize = kSize; - - typedef typename Set::value_type value_type; - - std::vector< value_type > data; - std::vector< size_t> indices; - data.reserve( kSize ); - indices.reserve( kSize ); - for ( size_t key = 0; key < kSize; ++key ) { - data.push_back( value_type( static_cast( key ))); - indices.push_back( key ); - } - shuffle( indices.begin(), indices.end() ); - - // insert/find - for ( auto idx : indices ) { - auto& i = data[ idx ]; - - ASSERT_FALSE( s.contains( i.nKey )); - ASSERT_FALSE( s.contains( i )); - ASSERT_FALSE( s.contains( other_item( i.key()), other_less())); - ASSERT_FALSE( s.find( i.nKey, []( value_type&, int ) {} )); - ASSERT_FALSE( s.find_with( other_item( i.key()), other_less(), []( value_type&, other_item const& ) {} )); - - std::pair updResult; - - updResult = s.update( i, []( bool bNew, value_type&, value_type& ) - { - ASSERT_TRUE( false ); - }, false ); - EXPECT_FALSE( updResult.first ); - EXPECT_FALSE( updResult.second ); - - switch ( i.key() % 3 ) { - case 0: - ASSERT_TRUE( s.insert( i )); - ASSERT_FALSE( s.insert( i )); - updResult = s.update( i, []( bool bNew, value_type& val, value_type& arg) - { - EXPECT_FALSE( bNew ); - EXPECT_EQ( &val, &arg ); - }, false ); - EXPECT_TRUE( updResult.first ); - EXPECT_FALSE( updResult.second ); - break; - case 1: - EXPECT_EQ( i.nUpdateNewCount, 0 ); - ASSERT_TRUE( s.insert( i, []( value_type& v ) { ++v.nUpdateNewCount;} )); - EXPECT_EQ( i.nUpdateNewCount, 1 ); - ASSERT_FALSE( s.insert( i, []( value_type& v ) { ++v.nUpdateNewCount;} ) ); - EXPECT_EQ( i.nUpdateNewCount, 1 ); - i.nUpdateNewCount = 0; - break; - case 2: - updResult = s.update( i, []( bool bNew, value_type& val, value_type& arg ) - { - EXPECT_TRUE( bNew ); - EXPECT_EQ( &val, &arg ); - }); - EXPECT_TRUE( updResult.first ); - EXPECT_TRUE( updResult.second ); - break; - } - - ASSERT_TRUE( s.contains( i.nKey ) ); - ASSERT_TRUE( s.contains( i ) ); - ASSERT_TRUE( s.contains( other_item( i.key() ), other_less())); - EXPECT_EQ( i.nFindCount, 0 ); - ASSERT_TRUE( s.find( i.nKey, []( value_type& v, int ) { ++v.nFindCount; } )); - EXPECT_EQ( i.nFindCount, 1 ); - ASSERT_TRUE( s.find_with( other_item( i.key() ), other_less(), []( value_type& v, other_item const& ) { ++v.nFindCount; } )); - EXPECT_EQ( i.nFindCount, 2 ); - } - ASSERT_FALSE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, nSetSize ); - - std::for_each( data.begin(), data.end(), []( value_type& v ) { v.clear_stat(); }); - - // erase - shuffle( indices.begin(), indices.end() ); - for ( auto idx : indices ) { - auto& i = data[ idx ]; - - ASSERT_TRUE( s.contains( i.nKey ) ); - ASSERT_TRUE( s.contains( i ) ); - ASSERT_TRUE( s.contains( other_item( i.key() ), other_less() ) ); - EXPECT_EQ( i.nFindCount, 0 ); - ASSERT_TRUE( s.find( i.nKey, []( value_type& v, int ) { ++v.nFindCount; } ) ); - EXPECT_EQ( i.nFindCount, 1 ); - ASSERT_TRUE( s.find_with( other_item( i.key() ), other_less(), []( value_type& v, other_item const& ) { ++v.nFindCount; } ) ); - EXPECT_EQ( i.nFindCount, 2 ); - - value_type v( i ); - switch ( i.key() % 6 ) { - case 0: - ASSERT_FALSE( s.unlink( v )); - ASSERT_TRUE( s.unlink( i )); - ASSERT_FALSE( s.unlink( i ) ); - break; - case 1: - ASSERT_TRUE( s.erase( i.key())); - ASSERT_FALSE( s.erase( i.key() ) ); - break; - case 2: - ASSERT_TRUE( s.erase( v )); - ASSERT_FALSE( s.erase( v ) ); - break; - case 3: - ASSERT_TRUE( s.erase_with( other_item( i.key()), other_less())); - ASSERT_FALSE( s.erase_with( other_item( i.key() ), other_less() ) ); - break; - case 4: - EXPECT_EQ( i.nEraseCount, 0 ); - ASSERT_TRUE( s.erase( v, []( value_type& val ) { ++val.nEraseCount; } )); - EXPECT_EQ( i.nEraseCount, 1 ); - ASSERT_FALSE( s.erase( v, []( value_type& val ) { ++val.nEraseCount; } )); - EXPECT_EQ( i.nEraseCount, 1 ); - break; - case 5: - EXPECT_EQ( i.nEraseCount, 0 ); - ASSERT_TRUE( s.erase_with( other_item( i.key() ), other_less(), []( value_type& val ) { ++val.nEraseCount; } )); - EXPECT_EQ( i.nEraseCount, 1 ); - ASSERT_FALSE( s.erase_with( other_item( i.key() ), other_less(), []( value_type& val ) { ++val.nEraseCount; } )); - EXPECT_EQ( i.nEraseCount, 1 ); - break; - } - - ASSERT_FALSE( s.contains( i.nKey )); - ASSERT_FALSE( s.contains( i )); - ASSERT_FALSE( s.contains( other_item( i.key()), other_less())); - ASSERT_FALSE( s.find( i.nKey, []( value_type&, int ) {} )); - ASSERT_FALSE( s.find_with( other_item( i.key()), other_less(), []( value_type&, other_item const& ) {} )); - } - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - // Force retiring cycle - Set::gc::force_dispose(); - for ( auto& i : data ) { - EXPECT_EQ( i.nDisposeCount, 1 ); - } - - // clear - for ( auto& i : data ) { - i.clear_stat(); - ASSERT_TRUE( s.insert( i )); - } - ASSERT_FALSE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, nSetSize ); - - // Iterator test - for ( auto it = s.begin(); it != s.end(); ++it ) { - ++it->nFindCount; - } - for ( auto it = s.cbegin(); it != s.cend(); ++it ) { - EXPECT_EQ( it->nFindCount, 1 ); - } - for ( auto& i : data ) { - EXPECT_EQ( i.nFindCount, 1 ); - } - - // clear test - s.clear(); - - ASSERT_TRUE( s.empty()); - ASSERT_CONTAINER_SIZE( s, 0 ); - ASSERT_TRUE( s.begin() == s.end() ); - ASSERT_TRUE( s.cbegin() == s.cend() ); - - // Force retiring cycle - Set::gc::force_dispose(); - for ( auto& i : data ) { - EXPECT_EQ( i.nDisposeCount, 1 ); - } - - } - }; - -} // namespace cds_test - -#endif // #ifndef CDSUNIT_SET_TEST_INTRUSIVE_SET_H diff --git a/test/unit/set/test_intrusive_set_hp.h b/test/unit/set/test_intrusive_set_hp.h deleted file mode 100644 index 7ae09c73..00000000 --- a/test/unit/set/test_intrusive_set_hp.h +++ /dev/null @@ -1,160 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#ifndef CDSUNIT_SET_TEST_INTRUSIVE_SET_HP_H -#define CDSUNIT_SET_TEST_INTRUSIVE_SET_HP_H - -#include "test_intrusive_set.h" - -// forward declaration -namespace cds { namespace intrusive {}} - -namespace cds_test { - - namespace ci = cds::intrusive; - namespace co = cds::opt; - - class intrusive_set_hp: public intrusive_set - { - typedef intrusive_set base_class; - - protected: - - template - void test( Set& s ) - { - // Precondition: set is empty - // Postcondition: set is empty - - base_class::test( s ); - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - typedef typename Set::value_type value_type; - - std::vector< value_type > data; - std::vector< size_t> indices; - data.reserve( kSize ); - indices.reserve( kSize ); - for ( size_t key = 0; key < kSize; ++key ) { - data.push_back( value_type( static_cast(key) ) ); - indices.push_back( key ); - } - shuffle( indices.begin(), indices.end() ); - - typename Set::guarded_ptr gp; - - // get/extract from empty set - for ( auto idx : indices ) { - auto& i = data[idx]; - - gp = s.get( i ); - ASSERT_TRUE( !gp ); - gp = s.get( i.key() ); - ASSERT_TRUE( !gp ); - gp = s.get_with( other_item( i.key()), other_less()); - ASSERT_TRUE( !gp ); - - gp = s.extract( i ); - ASSERT_TRUE( !gp ); - gp = s.extract( i.key()); - ASSERT_TRUE( !gp ); - gp = s.extract_with( other_item( i.key()), other_less()); - ASSERT_TRUE( !gp ); - } - - // fill set - for ( auto& i : data ) { - i.nDisposeCount = 0; - ASSERT_TRUE( s.insert( i ) ); - } - - // get/extract - for ( auto idx : indices ) { - auto& i = data[idx]; - - EXPECT_EQ( i.nFindCount, 0 ); - gp = s.get( i ); - ASSERT_FALSE( !gp ); - ++gp->nFindCount; - EXPECT_EQ( i.nFindCount, 1 ); - - gp = s.get( i.key() ); - ASSERT_FALSE( !gp ); - ++gp->nFindCount; - EXPECT_EQ( i.nFindCount, 2 ); - - gp = s.get_with( other_item( i.key()), other_less()); - ASSERT_FALSE( !gp ); - ++gp->nFindCount; - EXPECT_EQ( i.nFindCount, 3 ); - - EXPECT_EQ( i.nEraseCount, 0 ); - switch ( i.key() % 3 ) { - case 0: - gp = s.extract( i.key()); - break; - case 1: - gp = s.extract( i ); - break; - case 2: - gp = s.extract_with( other_item( i.key() ), other_less() ); - break; - } - ASSERT_FALSE( !gp ); - ++gp->nEraseCount; - EXPECT_EQ( i.nEraseCount, 1 ); - - gp = s.extract( i ); - ASSERT_TRUE( !gp ); - gp = s.extract( i.key() ); - ASSERT_TRUE( !gp ); - gp = s.extract_with( other_item( i.key() ), other_less() ); - ASSERT_TRUE( !gp ); - } - - gp.release(); - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - // Force retiring cycle - Set::gc::force_dispose(); - for ( auto& i : data ) { - EXPECT_EQ( i.nDisposeCount, 1 ); - } - - } - }; - -} // namespace cds_test - -#endif // #ifndef CDSUNIT_SET_TEST_INTRUSIVE_SET_HP_H diff --git a/test/unit/set/test_intrusive_set_nogc.h b/test/unit/set/test_intrusive_set_nogc.h deleted file mode 100644 index 46e06a55..00000000 --- a/test/unit/set/test_intrusive_set_nogc.h +++ /dev/null @@ -1,374 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#ifndef CDSUNIT_SET_TEST_INTRUSIVE_SET_NOGC_H -#define CDSUNIT_SET_TEST_INTRUSIVE_SET_NOGC_H - -#include -#include - -#include -#include // ref - -// forward declaration -namespace cds { namespace intrusive {}} - -namespace cds_test { - - namespace ci = cds::intrusive; - namespace co = cds::opt; - - class intrusive_set_nogc: public fixture - { - public: - static size_t const kSize = 100; - - struct stat - { - unsigned int nFindCount ; // count of find-functor calling - unsigned int nUpdateNewCount; - unsigned int nUpdateCount; - unsigned int nDisposeCount; - - stat() - { - clear_stat(); - } - - void clear_stat() - { - memset( this, 0, sizeof( *this ) ); - } - }; - - template - struct base_int_item - : public Node - , public stat - - { - int nKey; - int nVal; - - base_int_item() - {} - - explicit base_int_item( int key ) - : nKey( key ) - , nVal( key ) - {} - - base_int_item(int key, int val) - : nKey( key ) - , nVal(val) - {} - - base_int_item( base_int_item const& v ) - : Node() - , stat() - , nKey( v.nKey ) - , nVal( v.nVal ) - {} - - int key() const - { - return nKey; - } - }; - - template - struct member_int_item: public stat - { - int nKey; - int nVal; - - Node hMember; - - stat s; - - member_int_item() - {} - - explicit member_int_item( int key ) - : nKey( key ) - , nVal( key ) - {} - - member_int_item(int key, int val) - : nKey( key ) - , nVal(val) - {} - - member_int_item(member_int_item const& v ) - : stat() - , nKey( v.nKey ) - , nVal( v.nVal ) - {} - - int key() const - { - return nKey; - } - }; - - struct hash_int { - size_t operator()( int i ) const - { - return co::v::hash()( i ); - } - template - size_t operator()( const Item& i ) const - { - return (*this)( i.key() ); - } - }; - - struct simple_item_counter { - size_t m_nCount; - - simple_item_counter() - : m_nCount(0) - {} - - size_t operator ++() - { - return ++m_nCount; - } - - size_t operator --() - { - return --m_nCount; - } - - void reset() - { - m_nCount = 0; - } - - operator size_t() const - { - return m_nCount; - } - - }; - - - template - struct less - { - bool operator ()(const T& v1, const T& v2 ) const - { - return v1.key() < v2.key(); - } - - template - bool operator ()(const T& v1, const Q& v2 ) const - { - return v1.key() < v2; - } - - template - bool operator ()(const Q& v1, const T& v2 ) const - { - return v1 < v2.key(); - } - }; - - template - struct cmp { - int operator ()(const T& v1, const T& v2 ) const - { - if ( v1.key() < v2.key() ) - return -1; - return v1.key() > v2.key() ? 1 : 0; - } - - template - int operator ()(const T& v1, const Q& v2 ) const - { - if ( v1.key() < v2 ) - return -1; - return v1.key() > v2 ? 1 : 0; - } - - template - int operator ()(const Q& v1, const T& v2 ) const - { - if ( v1 < v2.key() ) - return -1; - return v1 > v2.key() ? 1 : 0; - } - }; - - struct other_item { - int nKey; - - explicit other_item( int k ) - : nKey( k ) - {} - - int key() const - { - return nKey; - } - }; - - struct other_less { - template - bool operator()( Q const& lhs, T const& rhs ) const - { - return lhs.key() < rhs.key(); - } - }; - - struct mock_disposer - { - template - void operator ()( T * p ) - { - ++p->nDisposeCount; - } - }; - - protected: - template - void test( Set& s ) - { - // Precondition: set is empty - // Postcondition: set is empty - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - size_t const nSetSize = kSize; - - typedef typename Set::value_type value_type; - - std::vector< value_type > data; - std::vector< size_t> indices; - data.reserve( kSize ); - indices.reserve( kSize ); - for ( size_t key = 0; key < kSize; ++key ) { - data.push_back( value_type( static_cast( key ))); - indices.push_back( key ); - } - shuffle( indices.begin(), indices.end() ); - - // insert/find - for ( auto idx : indices ) { - auto& i = data[ idx ]; - - ASSERT_TRUE( s.contains( i.nKey ) == nullptr ); - ASSERT_TRUE( s.contains( i ) == nullptr ); - ASSERT_TRUE( s.contains( other_item( i.key()), other_less()) == nullptr ); - ASSERT_FALSE( s.find( i.nKey, []( value_type&, int ) {} )); - ASSERT_FALSE( s.find_with( other_item( i.key()), other_less(), []( value_type&, other_item const& ) {} )); - - std::pair updResult; - - updResult = s.update( i, []( bool bNew, value_type&, value_type& ) - { - ASSERT_TRUE( false ); - }, false ); - EXPECT_FALSE( updResult.first ); - EXPECT_FALSE( updResult.second ); - - switch ( i.key() % 2 ) { - case 0: - ASSERT_TRUE( s.insert( i )); - ASSERT_FALSE( s.insert( i )); - EXPECT_EQ( i.nUpdateCount, 0 ); - updResult = s.update( i, []( bool bNew, value_type& val, value_type& arg) - { - EXPECT_FALSE( bNew ); - EXPECT_EQ( &val, &arg ); - ++val.nUpdateCount; - }, false ); - EXPECT_TRUE( updResult.first ); - EXPECT_FALSE( updResult.second ); - EXPECT_EQ( i.nUpdateCount, 1 ); - break; - case 1: - EXPECT_EQ( i.nUpdateNewCount, 0 ); - updResult = s.update( i, []( bool bNew, value_type& val, value_type& arg ) - { - EXPECT_TRUE( bNew ); - EXPECT_EQ( &val, &arg ); - ++val.nUpdateNewCount; - }); - EXPECT_TRUE( updResult.first ); - EXPECT_TRUE( updResult.second ); - EXPECT_EQ( i.nUpdateNewCount, 1 ); - break; - } - - ASSERT_TRUE( s.contains( i.nKey ) == &i ); - ASSERT_TRUE( s.contains( i ) == &i ); - ASSERT_TRUE( s.contains( other_item( i.key() ), other_less()) == &i ); - EXPECT_EQ( i.nFindCount, 0 ); - ASSERT_TRUE( s.find( i.nKey, []( value_type& v, int ) { ++v.nFindCount; } )); - EXPECT_EQ( i.nFindCount, 1 ); - ASSERT_TRUE( s.find_with( other_item( i.key() ), other_less(), []( value_type& v, other_item const& ) { ++v.nFindCount; } )); - EXPECT_EQ( i.nFindCount, 2 ); - } - ASSERT_FALSE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, nSetSize ); - - std::for_each( data.begin(), data.end(), []( value_type& v ) { v.clear_stat(); }); - - // Iterator test - for ( auto it = s.begin(); it != s.end(); ++it ) { - ++it->nFindCount; - } - for ( auto it = s.cbegin(); it != s.cend(); ++it ) { - EXPECT_EQ( it->nFindCount, 1 ); - } - for ( auto& i : data ) { - EXPECT_EQ( i.nFindCount, 1 ); - } - - // clear test - for ( auto& i : data ) { - EXPECT_EQ( i.nDisposeCount, 0 ); - } - s.clear(); - for ( auto& i : data ) { - EXPECT_EQ( i.nDisposeCount, 1 ); - } - - ASSERT_TRUE( s.empty()); - ASSERT_CONTAINER_SIZE( s, 0 ); - ASSERT_TRUE( s.begin() == s.end() ); - ASSERT_TRUE( s.cbegin() == s.cend() ); - } - }; - -} // namespace cds_test - -#endif // #ifndef CDSUNIT_SET_TEST_INTRUSIVE_SET_NOGC_H diff --git a/test/unit/set/test_intrusive_set_rcu.h b/test/unit/set/test_intrusive_set_rcu.h deleted file mode 100644 index ff28bef3..00000000 --- a/test/unit/set/test_intrusive_set_rcu.h +++ /dev/null @@ -1,212 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#ifndef CDSUNIT_SET_TEST_INTRUSIVE_SET_RCU_H -#define CDSUNIT_SET_TEST_INTRUSIVE_SET_RCU_H - -#include "test_intrusive_set.h" - -// forward declaration -namespace cds { namespace intrusive {}} - -namespace cds_test { - - namespace ci = cds::intrusive; - namespace co = cds::opt; - - class intrusive_set_rcu: public intrusive_set - { - typedef intrusive_set base_class; - - protected: - - template - void test( Set& s ) - { - // Precondition: set is empty - // Postcondition: set is empty - - base_class::test( s ); - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - typedef typename Set::value_type value_type; - - std::vector< value_type > data; - std::vector< size_t> indices; - data.reserve( kSize ); - indices.reserve( kSize ); - for ( size_t key = 0; key < kSize; ++key ) { - data.push_back( value_type( static_cast(key) ) ); - indices.push_back( key ); - } - shuffle( indices.begin(), indices.end() ); - - typename Set::exempt_ptr xp; - typename Set::raw_ptr rp; - typedef typename Set::rcu_lock rcu_lock; - - // get/extract from empty set - for ( auto idx : indices ) { - auto& i = data[idx]; - - { - rcu_lock l; - rp = s.get( i ); - ASSERT_TRUE( !rp ); - rp = s.get( i.key() ); - ASSERT_TRUE( !rp ); - rp = s.get_with( other_item( i.key()), other_less()); - ASSERT_TRUE( !rp ); - } - - if ( Set::c_bExtractLockExternal ) { - rcu_lock l; - - xp = s.extract( i ); - ASSERT_TRUE( !xp ); - xp = s.extract( i.key() ); - ASSERT_TRUE( !xp ); - xp = s.extract_with( other_item( i.key() ), other_less() ); - ASSERT_TRUE( !xp ); - } - else { - xp = s.extract( i ); - ASSERT_TRUE( !xp ); - xp = s.extract( i.key() ); - ASSERT_TRUE( !xp ); - xp = s.extract_with( other_item( i.key() ), other_less() ); - ASSERT_TRUE( !xp ); - } - } - - // fill set - for ( auto& i : data ) { - i.nDisposeCount = 0; - ASSERT_TRUE( s.insert( i ) ); - } - - // get/extract - for ( auto idx : indices ) { - auto& i = data[idx]; - - { - rcu_lock l; - EXPECT_EQ( i.nFindCount, 0 ); - rp = s.get( i ); - ASSERT_FALSE( !rp ); - ++rp->nFindCount; - EXPECT_EQ( i.nFindCount, 1 ); - - rp = s.get( i.key() ); - ASSERT_FALSE( !rp ); - ++rp->nFindCount; - EXPECT_EQ( i.nFindCount, 2 ); - - rp = s.get_with( other_item( i.key()), other_less()); - ASSERT_FALSE( !rp ); - ++rp->nFindCount; - EXPECT_EQ( i.nFindCount, 3 ); - } - - if ( Set::c_bExtractLockExternal ) { - { - rcu_lock l; - - EXPECT_EQ( i.nEraseCount, 0 ); - switch ( i.key() % 3 ) { - case 0: - xp = s.extract( i.key()); - break; - case 1: - xp = s.extract( i ); - break; - case 2: - xp = s.extract_with( other_item( i.key() ), other_less() ); - break; - } - ASSERT_FALSE( !xp ); - ++xp->nEraseCount; - } - EXPECT_EQ( i.nEraseCount, 1 ); - xp.release(); - - { - rcu_lock l; - - xp = s.extract( i ); - ASSERT_TRUE( !xp ); - xp = s.extract( i.key() ); - ASSERT_TRUE( !xp ); - xp = s.extract_with( other_item( i.key() ), other_less() ); - ASSERT_TRUE( !xp ); - } - } - else { - EXPECT_EQ( i.nEraseCount, 0 ); - switch ( i.key() % 3 ) { - case 0: - xp = s.extract( i.key()); - break; - case 1: - xp = s.extract( i ); - break; - case 2: - xp = s.extract_with( other_item( i.key() ), other_less() ); - break; - } - ASSERT_FALSE( !xp ); - ++xp->nEraseCount; - EXPECT_EQ( i.nEraseCount, 1 ); - - xp = s.extract( i ); - ASSERT_TRUE( !xp ); - xp = s.extract( i.key() ); - ASSERT_TRUE( !xp ); - xp = s.extract_with( other_item( i.key() ), other_less() ); - ASSERT_TRUE( !xp ); - } - } - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - // Force retiring cycle - Set::gc::force_dispose(); - for ( auto& i : data ) { - EXPECT_EQ( i.nDisposeCount, 1 ); - } - } - }; - -} // namespace cds_test - -#endif // #ifndef CDSUNIT_SET_TEST_INTRUSIVE_SET_RCU_H diff --git a/test/unit/set/test_intrusive_skiplist_rcu.h b/test/unit/set/test_intrusive_skiplist_rcu.h deleted file mode 100644 index ddaa8dd1..00000000 --- a/test/unit/set/test_intrusive_skiplist_rcu.h +++ /dev/null @@ -1,248 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -#ifndef CDSUNIT_SET_TEST_INTRUSIVE_SKIPLIST_RCU_H -#define CDSUNIT_SET_TEST_INTRUSIVE_SKIPLIST_RCU_H - -#include "test_intrusive_set_rcu.h" -#include - -namespace ci = cds::intrusive; - -template -class IntrusiveSkipListSet: public cds_test::intrusive_set_rcu -{ - typedef cds_test::intrusive_set_rcu base_class; -public: - typedef cds::urcu::gc rcu_type; - typedef typename base_class::base_int_item< ci::skip_list::node> base_item_type; - typedef typename base_class::member_int_item< ci::skip_list::node> member_item_type; - -protected: - void SetUp() - { - RCU::Construct(); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - RCU::Destruct(); - } -}; - -TYPED_TEST_CASE_P( IntrusiveSkipListSet ); - -TYPED_TEST_P( IntrusiveSkipListSet, base_cmp ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_item_type base_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template cmp cmp; - - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - }; - - typedef ci::SkipListSet< rcu_type, base_item_type, traits > set_type; - - set_type s; - this->test( s ); -} - -TYPED_TEST_P( IntrusiveSkipListSet, base_less ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_item_type base_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template less less_predicate; - - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook; - typedef mock_disposer disposer; - typedef less_predicate less; - typedef cds::atomicity::item_counter item_counter; - }; - - typedef ci::SkipListSet< rcu_type, base_item_type, traits > set_type; - - set_type s; - this->test( s ); -} - -TYPED_TEST_P( IntrusiveSkipListSet, base_cmpmix ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_item_type base_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template cmp cmp; - typedef typename TestFixture::template less less_predicate; - - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - typedef less_predicate less; - typedef ci::skip_list::stat<> stat; - }; - - typedef ci::SkipListSet< rcu_type, base_item_type, traits > set_type; - - set_type s; - this->test( s ); -} - -TYPED_TEST_P( IntrusiveSkipListSet, base_xorshift ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_item_type base_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template cmp cmp; - - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - typedef ci::skip_list::xorshift random_level_generator; - }; - - typedef ci::SkipListSet< rcu_type, base_item_type, traits > set_type; - - set_type s; - this->test( s ); -} - - -TYPED_TEST_P( IntrusiveSkipListSet, member_cmp ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_item_type member_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template cmp cmp; - - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - }; - - typedef ci::SkipListSet< rcu_type, member_item_type, traits > set_type; - - set_type s; - this->test( s ); -} - -TYPED_TEST_P( IntrusiveSkipListSet, member_less ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_item_type member_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template less less_predicate; - typedef typename TestFixture::hash_int hash_int; - - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook; - typedef mock_disposer disposer; - typedef less_predicate less; - typedef cds::atomicity::item_counter item_counter; - typedef ci::opt::v::sequential_consistent memory_model; - }; - - typedef ci::SkipListSet< rcu_type, member_item_type, traits > set_type; - - set_type s; - this->test( s ); -} - -TYPED_TEST_P( IntrusiveSkipListSet, member_cmpmix ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_item_type member_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template less less_predicate; - typedef typename TestFixture::template cmp cmp; - - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - typedef less_predicate less; - typedef ci::skip_list::stat<> stat; - }; - - typedef ci::SkipListSet< rcu_type, member_item_type, traits > set_type; - - set_type s; - this->test( s ); -} - -TYPED_TEST_P( IntrusiveSkipListSet, member_xorshift ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_item_type member_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template less less_predicate; - typedef typename TestFixture::template cmp cmp; - - struct traits : public ci::skip_list::traits - { - typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook; - typedef mock_disposer disposer; - typedef cmp compare; - typedef less_predicate less; - typedef ci::skip_list::stat<> stat; - typedef ci::skip_list::xorshift random_level_generator; - }; - - typedef ci::SkipListSet< rcu_type, member_item_type, traits > set_type; - - set_type s; - this->test( s ); -} - - -// GCC 5: All test names should be written on single line, otherwise a runtime error will be encountered like as -// "No test named can be found in this test case" -REGISTER_TYPED_TEST_CASE_P( IntrusiveSkipListSet, - base_cmp, base_less, base_cmpmix, base_xorshift, member_cmp, member_less, member_cmpmix, member_xorshift -); - - -#endif // CDSUNIT_SET_TEST_INTRUSIVE_SKIPLIST_RCU_H - \ No newline at end of file diff --git a/test/unit/set/test_intrusive_split_lazy_rcu.h b/test/unit/set/test_intrusive_split_lazy_rcu.h deleted file mode 100644 index 33ab6fd5..00000000 --- a/test/unit/set/test_intrusive_split_lazy_rcu.h +++ /dev/null @@ -1,302 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -#ifndef CDSUNIT_SET_TEST_INTRUSIVE_SPLIT_LAZY_RCU_H -#define CDSUNIT_SET_TEST_INTRUSIVE_SPLIT_LAZY_RCU_H - -#include "test_intrusive_set_rcu.h" -#include -#include - -namespace ci = cds::intrusive; - -template -class IntrusiveSplitLazySet: public cds_test::intrusive_set_rcu -{ - typedef cds_test::intrusive_set_rcu base_class; -public: - typedef cds::urcu::gc rcu_type; - typedef typename base_class::base_int_item< ci::split_list::node>> base_item_type; - typedef typename base_class::base_int_item< ci::split_list::node>> base_mutex_item_type; - typedef typename base_class::member_int_item< ci::split_list::node>> member_item_type; - typedef typename base_class::member_int_item< ci::split_list::node>> member_mutex_item_type; - -protected: - void SetUp() - { - RCU::Construct(); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - RCU::Destruct(); - } -}; - -TYPED_TEST_CASE_P( IntrusiveSplitLazySet ); - -TYPED_TEST_P( IntrusiveSplitLazySet, base_cmp ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_item_type base_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template cmp cmp; - typedef typename TestFixture::hash_int hash_int; - - typedef ci::LazyList< rcu_type - , base_item_type - , typename ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< rcu_type > > > - , ci::opt::compare< cmp > - , ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< rcu_type, bucket_type, - typename ci::split_list::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveSplitLazySet, base_less ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_item_type base_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template less less; - typedef typename TestFixture::hash_int hash_int; - - typedef ci::LazyList< rcu_type - , base_item_type - , typename ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< rcu_type >>> - , ci::opt::less< less > - , ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< rcu_type, bucket_type, - typename ci::split_list::make_traits< - ci::opt::hash< hash_int > - , ci::opt::item_counter< cds::atomicity::item_counter > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveSplitLazySet, base_cmpmix ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_item_type base_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::hash_int hash_int; - - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc> hook; - typedef typename TestFixture::template less less; - typedef typename TestFixture::template cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< rcu_type, base_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef typename TestFixture::simple_item_counter item_counter; - typedef ci::split_list::stat<> stat; - }; - typedef ci::SplitListSet< rcu_type, bucket_type, set_traits > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveSplitLazySet, base_mutex ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_mutex_item_type base_mutex_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::hash_int hash_int; - - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::base_hook< ci::opt::gc, ci::opt::lock_type> hook; - typedef typename TestFixture::template less less; - typedef typename TestFixture::template cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< rcu_type, base_mutex_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef typename TestFixture::simple_item_counter item_counter; - typedef cds::backoff::empty back_off; - }; - typedef ci::SplitListSet< rcu_type, bucket_type, set_traits > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - - -TYPED_TEST_P( IntrusiveSplitLazySet, member_cmp ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_item_type member_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template cmp cmp; - typedef typename TestFixture::hash_int hash_int; - - typedef ci::LazyList< rcu_type - , member_item_type - , typename ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - >> - , ci::opt::compare< cmp > - , ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< rcu_type, bucket_type, - typename ci::split_list::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveSplitLazySet, member_less ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_item_type member_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template less less; - typedef typename TestFixture::hash_int hash_int; - - typedef ci::LazyList< rcu_type - , member_item_type - , typename ci::lazy_list::make_traits< - ci::opt::hook< ci::lazy_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - , ci::opt::less< less > - , ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< rcu_type, bucket_type, - typename ci::split_list::make_traits< - ci::opt::hash< hash_int > - , ci::opt::back_off< cds::backoff::pause > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveSplitLazySet, member_cmpmix ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_item_type member_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::hash_int hash_int; - - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; - typedef typename TestFixture::template less less; - typedef typename TestFixture::template cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< rcu_type, member_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef typename TestFixture::simple_item_counter item_counter; - }; - typedef ci::SplitListSet< rcu_type, bucket_type, set_traits > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveSplitLazySet, member_mutex ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_mutex_item_type member_mutex_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::hash_int hash_int; - - struct list_traits : public ci::lazy_list::traits - { - typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc, ci::opt::lock_type> hook; - typedef typename TestFixture::template less less; - typedef typename TestFixture::template cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::LazyList< rcu_type, member_mutex_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef typename TestFixture::simple_item_counter item_counter; - }; - typedef ci::SplitListSet< rcu_type, bucket_type, set_traits > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - - -// GCC 5: All test names should be written on single line, otherwise a runtime error will be encountered like as -// "No test named can be found in this test case" -REGISTER_TYPED_TEST_CASE_P( IntrusiveSplitLazySet, - base_cmp, base_less, base_cmpmix, base_mutex, member_cmp, member_less, member_cmpmix, member_mutex -); - - -#endif // CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_LAZY_RCU_H - \ No newline at end of file diff --git a/test/unit/set/test_intrusive_split_michael_rcu.h b/test/unit/set/test_intrusive_split_michael_rcu.h deleted file mode 100644 index e67097f7..00000000 --- a/test/unit/set/test_intrusive_split_michael_rcu.h +++ /dev/null @@ -1,246 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -#ifndef CDSUNIT_SET_TEST_INTRUSIVE_SPLIT_MICHAEL_RCU_H -#define CDSUNIT_SET_TEST_INTRUSIVE_SPLIT_MICHAEL_RCU_H - -#include "test_intrusive_set_rcu.h" -#include -#include - -namespace ci = cds::intrusive; - -template -class IntrusiveSplitMichaelSet: public cds_test::intrusive_set_rcu -{ - typedef cds_test::intrusive_set_rcu base_class; -public: - typedef cds::urcu::gc rcu_type; - typedef typename base_class::base_int_item< ci::split_list::node>> base_item_type; - typedef typename base_class::member_int_item< ci::split_list::node>> member_item_type; - -protected: - void SetUp() - { - RCU::Construct(); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - RCU::Destruct(); - } -}; - -TYPED_TEST_CASE_P( IntrusiveSplitMichaelSet ); - -TYPED_TEST_P( IntrusiveSplitMichaelSet, base_cmp ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_item_type base_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template cmp cmp; - typedef typename TestFixture::hash_int hash_int; - - typedef ci::MichaelList< rcu_type - , base_item_type - , typename ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< rcu_type > > > - , ci::opt::compare< cmp > - , ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< rcu_type, bucket_type, - typename ci::split_list::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveSplitMichaelSet, base_less ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_item_type base_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template less less; - typedef typename TestFixture::hash_int hash_int; - - typedef ci::MichaelList< rcu_type - , base_item_type - , typename ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< rcu_type >>> - , ci::opt::less< less > - , ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< rcu_type, bucket_type, - typename ci::split_list::make_traits< - ci::opt::hash< hash_int > - , ci::opt::item_counter< cds::atomicity::item_counter > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveSplitMichaelSet, base_cmpmix ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::base_item_type base_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::hash_int hash_int; - - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::base_hook< ci::opt::gc> hook; - typedef typename TestFixture::template less less; - typedef typename TestFixture::template cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::MichaelList< rcu_type, base_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef typename TestFixture::simple_item_counter item_counter; - typedef ci::split_list::stat<> stat; - }; - typedef ci::SplitListSet< rcu_type, bucket_type, set_traits > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - - -TYPED_TEST_P( IntrusiveSplitMichaelSet, member_cmp ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_item_type member_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template cmp cmp; - typedef typename TestFixture::hash_int hash_int; - - typedef ci::MichaelList< rcu_type - , member_item_type - , typename ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - >> - , ci::opt::compare< cmp > - , ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< rcu_type, bucket_type, - typename ci::split_list::make_traits< - ci::opt::hash< hash_int > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveSplitMichaelSet, member_less ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_item_type member_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::template less less; - typedef typename TestFixture::hash_int hash_int; - - typedef ci::MichaelList< rcu_type - , member_item_type - , typename ci::michael_list::make_traits< - ci::opt::hook< ci::michael_list::member_hook< - offsetof( member_item_type, hMember ), - ci::opt::gc - > > - , ci::opt::less< less > - , ci::opt::disposer< mock_disposer > - >::type - > bucket_type; - - typedef ci::SplitListSet< rcu_type, bucket_type, - typename ci::split_list::make_traits< - ci::opt::hash< hash_int > - , ci::opt::back_off< cds::backoff::pause > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( IntrusiveSplitMichaelSet, member_cmpmix ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::member_item_type member_item_type; - typedef typename TestFixture::mock_disposer mock_disposer; - typedef typename TestFixture::hash_int hash_int; - - struct list_traits : public ci::michael_list::traits - { - typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc> hook; - typedef typename TestFixture::template less less; - typedef typename TestFixture::template cmp compare; - typedef mock_disposer disposer; - }; - typedef ci::MichaelList< rcu_type, member_item_type, list_traits > bucket_type; - - struct set_traits : public ci::split_list::traits - { - typedef hash_int hash; - typedef typename TestFixture::simple_item_counter item_counter; - }; - typedef ci::SplitListSet< rcu_type, bucket_type, set_traits > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - - - -// GCC 5: All test names should be written on single line, otherwise a runtime error will be encountered like as -// "No test named can be found in this test case" -REGISTER_TYPED_TEST_CASE_P( IntrusiveSplitMichaelSet, - base_cmp, base_less, base_cmpmix, member_cmp, member_less, member_cmpmix -); - - -#endif // CDSUNIT_SET_TEST_INTRUSIVE_SPLIT_MICHAEL_RCU_H - \ No newline at end of file diff --git a/test/unit/set/test_michael_michael_rcu.h b/test/unit/set/test_michael_michael_rcu.h deleted file mode 100644 index 99f75ee6..00000000 --- a/test/unit/set/test_michael_michael_rcu.h +++ /dev/null @@ -1,204 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -#ifndef CDSUNIT_SET_TEST_MICHAEL_MICHAEL_RCU_H -#define CDSUNIT_SET_TEST_MICHAEL_MICHAEL_RCU_H - -#include "test_set_rcu.h" -#include -#include - -namespace cc = cds::container; - -template -class MichaelSet: public cds_test::container_set_rcu -{ - typedef cds_test::container_set_rcu base_class; -public: - typedef cds::urcu::gc rcu_type; - -protected: - void SetUp() - { - RCU::Construct(); - cds::threading::Manager::attachThread(); - } - - void TearDown() - { - cds::threading::Manager::detachThread(); - RCU::Destruct(); - } -}; - -TYPED_TEST_CASE_P( MichaelSet ); - -TYPED_TEST_P( MichaelSet, compare ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::int_item int_item; - - typedef cc::MichaelList< rcu_type, int_item, - typename cc::michael_list::make_traits< - cds::opt::compare< typename TestFixture::cmp > - >::type - > list_type; - - typedef cc::MichaelHashSet< rcu_type, list_type, - typename cc::michael_set::make_traits< - cds::opt::hash< typename TestFixture::hash_int > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( MichaelSet, less ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::int_item int_item; - - typedef cc::MichaelList< rcu_type, int_item, - typename cc::michael_list::make_traits< - cds::opt::less< typename TestFixture::less > - >::type - > list_type; - - typedef cc::MichaelHashSet< rcu_type, list_type, - typename cc::michael_set::make_traits< - cds::opt::hash< typename TestFixture::hash_int > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( MichaelSet, cmpmix ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::int_item int_item; - - struct list_traits : public cc::michael_list::traits - { - typedef typename TestFixture::less less; - typedef typename TestFixture::cmp compare; - }; - typedef cc::MichaelList< rcu_type, int_item, list_traits > list_type; - - typedef cc::MichaelHashSet< rcu_type, list_type, - typename cc::michael_set::make_traits< - cds::opt::hash< typename TestFixture::hash_int > - >::type - > set_type; - - set_type s( TestFixture::kSize, 2 ); - this->test( s ); -} - -TYPED_TEST_P( MichaelSet, item_counting ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::int_item int_item; - - struct list_traits : public cc::michael_list::traits - { - typedef typename TestFixture::cmp compare; - }; - typedef cc::MichaelList< rcu_type, int_item, list_traits > list_type; - - struct set_traits: public cc::michael_set::traits - { - typedef typename TestFixture::hash_int hash; - typedef typename TestFixture::simple_item_counter item_counter; - }; - typedef cc::MichaelHashSet< rcu_type, list_type, set_traits >set_type; - - set_type s( TestFixture::kSize, 3 ); - this->test( s ); -} - -TYPED_TEST_P( MichaelSet, backoff ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::int_item int_item; - - struct list_traits : public cc::michael_list::traits - { - typedef typename TestFixture::cmp compare; - typedef cds::backoff::exponential back_off; - }; - typedef cc::MichaelList< rcu_type, int_item, list_traits > list_type; - - struct set_traits : public cc::michael_set::traits - { - typedef typename TestFixture::hash_int hash; - typedef cds::atomicity::item_counter item_counter; - }; - typedef cc::MichaelHashSet< rcu_type, list_type, set_traits >set_type; - - set_type s( TestFixture::kSize, 4 ); - this->test( s ); -} - -TYPED_TEST_P( MichaelSet, seq_cst ) -{ - typedef typename TestFixture::rcu_type rcu_type; - typedef typename TestFixture::int_item int_item; - - struct list_traits : public cc::michael_list::traits - { - typedef typename TestFixture::less less; - typedef cds::backoff::pause back_off; - typedef cds::opt::v::sequential_consistent memory_model; - }; - typedef cc::MichaelList< rcu_type, int_item, list_traits > list_type; - - struct set_traits : public cc::michael_set::traits - { - typedef typename TestFixture::hash_int hash; - typedef cds::atomicity::item_counter item_counter; - }; - typedef cc::MichaelHashSet< rcu_type, list_type, set_traits >set_type; - - set_type s( TestFixture::kSize, 4 ); - this->test( s ); -} - - -// GCC 5: All test names should be written on single line, otherwise a runtime error will be encountered like as -// "No test named can be found in this test case" -REGISTER_TYPED_TEST_CASE_P( MichaelSet, - compare, less, cmpmix, item_counting, backoff, seq_cst -); - - -#endif // CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_MICHAEL_RCU_H - \ No newline at end of file diff --git a/test/unit/set/test_set.h b/test/unit/set/test_set.h deleted file mode 100644 index 1f6e142a..00000000 --- a/test/unit/set/test_set.h +++ /dev/null @@ -1,507 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#ifndef CDSUNIT_SET_TEST_SET_H -#define CDSUNIT_SET_TEST_SET_H - -#include -#include - -#include -#include // ref - -// forward declaration -namespace cds { namespace container {}} - -namespace cds_test { - namespace co = cds::opt; - - class container_set : public fixture - { - public: - static size_t const kSize = 100; - - struct stat - { - unsigned int nFindCount; - unsigned int nUpdateNewCount; - unsigned int nUpdateCount; - mutable unsigned int nEraseCount; - - stat() - { - clear_stat(); - } - - void clear_stat() - { - memset( this, 0, sizeof( *this ) ); - } - }; - - struct other_item { - int nKey; - - explicit other_item( int k ) - : nKey( k ) - {} - - int key() const - { - return nKey; - } - }; - - struct int_item: public stat - { - int nKey; - int nVal; - std::string strVal; - - int_item() - : nKey( 0 ) - , nVal( 0 ) - {} - - explicit int_item( int k ) - : nKey( k ) - , nVal( k * 2 ) - {} - - template - explicit int_item( Q const& src ) - : nKey( src.key() ) - , nVal( 0 ) - {} - - int_item( int_item const& src ) - : nKey( src.nKey ) - , nVal( src.nVal ) - , strVal( src.strVal ) - {} - - int_item( int_item&& src ) - : nKey( src.nKey ) - , nVal( src.nVal ) - , strVal( std::move( src.strVal ) ) - {} - - int_item( int k, std::string&& s ) - : nKey( k ) - , nVal( k * 2 ) - , strVal( std::move( s ) ) - {} - - explicit int_item( other_item const& s ) - : nKey( s.key() ) - , nVal( s.key() * 2 ) - {} - - int key() const - { - return nKey; - } - }; - - struct hash_int { - size_t operator()( int i ) const - { - return co::v::hash()(i); - } - template - size_t operator()( const Item& i ) const - { - return (*this)(i.key()); - } - }; - - struct simple_item_counter { - size_t m_nCount; - - simple_item_counter() - : m_nCount( 0 ) - {} - - size_t operator ++() - { - return ++m_nCount; - } - - size_t operator --() - { - return --m_nCount; - } - - void reset() - { - m_nCount = 0; - } - - operator size_t() const - { - return m_nCount; - } - - }; - - struct less - { - bool operator ()( int_item const& v1, int_item const& v2 ) const - { - return v1.key() < v2.key(); - } - - template - bool operator ()( int_item const& v1, const Q& v2 ) const - { - return v1.key() < v2; - } - - template - bool operator ()( const Q& v1, int_item const& v2 ) const - { - return v1 < v2.key(); - } - }; - - struct cmp { - int operator ()( int_item const& v1, int_item const& v2 ) const - { - if ( v1.key() < v2.key() ) - return -1; - return v1.key() > v2.key() ? 1 : 0; - } - - template - int operator ()( T const& v1, int v2 ) const - { - if ( v1.key() < v2 ) - return -1; - return v1.key() > v2 ? 1 : 0; - } - - template - int operator ()( int v1, T const& v2 ) const - { - if ( v1 < v2.key() ) - return -1; - return v1 > v2.key() ? 1 : 0; - } - }; - - struct other_less { - template - bool operator()( Q const& lhs, T const& rhs ) const - { - return lhs.key() < rhs.key(); - } - }; - - protected: - template - void test( Set& s ) - { - // Precondition: set is empty - // Postcondition: set is empty - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - size_t const nSetSize = kSize; - - typedef typename Set::value_type value_type; - - std::vector< value_type > data; - std::vector< size_t> indices; - data.reserve( kSize ); - indices.reserve( kSize ); - for ( size_t key = 0; key < kSize; ++key ) { - data.push_back( value_type( static_cast(key) ) ); - indices.push_back( key ); - } - shuffle( indices.begin(), indices.end() ); - - // insert/find - for ( auto idx : indices ) { - auto& i = data[idx]; - - ASSERT_FALSE( s.contains( i.nKey ) ); - ASSERT_FALSE( s.contains( i ) ); - ASSERT_FALSE( s.contains( other_item( i.key() ), other_less())); - ASSERT_FALSE( s.find( i.nKey, []( value_type&, int ) {} )); - ASSERT_FALSE( s.find( i, []( value_type&, value_type const& ) {} )); - ASSERT_FALSE( s.find_with( other_item( i.key()), other_less(), []( value_type&, other_item const& ) {} )); - - std::pair updResult; - - std::string str; - updResult = s.update( i.key(), []( bool bNew, value_type&, int ) - { - ASSERT_TRUE( false ); - }, false ); - EXPECT_FALSE( updResult.first ); - EXPECT_FALSE( updResult.second ); - - switch ( idx % 8 ) { - case 0: - ASSERT_TRUE( s.insert( i )); - ASSERT_FALSE( s.insert( i )); - updResult = s.update( i, []( bool bNew, value_type& val, value_type const& arg) - { - EXPECT_FALSE( bNew ); - EXPECT_EQ( val.key(), arg.key() ); - }, false ); - EXPECT_TRUE( updResult.first ); - EXPECT_FALSE( updResult.second ); - break; - case 1: - ASSERT_TRUE( s.insert( i.key() )); - ASSERT_FALSE( s.insert( i.key() )); - updResult = s.update( i.key(), []( bool bNew, value_type& val, int arg) - { - EXPECT_FALSE( bNew ); - EXPECT_EQ( val.key(), arg ); - }, false ); - EXPECT_TRUE( updResult.first ); - EXPECT_FALSE( updResult.second ); - break; - case 2: - ASSERT_TRUE( s.insert( i, []( value_type& v ) { ++v.nFindCount; } )); - ASSERT_FALSE( s.insert( i, []( value_type& v ) { ++v.nFindCount; } )); - ASSERT_TRUE( s.find( i.nKey, []( value_type const& v, int key ) - { - EXPECT_EQ( v.key(), key ); - EXPECT_EQ( v.nFindCount, 1 ); - })); - break; - case 3: - ASSERT_TRUE( s.insert( i.key(), []( value_type& v ) { ++v.nFindCount; } )); - ASSERT_FALSE( s.insert( i.key(), []( value_type& v ) { ++v.nFindCount; } )); - ASSERT_TRUE( s.find( i.nKey, []( value_type const& v, int key ) - { - EXPECT_EQ( v.key(), key ); - EXPECT_EQ( v.nFindCount, 1 ); - })); - break; - case 4: - updResult = s.update( i, []( bool bNew, value_type& v, value_type const& arg ) - { - EXPECT_TRUE( bNew ); - EXPECT_EQ( v.key(), arg.key() ); - ++v.nUpdateNewCount; - }); - EXPECT_TRUE( updResult.first ); - EXPECT_TRUE( updResult.second ); - - updResult = s.update( i, []( bool bNew, value_type& v, value_type const& arg ) - { - EXPECT_FALSE( bNew ); - EXPECT_EQ( v.key(), arg.key() ); - ++v.nUpdateNewCount; - }, false ); - EXPECT_TRUE( updResult.first ); - EXPECT_FALSE( updResult.second ); - - ASSERT_TRUE( s.find( i.nKey, []( value_type const& v, int key ) - { - EXPECT_EQ( v.key(), key ); - EXPECT_EQ( v.nUpdateNewCount, 2 ); - })); - break; - case 5: - updResult = s.update( i.key(), []( bool bNew, value_type& v, int arg ) - { - EXPECT_TRUE( bNew ); - EXPECT_EQ( v.key(), arg ); - ++v.nUpdateNewCount; - }); - EXPECT_TRUE( updResult.first ); - EXPECT_TRUE( updResult.second ); - - updResult = s.update( i.key(), []( bool bNew, value_type& v, int arg ) - { - EXPECT_FALSE( bNew ); - EXPECT_EQ( v.key(), arg ); - ++v.nUpdateNewCount; - }, false ); - EXPECT_TRUE( updResult.first ); - EXPECT_FALSE( updResult.second ); - - ASSERT_TRUE( s.find( i, []( value_type const& v, value_type const& arg ) - { - EXPECT_EQ( v.key(), arg.key() ); - EXPECT_EQ( v.nUpdateNewCount, 2 ); - })); - break; - case 6: - ASSERT_TRUE( s.emplace( i.key())); - ASSERT_TRUE( s.find( i, []( value_type const& v, value_type const& arg ) - { - EXPECT_EQ( v.key(), arg.key() ); - EXPECT_EQ( v.nVal, arg.nVal ); - })); - break; - case 7: - str = "Hello!"; - ASSERT_TRUE( s.emplace( i.key(), std::move( str ))); - EXPECT_TRUE( str.empty()); - ASSERT_TRUE( s.find( i, []( value_type const& v, value_type const& arg ) - { - EXPECT_EQ( v.key(), arg.key() ); - EXPECT_EQ( v.nVal, arg.nVal ); - EXPECT_EQ( v.strVal, std::string( "Hello!" )); - } ) ); - break; - default: - // forgot anything?.. - ASSERT_TRUE( false ); - } - - ASSERT_TRUE( s.contains( i.nKey ) ); - ASSERT_TRUE( s.contains( i ) ); - ASSERT_TRUE( s.contains( other_item( i.key() ), other_less() ) ); - ASSERT_TRUE( s.find( i.nKey, []( value_type&, int ) {} ) ); - ASSERT_TRUE( s.find( i, []( value_type&, value_type const& ) {} ) ); - ASSERT_TRUE( s.find_with( other_item( i.key() ), other_less(), []( value_type&, other_item const& ) {} ) ); - } - - ASSERT_FALSE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, nSetSize ); - - // erase - shuffle( indices.begin(), indices.end() ); - for ( auto idx : indices ) { - auto& i = data[idx]; - - ASSERT_TRUE( s.contains( i.nKey ) ); - ASSERT_TRUE( s.contains( i ) ); - ASSERT_TRUE( s.contains( other_item( i.key() ), other_less() ) ); - ASSERT_TRUE( s.find( i.nKey, []( value_type& v, int ) - { - v.nFindCount = 1; - })); - ASSERT_TRUE( s.find( i, []( value_type& v, value_type const& ) - { - EXPECT_EQ( ++v.nFindCount, 2 ); - })); - ASSERT_TRUE( s.find_with( other_item( i.key() ), other_less(), []( value_type& v, other_item const& ) - { - EXPECT_EQ( ++v.nFindCount, 3 ); - })); - - int nKey = i.key() - 1; - switch ( idx % 6 ) { - case 0: - ASSERT_TRUE( s.erase( i.key())); - ASSERT_FALSE( s.erase( i.key())); - break; - case 1: - ASSERT_TRUE( s.erase( i )); - ASSERT_FALSE( s.erase( i )); - break; - case 2: - ASSERT_TRUE( s.erase_with( other_item( i.key()), other_less())); - ASSERT_FALSE( s.erase_with( other_item( i.key() ), other_less() ) ); - break; - case 3: - ASSERT_TRUE( s.erase( i.key(), [&nKey]( value_type const& v ) - { - nKey = v.key(); - } )); - EXPECT_EQ( i.key(), nKey ); - - nKey = i.key() - 1; - ASSERT_FALSE( s.erase( i.key(), [&nKey]( value_type const& v ) - { - nKey = v.key(); - } )); - EXPECT_EQ( i.key(), nKey + 1 ); - break; - case 4: - ASSERT_TRUE( s.erase( i, [&nKey]( value_type const& v ) - { - nKey = v.key(); - } )); - EXPECT_EQ( i.key(), nKey ); - - nKey = i.key() - 1; - ASSERT_FALSE( s.erase( i, [&nKey]( value_type const& v ) - { - nKey = v.key(); - } )); - EXPECT_EQ( i.key(), nKey + 1 ); - break; - case 5: - ASSERT_TRUE( s.erase_with( other_item( i.key()), other_less(), [&nKey]( value_type const& v ) - { - nKey = v.key(); - } )); - EXPECT_EQ( i.key(), nKey ); - - nKey = i.key() - 1; - ASSERT_FALSE( s.erase_with( other_item( i.key()), other_less(), [&nKey]( value_type const& v ) - { - nKey = v.key(); - } )); - EXPECT_EQ( i.key(), nKey + 1 ); - break; - } - - ASSERT_FALSE( s.contains( i.nKey ) ); - ASSERT_FALSE( s.contains( i ) ); - ASSERT_FALSE( s.contains( other_item( i.key() ), other_less())); - ASSERT_FALSE( s.find( i.nKey, []( value_type&, int ) {} )); - ASSERT_FALSE( s.find( i, []( value_type&, value_type const& ) {} )); - ASSERT_FALSE( s.find_with( other_item( i.key()), other_less(), []( value_type&, other_item const& ) {} )); - } - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - - // clear - for ( auto& i : data ) { - ASSERT_TRUE( s.insert( i ) ); - } - - ASSERT_FALSE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, nSetSize ); - - s.clear(); - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - ASSERT_TRUE( s.begin() == s.end() ); - ASSERT_TRUE( s.cbegin() == s.cend() ); - } - }; - -} // namespace cds_test - -#endif // CDSUNIT_SET_TEST_SET_H diff --git a/test/unit/set/test_set_hp.h b/test/unit/set/test_set_hp.h deleted file mode 100644 index dd5b3513..00000000 --- a/test/unit/set/test_set_hp.h +++ /dev/null @@ -1,153 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#ifndef CDSUNIT_SET_TEST_SET_HP_H -#define CDSUNIT_SET_TEST_SET_HP_H - -#include "test_set.h" - -namespace cds_test { - - class container_set_hp: public container_set - { - typedef container_set base_class; - - protected: - template - void test( Set& s ) - { - // Precondition: set is empty - // Postcondition: set is empty - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - base_class::test( s ); - - typedef typename Set::value_type value_type; - - size_t const nSetSize = kSize; - std::vector< value_type > data; - std::vector< size_t> indices; - data.reserve( kSize ); - indices.reserve( kSize ); - for ( size_t key = 0; key < kSize; ++key ) { - data.push_back( value_type( static_cast(key) ) ); - indices.push_back( key ); - } - shuffle( indices.begin(), indices.end() ); - - for ( auto& i : data ) { - ASSERT_TRUE( s.insert( i ) ); - } - ASSERT_FALSE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, nSetSize ); - - // iterator test - for ( auto it = s.begin(); it != s.end(); ++it ) { - it->nFindCount = it->key() * 3; - } - - for ( auto it = s.cbegin(); it != s.cend(); ++it ) { - EXPECT_EQ( it->nFindCount, it->key() * 3 ); - } - - typedef typename Set::guarded_ptr guarded_ptr; - guarded_ptr gp; - - // get() - for ( auto idx : indices ) { - auto& i = data[idx]; - - ASSERT_TRUE( !gp ); - switch ( idx % 3 ) { - case 0: - gp = s.get( i.key() ); - ASSERT_FALSE( !gp ); - break; - case 1: - gp = s.get( i ); - ASSERT_FALSE( !gp ); - break; - case 2: - gp = s.get_with( other_item( i.key() ), other_less() ); - ASSERT_FALSE( !gp ); - } - EXPECT_EQ( gp->key(), i.key() ); - EXPECT_EQ( gp->nFindCount, i.key() * 3 ); - gp->nFindCount *= 2; - - gp.release(); - } - - // extract() - for ( auto idx : indices ) { - auto& i = data[idx]; - - ASSERT_TRUE( !gp ); - switch ( idx % 3 ) { - case 0: - gp = s.extract( i.key() ); - ASSERT_FALSE( !gp ); - break; - case 1: - gp = s.extract( i ); - ASSERT_FALSE( !gp ); - break; - case 2: - gp = s.extract_with( other_item( i.key() ), other_less() ); - ASSERT_FALSE( !gp ); - break; - } - EXPECT_EQ( gp->key(), i.key() ); - EXPECT_EQ( gp->nFindCount, i.key() * 6 ); - - switch ( idx % 3 ) { - case 0: - gp = s.extract( i.key() ); - break; - case 1: - gp = s.extract( i ); - break; - case 2: - gp = s.extract_with( other_item( i.key() ), other_less() ); - break; - } - ASSERT_TRUE( !gp ); - } - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - } - - }; -} // namespace cds_test - -#endif // CDSUNIT_SET_TEST_SET_HP_H diff --git a/test/unit/set/test_set_nogc.h b/test/unit/set/test_set_nogc.h deleted file mode 100644 index 8fbcbdfb..00000000 --- a/test/unit/set/test_set_nogc.h +++ /dev/null @@ -1,349 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#ifndef CDSUNIT_SET_TEST_SET_NOGC_H -#define CDSUNIT_SET_TEST_SET_NOGC_H - -#include -#include - -#include - -// forward declaration -namespace cds { namespace container {}} - -namespace cds_test { - namespace co = cds::opt; - - class container_set_nogc : public fixture - { - public: - static size_t const kSize = 100; - - struct stat - { - unsigned int nFindCount; - unsigned int nUpdateNewCount; - unsigned int nUpdateCount; - - stat() - { - clear_stat(); - } - - void clear_stat() - { - memset( this, 0, sizeof( *this ) ); - } - }; - - struct other_item { - int nKey; - - explicit other_item( int k ) - : nKey( k ) - {} - - int key() const - { - return nKey; - } - }; - - struct int_item: public stat - { - int nKey; - int nVal; - std::string strVal; - - int_item() - : nKey( 0 ) - , nVal( 0 ) - {} - - explicit int_item( int k ) - : nKey( k ) - , nVal( k * 2 ) - {} - - template - explicit int_item( Q const& src ) - : nKey( src.key() ) - , nVal( 0 ) - {} - - int_item( int_item const& src ) - : nKey( src.nKey ) - , nVal( src.nVal ) - , strVal( src.strVal ) - {} - - int_item( int_item&& src ) - : nKey( src.nKey ) - , nVal( src.nVal ) - , strVal( std::move( src.strVal ) ) - {} - - int_item( int k, std::string&& s ) - : nKey( k ) - , nVal( k * 2 ) - , strVal( std::move( s ) ) - {} - - explicit int_item( other_item const& s ) - : nKey( s.key() ) - , nVal( s.key() * 2 ) - {} - - int key() const - { - return nKey; - } - }; - - struct hash_int { - size_t operator()( int i ) const - { - return co::v::hash()(i); - } - template - size_t operator()( const Item& i ) const - { - return (*this)(i.key()); - } - }; - - struct simple_item_counter { - size_t m_nCount; - - simple_item_counter() - : m_nCount( 0 ) - {} - - size_t operator ++() - { - return ++m_nCount; - } - - size_t operator --() - { - return --m_nCount; - } - - void reset() - { - m_nCount = 0; - } - - operator size_t() const - { - return m_nCount; - } - - }; - - struct less - { - bool operator ()( int_item const& v1, int_item const& v2 ) const - { - return v1.key() < v2.key(); - } - - template - bool operator ()( int_item const& v1, const Q& v2 ) const - { - return v1.key() < v2; - } - - template - bool operator ()( const Q& v1, int_item const& v2 ) const - { - return v1 < v2.key(); - } - }; - - struct cmp { - int operator ()( int_item const& v1, int_item const& v2 ) const - { - if ( v1.key() < v2.key() ) - return -1; - return v1.key() > v2.key() ? 1 : 0; - } - - template - int operator ()( T const& v1, int v2 ) const - { - if ( v1.key() < v2 ) - return -1; - return v1.key() > v2 ? 1 : 0; - } - - template - int operator ()( int v1, T const& v2 ) const - { - if ( v1 < v2.key() ) - return -1; - return v1 > v2.key() ? 1 : 0; - } - }; - - struct other_less { - template - bool operator()( Q const& lhs, T const& rhs ) const - { - return lhs.key() < rhs.key(); - } - }; - - protected: - template - void test( Set& s ) - { - // Precondition: set is empty - // Postcondition: set is empty - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - size_t const nSetSize = kSize; - - typedef typename Set::value_type value_type; - - std::vector< value_type > data; - std::vector< size_t> indices; - data.reserve( kSize ); - indices.reserve( kSize ); - for ( size_t key = 0; key < kSize; ++key ) { - data.push_back( value_type( static_cast(key) ) ); - indices.push_back( key ); - } - shuffle( indices.begin(), indices.end() ); - - // insert/find - for ( auto idx : indices ) { - auto& i = data[idx]; - - ASSERT_FALSE( s.contains( i.nKey ) != s.end() ); - ASSERT_FALSE( s.contains( i ) != s.end() ); - ASSERT_FALSE( s.contains( other_item( i.key() ), other_less()) != s.end()); - - std::pair updResult; - - std::string str; - updResult = s.update( i.key(), false ); - EXPECT_TRUE( updResult.first == s.end()); - EXPECT_FALSE( updResult.second ); - - typename Set::iterator it; - switch ( idx % 6 ) { - case 0: - it = s.insert( i ); - ASSERT_TRUE( it != s.end() ); - it->nFindCount = it->nKey; - ASSERT_TRUE( s.insert( i ) == s.end()); - updResult = s.update( i, false ); - EXPECT_TRUE( updResult.first == it ); - EXPECT_FALSE( updResult.second ); - break; - case 1: - it = s.insert( i.key() ); - ASSERT_TRUE( it != s.end()); - ASSERT_TRUE( s.insert( i.key() ) == s.end()); - it->nFindCount = it->nKey; - updResult = s.update( i.key(), false ); - EXPECT_TRUE( updResult.first == it ); - EXPECT_FALSE( updResult.second ); - break; - case 2: - updResult = s.update( i ); - EXPECT_TRUE( updResult.first != s.end()); - EXPECT_TRUE( updResult.second ); - updResult.first->nFindCount = updResult.first->nKey; - break; - case 3: - updResult = s.update( i.key()); - EXPECT_TRUE( updResult.first != s.end() ); - EXPECT_TRUE( updResult.second ); - updResult.first->nFindCount = updResult.first->nKey; - break; - case 4: - it = s.emplace( i.key()); - ASSERT_TRUE( it != s.end()); - it->nFindCount = it->nKey; - ASSERT_FALSE( s.emplace( i.key() ) != s.end()); - break; - case 5: - str = "Hello!"; - it = s.emplace( i.key(), std::move( str )); - ASSERT_TRUE( it != s.end() ); - EXPECT_TRUE( str.empty()); - it->nFindCount = it->nKey; - str = "Hello!"; - ASSERT_TRUE( s.emplace( i.key(), std::move( str )) == s.end()); - EXPECT_TRUE( str.empty() ); // yes, that's is :( - break; - default: - // forgot anything?.. - ASSERT_TRUE( false ); - } - - it = s.contains( i.nKey ); - ASSERT_TRUE( it != s.end() ); - EXPECT_EQ( it->nFindCount, it->nKey ); - ASSERT_TRUE( s.contains( i ) != s.end() ); - ASSERT_TRUE( s.contains( other_item( i.key() ), other_less() ) != s.end()); - } - - ASSERT_FALSE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, nSetSize ); - - // iterators - for ( auto it = s.begin(); it != s.end(); ++it ) { - it->nFindCount = it->key() * 3; - } - - for ( auto it = s.cbegin(); it != s.cend(); ++it ) { - EXPECT_EQ( it->nFindCount, it->key() * 3 ); - } - - // clear - - s.clear(); - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - ASSERT_TRUE( s.begin() == s.end() ); - ASSERT_TRUE( s.cbegin() == s.cend() ); - } - }; - -} // namespace cds_test - -#endif // CDSUNIT_SET_TEST_SET_NOGC_H diff --git a/test/unit/set/test_set_rcu.h b/test/unit/set/test_set_rcu.h deleted file mode 100644 index d819278a..00000000 --- a/test/unit/set/test_set_rcu.h +++ /dev/null @@ -1,192 +0,0 @@ -/* - This file is a part of libcds - Concurrent Data Structures library - - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 - - Source code repo: http://github.com/khizmax/libcds/ - Download: http://sourceforge.net/projects/libcds/files/ - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#ifndef CDSUNIT_SET_TEST_SET_RCU_H -#define CDSUNIT_SET_TEST_SET_RCU_H - -#include "test_set.h" - -namespace cds_test { - - class container_set_rcu: public container_set - { - typedef container_set base_class; - - protected: - template - void test( Set& s ) - { - // Precondition: set is empty - // Postcondition: set is empty - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - - base_class::test( s ); - - typedef typename Set::value_type value_type; - - size_t const nSetSize = kSize; - std::vector< value_type > data; - std::vector< size_t> indices; - data.reserve( kSize ); - indices.reserve( kSize ); - for ( size_t key = 0; key < kSize; ++key ) { - data.push_back( value_type( static_cast(key) ) ); - indices.push_back( key ); - } - shuffle( indices.begin(), indices.end() ); - - for ( auto& i : data ) { - ASSERT_TRUE( s.insert( i ) ); - } - ASSERT_FALSE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, nSetSize ); - - // iterator test - for ( auto it = s.begin(); it != s.end(); ++it ) { - it->nFindCount = it->key() * 3; - } - - for ( auto it = s.cbegin(); it != s.cend(); ++it ) { - EXPECT_EQ( it->nFindCount, it->key() * 3 ); - } - - typedef typename Set::exempt_ptr exempt_ptr; - typedef typename Set::raw_ptr raw_ptr; - typedef typename Set::rcu_lock rcu_lock; - - // get() - for ( auto idx : indices ) { - auto& i = data[idx]; - - { - rcu_lock l; - raw_ptr rp; - ASSERT_TRUE( !rp ); - switch ( idx % 3 ) { - case 0: - rp = s.get( i.key() ); - ASSERT_FALSE( !rp ); - break; - case 1: - rp = s.get( i ); - ASSERT_FALSE( !rp ); - break; - case 2: - rp = s.get_with( other_item( i.key() ), other_less() ); - ASSERT_FALSE( !rp ); - } - EXPECT_EQ( rp->key(), i.key() ); - EXPECT_EQ( rp->nFindCount, i.key() * 3 ); - rp->nFindCount *= 2; - } - } - - // extract() - exempt_ptr xp; - for ( auto idx : indices ) { - auto& i = data[idx]; - - ASSERT_TRUE( !xp ); - if ( Set::c_bExtractLockExternal ) { - rcu_lock l; - - switch ( idx % 3 ) { - case 0: - xp = s.extract( i.key() ); - ASSERT_FALSE( !xp ); - break; - case 1: - xp = s.extract( i ); - ASSERT_FALSE( !xp ); - break; - case 2: - xp = s.extract_with( other_item( i.key() ), other_less() ); - ASSERT_FALSE( !xp ); - break; - } - EXPECT_EQ( xp->key(), i.key() ); - EXPECT_EQ( xp->nFindCount, i.key() * 6 ); - - switch ( idx % 3 ) { - case 0: - xp = s.extract( i.key() ); - break; - case 1: - xp = s.extract( i ); - break; - case 2: - xp = s.extract_with( other_item( i.key() ), other_less() ); - break; - } - ASSERT_TRUE( !xp ); - } - else { - switch ( idx % 3 ) { - case 0: - xp = s.extract( i.key() ); - ASSERT_FALSE( !xp ); - break; - case 1: - xp = s.extract( i ); - ASSERT_FALSE( !xp ); - break; - case 2: - xp = s.extract_with( other_item( i.key() ), other_less() ); - ASSERT_FALSE( !xp ); - break; - } - EXPECT_EQ( xp->key(), i.key() ); - EXPECT_EQ( xp->nFindCount, i.key() * 6 ); - - switch ( idx % 3 ) { - case 0: - xp = s.extract( i.key() ); - break; - case 1: - xp = s.extract( i ); - break; - case 2: - xp = s.extract_with( other_item( i.key() ), other_less() ); - break; - } - ASSERT_TRUE( !xp ); - } - } - - ASSERT_TRUE( s.empty() ); - ASSERT_CONTAINER_SIZE( s, 0 ); - } - - }; -} // namespace cds_test - -#endif // CDSUNIT_SET_TEST_SET_RCU_H