From 6298e6f7b27bbea63a4321b6756b53be2edfb3a4 Mon Sep 17 00:00:00 2001 From: Brendon Scheinman Date: Sat, 9 Mar 2013 09:55:41 -0600 Subject: [PATCH] ck_cohort: Updated documentation to reflect trylock support --- doc/CK_COHORT_INIT | 2 + doc/CK_COHORT_INSTANCE | 2 + doc/CK_COHORT_LOCK | 2 + doc/CK_COHORT_PROTOTYPE | 21 ++------- doc/CK_COHORT_TRYLOCK | 66 +++++++++++++++++++++++++++ doc/CK_COHORT_TRYLOCK_PROTOTYPE | 81 +++++++++++++++++++++++++++++++++ doc/CK_COHORT_UNLOCK | 2 + doc/Makefile.in | 4 +- doc/ck_cohort | 50 ++++++++++++++++---- 9 files changed, 203 insertions(+), 27 deletions(-) create mode 100644 doc/CK_COHORT_TRYLOCK create mode 100644 doc/CK_COHORT_TRYLOCK_PROTOTYPE diff --git a/doc/CK_COHORT_INIT b/doc/CK_COHORT_INIT index 702764f..5f367de 100644 --- a/doc/CK_COHORT_INIT +++ b/doc/CK_COHORT_INIT @@ -55,9 +55,11 @@ argument, you should use CK_COHORT_DEFAULT_LOCAL_PASS_LIMIT. .Sh SEE ALSO .Xr ck_cohort 3 , .Xr CK_COHORT_PROTOTYPE 3 , +.Xr CK_COHORT_TRYLOCK_PROTOTYPE 3 , .Xr CK_COHORT_INSTANCE 3 , .Xr CK_COHORT_INITIALIZER 3 , .Xr CK_COHORT_LOCK 3 , .Xr CK_COHORT_UNLOCK 3 , +.Xr CK_COHORT_TRYLOCK 3 , .Pp Additional information available at http://concurrencykit.org/ diff --git a/doc/CK_COHORT_INSTANCE b/doc/CK_COHORT_INSTANCE index 1230b26..ca622a0 100644 --- a/doc/CK_COHORT_INSTANCE +++ b/doc/CK_COHORT_INSTANCE @@ -48,9 +48,11 @@ CK_COHORT_INSTANCE(foo) *cohorts = malloc(4 * sizeof(CK_COHORT_INSTANCE(foo))); .Sh SEE ALSO .Xr ck_cohort 3 , .Xr CK_COHORT_PROTOTYPE 3 , +.Xr CK_COHORT_TRYLOCK_PROTOTYPE 3 , .Xr CK_COHORT_INSTANCE 3 , .Xr CK_COHORT_INITIALIZER 3 , .Xr CK_COHORT_LOCK 3 , .Xr CK_COHORT_UNLOCK 3 , +.Xr CK_COHORT_TRYLOCK 3 , .Pp Additional information available at http://concurrencykit.org/ diff --git a/doc/CK_COHORT_LOCK b/doc/CK_COHORT_LOCK index 9ea6342..a1e42e5 100644 --- a/doc/CK_COHORT_LOCK +++ b/doc/CK_COHORT_LOCK @@ -50,9 +50,11 @@ will be passed to the function specified by .Sh SEE ALSO .Xr ck_cohort 3 , .Xr CK_COHORT_PROTOTYPE 3 , +.Xr CK_COHORT_TRYLOCK_PROTOTYPE 3 , .Xr CK_COHORT_INSTANCE 3 , .Xr CK_COHORT_INITIALIZER 3 , .Xr CK_COHORT_INIT 3 , .Xr CK_COHORT_UNLOCK 3 , +.Xr CK_COHORT_TRYLOCK 3 , .Pp Additional information available at http://concurrencykit.org/ diff --git a/doc/CK_COHORT_PROTOTYPE b/doc/CK_COHORT_PROTOTYPE index 2e559cb..c019209 100644 --- a/doc/CK_COHORT_PROTOTYPE +++ b/doc/CK_COHORT_PROTOTYPE @@ -1,5 +1,4 @@ .\" -.\" Copyright 2013 Samy Al Bahra. .\" Copyright 2013 Brendon Scheinman. .\" All rights reserved. .\" @@ -36,24 +35,11 @@ Concurrency Kit (libck, \-lck) .In ck_cohort.h .Fn CK_COHORT_PROTOTYPE "COHORT_NAME cohort_name" "TYPE global_lock_method" \ "LOCK_FXN global_unlock_method" "LOCK_FXN local_lock_method" "LOCK_FXN local_unlock_method" -.Pp -where LOCK_FXN refers to a method with the signature -.br -void(void *lock, void *context) -.Pp -The -.Fa context -argument is used to pass along any additional information that -the lock might need for its lock and unlock methods. The values for this -argument are provided to each call to -.Xr CK_COHORT_LOCK 3 -and -.Xr CK_COHORT_UNLOCK 3 -. -.br .Sh DESCRIPTION The ck_cohort.h header file does not define any cohort types. Instead, the user must use -the CK_COHORT_PROTOTYPE macro to define any types they want to use. This macro takes the +the CK_COHORT_PROTOTYPE or +.Xr CK_COHORT_TRYLOCK_PROTOTYPE 3 +macros to define any types they want to use. The CK_COHORT_PROTOTYPE macro takes the following arguments: .Pp .Fa COHORT_NAME cohort_name @@ -77,6 +63,7 @@ Instances of the defined cohort type can be declared as: CK_COHORT_INSTANCE(cohort_name) cohort; .Sh SEE ALSO .Xr ck_cohort 3 , +.Xr CK_COHORT_TRYLOCK_PROTOTYPE 3 , .Xr CK_COHORT_INSTANCE 3 , .Xr CK_COHORT_INITIALIZER 3 , .Xr CK_COHORT_INIT 3 , diff --git a/doc/CK_COHORT_TRYLOCK b/doc/CK_COHORT_TRYLOCK new file mode 100644 index 0000000..23c08fc --- /dev/null +++ b/doc/CK_COHORT_TRYLOCK @@ -0,0 +1,66 @@ +.\" +.\" Copyright 2013 Brendon Scheinman. +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" +.Dd March 9, 2013. +.Dt CK_COHORT_TRYLOCK 3 +.Sh NAME +.Nm CK_COHORT_TRYLOCK +.Nd Try to acquire a cohort's locks +.Sh LIBRARY +Concurrency Kit (libck, \-lck) +.Sh SYNOPSIS +.In ck_cohort.h +.Fn CK_COHORT_TRYLOCK "COHORT_NAME cohort_name" "COHORT *cohort" "void *global_trylock_context" \ +"void *local_trylock_context" "void *lock_unlock_context" +.Sh DESCRIPTION +This call attempts to acquire both the local and global (if necessary) locks from +.Fa cohort . It can only be used with cohort types that were defined using the +.Xr CK_COHORT_TRYLOCK_PROTOTYPE 3 +macro. The call will not block and will return a bool that will evaluate to true iff +the cohort was successfully acquired. +.Fa global_trylock_context +will be passed as the second argument to the function that was provided as the +.Fa global_trylock_method +argument to CK_COHORT_TRYLOCK_PROTOTYPE if that method is called, and +.Fa local_trylock_context +will be passed to the function specified by +.Fa local_trylock_method +. If the global lock acquisition fails, then the cohort will immediately release its +local lock as well, and +.Fa local_unlock_context +will be passed to the function specified by +.Fa local_unlock_method +when this call is made. +.Sh SEE ALSO +.Xr ck_cohort 3 , +.Xr CK_COHORT_PROTOTYPE 3 , +.Xr CK_COHORT_TRYLOCK_PROTOTYPE 3 , +.Xr CK_COHORT_INSTANCE 3 , +.Xr CK_COHORT_INITIALIZER 3 , +.Xr CK_COHORT_INIT 3 , +.Xr CK_COHORT_UNLOCK 3 , +.Pp +Additional information available at http://concurrencykit.org/ diff --git a/doc/CK_COHORT_TRYLOCK_PROTOTYPE b/doc/CK_COHORT_TRYLOCK_PROTOTYPE new file mode 100644 index 0000000..d7eddc4 --- /dev/null +++ b/doc/CK_COHORT_TRYLOCK_PROTOTYPE @@ -0,0 +1,81 @@ +.\" +.\" Copyright 2013 Brendon Scheinman. +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" +.Dd March 9, 2013. +.Dt CK_COHORT_TRYLOCK_PROTOTYPE 3 +.Sh NAME +.Nm CK_COHORT_TRYLOCK_PROTOTYPE +.Nd Define a cohort type with the given lock types +.Sh LIBRARY +Concurrency Kit (libck, \-lck) +.Sh SYNOPSIS +.In ck_cohort.h +.Fn CK_COHORT_TRYLOCK_PROTOTYPE "COHORT_NAME cohort_name" "LOCK_FXN global_lock_method" \ +"LOCK_FXN global_unlock_method" "TRYLOCK_FXN global_trylock_method" \ +"LOCK_FXN local_lock_method" "LOCK_FXN local_unlock_method" "TRYLOCK_FXN local_trylock_method" +.Sh DESCRIPTION +The ck_cohort.h header file does not define any cohort types. Instead, the user must use +the CK_COHORT_PROTOTYPE or CK_COHORT_TRYLOCK_PROTOTYPE macros to define any types +they want to use. The CK_COHORT_TRYLOCK_PROTOTYPE macro takes the +following arguments: +.Pp +.Fa COHORT_NAME cohort_name +: An identifier used for this cohort type. This will have to be passed to each +of the other CK_COHORT macros. +.br +.Fa LOCK_FXN global_lock_method +: The method that should be called to acquire the global lock +.br +.Fa LOCK_FXN global_unlock_method +: The method that should be called to relinquish the global lock +.br +.Fa TRYLOCK_FXN global_trylock_method +: The method that should be called to try to acquire the global lock. +It should not block and return true iff the lock was successfully acquired. +.br +.Fa LOCK_FXN local_lock_method +: The method that should be called to acquire the local lock +.br +.Fa LOCK_FXN local_unlock_method +: The method that should be called to relinquish the local lock +.br +.Fa TRYLOCK_FXN local_trylock_method +: The method that should be called to try to acquire the local lock. +It should not block and return true iff the lock was successfully acquired. +.Pp +Instances of the defined cohort type can be declared as: +.br + CK_COHORT_INSTANCE(cohort_name) cohort; +.Sh SEE ALSO +.Xr ck_cohort 3 , +.Xr CK_COHORT_PROTOTYPE 3 , +.Xr CK_COHORT_INSTANCE 3 , +.Xr CK_COHORT_INITIALIZER 3 , +.Xr CK_COHORT_INIT 3 , +.Xr CK_COHORT_LOCK 3 , +.Xr CK_COHORT_UNLOCK 3 , +.Pp +Additional information available at http://concurrencykit.org/ diff --git a/doc/CK_COHORT_UNLOCK b/doc/CK_COHORT_UNLOCK index 60d6133..7dca173 100644 --- a/doc/CK_COHORT_UNLOCK +++ b/doc/CK_COHORT_UNLOCK @@ -50,9 +50,11 @@ will be passed to the function specified by .Sh SEE ALSO .Xr ck_cohort 3 , .Xr CK_COHORT_PROTOTYPE 3 , +.Xr CK_COHORT_TRYLOCK_PROTOTYPE 3 , .Xr CK_COHORT_INSTANCE 3 , .Xr CK_COHORT_INITIALIZER 3 , .Xr CK_COHORT_INIT 3 , .Xr CK_COHORT_LOCK 3 , +.Xr CK_COHORT_TRYLOCK 3 , .Pp Additional information available at http://concurrencykit.org/ diff --git a/doc/Makefile.in b/doc/Makefile.in index c15bf1a..6e61948 100644 --- a/doc/Makefile.in +++ b/doc/Makefile.in @@ -78,10 +78,12 @@ OBJECTS=ck_ht_count \ ck_hs_stat \ ck_cohort \ CK_COHORT_PROTOTYPE \ + CK_COHORT_TRYLOCK_PROTOTYPE \ CK_COHORT_INSTANCE \ CK_COHORT_INIT \ CK_COHORT_LOCK \ - CK_COHORT_UNLOCK + CK_COHORT_UNLOCK \ + CK_COHORT_TRYLOCK all: for target in $(OBJECTS); do \ diff --git a/doc/ck_cohort b/doc/ck_cohort index f30977f..cc6ba17 100644 --- a/doc/ck_cohort +++ b/doc/ck_cohort @@ -33,12 +33,38 @@ Concurrency Kit (libck, \-lck) .Sh SYNOPSIS .In ck_cohort.h -.Fn CK_COHORT_PROTOTYPE "cohort_name" "global_lock_type" "global_lock_method" \ -"global_unlock_method" "local_lock_type" "local_lock_method" "local_unlock_method" -.Fn CK_COHORT_INSTANCE "cohort_name" -.Fn CK_COHORT_INIT "name" "ck_cohort *cohort" "global_lock" "local_lock" "unsigned int pass_limit" -.Fn CK_COHORT_LOCK "name" "ck_cohort *cohort" "void *global_context" "void *local_context" -.Fn CK_COHORT_UNLOCK "name" "ck_cohort *cohort" "void *global_context" "void *local_context" +.Fn CK_COHORT_PROTOTYPE "COHORT_NAME cohort_name" "LOCK_FXN global_lock_method" \ +"LOCK_FXN global_unlock_method" "LOCK_FXN local_lock_method" "LOCK_FXN local_unlock_method" +.Fn CK_COHORT_TRYLOCK_PROTOTYPE "COHORT_NAME cohort_name" \ +"LOCK_FXN global_lock_method" "LOCK_FXN global_unlock_method" "TRYLOCK_FXN global_trylock_method" \ +"LOCK_FXN local_lock_method" "LOCK_FXN local_unlock_method" "TRYLOCK_FXN local_trylock_method" +.Fn CK_COHORT_INSTANCE "COHORT_NAME cohort_name" +.Fn CK_COHORT_INIT "COHORT_NAME cohort_name" "ck_cohort *cohort" \ +"void *global_lock" "void *local_lock" "unsigned int pass_limit" +.Fn CK_COHORT_LOCK "COHORT_NAME cohort_name" "ck_cohort *cohort" \ +"void *global_context" "void *local_context" +.Fn CK_COHORT_UNLOCK "COHORT_NAME cohort_name" "ck_cohort *cohort" \ +"void *global_context" "void *local_context" +.Pp +Where LOCK_FXN refers to a method with the signature +.br +void(void *lock, void *context) +.br +and TRYLOCK_FXN refers to a method with the signature +.br +bool(void *lock, void *context) +.Pp +The +.Fa context +argument in each signature is used to pass along any additional information that +the lock might need for its lock, unlock and trylock methods. The values for this +argument are provided to each call to +.Xr CK_COHORT_LOCK 3 +, +.Xr CK_COHORT_UNLOCK 3 +and +.Xr CK_COHORT_TRYLOCK 3 +. .Sh DESCRIPTION ck_cohort.h provides an interface for defining lock cohorts with arbitrary lock types. Cohorts are a mechanism for coordinating @@ -46,12 +72,16 @@ threads on NUMA architectures in order to reduce the frequency with which a lock is passed between threads on different clusters. .Pp Before using a cohort, the user must define a cohort type using -the +either the .Fn CK_COHORT_PROTOTYPE -macro. This macro allows the user to specify the lock types that +or the +.Fn CK_COHORT_TRYLOCK_PROTOTYPE +macros. These macros allow the user to specify the lock methods that they would like the cohort to use. See the .Xr CK_COHORT_PROTOTYPE 3 -man page for more details. +and +.Xr CK_COHORT_TRYLOCK_PROTOTYPE 3 +man pages for more details. .Pp .Sh EXAMPLE .Bd -literal -offset indent @@ -161,10 +191,12 @@ main(void) .Sh SEE ALSO .Xr CK_COHORT_PROTOTYPE 3 , +.Xr CK_COHORT_TRYLOCK_PROTOTYPE 3 , .Xr CK_COHORT_INSTANCE 3 , .Xr CK_COHORT_INITIALIZER 3 , .Xr CK_COHORT_INIT 3 , .Xr CK_COHORT_LOCK 3 , .Xr CK_COHORT_UNLOCK 3 , +.Xr CK_COHORT_TRYLOCK 3 , .Pp Additional information available at http://concurrencykit.org/