bgirgis/concurrency-in-action
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Run clang-format

Browse Source
This commit is contained in:
Bassem Girgis
2018-10-18 00:40:34 -05:00
parent fffe4528da
commit 31c32e368a
149 changed files with 5974 additions and 6287 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
.clang-format Normal file
View File

@@ -0,0 +1,104 @@
Language: Cpp
# BasedOnStyle: Google
AccessModifierOffset: -2
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: true
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Right
AlignOperands: true
AlignTrailingComments: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: Inline
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: true
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: TopLevelDefinitions
AlwaysBreakBeforeMultilineStrings: true
AlwaysBreakTemplateDeclarations: true
BinPackArguments: false
BinPackParameters: false
BreakBeforeBraces : Custom
BraceWrapping:
AfterClass: false
AfterControlStatement: false
AfterEnum: false
AfterFunction: true
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
BeforeCatch: true
BeforeElse: true
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None
BreakBeforeInheritanceComma: true
BreakBeforeTernaryOperators: true
BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit: 80
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: true
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DerivePointerAlignment: false
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IncludeCategories:
- Regex: '^<.*\.h>'
Priority: 1
- Regex: '^<.*'
Priority: 2
- Regex: '.*'
Priority: 3
IncludeIsMainRegex: '([-_](test|unittest))?$'
IndentCaseLabels: false
IndentWidth: 2
IndentWrappedFunctionNames: false
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: false
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBlockIndentWidth: 2
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: false
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 1
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 200
PointerAlignment: Left
ReflowComments: true
SortIncludes: true
SortUsingDeclarations: true
SpaceAfterCStyleCast: true
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeParens: ControlStatements
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 2
SpacesInAngles: false
SpacesInContainerLiterals: false
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Cpp11
TabWidth: 2
UseTab: Never

114
.cproject Normal file
View File

@@ -0,0 +1,114 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<?fileVersion 4.0.0?><cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage">
<storageModule moduleId="org.eclipse.cdt.core.settings">
<cconfiguration id="cdt.managedbuild.config.gnu.cross.exe.debug.1192994012">
<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="cdt.managedbuild.config.gnu.cross.exe.debug.1192994012" moduleId="org.eclipse.cdt.core.settings" name="Debug">
<externalSettings/>
<extensions>
<extension id="org.eclipse.cdt.core.ELF" point="org.eclipse.cdt.core.BinaryParser"/>
<extension id="org.eclipse.cdt.core.GASErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="org.eclipse.cdt.core.GLDErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="org.eclipse.cdt.core.CWDLocator" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="org.eclipse.cdt.core.GCCErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
</extensions>
</storageModule>
<storageModule moduleId="cdtBuildSystem" version="4.0.0">
<configuration artifactName="${ProjName}" buildArtefactType="org.eclipse.cdt.build.core.buildArtefactType.exe" buildProperties="org.eclipse.cdt.build.core.buildArtefactType=org.eclipse.cdt.build.core.buildArtefactType.exe,org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug" cleanCommand="rm -rf" description="" id="cdt.managedbuild.config.gnu.cross.exe.debug.1192994012" name="Debug" parent="cdt.managedbuild.config.gnu.cross.exe.debug">
<folderInfo id="cdt.managedbuild.config.gnu.cross.exe.debug.1192994012." name="/" resourcePath="">
<toolChain id="cdt.managedbuild.toolchain.gnu.cross.exe.debug.1122035376" name="Cross GCC" superClass="cdt.managedbuild.toolchain.gnu.cross.exe.debug">
<targetPlatform archList="all" binaryParser="org.eclipse.cdt.core.ELF" id="cdt.managedbuild.targetPlatform.gnu.cross.890879207" isAbstract="false" osList="all" superClass="cdt.managedbuild.targetPlatform.gnu.cross"/>
<builder buildPath="${workspace_loc:/concurrency-in-action}/Debug" id="cdt.managedbuild.builder.gnu.cross.730695170" managedBuildOn="true" name="Gnu Make Builder.Debug" superClass="cdt.managedbuild.builder.gnu.cross"/>
<tool id="cdt.managedbuild.tool.gnu.cross.c.compiler.680385655" name="Cross GCC Compiler" superClass="cdt.managedbuild.tool.gnu.cross.c.compiler">
<option defaultValue="gnu.c.optimization.level.none" id="gnu.c.compiler.option.optimization.level.1148144853" superClass="gnu.c.compiler.option.optimization.level" useByScannerDiscovery="false" valueType="enumerated"/>
<option defaultValue="gnu.c.debugging.level.max" id="gnu.c.compiler.option.debugging.level.1348513497" superClass="gnu.c.compiler.option.debugging.level" useByScannerDiscovery="false" valueType="enumerated"/>
<inputType id="cdt.managedbuild.tool.gnu.c.compiler.input.2123668139" superClass="cdt.managedbuild.tool.gnu.c.compiler.input"/>
</tool>
<tool id="cdt.managedbuild.tool.gnu.cross.cpp.compiler.241274475" name="Cross G++ Compiler" superClass="cdt.managedbuild.tool.gnu.cross.cpp.compiler">
<option id="gnu.cpp.compiler.option.optimization.level.427163038" superClass="gnu.cpp.compiler.option.optimization.level" useByScannerDiscovery="false" value="gnu.cpp.compiler.optimization.level.none" valueType="enumerated"/>
<option defaultValue="gnu.cpp.compiler.debugging.level.max" id="gnu.cpp.compiler.option.debugging.level.1633475294" superClass="gnu.cpp.compiler.option.debugging.level" useByScannerDiscovery="false" valueType="enumerated"/>
<inputType id="cdt.managedbuild.tool.gnu.cpp.compiler.input.1614770923" superClass="cdt.managedbuild.tool.gnu.cpp.compiler.input"/>
</tool>
<tool id="cdt.managedbuild.tool.gnu.cross.c.linker.301173203" name="Cross GCC Linker" superClass="cdt.managedbuild.tool.gnu.cross.c.linker"/>
<tool id="cdt.managedbuild.tool.gnu.cross.cpp.linker.1152604941" name="Cross G++ Linker" superClass="cdt.managedbuild.tool.gnu.cross.cpp.linker">
<inputType id="cdt.managedbuild.tool.gnu.cpp.linker.input.1534571725" superClass="cdt.managedbuild.tool.gnu.cpp.linker.input">
<additionalInput kind="additionalinputdependency" paths="$(USER_OBJS)"/>
<additionalInput kind="additionalinput" paths="$(LIBS)"/>
</inputType>
</tool>
<tool id="cdt.managedbuild.tool.gnu.cross.archiver.1417897260" name="Cross GCC Archiver" superClass="cdt.managedbuild.tool.gnu.cross.archiver"/>
<tool id="cdt.managedbuild.tool.gnu.cross.assembler.206754207" name="Cross GCC Assembler" superClass="cdt.managedbuild.tool.gnu.cross.assembler">
<inputType id="cdt.managedbuild.tool.gnu.assembler.input.2135072614" superClass="cdt.managedbuild.tool.gnu.assembler.input"/>
</tool>
</toolChain>
</folderInfo>
</configuration>
</storageModule>
<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
</cconfiguration>
<cconfiguration id="cdt.managedbuild.config.gnu.cross.exe.release.1308789762">
<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="cdt.managedbuild.config.gnu.cross.exe.release.1308789762" moduleId="org.eclipse.cdt.core.settings" name="Release">
<externalSettings/>
<extensions>
<extension id="org.eclipse.cdt.core.ELF" point="org.eclipse.cdt.core.BinaryParser"/>
<extension id="org.eclipse.cdt.core.GASErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="org.eclipse.cdt.core.GLDErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="org.eclipse.cdt.core.CWDLocator" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="org.eclipse.cdt.core.GCCErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
</extensions>
</storageModule>
<storageModule moduleId="cdtBuildSystem" version="4.0.0">
<configuration artifactName="${ProjName}" buildArtefactType="org.eclipse.cdt.build.core.buildArtefactType.exe" buildProperties="org.eclipse.cdt.build.core.buildArtefactType=org.eclipse.cdt.build.core.buildArtefactType.exe,org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release" cleanCommand="rm -rf" description="" id="cdt.managedbuild.config.gnu.cross.exe.release.1308789762" name="Release" parent="cdt.managedbuild.config.gnu.cross.exe.release">
<folderInfo id="cdt.managedbuild.config.gnu.cross.exe.release.1308789762." name="/" resourcePath="">
<toolChain id="cdt.managedbuild.toolchain.gnu.cross.exe.release.2089802121" name="Cross GCC" superClass="cdt.managedbuild.toolchain.gnu.cross.exe.release">
<targetPlatform archList="all" binaryParser="org.eclipse.cdt.core.ELF" id="cdt.managedbuild.targetPlatform.gnu.cross.321811258" isAbstract="false" osList="all" superClass="cdt.managedbuild.targetPlatform.gnu.cross"/>
<builder buildPath="${workspace_loc:/concurrency-in-action}/Release" id="cdt.managedbuild.builder.gnu.cross.581862874" managedBuildOn="true" name="Gnu Make Builder.Release" superClass="cdt.managedbuild.builder.gnu.cross"/>
<tool id="cdt.managedbuild.tool.gnu.cross.c.compiler.1263617891" name="Cross GCC Compiler" superClass="cdt.managedbuild.tool.gnu.cross.c.compiler">
<option defaultValue="gnu.c.optimization.level.most" id="gnu.c.compiler.option.optimization.level.1570617197" superClass="gnu.c.compiler.option.optimization.level" useByScannerDiscovery="false" valueType="enumerated"/>
<option defaultValue="gnu.c.debugging.level.none" id="gnu.c.compiler.option.debugging.level.1573251332" superClass="gnu.c.compiler.option.debugging.level" useByScannerDiscovery="false" valueType="enumerated"/>
<inputType id="cdt.managedbuild.tool.gnu.c.compiler.input.1569558056" superClass="cdt.managedbuild.tool.gnu.c.compiler.input"/>
</tool>
<tool id="cdt.managedbuild.tool.gnu.cross.cpp.compiler.1348481540" name="Cross G++ Compiler" superClass="cdt.managedbuild.tool.gnu.cross.cpp.compiler">
<option id="gnu.cpp.compiler.option.optimization.level.100340695" superClass="gnu.cpp.compiler.option.optimization.level" useByScannerDiscovery="false" value="gnu.cpp.compiler.optimization.level.most" valueType="enumerated"/>
<option defaultValue="gnu.cpp.compiler.debugging.level.none" id="gnu.cpp.compiler.option.debugging.level.584780047" superClass="gnu.cpp.compiler.option.debugging.level" useByScannerDiscovery="false" valueType="enumerated"/>
<inputType id="cdt.managedbuild.tool.gnu.cpp.compiler.input.1437636074" superClass="cdt.managedbuild.tool.gnu.cpp.compiler.input"/>
</tool>
<tool id="cdt.managedbuild.tool.gnu.cross.c.linker.170044107" name="Cross GCC Linker" superClass="cdt.managedbuild.tool.gnu.cross.c.linker"/>
<tool id="cdt.managedbuild.tool.gnu.cross.cpp.linker.1428396919" name="Cross G++ Linker" superClass="cdt.managedbuild.tool.gnu.cross.cpp.linker">
<inputType id="cdt.managedbuild.tool.gnu.cpp.linker.input.948393561" superClass="cdt.managedbuild.tool.gnu.cpp.linker.input">
<additionalInput kind="additionalinputdependency" paths="$(USER_OBJS)"/>
<additionalInput kind="additionalinput" paths="$(LIBS)"/>
</inputType>
</tool>
<tool id="cdt.managedbuild.tool.gnu.cross.archiver.1625798495" name="Cross GCC Archiver" superClass="cdt.managedbuild.tool.gnu.cross.archiver"/>
<tool id="cdt.managedbuild.tool.gnu.cross.assembler.70580537" name="Cross GCC Assembler" superClass="cdt.managedbuild.tool.gnu.cross.assembler">
<inputType id="cdt.managedbuild.tool.gnu.assembler.input.226212603" superClass="cdt.managedbuild.tool.gnu.assembler.input"/>
</tool>
</toolChain>
</folderInfo>
</configuration>
</storageModule>
<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
</cconfiguration>
</storageModule>
<storageModule moduleId="cdtBuildSystem" version="4.0.0">
<project id="concurrency-in-action.cdt.managedbuild.target.gnu.cross.exe.508515326" name="Executable" projectType="cdt.managedbuild.target.gnu.cross.exe"/>
</storageModule>
<storageModule moduleId="scannerConfiguration">
<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
<scannerConfigBuildInfo instanceId="cdt.managedbuild.config.gnu.cross.exe.debug.1192994012;cdt.managedbuild.config.gnu.cross.exe.debug.1192994012.;cdt.managedbuild.tool.gnu.cross.c.compiler.680385655;cdt.managedbuild.tool.gnu.c.compiler.input.2123668139">
<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
</scannerConfigBuildInfo>
<scannerConfigBuildInfo instanceId="cdt.managedbuild.config.gnu.cross.exe.debug.1192994012;cdt.managedbuild.config.gnu.cross.exe.debug.1192994012.;cdt.managedbuild.tool.gnu.cross.cpp.compiler.241274475;cdt.managedbuild.tool.gnu.cpp.compiler.input.1614770923">
<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
</scannerConfigBuildInfo>
<scannerConfigBuildInfo instanceId="cdt.managedbuild.config.gnu.cross.exe.release.1308789762;cdt.managedbuild.config.gnu.cross.exe.release.1308789762.;cdt.managedbuild.tool.gnu.cross.cpp.compiler.1348481540;cdt.managedbuild.tool.gnu.cpp.compiler.input.1437636074">
<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
</scannerConfigBuildInfo>
<scannerConfigBuildInfo instanceId="cdt.managedbuild.config.gnu.cross.exe.release.1308789762;cdt.managedbuild.config.gnu.cross.exe.release.1308789762.;cdt.managedbuild.tool.gnu.cross.c.compiler.1263617891;cdt.managedbuild.tool.gnu.c.compiler.input.1569558056">
<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
</scannerConfigBuildInfo>
</storageModule>
<storageModule moduleId="org.eclipse.cdt.core.LanguageSettingsProviders"/>
</cproject>

27
.project Normal file
View File

@@ -0,0 +1,27 @@
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>concurrency-in-action</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
<triggers>clean,full,incremental,</triggers>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name>
<triggers>full,incremental,</triggers>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.cdt.core.cnature</nature>
<nature>org.eclipse.cdt.core.ccnature</nature>
<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
</natures>
</projectDescription>

25
.settings/language.settings.xml Normal file
View File

@@ -0,0 +1,25 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project>
<configuration id="cdt.managedbuild.config.gnu.cross.exe.debug.1192994012" name="Debug">
<extension point="org.eclipse.cdt.core.LanguageSettingsProvider">
<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
<provider class="org.eclipse.cdt.internal.build.crossgcc.CrossGCCBuiltinSpecsDetector" console="false" env-hash="564395207262711818" id="org.eclipse.cdt.build.crossgcc.CrossGCCBuiltinSpecsDetector" keep-relative-paths="false" name="CDT Cross GCC Built-in Compiler Settings" parameter="${COMMAND} ${FLAGS} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
<language-scope id="org.eclipse.cdt.core.gcc"/>
<language-scope id="org.eclipse.cdt.core.g++"/>
</provider>
</extension>
</configuration>
<configuration id="cdt.managedbuild.config.gnu.cross.exe.release.1308789762" name="Release">
<extension point="org.eclipse.cdt.core.LanguageSettingsProvider">
<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
<provider class="org.eclipse.cdt.internal.build.crossgcc.CrossGCCBuiltinSpecsDetector" console="false" env-hash="564395207262711818" id="org.eclipse.cdt.build.crossgcc.CrossGCCBuiltinSpecsDetector" keep-relative-paths="false" name="CDT Cross GCC Built-in Compiler Settings" parameter="${COMMAND} ${FLAGS} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
<language-scope id="org.eclipse.cdt.core.gcc"/>
<language-scope id="org.eclipse.cdt.core.g++"/>
</provider>
</extension>
</configuration>
</project>

13
ch1/hello.cpp
View File

@@ -1,18 +1,17 @@
#include <iostream> #include <iostream>
#include <thread> #include <thread>
void hello() void
hello()
{ {
std::cout << "Hello Concurrent World\n"; std::cout << "Hello Concurrent World\n";
} }
int main() int
main()
{ {
//boost::thread t([]() // boost::thread t([]()
std::thread t([]() std::thread t([]() { std::cout << "Hello Concurrent World\n"; });
{
std::cout << "Hello Concurrent World\n";
});
t.join(); t.join();
} }

56
ch2/accumulate.cpp
View File

@@ -1,69 +1,69 @@
#include <algorithm> #include <algorithm>
#include <functional> #include <functional>
#include <iostream> #include <iostream>
#include <vector>
#include <thread>
#include <numeric> // std::accumulate #include <numeric> // std::accumulate
#include <thread>
#include <vector>
template <typename Iterator, typename T> template <typename Iterator, typename T>
struct accumulate_block struct accumulate_block {
{
void operator()(Iterator first, Iterator last, T& result) void operator()(Iterator first, Iterator last, T& result)
{ {
result = std::accumulate(first,last,result); result = std::accumulate(first, last, result);
} }
}; };
template <typename Iterator, typename T> template <typename Iterator, typename T>
T parallel_accumulate(Iterator first, Iterator last, T init) T
parallel_accumulate(Iterator first, Iterator last, T init)
{ {
unsigned long const length = std::distance(first,last); unsigned long const length = std::distance(first, last);
if (!length) return init; if (!length)
return init;
unsigned long const min_per_thread = 25; unsigned long const min_per_thread = 25;
unsigned long const max_threads = unsigned long const max_threads =
(length+min_per_thread-1)/min_per_thread; (length + min_per_thread - 1) / min_per_thread;
unsigned long const hardware_threads = unsigned long const hardware_threads = std::thread::hardware_concurrency();
std::thread::hardware_concurrency();
unsigned long const num_threads = unsigned long const num_threads =
std::min(hardware_threads != 0 ? hardware_threads:2, max_threads); std::min(hardware_threads != 0 ? hardware_threads : 2, max_threads);
unsigned long const block_size = length / num_threads; unsigned long const block_size = length / num_threads;
std::vector<T> results(num_threads); std::vector<T> results(num_threads);
std::vector<std::thread> threads(num_threads-1); std::vector<std::thread> threads(num_threads - 1);
Iterator block_start = first; Iterator block_start = first;
for (unsigned long i = 0; i < (num_threads-1); ++i) for (unsigned long i = 0; i < (num_threads - 1); ++i) {
{
Iterator block_end = block_start; Iterator block_end = block_start;
std::advance(block_end,block_size); std::advance(block_end, block_size);
threads[i] = std::thread( threads[i] = std::thread(accumulate_block<Iterator, T>(),
accumulate_block<Iterator,T>(), block_start,
block_start,block_end,std::ref(results[i])); block_end,
std::ref(results[i]));
block_start = block_end; block_start = block_end;
} }
accumulate_block<std::vector<int>::iterator,int>()( accumulate_block<std::vector<int>::iterator, int>()(
block_start,last,results[num_threads-1]); block_start, last, results[num_threads - 1]);
std::for_each(threads.begin(),threads.end(), std::for_each(
std::mem_fn(&std::thread::join)); threads.begin(), threads.end(), std::mem_fn(&std::thread::join));
return std::accumulate(results.begin(),results.end(),init); return std::accumulate(results.begin(), results.end(), init);
} }
int main() int
main()
{ {
std::vector<int> numbers(50); std::vector<int> numbers(50);
for (int i = 0; i < 50; ++i) { for (int i = 0; i < 50; ++i) {
numbers[i] = i; numbers[i] = i;
} }
int result = parallel_accumulate<std::vector<int>::iterator,int> int result = parallel_accumulate<std::vector<int>::iterator, int>(
(numbers.begin(),numbers.end(),0); numbers.begin(), numbers.end(), 0);
std::cout << "result: " << result << std::endl; std::cout << "result: " << result << std::endl;
} }

33
ch3/hierarchical.cpp
View File

@@ -1,9 +1,8 @@
#include <climits>
#include <mutex> #include <mutex>
#include <stdexcept> #include <stdexcept>
#include <climits>
class hierarchical_mutex class hierarchical_mutex {
{
std::mutex internal_mutex; std::mutex internal_mutex;
unsigned long const hierarchy_value; unsigned long const hierarchy_value;
unsigned long previous_hierarchy_value; unsigned long previous_hierarchy_value;
@@ -11,21 +10,21 @@ class hierarchical_mutex
void check_for_hierarchy_violation() void check_for_hierarchy_violation()
{ {
if(this_thread_hierarchy_value <= hierarchy_value) if (this_thread_hierarchy_value <= hierarchy_value) {
{
throw std::logic_error("mutex hierarchy violated"); throw std::logic_error("mutex hierarchy violated");
} }
} }
void update_hierarchy_value() void update_hierarchy_value()
{ {
previous_hierarchy_value=this_thread_hierarchy_value; previous_hierarchy_value = this_thread_hierarchy_value;
this_thread_hierarchy_value=hierarchy_value; this_thread_hierarchy_value = hierarchy_value;
} }
public: public:
explicit hierarchical_mutex(unsigned long value): explicit hierarchical_mutex(unsigned long value)
hierarchy_value(value), : hierarchy_value(value), previous_hierarchy_value(0)
previous_hierarchy_value(0) {
{} }
void lock() void lock()
{ {
check_for_hierarchy_violation(); check_for_hierarchy_violation();
@@ -34,24 +33,24 @@ public:
} }
void unlock() void unlock()
{ {
this_thread_hierarchy_value=previous_hierarchy_value; this_thread_hierarchy_value = previous_hierarchy_value;
internal_mutex.unlock(); internal_mutex.unlock();
} }
bool try_lock() bool try_lock()
{ {
check_for_hierarchy_violation(); check_for_hierarchy_violation();
if(!internal_mutex.try_lock()) if (!internal_mutex.try_lock())
return false; return false;
update_hierarchy_value(); update_hierarchy_value();
return true; return true;
} }
}; };
thread_local unsigned long thread_local unsigned long hierarchical_mutex::this_thread_hierarchy_value(
hierarchical_mutex::this_thread_hierarchy_value(ULONG_MAX); ULONG_MAX);
int main() int
main()
{ {
hierarchical_mutex m1(42); hierarchical_mutex m1(42);
hierarchical_mutex m2(2000); hierarchical_mutex m2(2000);
} }

38
ch3/stack.cpp
View File

@@ -1,29 +1,24 @@
#include <exception> #include <exception>
#include <stack>
#include <mutex>
#include <memory> #include <memory>
#include <mutex>
#include <stack>
struct empty_stack: std::exception struct empty_stack : std::exception {
{ const char* what() const throw() { return "empty stack"; }
const char* what() const throw()
{
return "empty stack";
}
}; };
template<typename T> template <typename T>
class threadsafe_stack class threadsafe_stack {
{
private: private:
std::stack<T> data; std::stack<T> data;
mutable std::mutex m; mutable std::mutex m;
public: public:
threadsafe_stack(){} threadsafe_stack() {}
threadsafe_stack(const threadsafe_stack& other) threadsafe_stack(const threadsafe_stack& other)
{ {
std::lock_guard<std::mutex> lock(other.m); std::lock_guard<std::mutex> lock(other.m);
data=other.data; data = other.data;
} }
threadsafe_stack& operator=(const threadsafe_stack&) = delete; threadsafe_stack& operator=(const threadsafe_stack&) = delete;
@@ -35,7 +30,8 @@ public:
std::shared_ptr<T> pop() std::shared_ptr<T> pop()
{ {
std::lock_guard<std::mutex> lock(m); std::lock_guard<std::mutex> lock(m);
if(data.empty()) throw empty_stack(); if (data.empty())
throw empty_stack();
std::shared_ptr<T> const res(std::make_shared<T>(data.top())); std::shared_ptr<T> const res(std::make_shared<T>(data.top()));
data.pop(); data.pop();
return res; return res;
@@ -43,8 +39,9 @@ public:
void pop(T& value) void pop(T& value)
{ {
std::lock_guard<std::mutex> lock(m); std::lock_guard<std::mutex> lock(m);
if(data.empty()) throw empty_stack(); if (data.empty())
value=data.top(); throw empty_stack();
value = data.top();
data.pop(); data.pop();
} }
bool empty() const bool empty() const
@@ -54,15 +51,14 @@ public:
} }
}; };
int main() int
main()
{ {
threadsafe_stack<int> si; threadsafe_stack<int> si;
si.push(5); si.push(5);
si.pop(); si.pop();
if(!si.empty()) if (!si.empty()) {
{
int x; int x;
si.pop(x); si.pop(x);
} }
} }

37
ch4/queue.cpp
View File

