Result:
found more than 706 distributions - search limited to the first 2001 files matching your query
( run in 1.753 )
Data-AnyXfer
view release on metacpan or search on metacpan
t/json/upstream/12_blessed.t view on Meta::CPAN
my $o2 = bless \(my $dummy = 1), "YY";
if (eval 'require Hash::Util') {
if ($Hash::Util::VERSION > 0.05) {
Hash::Util::lock_ref_keys($o1);
print "# blessed hash is locked\n";
}
else {
Hash::Util::lock_hash($o1);
print "# hash is locked\n";
}
}
else {
print "# locked hashes are not supported\n";
};
sub XX::TO_JSON {
{__,""}
}
Data-Buffer-Shared
view release on metacpan or search on metacpan
bench/throughput.pl view on Meta::CPAN
print "\n=== Str/16B ($n ops, $cap elements) ===\n";
{
my $buf = Data::Buffer::Shared::Str->new_anon($cap, 16);
my $val = "hello world!!!!"; # 15 bytes
bench "str set (locked)" => sub {
for my $i (1..$n) { $buf->set($i % $cap, $val) }
};
bench "str get (seqlock)" => sub {
my $v;
for my $i (1..$n) { $v = $buf->get($i % $cap) }
Data-ChipsChallenge
view release on metacpan or search on metacpan
lib/Data/ChipsChallenge.pm view on Meta::CPAN
01 Wall
02 Computer Chip
03 Water
04 Fire
05 Invisible Wall (won't appear)
06 Blocked North
07 Blocked West
08 Blocked South
09 Blocked East
0A Movable Dirt Block
0B Dirt (mud, turns to floor)
0C Ice
0D Force South (S)
0E Cloning Block North (N)
lib/Data/ChipsChallenge.pm view on Meta::CPAN
2B Bear Trap
2C Invisible Wall (will appear)
2D Gravel
2E Pass Once
2F Hint
30 Blocked South/East
31 Cloning Machine
32 Force Random Direction
34 Burned Chip
35 Burned Chip (2)
36 NOT USED
Data-Conveyor
view release on metacpan or search on metacpan
eg/rangelocks_perl.pl view on Meta::CPAN
print "# getting meta lock\n";
print "# trying to get locks for [$number]\n";
our %locks;
if ($locks{block_exact}{$number}) { # EXC
print "# exact number [$number] is blocked, aborting\n";
print "# releasing meta lock\n";
return;
}
local $_ = $number;
eg/rangelocks_perl.pl view on Meta::CPAN
chop;
}
for my $substr (@substr) {
if ($locks{block_range}{$substr}) { # EXC
print "# range [$substr] is blocked, aborting\n";
print "# releasing meta lock\n";
return;
}
}
eg/rangelocks_perl.pl view on Meta::CPAN
}
sub test_locks_are_empty {
our %locks;
is_deeply(($locks{block_exact} || {}), {}, 'no exact numbers are blocked');
is_deeply(($locks{block_range} || {}), {}, 'no numbers ranges are blocked');
}
reset_locks();
test_ok_locks(431234);
Data-Deque-Shared
view release on metacpan or search on metacpan
xt/signal_during_wait.t view on Meta::CPAN
plan skip_all => 'AUTHOR_TESTING not set' unless $ENV{AUTHOR_TESTING};
# A SIGUSR1 while a process is parked in pop_wait must cleanly interrupt
# the futex, re-check the predicate, and (since no data arrived) continue
# waiting for the FULL remaining window. Wall-time assertion: total time
# spent blocked ≈ timeout, not just up-to-signal-arrival.
my $s = Data::Deque::Shared::Int->new(undef, 4);
my $TIMEOUT = 2.0;
pipe(my $rd, my $wr) or die $!;
Data-Downloader
view release on metacpan or search on metacpan
lib/Data/Downloader/DB.pm view on Meta::CPAN
$dbh->do("PRAGMA count_changes = OFF");
if (my $mode = $ENV{DATA_DOWNLOADER_JOURNAL_MODE}) {
$dbh->do("PRAGMA journal_mode = $mode")
if (grep $_ eq $mode, qw(DELETE TRUNCATE PERSIST MEMORY WAL OFF));
}
$dbh->sqlite_busy_timeout(1000*300); # wait up to 5 minutes if it is locked
return $dbh;
}
=item simple
Data-Dump-HTML-PopUp
view release on metacpan or search on metacpan
share/jquery-3.7.1/jquery-3.7.1.min.js view on Meta::CPAN
/*! jQuery v3.7.1 | (c) OpenJS Foundation and other contributors | jquery.org/license */
!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof windo...
Data-Dump-Streamer
view release on metacpan or search on metacpan
Added additional support for utf8 and some minor doc fixes. Thanks to
Yitzchak yet again for the patches and advice.
1.05
Added support for locked hashes. Probably there are still bugs in here,
but for now it looks good. Thanks to Yitzchak for pointing out this wasn't
implemented.
Also started adding support for a "smart indent mode". Try using Indent(1)
instead of Indent(2).
Data-Dumper
view release on metacpan or search on metacpan
get_av|5.006000|5.003007|p
getc|5.003007||Viu
get_c_backtrace|5.021001||Vi
get_c_backtrace_dump|5.021001||V
get_context|5.006000|5.006000|nu
getc_unlocked|5.003007||Viu
get_cv|5.006000|5.003007|p
get_cvn_flags|5.009005|5.003007|p
get_cvs|5.011000|5.003007|p
getcwd_sv|5.007002|5.007002|
get_db_sub|||iu
PERL_MALLOC_WRAP|5.009002|5.009002|Vn
PerlMem_calloc|5.006000||Viu
PerlMem_free|5.005000||Viu
PerlMem_free_lock|5.006000||Viu
PerlMem_get_lock|5.006000||Viu
PerlMem_is_locked|5.006000||Viu
PerlMem_malloc|5.005000||Viu
PERL_MEMORY_DEBUG_HEADER_SIZE|5.019009||Viu
PerlMemParse_calloc|5.006000||Viu
PerlMemParse_free|5.006000||Viu
PerlMemParse_free_lock|5.006000||Viu
PerlMemParse_get_lock|5.006000||Viu
PerlMemParse_is_locked|5.006000||Viu
PerlMemParse_malloc|5.006000||Viu
PerlMemParse_realloc|5.006000||Viu
PerlMem_realloc|5.005000||Viu
PerlMemShared_calloc|5.006000||Viu
PerlMemShared_free|5.006000||Viu
PerlMemShared_free_lock|5.006000||Viu
PerlMemShared_get_lock|5.006000||Viu
PerlMemShared_is_locked|5.006000||Viu
PerlMemShared_malloc|5.006000||Viu
PerlMemShared_realloc|5.006000||Viu
Perl_mfree|5.006000||Viu
PERL_MG_UFUNC|5.007001||Viu
Perl_modf|5.006000||Viu
putc|5.003007||Viu
put_charclass_bitmap_innards|5.021004||Viu
put_charclass_bitmap_innards_common|5.023008||Viu
put_charclass_bitmap_innards_invlist|5.023008||Viu
put_code_point|5.021004||Viu
putc_unlocked|5.003007||Viu
putenv|5.005000||Viu
put_range|5.019009||Viu
putw|5.003007||Viu
pv_display|5.006000|5.003007|p
pv_escape|5.009004|5.003007|p
Data-Enumerable-Lazy
view release on metacpan or search on metacpan
lib/Data/Enumerable/Lazy.pm view on Meta::CPAN
while (my $queue_item = $queue_enum->next) {
# do something with the queue item
}
In this example the client is blocked until there is an element available in
the queue, but it's hidden away from the clients who consume the data item by
item.
=head2 Kafka example
Data-FSM
view release on metacpan or search on metacpan
FSM/Transition.pm view on Meta::CPAN
use warnings;
use Data::FSM::Transition;
use Data::FSM::State;
my $locked = Data::FSM::State->new(
'name' => 'Locked',
);
my $unlocked = Data::FSM::State->new(
'name' => 'Unlocked',
);
my $obj = Data::FSM::Transition->new(
'callback' => sub {
my $self = shift;
print 'Id: '.$self->id."\n";
},
'from' => $locked,
'id' => 7,
'name' => 'Coin',
'to' => $unlocked,
);
# Print out.
print 'Id: '.$obj->id."\n";
print 'From: '.$obj->from->name."\n";
Data-Graph-Shared
view release on metacpan or search on metacpan
/* ================================================================
* Graph operations (must hold mutex)
* ================================================================ */
static inline int32_t graph_add_node_locked(GraphHandle *h, int64_t data) {
int32_t idx = graph_bit_alloc(h->node_bitmap, h->node_bwords, h->hdr->max_nodes);
if (idx < 0) return -1;
h->node_data[idx] = data;
h->node_heads[idx] = GRAPH_NONE;
__atomic_fetch_add(&h->hdr->node_count, 1, __ATOMIC_RELAXED);
return idx;
}
static inline int graph_add_edge_locked(GraphHandle *h, uint32_t src, uint32_t dst, int64_t weight) {
if (src >= h->hdr->max_nodes || dst >= h->hdr->max_nodes) return 0;
if (!graph_bit_set(h->node_bitmap, src) || !graph_bit_set(h->node_bitmap, dst))
return 0;
int32_t eidx = graph_bit_alloc(h->edge_bitmap, h->edge_bwords, h->hdr->max_edges);
if (eidx < 0) return 0;
h->node_heads[src] = (uint32_t)eidx;
__atomic_fetch_add(&h->hdr->edge_count, 1, __ATOMIC_RELAXED);
return 1;
}
static inline int graph_remove_node_locked(GraphHandle *h, uint32_t node) {
if (node >= h->hdr->max_nodes) return 0;
if (!graph_bit_set(h->node_bitmap, node)) return 0;
/* free all outgoing edges */
uint32_t eidx = h->node_heads[node];
while (eidx != GRAPH_NONE) {
graph_bit_free(h->node_bitmap, node);
__atomic_fetch_sub(&h->hdr->node_count, 1, __ATOMIC_RELAXED);
return 1;
}
/* Like remove_node_locked, but also splices every other node's adjacency
* list to drop edges pointing TO `node` (incoming edges). O(N+E). */
static inline int graph_remove_node_full_locked(GraphHandle *h, uint32_t node) {
if (node >= h->hdr->max_nodes) return 0;
if (!graph_bit_set(h->node_bitmap, node)) return 0;
uint32_t max_n = h->hdr->max_nodes;
for (uint32_t src = 0; src < max_n; src++) {
if (src == node) continue;
slot = &h->edges[eidx].next;
}
eidx = next;
}
}
return graph_remove_node_locked(h, node);
}
/* ================================================================
* Public API (lock + operation + unlock)
* ================================================================ */
static inline int32_t graph_add_node(GraphHandle *h, int64_t data) {
graph_mutex_lock(h->hdr);
int32_t r = graph_add_node_locked(h, data);
__atomic_fetch_add(&h->hdr->stat_ops, 1, __ATOMIC_RELAXED);
graph_mutex_unlock(h->hdr);
return r;
}
static inline int graph_add_edge(GraphHandle *h, uint32_t src, uint32_t dst, int64_t weight) {
graph_mutex_lock(h->hdr);
int r = graph_add_edge_locked(h, src, dst, weight);
__atomic_fetch_add(&h->hdr->stat_ops, 1, __ATOMIC_RELAXED);
graph_mutex_unlock(h->hdr);
return r;
}
static inline int graph_remove_node(GraphHandle *h, uint32_t node) {
graph_mutex_lock(h->hdr);
int r = graph_remove_node_locked(h, node);
__atomic_fetch_add(&h->hdr->stat_ops, 1, __ATOMIC_RELAXED);
graph_mutex_unlock(h->hdr);
return r;
}
static inline int graph_remove_node_full(GraphHandle *h, uint32_t node) {
graph_mutex_lock(h->hdr);
int r = graph_remove_node_full_locked(h, node);
__atomic_fetch_add(&h->hdr->stat_ops, 1, __ATOMIC_RELAXED);
graph_mutex_unlock(h->hdr);
return r;
}
Data-HashMap-Shared
view release on metacpan or search on metacpan
shm_generic.h view on Meta::CPAN
(reader write-preferring yield signal) */
uint64_t arena_cap; /* 72: immutable, read by seqlock string path */
uint8_t _reserved1[48]; /* 80-127 */
/* ---- Cache line 2 (128-191): rwlock + write-hot fields ---- */
uint32_t rwlock; /* 128: 0=unlocked, 1..0x7FFFFFFF=readers, 0x80000000|pid=writer */
uint32_t rwlock_waiters; /* 132 */
uint32_t size; /* 136 */
uint32_t tombstones; /* 140 */
uint32_t lru_head; /* 144: MRU slot index */
uint32_t lru_tail; /* 148: LRU slot index */
shm_generic.h view on Meta::CPAN
#else
__asm__ volatile("" ::: "memory");
#endif
}
/* Extract writer PID from rwlock value (lower 31 bits when write-locked). */
#define SHM_RWLOCK_WRITER_BIT 0x80000000U
#define SHM_RWLOCK_PID_MASK 0x7FFFFFFFU
#define SHM_RWLOCK_WR(pid) (SHM_RWLOCK_WRITER_BIT | ((uint32_t)(pid) & SHM_RWLOCK_PID_MASK))
/* Check if a PID is alive. Returns 1 if alive or unknown, 0 if definitely dead. */
shm_generic.h view on Meta::CPAN
shm_rwlock_spin_pause();
continue;
}
__atomic_add_fetch(waiters, 1, __ATOMIC_RELAXED);
cur = __atomic_load_n(lock, __ATOMIC_RELAXED);
/* Sleep when write-locked OR when yielding to waiting writers */
if (cur >= SHM_RWLOCK_WRITER_BIT || cur == 0) {
long rc = syscall(SYS_futex, lock, FUTEX_WAIT, cur,
&shm_lock_timeout, NULL, 0);
if (rc == -1 && errno == ETIMEDOUT) {
__atomic_sub_fetch(waiters, 1, __ATOMIC_RELAXED);
Data-Heap-Shared
view release on metacpan or search on metacpan
uint64_t total_size;
uint64_t data_off;
uint8_t _pad0[32];
uint32_t size; /* 64: current element count (futex word for pop) */
uint32_t mutex; /* 68: 0=free, HEAP_MUTEX_BIT|pid=locked */
uint32_t mutex_waiters; /* 72 */
uint32_t waiters_pop; /* 76 */
uint64_t stat_pushes; /* 80 */
uint64_t stat_pops; /* 88 */
uint64_t stat_waits; /* 96 */
Data-Keys
view release on metacpan or search on metacpan
lib/Data/Keys/E/Dir/Lock.pm view on Meta::CPAN
my $lock_key = $key;
$lock_key =~ s{/}{_}g;
my $lock_filename = File::Spec->catfile($self->lock_dir, $lock_key);
$self->_lock_dir_data->{$key}->{'counter'}++;
# return if already locked
return
if ($self->_lock_dir_data->{$key}->{'counter'} != 1);
my $lock_fh;
my $num_tries = 0;
lib/Data/Keys/E/Dir/Lock.pm view on Meta::CPAN
sub unlock {
my $self = shift;
my $key = shift;
if (not $self->_lock_dir_data->{$key}) {
warn 'unlock("'.$key.'") but is is not locked';
return;
};
$self->_lock_dir_data->{$key}->{'counter'}--;
Data-Lock
view release on metacpan or search on metacpan
lib/Data/Lock.pm view on Meta::CPAN
our @EXPORT_OK = qw/dlock dunlock/;
#my @builtin_types =
# qw/SCALAR ARRAY HASH CODE REF GLOB LVALUE FORMAT IO VSTRING Regexp/;
for my $locked ( 0, 1 ) {
my $subname = $locked ? 'dlock' : 'dunlock';
no strict 'refs';
*{$subname} = sub {
no warnings "uninitialized";
return if $_[1] and Internals::SvREADONLY( $_[0]) == $locked;
Internals::SvREADONLY( $_[0], $locked );
return unless my $type = Scalar::Util::reftype( $_[0] );
for (
$type eq 'ARRAY' ? @{ $_[0] }
: $type eq 'HASH' ? values %{ $_[0] }
: $type ne 'CODE' ? ${ $_[0] }
: ()
)
{
&$subname($_, 1) if ref $_;
Internals::SvREADONLY( $_, $locked );
}
$type eq 'ARRAY' ? Internals::SvREADONLY( @{ $_[0] }, $locked )
: $type eq 'HASH' ? Internals::SvREADONLY( %{ $_[0] }, $locked )
: $type ne 'CODE' ? Internals::SvREADONLY( ${ $_[0] }, $locked )
: undef;
};
}
1;
Data-Log-Shared
view release on metacpan or search on metacpan
uint64_t data_off; /* 24 */
uint8_t _pad0[32]; /* 32-63 */
uint64_t tail; /* 64: byte offset past last entry (CAS target) */
uint64_t count; /* 72: number of committed entries */
uint32_t waiters; /* 80: blocked tailers */
uint32_t wake_seq; /* 84: FUTEX_WAIT target (avoids 64-bit count wraparound) */
uint64_t stat_appends; /* 88 */
uint64_t stat_waits; /* 96 */
uint64_t stat_timeouts; /* 104 */
uint64_t truncation; /* 112: entries before this offset are invalid */
Data-MessagePack-Stream
view release on metacpan or search on metacpan
msgpack-3.3.0/include/msgpack/sysdep.h view on Meta::CPAN
# define WIN32_LEAN_AND_MEAN
# endif /* WIN32_LEAN_AND_MEAN */
# endif
typedef long _msgpack_atomic_counter_t;
#if defined(_AMD64_) || defined(_M_X64) || defined(_M_ARM64)
# define _msgpack_sync_decr_and_fetch(ptr) _InterlockedDecrement(ptr)
# define _msgpack_sync_incr_and_fetch(ptr) _InterlockedIncrement(ptr)
#else
# define _msgpack_sync_decr_and_fetch(ptr) InterlockedDecrement(ptr)
# define _msgpack_sync_incr_and_fetch(ptr) InterlockedIncrement(ptr)
#endif
#elif defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41)
# if defined(__cplusplus)
# define _msgpack_atomic_counter_header "msgpack/gcc_atomic.hpp"
Data-MessagePack
view release on metacpan or search on metacpan
include/msgpack/sysdep.h view on Meta::CPAN
#endif
#ifdef _WIN32
# define _msgpack_atomic_counter_header <windows.h>
typedef long _msgpack_atomic_counter_t;
# define _msgpack_sync_decr_and_fetch(ptr) InterlockedDecrement(ptr)
# define _msgpack_sync_incr_and_fetch(ptr) InterlockedIncrement(ptr)
#elif defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41)
# if defined(__cplusplus)
# define _msgpack_atomic_counter_header "gcc_atomic.hpp"
# else
Data-OFAC
view release on metacpan or search on metacpan
lib/Data/OFAC.pm view on Meta::CPAN
individuals and companies owned or controlled by, or acting for or on
behalf of, targeted countries. It also lists individuals, groups, and
entities, such as terrorists and narcotics traffickers designated under
programs that are not country-specific. Collectively, such individuals
and companies are called "Specially Designated Nationals" or "SDNs."
Their assets are blocked and U.S. persons are generally prohibited from
dealing with them.
This interface is helpful for insitutions that use Perl, and may have a
need to screen individuals as potential customers.
Data-ObjectStore
view release on metacpan or search on metacpan
lib/Data/ObjectStore.pm view on Meta::CPAN
Adds an advisory (flock) lock for each of the unique names given.
=head2 unlock()
Unlocks all names locked by this thread
=head2 sync()
Asks the data provider to sync to persistance.
lib/Data/ObjectStore.pm view on Meta::CPAN
Adds an advisory (flock) lock for each of the unique names given.
This may not be called twice in a row without an unlock in between.
=head2 unlock
Unlocks all names locked by this thread
=head2 _init
This is called the first time an object is created. It is not
called when the object is loaded from storage. This can be used
Data-Page-Viewport
view release on metacpan or search on metacpan
lib/Data/Page/Viewport.pm view on Meta::CPAN
my(@bound) = $page -> offset(- 1) -> bounds();
the call to C<sub offset(- 1)> will have no effect.
That is, when trying to go back past the beginning of the data set, the
bounds will be locked to values within 0 .. data_size.
Similarly, a call which would go beyond the other end of the data set,
will lock the bounds to the same range.
In short, you can't fall off the edge by calling C<sub offset()>.
Data-Password-Filter
view release on metacpan or search on metacpan
share/dictionary.txt view on Meta::CPAN
blockage's
blockages
blockbuster
blockbuster's
blockbusters
blocked
blockhead
blockhead's
blockheads
blockhouse
blockhouse's
share/dictionary.txt view on Meta::CPAN
cloche
cloche's
cloches
clock
clock's
clocked
clocking
clocks
clockwise
clockwork
clockwork's
share/dictionary.txt view on Meta::CPAN
deadliness
deadliness's
deadlining
deadlock
deadlock's
deadlocked
deadlocking
deadlocks
deadly
deadpan
deadpanned
share/dictionary.txt view on Meta::CPAN
floaters
floating
floats
flock
flock's
flocked
flocking
flocks
floe
floe's
floes
share/dictionary.txt view on Meta::CPAN
griding
gridiron
gridiron's
gridirons
gridlock
gridlocked
gridlocking
gridlocks
grids
grief
grief's
share/dictionary.txt view on Meta::CPAN
interlink
interlinked
interlinking
interlinks
interlock
interlocked
interlocking
interlocks
interlocutory
interloper
interloper's
share/dictionary.txt view on Meta::CPAN
landing's
landings
landladies
landlady
landlady's
landlocked
landlord
landlord's
landlords
landlubber
landlubber's
share/dictionary.txt view on Meta::CPAN
loci
loci's
lock
lock's
lockable
locked
locker
locker's
lockers
locket
locket's
share/dictionary.txt view on Meta::CPAN
paddocks
paddy
paddy's
padlock
padlock's
padlocked
padlocking
padlocks
padre
padre's
padres
share/dictionary.txt view on Meta::CPAN
roadbed
roadbed's
roadbeds
roadblock
roadblock's
roadblocked
roadblocking
roadblocks
roadhouse
roadhouse's
roadhouses
share/dictionary.txt view on Meta::CPAN
unbidden
unbind
unbinding
unbinds
unblock
unblocked
unblocking
unblocks
unblushing
unbolt
unbolted
share/dictionary.txt view on Meta::CPAN
unload
unloaded
unloading
unloads
unlock
unlocked
unlocking
unlocks
unloose
unloosed
unlooses
Data-Password-zxcvbn
view release on metacpan or search on metacpan
lib/Data/Password/zxcvbn/RankedDictionaries/Common.pm view on Meta::CPAN
'lobito' => 18300,
'lobster' => 3894,
'lobster1' => 14038,
'location' => 26114,
'lockdown' => 11642,
'locked' => 10146,
'locker' => 18028,
'lockout' => 13020,
'lockwood' => 29171,
'locoloco' => 13368,
'locura' => 16471,
Data-Peek
view release on metacpan or search on metacpan
Makefile.PL view on Meta::CPAN
require 5.008001; # <- also see postamble at the bottom for META.yml
use strict;
if ($ENV{PERLBREW_HOME} and $ENV{PERLBREW_HOME} eq "/home/njh/.perlbrew") {
warn "Your smokers have been blocked because of consistent failures that\n";
warn " are all caused by the smoking setup and not by module errors. I you\n";
warn " have fixed that all, please inform the authors, so this block can\n";
warn " be lifted again.\n";
exit 0;
}
Data-Pool-Shared
view release on metacpan or search on metacpan
lib/Data/Pool/Shared.pm view on Meta::CPAN
=item C<used> — currently allocated slot count
=item C<available> — currently free slot count (C<capacity - used>)
=item C<waiters> — processes currently blocked on C<alloc>
=item C<mmap_size> — total mmap region size in bytes
=item C<allocs> — cumulative successful allocations
Data-PubSub-Shared
view release on metacpan or search on metacpan
const char *str;
if (utf8)
str = SvPVutf8(val, len);
else
str = SvPV(val, len);
int r = pubsub_str_publish_locked(h, str, (uint32_t)len, utf8);
if (r == -1) {
pubsub_mutex_unlock(h->hdr);
croak("publish_multi: message too long (%u > %u)", (unsigned)len, h->msg_size);
}
RETVAL++;
Data-Queue-Shared
view release on metacpan or search on metacpan
lib/Data/Queue/Shared.pm view on Meta::CPAN
Stats keys: C<size>, C<capacity>, C<mmap_size>, C<push_ok>, C<pop_ok>,
C<push_full>, C<pop_empty>, C<recoveries>, C<push_waiters>, C<pop_waiters>.
Str queues additionally include C<arena_cap> and C<arena_used>.
All counters are approximate under concurrent access (diagnostic only).
C<push_waiters>/C<pop_waiters> show currently blocked producers/consumers.
=head2 Event Loop Integration (eventfd)
my $fd = $q->eventfd; # create eventfd, returns fd number
$q->eventfd_set($fd); # use an existing fd (e.g. inherited via fork)
Data-Radius
view release on metacpan or search on metacpan
radius/starent view on Meta::CPAN
VALUE SN1-Disconnect-Reason duplicate-session-detected 344
VALUE SN1-Disconnect-Reason sgsn-xid-response-failure 345
VALUE SN1-Disconnect-Reason sgsn-nse-cleanup 346
VALUE SN1-Disconnect-Reason sgsn-gtp-req-failure 347
VALUE SN1-Disconnect-Reason sgsn-imsi-mismatch 348
VALUE SN1-Disconnect-Reason sgsn-bvc-blocked 349
VALUE SN1-Disconnect-Reason sgsn-attach-on-inbound-irau 350
VALUE SN1-Disconnect-Reason sgsn-attach-on-outbound-irau 351
VALUE SN1-Disconnect-Reason sgsn-incorrect-state 352
VALUE SN1-Disconnect-Reason sgsn-t3350-expiry 353
VALUE SN1-Disconnect-Reason sgsn-page-timer-expiry 354
( run in 1.753 second using v1.01-cache-2.11-cpan-39bf76dae61 )