Merge branch 'master' of https://github.com/bscheinman/ck
Samy Al Bahra
12 years ago
commit
b36e35ec76
@ -0,0 +1,61 @@
|
||||
.\"
|
||||
.\" 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 February 24, 2013.
|
||||
.Dt CK_RWCOHORT_INIT 3
|
||||
.Sh NAME
|
||||
.Nm CK_RWCOHORT_INIT
|
||||
.Nd initialize instance of a cohort-based reader-writer lock type
|
||||
.Sh LIBRARY
|
||||
Concurrency Kit (libck, \-lck)
|
||||
.Sh SYNOPSIS
|
||||
.In ck_rwcohort.h
|
||||
.Fn CK_RWCOHORT_NEUTRAL_INIT "COHORT_NAME cohort_name" "LOCK *lock"
|
||||
.Fn CK_RWCOHORT_RP_INIT "COHORT_NAME cohort_name" "LOCK *lock" "unsigned int wait_limit"
|
||||
.Fn CK_RWCOHORT_WP_INIT "COHORT_NAME cohort_name" "LOCK *lock" "unsigned int wait_limit"
|
||||
.Sh DESCRIPTION
|
||||
This macro initializes the lock instance pointed to by the
|
||||
.Fa lock
|
||||
argument. Until a lock instance is initialized using the CK_RWCOHORT_INIT macro, any operations
|
||||
involving it will have undefined behavior. Note that the
|
||||
.Fa wait_limit
|
||||
argument should only be used with reader-preference or writer-preference locks. For neutral
|
||||
locks, this argument should be excluded.
|
||||
If you are unsure of a value to use for the
|
||||
.Fa wait_limit
|
||||
argument, you should use CK_RWCOHORT_STRATEGY_DEFAULT_LOCAL_WAIT_LIMIT.
|
||||
.Sh SEE ALSO
|
||||
.Xr ck_rwcohort 3 ,
|
||||
.Xr CK_RWCOHORT_PROTOTYPE 3 ,
|
||||
.Xr CK_RWCOHORT_TRYLOCK_PROTOTYPE 3 ,
|
||||
.Xr CK_RWCOHORT_INSTANCE 3 ,
|
||||
.Xr CK_RWCOHORT_INITIALIZER 3 ,
|
||||
.Xr CK_RWCOHORT_LOCK 3 ,
|
||||
.Xr CK_RWCOHORT_UNLOCK 3 ,
|
||||
.Xr CK_RWCOHORT_LOCKED 3 ,
|
||||
.Xr CK_RWCOHORT_TRYLOCK 3 ,
|
||||
.Pp
|
||||
Additional information available at http://concurrencykit.org/
|
||||
@ -0,0 +1,64 @@
|
||||
.\"
|
||||
.\" 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 February 24, 2013.
|
||||
.Dt CK_RWCOHORT_INSTANCE 3
|
||||
.Sh NAME
|
||||
.Nm CK_RWCOHORT_INSTANCE
|
||||
.Nd declare an instance of a cohort-based reader-writer lock type
|
||||
.Sh LIBRARY
|
||||
Concurrency Kit (libck, \-lck)
|
||||
.Sh SYNOPSIS
|
||||
.In ck_cohort.h
|
||||
.Fn CK_RWCOHORT_NEUTRAL_INSTANCE "COHORT_NAME cohort_name"
|
||||
.Fn CK_RWCOHORT_RP_INSTANCE "COHORT_NAME cohort_name"
|
||||
.Fn CK_RWCOHORT_WP_INSTANCE "COHORT_NAME cohort_name"
|
||||
.Sh DESCRIPTION
|
||||
The user must use this macro to declare instances of lock types that they have
|
||||
defined using the
|
||||
.Xr CK_RWCOHORT_PROTOTYPE 3
|
||||
macro. The cohort_name must be the same as the one used in the prototype macro.
|
||||
For instance, if CK_RWCOHORT_PROTOTYPE was called with the name "foo", the
|
||||
CK_RWCOHORT_INSTANCE macro should be called as
|
||||
.br
|
||||
CK_RWCOHORT_INSTANCE(foo) cohort;
|
||||
.Pp
|
||||
This macro should also be used when allocating memory for cohorts. For instance,
|
||||
to allocate a block of 4 cohorts:
|
||||
.br
|
||||
CK_RWCOHORT_WP_INSTANCE(foo) *cohorts = malloc(4 * sizeof(CK_RWCOHORT_WP_INSTANCE(foo)));
|
||||
.Sh SEE ALSO
|
||||
.Xr ck_rwcohort 3 ,
|
||||
.Xr CK_RWCOHORT_PROTOTYPE 3 ,
|
||||
.Xr CK_RWCOHORT_TRYLOCK_PROTOTYPE 3 ,
|
||||
.Xr CK_RWCOHORT_INSTANCE 3 ,
|
||||
.Xr CK_RWCOHORT_INITIALIZER 3 ,
|
||||
.Xr CK_RWCOHORT_LOCK 3 ,
|
||||
.Xr CK_RWCOHORT_UNLOCK 3 ,
|
||||
.Xr CK_RWCOHORT_LOCKED 3 ,
|
||||
.Xr CK_RWCOHORT_TRYLOCK 3 ,
|
||||
.Pp
|
||||
Additional information available at http://concurrencykit.org/
|
||||
@ -0,0 +1,65 @@
|
||||
.\"
|
||||
.\" 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 February 24, 2013.
|
||||
.Dt CK_RWCOHORT_PROTOTYPE 3
|
||||
.Sh NAME
|
||||
.Nm CK_RWCOHORT_PROTOTYPE
|
||||
.Nd define reader-writer cohort-based lock using the specified cohort type
|
||||
.Sh LIBRARY
|
||||
Concurrency Kit (libck, \-lck)
|
||||
.Sh SYNOPSIS
|
||||
.In ck_rwcohort.h
|
||||
.Fn CK_RWCOHORT_NEUTRAL_PROTOTYPE "COHORT_NAME cohort_name"
|
||||
.Fn CK_RWCOHORT_RP_PROTOTYPE "COHORT_NAME cohort_name"
|
||||
.Fn CK_RWCOHORT_WP_PROTOTYPE "COHORT_NAME cohort_name"
|
||||
.Sh DESCRIPTION
|
||||
The ck_rwcohort.h header file does not define any cohort types. Instead, the user must use
|
||||
the CK_RWCOHORT_PROTOTYPE macro to define any types they want to use.
|
||||
This macro takes a single argument which corresponds to the type of the cohort lock that
|
||||
the reader-writer lock should use. A cohort type must have already been defined with that name
|
||||
using the
|
||||
.Xr CK_COHORT_PROTOTYPE 3
|
||||
or
|
||||
.Xr CK_COHORT_TRYLOCK_PROTOTYPE 3
|
||||
macros.
|
||||
.Pp
|
||||
Instances of the defined lock type can be declared as:
|
||||
.br
|
||||
CK_RWCOHORT_INSTANCE(cohort_name) lock;
|
||||
.Sh SEE ALSO
|
||||
.Xr ck_rwcohort 3 ,
|
||||
.Xr CK_COHORT_PROTOTYPE 3 ,
|
||||
.Xr CK_COHORT_TRYLOCK_PROTOTYPE 3 ,
|
||||
.Xr CK_RWCOHORT_INSTANCE 3 ,
|
||||
.Xr CK_RWCOHORT_INITIALIZER 3 ,
|
||||
.Xr CK_RWCOHORT_INIT 3 ,
|
||||
.Xr CK_RWCOHORT_READ_LOCK 3 ,
|
||||
.Xr CK_RWCOHORT_READ_UNLOCK 3 ,
|
||||
.Xr CK_RWCOHORT_WRITE_LOCK 3 ,
|
||||
.Xr CK_RWCOHORT_WRITE_UNLOCK 3 ,
|
||||
.Pp
|
||||
Additional information available at http://concurrencykit.org/
|
||||
@ -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 February 24, 2013.
|
||||
.Dt CK_RWCOHORT_READ_LOCK 3
|
||||
.Sh NAME
|
||||
.Nm CK_RWCOHORT_READ_LOCK
|
||||
.Nd acquire read-only permission for cohort-based reader-writer lock
|
||||
.Sh LIBRARY
|
||||
Concurrency Kit (libck, \-lck)
|
||||
.Sh SYNOPSIS
|
||||
.In ck_cohort.h
|
||||
.Fn CK_RWCOHORT_NEUTRAL_READ_LOCK "COHORT_NAME cohort_name" "LOCK *lock" "COHORT *cohort"\
|
||||
"void *global_context" "void *local_context"
|
||||
.Fn CK_RWCOHORT_RP_READ_LOCK "COHORT_NAME cohort_name" "LOCK *lock" "COHORT *cohort"\
|
||||
"void *global_context" "void *local_context"
|
||||
.Fn CK_RWCOHORT_WP_READ_LOCK "COHORT_NAME cohort_name" "LOCK *lock" "COHORT *cohort"\
|
||||
"void *global_context" "void *local_context"
|
||||
.Sh DESCRIPTION
|
||||
This call will acquire read-only permission from
|
||||
.Fa lock .
|
||||
The call will block until this permission has been acquired.
|
||||
.Fa cohort
|
||||
must point to a cohort whose global lock is the same as all other cohorts used with
|
||||
.Fa lock .
|
||||
The
|
||||
.Fa global_context
|
||||
and
|
||||
.Fa local_context
|
||||
arguments will be passed along as the context arguments to any calls to
|
||||
.Fa cohort .
|
||||
.
|
||||
.Sh SEE ALSO
|
||||
.Xr ck_cohort 3 ,
|
||||
.Xr CK_RWCOHORT_PROTOTYPE 3 ,
|
||||
.Xr CK_RWCOHORT_INSTANCE 3 ,
|
||||
.Xr CK_RWCOHORT_INITIALIZER 3 ,
|
||||
.Xr CK_RWCOHORT_INIT 3 ,
|
||||
.Xr CK_RWCOHORT_READ_UNLOCK 3 ,
|
||||
.Xr CK_RWCOHORT_WRITE_LOCK 3 ,
|
||||
.Xr CK_RWCOHORT_WRITE_UNLOCK 3 ,
|
||||
.Pp
|
||||
Additional information available at http://concurrencykit.org/
|
||||
@ -0,0 +1,65 @@
|
||||
.\"
|
||||
.\" 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 February 24, 2013.
|
||||
.Dt CK_RWCOHORT_READ_UNLOCK 3
|
||||
.Sh NAME
|
||||
.Nm CK_RWCOHORT_READ_UNLOCK
|
||||
.Nd relinquish read-only access to cohort-based reader-writer lock
|
||||
.Sh LIBRARY
|
||||
Concurrency Kit (libck, \-lck)
|
||||
.Sh SYNOPSIS
|
||||
.In ck_cohort.h
|
||||
.Fn CK_RWCOHORT_NEUTRAL_READ_UNLOCK "COHORT_NAME cohort_name" "LOCK *lock" "COHORT *cohort"\
|
||||
"void *global_context" "void *local_context"
|
||||
.Fn CK_RWCOHORT_RP_READ_UNLOCK "COHORT_NAME cohort_name" "LOCK *lock" "COHORT *cohort"\
|
||||
"void *global_context" "void *local_context"
|
||||
.Fn CK_RWCOHORT_WP_READ_UNLOCK "COHORT_NAME cohort_name" "LOCK *lock" "COHORT *cohort"\
|
||||
"void *global_context" "void *local_context"
|
||||
.Sh DESCRIPTION
|
||||
This call will relinquish read-only permission to
|
||||
.Fa lock .
|
||||
.Fa cohort
|
||||
must point to a cohort whose global lock is the same as all other cohorts used with
|
||||
.Fa lock .
|
||||
The
|
||||
.Fa global_context
|
||||
and
|
||||
.Fa local_context
|
||||
arguments will be passed along as the context arguments to any calls to
|
||||
.Fa cohort .
|
||||
.
|
||||
.Sh SEE ALSO
|
||||
.Xr ck_cohort 3 ,
|
||||
.Xr CK_RWCOHORT_PROTOTYPE 3 ,
|
||||
.Xr CK_RWCOHORT_INSTANCE 3 ,
|
||||
.Xr CK_RWCOHORT_INITIALIZER 3 ,
|
||||
.Xr CK_RWCOHORT_INIT 3 ,
|
||||
.Xr CK_RWCOHORT_READ_LOCK 3 ,
|
||||
.Xr CK_RWCOHORT_WRITE_LOCK 3 ,
|
||||
.Xr CK_RWCOHORT_WRITE_UNLOCK 3 ,
|
||||
.Pp
|
||||
Additional information available at http://concurrencykit.org/
|
||||
@ -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 February 24, 2013.
|
||||
.Dt CK_RWCOHORT_READ_LOCK 3
|
||||
.Sh NAME
|
||||
.Nm CK_RWCOHORT_READ_LOCK
|
||||
.Nd acquite write access for a cohort-based reader-writer lock
|
||||
.Sh LIBRARY
|
||||
Concurrency Kit (libck, \-lck)
|
||||
.Sh SYNOPSIS
|
||||
.In ck_cohort.h
|
||||
.Fn CK_RWCOHORT_NEUTRAL_WRITE_LOCK "COHORT_NAME cohort_name" "LOCK *lock" "COHORT *cohort"\
|
||||
"void *global_context" "void *local_context"
|
||||
.Fn CK_RWCOHORT_RP_WRITE_LOCK "COHORT_NAME cohort_name" "LOCK *lock" "COHORT *cohort"\
|
||||
"void *global_context" "void *local_context"
|
||||
.Fn CK_RWCOHORT_WP_WRITE_LOCK "COHORT_NAME cohort_name" "LOCK *lock" "COHORT *cohort"\
|
||||
"void *global_context" "void *local_context"
|
||||
.Sh DESCRIPTION
|
||||
This call will acquire write permission for
|
||||
.Fa lock .
|
||||
The call will block until this permission has been acquired.
|
||||
.Fa cohort
|
||||
must point to a cohort whose global lock is the same as all other cohorts used with
|
||||
.Fa lock .
|
||||
The
|
||||
.Fa global_context
|
||||
and
|
||||
.Fa local_context
|
||||
arguments will be passed along as the context arguments to any calls to
|
||||
.Fa cohort .
|
||||
.
|
||||
.Sh SEE ALSO
|
||||
.Xr ck_cohort 3 ,
|
||||
.Xr CK_RWCOHORT_PROTOTYPE 3 ,
|
||||
.Xr CK_RWCOHORT_INSTANCE 3 ,
|
||||
.Xr CK_RWCOHORT_INITIALIZER 3 ,
|
||||
.Xr CK_RWCOHORT_INIT 3 ,
|
||||
.Xr CK_RWCOHORT_READ_LOCK 3 ,
|
||||
.Xr CK_RWCOHORT_READ_UNLOCK 3 ,
|
||||
.Xr CK_RWCOHORT_WRITE_UNLOCK 3 ,
|
||||
.Pp
|
||||
Additional information available at http://concurrencykit.org/
|
||||
@ -0,0 +1,65 @@
|
||||
.\"
|
||||
.\" 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 February 24, 2013.
|
||||
.Dt CK_RWCOHORT_READ_LOCK 3
|
||||
.Sh NAME
|
||||
.Nm CK_RWCOHORT_READ_LOCK
|
||||
.Nd relinquish write access for cohort-based reader-writer lock
|
||||
.Sh LIBRARY
|
||||
Concurrency Kit (libck, \-lck)
|
||||
.Sh SYNOPSIS
|
||||
.In ck_cohort.h
|
||||
.Fn CK_RWCOHORT_NEUTRAL_WRITE_UNLOCK "COHORT_NAME cohort_name" "LOCK *lock" "COHORT *cohort"\
|
||||
"void *global_context" "void *local_context"
|
||||
.Fn CK_RWCOHORT_RP_WRITE_UNLOCK "COHORT_NAME cohort_name" "LOCK *lock" "COHORT *cohort"\
|
||||
"void *global_context" "void *local_context"
|
||||
.Fn CK_RWCOHORT_WP_WRITE_UNLOCK "COHORT_NAME cohort_name" "LOCK *lock" "COHORT *cohort"\
|
||||
"void *global_context" "void *local_context"
|
||||
.Sh DESCRIPTION
|
||||
This call will relinquish write permission for
|
||||
.Fa lock .
|
||||
.Fa cohort
|
||||
must point to a cohort whose global lock is the same as all other cohorts used with
|
||||
.Fa lock .
|
||||
The
|
||||
.Fa global_context
|
||||
and
|
||||
.Fa local_context
|
||||
arguments will be passed along as the context arguments to any calls to
|
||||
.Fa cohort .
|
||||
.
|
||||
.Sh SEE ALSO
|
||||
.Xr ck_cohort 3 ,
|
||||
.Xr CK_RWCOHORT_PROTOTYPE 3 ,
|
||||
.Xr CK_RWCOHORT_INSTANCE 3 ,
|
||||
.Xr CK_RWCOHORT_INITIALIZER 3 ,
|
||||
.Xr CK_RWCOHORT_INIT 3 ,
|
||||
.Xr CK_RWCOHORT_READ_LOCK 3 ,
|
||||
.Xr CK_RWCOHORT_READ_UNLOCK 3 ,
|
||||
.Xr CK_RWCOHORT_WRITE_LOCK 3 ,
|
||||
.Pp
|
||||
Additional information available at http://concurrencykit.org/
|
||||
@ -0,0 +1,204 @@
|
||||
.\"
|
||||
.\" 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 April 23, 2013.
|
||||
.Dt ck_rwcohort 3
|
||||
.Sh NAME
|
||||
.Nm ck_rwcohort
|
||||
.Nd generalized interface for reader-writer locks using cohort locks
|
||||
.Sh LIBRARY
|
||||
Concurrency Kit (libck, \-lck)
|
||||
.Sh SYNOPSIS
|
||||
.In ck_rwcohort.h
|
||||
In each of the following macros, "STRATEGY" should be replaced with either "NEUTRAL", "RP", or "WP"
|
||||
depending on which locking strategy the user prefers. RP and WP represent reader preference and
|
||||
writer preference, respectively, while NEUTRAL represents a strategy neutral to reads vs. writes.
|
||||
.Fn CK_RWCOHORT_STRATEGY_PROTOTYPE "COHORT_NAME cohort_name"
|
||||
.Fn CK_RWCOHORT_STRATEGY_NAME "COHORT_NAME cohort_name"
|
||||
.Fn CK_RWCOHORT_STRATEGY_INSTANCE "COHORT_NAME cohort_name"
|
||||
.Fn CK_RWCOHORT_STRATEGY_INIT "COHORT_NAME cohort_name" "RWCOHORT lock" "unsigned int wait_limit"
|
||||
Note: the wait_limit argument should be omitted for locks using the neutral strategy
|
||||
.Fn CK_RWCOHORT_STRATEGY_READ_LOCK "COHORT_NAME cohort_name" "RWCOHORT lock" "COHORT cohort" \
|
||||
"void *global_context" "void *local_context"
|
||||
.Fn CK_RWCOHORT_STRATEGY_READ_UNLOCK "COHORT_NAME cohort_name" "RWCOHORT lock" "COHORT cohort" \
|
||||
"void *global_context" "void *local_context"
|
||||
.Fn CK_RWCOHORT_STRATEGY_WRITE_LOCK "COHORT_NAME cohort_name" "RWCOHORT lock" "COHORT cohort" \
|
||||
"void *global_context" "void *local_context"
|
||||
.Fn CK_RWCOHORT_STRATEGY_WRITE_UNLOCK "COHORT_NAME cohort_name" "RWCOHORT lock" "COHORT cohort" \
|
||||
"void *global_context" "void *local_context"
|
||||
|
||||
Arguments of type RWCOHORT must be pointers to structs defined using the
|
||||
.Xr CK_RWCOHORT_STRATEGY_PROTOTYPE 3
|
||||
macro with the same strategy and cohort name as the current call.
|
||||
|
||||
Arguments of type COHORT must be pointers to structs defined using the
|
||||
.Xr CK_COHORT_PROTOTYPE 3
|
||||
macro.
|
||||
|
||||
.Sh DESCRIPTION
|
||||
ck_rwcohort.h provides an interface for defining reader-writer locks
|
||||
that use cohort locks internally to increase performance on NUMA
|
||||
architectures. See
|
||||
.Xr ck_cohort 3
|
||||
for more information about cohort locks.
|
||||
.Pp
|
||||
Before using a reader-writer cohort lock, the user must define a cohort type using
|
||||
either the
|
||||
.Xr CK_COHORT_PROTOTYPE 3
|
||||
or the
|
||||
.Xr CK_COHORT_TRYLOCK_PROTOTYPE 3
|
||||
macros, and define a reader-writer lock type using the
|
||||
.Xr CK_RWCOHORT_PROTOTYPE 3
|
||||
macro.
|
||||
.Pp
|
||||
.Sh EXAMPLE
|
||||
.Bd -literal -offset indent
|
||||
#include <stdlib.h>
|
||||
#include <pthread.h>
|
||||
|
||||
#include <ck_pr.h>
|
||||
#include <ck_cohort.h>
|
||||
#include <ck_rwcohort.h>
|
||||
#include <ck_spinlock.h>
|
||||
|
||||
/* Create cohort methods with signatures that match the required signature */
|
||||
|
||||
static void
|
||||
ck_spinlock_lock_with_context(ck_spinlock_t *lock, void *context)
|
||||
{
|
||||
(void)context;
|
||||
ck_spinlock_lock(lock);
|
||||
return;
|
||||
}
|
||||
|
||||
static void
|
||||
ck_spinlock_unlock_with_context(ck_spinlock_t *lock, void *context)
|
||||
{
|
||||
(void)context;
|
||||
ck_spinlock_unlock(lock);
|
||||
return;
|
||||
}
|
||||
|
||||
static bool
|
||||
ck_spinlock_locked_with_context(ck_spinlock_t *lock, void *context)
|
||||
{
|
||||
(void)context;
|
||||
return ck_spinlock_locked(lock);
|
||||
}
|
||||
|
||||
/*
|
||||
* define a cohort type named "test_cohort" that will use
|
||||
* the above methods for both its global and local locks
|
||||
*/
|
||||
CK_COHORT_PROTOTYPE(test_cohort,
|
||||
ck_spinlock_lock_with_context, ck_spinlock_unlock_with_context, ck_spinlock_locked_with_context,
|
||||
ck_spinlock_lock_with_context, ck_spinlock_unlock_with_context, ck_spinlock_locked_with_context)
|
||||
|
||||
/* define a reader-writer type using the same cohort type */
|
||||
CK_RWCOHORT_WP_PROTOTYPE(test_cohort)
|
||||
|
||||
static ck_spinlock_t global_lock = CK_SPINLOCK_INITIALIZER;
|
||||
static CK_COHORT_INSTANCE(test_cohort) *cohorts;
|
||||
static CK_RWCOHORT_WP_INSTANCE(test_cohort) rw_cohort = CK_RWCOHORT_WP_INITIALIZER;
|
||||
static unsigned int ready;
|
||||
|
||||
static void *
|
||||
function(void *context)
|
||||
{
|
||||
CK_COHORT_INSTANCE(test_cohort) *cohort = context;
|
||||
|
||||
while (ck_pr_load_uint(&ready) == 0);
|
||||
|
||||
while (ck_pr_load_uint(&ready) > 0) {
|
||||
/*
|
||||
* acquire the cohort lock before performing critical section.
|
||||
* note that we pass NULL for both the global and local context
|
||||
* arguments because neither the lock nor unlock functions
|
||||
* will use them.
|
||||
*/
|
||||
CK_COHORT_LOCK(test_cohort, cohort, NULL, NULL);
|
||||
|
||||
/* perform critical section */
|
||||
|
||||
/* relinquish cohort lock */
|
||||
CK_COHORT_UNLOCK(test_cohort, cohort, NULL, NULL);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int
|
||||
main(void)
|
||||
{
|
||||
unsigned int nthr = 4;
|
||||
unsigned int n_cohorts = 2;
|
||||
unsigned int i;
|
||||
|
||||
/* allocate 2 cohorts of the defined type */
|
||||
CK_COHORT_INSTANCE(test_cohort) *cohorts =
|
||||
calloc(n_cohorts, sizeof(CK_COHORT_INSTANCE(test_cohort)));
|
||||
|
||||
/* create local locks to use with each cohort */
|
||||
ck_spinlock_t *local_locks =
|
||||
calloc(n_cohorts, sizeof(ck_spinlock_t));
|
||||
|
||||
pthread_t *threads =
|
||||
calloc(nthr, sizeof(pthread_t));
|
||||
|
||||
/* initialize each of the cohorts before using them */
|
||||
for (i = 0 ; i < n_cohorts ; ++i) {
|
||||
CK_COHORT_INIT(test_cohort, cohorts + i, &global_lock, local_locks + i,
|
||||
CK_COHORT_DEFAULT_LOCAL_PASS_LIMIT);
|
||||
}
|
||||
|
||||
/* start each thread and assign cohorts equally */
|
||||
for (i = 0 ; i < nthr ; ++i) {
|
||||
pthread_create(threads + i, NULL, function, cohorts + (i % n_cohorts));
|
||||
}
|
||||
|
||||
ck_pr_store_uint(&ready, 1);
|
||||
sleep(10);
|
||||
ck_pr_store_uint(&ready, 0);
|
||||
|
||||
for (i = 0 ; i < nthr ; ++i) {
|
||||
pthread_join(threads[i], NULL);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
.Ed
|
||||
.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_LOCKED 3 ,
|
||||
.Xr CK_COHORT_TRYLOCK 3 ,
|
||||
.Pp
|
||||
Additional information available at http://concurrencykit.org/
|
||||
@ -0,0 +1,292 @@
|
||||
/*
|
||||
* Copyright 2013 Samy Al Bahra.
|
||||
* 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 AUTHOR 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 AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef _CK_RWCOHORT_H
|
||||
#define _CK_RWCOHORT_H
|
||||
|
||||
/*
|
||||
* This is an implementation of NUMA-aware reader-writer locks as described in:
|
||||
* Calciu, I.; Dice, D.; Lev, Y.; Luchangco, V.; Marathe, V.; and Shavit, N. 2013.
|
||||
* NUMA-Aware Reader-Writer Locks
|
||||
*/
|
||||
|
||||
#include <ck_cc.h>
|
||||
#include <ck_pr.h>
|
||||
#include <stddef.h>
|
||||
#include <ck_cohort.h>
|
||||
|
||||
#define CK_RWCOHORT_WP_NAME(N) ck_rwcohort_wp_##N
|
||||
#define CK_RWCOHORT_WP_INSTANCE(N) struct CK_RWCOHORT_WP_NAME(N)
|
||||
#define CK_RWCOHORT_WP_INIT(N, RW, WL) ck_rwcohort_wp_##N##_init(RW, WL)
|
||||
#define CK_RWCOHORT_WP_READ_LOCK(N, RW, C, GC, LC) ck_rwcohort_wp_##N##_read_lock(RW, C, GC, LC)
|
||||
#define CK_RWCOHORT_WP_READ_UNLOCK(N, RW, C, GC, LC) ck_rwcohort_wp_##N##_read_unlock(RW)
|
||||
#define CK_RWCOHORT_WP_WRITE_LOCK(N, RW, C, GC, LC) ck_rwcohort_wp_##N##_write_lock(RW, C, GC, LC)
|
||||
#define CK_RWCOHORT_WP_WRITE_UNLOCK(N, RW, C, GC, LC) ck_rwcohort_wp_##N##_write_unlock(RW, C, GC, LC)
|
||||
#define CK_RWCOHORT_WP_DEFAULT_WAIT_LIMIT 1000
|
||||
|
||||
#define CK_RWCOHORT_WP_PROTOTYPE(N) \
|
||||
CK_RWCOHORT_WP_INSTANCE(N) { \
|
||||
unsigned int read_counter; \
|
||||
unsigned int write_barrier; \
|
||||
unsigned int wait_limit; \
|
||||
}; \
|
||||
CK_CC_INLINE static void \
|
||||
ck_rwcohort_wp_##N##_init(CK_RWCOHORT_WP_INSTANCE(N) *rw_cohort, \
|
||||
unsigned int wait_limit) \
|
||||
{ \
|
||||
rw_cohort->read_counter = 0; \
|
||||
rw_cohort->write_barrier = 0; \
|
||||
rw_cohort->wait_limit = wait_limit; \
|
||||
ck_pr_barrier(); \
|
||||
return; \
|
||||
} \
|
||||
CK_CC_INLINE static void \
|
||||
ck_rwcohort_wp_##N##_write_lock(CK_RWCOHORT_WP_INSTANCE(N) *rw_cohort, \
|
||||
CK_COHORT_INSTANCE(N) *cohort, void *global_context, \
|
||||
void *local_context) \
|
||||
{ \
|
||||
while (ck_pr_load_uint(&rw_cohort->write_barrier) > 0) { \
|
||||
ck_pr_stall(); \
|
||||
} \
|
||||
\
|
||||
CK_COHORT_LOCK(N, cohort, global_context, local_context); \
|
||||
\
|
||||
while (ck_pr_load_uint(&rw_cohort->read_counter) > 0) { \
|
||||
ck_pr_stall(); \
|
||||
} \
|
||||
\
|
||||
return; \
|
||||
} \
|
||||
CK_CC_INLINE static void \
|
||||
ck_rwcohort_wp_##N##_write_unlock(CK_RWCOHORT_WP_INSTANCE(N) *rw_cohort, \
|
||||
CK_COHORT_INSTANCE(N) *cohort, void *global_context, \
|
||||
void *local_context) \
|
||||
{ \
|
||||
(void)rw_cohort; \
|
||||
CK_COHORT_UNLOCK(N, cohort, global_context, local_context); \
|
||||
return; \
|
||||
} \
|
||||
CK_CC_INLINE static void \
|
||||
ck_rwcohort_wp_##N##_read_lock(CK_RWCOHORT_WP_INSTANCE(N) *rw_cohort, \
|
||||
CK_COHORT_INSTANCE(N) *cohort, void *global_context, \
|
||||
void *local_context) \
|
||||
{ \
|
||||
unsigned int wait_count = 0; \
|
||||
bool raised = false; \
|
||||
\
|
||||
for (;;) { \
|
||||
ck_pr_inc_uint(&rw_cohort->read_counter); \
|
||||
if (CK_COHORT_LOCKED(N, cohort, global_context, local_context) == false) {\
|
||||
break; \
|
||||
} \
|
||||
\
|
||||
ck_pr_dec_uint(&rw_cohort->read_counter); \
|
||||
while (CK_COHORT_LOCKED(N, cohort, global_context, local_context) == true) {\
|
||||
ck_pr_stall(); \
|
||||
if (++wait_count > rw_cohort->wait_limit && raised == false) { \
|
||||
ck_pr_inc_uint(&rw_cohort->write_barrier); \
|
||||
raised = true; \
|
||||
} \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
if (raised == true) { \
|
||||
ck_pr_dec_uint(&rw_cohort->write_barrier); \
|
||||
} \
|
||||
\
|
||||
return; \
|
||||
} \
|
||||
CK_CC_INLINE static void \
|
||||
ck_rwcohort_wp_##N##_read_unlock(CK_RWCOHORT_WP_INSTANCE(N) *cohort) \
|
||||
{ \
|
||||
ck_pr_dec_uint(&cohort->read_counter); \
|
||||
return; \
|
||||
}
|
||||
|
||||
#define CK_RWCOHORT_WP_INITIALIZER { \
|
||||
.read_counter = 0, \
|
||||
.write_barrier = 0, \
|
||||
.wait_limit = 0 \
|
||||
}
|
||||
|
||||
|
||||
#define CK_RWCOHORT_RP_NAME(N) ck_rwcohort_rp_##N
|
||||
#define CK_RWCOHORT_RP_INSTANCE(N) struct CK_RWCOHORT_RP_NAME(N)
|
||||
#define CK_RWCOHORT_RP_INIT(N, RW, WL) ck_rwcohort_rp_##N##_init(RW, WL)
|
||||
#define CK_RWCOHORT_RP_READ_LOCK(N, RW, C, GC, LC) ck_rwcohort_rp_##N##_read_lock(RW, C, GC, LC)
|
||||
#define CK_RWCOHORT_RP_READ_UNLOCK(N, RW, C, GC, LC) ck_rwcohort_rp_##N##_read_unlock(RW)
|
||||
#define CK_RWCOHORT_RP_WRITE_LOCK(N, RW, C, GC, LC) ck_rwcohort_rp_##N##_write_lock(RW, C, GC, LC)
|
||||
#define CK_RWCOHORT_RP_WRITE_UNLOCK(N, RW, C, GC, LC) ck_rwcohort_rp_##N##_write_unlock(RW, C, GC, LC)
|
||||
#define CK_RWCOHORT_RP_DEFAULT_WAIT_LIMIT 1000
|
||||
|
||||
#define CK_RWCOHORT_RP_PROTOTYPE(N) \
|
||||
CK_RWCOHORT_RP_INSTANCE(N) { \
|
||||
unsigned int read_counter; \
|
||||
unsigned int read_barrier; \
|
||||
unsigned int wait_limit; \
|
||||
}; \
|
||||
CK_CC_INLINE static void \
|
||||
ck_rwcohort_rp_##N##_init(CK_RWCOHORT_RP_INSTANCE(N) *rw_cohort, \
|
||||
unsigned int wait_limit) \
|
||||
{ \
|
||||
rw_cohort->read_counter = 0; \
|
||||
rw_cohort->read_barrier = 0; \
|
||||
rw_cohort->wait_limit = wait_limit; \
|
||||
ck_pr_barrier(); \
|
||||
return; \
|
||||
} \
|
||||
CK_CC_INLINE static void \
|
||||
ck_rwcohort_rp_##N##_write_lock(CK_RWCOHORT_RP_INSTANCE(N) *rw_cohort, \
|
||||
CK_COHORT_INSTANCE(N) *cohort, void *global_context, \
|
||||
void *local_context) \
|
||||
{ \
|
||||
unsigned int wait_count = 0; \
|
||||
bool raised = false; \
|
||||
\
|
||||
for (;;) { \
|
||||
CK_COHORT_LOCK(N, cohort, global_context, local_context); \
|
||||
if (ck_pr_load_uint(&rw_cohort->read_counter) == 0) { \
|
||||
break; \
|
||||
} \
|
||||
\
|
||||
CK_COHORT_UNLOCK(N, cohort, global_context, local_context); \
|
||||
while (ck_pr_load_uint(&rw_cohort->read_counter) > 0) { \
|
||||
ck_pr_stall(); \
|
||||
if (++wait_count > rw_cohort->wait_limit && raised == false) { \
|
||||
ck_pr_inc_uint(&rw_cohort->read_barrier); \
|
||||
raised = true; \
|
||||
} \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
if (raised == true) { \
|
||||
ck_pr_dec_uint(&rw_cohort->read_barrier); \
|
||||
} \
|
||||
\
|
||||
return; \
|
||||
} \
|
||||
CK_CC_INLINE static void \
|
||||
ck_rwcohort_rp_##N##_write_unlock(CK_RWCOHORT_RP_INSTANCE(N) *rw_cohort, \
|
||||
CK_COHORT_INSTANCE(N) *cohort, void *global_context, void *local_context) \
|
||||
{ \
|
||||
(void)rw_cohort; \
|
||||
CK_COHORT_UNLOCK(N, cohort, global_context, local_context); \
|
||||
return; \
|
||||
} \
|
||||
CK_CC_INLINE static void \
|
||||
ck_rwcohort_rp_##N##_read_lock(CK_RWCOHORT_RP_INSTANCE(N) *rw_cohort, \
|
||||
CK_COHORT_INSTANCE(N) *cohort, void *global_context, \
|
||||
void *local_context) \
|
||||
{ \
|
||||
while (ck_pr_load_uint(&rw_cohort->read_barrier) > 0) { \
|
||||
ck_pr_stall(); \
|
||||
} \
|
||||
ck_pr_inc_uint(&rw_cohort->read_counter); \
|
||||
\
|
||||
while (CK_COHORT_LOCKED(N, cohort, global_context, local_context) == true) { \
|
||||
ck_pr_stall(); \
|
||||
} \
|
||||
\
|
||||
return; \
|
||||
} \
|
||||
CK_CC_INLINE static void \
|
||||
ck_rwcohort_rp_##N##_read_unlock(CK_RWCOHORT_RP_INSTANCE(N) *cohort) \
|
||||
{ \
|
||||
ck_pr_dec_uint(&cohort->read_counter); \
|
||||
return; \
|
||||
}
|
||||
|
||||
#define CK_RWCOHORT_RP_INITIALIZER { \
|
||||
.read_counter = 0, \
|
||||
.read_barrier = 0, \
|
||||
.wait_limit = 0 \
|
||||
}
|
||||
|
||||
|
||||
#define CK_RWCOHORT_NEUTRAL_NAME(N) ck_rwcohort_neutral_##N
|
||||
#define CK_RWCOHORT_NEUTRAL_INSTANCE(N) struct CK_RWCOHORT_NEUTRAL_NAME(N)
|
||||
#define CK_RWCOHORT_NEUTRAL_INIT(N, RW) ck_rwcohort_neutral_##N##_init(RW)
|
||||
#define CK_RWCOHORT_NEUTRAL_READ_LOCK(N, RW, C, GC, LC) ck_rwcohort_neutral_##N##_read_lock(RW, C, GC, LC)
|
||||
#define CK_RWCOHORT_NEUTRAL_READ_UNLOCK(N, RW, C, GC, LC) ck_rwcohort_neutral_##N##_read_unlock(RW)
|
||||
#define CK_RWCOHORT_NEUTRAL_WRITE_LOCK(N, RW, C, GC, LC) ck_rwcohort_neutral_##N##_write_lock(RW, C, GC, LC)
|
||||
#define CK_RWCOHORT_NEUTRAL_WRITE_UNLOCK(N, RW, C, GC, LC) ck_rwcohort_neutral_##N##_write_unlock(RW, C, GC, LC)
|
||||
#define CK_RWCOHORT_NEUTRAL_DEFAULT_WAIT_LIMIT 1000
|
||||
|
||||
#define CK_RWCOHORT_NEUTRAL_PROTOTYPE(N) \
|
||||
CK_RWCOHORT_NEUTRAL_INSTANCE(N) { \
|
||||
unsigned int read_counter; \
|
||||
}; \
|
||||
CK_CC_INLINE static void \
|
||||
ck_rwcohort_neutral_##N##_init(CK_RWCOHORT_NEUTRAL_INSTANCE(N) *rw_cohort) \
|
||||
{ \
|
||||
rw_cohort->read_counter = 0; \
|
||||
ck_pr_barrier(); \
|
||||
return; \
|
||||
} \
|
||||
CK_CC_INLINE static void \
|
||||
ck_rwcohort_neutral_##N##_write_lock(CK_RWCOHORT_NEUTRAL_INSTANCE(N) *rw_cohort, \
|
||||
CK_COHORT_INSTANCE(N) *cohort, void *global_context, \
|
||||
void *local_context) \
|
||||
{ \
|
||||
CK_COHORT_LOCK(N, cohort, global_context, local_context); \
|
||||
while (ck_pr_load_uint(&rw_cohort->read_counter) > 0) { \
|
||||
ck_pr_stall(); \
|
||||
} \
|
||||
return; \
|
||||
} \
|
||||
CK_CC_INLINE static void \
|
||||
ck_rwcohort_neutral_##N##_write_unlock(CK_RWCOHORT_NEUTRAL_INSTANCE(N) *rw_cohort, \
|
||||
CK_COHORT_INSTANCE(N) *cohort, void *global_context, void *local_context) \
|
||||
{ \
|
||||
(void)rw_cohort; \
|
||||
CK_COHORT_UNLOCK(N, cohort, global_context, local_context); \
|
||||
return; \
|
||||
} \
|
||||
CK_CC_INLINE static void \
|
||||
ck_rwcohort_neutral_##N##_read_lock(CK_RWCOHORT_NEUTRAL_INSTANCE(N) *rw_cohort, \
|
||||
CK_COHORT_INSTANCE(N) *cohort, void *global_context, \
|
||||
void *local_context) \
|
||||
{ \
|
||||
CK_COHORT_LOCK(N, cohort, global_context, local_context); \
|
||||
ck_pr_inc_uint(&rw_cohort->read_counter); \
|
||||
CK_COHORT_UNLOCK(N, cohort, global_context, local_context); \
|
||||
\
|
||||
return; \
|
||||
} \
|
||||
CK_CC_INLINE static void \
|
||||
ck_rwcohort_neutral_##N##_read_unlock(CK_RWCOHORT_NEUTRAL_INSTANCE(N) *cohort) \
|
||||
{ \
|
||||
ck_pr_dec_uint(&cohort->read_counter); \
|
||||
return; \
|
||||
}
|
||||
|
||||
#define CK_RWCOHORT_NEUTRAL_INITIALIZER { \
|
||||
.read_counter = 0, \
|
||||
}
|
||||
|
||||
|
||||
#endif /* _CK_RWCOHORT_H */
|
||||
@ -0,0 +1,32 @@
|
||||
.PHONY: clean distribution
|
||||
|
||||
OBJECTS=latency throughput
|
||||
OBJECTS=ck_neutral.THROUGHPUT ck_neutral.LATENCY \
|
||||
ck_rp.THROUGHPUT ck_rp.LATENCY \
|
||||
ck_wp.THROUGHPUT ck_wp.LATENCY
|
||||
|
||||
all: $(OBJECTS)
|
||||
|
||||
ck_neutral.THROUGHPUT: ck_neutral.c
|
||||
$(CC) -DTHROUGHPUT $(CFLAGS) -o ck_neutral.THROUGHPUT ck_neutral.c
|
||||
|
||||
ck_neutral.LATENCY: ck_neutral.c
|
||||
$(CC) -DLATENCY $(CFLAGS) -o ck_neutral.LATENCY ck_neutral.c
|
||||
|
||||
ck_rp.THROUGHPUT: ck_rp.c
|
||||
$(CC) -DTHROUGHPUT $(CFLAGS) -o ck_rp.THROUGHPUT ck_rp.c
|
||||
|
||||
ck_rp.LATENCY: ck_rp.c
|
||||
$(CC) -DLATENCY $(CFLAGS) -o ck_rp.LATENCY ck_rp.c
|
||||
|
||||
ck_wp.THROUGHPUT: ck_wp.c
|
||||
$(CC) -DTHROUGHPUT $(CFLAGS) -o ck_wp.THROUGHPUT ck_wp.c
|
||||
|
||||
ck_wp.LATENCY: ck_wp.c
|
||||
$(CC) -DLATENCY $(CFLAGS) -o ck_wp.LATENCY ck_wp.c
|
||||
|
||||
clean:
|
||||
rm -rf *.dSYM *~ *.o $(OBJECTS)
|
||||
|
||||
include ../../../build/regressions.build
|
||||
CFLAGS+=$(PTHREAD_CFLAGS) -D_GNU_SOURCE
|
||||
@ -0,0 +1,7 @@
|
||||
#include "../ck_neutral.h"
|
||||
|
||||
#ifdef THROUGHPUT
|
||||
#include "throughput.h"
|
||||
#elif defined(LATENCY)
|
||||
#include "latency.h"
|
||||
#endif
|
||||
@ -0,0 +1,7 @@
|
||||
#include "../ck_rp.h"
|
||||
|
||||
#ifdef THROUGHPUT
|
||||
#include "throughput.h"
|
||||
#elif defined(LATENCY)
|
||||
#include "latency.h"
|
||||
#endif
|
||||
@ -0,0 +1,7 @@
|
||||
#include "../ck_wp.h"
|
||||
|
||||
#ifdef THROUGHPUT
|
||||
#include "throughput.h"
|
||||
#elif defined(LATENCY)
|
||||
#include "latency.h"
|
||||
#endif
|
||||
@ -0,0 +1,106 @@
|
||||
/*
|
||||
* Copyright 2013 Samy Al Bahra.
|
||||
* 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 AUTHOR 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 AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <ck_rwcohort.h>
|
||||
#include <ck_spinlock.h>
|
||||
#include <inttypes.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "../../common.h"
|
||||
|
||||
#ifndef STEPS
|
||||
#define STEPS 1000000
|
||||
#endif
|
||||
|
||||
static void
|
||||
ck_spinlock_fas_lock_with_context(ck_spinlock_fas_t *lock, void *context)
|
||||
{
|
||||
(void)context;
|
||||
ck_spinlock_fas_lock(lock);
|
||||
}
|
||||
|
||||
static void
|
||||
ck_spinlock_fas_unlock_with_context(ck_spinlock_fas_t *lock, void *context)
|
||||
{
|
||||
(void)context;
|
||||
ck_spinlock_fas_unlock(lock);
|
||||
}
|
||||
|
||||
static bool
|
||||
ck_spinlock_fas_locked_with_context(ck_spinlock_fas_t *lock, void *context)
|
||||
{
|
||||
(void)context;
|
||||
return ck_spinlock_fas_locked(lock);
|
||||
}
|
||||
|
||||
CK_COHORT_PROTOTYPE(fas_fas,
|
||||
ck_spinlock_fas_lock_with_context, ck_spinlock_fas_unlock_with_context, ck_spinlock_fas_locked_with_context,
|
||||
ck_spinlock_fas_lock_with_context, ck_spinlock_fas_unlock_with_context, ck_spinlock_fas_locked_with_context)
|
||||
LOCK_PROTOTYPE(fas_fas)
|
||||
|
||||
int
|
||||
main(void)
|
||||
{
|
||||
uint64_t s_b, e_b, i;
|
||||
ck_spinlock_fas_t global_lock = CK_SPINLOCK_FAS_INITIALIZER;
|
||||
ck_spinlock_fas_t local_lock = CK_SPINLOCK_FAS_INITIALIZER;
|
||||
CK_COHORT_INSTANCE(fas_fas) cohort = CK_COHORT_INITIALIZER;
|
||||
LOCK_INSTANCE(fas_fas) rw_cohort = LOCK_INITIALIZER;
|
||||
|
||||
CK_COHORT_INIT(fas_fas, &cohort, &global_lock, &local_lock,
|
||||
CK_COHORT_DEFAULT_LOCAL_PASS_LIMIT);
|
||||
LOCK_INIT(fas_fas, &rw_cohort, CK_RWCOHORT_WP_DEFAULT_WAIT_LIMIT);
|
||||
|
||||
for (i = 0; i < STEPS; i++) {
|
||||
WRITE_LOCK(fas_fas, &rw_cohort, &cohort, NULL, NULL);
|
||||
WRITE_UNLOCK(fas_fas, &rw_cohort, &cohort, NULL, NULL);
|
||||
}
|
||||
|
||||
s_b = rdtsc();
|
||||
for (i = 0; i < STEPS; i++) {
|
||||
WRITE_LOCK(fas_fas, &rw_cohort, &cohort, NULL, NULL);
|
||||
WRITE_UNLOCK(fas_fas, &rw_cohort, &cohort, NULL, NULL);
|
||||
}
|
||||
e_b = rdtsc();
|
||||
printf("WRITE: rwlock %15" PRIu64 "\n", (e_b - s_b) / STEPS);
|
||||
|
||||
for (i = 0; i < STEPS; i++) {
|
||||
READ_LOCK(fas_fas, &rw_cohort, &cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, &cohort, NULL, NULL);
|
||||
}
|
||||
|
||||
s_b = rdtsc();
|
||||
for (i = 0; i < STEPS; i++) {
|
||||
READ_LOCK(fas_fas, &rw_cohort, &cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, &cohort, NULL, NULL);
|
||||
}
|
||||
e_b = rdtsc();
|
||||
printf("READ: rwlock %15" PRIu64 "\n", (e_b - s_b) / STEPS);
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
@ -0,0 +1,245 @@
|
||||
/*
|
||||
* Copyright 2013 Samy Al Bahra.
|
||||
* 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 AUTHOR 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 AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <ck_cohort.h>
|
||||
#include <ck_rwcohort.h>
|
||||
#include <ck_spinlock.h>
|
||||
#include <inttypes.h>
|
||||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "../../common.h"
|
||||
|
||||
#define max(x, y) (((x) > (y)) ? (x) : (y))
|
||||
|
||||
#ifndef STEPS
|
||||
#define STEPS 1000000
|
||||
#endif
|
||||
|
||||
static unsigned int barrier;
|
||||
static unsigned int flag CK_CC_CACHELINE;
|
||||
static struct affinity affinity;
|
||||
static unsigned int nthr;
|
||||
|
||||
static void
|
||||
ck_spinlock_fas_lock_with_context(ck_spinlock_fas_t *lock, void *context)
|
||||
{
|
||||
|
||||
(void)context;
|
||||
ck_spinlock_fas_lock(lock);
|
||||
return;
|
||||
}
|
||||
|
||||
static void
|
||||
ck_spinlock_fas_unlock_with_context(ck_spinlock_fas_t *lock, void *context)
|
||||
{
|
||||
|
||||
(void)context;
|
||||
ck_spinlock_fas_unlock(lock);
|
||||
return;
|
||||
}
|
||||
|
||||
static bool
|
||||
ck_spinlock_fas_locked_with_context(ck_spinlock_fas_t *lock, void *context)
|
||||
{
|
||||
|
||||
(void)context;
|
||||
return ck_spinlock_fas_locked(lock);
|
||||
}
|
||||
|
||||
CK_COHORT_PROTOTYPE(fas_fas,
|
||||
ck_spinlock_fas_lock_with_context, ck_spinlock_fas_unlock_with_context, ck_spinlock_fas_locked_with_context,
|
||||
ck_spinlock_fas_lock_with_context, ck_spinlock_fas_unlock_with_context, ck_spinlock_fas_locked_with_context)
|
||||
LOCK_PROTOTYPE(fas_fas)
|
||||
|
||||
struct cohort_record {
|
||||
CK_COHORT_INSTANCE(fas_fas) cohort;
|
||||
} CK_CC_CACHELINE;
|
||||
static struct cohort_record *cohorts;
|
||||
|
||||
static ck_spinlock_t global_lock = CK_SPINLOCK_INITIALIZER;
|
||||
static LOCK_INSTANCE(fas_fas) rw_cohort = LOCK_INITIALIZER;
|
||||
static unsigned int n_cohorts;
|
||||
|
||||
struct block {
|
||||
unsigned int tid;
|
||||
};
|
||||
|
||||
static void *
|
||||
thread_rwlock(void *pun)
|
||||
{
|
||||
uint64_t s_b, e_b, a, i;
|
||||
uint64_t *value = pun;
|
||||
CK_COHORT_INSTANCE(fas_fas) *cohort;
|
||||
unsigned int core;
|
||||
|
||||
if (aff_iterate_core(&affinity, &core) != 0) {
|
||||
perror("ERROR: Could not affine thread");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
cohort = &((cohorts + (core / (int)(affinity.delta)) % n_cohorts)->cohort);
|
||||
|
||||
ck_pr_inc_uint(&barrier);
|
||||
while (ck_pr_load_uint(&barrier) != nthr)
|
||||
ck_pr_stall();
|
||||
|
||||
for (i = 1, a = 0;; i++) {
|
||||
s_b = rdtsc();
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
e_b = rdtsc();
|
||||
|
||||
a += (e_b - s_b) >> 4;
|
||||
|
||||
if (ck_pr_load_uint(&flag) == 1)
|
||||
break;
|
||||
}
|
||||
|
||||
ck_pr_inc_uint(&barrier);
|
||||
while (ck_pr_load_uint(&barrier) != nthr * 2)
|
||||
ck_pr_stall();
|
||||
|
||||
*value = (a / i);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char *argv[])
|
||||
{
|
||||
unsigned int i;
|
||||
pthread_t *threads;
|
||||
uint64_t *latency;
|
||||
struct block *context;
|
||||
ck_spinlock_fas_t *local_lock;
|
||||
|
||||
if (argc != 4) {
|
||||
ck_error("Usage: throughput <number of cohorts> <threads per cohort> <affinity delta>\n");
|
||||
}
|
||||
|
||||
n_cohorts = atoi(argv[1]);
|
||||
if (n_cohorts <= 0) {
|
||||
ck_error("ERROR: Number of cohorts must be greater than 0\n");
|
||||
}
|
||||
|
||||
nthr = n_cohorts * atoi(argv[2]);
|
||||
if (nthr <= 0) {
|
||||
ck_error("ERROR: Number of threads must be greater than 0\n");
|
||||
}
|
||||
|
||||
threads = malloc(sizeof(pthread_t) * nthr);
|
||||
if (threads == NULL) {
|
||||
ck_error("ERROR: Could not allocate thread structures\n");
|
||||
}
|
||||
|
||||
cohorts = malloc(sizeof(struct cohort_record) * n_cohorts);
|
||||
if (cohorts == NULL) {
|
||||
ck_error("ERROR: Could not allocate cohort structures\n");
|
||||
}
|
||||
|
||||
context = malloc(sizeof(struct block) * nthr);
|
||||
if (context == NULL) {
|
||||
ck_error("ERROR: Could not allocate thread contexts\n");
|
||||
}
|
||||
|
||||
affinity.delta = atoi(argv[3]);
|
||||
affinity.request = 0;
|
||||
|
||||
latency = malloc(sizeof(*latency) * nthr);
|
||||
if (latency == NULL) {
|
||||
ck_error("ERROR: Could not create latency buffer\n");
|
||||
}
|
||||
memset(latency, 0, sizeof(*latency) * nthr);
|
||||
|
||||
fprintf(stderr, "Creating cohorts...");
|
||||
for (i = 0 ; i < n_cohorts ; i++) {
|
||||
local_lock = malloc(max(CK_MD_CACHELINE, sizeof(ck_spinlock_fas_t)));
|
||||
if (local_lock == NULL) {
|
||||
ck_error("ERROR: Could not allocate local lock\n");
|
||||
}
|
||||
CK_COHORT_INIT(fas_fas, &((cohorts + i)->cohort), &global_lock, local_lock,
|
||||
CK_COHORT_DEFAULT_LOCAL_PASS_LIMIT);
|
||||
local_lock = NULL;
|
||||
}
|
||||
fprintf(stderr, "done\n");
|
||||
|
||||
fprintf(stderr, "Creating threads (rwlock)...");
|
||||
for (i = 0; i < nthr; i++) {
|
||||
if (pthread_create(&threads[i], NULL, thread_rwlock, latency + i) != 0) {
|
||||
ck_error("ERROR: Could not create thread %d\n", i);
|
||||
}
|
||||
}
|
||||
fprintf(stderr, "done\n");
|
||||
|
||||
common_sleep(10);
|
||||
ck_pr_store_uint(&flag, 1);
|
||||
|
||||
fprintf(stderr, "Waiting for threads to finish acquisition regression...");
|
||||
for (i = 0; i < nthr; i++)
|
||||
pthread_join(threads[i], NULL);
|
||||
fprintf(stderr, "done\n\n");
|
||||
|
||||
for (i = 1; i <= nthr; i++)
|
||||
printf("%10u %20" PRIu64 "\n", i, latency[i - 1]);
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
@ -0,0 +1,8 @@
|
||||
#define LOCK_PROTOTYPE CK_RWCOHORT_NEUTRAL_PROTOTYPE
|
||||
#define LOCK_INSTANCE CK_RWCOHORT_NEUTRAL_INSTANCE
|
||||
#define LOCK_INITIALIZER CK_RWCOHORT_NEUTRAL_INITIALIZER
|
||||
#define LOCK_INIT(N, C, W) CK_RWCOHORT_NEUTRAL_INIT(N, C)
|
||||
#define READ_LOCK CK_RWCOHORT_NEUTRAL_READ_LOCK
|
||||
#define WRITE_LOCK CK_RWCOHORT_NEUTRAL_WRITE_LOCK
|
||||
#define READ_UNLOCK CK_RWCOHORT_NEUTRAL_READ_UNLOCK
|
||||
#define WRITE_UNLOCK CK_RWCOHORT_NEUTRAL_WRITE_UNLOCK
|
||||
@ -0,0 +1,8 @@
|
||||
#define LOCK_PROTOTYPE CK_RWCOHORT_RP_PROTOTYPE
|
||||
#define LOCK_INSTANCE CK_RWCOHORT_RP_INSTANCE
|
||||
#define LOCK_INITIALIZER CK_RWCOHORT_RP_INITIALIZER
|
||||
#define LOCK_INIT CK_RWCOHORT_RP_INIT
|
||||
#define READ_LOCK CK_RWCOHORT_RP_READ_LOCK
|
||||
#define READ_UNLOCK CK_RWCOHORT_RP_READ_UNLOCK
|
||||
#define WRITE_LOCK CK_RWCOHORT_RP_WRITE_LOCK
|
||||
#define WRITE_UNLOCK CK_RWCOHORT_RP_WRITE_UNLOCK
|
||||
@ -0,0 +1,8 @@
|
||||
#define LOCK_PROTOTYPE CK_RWCOHORT_WP_PROTOTYPE
|
||||
#define LOCK_INSTANCE CK_RWCOHORT_WP_INSTANCE
|
||||
#define LOCK_INITIALIZER CK_RWCOHORT_WP_INITIALIZER
|
||||
#define LOCK_INIT CK_RWCOHORT_WP_INIT
|
||||
#define READ_LOCK CK_RWCOHORT_WP_READ_LOCK
|
||||
#define WRITE_LOCK CK_RWCOHORT_WP_WRITE_LOCK
|
||||
#define READ_UNLOCK CK_RWCOHORT_WP_READ_UNLOCK
|
||||
#define WRITE_UNLOCK CK_RWCOHORT_WP_WRITE_UNLOCK
|
||||
@ -0,0 +1,25 @@
|
||||
.PHONY: check clean distribution
|
||||
|
||||
OBJECTS=ck_neutral ck_rp ck_wp
|
||||
|
||||
all: $(OBJECTS)
|
||||
|
||||
ck_neutral: ck_neutral.c ../../../include/ck_rwcohort.h
|
||||
$(CC) $(CFLAGS) -o ck_neutral ck_neutral.c -g
|
||||
|
||||
ck_rp: ck_rp.c ../../../include/ck_rwcohort.h
|
||||
$(CC) $(CFLAGS) -o ck_rp ck_rp.c -g
|
||||
|
||||
ck_wp: ck_wp.c ../../../include/ck_rwcohort.h
|
||||
$(CC) $(CFLAGS) -o ck_wp ck_wp.c -g
|
||||
|
||||
check: all
|
||||
./ck_neutral `expr $(CORES) / 2` 2 1
|
||||
./ck_rp `expr $(CORES) / 2` 2 1
|
||||
./ck_wp `expr $(CORES) / 2` 2 1
|
||||
|
||||
clean:
|
||||
rm -rf *.dSYM *~ *.o $(OBJECTS)
|
||||
|
||||
include ../../../build/regressions.build
|
||||
CFLAGS+=$(PTHREAD_CFLAGS) -D_GNU_SOURCE
|
||||
@ -0,0 +1,2 @@
|
||||
#include "../ck_neutral.h"
|
||||
#include "validate.h"
|
||||
@ -0,0 +1,2 @@
|
||||
#include "../ck_rp.h"
|
||||
#include "validate.h"
|
||||
@ -0,0 +1,2 @@
|
||||
#include "../ck_wp.h"
|
||||
#include "validate.h"
|
||||
@ -0,0 +1,209 @@
|
||||
/*
|
||||
* Copyright 2013 Samy Al Bahra.
|
||||
* Copything 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 AUTHOR 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 AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <inttypes.h>
|
||||
#include <pthread.h>
|
||||
#include <math.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <strings.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#include <ck_pr.h>
|
||||
#include <ck_rwcohort.h>
|
||||
#include <ck_spinlock.h>
|
||||
|
||||
#include "../../common.h"
|
||||
|
||||
#ifndef ITERATE
|
||||
#define ITERATE 1000000
|
||||
#endif
|
||||
|
||||
|
||||
static struct affinity a;
|
||||
static unsigned int locked;
|
||||
static int nthr;
|
||||
static ck_spinlock_fas_t global_fas_lock = CK_SPINLOCK_FAS_INITIALIZER;
|
||||
|
||||
static void
|
||||
ck_spinlock_fas_lock_with_context(ck_spinlock_fas_t *lock, void *context)
|
||||
{
|
||||
(void)context;
|
||||
ck_spinlock_fas_lock(lock);
|
||||
}
|
||||
|
||||
static void
|
||||
ck_spinlock_fas_unlock_with_context(ck_spinlock_fas_t *lock, void *context)
|
||||
{
|
||||
(void)context;
|
||||
ck_spinlock_fas_unlock(lock);
|
||||
}
|
||||
|
||||
static bool
|
||||
ck_spinlock_fas_locked_with_context(ck_spinlock_fas_t *lock, void *context)
|
||||
{
|
||||
(void)context;
|
||||
return ck_spinlock_fas_locked(lock);
|
||||
}
|
||||
|
||||
CK_COHORT_PROTOTYPE(fas_fas,
|
||||
ck_spinlock_fas_lock_with_context, ck_spinlock_fas_unlock_with_context, ck_spinlock_fas_locked_with_context,
|
||||
ck_spinlock_fas_lock_with_context, ck_spinlock_fas_unlock_with_context, ck_spinlock_fas_locked_with_context)
|
||||
LOCK_PROTOTYPE(fas_fas)
|
||||
|
||||
static CK_COHORT_INSTANCE(fas_fas) *cohorts;
|
||||
static LOCK_INSTANCE(fas_fas) rw_cohort = LOCK_INITIALIZER;
|
||||
static int n_cohorts;
|
||||
|
||||
static void *
|
||||
thread(void *null CK_CC_UNUSED)
|
||||
{
|
||||
int i = ITERATE;
|
||||
unsigned int l;
|
||||
unsigned int core;
|
||||
CK_COHORT_INSTANCE(fas_fas) *cohort;
|
||||
|
||||
if (aff_iterate_core(&a, &core)) {
|
||||
perror("ERROR: Could not affine thread");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
cohort = cohorts + (core / (int)(a.delta)) % n_cohorts;
|
||||
|
||||
while (i--) {
|
||||
WRITE_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
{
|
||||
l = ck_pr_load_uint(&locked);
|
||||
if (l != 0) {
|
||||
ck_error("ERROR [WR:%d]: %u != 0\n", __LINE__, l);
|
||||
}
|
||||
|
||||
ck_pr_inc_uint(&locked);
|
||||
ck_pr_inc_uint(&locked);
|
||||
ck_pr_inc_uint(&locked);
|
||||
ck_pr_inc_uint(&locked);
|
||||
ck_pr_inc_uint(&locked);
|
||||
ck_pr_inc_uint(&locked);
|
||||
ck_pr_inc_uint(&locked);
|
||||
ck_pr_inc_uint(&locked);
|
||||
|
||||
l = ck_pr_load_uint(&locked);
|
||||
if (l != 8) {
|
||||
ck_error("ERROR [WR:%d]: %u != 2\n", __LINE__, l);
|
||||
}
|
||||
|
||||
ck_pr_dec_uint(&locked);
|
||||
ck_pr_dec_uint(&locked);
|
||||
ck_pr_dec_uint(&locked);
|
||||
ck_pr_dec_uint(&locked);
|
||||
ck_pr_dec_uint(&locked);
|
||||
ck_pr_dec_uint(&locked);
|
||||
ck_pr_dec_uint(&locked);
|
||||
ck_pr_dec_uint(&locked);
|
||||
|
||||
l = ck_pr_load_uint(&locked);
|
||||
if (l != 0) {
|
||||
ck_error("ERROR [WR:%d]: %u != 0\n", __LINE__, l);
|
||||
}
|
||||
}
|
||||
WRITE_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
|
||||
READ_LOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
{
|
||||
l = ck_pr_load_uint(&locked);
|
||||
if (l != 0) {
|
||||
ck_error("ERROR [RD:%d]: %u != 0\n", __LINE__, l);
|
||||
}
|
||||
}
|
||||
READ_UNLOCK(fas_fas, &rw_cohort, cohort, NULL, NULL);
|
||||
}
|
||||
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char *argv[])
|
||||
{
|
||||
pthread_t *threads;
|
||||
int threads_per_cohort;
|
||||
ck_spinlock_fas_t *local_lock;
|
||||
int i;
|
||||
|
||||
if (argc != 4) {
|
||||
ck_error("Usage: validate <number of cohorts> <threads per cohort> <affinity delta>\n");
|
||||
}
|
||||
|
||||
n_cohorts = atoi(argv[1]);
|
||||
if (n_cohorts <= 0) {
|
||||
ck_error("ERROR: Number of cohorts must be greater than 0\n");
|
||||
}
|
||||
|
||||
threads_per_cohort = atoi(argv[2]);
|
||||
if (threads_per_cohort <= 0) {
|
||||
ck_error("ERROR: Threads per cohort must be greater than 0\n");
|
||||
}
|
||||
|
||||
nthr = n_cohorts * threads_per_cohort;
|
||||
|
||||
threads = malloc(sizeof(pthread_t) * nthr);
|
||||
if (threads == NULL) {
|
||||
ck_error("ERROR: Could not allocate thread structures\n");
|
||||
}
|
||||
|
||||
a.delta = atoi(argv[3]);
|
||||
|
||||
fprintf(stderr, "Creating cohorts...");
|
||||
cohorts = malloc(sizeof(CK_COHORT_INSTANCE(fas_fas)) * n_cohorts);
|
||||
if (cohorts == NULL) {
|
||||
ck_error("ERROR: Could not allocate base cohort structures\n");
|
||||
}
|
||||
for (i = 0 ; i < n_cohorts ; i++) {
|
||||
local_lock = malloc(sizeof(ck_spinlock_fas_t));
|
||||
CK_COHORT_INIT(fas_fas, cohorts + i, &global_fas_lock, local_lock,
|
||||
CK_COHORT_DEFAULT_LOCAL_PASS_LIMIT);
|
||||
}
|
||||
fprintf(stderr, "done\n");
|
||||
|
||||
fprintf(stderr, "Creating threads...");
|
||||
for (i = 0; i < nthr; i++) {
|
||||
if (pthread_create(&threads[i], NULL, thread, NULL)) {
|
||||
ck_error("ERROR: Could not create thread %d\n", i);
|
||||
}
|
||||
}
|
||||
fprintf(stderr, "done\n");
|
||||
|
||||
fprintf(stderr, "Waiting for threads to finish correctness regression...");
|
||||
for (i = 0; i < nthr; i++)
|
||||
pthread_join(threads[i], NULL);
|
||||
fprintf(stderr, "done (passed)\n");
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
Loading…
Reference in new issue