@@ -1,21 +1,20 @@
#include <iostream> #include <condition_variable>
#include <cstdio> #include <cstdio>
#include <queue> #include <iostream>
#include <thread>
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include <condition_variable> #include <queue>
#include <thread>
template <typename T> template <typename T>
class queue class queue {
{ private:
private:
mutable std::mutex mut; mutable std::mutex mut;
std::queue<T> data_queue; std::queue<T> data_queue;
std::condition_variable data_cond; std::condition_variable data_cond;
public: public:
queue(){} queue() {}
queue(const queue& other) queue(const queue& other)
{ {
@@ -33,7 +32,7 @@ class queue
void wait_and_pop(T& value) void wait_and_pop(T& value)
{ {
std::unique_lock<std::mutex> lk(mut); std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk, [this]{return !data_queue.empty();}); data_cond.wait(lk, [this] { return !data_queue.empty(); });
value = data_queue.front(); value = data_queue.front();
data_queue.pop(); data_queue.pop();
} }
@@ -41,7 +40,7 @@ class queue
std::shared_ptr<T> wait_and_pop() std::shared_ptr<T> wait_and_pop()
{ {
std::unique_lock<std::mutex> lk(mut); std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk, [this]{return !data_queue.empty();}); data_cond.wait(lk, [this] { return !data_queue.empty(); });
std::shared_ptr<T> res(std::make_shared<T>(data_queue.front())); std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));
data_queue.pop(); data_queue.pop();
return res; return res;
@@ -76,29 +75,31 @@ class queue
} }
}; };
void push(queue<int>* q) void
push(queue<int>* q)
{ {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
//std::cout << "pushing " << i << std::endl; // std::cout << "pushing " << i << std::endl;
printf("pushing %d\n", i); printf("pushing %d\n", i);
q->push(i); q->push(i);
} }
} }
void pop(queue<int>* q) void
pop(queue<int>* q)
{ {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
printf("poping %d\n", *q->wait_and_pop()); printf("poping %d\n", *q->wait_and_pop());
} }
} }
int main() int
main()
{ {
queue<int> q; queue<int> q;
std::thread t1(push,&q); std::thread t1(push, &q);
std::thread t2(pop,&q); std::thread t2(pop, &q);
t1.join(); t1.join();
t2.join(); t2.join();
return 0; return 0;
} }

78
ch4/quicksort.cpp
View File

@@ -1,68 +1,65 @@
#include <iostream>
#include <cstdio>
#include <list>
#include <thread>
#include <memory>
#include <algorithm> #include <algorithm>
#include <cstdio>
#include <future> #include <future>
#include <iostream>
#include <list>
#include <memory>
#include <thread>
std::ostream& operator<<(std::ostream& ostr, const std::list<int>& list) std::ostream&
operator<<(std::ostream& ostr, const std::list<int>& list)
{ {
for (auto &i : list) { for (auto& i : list) {
ostr << " " << i; ostr << " " << i;
} }
return ostr; return ostr;
} }
template<typename T> template <typename T>
std::list<T> sequential_quick_sort(std::list<T> input) std::list<T>
sequential_quick_sort(std::list<T> input)
{ {
if(input.empty()) if (input.empty()) {
{
return input; return input;
} }
std::list<T> result; std::list<T> result;
result.splice(result.begin(),input,input.begin()); result.splice(result.begin(), input, input.begin());
T const& pivot=*result.begin(); T const& pivot = *result.begin();
auto divide_point=std::partition(input.begin(),input.end(), auto divide_point = std::partition(
[&](T const& t){return t<pivot;}); input.begin(), input.end(), [&](T const& t) { return t < pivot; });
std::list<T> lower_part; std::list<T> lower_part;
lower_part.splice(lower_part.end(),input,input.begin(), lower_part.splice(lower_part.end(), input, input.begin(), divide_point);
divide_point); auto new_lower(sequential_quick_sort(std::move(lower_part)));
auto new_lower( auto new_higher(sequential_quick_sort(std::move(input)));
sequential_quick_sort(std::move(lower_part))); result.splice(result.end(), new_higher);
auto new_higher( result.splice(result.begin(), new_lower);
sequential_quick_sort(std::move(input)));
result.splice(result.end(),new_higher);
result.splice(result.begin(),new_lower);
return result; return result;
} }
template<typename T> template <typename T>
std::list<T> parallel_quick_sort(std::list<T> input) std::list<T>
parallel_quick_sort(std::list<T> input)
{ {
if(input.empty()) if (input.empty()) {
{
return input; return input;
} }
std::list<T> result; std::list<T> result;
result.splice(result.begin(),input,input.begin()); result.splice(result.begin(), input, input.begin());
T const& pivot=*result.begin(); T const& pivot = *result.begin();
auto divide_point=std::partition(input.begin(),input.end(), auto divide_point = std::partition(
[&](T const& t){return t<pivot;}); input.begin(), input.end(), [&](T const& t) { return t < pivot; });
std::list<T> lower_part; std::list<T> lower_part;
lower_part.splice(lower_part.end(),input,input.begin(), lower_part.splice(lower_part.end(), input, input.begin(), divide_point);
divide_point); std::future<std::list<T>> new_lower(
std::future<std::list<T> > new_lower( std::async(&parallel_quick_sort<T>, std::move(lower_part)));
std::async(&parallel_quick_sort<T>,std::move(lower_part))); auto new_higher(parallel_quick_sort(std::move(input)));
auto new_higher( result.splice(result.end(), new_higher);
parallel_quick_sort(std::move(input))); result.splice(result.begin(), new_lower.get());
result.splice(result.end(),new_higher);
result.splice(result.begin(),new_lower.get());
return result; return result;
} }
int main() int
main()
{ {
std::list<int> list1 = {4, 2, 1, 5, 8, 9, 7}; std::list<int> list1 = {4, 2, 1, 5, 8, 9, 7};
std::list<int> sorted1 = sequential_quick_sort(list1); std::list<int> sorted1 = sequential_quick_sort(list1);
@@ -71,4 +68,3 @@ int main()
std::cout << "sorted2: " << sorted2 << std::endl; std::cout << "sorted2: " << sorted2 << std::endl;
return 0; return 0;
} }

61
ch6/list.cpp
View File

@@ -1,35 +1,28 @@
#include <iostream>
#include <thread>
#include <memory>
#include <cstdio> #include <cstdio>
#include <iostream>
#include <memory>
#include <thread>
template <typename T> template <typename T>
class list class list {
{ struct node {
struct node
{
std::mutex m; std::mutex m;
std::shared_ptr<T> data; std::shared_ptr<T> data;
std::unique_ptr<node> next; std::unique_ptr<node> next;
node() node() : next() {}
: next()
{}
node(T const& value) node(T const& value) : data(std::make_shared<T>(value)) {}
: data(std::make_shared<T>(value))
{}
}; };
node head; node head;
public: public:
list() list() {}
{}
~list() ~list()
{ {
remove_if([](T const&){return true;}); remove_if([](T const&) { return true; });
} }
list(list const& other) = delete; list(list const& other) = delete;
@@ -48,8 +41,7 @@ class list
{ {
node* current = &head; node* current = &head;
std::unique_lock<std::mutex> lk(head.m); std::unique_lock<std::mutex> lk(head.m);
while (node* const next = current->next.get()) while (node* const next = current->next.get()) {
{
std::unique_lock<std::mutex> next_lk(next->m); std::unique_lock<std::mutex> next_lk(next->m);
lk.unlock(); lk.unlock();
f(*next->data); f(*next->data);
@@ -61,14 +53,12 @@ class list
template <typename Predicate> template <typename Predicate>
std::shared_ptr<T> find_first_of(Predicate p) std::shared_ptr<T> find_first_of(Predicate p)
{ {
node *current = &head; node* current = &head;
std::unique_lock<std::mutex> lk(head.m); std::unique_lock<std::mutex> lk(head.m);
while (node* const next = current->next.get()) while (node* const next = current->next.get()) {
{
std::unique_lock<std::mutex> next_lk(next->m); std::unique_lock<std::mutex> next_lk(next->m);
lk.unlock(); lk.unlock();
if (p(*next->data)) if (p(*next->data)) {
{
return next->data; return next->data;
} }
current = next; current = next;
@@ -80,19 +70,16 @@ class list
template <typename Predicate> template <typename Predicate>
void remove_if(Predicate p) void remove_if(Predicate p)
{ {
node *current = &head; node* current = &head;
std::unique_lock<std::mutex> lk(head.m); std::unique_lock<std::mutex> lk(head.m);
while (node* const next = current->next.get()) while (node* const next = current->next.get()) {
{
std::unique_lock<std::mutex> next_lk(next->m); std::unique_lock<std::mutex> next_lk(next->m);
if (p(*next->data)) if (p(*next->data)) {
{
std::unique_ptr<node> old_next = std::move(current->next); std::unique_ptr<node> old_next = std::move(current->next);
current->next = std::move(next->next); current->next = std::move(next->next);
next_lk.unlock(); next_lk.unlock();
} }
else else {
{
lk.unlock(); lk.unlock();
current = next; current = next;
lk = std::move(next_lk); lk = std::move(next_lk);
@@ -101,7 +88,8 @@ class list
} }
}; };
void push(list<int>* l) void
push(list<int>* l)
{ {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
printf("pushing %d\n", i); printf("pushing %d\n", i);
@@ -109,18 +97,19 @@ void push(list<int>* l)
} }
} }
void visit(int i) void
visit(int i)
{ {
printf("visit %d\n", i); printf("visit %d\n", i);
} }
int main() int
main()
{ {
list<int> l; list<int> l;
std::thread t(push,&l); std::thread t(push, &l);
sleep(1); sleep(1);
l.for_each(visit); l.for_each(visit);
t.join(); t.join();
return 0; return 0;
} }

73
ch6/lookuptable.cpp
View File

@@ -1,17 +1,15 @@
#include <boost/thread/shared_mutex.hpp>
#include <iostream> #include <iostream>
#include <list>
#include <memory>
#include <string> #include <string>
#include <thread> #include <thread>
#include <boost/thread/shared_mutex.hpp>
#include <memory>
#include <list>
#include <vector> #include <vector>
template <typename Key, typename Value, typename Hash=std::hash<Key> > template <typename Key, typename Value, typename Hash = std::hash<Key>>
class lookup_table class lookup_table {
{ private:
private: class bucket_type {
class bucket_type
{
private: private:
typedef std::pair<Key, Value> bucket_value; typedef std::pair<Key, Value> bucket_value;
typedef std::list<bucket_value> bucket_data; typedef std::list<bucket_value> bucket_data;
@@ -22,9 +20,10 @@ class lookup_table
bucket_iterator find_entry_for(Key const& key) const bucket_iterator find_entry_for(Key const& key) const
{ {
return std::find_if(data.begin(), data.end(), return std::find_if(
[&](bucket_value const& item) data.begin(), data.end(), [&](bucket_value const& item) {
{return item.first == key;}); return item.first == key;
});
} }
public: public:
@@ -32,8 +31,7 @@ class lookup_table
{ {
boost::shared_lock<boost::shared_mutex> lock(mutex); boost::shared_lock<boost::shared_mutex> lock(mutex);
bucket_iterator const found_entry = find_entry_for(key); bucket_iterator const found_entry = find_entry_for(key);
return (found_entry == data.end()) ? return (found_entry == data.end()) ? default_value : found_entry->second;
default_value : found_entry->second;
} }
void add_or_update_mapping(Key const& key, Value const& value) void add_or_update_mapping(Key const& key, Value const& value)
@@ -41,7 +39,7 @@ class lookup_table
std::unique_lock<boost::shared_mutex> lock(mutex); std::unique_lock<boost::shared_mutex> lock(mutex);
bucket_iterator const found_entry = find_entry_for(key); bucket_iterator const found_entry = find_entry_for(key);
if (found_entry == data.end()) { if (found_entry == data.end()) {
data.push_back(bucket_value(key,value)); data.push_back(bucket_value(key, value));
} }
else { else {
found_entry->second = value; found_entry->second = value;
@@ -58,7 +56,7 @@ class lookup_table
} }
}; };
std::vector<std::unique_ptr<bucket_type> > buckets; std::vector<std::unique_ptr<bucket_type>> buckets;
Hash hasher; Hash hasher;
bucket_type& get_bucket(Key const& key) const bucket_type& get_bucket(Key const& key) const
@@ -67,17 +65,15 @@ class lookup_table
return *buckets[bucket_index]; return *buckets[bucket_index];
} }
public: public:
typedef Key key_type; typedef Key key_type;
typedef Value mapped_type; typedef Value mapped_type;
typedef Hash hash_type; typedef Hash hash_type;
lookup_table(unsigned num_buckets = 19, const Hash& hasher_ = Hash()) lookup_table(unsigned num_buckets = 19, const Hash& hasher_ = Hash())
: buckets(num_buckets) : buckets(num_buckets), hasher(hasher_)
, hasher(hasher_)
{
for (unsigned i = 0; i < num_buckets; ++i)
{ {
for (unsigned i = 0; i < num_buckets; ++i) {
buckets[i].reset(new bucket_type); buckets[i].reset(new bucket_type);
} }
} }
@@ -85,8 +81,7 @@ class lookup_table
lookup_table(const lookup_table& other) = delete; lookup_table(const lookup_table& other) = delete;
lookup_table& operator=(const lookup_table& other) = delete; lookup_table& operator=(const lookup_table& other) = delete;
Value value_for(Key const& key, Value value_for(Key const& key, Value const& default_value = Value()) const
Value const& default_value = Value()) const
{ {
return get_bucket(key).value_for(key, default_value); return get_bucket(key).value_for(key, default_value);
} }
@@ -96,26 +91,20 @@ class lookup_table
get_bucket(key).add_or_update_mapping(key, value); get_bucket(key).add_or_update_mapping(key, value);
} }
void remove_mapping(const Key& key) void remove_mapping(const Key& key) { get_bucket(key).remove_mapping(key); }
{
get_bucket(key).remove_mapping(key);
}
std::map<Key,Value> get_map() const std::map<Key, Value> get_map() const
{ {
std::vector<boost::unique_lock<boost::shared_mutex> > locks; std::vector<boost::unique_lock<boost::shared_mutex>> locks;
for (unsigned i = 0; i < buckets.size(); ++i) for (unsigned i = 0; i < buckets.size(); ++i) {
{ locks.push_back(
locks.push_back(boost::unique_lock<boost::shared_mutex>( boost::unique_lock<boost::shared_mutex>(buckets[i].mutex));
buckets[i].mutex));
} }
std::map<Key,Value> res; std::map<Key, Value> res;
for (unsigned i = 0; i < buckets.size(); ++i) for (unsigned i = 0; i < buckets.size(); ++i) {
{
for (typename bucket_type::bucket_iterator it = buckets[i].data.begin(); for (typename bucket_type::bucket_iterator it = buckets[i].data.begin();
it != buckets[i].data.end(); it != buckets[i].data.end();
++it) ++it) {
{
res.insert(*it); res.insert(*it);
} }
} }
@@ -123,11 +112,11 @@ class lookup_table
} }
}; };
int main() int
main()
{ {
lookup_table<int,std::string> t; lookup_table<int, std::string> t;
t.add_or_update_mapping(1,"hello"); t.add_or_update_mapping(1, "hello");
std::cout << "value for 1 is " << t.value_for(1) << std::endl; std::cout << "value for 1 is " << t.value_for(1) << std::endl;
return 0; return 0;
} }

39
ch6/queue.cpp
View File

@@ -1,21 +1,20 @@
#include <iostream> #include <condition_variable>
#include <cstdio> #include <cstdio>
#include <queue> #include <iostream>
#include <thread>
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include <condition_variable> #include <queue>
#include <thread>
template <typename T> template <typename T>
class queue class queue {
{ private:
private:
mutable std::mutex mut; mutable std::mutex mut;
std::queue<std::shared_ptr<T> > data_queue; std::queue<std::shared_ptr<T>> data_queue;
std::condition_variable data_cond; std::condition_variable data_cond;
public: public:
queue(){} queue() {}
queue(const queue& other) queue(const queue& other)
{ {
@@ -34,7 +33,7 @@ class queue
void wait_and_pop(T& value) void wait_and_pop(T& value)
{ {
std::unique_lock<std::mutex> lk(mut); std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk, [&]{return !data_queue.empty();}); data_cond.wait(lk, [&] { return !data_queue.empty(); });
/* /*
while (data_queue.empty()) { while (data_queue.empty()) {
data_cond.wait(lk); data_cond.wait(lk);
@@ -47,7 +46,7 @@ class queue
std::shared_ptr<T> wait_and_pop() std::shared_ptr<T> wait_and_pop()
{ {
std::unique_lock<std::mutex> lk(mut); std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk, [&]{return !data_queue.empty();}); data_cond.wait(lk, [&] { return !data_queue.empty(); });
/* /*
while (data_queue.empty()) { while (data_queue.empty()) {
data_cond.wait(lk); data_cond.wait(lk);
@@ -84,29 +83,31 @@ class queue
} }
}; };
void push(queue<int>* q) void
push(queue<int>* q)
{ {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
//std::cout << "pushing " << i << std::endl; // std::cout << "pushing " << i << std::endl;
printf("pushing %d\n", i); printf("pushing %d\n", i);
q->push(i); q->push(i);
} }
} }
void pop(queue<int>* q) void
pop(queue<int>* q)
{ {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
printf("poping %d\n", *q->wait_and_pop()); printf("poping %d\n", *q->wait_and_pop());
} }
} }
int main() int
main()
{ {
queue<int> q; queue<int> q;
std::thread t1(push,&q); std::thread t1(push, &q);
std::thread t2(pop,&q); std::thread t2(pop, &q);
t1.join(); t1.join();
t2.join(); t2.join();
return 0; return 0;
} }

43
ch6/queuelist.cpp
View File

@@ -1,15 +1,13 @@
#include <iostream> #include <iostream>
#include <queue>
#include <memory> #include <memory>
#include <thread>
#include <mutex> #include <mutex>
#include <queue>
#include <thread>
template <typename T> template <typename T>
class queue class queue {
{ private:
private: struct node {
struct node
{
std::shared_ptr<T> data; std::shared_ptr<T> data;
std::unique_ptr<node> next; std::unique_ptr<node> next;
}; };
@@ -17,9 +15,9 @@ class queue
std::mutex head_mutex; std::mutex head_mutex;
std::unique_ptr<node> head; std::unique_ptr<node> head;
std::mutex tail_mutex; std::mutex tail_mutex;
node *tail; node* tail;
node *get_tail() node* get_tail()
{ {
std::lock_guard<std::mutex> tail_lock(tail_mutex); std::lock_guard<std::mutex> tail_lock(tail_mutex);
return tail; return tail;
@@ -36,9 +34,8 @@ class queue
return old_head; return old_head;
} }
public: public:
queue():head(new node),tail(head.get()) queue() : head(new node), tail(head.get()) {}
{}
queue(const queue& other) = delete; queue(const queue& other) = delete;
queue& operator=(const queue& other) = delete; queue& operator=(const queue& other) = delete;
@@ -51,10 +48,9 @@ class queue
void push(T new_value) void push(T new_value)
{ {
std::shared_ptr<T> new_data( std::shared_ptr<T> new_data(std::make_shared<T>(std::move(new_value)));
std::make_shared<T>(std::move(new_value)));
std::unique_ptr<node> p(new node); std::unique_ptr<node> p(new node);
node *const new_tail = p.get(); node* const new_tail = p.get();
std::lock_guard<std::mutex> tail_lock(tail_mutex); std::lock_guard<std::mutex> tail_lock(tail_mutex);
tail->data = new_data; tail->data = new_data;
tail->next = std::move(p); tail->next = std::move(p);
@@ -62,7 +58,8 @@ class queue
} }
}; };
void push(queue<int>* q) void
push(queue<int>* q)
{ {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
printf("pushing %d\n", i); printf("pushing %d\n", i);
@@ -70,7 +67,8 @@ void push(queue<int>* q)
} }
} }
void pop(queue<int>* q) void
pop(queue<int>* q)
{ {
int i = 0; int i = 0;
while (true) { while (true) {
@@ -78,17 +76,18 @@ void pop(queue<int>* q)
printf("poping %d\n", *p); printf("poping %d\n", *p);
++i; ++i;
} }
if (i == 10) break; if (i == 10)
break;
} }
} }
int main() int
main()
{ {
queue<int> q; queue<int> q;
std::thread th1(push,&q); std::thread th1(push, &q);
std::thread th2(pop,&q); std::thread th2(pop, &q);
th1.join(); th1.join();
th2.join(); th2.join();
return 0; return 0;
} }

49
ch6/queuelist2.cpp
View File

@@ -1,16 +1,14 @@
#include <iostream>
#include <queue>
#include <memory>
#include <thread>
#include <mutex>
#include <condition_variable> #include <condition_variable>
#include <iostream>
#include <memory>
#include <mutex>
#include <queue>
#include <thread>
template <typename T> template <typename T>
class queue class queue {
{ private:
private: struct node {
struct node
{
std::shared_ptr<T> data; std::shared_ptr<T> data;
std::unique_ptr<node> next; std::unique_ptr<node> next;
}; };
@@ -18,10 +16,10 @@ class queue
std::mutex head_mutex; std::mutex head_mutex;
std::unique_ptr<node> head; std::unique_ptr<node> head;
std::mutex tail_mutex; std::mutex tail_mutex;
node *tail; node* tail;
std::condition_variable data_cond; std::condition_variable data_cond;
node *get_tail() node* get_tail()
{ {
std::lock_guard<std::mutex> tail_lock(tail_mutex); std::lock_guard<std::mutex> tail_lock(tail_mutex);
return tail; return tail;
@@ -56,7 +54,7 @@ class queue
std::unique_lock<std::mutex> wait_for_data() std::unique_lock<std::mutex> wait_for_data()
{ {
std::unique_lock<std::mutex> head_lock(head_mutex); std::unique_lock<std::mutex> head_lock(head_mutex);
data_cond.wait(head_lock, [&]{return head.get() != queue::get_tail();}); data_cond.wait(head_lock, [&] { return head.get() != queue::get_tail(); });
return std::move(head_lock); return std::move(head_lock);
} }
@@ -73,9 +71,8 @@ class queue
return pop_head(); return pop_head();
} }
public: public:
queue():head(new node),tail(head.get()) queue() : head(new node), tail(head.get()) {}
{}
queue(const queue& other) = delete; queue(const queue& other) = delete;
queue& operator=(const queue& other) = delete; queue& operator=(const queue& other) = delete;
@@ -105,13 +102,12 @@ class queue
void push(T new_value) void push(T new_value)
{ {
std::shared_ptr<T> new_data( std::shared_ptr<T> new_data(std::make_shared<T>(std::move(new_value)));
std::make_shared<T>(std::move(new_value)));
std::unique_ptr<node> p(new node); std::unique_ptr<node> p(new node);
{ {
std::lock_guard<std::mutex> tail_lock(tail_mutex); std::lock_guard<std::mutex> tail_lock(tail_mutex);
tail->data = new_data; tail->data = new_data;
node *const new_tail = p.get(); node* const new_tail = p.get();
tail->next = std::move(p); tail->next = std::move(p);
tail = new_tail; tail = new_tail;
} }
@@ -125,8 +121,8 @@ class queue
} }
}; };
void
void push(queue<int>* q) push(queue<int>* q)
{ {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
printf("pushing %d\n", i); printf("pushing %d\n", i);
@@ -134,7 +130,8 @@ void push(queue<int>* q)
} }
} }
void pop(queue<int>* q) void
pop(queue<int>* q)
{ {
int i = 0; int i = 0;
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
@@ -142,13 +139,13 @@ void pop(queue<int>* q)
} }
} }
int main() int
main()
{ {
queue<int> q; queue<int> q;
std::thread th1(push,&q); std::thread th1(push, &q);
std::thread th2(pop,&q); std::thread th2(pop, &q);
th1.join(); th1.join();
th2.join(); th2.join();
return 0; return 0;
} }

23
ch6/stack.cpp
View File

@@ -1,19 +1,18 @@
#include <exception> #include <exception>
#include <iostream> #include <iostream>
#include <stack>
#include <memory> #include <memory>
#include <thread>
#include <mutex> #include <mutex>
#include <stack>
#include <thread>
template <typename T> template <typename T>
class stack class stack {
{ private:
private:
std::stack<T> data; std::stack<T> data;
mutable std::mutex m; mutable std::mutex m;
public: public:
stack(){} stack() {}
stack(const stack& other) stack(const stack& other)
{ {
@@ -32,7 +31,8 @@ class stack
std::shared_ptr<T> pop() std::shared_ptr<T> pop()
{ {
std::lock_guard<std::mutex> lock(m); std::lock_guard<std::mutex> lock(m);
if (data.empty()) throw std::underflow_error("empty stack"); if (data.empty())
throw std::underflow_error("empty stack");
std::shared_ptr<T> const res(new T(data.top())); std::shared_ptr<T> const res(new T(data.top()));
data.pop(); data.pop();
return res; return res;
@@ -41,7 +41,8 @@ class stack
void pop(T& value) void pop(T& value)
{ {
std::lock_guard<std::mutex> lock(m); std::lock_guard<std::mutex> lock(m);
if (data.empty()) throw std::underflow_error("empty stack"); if (data.empty())
throw std::underflow_error("empty stack");
value = data.top(); value = data.top();
data.pop(); data.pop();
} }
@@ -53,10 +54,10 @@ class stack
} }
}; };
int main() int
main()
{ {
stack<int> s; stack<int> s;
s.push(1); s.push(1);
std::cout << *s.pop() << std::endl; std::cout << *s.pop() << std::endl;
} }

30
ch7/hazard_pointer.h
View File

@@ -1,24 +1,21 @@
#include <cstdio>
#include <memory> #include <memory>
#include <thread> #include <thread>
#include <cstdio>
unsigned const max_hazard_pointers = 100; unsigned const max_hazard_pointers = 100;
struct hazard_pointer struct hazard_pointer {
{
std::atomic<std::thread::id> id; std::atomic<std::thread::id> id;
std::atomic<void*> pointer; std::atomic<void*> pointer;
}; };
hazard_pointer hazard_pointers[max_hazard_pointers]; hazard_pointer hazard_pointers[max_hazard_pointers];
class hp_owner class hp_owner {
{
hazard_pointer* hp; hazard_pointer* hp;
public: public:
hp_owner(hp_owner const&)=delete; hp_owner(hp_owner const&) = delete;
hp_owner operator=(hp_owner const&)=delete; hp_owner operator=(hp_owner const&) = delete;
hp_owner() hp_owner() : hp(nullptr)
: hp(nullptr)
{ {
for (unsigned i = 0; i < max_hazard_pointers; ++i) { for (unsigned i = 0; i < max_hazard_pointers; ++i) {
std::thread::id old_id; std::thread::id old_id;
@@ -41,10 +38,7 @@ class hp_owner
} }
} }
std::atomic<void*>& get_pointer() std::atomic<void*>& get_pointer() { return hp->pointer; }
{
return hp->pointer;
}
~hp_owner() ~hp_owner()
{ {
@@ -53,11 +47,7 @@ class hp_owner
// the actual pointer to nullptr before setting the owner ID to // the actual pointer to nullptr before setting the owner ID to
// std::thread::id(), allowing another thread to reuse the entry later. // std::thread::id(), allowing another thread to reuse the entry later.
// TODO: this causes crash // TODO: this causes crash
//hp->pointer.store(nullptr); // hp->pointer.store(nullptr);
//hp->id.store(std::thread::id()); // hp->id.store(std::thread::id());
} }
}; };

162
ch7/queue_mpmc.cpp
View File

@@ -1,6 +1,6 @@
#include <iostream>
#include <cstdio>
#include <atomic> #include <atomic>
#include <cstdio>
#include <iostream>
#include <memory> #include <memory>
#include <thread> #include <thread>
@@ -9,12 +9,10 @@
// mpmc queue // mpmc queue
template <typename T> template <typename T>
class queue class queue {
{ private:
private:
struct node; struct node;
struct counted_node_ptr struct counted_node_ptr {
{
int external_count; int external_count;
node* ptr; node* ptr;
}; };
@@ -22,16 +20,14 @@ class queue
std::atomic<counted_node_ptr> head; std::atomic<counted_node_ptr> head;
std::atomic<counted_node_ptr> tail; std::atomic<counted_node_ptr> tail;
struct node_counter struct node_counter {
{ unsigned internal_count : 30;
unsigned internal_count:30; unsigned external_counters : 2;
unsigned external_counters:2;
// you need only 2 bits because there are at most two such // you need only 2 bits because there are at most two such
// counters (next and tail) // counters (next and tail)
}; };
struct node struct node {
{
std::atomic<T*> data; std::atomic<T*> data;
std::atomic<node_counter> count; std::atomic<node_counter> count;
std::atomic<counted_node_ptr> next; std::atomic<counted_node_ptr> next;
@@ -54,85 +50,72 @@ class queue
void release_ref() void release_ref()
{ {
node_counter old_counter= node_counter old_counter = count.load(std::memory_order_relaxed);
count.load(std::memory_order_relaxed);
node_counter new_counter; node_counter new_counter;
do do {
{ new_counter = old_counter;
new_counter=old_counter;
--new_counter.internal_count; --new_counter.internal_count;
} } while (!count.compare_exchange_strong(old_counter,
while(!count.compare_exchange_strong( new_counter,
old_counter,new_counter, std::memory_order_acquire,
std::memory_order_acquire,std::memory_order_relaxed)); std::memory_order_relaxed));
if(!new_counter.internal_count && if (!new_counter.internal_count && !new_counter.external_counters) {
!new_counter.external_counters)
{
delete this; delete this;
} }
} }
}; };
void set_new_tail(counted_node_ptr &old_tail, void set_new_tail(counted_node_ptr& old_tail,
counted_node_ptr const &new_tail) counted_node_ptr const& new_tail)
{ {
node* const current_tail_ptr = old_tail.ptr; node* const current_tail_ptr = old_tail.ptr;
while(!tail.compare_exchange_weak(old_tail,new_tail) && while (!tail.compare_exchange_weak(old_tail, new_tail) &&
old_tail.ptr == current_tail_ptr); old_tail.ptr == current_tail_ptr)
if(old_tail.ptr == current_tail_ptr) ;
if (old_tail.ptr == current_tail_ptr)
free_external_counter(old_tail); free_external_counter(old_tail);
else else
current_tail_ptr->release_ref(); current_tail_ptr->release_ref();
} }
static void increase_external_count( static void increase_external_count(std::atomic<counted_node_ptr>& counter,
std::atomic<counted_node_ptr>& counter,
counted_node_ptr& old_counter) counted_node_ptr& old_counter)
{ {
counted_node_ptr new_counter; counted_node_ptr new_counter;
do do {
{
new_counter = old_counter; new_counter = old_counter;
++new_counter.external_count; ++new_counter.external_count;
} } while (!counter.compare_exchange_strong(old_counter,
while(!counter.compare_exchange_strong( new_counter,
old_counter,new_counter, std::memory_order_acquire,
std::memory_order_acquire,std::memory_order_relaxed)); std::memory_order_relaxed));
old_counter.external_count = new_counter.external_count; old_counter.external_count = new_counter.external_count;
} }
static void free_external_counter(counted_node_ptr &old_node_ptr) static void free_external_counter(counted_node_ptr& old_node_ptr)
{ {
node* const ptr = old_node_ptr.ptr; node* const ptr = old_node_ptr.ptr;
int const count_increase = old_node_ptr.external_count-2; int const count_increase = old_node_ptr.external_count - 2;
node_counter old_counter = node_counter old_counter = ptr->count.load(std::memory_order_relaxed);
ptr->count.load(std::memory_order_relaxed);
node_counter new_counter; node_counter new_counter;
do do {
{ new_counter = old_counter;
new_counter=old_counter;
--new_counter.external_counters; --new_counter.external_counters;
new_counter.internal_count+=count_increase; new_counter.internal_count += count_increase;
} } while (!ptr->count.compare_exchange_strong(old_counter,
while(!ptr->count.compare_exchange_strong( new_counter,
old_counter,new_counter, std::memory_order_acquire,
std::memory_order_acquire,std::memory_order_relaxed)); std::memory_order_relaxed));
if(!new_counter.internal_count && if (!new_counter.internal_count && !new_counter.external_counters) {
!new_counter.external_counters)
{
delete ptr; delete ptr;
} }
} }
public: public:
queue() queue() : head(), tail() {}
: head()
, tail()
{}
queue(const queue& other)=delete; queue(const queue& other) = delete;
queue& operator=(const queue& other)=delete; queue& operator=(const queue& other) = delete;
~queue() ~queue()
{ {
@@ -149,48 +132,42 @@ class queue
std::unique_ptr<T> new_data(new T(new_value)); std::unique_ptr<T> new_data(new T(new_value));
counted_node_ptr new_next; counted_node_ptr new_next;
new_next.ptr = new node; new_next.ptr = new node;
new_next.external_count=1; new_next.external_count = 1;
counted_node_ptr old_tail=tail.load(); counted_node_ptr old_tail = tail.load();
for(;;) for (;;) {
{ increase_external_count(tail, old_tail);
increase_external_count(tail,old_tail); T* old_data = nullptr;
T* old_data=nullptr; if (old_tail.ptr->data.compare_exchange_strong(old_data,
if(old_tail.ptr->data.compare_exchange_strong( new_data.get())) {
old_data,new_data.get())) counted_node_ptr old_next = {0};
{ if (!old_tail.ptr->next.compare_exchange_strong(old_next, new_next)) {
counted_node_ptr old_next={0};
if(!old_tail.ptr->next.compare_exchange_strong(
old_next,new_next))
{
delete new_next.ptr; delete new_next.ptr;
new_next=old_next; new_next = old_next;
} }
set_new_tail(old_tail, new_next); set_new_tail(old_tail, new_next);
new_data.release(); new_data.release();
break; break;
} }
else else {
{ counted_node_ptr old_next = {0};
counted_node_ptr old_next={0}; if (old_tail.ptr->next.compare_exchange_strong(old_next, new_next)) {
if(old_tail.ptr->next.compare_exchange_strong( old_next = new_next;
old_next,new_next)) new_next.ptr = new node;
{
old_next=new_next;
new_next.ptr=new node;
} }
set_new_tail(old_tail, old_next); set_new_tail(old_tail, old_next);
} }
} }
} }
std::unique_ptr<T> pop() { std::unique_ptr<T> pop()
{
counted_node_ptr old_head = head.load(std::memory_order_relaxed); counted_node_ptr old_head = head.load(std::memory_order_relaxed);
for(;;) { for (;;) {
increase_external_count(head, old_head); increase_external_count(head, old_head);
node* const ptr = old_head.ptr; node* const ptr = old_head.ptr;
if (ptr==tail.load().ptr) { if (ptr == tail.load().ptr) {
ptr->release_ref(); ptr->release_ref();
return std::unique_ptr<T>(); return std::unique_ptr<T>();
} }
@@ -198,7 +175,7 @@ class queue
counted_node_ptr next = ptr->next.load(); counted_node_ptr next = ptr->next.load();
if (head.compare_exchange_strong(old_head, next)) { if (head.compare_exchange_strong(old_head, next)) {
T* const res=ptr->data.exchange(nullptr); T* const res = ptr->data.exchange(nullptr);
free_external_counter(old_head); free_external_counter(old_head);
return std::unique_ptr<T>(res); return std::unique_ptr<T>(res);
} }
@@ -207,7 +184,8 @@ class queue
} }
}; };
void push(queue<int>* q) void
push(queue<int>* q)
{ {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
printf("pushing %d\n", i); printf("pushing %d\n", i);
@@ -215,7 +193,8 @@ void push(queue<int>* q)
} }
} }
void pop(queue<int>* q) void
pop(queue<int>* q)
{ {
int i = 0; int i = 0;
while (i < 10) { while (i < 10) {
@@ -227,7 +206,8 @@ void pop(queue<int>* q)
} }
} }
int main() int
main()
{ {
queue<int> q; queue<int> q;
std::thread t1(push, &q); std::thread t1(push, &q);
@@ -236,5 +216,3 @@ int main()
t2.join(); t2.join();
return 0; return 0;
} }

38
ch7/queue_spsc.cpp
View File

@@ -1,21 +1,17 @@
#include <iostream>
#include <cstdio>
#include <atomic> #include <atomic>
#include <cstdio>
#include <iostream>
#include <memory> #include <memory>
#include <thread> #include <thread>
template <typename T> template <typename T>
class queue class queue {
{ private:
private: struct node {
struct node
{
std::shared_ptr<T> data; std::shared_ptr<T> data;
node* next; node* next;
node() node() : next(nullptr) {}
: next(nullptr)
{}
}; };
std::atomic<node*> head; std::atomic<node*> head;
@@ -30,14 +26,12 @@ class queue
head.store(old_head->next); head.store(old_head->next);
return old_head; return old_head;
} }
public:
queue()
: head(new node)
, tail(head.load())
{}
queue(const queue& other)=delete; public:
queue& operator=(const queue& other)=delete; queue() : head(new node), tail(head.load()) {}
queue(const queue& other) = delete;
queue& operator=(const queue& other) = delete;
~queue() ~queue()
{ {
@@ -70,7 +64,8 @@ class queue
} }
}; };
void push(queue<int>* q) void
push(queue<int>* q)
{ {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
printf("pushing %d\n", i); printf("pushing %d\n", i);
@@ -78,7 +73,8 @@ void push(queue<int>* q)
} }
} }
void pop(queue<int>* q) void
pop(queue<int>* q)
{ {
int i = 0; int i = 0;
while (i < 10) { while (i < 10) {
@@ -90,7 +86,8 @@ void pop(queue<int>* q)
} }
} }
int main() int
main()
{ {
queue<int> q; queue<int> q;
std::thread t1(push, &q); std::thread t1(push, &q);
@@ -99,4 +96,3 @@ int main()
t2.join(); t2.join();
return 0; return 0;
} }

63
ch7/stack.cpp
View File

@@ -11,35 +11,30 @@
// it can reclaimed. By far the easiest such mechanism to reason about is the // it can reclaimed. By far the easiest such mechanism to reason about is the
// use of hazard ponters. // use of hazard ponters.
#include <iostream>
#include <cstdio>
#include <atomic> #include <atomic>
#include <cstdio>
#include <iostream>
#include <memory> #include <memory>
#include <thread> #include <thread>
template <typename T> template <typename T>
class stack class stack {
{ private:
private: struct node {
struct node
{
std::shared_ptr<T> data; std::shared_ptr<T> data;
node *next; node* next;
node(const T& data_) node(const T& data_) : data(std::make_shared<T>(data_)) {}
: data(std::make_shared<T>(data_))
{}
}; };
std::atomic<node *> head; std::atomic<node*> head;
std::atomic<unsigned> threads_in_pop; std::atomic<unsigned> threads_in_pop;
std::atomic<node *> to_be_deleted; std::atomic<node*> to_be_deleted;
static void delete_nodes(node* nodes)
static void delete_nodes(node *nodes)
{ {
while (nodes) { while (nodes) {
node *next = nodes->next; node* next = nodes->next;
delete nodes; delete nodes;
nodes = next; nodes = next;
} }
@@ -98,9 +93,8 @@ class stack
// store the first node in the chain as the new to_be_deleted pointer // store the first node in the chain as the new to_be_deleted pointer
// have to use compare_exchange_weak in a loop here in order to ensure // have to use compare_exchange_weak in a loop here in order to ensure
// that you don't leak any nodes that have been added by another thread // that you don't leak any nodes that have been added by another thread
while (!to_be_deleted.compare_exchange_weak( while (!to_be_deleted.compare_exchange_weak(last->next, first))
last->next,first)); ;
} }
void chain_pending_node(node* n) void chain_pending_node(node* n)
@@ -108,30 +102,27 @@ class stack
// adding a single node onto the list is a special case where the // adding a single node onto the list is a special case where the
// first node onto the list is a special case where the first node // first node onto the list is a special case where the first node
// in the chain to be added is the same as the last one. // in the chain to be added is the same as the last one.
chain_pending_nodes(n,n); chain_pending_nodes(n, n);
} }
public: public:
stack() stack() : head(nullptr), threads_in_pop(0), to_be_deleted(nullptr) {}
: head(nullptr)
, threads_in_pop(0)
, to_be_deleted(nullptr)
{}
void push(const T& data) void push(const T& data)
{ {
node *const new_node = new node(data); node* const new_node = new node(data);
new_node->next = head.load(); new_node->next = head.load();
// loop to gurantee that last->next is correct // loop to gurantee that last->next is correct
while (!head.compare_exchange_weak(new_node->next, new_node)); while (!head.compare_exchange_weak(new_node->next, new_node))
;
} }
std::shared_ptr<T> pop() std::shared_ptr<T> pop()
{ {
++threads_in_pop; // increase counter before doing anything else ++threads_in_pop; // increase counter before doing anything else
node *old_head = head.load(); node* old_head = head.load();
while (old_head && while (old_head && !head.compare_exchange_weak(old_head, old_head->next))
!head.compare_exchange_weak(old_head, old_head->next)); ;
std::shared_ptr<T> res; std::shared_ptr<T> res;
if (old_head) { if (old_head) {
res.swap(old_head->data); // extract data from node rather than res.swap(old_head->data); // extract data from node rather than
@@ -142,7 +133,8 @@ class stack
} }
}; };
void push(stack<int>* s) void
push(stack<int>* s)
{ {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
printf("pushing %d\n", i); printf("pushing %d\n", i);
@@ -150,7 +142,8 @@ void push(stack<int>* s)
} }
} }
void pop(stack<int>* s) void
pop(stack<int>* s)
{ {
int count = 0; int count = 0;
std::shared_ptr<int> e; std::shared_ptr<int> e;
@@ -162,7 +155,8 @@ void pop(stack<int>* s)
} }
} }
int main() int
main()
{ {
stack<int> s; stack<int> s;
std::thread t1(push, &s); std::thread t1(push, &s);
@@ -171,4 +165,3 @@ int main()
t2.join(); t2.join();
return 0; return 0;
} }

90
ch7/stack_hp.cpp
View File

@@ -1,11 +1,12 @@
#include <iostream>
#include <cstdio>
#include <atomic> #include <atomic>
#include <cstdio>
#include <iostream>
#include <memory> #include <memory>
#include <thread> #include <thread>
#include "hazard_pointer.h" #include "hazard_pointer.h"
std::atomic<void*>& get_hazard_pointer_for_current_thread() std::atomic<void*>&
get_hazard_pointer_for_current_thread()
{ {
// The first time each thread calls this function, a new instance of // The first time each thread calls this function, a new instance of
// hp_owner is created. The constructor for this new instance then // hp_owner is created. The constructor for this new instance then
@@ -17,12 +18,14 @@ std::atomic<void*>& get_hazard_pointer_for_current_thread()
// accesses are much faster because the pointer is cached, so the table // accesses are much faster because the pointer is cached, so the table
// doesn't have to be scanned again. // doesn't have to be scanned again.
printf("get harzard pointer for current thread, thread id: %d\n", std::this_thread::get_id()); printf("get harzard pointer for current thread, thread id: %d\n",
std::this_thread::get_id());
thread_local static hp_owner hazard; thread_local static hp_owner hazard;
return hazard.get_pointer(); return hazard.get_pointer();
} }
bool outstanding_hazard_pointers_for(void *p) bool
outstanding_hazard_pointers_for(void* p)
{ {
for (unsigned i = 0; i < max_hazard_pointers; ++i) { for (unsigned i = 0; i < max_hazard_pointers; ++i) {
if (hazard_pointers[i].pointer.load() == p) { if (hazard_pointers[i].pointer.load() == p) {
@@ -33,44 +36,43 @@ bool outstanding_hazard_pointers_for(void *p)
} }
template <typename T> template <typename T>
void do_delete(void* p) void
do_delete(void* p)
{ {
delete static_cast<T*>(p); delete static_cast<T*>(p);
} }
struct data_to_reclaim struct data_to_reclaim {
{
void* data; void* data;
std::function<void(void *)> deleter; std::function<void(void*)> deleter;
data_to_reclaim* next; data_to_reclaim* next;
template<typename T> template <typename T>
data_to_reclaim(T* p) data_to_reclaim(T* p) : data(p), deleter(&do_delete<T>), next(0)
: data(p)
, deleter(&do_delete<T>)
, next(0)
{}
~data_to_reclaim()
{ {
deleter(data);
} }
~data_to_reclaim() { deleter(data); }
}; };
std::atomic<data_to_reclaim*> nodes_to_reclaim; std::atomic<data_to_reclaim*> nodes_to_reclaim;
void add_to_reclaim_list(data_to_reclaim* node) void
add_to_reclaim_list(data_to_reclaim* node)
{ {
node->next = nodes_to_reclaim.load(); node->next = nodes_to_reclaim.load();
while (!nodes_to_reclaim.compare_exchange_weak(node->next, node)); while (!nodes_to_reclaim.compare_exchange_weak(node->next, node))
;
} }
template<typename T> template <typename T>
void reclaim_later(T* data) void
reclaim_later(T* data)
{ {
add_to_reclaim_list(new data_to_reclaim(data)); add_to_reclaim_list(new data_to_reclaim(data));
} }
void delete_nodes_with_no_hazards() void
delete_nodes_with_no_hazards()
{ {
// first claims the entire list of nodes to be reclaimed; // first claims the entire list of nodes to be reclaimed;
// ensures that this is the only thread trying to reclaim // ensures that this is the only thread trying to reclaim
@@ -93,36 +95,31 @@ void delete_nodes_with_no_hazards()
// reclaiming later // reclaiming later
add_to_reclaim_list(current); add_to_reclaim_list(current);
} }
current=next; current = next;
} }
} }
template <typename T> template <typename T>
class stack class stack {
{ private:
private: struct node {
struct node
{
std::shared_ptr<T> data; std::shared_ptr<T> data;
node *next; node* next;
node(const T& data_) node(const T& data_) : data(std::make_shared<T>(data_)) {}
: data(std::make_shared<T>(data_))
{}
}; };
std::atomic<node *> head; std::atomic<node*> head;
public: public:
stack() stack() : head(nullptr) {}
: head(nullptr)
{}
void push(const T& data) void push(const T& data)
{ {
node *const new_node = new node(data); node* const new_node = new node(data);
new_node->next = head.load(); new_node->next = head.load();
while (!head.compare_exchange_weak(new_node->next, new_node)); while (!head.compare_exchange_weak(new_node->next, new_node))
;
} }
std::shared_ptr<T> pop() std::shared_ptr<T> pop()
@@ -136,8 +133,7 @@ class stack
hp.store(old_head); hp.store(old_head);
old_head = head.load(); old_head = head.load();
} while (old_head != temp); } while (old_head != temp);
} } while (old_head &&
while (old_head &&
!head.compare_exchange_strong(old_head, old_head->next)); !head.compare_exchange_strong(old_head, old_head->next));
hp.store(nullptr); // clear hazard pointer once you're finished hp.store(nullptr); // clear hazard pointer once you're finished
std::shared_ptr<T> res; std::shared_ptr<T> res;
@@ -157,7 +153,8 @@ class stack
} }
}; };
void push(stack<int>* s) void
push(stack<int>* s)
{ {
printf("starting push\n"); printf("starting push\n");
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
@@ -166,7 +163,8 @@ void push(stack<int>* s)
} }
} }
void pop(stack<int>* s) void
pop(stack<int>* s)
{ {
printf("starting pop\n"); printf("starting pop\n");
int count = 0; int count = 0;
@@ -179,7 +177,8 @@ void pop(stack<int>* s)
} }
} }
int main() int
main()
{ {
printf("creating stack\n"); printf("creating stack\n");
stack<int> s; stack<int> s;
@@ -190,4 +189,3 @@ int main()
t2.join(); t2.join();
return 0; return 0;
} }

64
ch7/stack_ref.cpp
View File

@@ -1,13 +1,12 @@
#include <iostream>
#include <cstdio>
#include <atomic> #include <atomic>
#include <cstdio>
#include <iostream>
#include <memory> #include <memory>
#include <thread> #include <thread>
template <typename T> template <typename T>
class stack class stack {
{ private:
private:
struct node; struct node;
// the external count is kept alongside the poiner to the node and is // the external count is kept alongside the poiner to the node and is
@@ -22,22 +21,17 @@ class stack
// count minus one and external counter is discarded. Once the internal // count minus one and external counter is discarded. Once the internal
// count is equal to zero, there are no outstanding references to the node // count is equal to zero, there are no outstanding references to the node
// and it can be safely deleted. // and it can be safely deleted.
struct counted_node_ptr struct counted_node_ptr {
{
int external_count; int external_count;
node *ptr; node* ptr;
}; };
struct node struct node {
{
std::shared_ptr<T> data; std::shared_ptr<T> data;
std::atomic_int internal_count; std::atomic_int internal_count;
counted_node_ptr next; counted_node_ptr next;
node(const T& data_) node(const T& data_) : data(new T(data_)), internal_count(0) {}
: data(new T(data_))
, internal_count(0)
{}
}; };
std::atomic<counted_node_ptr> head; std::atomic<counted_node_ptr> head;
@@ -54,7 +48,6 @@ class stack
// the count inside the spare bits of the pointer to fit it all back in a // the count inside the spare bits of the pointer to fit it all back in a
// single machine word. // single machine word.
// once you've loaded the value of head, you must first increaes the count // once you've loaded the value of head, you must first increaes the count
// of external references to the head node to indicate that you're // of external references to the head node to indicate that you're
// referencing it and to ensure that it's safe to deference it. // referencing it and to ensure that it's safe to deference it.
@@ -64,20 +57,19 @@ class stack
{ {
counted_node_ptr new_counter; counted_node_ptr new_counter;
do do {
{
new_counter = old_counter; new_counter = old_counter;
++new_counter.external_count; ++new_counter.external_count;
} } while (!head.compare_exchange_strong(old_counter, new_counter));
while (!head.compare_exchange_strong(old_counter, new_counter));
old_counter.external_count = new_counter.external_count; old_counter.external_count = new_counter.external_count;
} }
public: public:
~stack() ~stack()
{ {
while (pop()); while (pop())
;
} }
void push(const T& data) void push(const T& data)
@@ -89,26 +81,24 @@ class stack
// external reference to the node (the head pointer itself). // external reference to the node (the head pointer itself).
new_node.external_count = 1; new_node.external_count = 1;
new_node.ptr->next = head.load(); new_node.ptr->next = head.load();
while (!head.compare_exchange_weak(new_node.ptr->next, new_node)); while (!head.compare_exchange_weak(new_node.ptr->next, new_node))
;
} }
std::shared_ptr<T> pop() std::shared_ptr<T> pop()
{ {
counted_node_ptr old_head = head.load(); counted_node_ptr old_head = head.load();
for (;;) for (;;) {
{
increase_head_count(old_head); increase_head_count(old_head);
node* ptr = old_head.ptr; node* ptr = old_head.ptr;
// if the pointer is a null pointer, you're at the end of list: // if the pointer is a null pointer, you're at the end of list:
// no more entires // no more entires
if (!ptr) if (!ptr) {
{
return std::shared_ptr<T>(); return std::shared_ptr<T>();
} }
// if the pointer isn't a null pointer, try to remove the node // if the pointer isn't a null pointer, try to remove the node
if (head.compare_exchange_strong(old_head,ptr->next)) if (head.compare_exchange_strong(old_head, ptr->next)) {
{
// you've taken the ownership of the node and can swap out // you've taken the ownership of the node and can swap out
// the data in prepration for returning it. // the data in prepration for returning it.
std::shared_ptr<T> res; std::shared_ptr<T> res;
@@ -123,9 +113,7 @@ class stack
// if the reference count is now zero, the previous value // if the reference count is now zero, the previous value
// (which is what fetch_add returns) was the negative of what // (which is what fetch_add returns) was the negative of what
// you just added, in which case you can delete the node. // you just added, in which case you can delete the node.
if (ptr->internal_count.fetch_add(count_increase) == if (ptr->internal_count.fetch_add(count_increase) == -count_increase) {
-count_increase)
{
delete ptr; delete ptr;
} }
@@ -142,15 +130,15 @@ class stack
// from the stack), the internal reference count will be 1, so // from the stack), the internal reference count will be 1, so
// subtracing 1 will set the count to zero. In this case, you can // subtracing 1 will set the count to zero. In this case, you can
// delete the node here before you loop. // delete the node here before you loop.
else if (ptr->internal_count.fetch_add(-1) == 1) else if (ptr->internal_count.fetch_add(-1) == 1) {
{
delete ptr; delete ptr;
} }
} }
} }
}; };
void push(stack<int>* s) void
push(stack<int>* s)
{ {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
printf("pushing %d\n", i); printf("pushing %d\n", i);
@@ -158,7 +146,8 @@ void push(stack<int>* s)
} }
} }
void pop(stack<int>* s) void
pop(stack<int>* s)
{ {
int count = 0; int count = 0;
std::shared_ptr<int> e; std::shared_ptr<int> e;
@@ -170,7 +159,8 @@ void pop(stack<int>* s)
} }
} }
int main() int
main()
{ {
stack<int> s; stack<int> s;
std::thread t1(push, &s); std::thread t1(push, &s);
@@ -179,5 +169,3 @@ int main()
t2.join(); t2.join();
return 0; return 0;
} }

40
ch7/stack_sp.cpp
View File

@@ -1,41 +1,40 @@
#include <thread>
#include <memory>
#include <atomic> #include <atomic>
#include <iostream> #include <iostream>
#include <memory>
#include <thread>
template <typename T> template <typename T>
class stack class stack {
{ private:
private: struct node {
struct node
{
std::shared_ptr<T> data; std::shared_ptr<T> data;
std::shared_ptr<node> next; std::shared_ptr<node> next;
node(T const& data_) node(T const& data_) : data(std::make_shared<T>(data_)) {}
: data(std::make_shared<T>(data_))
{}
}; };
std::shared_ptr<node> head; std::shared_ptr<node> head;
public:
public:
void push(T const& data) void push(T const& data)
{ {
std::shared_ptr<node> const new_node = std::make_shared<node>(data); std::shared_ptr<node> const new_node = std::make_shared<node>(data);
new_node->next = std::atomic_load(head); new_node->next = std::atomic_load(head);
while (!std::atomic_compare_exchange_weak(&head, while (!std::atomic_compare_exchange_weak(&head, &new_node->next, new_node))
&new_node->next, new_node)); ;
} }
std::shared_ptr<T> pop() std::shared_ptr<T> pop()
{ {
std::shared_ptr<node> old_head = std::atomic_load(head); std::shared_ptr<node> old_head = std::atomic_load(head);
while (old_head && !std::atomic_compare_exchange_weak(&head, while (old_head &&
&old_head, old_head->next)); !std::atomic_compare_exchange_weak(&head, &old_head, old_head->next))
;
return old_head ? old_head->data : std::shared_ptr<T>(); return old_head ? old_head->data : std::shared_ptr<T>();
} }
}; };
void push(stack<int>* s) void
push(stack<int>* s)
{ {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
printf("pushing %d\n", i); printf("pushing %d\n", i);
@@ -43,7 +42,8 @@ void push(stack<int>* s)
} }
} }
void pop(stack<int>* s) void
pop(stack<int>* s)
{ {
int count = 0; int count = 0;
std::shared_ptr<int> e; std::shared_ptr<int> e;
@@ -55,10 +55,11 @@ void pop(stack<int>* s)
} }
} }
int main() int
main()
{ {
std::shared_ptr<int> sp = std::make_shared<int>(1); std::shared_ptr<int> sp = std::make_shared<int>(1);
//printf("std::atomic_is_lock_free(std::shared_ptr): %d\n", // printf("std::atomic_is_lock_free(std::shared_ptr): %d\n",
// std::atomic_is_lock_free(&sp)); // std::atomic_is_lock_free(&sp));
stack<int> s; stack<int> s;
std::thread t1(push, &s); std::thread t1(push, &s);
@@ -67,4 +68,3 @@ int main()
t2.join(); t2.join();
return 0; return 0;
} }

8
source/listing_1.1.cpp
View File

@@ -1,12 +1,14 @@
#include <iostream> #include <iostream>
#include <thread> #include <thread>
void hello() void
hello()
{ {
std::cout<<"Hello Concurrent World\n"; std::cout << "Hello Concurrent World\n";
} }
int main() int
main()
{ {
std::thread t(hello); std::thread t(hello);
t.join(); t.join();

27
source/listing_10.1.cpp
View File

@@ -1,41 +1,34 @@
void test_concurrent_push_and_pop_on_empty_queue() void
test_concurrent_push_and_pop_on_empty_queue()
{ {
threadsafe_queue<int> q; threadsafe_queue<int> q;
std::promise<void> go,push_ready,pop_ready; std::promise<void> go, push_ready, pop_ready;
std::shared_future<void> ready(go.get_future()); std::shared_future<void> ready(go.get_future());
std::future<void> push_done; std::future<void> push_done;
std::future<int> pop_done; std::future<int> pop_done;
try try {
{ push_done = std::async(std::launch::async, [&q, ready, &push_ready]() {
push_done=std::async(std::launch::async,
[&q,ready,&push_ready]()
{
push_ready.set_value(); push_ready.set_value();
ready.wait(); ready.wait();
q.push(42); q.push(42);
} });
); pop_done = std::async(std::launch::async, [&q, ready, &pop_ready]() {
pop_done=std::async(std::launch::async,
[&q,ready,&pop_ready]()
{
pop_ready.set_value(); pop_ready.set_value();
ready.wait(); ready.wait();
return q.pop(); return q.pop();
} });
);
push_ready.get_future().wait(); push_ready.get_future().wait();
pop_ready.get_future().wait(); pop_ready.get_future().wait();
go.set_value(); go.set_value();
push_done.get(); push_done.get();
assert(pop_done.get()==42); assert(pop_done.get() == 42);
assert(q.empty()); assert(q.empty());
} }
catch(...) catch (...) {
{
go.set_value(); go.set_value();
throw; throw;
} }

20
source/listing_2.1.cpp
View File

@@ -1,35 +1,35 @@
#include <thread> #include <thread>
void do_something(int& i) void
do_something(int& i)
{ {
++i; ++i;
} }
struct func struct func {
{
int& i; int& i;
func(int& i_):i(i_){} func(int& i_) : i(i_) {}
void operator()() void operator()()
{ {
for(unsigned j=0;j<1000000;++j) for (unsigned j = 0; j < 1000000; ++j) {
{
do_something(i); do_something(i);
} }
} }
}; };
void
void oops() oops()
{ {
int some_local_state=0; int some_local_state = 0;
func my_func(some_local_state); func my_func(some_local_state);
std::thread my_thread(my_func); std::thread my_thread(my_func);
my_thread.detach(); my_thread.detach();
} }
int main() int
main()
{ {
oops(); oops();
} }

33
source/listing_2.2.cpp
View File

@@ -1,46 +1,47 @@
#include <thread> #include <thread>
void do_something(int& i) void
do_something(int& i)
{ {
++i; ++i;
} }
struct func struct func {
{
int& i; int& i;
func(int& i_):i(i_){} func(int& i_) : i(i_) {}
void operator()() void operator()()
{ {
for(unsigned j=0;j<1000000;++j) for (unsigned j = 0; j < 1000000; ++j) {
{
do_something(i); do_something(i);
} }
} }
}; };
void do_something_in_current_thread() void
{} do_something_in_current_thread()
void f()
{ {
int some_local_state=0; }
void
f()
{
int some_local_state = 0;
func my_func(some_local_state); func my_func(some_local_state);
std::thread t(my_func); std::thread t(my_func);
try try {
{
do_something_in_current_thread(); do_something_in_current_thread();
} }
catch(...) catch (...) {
{
t.join(); t.join();
throw; throw;
} }
t.join(); t.join();
} }
int main() int
main()
{ {
f(); f();
} }

39
source/listing_2.3.cpp
View File

@@ -1,48 +1,46 @@
#include <thread> #include <thread>
class thread_guard class thread_guard {
{
std::thread& t; std::thread& t;
public: public:
explicit thread_guard(std::thread& t_): explicit thread_guard(std::thread& t_) : t(t_) {}
t(t_)
{}
~thread_guard() ~thread_guard()
{ {
if(t.joinable()) if (t.joinable()) {
{
t.join(); t.join();
} }
} }
thread_guard(thread_guard const&)=delete; thread_guard(thread_guard const&) = delete;
thread_guard& operator=(thread_guard const&)=delete; thread_guard& operator=(thread_guard const&) = delete;
}; };
void do_something(int& i) void
do_something(int& i)
{ {
++i; ++i;
} }
struct func struct func {
{
int& i; int& i;
func(int& i_):i(i_){} func(int& i_) : i(i_) {}
void operator()() void operator()()
{ {
for(unsigned j=0;j<1000000;++j) for (unsigned j = 0; j < 1000000; ++j) {
{
do_something(i); do_something(i);
} }
} }
}; };
void do_something_in_current_thread() void
{} do_something_in_current_thread()
{
}
void
void f() f()
{ {
int some_local_state; int some_local_state;
func my_func(some_local_state); func my_func(some_local_state);
@@ -52,7 +50,8 @@ void f()
do_something_in_current_thread(); do_something_in_current_thread();
} }
int main() int
main()
{ {
f(); f();
} }

56
source/listing_2.4.cpp
View File

@@ -1,61 +1,61 @@
#include <thread>
#include <string> #include <string>
#include <thread>
void open_document_and_display_gui(std::string const& filename) void
{} open_document_and_display_gui(std::string const& filename)
{
}
bool done_editing() bool
done_editing()
{ {
return true; return true;
} }
enum command_type{ enum command_type { open_new_document };
open_new_document
};
struct user_command {
struct user_command
{
command_type type; command_type type;
user_command(): user_command() : type(open_new_document) {}
type(open_new_document)
{}
}; };
user_command get_user_input() user_command
get_user_input()
{ {
return user_command(); return user_command();
} }
std::string get_filename_from_user() std::string
get_filename_from_user()
{ {
return "foo.doc"; return "foo.doc";
} }
void process_user_input(user_command const& cmd) void
{} process_user_input(user_command const& cmd)
{
}
void edit_document(std::string const& filename) void
edit_document(std::string const& filename)
{ {
open_document_and_display_gui(filename); open_document_and_display_gui(filename);
while(!done_editing()) while (!done_editing()) {
{ user_command cmd = get_user_input();
user_command cmd=get_user_input(); if (cmd.type == open_new_document) {
if(cmd.type==open_new_document) std::string const new_name = get_filename_from_user();
{ std::thread t(edit_document, new_name);
std::string const new_name=get_filename_from_user();
std::thread t(edit_document,new_name);
t.detach(); t.detach();
} }
else else {
{
process_user_input(cmd); process_user_input(cmd);
} }
} }
} }
int main() int
main()
{ {
edit_document("bar.doc"); edit_document("bar.doc");
} }

27
source/listing_2.5.cpp
View File

@@ -1,27 +1,34 @@
#include <thread> #include <thread>
void some_function() void
{} some_function()
{
}
void some_other_function(int) void
{} some_other_function(int)
{
}
std::thread f() std::thread
f()
{ {
void some_function(); void some_function();
return std::thread(some_function); return std::thread(some_function);
} }
std::thread g() std::thread
g()
{ {
void some_other_function(int); void some_other_function(int);
std::thread t(some_other_function,42); std::thread t(some_other_function, 42);
return t; return t;
} }
int main() int
main()
{ {
std::thread t1=f(); std::thread t1 = f();
t1.join(); t1.join();
std::thread t2=g(); std::thread t2 = g();
t2.join(); t2.join();
} }

41
source/listing_2.6.cpp
View File

@@ -1,48 +1,46 @@
#include <thread> #include <thread>
#include <utility> #include <utility>
class scoped_thread class scoped_thread {
{
std::thread t; std::thread t;
public: public:
explicit scoped_thread(std::thread t_): explicit scoped_thread(std::thread t_) : t(std::move(t_))
t(std::move(t_))
{ {
if(!t.joinable()) if (!t.joinable())
throw std::logic_error("No thread"); throw std::logic_error("No thread");
} }
~scoped_thread() ~scoped_thread() { t.join(); }
{ scoped_thread(scoped_thread const&) = delete;
t.join(); scoped_thread& operator=(scoped_thread const&) = delete;
}
scoped_thread(scoped_thread const&)=delete;
scoped_thread& operator=(scoped_thread const&)=delete;
}; };
void do_something(int& i) void
do_something(int& i)
{ {
++i; ++i;
} }
struct func struct func {
{
int& i; int& i;
func(int& i_):i(i_){} func(int& i_) : i(i_) {}
void operator()() void operator()()
{ {
for(unsigned j=0;j<1000000;++j) for (unsigned j = 0; j < 1000000; ++j) {
{
do_something(i); do_something(i);
} }
} }
}; };
void do_something_in_current_thread() void
{} do_something_in_current_thread()
{
}
void f() void
f()
{ {
int some_local_state; int some_local_state;
scoped_thread t(std::thread(func(some_local_state))); scoped_thread t(std::thread(func(some_local_state)));
@@ -50,7 +48,8 @@ void f()
do_something_in_current_thread(); do_something_in_current_thread();
} }
int main() int
main()
{ {
f(); f();
} }

31
source/listing_2.7.cpp
View File

@@ -1,23 +1,26 @@
#include <vector>
#include <thread>
#include <algorithm> #include <algorithm>
#include <functional> #include <functional>
#include <thread>
#include <vector>
void do_work(unsigned id) void
{} do_work(unsigned id)
void f()
{ {
std::vector<std::thread> threads;
for(unsigned i=0;i<20;++i)
{
threads.push_back(std::thread(do_work,i));
}
std::for_each(threads.begin(),threads.end(),
std::mem_fn(&std::thread::join));
} }
int main() void
f()
{
std::vector<std::thread> threads;
for (unsigned i = 0; i < 20; ++i) {
threads.push_back(std::thread(do_work, i));
}
std::for_each(
threads.begin(), threads.end(), std::mem_fn(&std::thread::join));
}
int
main()
{ {
f(); f();
} }

77
source/listing_2.8.cpp
View File

@@ -1,67 +1,66 @@
#include <thread>
#include <numeric>
#include <algorithm> #include <algorithm>
#include <functional> #include <functional>
#include <vector>
#include <iostream> #include <iostream>
#include <numeric>
#include <thread>
#include <vector>
template<typename Iterator,typename T> template <typename Iterator, typename T>
struct accumulate_block struct accumulate_block {
{ void operator()(Iterator first, Iterator last, T& result)
void operator()(Iterator first,Iterator last,T& result)
{ {
result=std::accumulate(first,last,result); result = std::accumulate(first, last, result);
} }
}; };
template<typename Iterator,typename T> template <typename Iterator, typename T>
T parallel_accumulate(Iterator first,Iterator last,T init) T
parallel_accumulate(Iterator first, Iterator last, T init)
{ {
unsigned long const length=std::distance(first,last); unsigned long const length = std::distance(first, last);
if(!length) if (!length)
return init; return init;
unsigned long const min_per_thread=25; unsigned long const min_per_thread = 25;
unsigned long const max_threads= unsigned long const max_threads =
(length+min_per_thread-1)/min_per_thread; (length + min_per_thread - 1) / min_per_thread;
unsigned long const hardware_threads= unsigned long const hardware_threads = std::thread::hardware_concurrency();
std::thread::hardware_concurrency();
unsigned long const num_threads= unsigned long const num_threads =
std::min(hardware_threads!=0?hardware_threads:2,max_threads); std::min(hardware_threads != 0 ? hardware_threads : 2, max_threads);
unsigned long const block_size=length/num_threads; unsigned long const block_size = length / num_threads;
std::vector<T> results(num_threads); std::vector<T> results(num_threads);
std::vector<std::thread> threads(num_threads-1); std::vector<std::thread> threads(num_threads - 1);
Iterator block_start=first; Iterator block_start = first;
for(unsigned long i=0;i<(num_threads-1);++i) for (unsigned long i = 0; i < (num_threads - 1); ++i) {
{ Iterator block_end = block_start;
Iterator block_end=block_start; std::advance(block_end, block_size);
std::advance(block_end,block_size); threads[i] = std::thread(accumulate_block<Iterator, T>(),
threads[i]=std::thread( block_start,
accumulate_block<Iterator,T>(), block_end,
block_start,block_end,std::ref(results[i])); std::ref(results[i]));
block_start=block_end; block_start = block_end;
} }
accumulate_block<Iterator,T>()(block_start,last,results[num_threads-1]); accumulate_block<Iterator, T>()(block_start, last, results[num_threads - 1]);
std::for_each(threads.begin(),threads.end(), std::for_each(
std::mem_fn(&std::thread::join)); threads.begin(), threads.end(), std::mem_fn(&std::thread::join));
return std::accumulate(results.begin(),results.end(),init); return std::accumulate(results.begin(), results.end(), init);
} }
int main() int
main()
{ {
std::vector<int> vi; std::vector<int> vi;
for(int i=0;i<10;++i) for (int i = 0; i < 10; ++i) {
{
vi.push_back(10); vi.push_back(10);
} }
int sum=parallel_accumulate(vi.begin(),vi.end(),5); int sum = parallel_accumulate(vi.begin(), vi.end(), 5);
std::cout<<"sum="<<sum<<std::endl; std::cout << "sum=" << sum << std::endl;
} }

18
source/listing_3.1.cpp
View File

@@ -1,26 +1,30 @@
#include <algorithm>
#include <list> #include <list>
#include <mutex> #include <mutex>
#include <algorithm>
std::list<int> some_list; std::list<int> some_list;
std::mutex some_mutex; std::mutex some_mutex;
void add_to_list(int new_value) void
add_to_list(int new_value)
{ {
std::lock_guard<std::mutex> guard(some_mutex); std::lock_guard<std::mutex> guard(some_mutex);
some_list.push_back(new_value); some_list.push_back(new_value);
} }
bool list_contains(int value_to_find) bool
list_contains(int value_to_find)
{ {
std::lock_guard<std::mutex> guard(some_mutex); std::lock_guard<std::mutex> guard(some_mutex);
return std::find(some_list.begin(),some_list.end(),value_to_find) return std::find(some_list.begin(), some_list.end(), value_to_find) !=
!= some_list.end(); some_list.end();
} }
#include <iostream> #include <iostream>
int main() int
main()
{ {
add_to_list(42); add_to_list(42);
std::cout<<"contains(1)="<<list_contains(1)<<", contains(42)="<<list_contains(42)<<std::endl; std::cout << "contains(1)=" << list_contains(1)
<< ", contains(42)=" << list_contains(42) << std::endl;
} }

20
source/listing_3.10.cpp
View File

@@ -1,6 +1,5 @@
#include <mutex> #include <mutex>
class Y class Y {
{
private: private:
int some_detail; int some_detail;
mutable std::mutex m; mutable std::mutex m;
@@ -10,18 +9,21 @@ private:
std::lock_guard<std::mutex> lock_a(m); std::lock_guard<std::mutex> lock_a(m);
return some_detail; return some_detail;
} }
public: public:
Y(int sd):some_detail(sd){} Y(int sd) : some_detail(sd) {}
friend bool operator==(Y const& lhs, Y const& rhs) friend bool operator==(Y const& lhs, Y const& rhs)
{ {
if(&lhs==&rhs) if (&lhs == &rhs)
return true; return true;
int const lhs_value=lhs.get_detail(); int const lhs_value = lhs.get_detail();
int const rhs_value=rhs.get_detail(); int const rhs_value = rhs.get_detail();
return lhs_value==rhs_value; return lhs_value == rhs_value;
} }
}; };
int main() int
{} main()
{
}

17
source/listing_3.11.cpp
View File

@@ -1,28 +1,25 @@
#include <memory> #include <memory>
#include <mutex> #include <mutex>
struct some_resource struct some_resource {
{ void do_something() {}
void do_something()
{}
}; };
std::shared_ptr<some_resource> resource_ptr; std::shared_ptr<some_resource> resource_ptr;
std::mutex resource_mutex; std::mutex resource_mutex;
void foo() void
foo()
{ {
std::unique_lock<std::mutex> lk(resource_mutex); std::unique_lock<std::mutex> lk(resource_mutex);
if(!resource_ptr) if (!resource_ptr) {
{
resource_ptr.reset(new some_resource); resource_ptr.reset(new some_resource);
} }
lk.unlock(); lk.unlock();
resource_ptr->do_something(); resource_ptr->do_something();
} }
int main() int
main()
{ {
foo(); foo();
} }

55
source/listing_3.12.cpp
View File

@@ -1,32 +1,21 @@
#include <mutex> #include <mutex>
struct connection_info struct connection_info {
{};
struct data_packet
{};
struct connection_handle
{
void send_data(data_packet const&)
{}
data_packet receive_data()
{
return data_packet();
}
}; };
struct remote_connection_manager struct data_packet {
{ };
connection_handle open(connection_info const&)
{ struct connection_handle {
return connection_handle(); void send_data(data_packet const&) {}
} data_packet receive_data() { return data_packet(); }
};
struct remote_connection_manager {
connection_handle open(connection_info const&) { return connection_handle(); }
} connection_manager; } connection_manager;
class X {
class X
{
private: private:
connection_info connection_details; connection_info connection_details;
connection_handle connection; connection_handle connection;
@@ -34,23 +23,27 @@ private:
void open_connection() void open_connection()
{ {
connection=connection_manager.open(connection_details); connection = connection_manager.open(connection_details);
} }
public: public:
X(connection_info const& connection_details_): X(connection_info const& connection_details_)
connection_details(connection_details_) : connection_details(connection_details_)
{} {
}
void send_data(data_packet const& data) void send_data(data_packet const& data)
{ {
std::call_once(connection_init_flag,&X::open_connection,this); std::call_once(connection_init_flag, &X::open_connection, this);
connection.send_data(data); connection.send_data(data);
} }
data_packet receive_data() data_packet receive_data()
{ {
std::call_once(connection_init_flag,&X::open_connection,this); std::call_once(connection_init_flag, &X::open_connection, this);
return connection.receive_data(); return connection.receive_data();
} }
}; };
int main() int
{} main()
{
}

28
source/listing_3.13.cpp
View File

@@ -1,30 +1,32 @@
#include <map>
#include <string>
#include <mutex>
#include <boost/thread/shared_mutex.hpp> #include <boost/thread/shared_mutex.hpp>
#include <map>
#include <mutex>
#include <string>
class dns_entry class dns_entry {
{}; };
class dns_cache class dns_cache {
{ std::map<std::string, dns_entry> entries;
std::map<std::string,dns_entry> entries;
boost::shared_mutex entry_mutex; boost::shared_mutex entry_mutex;
public: public:
dns_entry find_entry(std::string const& domain) dns_entry find_entry(std::string const& domain)
{ {
boost::shared_lock<boost::shared_mutex> lk(entry_mutex); boost::shared_lock<boost::shared_mutex> lk(entry_mutex);
std::map<std::string,dns_entry>::const_iterator const it= std::map<std::string, dns_entry>::const_iterator const it =
entries.find(domain); entries.find(domain);
return (it==entries.end())?dns_entry():it->second; return (it == entries.end()) ? dns_entry() : it->second;
} }
void update_or_add_entry(std::string const& domain, void update_or_add_entry(std::string const& domain,
dns_entry const& dns_details) dns_entry const& dns_details)
{ {
std::lock_guard<boost::shared_mutex> lk(entry_mutex); std::lock_guard<boost::shared_mutex> lk(entry_mutex);
entries[domain]=dns_details; entries[domain] = dns_details;
} }
}; };
int main() int
{} main()
{
}

24
source/listing_3.2.cpp
View File

@@ -1,21 +1,20 @@
#include <mutex> #include <mutex>
class some_data class some_data {
{
int a; int a;
std::string b; std::string b;
public: public:
void do_something() void do_something() {}
{}
}; };
class data_wrapper class data_wrapper {
{
private: private:
some_data data; some_data data;
std::mutex m; std::mutex m;
public: public:
template<typename Function> template <typename Function>
void process_data(Function func) void process_data(Function func)
{ {
std::lock_guard<std::mutex> l(m); std::lock_guard<std::mutex> l(m);
@@ -25,20 +24,23 @@ public:
some_data* unprotected; some_data* unprotected;
void malicious_function(some_data& protected_data) void
malicious_function(some_data& protected_data)
{ {
unprotected=&protected_data; unprotected = &protected_data;
} }
data_wrapper x; data_wrapper x;
void foo() void
foo()
{ {
x.process_data(malicious_function); x.process_data(malicious_function);
unprotected->do_something(); unprotected->do_something();
} }
int main() int
main()
{ {
foo(); foo();
} }

23
source/listing_3.3.cpp
View File

@@ -1,14 +1,17 @@
#include <deque> #include <deque>
template<typename T,typename Container=std::deque<T> > template <typename T, typename Container = std::deque<T>>
class stack class stack {
{
public: public:
explicit stack(const Container&); explicit stack(const Container&);
explicit stack(Container&& = Container()); explicit stack(Container&& = Container());
template <class Alloc> explicit stack(const Alloc&); template <class Alloc>
template <class Alloc> stack(const Container&, const Alloc&); explicit stack(const Alloc&);
template <class Alloc> stack(Container&&, const Alloc&); template <class Alloc>
template <class Alloc> stack(stack&&, const Alloc&); stack(const Container&, const Alloc&);
template <class Alloc>
stack(Container&&, const Alloc&);
template <class Alloc>
stack(stack&&, const Alloc&);
bool empty() const; bool empty() const;
size_t size() const; size_t size() const;
@@ -20,5 +23,7 @@ public:
void swap(stack&&); void swap(stack&&);
}; };
int main() int
{} main()
{
}

14
source/listing_3.4.cpp
View File

@@ -1,14 +1,12 @@
#include <exception> #include <exception>
#include <memory> #include <memory>
struct empty_stack: std::exception struct empty_stack : std::exception {
{
const char* what() const throw(); const char* what() const throw();
}; };
template<typename T> template <typename T>
class threadsafe_stack class threadsafe_stack {
{
public: public:
threadsafe_stack(); threadsafe_stack();
threadsafe_stack(const threadsafe_stack&); threadsafe_stack(const threadsafe_stack&);
@@ -20,5 +18,7 @@ public:
bool empty() const; bool empty() const;
}; };
int main() int
{} main()
{
}

38
source/listing_3.5.cpp
View File

@@ -1,29 +1,24 @@
#include <exception> #include <exception>
#include <stack>
#include <mutex>
#include <memory> #include <memory>
#include <mutex>
#include <stack>
struct empty_stack: std::exception struct empty_stack : std::exception {
{ const char* what() const throw() { return "empty stack"; }
const char* what() const throw()
{
return "empty stack";
}
}; };
template<typename T> template <typename T>
class threadsafe_stack class threadsafe_stack {
{
private: private:
std::stack<T> data; std::stack<T> data;
mutable std::mutex m; mutable std::mutex m;
public: public:
threadsafe_stack(){} threadsafe_stack() {}
threadsafe_stack(const threadsafe_stack& other) threadsafe_stack(const threadsafe_stack& other)
{ {
std::lock_guard<std::mutex> lock(other.m); std::lock_guard<std::mutex> lock(other.m);
data=other.data; data = other.data;
} }
threadsafe_stack& operator=(const threadsafe_stack&) = delete; threadsafe_stack& operator=(const threadsafe_stack&) = delete;
@@ -35,7 +30,8 @@ public:
std::shared_ptr<T> pop() std::shared_ptr<T> pop()
{ {
std::lock_guard<std::mutex> lock(m); std::lock_guard<std::mutex> lock(m);
if(data.empty()) throw empty_stack(); if (data.empty())
throw empty_stack();
std::shared_ptr<T> const res(std::make_shared<T>(data.top())); std::shared_ptr<T> const res(std::make_shared<T>(data.top()));
data.pop(); data.pop();
return res; return res;
@@ -43,8 +39,9 @@ public:
void pop(T& value) void pop(T& value)
{ {
std::lock_guard<std::mutex> lock(m); std::lock_guard<std::mutex> lock(m);
if(data.empty()) throw empty_stack(); if (data.empty())
value=data.top(); throw empty_stack();
value = data.top();
data.pop(); data.pop();
} }
bool empty() const bool empty() const
@@ -54,15 +51,14 @@ public:
} }
}; };
int main() int
main()
{ {
threadsafe_stack<int> si; threadsafe_stack<int> si;
si.push(5); si.push(5);
si.pop(); si.pop();
if(!si.empty()) if (!si.empty()) {
{
int x; int x;
si.pop(x); si.pop(x);
} }
} }

32
source/listing_3.6.cpp
View File

@@ -1,29 +1,33 @@
#include <mutex> #include <mutex>
class some_big_object class some_big_object {
{}; };
void swap(some_big_object& lhs,some_big_object& rhs) void
{} swap(some_big_object& lhs, some_big_object& rhs)
class X
{ {
}
class X {
private: private:
some_big_object some_detail; some_big_object some_detail;
mutable std::mutex m; mutable std::mutex m;
public: public:
X(some_big_object const& sd):some_detail(sd){} X(some_big_object const& sd) : some_detail(sd) {}
friend void swap(X& lhs, X& rhs) friend void swap(X& lhs, X& rhs)
{ {
if(&lhs==&rhs) if (&lhs == &rhs)
return; return;
std::lock(lhs.m,rhs.m); std::lock(lhs.m, rhs.m);
std::lock_guard<std::mutex> lock_a(lhs.m,std::adopt_lock); std::lock_guard<std::mutex> lock_a(lhs.m, std::adopt_lock);
std::lock_guard<std::mutex> lock_b(rhs.m,std::adopt_lock); std::lock_guard<std::mutex> lock_b(rhs.m, std::adopt_lock);
swap(lhs.some_detail,rhs.some_detail); swap(lhs.some_detail, rhs.some_detail);
} }
}; };
int main() int
{} main()
{
}

52
source/listing_3.7.cpp
View File

@@ -1,64 +1,68 @@
#include <mutex> #include <mutex>
class hierarchical_mutex class hierarchical_mutex {
{
public: public:
explicit hierarchical_mutex(unsigned level) explicit hierarchical_mutex(unsigned level) {}
{}
void lock() void lock() {}
{} void unlock() {}
void unlock()
{}
}; };
hierarchical_mutex high_level_mutex(10000); hierarchical_mutex high_level_mutex(10000);
hierarchical_mutex low_level_mutex(5000); hierarchical_mutex low_level_mutex(5000);
int do_low_level_stuff() int
do_low_level_stuff()
{ {
return 42; return 42;
} }
int
int low_level_func() low_level_func()
{ {
std::lock_guard<hierarchical_mutex> lk(low_level_mutex); std::lock_guard<hierarchical_mutex> lk(low_level_mutex);
return do_low_level_stuff(); return do_low_level_stuff();
} }
void high_level_stuff(int some_param) void
{} high_level_stuff(int some_param)
{
}
void
void high_level_func() high_level_func()
{ {
std::lock_guard<hierarchical_mutex> lk(high_level_mutex); std::lock_guard<hierarchical_mutex> lk(high_level_mutex);
high_level_stuff(low_level_func()); high_level_stuff(low_level_func());
} }
void thread_a() void
thread_a()
{ {
high_level_func(); high_level_func();
} }
hierarchical_mutex other_mutex(100); hierarchical_mutex other_mutex(100);
void do_other_stuff() void
{} do_other_stuff()
{
}
void
void other_stuff() other_stuff()
{ {
high_level_func(); high_level_func();
do_other_stuff(); do_other_stuff();
} }
void thread_b() void
thread_b()
{ {
std::lock_guard<hierarchical_mutex> lk(other_mutex); std::lock_guard<hierarchical_mutex> lk(other_mutex);
other_stuff(); other_stuff();
} }
int main() int
{} main()
{
}

31
source/listing_3.8.cpp
View File

@@ -1,8 +1,7 @@
#include <mutex> #include <mutex>
#include <stdexcept> #include <stdexcept>
class hierarchical_mutex class hierarchical_mutex {
{
std::mutex internal_mutex; std::mutex internal_mutex;
unsigned long const hierarchy_value; unsigned long const hierarchy_value;
unsigned long previous_hierarchy_value; unsigned long previous_hierarchy_value;
@@ -10,21 +9,21 @@ class hierarchical_mutex
void check_for_hierarchy_violation() void check_for_hierarchy_violation()
{ {
if(this_thread_hierarchy_value <= hierarchy_value) if (this_thread_hierarchy_value <= hierarchy_value) {
{
throw std::logic_error("mutex hierarchy violated"); throw std::logic_error("mutex hierarchy violated");
} }
} }
void update_hierarchy_value() void update_hierarchy_value()
{ {
previous_hierarchy_value=this_thread_hierarchy_value; previous_hierarchy_value = this_thread_hierarchy_value;
this_thread_hierarchy_value=hierarchy_value; this_thread_hierarchy_value = hierarchy_value;
} }
public: public:
explicit hierarchical_mutex(unsigned long value): explicit hierarchical_mutex(unsigned long value)
hierarchy_value(value), : hierarchy_value(value), previous_hierarchy_value(0)
previous_hierarchy_value(0) {
{} }
void lock() void lock()
{ {
check_for_hierarchy_violation(); check_for_hierarchy_violation();
@@ -33,24 +32,24 @@ public:
} }
void unlock() void unlock()
{ {
this_thread_hierarchy_value=previous_hierarchy_value; this_thread_hierarchy_value = previous_hierarchy_value;
internal_mutex.unlock(); internal_mutex.unlock();
} }
bool try_lock() bool try_lock()
{ {
check_for_hierarchy_violation(); check_for_hierarchy_violation();
if(!internal_mutex.try_lock()) if (!internal_mutex.try_lock())
return false; return false;
update_hierarchy_value(); update_hierarchy_value();
return true; return true;
} }
}; };
thread_local unsigned long thread_local unsigned long hierarchical_mutex::this_thread_hierarchy_value(
hierarchical_mutex::this_thread_hierarchy_value(ULONG_MAX); ULONG_MAX);
int main() int
main()
{ {
hierarchical_mutex m1(42); hierarchical_mutex m1(42);
hierarchical_mutex m2(2000); hierarchical_mutex m2(2000);
} }

32
source/listing_3.9.cpp
View File

@@ -1,29 +1,33 @@
#include <mutex> #include <mutex>
class some_big_object class some_big_object {
{}; };
void swap(some_big_object& lhs,some_big_object& rhs) void
{} swap(some_big_object& lhs, some_big_object& rhs)
class X
{ {
}
class X {
private: private:
some_big_object some_detail; some_big_object some_detail;
mutable std::mutex m; mutable std::mutex m;
public: public:
X(some_big_object const& sd):some_detail(sd){} X(some_big_object const& sd) : some_detail(sd) {}
friend void swap(X& lhs, X& rhs) friend void swap(X& lhs, X& rhs)
{ {
if(&lhs==&rhs) if (&lhs == &rhs)
return; return;
std::unique_lock<std::mutex> lock_a(lhs.m,std::defer_lock); std::unique_lock<std::mutex> lock_a(lhs.m, std::defer_lock);
std::unique_lock<std::mutex> lock_b(rhs.m,std::defer_lock); std::unique_lock<std::mutex> lock_b(rhs.m, std::defer_lock);
std::lock(lock_a,lock_b); std::lock(lock_a, lock_b);
swap(lhs.some_detail,rhs.some_detail); swap(lhs.some_detail, rhs.some_detail);
} }
}; };
int main() int
{} main()
{
}

46
source/listing_4.1.cpp
View File

@@ -1,25 +1,30 @@
#include <mutex>
#include <condition_variable> #include <condition_variable>
#include <thread> #include <mutex>
#include <queue> #include <queue>
#include <thread>
bool more_data_to_prepare() bool
more_data_to_prepare()
{ {
return false; return false;
} }
struct data_chunk struct data_chunk {
{}; };
data_chunk prepare_data() data_chunk
prepare_data()
{ {
return data_chunk(); return data_chunk();
} }
void process(data_chunk&) void
{} process(data_chunk&)
{
}
bool is_last_chunk(data_chunk&) bool
is_last_chunk(data_chunk&)
{ {
return true; return true;
} }
@@ -28,33 +33,34 @@ std::mutex mut;
std::queue<data_chunk> data_queue; std::queue<data_chunk> data_queue;
std::condition_variable data_cond; std::condition_variable data_cond;
void data_preparation_thread() void
data_preparation_thread()
{ {
while(more_data_to_prepare()) while (more_data_to_prepare()) {
{ data_chunk const data = prepare_data();
data_chunk const data=prepare_data();
std::lock_guard<std::mutex> lk(mut); std::lock_guard<std::mutex> lk(mut);
data_queue.push(data); data_queue.push(data);
data_cond.notify_one(); data_cond.notify_one();
} }
} }
void data_processing_thread() void
data_processing_thread()
{ {
while(true) while (true) {
{
std::unique_lock<std::mutex> lk(mut); std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk,[]{return !data_queue.empty();}); data_cond.wait(lk, [] { return !data_queue.empty(); });
data_chunk data=data_queue.front(); data_chunk data = data_queue.front();
data_queue.pop(); data_queue.pop();
lk.unlock(); lk.unlock();
process(data); process(data);
if(is_last_chunk(data)) if (is_last_chunk(data))
break; break;
} }
} }
int main() int
main()
{ {
std::thread t1(data_preparation_thread); std::thread t1(data_preparation_thread);
std::thread t2(data_processing_thread); std::thread t2(data_processing_thread);

29
source/listing_4.10.cpp
View File

@@ -1,24 +1,19 @@
#include <future> #include <future>
void process_connections(connection_set& connections) void
process_connections(connection_set& connections)
{ {
while(!done(connections)) while (!done(connections)) {
{ for (connection_iterator connection = connections.begin(),
for(connection_iterator end = connections.end();
connection=connections.begin(),end=connections.end(); connection != end;
connection!=end; ++connection) {
++connection) if (connection->has_incoming_data()) {
{ data_packet data = connection->incoming();
if(connection->has_incoming_data()) std::promise<payload_type>& p = connection->get_promise(data.id);
{
data_packet data=connection->incoming();
std::promise<payload_type>& p=
connection->get_promise(data.id);
p.set_value(data.payload); p.set_value(data.payload);
} }
if(connection->has_outgoing_data()) if (connection->has_outgoing_data()) {
{ outgoing_packet data = connection->top_of_outgoing_queue();
outgoing_packet data=
connection->top_of_outgoing_queue();
connection->send(data.payload); connection->send(data.payload);
data.promise.set_value(true); data.promise.set_value(true);
} }

14
source/listing_4.11.cpp
View File

@@ -1,17 +1,17 @@
#include <chrono>
#include <condition_variable> #include <condition_variable>
#include <mutex> #include <mutex>
#include <chrono>
std::condition_variable cv; std::condition_variable cv;
bool done; bool done;
std::mutex m; std::mutex m;
bool wait_loop() bool
wait_loop()
{ {
auto const timeout= std::chrono::steady_clock::now()+ auto const timeout =
std::chrono::milliseconds(500); std::chrono::steady_clock::now() + std::chrono::milliseconds(500);
std::unique_lock<std::mutex> lk(m); std::unique_lock<std::mutex> lk(m);
while(!done) while (!done) {
{ if (cv.wait_until(lk, timeout) == std::cv_status::timeout)
if(cv.wait_until(lk,timeout)==std::cv_status::timeout)
break; break;
} }
return done; return done;

31
source/listing_4.12.cpp
View File

@@ -1,24 +1,21 @@
template<typename T> template <typename T>
std::list<T> sequential_quick_sort(std::list<T> input) std::list<T>
sequential_quick_sort(std::list<T> input)
{ {
if(input.empty()) if (input.empty()) {
{
return input; return input;
} }
std::list<T> result; std::list<T> result;
result.splice(result.begin(),input,input.begin()); result.splice(result.begin(), input, input.begin());
T const& pivot=*result.begin(); T const& pivot = *result.begin();
auto divide_point=std::partition(input.begin(),input.end(), auto divide_point = std::partition(
[&](T const& t){return t<pivot;}); input.begin(), input.end(), [&](T const& t) { return t < pivot; });
std::list<T> lower_part; std::list<T> lower_part;
lower_part.splice(lower_part.end(),input,input.begin(), lower_part.splice(lower_part.end(), input, input.begin(), divide_point);
divide_point); auto new_lower(sequential_quick_sort(std::move(lower_part)));
auto new_lower( auto new_higher(sequential_quick_sort(std::move(input)));
sequential_quick_sort(std::move(lower_part))); result.splice(result.end(), new_higher);
auto new_higher( Using synchronization of operations to simplify code result.splice(
sequential_quick_sort(std::move(input))); result.begin(), new_lower);
result.splice(result.end(),new_higher);
Using synchronization of operations to simplify code
result.splice(result.begin(),new_lower);
return result; return result;
} }

30
source/listing_4.13.cpp
View File

@@ -1,23 +1,21 @@
template<typename T> template <typename T>
std::list<T> parallel_quick_sort(std::list<T> input) std::list<T>
parallel_quick_sort(std::list<T> input)
{ {
if(input.empty()) if (input.empty()) {
{
return input; return input;
} }
std::list<T> result; std::list<T> result;
result.splice(result.begin(),input,input.begin()); result.splice(result.begin(), input, input.begin());
T const& pivot=*result.begin(); T const& pivot = *result.begin();
auto divide_point=std::partition(input.begin(),input.end(), auto divide_point = std::partition(
[&](T const& t){return t<pivot;}); input.begin(), input.end(), [&](T const& t) { return t < pivot; });
std::list<T> lower_part; std::list<T> lower_part;
lower_part.splice(lower_part.end(),input,input.begin(), lower_part.splice(lower_part.end(), input, input.begin(), divide_point);
divide_point); std::future<std::list<T>> new_lower(
std::future<std::list<T> > new_lower( std::async(&parallel_quick_sort<T>, std::move(lower_part)));
std::async(&parallel_quick_sort<T>,std::move(lower_part))); auto new_higher(parallel_quick_sort(std::move(input)));
auto new_higher( result.splice(result.end(), new_higher);
parallel_quick_sort(std::move(input))); result.splice(result.begin(), new_lower.get());
result.splice(result.end(),new_higher);
result.splice(result.begin(),new_lower.get());
return result; return result;
} }

11
source/listing_4.14.cpp
View File

@@ -1,12 +1,11 @@
template<typename F,typename A> template <typename F, typename A>
std::future<std::result_of<F(A&&)>::type> std::future<std::result_of<F(A&&)>::type>
spawn_task(F&& f,A&& a) spawn_task(F&& f, A&& a)
{ {
typedef std::result_of<F(A&&)>::type result_type; typedef std::result_of<F(A &&)>::type result_type;
std::packaged_task<result_type(A&&)> std::packaged_task<result_type(A &&)> task(std::move(f));
task(std::move(f));
std::future<result_type> res(task.get_future()); std::future<result_type> res(task.get_future());
std::thread t(std::move(task),std::move(a)); std::thread t(std::move(task), std::move(a));
t.detach(); t.detach();
return res; return res;
} }

32
source/listing_4.15.cpp
View File

@@ -1,9 +1,7 @@
struct card_inserted struct card_inserted {
{
std::string account; std::string account;
}; };
class atm class atm {
{
messaging::receiver incoming; messaging::receiver incoming;
messaging::sender bank; messaging::sender bank;
messaging::sender interface_hardware; messaging::sender interface_hardware;
@@ -13,31 +11,25 @@ class atm
void waiting_for_card() void waiting_for_card()
{ {
interface_hardware.send(display_enter_card()); interface_hardware.send(display_enter_card());
incoming.wait() incoming.wait().handle<card_inserted>([&](card_inserted const& msg) {
.handle<card_inserted>( account = msg.account;
[&](card_inserted const& msg) pin = "";
{
account=msg.account;
pin="";
interface_hardware.send(display_enter_pin()); interface_hardware.send(display_enter_pin());
state=&atm::getting_pin; state = &atm::getting_pin;
} });
);
} }
void getting_pin(); void getting_pin();
public: public:
void run() void run()
{ {
state=&atm::waiting_for_card; state = &atm::waiting_for_card;
try try {
{ for (;;) {
for(;;)
{
(this->*state)(); (this->*state)();
} }
} }
catch(messaging::close_queue const&) catch (messaging::close_queue const&) {
{
} }
} }
}; };

39
source/listing_4.16.cpp
View File

@@ -1,31 +1,20 @@
void atm::getting_pin() void
atm::getting_pin()
{ {
incoming.wait() incoming.wait()
.handle<digit_pressed>( .handle<digit_pressed>([&](digit_pressed const& msg) {
[&](digit_pressed const& msg) unsigned const pin_length = 4;
{ pin += msg.digit;
unsigned const pin_length=4; if (pin.length() == pin_length) {
pin+=msg.digit; bank.send(verify_pin(account, pin, incoming));
if(pin.length()==pin_length) state = &atm::verifying_pin;
{
bank.send(verify_pin(account,pin,incoming));
state=&atm::verifying_pin;
} }
})
.handle<clear_last_pressed>([&](clear_last_pressed const& msg) {
if (!pin.empty()) {
pin.resize(pin.length() - 1);
} }
) })
.handle<clear_last_pressed>(
[&](clear_last_pressed const& msg)
{
if(!pin.empty())
{
pin.resize(pin.length()-1);
}
}
)
.handle<cancel_pressed>( .handle<cancel_pressed>(
[&](cancel_pressed const& msg) [&](cancel_pressed const& msg) { state = &atm::done_processing; });
{
state=&atm::done_processing;
}
);
} }

20
source/listing_4.2.cpp
View File

@@ -1,14 +1,18 @@
template <class T, class Container = std::deque<T> > template <class T, class Container = std::deque<T>>
class queue { class queue {
public: public:
explicit queue(const Container&); explicit queue(const Container&);
explicit queue(Container&& = Container()); explicit queue(Container&& = Container());
queue(queue&& q); queue(queue&& q);
template <class Alloc> explicit queue(const Alloc&); template <class Alloc>
template <class Alloc> queue(const Container&, const Alloc&); explicit queue(const Alloc&);
template <class Alloc> queue(Container&&, const Alloc&); template <class Alloc>
template <class Alloc> queue(queue&&, const Alloc&); queue(const Container&, const Alloc&);
template <class Alloc>
queue(Container&&, const Alloc&);
template <class Alloc>
queue(queue&&, const Alloc&);
queue& operator=(queue&& q); queue& operator=(queue&& q);
void swap(queue&& q); void swap(queue&& q);
@@ -26,5 +30,7 @@ public:
void pop(); void pop();
}; };
int main() int
{} main()
{
}

11
source/listing_4.3.cpp
View File

@@ -1,7 +1,6 @@
#include <memory> #include <memory>
template<typename T> template <typename T>
class threadsafe_queue class threadsafe_queue {
{
public: public:
threadsafe_queue(); threadsafe_queue();
threadsafe_queue(const threadsafe_queue&); threadsafe_queue(const threadsafe_queue&);
@@ -18,5 +17,7 @@ public:
bool empty() const; bool empty() const;
}; };
int main() int
{} main()
{
}

33
source/listing_4.4.cpp
View File

@@ -1,13 +1,13 @@
#include <mutex>
#include <condition_variable> #include <condition_variable>
#include <mutex>
#include <queue> #include <queue>
template<typename T> template <typename T>
class threadsafe_queue class threadsafe_queue {
{
private: private:
std::mutex mut; std::mutex mut;
std::queue<T> data_queue; std::queue<T> data_queue;
std::condition_variable data_cond; std::condition_variable data_cond;
public: public:
void push(T new_value) void push(T new_value)
{ {
@@ -19,15 +19,14 @@ public:
void wait_and_pop(T& value) void wait_and_pop(T& value)
{ {
std::unique_lock<std::mutex> lk(mut); std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk,[this]{return !data_queue.empty();}); data_cond.wait(lk, [this] { return !data_queue.empty(); });
value=data_queue.front(); value = data_queue.front();
data_queue.pop(); data_queue.pop();
} }
}; };
struct data_chunk {
struct data_chunk };
{};
data_chunk prepare_data(); data_chunk prepare_data();
bool more_data_to_prepare(); bool more_data_to_prepare();
@@ -36,23 +35,23 @@ bool is_last_chunk(data_chunk);
threadsafe_queue<data_chunk> data_queue; threadsafe_queue<data_chunk> data_queue;
void data_preparation_thread() void
data_preparation_thread()
{ {
while(more_data_to_prepare()) while (more_data_to_prepare()) {
{ data_chunk const data = prepare_data();
data_chunk const data=prepare_data();
data_queue.push(data); data_queue.push(data);
} }
} }
void data_processing_thread() void
data_processing_thread()
{ {
while(true) while (true) {
{
data_chunk data; data_chunk data;
data_queue.wait_and_pop(data); data_queue.wait_and_pop(data);
process(data); process(data);
if(is_last_chunk(data)) if (is_last_chunk(data))
break; break;
} }
} }

33
source/listing_4.5.cpp
View File

@@ -1,22 +1,21 @@
#include <mutex>
#include <condition_variable> #include <condition_variable>
#include <queue>
#include <memory> #include <memory>
#include <mutex>
#include <queue>
template<typename T> template <typename T>
class threadsafe_queue class threadsafe_queue {
{
private: private:
mutable std::mutex mut; mutable std::mutex mut;
std::queue<T> data_queue; std::queue<T> data_queue;
std::condition_variable data_cond; std::condition_variable data_cond;
public: public:
threadsafe_queue() threadsafe_queue() {}
{}
threadsafe_queue(threadsafe_queue const& other) threadsafe_queue(threadsafe_queue const& other)
{ {
std::lock_guard<std::mutex> lk(other.mut); std::lock_guard<std::mutex> lk(other.mut);
data_queue=other.data_queue; data_queue = other.data_queue;
} }
void push(T new_value) void push(T new_value)
@@ -29,15 +28,15 @@ public:
void wait_and_pop(T& value) void wait_and_pop(T& value)
{ {
std::unique_lock<std::mutex> lk(mut); std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk,[this]{return !data_queue.empty();}); data_cond.wait(lk, [this] { return !data_queue.empty(); });
value=data_queue.front(); value = data_queue.front();
data_queue.pop(); data_queue.pop();
} }
std::shared_ptr<T> wait_and_pop() std::shared_ptr<T> wait_and_pop()
{ {
std::unique_lock<std::mutex> lk(mut); std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk,[this]{return !data_queue.empty();}); data_cond.wait(lk, [this] { return !data_queue.empty(); });
std::shared_ptr<T> res(std::make_shared<T>(data_queue.front())); std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));
data_queue.pop(); data_queue.pop();
return res; return res;
@@ -46,16 +45,16 @@ public:
bool try_pop(T& value) bool try_pop(T& value)
{ {
std::lock_guard<std::mutex> lk(mut); std::lock_guard<std::mutex> lk(mut);
if(data_queue.empty) if (data_queue.empty)
return false; return false;
value=data_queue.front(); value = data_queue.front();
data_queue.pop(); data_queue.pop();
} }
std::shared_ptr<T> try_pop() std::shared_ptr<T> try_pop()
{ {
std::lock_guard<std::mutex> lk(mut); std::lock_guard<std::mutex> lk(mut);
if(data_queue.empty()) if (data_queue.empty())
return std::shared_ptr<T>(); return std::shared_ptr<T>();
std::shared_ptr<T> res(std::make_shared<T>(data_queue.front())); std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));
data_queue.pop(); data_queue.pop();
@@ -69,5 +68,7 @@ public:
} }
}; };
int main() int
{} main()
{
}

20
source/listing_4.6.cpp
View File

@@ -1,16 +1,20 @@
#include <future> #include <future>
#include <iostream> #include <iostream>
int find_the_answer_to_ltuae() int
find_the_answer_to_ltuae()
{ {
return 42; return 42;
} }
void do_other_stuff() void
{} do_other_stuff()
int main()
{ {
std::future<int> the_answer=std::async(find_the_answer_to_ltuae); }
do_other_stuff();
std::cout<<"The answer is "<<the_answer.get()<<std::endl; int
main()
{
std::future<int> the_answer = std::async(find_the_answer_to_ltuae);
do_other_stuff();
std::cout << "The answer is " << the_answer.get() << std::endl;
} }

28
source/listing_4.7.cpp
View File

@@ -1,34 +1,30 @@
#include <string>
#include <future> #include <future>
#include <string>
struct X struct X {
{ void foo(int, std::string const&);
void foo(int,std::string const&);
std::string bar(std::string const&); std::string bar(std::string const&);
}; };
X x; X x;
auto f1=std::async(&X::foo,&x,42,"hello"); auto f1 = std::async(&X::foo, &x, 42, "hello");
auto f2=std::async(&X::bar,x,"goodbye"); auto f2 = std::async(&X::bar, x, "goodbye");
struct Y struct Y {
{
double operator()(double); double operator()(double);
}; };
Y y; Y y;
auto f3=std::async(Y(),3.141); auto f3 = std::async(Y(), 3.141);
auto f4=std::async(std::ref(y),2.718); auto f4 = std::async(std::ref(y), 2.718);
X baz(X&); X baz(X&);
auto f6=std::async(baz,std::ref(x)); auto f6 = std::async(baz, std::ref(x));
class move_only class move_only {
{
public: public:
move_only(); move_only();
move_only(move_only&&); move_only(move_only&&);
move_only(move_only const&) = delete; move_only(move_only const&) = delete;
move_only& operator=(move_only&&); move_only& operator =(move_only&&);
move_only& operator=(move_only const&) = delete; move_only& operator=(move_only const&) = delete;
void operator()(); void operator()();
}; };
auto f5=std::async(move_only()); auto f5 = std::async(move_only());

9
source/listing_4.8.cpp
View File

@@ -1,9 +1,8 @@
template<> template <>
class packaged_task<std::string(std::vector<char>*,int)> class packaged_task<std::string(std::vector<char>*, int)> {
{
public: public:
template<typename Callable> template <typename Callable>
explicit packaged_task(Callable&& f); explicit packaged_task(Callable&& f);
std::future<std::string> get_future(); std::future<std::string> get_future();
void operator()(std::vector<char>*,int); void operator()(std::vector<char>*, int);
}; };

21
source/listing_4.9.cpp
View File

@@ -1,26 +1,26 @@
#include <deque> #include <deque>
#include <mutex>
#include <future> #include <future>
#include <mutex>
#include <thread> #include <thread>
#include <utility> #include <utility>
std::mutex m; std::mutex m;
std::deque<std::packaged_task<void()> > tasks; std::deque<std::packaged_task<void()>> tasks;
bool gui_shutdown_message_received(); bool gui_shutdown_message_received();
void get_and_process_gui_message(); void get_and_process_gui_message();
void gui_thread() void
gui_thread()
{ {
while(!gui_shutdown_message_received()) while (!gui_shutdown_message_received()) {
{
get_and_process_gui_message(); get_and_process_gui_message();
std::packaged_task<void()> task; std::packaged_task<void()> task;
{ {
std::lock_guard<std::mutex> lk(m); std::lock_guard<std::mutex> lk(m);
if(tasks.empty()) if (tasks.empty())
continue; continue;
task=std::move(tasks.front()); task = std::move(tasks.front());
tasks.pop_front(); tasks.pop_front();
} }
task(); task();
@@ -29,11 +29,12 @@ void gui_thread()
std::thread gui_bg_thread(gui_thread); std::thread gui_bg_thread(gui_thread);
template<typename Func> template <typename Func>
std::future<void> post_task_for_gui_thread(Func f) std::future<void>
post_task_for_gui_thread(Func f)
{ {
std::packaged_task<void()> task(f); std::packaged_task<void()> task(f);
std::future<void> res=task.get_future(); std::future<void> res = task.get_future();
std::lock_guard<std::mutex> lk(m); std::lock_guard<std::mutex> lk(m);
tasks.push_back(std::move(task)); tasks.push_back(std::move(task));
return res; return res;

16
source/listing_5.1.cpp
View File

@@ -1,16 +1,12 @@
class spinlock_mutex class spinlock_mutex {
{
std::atomic_flag flag; std::atomic_flag flag;
public: public:
spinlock_mutex(): spinlock_mutex() : flag(ATOMIC_FLAG_INIT) {}
flag(ATOMIC_FLAG_INIT)
{}
void lock() void lock()
{ {
while(flag.test_and_set(std::memory_order_acquire)); while (flag.test_and_set(std::memory_order_acquire))
} ;
void unlock()
{
flag.clear(std::memory_order_release);
} }
void unlock() { flag.clear(std::memory_order_release); }
}; };

35
source/listing_5.10.cpp
View File

@@ -1,9 +1,8 @@
#include <assert.h>
#include <atomic>
#include <string> #include <string>
#include <thread> #include <thread>
#include <atomic> struct X {
#include <assert.h>
struct X
{
int i; int i;
std::string s; std::string s;
}; };
@@ -11,29 +10,31 @@ struct X
std::atomic<X*> p; std::atomic<X*> p;
std::atomic<int> a; std::atomic<int> a;
void create_x() void
create_x()
{ {
X* x=new X; X* x = new X;
x->i=42; x->i = 42;
x->s="hello"; x->s = "hello";
a.store(99,std::memory_order_relaxed); a.store(99, std::memory_order_relaxed);
p.store(x,std::memory_order_release); p.store(x, std::memory_order_release);
} }
void use_x() void
use_x()
{ {
X* x; X* x;
while(!(x=p.load(std::memory_order_consume))) while (!(x = p.load(std::memory_order_consume)))
std::this_thread::sleep_for(std::chrono::microseconds(1)); std::this_thread::sleep_for(std::chrono::microseconds(1));
assert(x->i==42); assert(x->i == 42);
assert(x->s=="hello"); assert(x->s == "hello");
assert(a.load(std::memory_order_relaxed)==99); assert(a.load(std::memory_order_relaxed) == 99);
} }
int main() int
main()
{ {
std::thread t1(create_x); std::thread t1(create_x);
std::thread t2(use_x); std::thread t2(use_x);
t1.join(); t1.join();
t2.join(); t2.join();
} }

24
source/listing_5.11.cpp
View File

@@ -4,33 +4,33 @@
std::vector<int> queue_data; std::vector<int> queue_data;
std::atomic<int> count; std::atomic<int> count;
void populate_queue() void
populate_queue()
{ {
unsigned const number_of_items=20; unsigned const number_of_items = 20;
queue_data.clear(); queue_data.clear();
for(unsigned i=0;i<number_of_items;++i) for (unsigned i = 0; i < number_of_items; ++i) {
{
queue_data.push_back(i); queue_data.push_back(i);
} }
count.store(number_of_items,std::memory_order_release); count.store(number_of_items, std::memory_order_release);
} }
void consume_queue_items() void
consume_queue_items()
{ {
while(true) while (true) {
{
int item_index; int item_index;
if((item_index=count.fetch_sub(1,std::memory_order_acquire))<=0) if ((item_index = count.fetch_sub(1, std::memory_order_acquire)) <= 0) {
{
wait_for_more_items(); wait_for_more_items();
continue; continue;
} }
process(queue_data[item_index-1]); process(queue_data[item_index - 1]);
} }
} }
int main() int
main()
{ {
std::thread a(populate_queue); std::thread a(populate_queue);
std::thread b(consume_queue_items); std::thread b(consume_queue_items);

30
source/listing_5.12.cpp
View File

@@ -1,33 +1,37 @@
#include <assert.h>
#include <atomic> #include <atomic>
#include <thread> #include <thread>
#include <assert.h>
std::atomic<bool> x,y; std::atomic<bool> x, y;
std::atomic<int> z; std::atomic<int> z;
void write_x_then_y() void
write_x_then_y()
{ {
x.store(true,std::memory_order_relaxed); x.store(true, std::memory_order_relaxed);
std::atomic_thread_fence(std::memory_order_release); std::atomic_thread_fence(std::memory_order_release);
y.store(true,std::memory_order_relaxed); y.store(true, std::memory_order_relaxed);
} }
void read_y_then_x() void
read_y_then_x()
{ {
while(!y.load(std::memory_order_relaxed)); while (!y.load(std::memory_order_relaxed))
;
std::atomic_thread_fence(std::memory_order_acquire); std::atomic_thread_fence(std::memory_order_acquire);
if(x.load(std::memory_order_relaxed)) if (x.load(std::memory_order_relaxed))
++z; ++z;
} }
int main() int
main()
{ {
x=false; x = false;
y=false; y = false;
z=0; z = 0;
std::thread a(write_x_then_y); std::thread a(write_x_then_y);
std::thread b(read_y_then_x); std::thread b(read_y_then_x);
a.join(); a.join();
b.join(); b.join();
assert(z.load()!=0); assert(z.load() != 0);
} }

30
source/listing_5.13.cpp
View File

@@ -1,34 +1,38 @@
#include <assert.h>
#include <atomic> #include <atomic>
#include <thread> #include <thread>
#include <assert.h>
bool x=false; bool x = false;
std::atomic<bool> y; std::atomic<bool> y;
std::atomic<int> z; std::atomic<int> z;
void write_x_then_y() void
write_x_then_y()
{ {
x=true; x = true;
std::atomic_thread_fence(std::memory_order_release); std::atomic_thread_fence(std::memory_order_release);
y.store(true,std::memory_order_relaxed); y.store(true, std::memory_order_relaxed);
} }
void read_y_then_x() void
read_y_then_x()
{ {
while(!y.load(std::memory_order_relaxed)); while (!y.load(std::memory_order_relaxed))
;
std::atomic_thread_fence(std::memory_order_acquire); std::atomic_thread_fence(std::memory_order_acquire);
if(x) if (x)
++z; ++z;
} }
int main() int
main()
{ {
x=false; x = false;
y=false; y = false;
z=0; z = 0;
std::thread a(write_x_then_y); std::thread a(write_x_then_y);
std::thread b(read_y_then_x); std::thread b(read_y_then_x);
a.join(); a.join();
b.join(); b.join();
assert(z.load()!=0); assert(z.load() != 0);
} }

17
source/listing_5.2.cpp
View File

@@ -1,22 +1,23 @@
#include <vector>
#include <atomic> #include <atomic>
#include <iostream>
#include <chrono> #include <chrono>
#include <iostream>
#include <thread> #include <thread>
#include <vector>
std::vector<int> data; std::vector<int> data;
std::atomic_bool data_ready(false); std::atomic_bool data_ready(false);
void reader_thread() void
reader_thread()
{ {
while(!data_ready.load()) while (!data_ready.load()) {
{
std::this_thread::sleep_for(std::chrono::milliseconds(1)); std::this_thread::sleep_for(std::chrono::milliseconds(1));
} }
std::cout<<"The answer="<<data[0]<<"\n"; std::cout << "The answer=" << data[0] << "\n";
} }
void writer_thread() void
writer_thread()
{ {
data.push_back(42); data.push_back(42);
data_ready=true; data_ready = true;
} }

15
source/listing_5.3.cpp
View File

@@ -1,17 +1,20 @@
#include <iostream> #include <iostream>
void foo(int a,int b) void
foo(int a, int b)
{ {
std::cout<<a<<”,”<<b<<std::endl; std::cout << a <<”,”<< b << std::endl;
} }
int get_num() int
get_num()
{ {
static int i=0; static int i = 0;
return ++i; return ++i;
} }
int main() int
main()
{ {
foo(get_num(),get_num()); foo(get_num(), get_num());
} }

41
source/listing_5.4.cpp
View File

@@ -1,39 +1,46 @@
#include <assert.h>
#include <atomic> #include <atomic>
#include <thread> #include <thread>
#include <assert.h>
std::atomic<bool> x,y; std::atomic<bool> x, y;
std::atomic<int> z; std::atomic<int> z;
void write_x() void
write_x()
{ {
x.store(true,std::memory_order_seq_cst); x.store(true, std::memory_order_seq_cst);
} }
void write_y() void
write_y()
{ {
y.store(true,std::memory_order_seq_cst); y.store(true, std::memory_order_seq_cst);
} }
void read_x_then_y() void
read_x_then_y()
{ {
while(!x.load(std::memory_order_seq_cst)); while (!x.load(std::memory_order_seq_cst))
if(y.load(std::memory_order_seq_cst)) ;
if (y.load(std::memory_order_seq_cst))
++z; ++z;
} }
void read_y_then_x() void
read_y_then_x()
{ {
while(!y.load(std::memory_order_seq_cst)); while (!y.load(std::memory_order_seq_cst))
if(x.load(std::memory_order_seq_cst)) ;
if (x.load(std::memory_order_seq_cst))
++z; ++z;
} }
int main() int
main()
{ {
x=false; x = false;
y=false; y = false;
z=0; z = 0;
std::thread a(write_x); std::thread a(write_x);
std::thread b(write_y); std::thread b(write_y);
std::thread c(read_x_then_y); std::thread c(read_x_then_y);
@@ -42,5 +49,5 @@ int main()
b.join(); b.join();
c.join(); c.join();
d.join(); d.join();
assert(z.load()!=0); assert(z.load() != 0);
} }

30
source/listing_5.5.cpp
View File

@@ -1,31 +1,35 @@
#include <assert.h>
#include <atomic> #include <atomic>
#include <thread> #include <thread>
#include <assert.h>
std::atomic<bool> x,y; std::atomic<bool> x, y;
std::atomic<int> z; std::atomic<int> z;
void write_x_then_y() void
write_x_then_y()
{ {
x.store(true,std::memory_order_relaxed); x.store(true, std::memory_order_relaxed);
y.store(true,std::memory_order_relaxed); y.store(true, std::memory_order_relaxed);
} }
void read_y_then_x() void
read_y_then_x()
{ {
while(!y.load(std::memory_order_relaxed)); while (!y.load(std::memory_order_relaxed))
if(x.load(std::memory_order_relaxed)) ;
if (x.load(std::memory_order_relaxed))
++z; ++z;
} }
int main() int
main()
{ {
x=false; x = false;
y=false; y = false;
z=0; z = 0;
std::thread a(write_x_then_y); std::thread a(write_x_then_y);
std::thread b(read_y_then_x); std::thread b(read_y_then_x);
a.join(); a.join();
b.join(); b.join();
assert(z.load()!=0); assert(z.load() != 0);
} }

72
source/listing_5.6.cpp
View File

@@ -1,66 +1,64 @@
#include <thread>
#include <atomic> #include <atomic>
#include <iostream> #include <iostream>
#include <thread>
std::atomic<int> x(0),y(0),z(0); std::atomic<int> x(0), y(0), z(0);
std::atomic<bool> go(false); std::atomic<bool> go(false);
unsigned const loop_count=10; unsigned const loop_count = 10;
struct read_values struct read_values {
{ int x, y, z;
int x,y,z;
}; };
read_values values1[loop_count]; read_values values1[loop_count];
read_values values2[loop_count]; read_values values2[loop_count];
read_values values3[loop_count]; read_values values3[loop_count];
read_values values4[loop_count]; read_values values4[loop_count];
read_values values5[loop_count]; read_values values5[loop_count];
void increment(std::atomic<int>* var_to_inc,read_values* values) void
increment(std::atomic<int>* var_to_inc, read_values* values)
{ {
while(!go) while (!go) std::this_thread::yield();
std::this_thread::yield(); for (unsigned i = 0; i < loop_count; ++i) {
for(unsigned i=0;i<loop_count;++i) values[i].x = x.load(std::memory_order_relaxed);
{ values[i].y = y.load(std::memory_order_relaxed);
values[i].x=x.load(std::memory_order_relaxed); values[i].z = z.load(std::memory_order_relaxed);
values[i].y=y.load(std::memory_order_relaxed); var_to_inc->store(i + 1, std::memory_order_relaxed);
values[i].z=z.load(std::memory_order_relaxed);
var_to_inc->store(i+1,std::memory_order_relaxed);
std::this_thread::yield(); std::this_thread::yield();
} }
} }
void read_vals(read_values* values) void
read_vals(read_values* values)
{ {
while(!go) while (!go) std::this_thread::yield();
std::this_thread::yield(); for (unsigned i = 0; i < loop_count; ++i) {
for(unsigned i=0;i<loop_count;++i) values[i].x = x.load(std::memory_order_relaxed);
{ values[i].y = y.load(std::memory_order_relaxed);
values[i].x=x.load(std::memory_order_relaxed); values[i].z = z.load(std::memory_order_relaxed);
values[i].y=y.load(std::memory_order_relaxed);
values[i].z=z.load(std::memory_order_relaxed);
std::this_thread::yield(); std::this_thread::yield();
} }
} }
void print(read_values* v) void
print(read_values* v)
{ {
for(unsigned i=0;i<loop_count;++i) for (unsigned i = 0; i < loop_count; ++i) {
{ if (i)
if(i) std::cout << ",";
std::cout<<","; std::cout << "(" << v[i].x << "," << v[i].y << "," << v[i].z << ")";
std::cout<<"("<<v[i].x<<","<<v[i].y<<","<<v[i].z<<")";
} }
std::cout<<std::endl; std::cout << std::endl;
} }
int main() int
main()
{ {
std::thread t1(increment,&x,values1); std::thread t1(increment, &x, values1);
std::thread t2(increment,&y,values2); std::thread t2(increment, &y, values2);
std::thread t3(increment,&z,values3); std::thread t3(increment, &z, values3);
std::thread t4(read_vals,values4); std::thread t4(read_vals, values4);
std::thread t5(read_vals,values5); std::thread t5(read_vals, values5);
go=true; go = true;
t5.join(); t5.join();
t4.join(); t4.join();
t3.join(); t3.join();

41
source/listing_5.7.cpp
View File

@@ -1,39 +1,46 @@
#include <assert.h>
#include <atomic> #include <atomic>
#include <thread> #include <thread>
#include <assert.h>
std::atomic<bool> x,y; std::atomic<bool> x, y;
std::atomic<int> z; std::atomic<int> z;
void write_x() void
write_x()
{ {
x.store(true,std::memory_order_release); x.store(true, std::memory_order_release);
} }
void write_y() void
write_y()
{ {
y.store(true,std::memory_order_release); y.store(true, std::memory_order_release);
} }
void read_x_then_y() void
read_x_then_y()
{ {
while(!x.load(std::memory_order_acquire)); while (!x.load(std::memory_order_acquire))
if(y.load(std::memory_order_acquire)) ;
if (y.load(std::memory_order_acquire))
++z; ++z;
} }
void read_y_then_x() void
read_y_then_x()
{ {
while(!y.load(std::memory_order_acquire)); while (!y.load(std::memory_order_acquire))
if(x.load(std::memory_order_acquire)) ;
if (x.load(std::memory_order_acquire))
++z; ++z;
} }
int main() int
main()
{ {
x=false; x = false;
y=false; y = false;
z=0; z = 0;
std::thread a(write_x); std::thread a(write_x);
std::thread b(write_y); std::thread b(write_y);
std::thread c(read_x_then_y); std::thread c(read_x_then_y);
@@ -42,5 +49,5 @@ int main()
b.join(); b.join();
c.join(); c.join();
d.join(); d.join();
assert(z.load()!=0); assert(z.load() != 0);
} }

30
source/listing_5.8.cpp
View File

@@ -1,31 +1,35 @@
#include <assert.h>
#include <atomic> #include <atomic>
#include <thread> #include <thread>
#include <assert.h>
std::atomic<bool> x,y; std::atomic<bool> x, y;
std::atomic<int> z; std::atomic<int> z;
void write_x_then_y() void
write_x_then_y()
{ {
x.store(true,std::memory_order_relaxed); x.store(true, std::memory_order_relaxed);
y.store(true,std::memory_order_release); y.store(true, std::memory_order_release);
} }
void read_y_then_x() void
read_y_then_x()
{ {
while(!y.load(std::memory_order_acquire)); while (!y.load(std::memory_order_acquire))
if(x.load(std::memory_order_relaxed)) ;
if (x.load(std::memory_order_relaxed))
++z; ++z;
} }
int main() int
main()
{ {
x=false; x = false;
y=false; y = false;
z=0; z = 0;
std::thread a(write_x_then_y); std::thread a(write_x_then_y);
std::thread b(read_y_then_x); std::thread b(read_y_then_x);
a.join(); a.join();
b.join(); b.join();
assert(z.load()!=0); assert(z.load() != 0);
} }

44
source/listing_5.9.cpp
View File

@@ -1,37 +1,43 @@
#include <assert.h>
#include <atomic> #include <atomic>
#include <thread> #include <thread>
#include <assert.h>
std::atomic<int> data[5]; std::atomic<int> data[5];
std::atomic<bool> sync1(false),sync2(false); std::atomic<bool> sync1(false), sync2(false);
void thread_1() void
thread_1()
{ {
data[0].store(42,std::memory_order_relaxed); data[0].store(42, std::memory_order_relaxed);
data[1].store(97,std::memory_order_relaxed); data[1].store(97, std::memory_order_relaxed);
data[2].store(17,std::memory_order_relaxed); data[2].store(17, std::memory_order_relaxed);
data[3].store(-141,std::memory_order_relaxed); data[3].store(-141, std::memory_order_relaxed);
data[4].store(2003,std::memory_order_relaxed); data[4].store(2003, std::memory_order_relaxed);
sync1.store(true,std::memory_order_release); sync1.store(true, std::memory_order_release);
} }
void thread_2() void
thread_2()
{ {
while(!sync1.load(std::memory_order_acquire)); while (!sync1.load(std::memory_order_acquire))
;
sync2.store(std::memory_order_release); sync2.store(std::memory_order_release);
} }
void thread_3() void
thread_3()
{ {
while(!sync2.load(std::memory_order_acquire)); while (!sync2.load(std::memory_order_acquire))
assert(data[0].load(std::memory_order_relaxed)==42); ;
assert(data[1].load(std::memory_order_relaxed)==97); assert(data[0].load(std::memory_order_relaxed) == 42);
assert(data[2].load(std::memory_order_relaxed)==17); assert(data[1].load(std::memory_order_relaxed) == 97);
assert(data[3].load(std::memory_order_relaxed)==-141); assert(data[2].load(std::memory_order_relaxed) == 17);
assert(data[4].load(std::memory_order_relaxed)==2003); assert(data[3].load(std::memory_order_relaxed) == -141);
assert(data[4].load(std::memory_order_relaxed) == 2003);
} }
int main() int
main()
{ {
std::thread t1(thread_1); std::thread t1(thread_1);
std::thread t2(thread_2); std::thread t2(thread_2);

34
source/listing_6.1.cpp
View File

@@ -1,28 +1,24 @@
#include <exception> #include <exception>
#include <stack>
#include <mutex>
#include <memory> #include <memory>
#include <mutex>
#include <stack>
struct empty_stack: std::exception struct empty_stack : std::exception {
{ const char* what() const throw() { return "empty stack"; }
const char* what() const throw()
{
return "empty stack";
}
}; };
template<typename T> template <typename T>
class threadsafe_stack class threadsafe_stack {
{
private: private:
std::stack<T> data; std::stack<T> data;
mutable std::mutex m; mutable std::mutex m;
public: public:
threadsafe_stack(){} threadsafe_stack() {}
threadsafe_stack(const threadsafe_stack& other) threadsafe_stack(const threadsafe_stack& other)
{ {
std::lock_guard<std::mutex> lock(other.m); std::lock_guard<std::mutex> lock(other.m);
data=other.data; data = other.data;
} }
threadsafe_stack& operator=(const threadsafe_stack&) = delete; threadsafe_stack& operator=(const threadsafe_stack&) = delete;
@@ -34,17 +30,18 @@ public:
std::shared_ptr<T> pop() std::shared_ptr<T> pop()
{ {
std::lock_guard<std::mutex> lock(m); std::lock_guard<std::mutex> lock(m);
if(data.empty()) throw empty_stack(); if (data.empty())
std::shared_ptr<T> const res( throw empty_stack();
std::make_shared<T>(std::move(data.top()))); std::shared_ptr<T> const res(std::make_shared<T>(std::move(data.top())));
data.pop(); data.pop();
return res; return res;
} }
void pop(T& value) void pop(T& value)
{ {
std::lock_guard<std::mutex> lock(m); std::lock_guard<std::mutex> lock(m);
if(data.empty()) throw empty_stack(); if (data.empty())
value=std::move(data.top()); throw empty_stack();
value = std::move(data.top());
data.pop(); data.pop();
} }
bool empty() const bool empty() const
@@ -53,4 +50,3 @@ public:
return data.empty(); return data.empty();
} }
}; };

21
source/listing_6.10.cpp
View File

@@ -1,12 +1,10 @@
template<typename T> template <typename T>
class threadsafe_queue class threadsafe_queue {
{
private: private:
std::unique_ptr<node> try_pop_head() std::unique_ptr<node> try_pop_head()
{ {
std::lock_guard<std::mutex> head_lock(head_mutex); std::lock_guard<std::mutex> head_lock(head_mutex);
if(head.get()==get_tail()) if (head.get() == get_tail()) {
{
return std::unique_ptr<node>(); return std::unique_ptr<node>();
} }
return pop_head(); return pop_head();
@@ -15,30 +13,29 @@ private:
std::unique_ptr<node> try_pop_head(T& value) std::unique_ptr<node> try_pop_head(T& value)
{ {
std::lock_guard<std::mutex> head_lock(head_mutex); std::lock_guard<std::mutex> head_lock(head_mutex);
if(head.get()==get_tail()) if (head.get() == get_tail()) {
{
return std::unique_ptr<node>(); return std::unique_ptr<node>();
} }
value=std::move(*head->data); value = std::move(*head->data);
return pop_head(); return pop_head();
} }
public: public:
std::shared_ptr<T> try_pop() std::shared_ptr<T> try_pop()
{ {
std::unique_ptr<node> const old_head=try_pop_head(); std::unique_ptr<node> const old_head = try_pop_head();
return old_head?old_head->data:std::shared_ptr<T>(); return old_head ? old_head->data : std::shared_ptr<T>();
} }
bool try_pop(T& value) bool try_pop(T& value)
{ {
std::unique_ptr<node> const old_head=try_pop_head(value); std::unique_ptr<node> const old_head = try_pop_head(value);
return old_head; return old_head;
} }
void empty() void empty()
{ {
std::lock_guard<std::mutex> head_lock(head_mutex); std::lock_guard<std::mutex> head_lock(head_mutex);
return (head==get_tail()); return (head == get_tail());
} }
}; };

95
source/listing_6.11.cpp
View File

@@ -1,19 +1,17 @@
#include <vector> #include <boost/thread/shared_mutex.hpp>
#include <memory>
#include <mutex>
#include <functional> #include <functional>
#include <list> #include <list>
#include <memory>
#include <mutex>
#include <utility> #include <utility>
#include <boost/thread/shared_mutex.hpp> #include <vector>
template<typename Key,typename Value,typename Hash=std::hash<Key> > template <typename Key, typename Value, typename Hash = std::hash<Key>>
class threadsafe_lookup_table class threadsafe_lookup_table {
{
private: private:
class bucket_type class bucket_type {
{
private: private:
typedef std::pair<Key,Value> bucket_value; typedef std::pair<Key, Value> bucket_value;
typedef std::list<bucket_value> bucket_data; typedef std::list<bucket_value> bucket_data;
typedef typename bucket_data::iterator bucket_iterator; typedef typename bucket_data::iterator bucket_iterator;
@@ -22,50 +20,48 @@ private:
bucket_iterator find_entry_for(Key const& key) const bucket_iterator find_entry_for(Key const& key) const
{ {
return std::find_if(data.begin(),data.end(), return std::find_if(
[&](bucket_value const& item) data.begin(), data.end(), [&](bucket_value const& item) {
{return item.first==key;}); return item.first == key;
} });
public:
Value value_for(Key const& key,Value const& default_value) const
{
boost::shared_lock<boost::shared_mutex> lock(mutex);
bucket_iterator const found_entry=find_entry_for(key);
return (found_entry==data.end())?
default_value : found_entry->second;
} }
void add_or_update_mapping(Key const& key,Value const& value) public:
Value value_for(Key const& key, Value const& default_value) const
{
boost::shared_lock<boost::shared_mutex> lock(mutex);
bucket_iterator const found_entry = find_entry_for(key);
return (found_entry == data.end()) ? default_value : found_entry->second;
}
void add_or_update_mapping(Key const& key, Value const& value)
{ {
std::unique_lock<boost::shared_mutex> lock(mutex); std::unique_lock<boost::shared_mutex> lock(mutex);
bucket_iterator const found_entry=find_entry_for(key); bucket_iterator const found_entry = find_entry_for(key);
if(found_entry==data.end()) if (found_entry == data.end()) {
{ data.push_back(bucket_value(key, value));
data.push_back(bucket_value(key,value));
} }
else else {
{ found_entry->second = value;
found_entry->second=value;
} }
} }
void remove_mapping(Key const& key) void remove_mapping(Key const& key)
{ {
std::unique_lock<boost::shared_mutex> lock(mutex); std::unique_lock<boost::shared_mutex> lock(mutex);
bucket_iterator const found_entry=find_entry_for(key); bucket_iterator const found_entry = find_entry_for(key);
if(found_entry!=data.end()) if (found_entry != data.end()) {
{
data.erase(found_entry); data.erase(found_entry);
} }
} }
}; };
std::vector<std::unique_ptr<bucket_type> > buckets; std::vector<std::unique_ptr<bucket_type>> buckets;
Hash hasher; Hash hasher;
bucket_type& get_bucket(Key const& key) const bucket_type& get_bucket(Key const& key) const
{ {
std::size_t const bucket_index=hasher(key)%buckets.size(); std::size_t const bucket_index = hasher(key) % buckets.size();
return *buckets[bucket_index]; return *buckets[bucket_index];
} }
@@ -74,35 +70,28 @@ public:
typedef Value mapped_type; typedef Value mapped_type;
typedef Hash hash_type; typedef Hash hash_type;
threadsafe_lookup_table( threadsafe_lookup_table(unsigned num_buckets = 19,
unsigned num_buckets=19, Hash const& hasher_=Hash()): Hash const& hasher_ = Hash())
buckets(num_buckets),hasher(hasher_) : buckets(num_buckets), hasher(hasher_)
{
for(unsigned i=0;i<num_buckets;++i)
{ {
for (unsigned i = 0; i < num_buckets; ++i) {
buckets[i].reset(new bucket_type); buckets[i].reset(new bucket_type);
} }
} }
threadsafe_lookup_table(threadsafe_lookup_table const& other)=delete; threadsafe_lookup_table(threadsafe_lookup_table const& other) = delete;
threadsafe_lookup_table& operator=( threadsafe_lookup_table& operator=(threadsafe_lookup_table const& other) =
threadsafe_lookup_table const& other)=delete; delete;
Value value_for(Key const& key, Value value_for(Key const& key, Value const& default_value = Value()) const
Value const& default_value=Value()) const
{ {
return get_bucket(key).value_for(key,default_value); return get_bucket(key).value_for(key, default_value);
} }
void add_or_update_mapping(Key const& key,Value const& value) void add_or_update_mapping(Key const& key, Value const& value)
{ {
get_bucket(key).add_or_update_mapping(key,value); get_bucket(key).add_or_update_mapping(key, value);
} }
void remove_mapping(Key const& key) void remove_mapping(Key const& key) { get_bucket(key).remove_mapping(key); }
{
get_bucket(key).remove_mapping(key);
}
}; };

23
source/listing_6.12.cpp
View File

@@ -1,18 +1,15 @@
std::map<Key,Value> threadsafe_lookup_table::get_map() const std::map<Key, Value>
threadsafe_lookup_table::get_map() const
{ {
std::vector<std::unique_lock<boost::shared_mutex> > locks; std::vector<std::unique_lock<boost::shared_mutex>> locks;
for(unsigned i=0;i<buckets.size();++i) for (unsigned i = 0; i < buckets.size(); ++i) {
{ locks.push_back(std::unique_lock<boost::shared_mutex>(buckets[i].mutex));
locks.push_back(
std::unique_lock<boost::shared_mutex>(buckets[i].mutex));
} }
std::map<Key,Value> res; std::map<Key, Value> res;
for(unsigned i=0;i<buckets.size();++i) for (unsigned i = 0; i < buckets.size(); ++i) {
{ for (bucket_iterator it = buckets[i].data.begin();
for(bucket_iterator it=buckets[i].data.begin(); it != buckets[i].data.end();
it!=buckets[i].data.end(); ++it) {
++it)
{
res.insert(*it); res.insert(*it);
} }
} }

76
source/listing_6.13.cpp
View File

@@ -1,101 +1,87 @@
#include <memory> #include <memory>
#include <mutex> #include <mutex>
template<typename T> template <typename T>
class threadsafe_list class threadsafe_list {
{ struct node {
struct node
{
std::mutex m; std::mutex m;
std::shared_ptr<T> data; std::shared_ptr<T> data;
std::unique_ptr<node> next; std::unique_ptr<node> next;
node(): node() : next() {}
next()
{}
node(T const& value): node(T const& value) : data(std::make_shared<T>(value)) {}
data(std::make_shared<T>(value))
{}
}; };
node head; node head;
public: public:
threadsafe_list() threadsafe_list() {}
{}
~threadsafe_list() ~threadsafe_list()
{ {
remove_if([](T const&){return true;}); remove_if([](T const&) { return true; });
} }
threadsafe_list(threadsafe_list const& other)=delete; threadsafe_list(threadsafe_list const& other) = delete;
threadsafe_list& operator=(threadsafe_list const& other)=delete; threadsafe_list& operator=(threadsafe_list const& other) = delete;
void push_front(T const& value) void push_front(T const& value)
{ {
std::unique_ptr<node> new_node(new node(value)); std::unique_ptr<node> new_node(new node(value));
std::lock_guard<std::mutex> lk(head.m); std::lock_guard<std::mutex> lk(head.m);
new_node->next=std::move(head.next); new_node->next = std::move(head.next);
head.next=std::move(new_node); head.next = std::move(new_node);
} }
template<typename Function> template <typename Function>
void for_each(Function f) void for_each(Function f)
{ {
node* current=&head; node* current = &head;
std::unique_lock<std::mutex> lk(head.m); std::unique_lock<std::mutex> lk(head.m);
while(node* const next=current->next.get()) while (node* const next = current->next.get()) {
{
std::unique_lock<std::mutex> next_lk(next->m); std::unique_lock<std::mutex> next_lk(next->m);
lk.unlock(); lk.unlock();
f(*next->data); f(*next->data);
current=next; current = next;
lk=std::move(next_lk); lk = std::move(next_lk);
} }
} }
template<typename Predicate> template <typename Predicate>
std::shared_ptr<T> find_first_if(Predicate p) std::shared_ptr<T> find_first_if(Predicate p)
{ {
node* current=&head; node* current = &head;
std::unique_lock<std::mutex> lk(head.m); std::unique_lock<std::mutex> lk(head.m);
while(node* const next=current->next.get()) while (node* const next = current->next.get()) {
{
std::unique_lock<std::mutex> next_lk(next->m); std::unique_lock<std::mutex> next_lk(next->m);
lk.unlock(); lk.unlock();
if(p(*next->data)) if (p(*next->data)) {
{
return next->data; return next->data;
} }
current=next; current = next;
lk=std::move(next_lk); lk = std::move(next_lk);
} }
return std::shared_ptr<T>(); return std::shared_ptr<T>();
} }
template<typename Predicate> template <typename Predicate>
void remove_if(Predicate p) void remove_if(Predicate p)
{ {
node* current=&head; node* current = &head;
std::unique_lock<std::mutex> lk(head.m); std::unique_lock<std::mutex> lk(head.m);
while(node* const next=current->next.get()) while (node* const next = current->next.get()) {
{
std::unique_lock<std::mutex> next_lk(next->m); std::unique_lock<std::mutex> next_lk(next->m);
if(p(*next->data)) if (p(*next->data)) {
{ std::unique_ptr<node> old_next = std::move(current->next);
std::unique_ptr<node> old_next=std::move(current->next); current->next = std::move(next->next);
current->next=std::move(next->next);
next_lk.unlock(); next_lk.unlock();
} }
else else {
{
lk.unlock(); lk.unlock();
current=next; current = next;
lk=std::move(next_lk); lk = std::move(next_lk);
} }
} }
} }
}; };

34
source/listing_6.2.cpp
View File

@@ -1,18 +1,17 @@
#include <queue>
#include <mutex>
#include <condition_variable> #include <condition_variable>
#include <memory> #include <memory>
#include <mutex>
#include <queue>
template<typename T> template <typename T>
class threadsafe_queue class threadsafe_queue {
{
private: private:
mutable std::mutex mut; mutable std::mutex mut;
std::queue<T> data_queue; std::queue<T> data_queue;
std::condition_variable data_cond; std::condition_variable data_cond;
public: public:
threadsafe_queue() threadsafe_queue() {}
{}
void push(T new_value) void push(T new_value)
{ {
@@ -24,17 +23,16 @@ public:
void wait_and_pop(T& value) void wait_and_pop(T& value)
{ {
std::unique_lock<std::mutex> lk(mut); std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk,[this]{return !data_queue.empty();}); data_cond.wait(lk, [this] { return !data_queue.empty(); });
value=std::move(data_queue.front()); value = std::move(data_queue.front());
data_queue.pop(); data_queue.pop();
} }
std::shared_ptr<T> wait_and_pop() std::shared_ptr<T> wait_and_pop()
{ {
std::unique_lock<std::mutex> lk(mut); std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk,[this]{return !data_queue.empty();}); data_cond.wait(lk, [this] { return !data_queue.empty(); });
std::shared_ptr<T> res( std::shared_ptr<T> res(std::make_shared<T>(std::move(data_queue.front())));
std::make_shared<T>(std::move(data_queue.front())));
data_queue.pop(); data_queue.pop();
return res; return res;
} }
@@ -42,19 +40,18 @@ public:
bool try_pop(T& value) bool try_pop(T& value)
{ {
std::lock_guard<std::mutex> lk(mut); std::lock_guard<std::mutex> lk(mut);
if(data_queue.empty()) if (data_queue.empty())
return false; return false;
value=std::move(data_queue.front()); value = std::move(data_queue.front());
data_queue.pop(); data_queue.pop();
} }
std::shared_ptr<T> try_pop() std::shared_ptr<T> try_pop()
{ {
std::lock_guard<std::mutex> lk(mut); std::lock_guard<std::mutex> lk(mut);
if(data_queue.empty()) if (data_queue.empty())
return std::shared_ptr<T>(); return std::shared_ptr<T>();
std::shared_ptr<T> res( std::shared_ptr<T> res(std::make_shared<T>(std::move(data_queue.front())));
std::make_shared<T>(std::move(data_queue.front())));
data_queue.pop(); data_queue.pop();
return res; return res;
} }
@@ -66,7 +63,8 @@ public:
} }
}; };
int main() int
main()
{ {
threadsafe_queue<int> rq; threadsafe_queue<int> rq;
} }

35
source/listing_6.3.cpp
View File

@@ -1,41 +1,40 @@
#include <queue>
#include <mutex>
#include <condition_variable> #include <condition_variable>
#include <memory> #include <memory>
#include <mutex>
#include <queue>
template<typename T> template <typename T>
class threadsafe_queue class threadsafe_queue {
{
private: private:
mutable std::mutex mut; mutable std::mutex mut;
std::queue<std::shared_ptr<T> > data_queue; std::queue<std::shared_ptr<T>> data_queue;
std::condition_variable data_cond; std::condition_variable data_cond;
public: public:
threadsafe_queue() threadsafe_queue() {}
{}
void wait_and_pop(T& value) void wait_and_pop(T& value)
{ {
std::unique_lock<std::mutex> lk(mut); std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk,[this]{return !data_queue.empty();}); data_cond.wait(lk, [this] { return !data_queue.empty(); });
value=std::move(*data_queue.front()); value = std::move(*data_queue.front());
data_queue.pop(); data_queue.pop();
} }
bool try_pop(T& value) bool try_pop(T& value)
{ {
std::lock_guard<std::mutex> lk(mut); std::lock_guard<std::mutex> lk(mut);
if(data_queue.empty()) if (data_queue.empty())
return false; return false;
value=std::move(*data_queue.front()); value = std::move(*data_queue.front());
data_queue.pop(); data_queue.pop();
} }
std::shared_ptr<T> wait_and_pop() std::shared_ptr<T> wait_and_pop()
{ {
std::unique_lock<std::mutex> lk(mut); std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk,[this]{return !data_queue.empty();}); data_cond.wait(lk, [this] { return !data_queue.empty(); });
std::shared_ptr<T> res=data_queue.front(); std::shared_ptr<T> res = data_queue.front();
data_queue.pop(); data_queue.pop();
return res; return res;
} }
@@ -43,9 +42,9 @@ public:
std::shared_ptr<T> try_pop() std::shared_ptr<T> try_pop()
{ {
std::lock_guard<std::mutex> lk(mut); std::lock_guard<std::mutex> lk(mut);
if(data_queue.empty()) if (data_queue.empty())
return std::shared_ptr<T>(); return std::shared_ptr<T>();
std::shared_ptr<T> res=data_queue.front(); std::shared_ptr<T> res = data_queue.front();
data_queue.pop(); data_queue.pop();
return res; return res;
} }
@@ -58,11 +57,9 @@ public:
void push(T new_value) void push(T new_value)
{ {
std::shared_ptr<T> data( std::shared_ptr<T> data(std::make_shared<T>(std::move(new_value)));
std::make_shared<T>(std::move(new_value)));
std::lock_guard<std::mutex> lk(mut); std::lock_guard<std::mutex> lk(mut);
data_queue.push(data); data_queue.push(data);
data_cond.notify_one(); data_cond.notify_one();
} }
}; };

45
source/listing_6.4.cpp
View File

@@ -1,56 +1,45 @@
#include <memory> #include <memory>
template<typename T> template <typename T>
class queue class queue {
{
private: private:
struct node struct node {
{
T data; T data;
std::unique_ptr<node> next; std::unique_ptr<node> next;
node(T data_): node(T data_) : data(std::move(data_)) {}
data(std::move(data_))
{}
}; };
std::unique_ptr<node> head; std::unique_ptr<node> head;
node* tail; node* tail;
public: public:
queue(): queue() : tail(nullptr) {}
tail(nullptr)
{}
queue(const queue& other)=delete; queue(const queue& other) = delete;
queue& operator=(const queue& other)=delete; queue& operator=(const queue& other) = delete;
std::shared_ptr<T> try_pop() std::shared_ptr<T> try_pop()
{ {
if(!head) if (!head) {
{
return std::shared_ptr<T>(); return std::shared_ptr<T>();
} }
std::shared_ptr<T> const res( std::shared_ptr<T> const res(std::make_shared<T>(std::move(head->data)));
std::make_shared<T>(std::move(head->data))); std::unique_ptr<node> const old_head = std::move(head);
std::unique_ptr<node> const old_head=std::move(head); head = std::move(old_head->next);
head=std::move(old_head->next);
return res; return res;
} }
void push(T new_value) void push(T new_value)
{ {
std::unique_ptr<node> p(new node(std::move(new_value))); std::unique_ptr<node> p(new node(std::move(new_value)));
node* const new_tail=p.get(); node* const new_tail = p.get();
if(tail) if (tail) {
{ tail->next = std::move(p);
tail->next=std::move(p);
} }
else else {
{ head = std::move(p);
head=std::move(p);
} }
tail=new_tail; tail = new_tail;
} }
}; };

35
source/listing_6.5.cpp
View File

@@ -1,10 +1,8 @@
#include <memory> #include <memory>
template<typename T> template <typename T>
class queue class queue {
{
private: private:
struct node struct node {
{
std::shared_ptr<T> data; std::shared_ptr<T> data;
std::unique_ptr<node> next; std::unique_ptr<node> next;
}; };
@@ -13,34 +11,29 @@ private:
node* tail; node* tail;
public: public:
queue(): queue() : head(new node), tail(head.get()) {}
head(new node),tail(head.get())
{}
queue(const queue& other)=delete; queue(const queue& other) = delete;
queue& operator=(const queue& other)=delete; queue& operator=(const queue& other) = delete;
std::shared_ptr<T> try_pop() std::shared_ptr<T> try_pop()
{ {
if(head.get()==tail) if (head.get() == tail) {
{
return std::shared_ptr<T>(); return std::shared_ptr<T>();
} }
std::shared_ptr<T> const res(head->data); std::shared_ptr<T> const res(head->data);
std::unique_ptr<node> const old_head=std::move(head); std::unique_ptr<node> const old_head = std::move(head);
head=std::move(old_head->next); head = std::move(old_head->next);
return res; return res;
} }
void push(T new_value) void push(T new_value)
{ {
std::shared_ptr<T> new_data( std::shared_ptr<T> new_data(std::make_shared<T>(std::move(new_value)));
std::make_shared<T>(std::move(new_value)));
std::unique_ptr<node> p(new node); std::unique_ptr<node> p(new node);
tail->data=new_data; tail->data = new_data;
node* const new_tail=p.get(); node* const new_tail = p.get();
tail->next=std::move(p); tail->next = std::move(p);
tail=new_tail; tail = new_tail;
} }
}; };

40
source/listing_6.6.cpp
View File

@@ -1,12 +1,10 @@
#include <memory> #include <memory>
#include <mutex> #include <mutex>
template<typename T> template <typename T>
class threadsafe_queue class threadsafe_queue {
{
private: private:
struct node struct node {
{
std::shared_ptr<T> data; std::shared_ptr<T> data;
std::unique_ptr<node> next; std::unique_ptr<node> next;
}; };
@@ -25,40 +23,34 @@ private:
std::unique_ptr<node> pop_head() std::unique_ptr<node> pop_head()
{ {
std::lock_guard<std::mutex> head_lock(head_mutex); std::lock_guard<std::mutex> head_lock(head_mutex);
if(head.get()==get_tail()) if (head.get() == get_tail()) {
{
return nullptr; return nullptr;
} }
std::unique_ptr<node> const old_head=std::move(head); std::unique_ptr<node> const old_head = std::move(head);
head=std::move(old_head->next); head = std::move(old_head->next);
return old_head; return old_head;
} }
public: public:
threadsafe_queue(): threadsafe_queue() : head(new node), tail(head.get()) {}
head(new node),tail(head.get())
{}
threadsafe_queue(const threadsafe_queue& other)=delete; threadsafe_queue(const threadsafe_queue& other) = delete;
threadsafe_queue& operator=(const threadsafe_queue& other)=delete; threadsafe_queue& operator=(const threadsafe_queue& other) = delete;
std::shared_ptr<T> try_pop() std::shared_ptr<T> try_pop()
{ {
std::unique_ptr<node> old_head=pop_head(); std::unique_ptr<node> old_head = pop_head();
return old_head?old_head->data:std::shared_ptr<T>(); return old_head ? old_head->data : std::shared_ptr<T>();
} }
void push(T new_value) void push(T new_value)
{ {
std::shared_ptr<T> new_data( std::shared_ptr<T> new_data(std::make_shared<T>(std::move(new_value)));
std::make_shared<T>(std::move(new_value)));
std::unique_ptr<node> p(new node); std::unique_ptr<node> p(new node);
node* const new_tail=p.get(); node* const new_tail = p.get();
std::lock_guard<std::mutex> tail_lock(tail_mutex); std::lock_guard<std::mutex> tail_lock(tail_mutex);
tail->data=new_data; tail->data = new_data;
tail->next=std::move(p); tail->next = std::move(p);
tail=new_tail; tail = new_tail;
} }
}; };

17
source/listing_6.7.cpp
View File

@@ -1,9 +1,7 @@
template<typename T> template <typename T>
class threadsafe_queue class threadsafe_queue {
{
private: private:
struct node struct node {
{
std::shared_ptr<T> data; std::shared_ptr<T> data;
std::unique_ptr<node> next; std::unique_ptr<node> next;
}; };
@@ -13,12 +11,11 @@ private:
std::mutex tail_mutex; std::mutex tail_mutex;
node* tail; node* tail;
std::condition_variable data_cond; std::condition_variable data_cond;
public: public:
threadsafe_queue(): threadsafe_queue() : head(new node), tail(head.get()) {}
head(new node),tail(head.get()) threadsafe_queue(const threadsafe_queue& other) = delete;
{} threadsafe_queue& operator=(const threadsafe_queue& other) = delete;
threadsafe_queue(const threadsafe_queue& other)=delete;
threadsafe_queue& operator=(const threadsafe_queue& other)=delete;
std::shared_ptr<T> try_pop(); std::shared_ptr<T> try_pop();
bool try_pop(T& value); bool try_pop(T& value);

16
source/listing_6.8.cpp
View File

@@ -1,15 +1,15 @@
template<typename T> template <typename T>
void threadsafe_queue<T>::push(T new_value) void
threadsafe_queue<T>::push(T new_value)
{ {
std::shared_ptr<T> new_data( std::shared_ptr<T> new_data(std::make_shared<T>(std::move(new_value)));
std::make_shared<T>(std::move(new_value)));
std::unique_ptr<node> p(new node); std::unique_ptr<node> p(new node);
{ {
std::lock_guard<std::mutex> tail_lock(tail_mutex); std::lock_guard<std::mutex> tail_lock(tail_mutex);
tail->data=new_data; tail->data = new_data;
node* const new_tail=p.get(); node* const new_tail = p.get();
tail->next=std::move(p); tail->next = std::move(p);
tail=new_tail; tail = new_tail;
} }
data_cond.notify_one(); data_cond.notify_one();
} }

17
source/listing_6.9.cpp
View File

@@ -1,6 +1,5 @@
template<typename T> template <typename T>
class threadsafe_queue class threadsafe_queue {
{
private: private:
node* get_tail() node* get_tail()
{ {
@@ -10,15 +9,15 @@ private:
std::unique_ptr<node> pop_head() std::unique_ptr<node> pop_head()
{ {
std::unique_ptr<node> const old_head=std::move(head); std::unique_ptr<node> const old_head = std::move(head);
head=std::move(old_head->next); head = std::move(old_head->next);
return old_head; return old_head;
} }
std::unique_lock<std::mutex> wait_for_data() std::unique_lock<std::mutex> wait_for_data()
{ {
std::unique_lock<std::mutex> head_lock(head_mutex); std::unique_lock<std::mutex> head_lock(head_mutex);
data_cond.wait(head_lock,[&]{return head!=get_tail();}); data_cond.wait(head_lock, [&] { return head != get_tail(); });
return std::move(head_lock); return std::move(head_lock);
} }
@@ -31,19 +30,19 @@ private:
std::unique_ptr<node> wait_pop_head(T& value) std::unique_ptr<node> wait_pop_head(T& value)
{ {
std::unique_lock<std::mutex> head_lock(wait_for_data()); std::unique_lock<std::mutex> head_lock(wait_for_data());
value=std::move(*head->data); value = std::move(*head->data);
return pop_head(); return pop_head();
} }
public: public:
std::shared_ptr<T> wait_and_pop() std::shared_ptr<T> wait_and_pop()
{ {
std::unique_ptr<node> const old_head=wait_pop_head(); std::unique_ptr<node> const old_head = wait_pop_head();
return old_head->data; return old_head->data;
} }
void wait_and_pop(T& value) void wait_and_pop(T& value)
{ {
std::unique_ptr<node> const old_head=wait_pop_head(value); std::unique_ptr<node> const old_head = wait_pop_head(value);
} }
}; };

16
source/listing_7.1.cpp
View File

@@ -1,18 +1,14 @@
#include <atomic> #include <atomic>
class spinlock_mutex class spinlock_mutex {
{
std::atomic_flag flag; std::atomic_flag flag;
public: public:
spinlock_mutex(): spinlock_mutex() : flag(ATOMIC_FLAG_INIT) {}
flag(ATOMIC_FLAG_INIT)
{}
void lock() void lock()
{ {
while(flag.test_and_set(std::memory_order_acquire)); while (flag.test_and_set(std::memory_order_acquire))
} ;
void unlock()
{
flag.clear(std::memory_order_release);
} }
void unlock() { flag.clear(std::memory_order_release); }
}; };

31
source/listing_7.10.cpp
View File

@@ -1,38 +1,37 @@
#include <atomic> #include <atomic>
#include <memory> #include <memory>
template<typename T> template <typename T>
class lock_free_stack class lock_free_stack {
{
private: private:
struct node; struct node;
struct counted_node_ptr struct counted_node_ptr {
{
int external_count; int external_count;
node* ptr; node* ptr;
}; };
struct node struct node {
{
std::shared_ptr<T> data; std::shared_ptr<T> data;
std::atomic<int> internal_count; std::atomic<int> internal_count;
counted_node_ptr next; counted_node_ptr next;
node(T const& data_): node(T const& data_) : data(std::make_shared<T>(data_)), internal_count(0)
data(std::make_shared<T>(data_)), {
internal_count(0) }
{}
}; };
std::atomic<counted_node_ptr> head; std::atomic<counted_node_ptr> head;
public: public:
~lock_free_stack() ~lock_free_stack()
{ {
while(pop()); while (pop())
;
} }
void push(T const& data) void push(T const& data)
{ {
counted_node_ptr new_node; counted_node_ptr new_node;
new_node.ptr=new node(data); new_node.ptr = new node(data);
new_node.external_count=1; new_node.external_count = 1;
new_node.ptr->next=head.load(); new_node.ptr->next = head.load();
while(!head.compare_exchange_weak(new_node.ptr->next,new_node)); while (!head.compare_exchange_weak(new_node.ptr->next, new_node))
;
} }
}; };

38
source/listing_7.11.cpp
View File

@@ -1,44 +1,36 @@
template<typename T> template <typename T>
class lock_free_stack class lock_free_stack {
{
private: private:
void increase_head_count(counted_node_ptr& old_counter) void increase_head_count(counted_node_ptr& old_counter)
{ {
counted_node_ptr new_counter; counted_node_ptr new_counter;
do do {
{ new_counter = old_counter;
new_counter=old_counter;
++new_counter.external_count; ++new_counter.external_count;
} while (!head.compare_exchange_strong(old_counter, new_counter));
old_counter.external_count = new_counter.external_count;
} }
while(!head.compare_exchange_strong(old_counter,new_counter));
old_counter.external_count=new_counter.external_count;
}
public: public:
std::shared_ptr<T> pop() std::shared_ptr<T> pop()
{ {
counted_node_ptr old_head=head.load(); counted_node_ptr old_head = head.load();
for(;;) for (;;) {
{
increase_head_count(old_head); increase_head_count(old_head);
node* const ptr=old_head.ptr; node* const ptr = old_head.ptr;
if(!ptr) if (!ptr) {
{
return std::shared_ptr<T>(); return std::shared_ptr<T>();
} }
if(head.compare_exchange_strong(old_head,ptr->next)) if (head.compare_exchange_strong(old_head, ptr->next)) {
{
std::shared_ptr<T> res; std::shared_ptr<T> res;
res.swap(ptr->data); res.swap(ptr->data);
int const count_increase=old_head.external_count-2; int const count_increase = old_head.external_count - 2;
if(ptr->internal_count.fetch_add(count_increase)== if (ptr->internal_count.fetch_add(count_increase) == -count_increase) {
-count_increase)
{
delete ptr; delete ptr;
} }
return res; return res;
} }
else if(ptr->internal_count.fetch_sub(1)==1) else if (ptr->internal_count.fetch_sub(1) == 1) {
{
delete ptr; delete ptr;
} }
} }

72
source/listing_7.12.cpp
View File

@@ -1,85 +1,75 @@
#include <atomic> #include <atomic>
#include <memory> #include <memory>
template<typename T> template <typename T>
class lock_free_stack class lock_free_stack {
{
private: private:
struct node; struct node;
struct counted_node_ptr struct counted_node_ptr {
{
int external_count; int external_count;
node* ptr; node* ptr;
}; };
struct node struct node {
{
std::shared_ptr<T> data; std::shared_ptr<T> data;
std::atomic<int> internal_count; std::atomic<int> internal_count;
counted_node_ptr next; counted_node_ptr next;
node(T const& data_): node(T const& data_) : data(std::make_shared<T>(data_)), internal_count(0)
data(std::make_shared<T>(data_)), {
internal_count(0) }
{}
}; };
std::atomic<counted_node_ptr> head; std::atomic<counted_node_ptr> head;
void increase_head_count(counted_node_ptr& old_counter) void increase_head_count(counted_node_ptr& old_counter)
{ {
counted_node_ptr new_counter; counted_node_ptr new_counter;
do do {
{ new_counter = old_counter;
new_counter=old_counter;
++new_counter.external_count; ++new_counter.external_count;
} } while (!head.compare_exchange_strong(old_counter,
while(!head.compare_exchange_strong( new_counter,
old_counter,new_counter,
std::memory_order_acquire, std::memory_order_acquire,
std::memory_order_relaxed)); std::memory_order_relaxed));
old_counter.external_count=new_counter.external_count; old_counter.external_count = new_counter.external_count;
} }
public: public:
~lock_free_stack() ~lock_free_stack()
{ {
while(pop()); while (pop())
;
} }
void push(T const& data) void push(T const& data)
{ {
counted_node_ptr new_node; counted_node_ptr new_node;
new_node.ptr=new node(data); new_node.ptr = new node(data);
new_node.external_count=1; new_node.external_count = 1;
new_node.ptr->next=head.load(std::memory_order_relaxed) new_node.ptr->next = head.load(std::memory_order_relaxed) while (
while(!head.compare_exchange_weak( !head.compare_exchange_weak(new_node.ptr->next,
new_node.ptr->next,new_node, new_node,
std::memory_order_release, std::memory_order_release,
std::memory_order_relaxed)); std::memory_order_relaxed));
} }
std::shared_ptr<T> pop() std::shared_ptr<T> pop()
{ {
counted_node_ptr old_head= counted_node_ptr old_head = head.load(std::memory_order_relaxed);
head.load(std::memory_order_relaxed); for (;;) {
for(;;)
{
increase_head_count(old_head); increase_head_count(old_head);
node* const ptr=old_head.ptr; node* const ptr = old_head.ptr;
if(!ptr) if (!ptr) {
{
return std::shared_ptr<T>(); return std::shared_ptr<T>();
} }
if(head.compare_exchange_strong( if (head.compare_exchange_strong(
old_head,ptr->next,std::memory_order_relaxed)) old_head, ptr->next, std::memory_order_relaxed)) {
{
std::shared_ptr<T> res; std::shared_ptr<T> res;
res.swap(ptr->data); res.swap(ptr->data);
int const count_increase=old_head.external_count-2; int const count_increase = old_head.external_count - 2;
if(ptr->internal_count.fetch_add( if (ptr->internal_count.fetch_add(
count_increase,std::memory_order_release)==-count_increase) count_increase, std::memory_order_release) == -count_increase) {
{
delete ptr; delete ptr;
} }
return res; return res;
} }
else if(ptr->internal_count.fetch_add( else if (ptr->internal_count.fetch_add(-1, std::memory_order_relaxed) ==
-1,std::memory_order_relaxed)==1) 1) {
{
ptr->internal_count.load(std::memory_order_acquire); ptr->internal_count.load(std::memory_order_acquire);
delete ptr; delete ptr;
} }

42
source/listing_7.13.cpp
View File

@@ -1,49 +1,41 @@
#include <memory>
#include <atomic> #include <atomic>
#include <memory>
template<typename T> template <typename T>
class lock_free_queue class lock_free_queue {
{
private: private:
struct node struct node {
{
std::shared_ptr<T> data; std::shared_ptr<T> data;
node* next; node* next;
node(): node() : next(nullptr) {}
next(nullptr)
{}
}; };
std::atomic<node*> head; std::atomic<node*> head;
std::atomic<node*> tail; std::atomic<node*> tail;
node* pop_head() node* pop_head()
{ {
node* const old_head=head.load(); node* const old_head = head.load();
if(old_head==tail.load()) if (old_head == tail.load()) {
{
return nullptr; return nullptr;
} }
head.store(old_head->next); head.store(old_head->next);
return old_head; return old_head;
} }
public: public:
lock_free_queue(): lock_free_queue() : head(new node), tail(head.load()) {}
head(new node),tail(head.load()) lock_free_queue(const lock_free_queue& other) = delete;
{} lock_free_queue& operator=(const lock_free_queue& other) = delete;
lock_free_queue(const lock_free_queue& other)=delete;
lock_free_queue& operator=(const lock_free_queue& other)=delete;
~lock_free_queue() ~lock_free_queue()
{ {
while(node* const old_head=head.load()) while (node* const old_head = head.load()) {
{
head.store(old_head->next); head.store(old_head->next);
delete old_head; delete old_head;
} }
} }
std::shared_ptr<T> pop() std::shared_ptr<T> pop()
{ {
node* old_head=pop_head(); node* old_head = pop_head();
if(!old_head) if (!old_head) {
{
return std::shared_ptr<T>(); return std::shared_ptr<T>();
} }
std::shared_ptr<T> const res(old_head->data); std::shared_ptr<T> const res(old_head->data);
@@ -53,10 +45,10 @@ public:
void push(T new_value) void push(T new_value)
{ {
std::shared_ptr<T> new_data(std::make_shared<T>(new_value)); std::shared_ptr<T> new_data(std::make_shared<T>(new_value));
node* p=new node; node* p = new node;
node* const old_tail=tail.load(); node* const old_tail = tail.load();
old_tail->data.swap(new_data); old_tail->data.swap(new_data);
old_tail->next=p; old_tail->next = p;
tail.store(p); tail.store(p);
} }
}; };

20
source/listing_7.14.cpp
View File

@@ -1,17 +1,15 @@
void push(T new_value) void
push(T new_value)
{ {
std::unique_ptr<T> new_data(new T(new_value)); std::unique_ptr<T> new_data(new T(new_value));
counted_node_ptr new_next; counted_node_ptr new_next;
new_next.ptr=new node; new_next.ptr = new node;
new_next.external_count=1; new_next.external_count = 1;
for(;;) for (;;) {
{ node* const old_tail = tail.load();
node* const old_tail=tail.load(); T* old_data = nullptr;
T* old_data=nullptr; if (old_tail->data.compare_exchange_strong(old_data, new_data.get())) {
if(old_tail->data.compare_exchange_strong( old_tail->next = new_next;
old_data,new_data.get()))
{
old_tail->next=new_next;
tail.store(new_next.ptr); tail.store(new_next.ptr);
new_data.release(); new_data.release();
break; break;

49
source/listing_7.15.cpp
View File

@@ -1,54 +1,49 @@
#include <atomic> #include <atomic>
template<typename T> template <typename T>
class lock_free_queue class lock_free_queue {
{
private: private:
struct node; struct node;
struct counted_node_ptr struct counted_node_ptr {
{
int external_count; int external_count;
node* ptr; node* ptr;
}; };
std::atomic<counted_node_ptr> head; std::atomic<counted_node_ptr> head;
std::atomic<counted_node_ptr> tail; std::atomic<counted_node_ptr> tail;
struct node_counter struct node_counter {
{ unsigned internal_count : 30;
unsigned internal_count:30; unsigned external_counters : 2;
unsigned external_counters:2;
}; };
struct node struct node {
{
std::atomic<T*> data; std::atomic<T*> data;
std::atomic<node_counter> count; std::atomic<node_counter> count;
counted_node_ptr next; counted_node_ptr next;
node() node()
{ {
node_counter new_count; node_counter new_count;
new_count.internal_count=0; new_count.internal_count = 0;
new_count.external_counters=2; new_count.external_counters = 2;
count.store(new_count); count.store(new_count);
next.ptr=nullptr; next.ptr = nullptr;
next.external_count=0; next.external_count = 0;
} }
}; };
public: public:
void push(T new_value) void push(T new_value)
{ {
std::unique_ptr<T> new_data(new T(new_value)); std::unique_ptr<T> new_data(new T(new_value));
counted_node_ptr new_next; counted_node_ptr new_next;
new_next.ptr=new node; new_next.ptr = new node;
new_next.external_count=1; new_next.external_count = 1;
counted_node_ptr old_tail=tail.load(); counted_node_ptr old_tail = tail.load();
for(;;) for (;;) {
{ increase_external_count(tail, old_tail);
increase_external_count(tail,old_tail); T* old_data = nullptr;
T* old_data=nullptr; if (old_tail.ptr->data.compare_exchange_strong(old_data,
if(old_tail.ptr->data.compare_exchange_strong( new_data.get())) {
old_data,new_data.get())) old_tail.ptr->next = new_next;
{ old_tail = tail.exchange(new_next);
old_tail.ptr->next=new_next;
old_tail=tail.exchange(new_next);
free_external_counter(old_tail); free_external_counter(old_tail);
new_data.release(); new_data.release();
break; break;

26
source/listing_7.16.cpp
View File

@@ -1,27 +1,23 @@
template<typename T> template <typename T>
class lock_free_queue class lock_free_queue {
{
private: private:
struct node struct node {
{
void release_ref(); void release_ref();
}; };
public: public:
std::unique_ptr<T> pop() std::unique_ptr<T> pop()
{ {
counted_node_ptr old_head=head.load(std::memory_order_relaxed); counted_node_ptr old_head = head.load(std::memory_order_relaxed);
for(;;) for (;;) {
{ increase_external_count(head, old_head);
increase_external_count(head,old_head); node* const ptr = old_head.ptr;
node* const ptr=old_head.ptr; if (ptr == tail.load().ptr) {
if(ptr==tail.load().ptr)
{
ptr->release_ref(); ptr->release_ref();
return std::unique_ptr<T>(); return std::unique_ptr<T>();
} }
if(head.compare_exchange_strong(old_head,ptr->next)) if (head.compare_exchange_strong(old_head, ptr->next)) {
{ T* const res = ptr->data.exchange(nullptr);
T* const res=ptr->data.exchange(nullptr);
free_external_counter(old_head); free_external_counter(old_head);
return std::unique_ptr<T>(res); return std::unique_ptr<T>(res);
} }

28
source/listing_7.17.cpp
View File

@@ -1,25 +1,19 @@
template<typename T> template <typename T>
class lock_free_queue class lock_free_queue {
{
private: private:
struct node struct node {
{
void release_ref() void release_ref()
{ {
node_counter old_counter= node_counter old_counter = count.load(std::memory_order_relaxed);
count.load(std::memory_order_relaxed);
node_counter new_counter; node_counter new_counter;
do do {
{ new_counter = old_counter;
new_counter=old_counter;
--new_counter.internal_count; --new_counter.internal_count;
} } while (!count.compare_exchange_strong(old_counter,
while(!count.compare_exchange_strong( new_counter,
old_counter,new_counter, std::memory_order_acquire,
std::memory_order_acquire,std::memory_order_relaxed)); std::memory_order_relaxed));
if(!new_counter.internal_count && if (!new_counter.internal_count && !new_counter.external_counters) {
!new_counter.external_counters)
{
delete this; delete this;
} }
} }

23
source/listing_7.18.cpp
View File

@@ -1,20 +1,17 @@
template<typename T> template <typename T>
class lock_free_queue class lock_free_queue {
{
private: private:
static void increase_external_count( static void increase_external_count(std::atomic<counted_node_ptr>& counter,
std::atomic<counted_node_ptr>& counter,
counted_node_ptr& old_counter) counted_node_ptr& old_counter)
{ {
counted_node_ptr new_counter; counted_node_ptr new_counter;
do do {
{ new_counter = old_counter;
new_counter=old_counter;
++new_counter.external_count; ++new_counter.external_count;
} } while (!counter.compare_exchange_strong(old_counter,
while(!counter.compare_exchange_strong( new_counter,
old_counter,new_counter, std::memory_order_acquire,
std::memory_order_acquire,std::memory_order_relaxed)); std::memory_order_relaxed));
old_counter.external_count=new_counter.external_count; old_counter.external_count = new_counter.external_count;
} }
}; };

33
source/listing_7.19.cpp
View File

@@ -1,26 +1,21 @@
template<typename T> template <typename T>
class lock_free_queue class lock_free_queue {
{
private: private:
static void free_external_counter(counted_node_ptr &old_node_ptr) static void free_external_counter(counted_node_ptr& old_node_ptr)
{ {
node* const ptr=old_node_ptr.ptr; node* const ptr = old_node_ptr.ptr;
int const count_increase=old_node_ptr.external_count-2; int const count_increase = old_node_ptr.external_count - 2;
node_counter old_counter= node_counter old_counter = ptr->count.load(std::memory_order_relaxed);
ptr->count.load(std::memory_order_relaxed);
node_counter new_counter; node_counter new_counter;
do do {
{ new_counter = old_counter;
new_counter=old_counter;
--new_counter.external_counters; --new_counter.external_counters;
new_counter.internal_count+=count_increase; new_counter.internal_count += count_increase;
} } while (!ptr->count.compare_exchange_strong(old_counter,
while(!ptr->count.compare_exchange_strong( new_counter,
old_counter,new_counter, std::memory_order_acquire,
std::memory_order_acquire,std::memory_order_relaxed)); std::memory_order_relaxed));
if(!new_counter.internal_count && if (!new_counter.internal_count && !new_counter.external_counters) {
!new_counter.external_counters)
{
delete ptr; delete ptr;
} }
} }

20
source/listing_7.2.cpp
View File

@@ -1,23 +1,21 @@
#include <atomic> #include <atomic>
template<typename T> template <typename T>
class lock_free_stack class lock_free_stack {
{
private: private:
struct node struct node {
{
T data; T data;
node* next; node* next;
node(T const& data_): node(T const& data_) : data(data_) {}
data(data_)
{}
}; };
std::atomic<node*> head; std::atomic<node*> head;
public: public:
void push(T const& data) void push(T const& data)
{ {
node* const new_node=new node(data); node* const new_node = new node(data);
new_node->next=head.load(); new_node->next = head.load();
while(!head.compare_exchange_weak(new_node->next,new_node)); while (!head.compare_exchange_weak(new_node->next, new_node))
;
} }
}; };

Some files were not shown because too many files have changed in this diff Show More