Result:
found more than 856 distributions - search limited to the first 2001 files matching your query
( run in 4.042 )
Data-Password-zxcvbn-French
view release on metacpan or search on metacpan
lib/Data/Password/zxcvbn/RankedDictionaries/French.pm view on Meta::CPAN
'alimenter' => 8872,
'alimentes' => 12163,
'aliments' => 5511,
'alinea' => 16706,
'alite' => 27647,
'alive' => 21499,
'aliyev' => 27648,
'allah' => 16050,
'allaient' => 6760,
'allait' => 2746,
'allant' => 1737,
lib/Data/Password/zxcvbn/RankedDictionaries/French.pm view on Meta::CPAN
'saline' => 19168,
'salines' => 17653,
'salinite' => 19508,
'salins' => 19509,
'salisbury' => 21860,
'salive' => 22319,
'salle' => 427,
'sally' => 12026,
'salon' => 1565,
'salonique' => 24548,
'salons' => 5543,
Data-Password-zxcvbn-German
view release on metacpan or search on metacpan
lib/Data/Password/zxcvbn/RankedDictionaries/German.pm view on Meta::CPAN
'alice' => 4230,
'alicia' => 26309,
'alien' => 26310,
'aliens' => 19863,
'alison' => 19144,
'alive' => 20299,
'alkohol' => 4344,
'alkoholgehalt' => 27985,
'alkoholiker' => 23131,
'alkoholkonsum' => 27986,
'allah' => 24963,
Data-PerfectHash-Shared
view release on metacpan or search on metacpan
memcpy(img+arena_off+awrite, b->arena+b->sslots[idx[i]].off, len);
ss->off=awrite; ss->len=len; awrite+=len; }
}
/* Atomic write: build a temp file in the SAME directory, then rename(2) it
* over `path`. Readers mmap `path`, and O_TRUNC on a mapped file would
* SIGBUS them; rename instead leaves the old inode alive until they unmap.
* mkstemp creates it O_CREAT|O_EXCL 0600 (no symlink to follow, so unlike
* ph_open's read side this needs no O_NOFOLLOW); fchmod applies the requested mode after. */
size_t plen = strlen(path);
char *tmp = (char*)malloc(plen + 12);
if (!tmp) { snprintf(err,el,"out of memory"); PHB_FREEALL(); return -1; }
Data-Pool-Shared
view release on metacpan or search on metacpan
eg/guard.pl view on Meta::CPAN
my $guard = $pool->alloc_guard;
printf "scalar guard: used = %d\n", $pool->used;
}
printf "after scalar guard: used = %d\n\n", $pool->used;
# try_alloc_guard — fill pool, guards keep slots alive
my @guards;
for (1..4) {
my ($idx, $guard) = $pool->try_alloc_guard;
printf "try_alloc_guard: %s (used=%d)\n",
defined $idx ? "slot $idx" : "full", $pool->used;
Data-PubSub-Shared
view release on metacpan or search on metacpan
PREINIT:
EXTRACT_SUB("Data::PubSub::Shared::Int::Sub", self);
int64_t value;
CODE:
RETVAL = 0;
/* Keep the backing handle alive across the callback: a callback that
* drops self's last reference would free `sub` mid-loop (UAF). Guard
* the referent (the blessed handle), not the RV container -- assigning
* undef to self overwrites the container and frees the referent. */
SV *psx_guard = SvRV(self);
SvREFCNT_inc_simple_void_NN(psx_guard);
const char *str;
uint32_t len;
bool utf8;
CODE:
RETVAL = 0;
/* Keep the backing handle alive across the callback: a callback that
* drops self's last reference would free `sub` mid-loop (UAF). Guard
* the referent (the blessed handle), not the RV container -- assigning
* undef to self overwrites the container and frees the referent. */
SV *psx_guard = SvRV(self);
SvREFCNT_inc_simple_void_NN(psx_guard);
PREINIT:
EXTRACT_SUB("Data::PubSub::Shared::Int32::Sub", self);
int32_t value;
CODE:
RETVAL = 0;
/* Keep the backing handle alive across the callback: a callback that
* drops self's last reference would free `sub` mid-loop (UAF). Guard
* the referent (the blessed handle), not the RV container -- assigning
* undef to self overwrites the container and frees the referent. */
SV *psx_guard = SvRV(self);
SvREFCNT_inc_simple_void_NN(psx_guard);
PREINIT:
EXTRACT_SUB("Data::PubSub::Shared::Int16::Sub", self);
int16_t value;
CODE:
RETVAL = 0;
/* Keep the backing handle alive across the callback: a callback that
* drops self's last reference would free `sub` mid-loop (UAF). Guard
* the referent (the blessed handle), not the RV container -- assigning
* undef to self overwrites the container and frees the referent. */
SV *psx_guard = SvRV(self);
SvREFCNT_inc_simple_void_NN(psx_guard);
Data-Queue-Shared
view release on metacpan or search on metacpan
#define QUEUE_MUTEX_WRITER_BIT 0x80000000U
#define QUEUE_MUTEX_PID_MASK 0x7FFFFFFFU
#define QUEUE_MUTEX_VAL(pid) (QUEUE_MUTEX_WRITER_BIT | ((uint32_t)(pid) & QUEUE_MUTEX_PID_MASK))
/* A zombie (dead but not yet reaped) still answers kill(pid,0) as alive, so a
* process that crashed while holding the lock and lingers unreaped would never
* be recovered. Treat /proc/<pid>/stat state 'Z' as dead. Linux-only (as is
* this module); if /proc is unreadable we fall back to "alive" (safe: we never
* force-recover a possibly-live holder). */
static inline int queue_pid_is_zombie(uint32_t pid) {
char path[32], buf[256];
snprintf(path, sizeof(path), "/proc/%u/stat", (unsigned)pid);
int fd = open(path, O_RDONLY | O_CLOEXEC);
/* "pid (comm) state ..."; comm may contain ')', so scan to the last one. */
char *rp = strrchr(buf, ')');
if (!rp || rp + 2 >= buf + n) return 0; /* need ") X" within the bytes read */
return rp[1] == ' ' && rp[2] == 'Z';
}
static inline int queue_pid_alive(uint32_t pid) {
if (pid == 0) return 1; /* no owner recorded, assume alive */
if (kill((pid_t)pid, 0) == -1 && errno == ESRCH) return 0; /* definitely dead */
return !queue_pid_is_zombie(pid); /* kill() also succeeds for a zombie -> treat as dead */
}
static const struct timespec queue_lock_timeout = { QUEUE_LOCK_TIMEOUT_SEC, 0 };
if (rc == -1 && errno == ETIMEDOUT) {
__atomic_sub_fetch(&hdr->mutex_waiters, 1, __ATOMIC_RELAXED);
uint32_t val = __atomic_load_n(&hdr->mutex, __ATOMIC_RELAXED);
if (val >= QUEUE_MUTEX_WRITER_BIT) {
uint32_t pid = val & QUEUE_MUTEX_PID_MASK;
if (!queue_pid_alive(pid))
queue_recover_stale_mutex(hdr, val);
}
spin = 0;
continue;
}
Data-Radius
view release on metacpan or search on metacpan
radius/laurel view on Meta::CPAN
ATTRIBUTE Laurel-PPPOE-Session-Limit 152 integer
ATTRIBUTE Laurel-PPPOE-Src-MAC-Validation 153 integer
ATTRIBUTE Laurel-PPP-Authentication 154 integer
ATTRIBUTE Laurel-CHAP-Challenge-Interval 155 integer
ATTRIBUTE Laurel-CHAP-Retries 157 integer
ATTRIBUTE Laurel-PPP-Keepalives 158 integer
ATTRIBUTE Laurel-Magic-Number 159 integer
ATTRIBUTE Laurel-Maximum-Receive-Unit 160 integer
ATTRIBUTE Laurel-Domain-Filter 161 string
ATTRIBUTE Laurel-DHCP 168 integer
ATTRIBUTE Laurel-DHCP-Host-Limit 169 integer
radius/laurel view on Meta::CPAN
VALUE Laurel-PPP-Authentication PAP 1
VALUE Laurel-PPP-Authentication CHAP 2
VALUE Laurel-PPP-Authentication PAP-then-CHAP 3
VALUE Laurel-PPP-Authentication CHAP-then-PAP 4
VALUE Laurel-PPP-Keepalives Disable 0
VALUE Laurel-PPP-Keepalives Enable 1
VALUE Laurel-PPPOE-Src-MAC-Validation No 0
VALUE Laurel-PPPOE-Src-MAC-Validation Yes 1
VALUE Laurel-Protocol None 0
Data-RadixTree-Shared
view release on metacpan or search on metacpan
/* Writer word encoding: WRITER_BIT|pid when write-locked, 0 when free. */
#define RDX_RWLOCK_WRITER_BIT 0x80000000U
#define RDX_RWLOCK_PID_MASK 0x7FFFFFFFU
#define RDX_RWLOCK_WR(pid) (RDX_RWLOCK_WRITER_BIT | ((uint32_t)(pid) & RDX_RWLOCK_PID_MASK))
/* A zombie (dead but not yet reaped) still answers kill(pid,0) as alive, so a
* process that crashed while holding the lock and lingers unreaped would never
* be recovered. Treat /proc/<pid>/stat state 'Z' as dead. Linux-only (as is
* this module); if /proc is unreadable we fall back to "alive" (safe: we never
* force-recover a possibly-live holder). */
static inline int rdx_pid_is_zombie(uint32_t pid) {
char path[32], buf[256];
snprintf(path, sizeof(path), "/proc/%u/stat", (unsigned)pid);
int fd = open(path, O_RDONLY | O_CLOEXEC);
/* "pid (comm) state ..."; comm may contain ')', so scan to the last one. */
char *rp = strrchr(buf, ')');
if (!rp || rp + 2 >= buf + n) return 0; /* need ") X" within the bytes read */
return rp[1] == ' ' && rp[2] == 'Z';
}
/* 1 if alive or unknown, 0 if definitely dead. Cannot detect PID reuse: a
* recycled PID reports "alive" and the slot is not reclaimed until that
* process exits. See "Crash Safety" in the POD. */
static inline int rdx_pid_alive(uint32_t pid) {
if (pid == 0) return 1; /* no owner recorded, assume alive */
if (kill((pid_t)pid, 0) == -1 && errno == ESRCH) return 0; /* definitely dead */
return !rdx_pid_is_zombie(pid); /* kill() also succeeds for a zombie -> treat as dead */
}
/* Force-recover a stale WRITE lock left by a dead writer (held or mid-drain).
* if its rdepth>0: clearing pid drops the dead reader's entire contribution
* (a writer scan ignores rdepth when pid==0) and we reset rdepth to 0 as we
* claim it. */
for (uint32_t i = 0; i < RDX_READER_SLOTS; i++) {
uint32_t dpid = __atomic_load_n(&h->reader_slots[i].pid, __ATOMIC_ACQUIRE);
if (dpid == 0 || dpid == now_pid || rdx_pid_alive(dpid)) continue;
uint32_t expected = dpid;
if (__atomic_compare_exchange_n(&h->reader_slots[i].pid, &expected, now_pid, 0,
__ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) {
__atomic_store_n(&h->reader_slots[i].rdepth, 0, __ATOMIC_RELAXED);
rdx_occ_set(h, i);
* wlock drains readers, and it clears dead readers inline in its own scan. */
static inline void rdx_recover_after_timeout(RdxHandle *h) {
uint32_t val = __atomic_load_n(&h->hdr->wlock, __ATOMIC_RELAXED);
if (val >= RDX_RWLOCK_WRITER_BIT) {
uint32_t pid = val & RDX_RWLOCK_PID_MASK;
if (!rdx_pid_alive(pid))
rdx_recover_stale_lock(h, val);
}
}
/* Bump/drop the parked-waiter hint. Both readers (blocked at the gate) and
spin = 0;
continue;
}
/* wlock != 0: a writer holds or is acquiring. Recover if it is dead. */
if (cur >= RDX_RWLOCK_WRITER_BIT &&
!rdx_pid_alive(cur & RDX_RWLOCK_PID_MASK)) {
rdx_recover_stale_lock(h, cur);
spin = 0;
continue;
}
if (__builtin_expect(spin < RDX_RWLOCK_SPIN_LIMIT, 1)) {
if (__atomic_compare_exchange_n(&hdr->wlock, &expected, mypid,
0, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED))
break;
/* Contended: expected now holds the current wlock value. */
if (expected >= RDX_RWLOCK_WRITER_BIT &&
!rdx_pid_alive(expected & RDX_RWLOCK_PID_MASK)) {
rdx_recover_stale_lock(h, expected);
spin = 0;
continue;
}
if (__builtin_expect(spin < RDX_RWLOCK_SPIN_LIMIT, 1)) {
word &= word - 1; /* consume this bit (local copy) */
uint32_t rd = __atomic_load_n(&h->reader_slots[i].rdepth, __ATOMIC_SEQ_CST);
if (rd == 0) continue; /* occupied but not read-locking now */
uint32_t pid = __atomic_load_n(&h->reader_slots[i].pid, __ATOMIC_ACQUIRE);
if (pid == 0) continue; /* stale rdepth on a freed slot */
if (!rdx_pid_alive(pid)) {
/* Dead reader: drop its pid so the slot no longer counts. Leave
* the occ bit set (harmless -- a later scan hits pid==0 and skips,
* a re-claim re-sets it) to avoid racing a concurrent claimant. */
uint32_t ep = pid;
__atomic_compare_exchange_n(&h->reader_slots[i].pid, &ep, 0,
Data-Random-Contact
view release on metacpan or search on metacpan
lib/Data/Random/Contact/Language/EN.pm view on Meta::CPAN
alike
alimentary
alimony
alimony's
alit
alive
alkali
alkali's
alkalies
alkaline
alkalinity
Data-Random
view release on metacpan or search on metacpan
lib/Data/Random/dict view on Meta::CPAN
aliment
aliments
alimony
Alison
Alistair
alive
alkali
alkaline
alkalis
alkaloid
alkaloids
Data-ReqRep-Shared
view release on metacpan or search on metacpan
#define REQREP_MUTEX_WRITER_BIT 0x80000000U
#define REQREP_MUTEX_PID_MASK 0x7FFFFFFFU
#define REQREP_MUTEX_VAL(pid) (REQREP_MUTEX_WRITER_BIT | ((uint32_t)(pid) & REQREP_MUTEX_PID_MASK))
/* A zombie (dead but not yet reaped) still answers kill(pid,0) as alive, so a
* process that crashed while holding the lock and lingers unreaped would never
* be recovered. Treat /proc/<pid>/stat state 'Z' as dead. Linux-only (as is
* this module); if /proc is unreadable we fall back to "alive" (safe: we never
* force-recover a possibly-live holder). */
static inline int reqrep_pid_is_zombie(uint32_t pid) {
char path[32], buf[256];
snprintf(path, sizeof(path), "/proc/%u/stat", (unsigned)pid);
int fd = open(path, O_RDONLY | O_CLOEXEC);
/* "pid (comm) state ..."; comm may contain ')', so scan to the last one. */
char *rp = strrchr(buf, ')');
if (!rp || rp + 2 >= buf + n) return 0; /* need ") X" within the bytes read */
return rp[1] == ' ' && rp[2] == 'Z';
}
static inline int reqrep_pid_alive(uint32_t pid) {
if (pid == 0) return 1; /* no owner recorded, assume alive */
if (kill((pid_t)pid, 0) == -1 && errno == ESRCH) return 0; /* definitely dead */
return !reqrep_pid_is_zombie(pid); /* kill() also succeeds for a zombie -> treat as dead */
}
static const struct timespec reqrep_lock_timeout = { REQREP_LOCK_TIMEOUT_SEC, 0 };
if (rc == -1 && errno == ETIMEDOUT) {
__atomic_sub_fetch(&hdr->mutex_waiters, 1, __ATOMIC_RELAXED);
uint32_t val = __atomic_load_n(&hdr->mutex, __ATOMIC_RELAXED);
if (val >= REQREP_MUTEX_WRITER_BIT) {
uint32_t pid = val & REQREP_MUTEX_PID_MASK;
if (!reqrep_pid_alive(pid))
reqrep_recover_stale_mutex(hdr, val);
}
spin = 0;
continue;
}
* still belongs to a client that may have died, and skipping it here
* would leak the slot for the life of the segment. */
if (state != RESP_ACQUIRED && state != RESP_READY && state != RESP_WRITING)
continue;
uint32_t pid = __atomic_load_n(&slot->owner_pid, __ATOMIC_ACQUIRE);
if (!pid || reqrep_pid_alive(pid)) continue;
/* Claim exclusive recovery rights by CASing the dead owner to 0.
* Loser of this race exits -- winner of state CAS would have already
* progressed; we can't safely race the state transition. */
uint32_t expected_pid = pid;
Data-Reservoir-Shared
view release on metacpan or search on metacpan
if (!iv || !*iv || !wv || !*wv)
croak("Data::Reservoir::Shared->add_many: each element must be [item, weight]");
/* Pin both element SVs by value BEFORE any magic runs: the item's
* SvPVbyte (or the weight's get-magic) can free or reassign the
* pair AV, dangling the other's raw SV** slot. The mortal INC
* keeps both alive for this branch even if the pair AV is freed. */
SV *isv = *iv, *wsv = *wv;
SvREFCNT_inc(isv); sv_2mortal(isv);
SvREFCNT_inc(wsv); sv_2mortal(wsv);
{
STRLEN len;
Data-Riak
view release on metacpan or search on metacpan
lib/Data/Riak/HTTP.pm view on Meta::CPAN
$opts{MaxLineLength} = 0;
@LWP::Protocol::http::EXTRA_SOCK_OPTS = %opts;
my $ua = LWP::UserAgent->new(
timeout => $self->timeout,
keep_alive => 1,
);
$CONN_CACHE ||= LWP::ConnCache->new;
$ua->conn_cache( $CONN_CACHE );
Data-RoaringBitmap-Shared
view release on metacpan or search on metacpan
/* Writer word encoding: WRITER_BIT|pid when write-locked, 0 when free. */
#define RB_RWLOCK_WRITER_BIT 0x80000000U
#define RB_RWLOCK_PID_MASK 0x7FFFFFFFU
#define RB_RWLOCK_WR(pid) (RB_RWLOCK_WRITER_BIT | ((uint32_t)(pid) & RB_RWLOCK_PID_MASK))
/* A zombie (dead but not yet reaped) still answers kill(pid,0) as alive, so a
* process that crashed while holding the lock and lingers unreaped would never
* be recovered. Treat /proc/<pid>/stat state 'Z' as dead. Linux-only (as is
* this module); if /proc is unreadable we fall back to "alive" (safe: we never
* force-recover a possibly-live holder). */
static inline int rb_pid_is_zombie(uint32_t pid) {
char path[32], buf[256];
snprintf(path, sizeof(path), "/proc/%u/stat", (unsigned)pid);
int fd = open(path, O_RDONLY | O_CLOEXEC);
/* "pid (comm) state ..."; comm may contain ')', so scan to the last one. */
char *rp = strrchr(buf, ')');
if (!rp || rp + 2 >= buf + n) return 0; /* need ") X" within the bytes read */
return rp[1] == ' ' && rp[2] == 'Z';
}
/* 1 if alive or unknown, 0 if definitely dead. Cannot detect PID reuse: a
* recycled PID reports "alive" and the slot is not reclaimed until that
* process exits. See "Crash Safety" in the POD. */
static inline int rb_pid_alive(uint32_t pid) {
if (pid == 0) return 1; /* no owner recorded, assume alive */
if (kill((pid_t)pid, 0) == -1 && errno == ESRCH) return 0; /* definitely dead */
return !rb_pid_is_zombie(pid); /* kill() also succeeds for a zombie -> treat as dead */
}
/* Force-recover a stale WRITE lock left by a dead writer (held or mid-drain).
* if its rdepth>0: clearing pid drops the dead reader's entire contribution
* (a writer scan ignores rdepth when pid==0) and we reset rdepth to 0 as we
* claim it. */
for (uint32_t i = 0; i < RB_READER_SLOTS; i++) {
uint32_t dpid = __atomic_load_n(&h->reader_slots[i].pid, __ATOMIC_ACQUIRE);
if (dpid == 0 || dpid == now_pid || rb_pid_alive(dpid)) continue;
uint32_t expected = dpid;
if (__atomic_compare_exchange_n(&h->reader_slots[i].pid, &expected, now_pid, 0,
__ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) {
__atomic_store_n(&h->reader_slots[i].rdepth, 0, __ATOMIC_RELAXED);
rb_occ_set(h, i);
* wlock drains readers, and it clears dead readers inline in its own scan. */
static inline void rb_recover_after_timeout(RbHandle *h) {
uint32_t val = __atomic_load_n(&h->hdr->wlock, __ATOMIC_RELAXED);
if (val >= RB_RWLOCK_WRITER_BIT) {
uint32_t pid = val & RB_RWLOCK_PID_MASK;
if (!rb_pid_alive(pid))
rb_recover_stale_lock(h, val);
}
}
/* Bump/drop the parked-waiter hint. Both readers (blocked at the gate) and
spin = 0;
continue;
}
/* wlock != 0: a writer holds or is acquiring. Recover if it is dead. */
if (cur >= RB_RWLOCK_WRITER_BIT &&
!rb_pid_alive(cur & RB_RWLOCK_PID_MASK)) {
rb_recover_stale_lock(h, cur);
spin = 0;
continue;
}
if (__builtin_expect(spin < RB_RWLOCK_SPIN_LIMIT, 1)) {
if (__atomic_compare_exchange_n(&hdr->wlock, &expected, mypid,
0, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED))
break;
/* Contended: expected now holds the current wlock value. */
if (expected >= RB_RWLOCK_WRITER_BIT &&
!rb_pid_alive(expected & RB_RWLOCK_PID_MASK)) {
rb_recover_stale_lock(h, expected);
spin = 0;
continue;
}
if (__builtin_expect(spin < RB_RWLOCK_SPIN_LIMIT, 1)) {
word &= word - 1; /* consume this bit (local copy) */
uint32_t rd = __atomic_load_n(&h->reader_slots[i].rdepth, __ATOMIC_SEQ_CST);
if (rd == 0) continue; /* occupied but not read-locking now */
uint32_t pid = __atomic_load_n(&h->reader_slots[i].pid, __ATOMIC_ACQUIRE);
if (pid == 0) continue; /* stale rdepth on a freed slot */
if (!rb_pid_alive(pid)) {
/* Dead reader: drop its pid so the slot no longer counts. Leave
* the occ bit set (harmless -- a later scan hits pid==0 and skips,
* a re-claim re-sets it) to avoid racing a concurrent claimant. */
uint32_t ep = pid;
__atomic_compare_exchange_n(&h->reader_slots[i].pid, &ep, 0,
Data-Roundtrip
view release on metacpan or search on metacpan
lib/Data/Roundtrip.pm view on Meta::CPAN
EOS
# this is OK also:
# - \"w: 1
my $pv = eval { YAML::Load($yamlstr) };
if( $@ ){ die "failed(1): ". $@ }
# it's OK! still alive.
I have provided an author-only test (C<make deficiencies>) which
tests all three of them on the edge cases. Both L<YAML::PP>
and L<YAML::XS> pass the tests.
Data-STUID
view release on metacpan or search on metacpan
lib/Data/STUID/Generator.pm view on Meta::CPAN
use constant SERIAL_SHIFT => HOST_ID_BITS;
# XXX WHAT ON EARTH ARE YOU DOING HERE?
#
# We normally protect ourselves from leaking resources in DESTROY, but...
# when we are enveloped in a PSGI app, a reference to us stays alive until
# global destruction.
#
# At global destruction time, the order in which objects get cleaned
# up is undefined, so it often happens that the mutex/shared memory gets
# freed before the dispatcher object -- so when DESTROY gets called,
Data-SegmentTree-Shared
view release on metacpan or search on metacpan
lib/Data/SegmentTree/Shared.pm view on Meta::CPAN
store (a no-op for anonymous and memfd trees); C<unlink> removes the backing file
(also callable as C<< Class->unlink($path) >>); C<path> returns the backing path
(C<undef> for anonymous, memfd, or fd-reopened trees) and C<memfd> the backing
descriptor. The descriptor C<memfd> returns is B<owned by the object> and closed
when the object is destroyed; do not close it yourself. Pass it to another process
(or C<new_from_fd>) while the object is still alive.
=head1 SHARING ACROSS PROCESSES
The tree lives in a shared mapping, exposed the same three ways as the rest of
the family: a B<backing file>, an B<anonymous mapping inherited across
Data-SortedSet-Shared
view release on metacpan or search on metacpan
lib/Data/SortedSet/Shared.pm view on Meta::CPAN
=item *
B<A memfd> -- create with C<< new_memfd($name, $max) >> and hand its C<memfd>
descriptor to an unrelated process (over a UNIX socket with C<SCM_RIGHTS>, or
while the creator is alive via C</proc/$pid/fd/$n>), which reopens it with
C<< new_from_fd($fd) >>.
=back
# children populate a fork-shared set; the parent reads the result
Data-SpatialHash-Shared
view release on metacpan or search on metacpan
eg/memfd_share.pl view on Meta::CPAN
if (!$pid) { # producer
close $R;
my $s = Data::SpatialHash::Shared->new_memfd('shared-index', 1000, 0, 1.0);
$s->insert(rand()*100, rand()*100, $_) for 1 .. 50;
syswrite $W, $$ . ' ' . $s->memfd . "\n";
select undef, undef, undef, 2; # stay alive while the consumer attaches
exit 0;
}
close $W;
my ($cpid, $cfd) = split ' ', scalar(<$R>);
open my $fh, '+<', "/proc/$cpid/fd/$cfd" or die "attach: $!";
Data-Sync-Shared
view release on metacpan or search on metacpan
#else
__asm__ volatile("" ::: "memory");
#endif
}
/* A zombie (dead but not yet reaped) still answers kill(pid,0) as alive, so a
* process that crashed while holding the lock and lingers unreaped would never
* be recovered. Treat /proc/<pid>/stat state 'Z' as dead. Linux-only (as is
* this module); if /proc is unreadable we fall back to "alive" (safe: we never
* force-recover a possibly-live holder). */
static inline int sync_pid_is_zombie(uint32_t pid) {
char path[32], buf[256];
snprintf(path, sizeof(path), "/proc/%u/stat", (unsigned)pid);
int fd = open(path, O_RDONLY | O_CLOEXEC);
/* "pid (comm) state ..."; comm may contain ')', so scan to the last one. */
char *rp = strrchr(buf, ')');
if (!rp || rp + 2 >= buf + n) return 0; /* need ") X" within the bytes read */
return rp[1] == ' ' && rp[2] == 'Z';
}
static inline int sync_pid_alive(uint32_t pid) {
if (pid == 0) return 1; /* no owner recorded, assume alive */
if (kill((pid_t)pid, 0) == -1 && errno == ESRCH) return 0; /* definitely dead */
return !sync_pid_is_zombie(pid); /* kill() also succeeds for a zombie -> treat as dead */
}
/* Convert timeout in seconds (double) to absolute deadline */
if (rc == -1 && errno == ETIMEDOUT) {
__atomic_sub_fetch(&hdr->mutex_waiters, 1, __ATOMIC_RELAXED);
uint32_t val = __atomic_load_n(&hdr->mutex, __ATOMIC_RELAXED);
if (val >= SYNC_MUTEX_WRITER_BIT) {
uint32_t pid = val & SYNC_MUTEX_PID_MASK;
if (!sync_pid_alive(pid))
sync_recover_stale_mutex(hdr, val);
}
spin = 0;
continue;
}
* if its rdepth>0: clearing pid drops the dead reader's entire contribution
* (a writer scan ignores rdepth when pid==0) and we reset rdepth to 0 as we
* claim it. */
for (uint32_t i = 0; i < SYNC_READER_SLOTS; i++) {
uint32_t dpid = __atomic_load_n(&h->reader_slots[i].pid, __ATOMIC_ACQUIRE);
if (dpid == 0 || dpid == now_pid || sync_pid_alive(dpid)) continue;
uint32_t expected = dpid;
if (__atomic_compare_exchange_n(&h->reader_slots[i].pid, &expected, now_pid, 0,
__ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) {
__atomic_store_n(&h->reader_slots[i].rdepth, 0, __ATOMIC_RELAXED);
sync_occ_set(h, i);
static inline void sync_recover_after_timeout(SyncHandle *h) {
SyncHeader *hdr = h->hdr;
uint32_t val = __atomic_load_n(&hdr->value, __ATOMIC_RELAXED);
if (val >= SYNC_RWLOCK_WRITER_BIT) {
uint32_t pid = val & SYNC_RWLOCK_PID_MASK;
if (!sync_pid_alive(pid))
sync_recover_stale_rwlock(hdr, val);
}
}
/* Bump/drop the parked-waiter hint. Both readers (blocked at the gate) and
word &= word - 1; /* consume this bit (local copy) */
uint32_t rd = __atomic_load_n(&h->reader_slots[i].rdepth, __ATOMIC_SEQ_CST);
if (rd == 0) continue; /* occupied but not read-locking now */
uint32_t pid = __atomic_load_n(&h->reader_slots[i].pid, __ATOMIC_ACQUIRE);
if (pid == 0) continue; /* no live owner -- stale rdepth, ignore */
if (!sync_pid_alive(pid)) {
/* Dead reader: clear its pid so the slot no longer counts (its
* whole contribution WAS this slot). Leave the occ bit SET
* (harmless -- a later scan hits pid==0 and skips, a re-claim
* re-sets it) to avoid racing a concurrent claimant. rdepth is
* left stale but is now ignored (pid==0) and zeroed by the next
spin = 0;
continue;
}
/* value != 0: a writer holds or is acquiring. Recover if it is dead. */
if (cur >= SYNC_RWLOCK_WRITER_BIT &&
!sync_pid_alive(cur & SYNC_RWLOCK_PID_MASK)) {
sync_recover_stale_rwlock(hdr, cur);
spin = 0;
continue;
}
if (__builtin_expect(spin < SYNC_SPIN_LIMIT, 1)) {
SyncHeader *hdr = h->hdr;
uint32_t cur = __atomic_load_n(&hdr->value, __ATOMIC_ACQUIRE);
if (cur != 0) {
/* A writer holds or is acquiring. Recover once if it is dead, re-read. */
if (cur >= SYNC_RWLOCK_WRITER_BIT &&
!sync_pid_alive(cur & SYNC_RWLOCK_PID_MASK)) {
sync_recover_stale_rwlock(hdr, cur);
cur = __atomic_load_n(&hdr->value, __ATOMIC_ACQUIRE);
}
if (cur != 0) return 0;
}
return 0; /* deadline passed; we hold nothing */
spin = 0;
continue;
}
if (cur >= SYNC_RWLOCK_WRITER_BIT &&
!sync_pid_alive(cur & SYNC_RWLOCK_PID_MASK)) {
sync_recover_stale_rwlock(hdr, cur);
spin = 0;
continue;
}
if (__builtin_expect(spin < SYNC_SPIN_LIMIT, 1)) {
if (__atomic_compare_exchange_n(&hdr->value, &expected, mypid,
0, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED))
break;
/* Contended: expected now holds the current value. Recover a dead writer. */
if (expected >= SYNC_RWLOCK_WRITER_BIT &&
!sync_pid_alive(expected & SYNC_RWLOCK_PID_MASK)) {
sync_recover_stale_rwlock(hdr, expected);
spin = 0;
continue;
}
if (__builtin_expect(spin < SYNC_SPIN_LIMIT, 1)) {
uint32_t expected = 0;
if (!__atomic_compare_exchange_n(&hdr->value, &expected, mypid,
0, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED)) {
/* Contended. Recover a dead writer and retry once; else fail. */
if (expected >= SYNC_RWLOCK_WRITER_BIT &&
!sync_pid_alive(expected & SYNC_RWLOCK_PID_MASK)) {
sync_recover_stale_rwlock(hdr, expected);
expected = 0;
if (!__atomic_compare_exchange_n(&hdr->value, &expected, mypid,
0, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED))
return 0;
uint32_t expected = 0;
if (__atomic_compare_exchange_n(&hdr->value, &expected, mypid,
0, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED))
break;
if (expected >= SYNC_RWLOCK_WRITER_BIT &&
!sync_pid_alive(expected & SYNC_RWLOCK_PID_MASK)) {
sync_recover_stale_rwlock(hdr, expected);
spin = 0;
continue;
}
if (__builtin_expect(spin < SYNC_SPIN_LIMIT, 1)) {
if (val == SYNC_ONCE_INIT) continue; /* race: was reset, retry */
/* Check stale initializer */
if (val >= SYNC_MUTEX_WRITER_BIT) {
uint32_t pid = val & SYNC_MUTEX_PID_MASK;
if (!sync_pid_alive(pid)) {
if (__atomic_compare_exchange_n(&hdr->value, &val, SYNC_ONCE_INIT,
0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED)) {
__atomic_add_fetch(&hdr->stat_recoveries, 1, __ATOMIC_RELAXED);
/* StoreLoad: publish the state change before reading the waiter count (weak-memory lost-wakeup guard). */
__atomic_thread_fence(__ATOMIC_SEQ_CST);
Data-TagDB
view release on metacpan or search on metacpan
lib/Data/TagDB.pm view on Meta::CPAN
my $dbh = $db->dbh;
Returns the current L<DBI> connection.
This connection can be used to call any transaction independent method on the handle.
It can for example be used to call L<DBI/ping> to keep the connection alive.
If methods are called that depend on the state of the transaction logic
(such as performing an SELECT or UPDATE) the state of the transaction B<must> be managed via
this module. See L</begin_work>.
Data-Tersify-Plugin-DBIx-Class
view release on metacpan or search on metacpan
t/tersify.t view on Meta::CPAN
# We can tersify a resultset object...
my %data = (
result_set => bless {
_result_class => 'Arbitrary::Class::Name',
attrs => {
Paul => 'alive',
Jessica => 'alive',
Leto => 'dead',
Alia => 'abomination',
},
cond => 'Not even a hashref',
result_source => 'Ignored',
Data-TimingWheel-Shared
view release on metacpan or search on metacpan
timingwheel.h view on Meta::CPAN
/* Writer word encoding: WRITER_BIT|pid when write-locked, 0 when free. */
#define TW_RWLOCK_WRITER_BIT 0x80000000U
#define TW_RWLOCK_PID_MASK 0x7FFFFFFFU
#define TW_RWLOCK_WR(pid) (TW_RWLOCK_WRITER_BIT | ((uint32_t)(pid) & TW_RWLOCK_PID_MASK))
/* A zombie (dead but not yet reaped) still answers kill(pid,0) as alive, so a
* process that crashed while holding the lock and lingers unreaped would never
* be recovered. Treat /proc/<pid>/stat state 'Z' as dead. Linux-only (as is
* this module); if /proc is unreadable we fall back to "alive" (safe: we never
* force-recover a possibly-live holder). */
static inline int tw_pid_is_zombie(uint32_t pid) {
char path[32], buf[256];
snprintf(path, sizeof(path), "/proc/%u/stat", (unsigned)pid);
int fd = open(path, O_RDONLY | O_CLOEXEC);
timingwheel.h view on Meta::CPAN
/* "pid (comm) state ..."; comm may contain ')', so scan to the last one. */
char *rp = strrchr(buf, ')');
if (!rp || rp + 2 >= buf + n) return 0; /* need ") X" within the bytes read */
return rp[1] == ' ' && rp[2] == 'Z';
}
/* 1 if alive or unknown, 0 if definitely dead. Cannot detect PID reuse: a
* recycled PID reports "alive" and the slot is not reclaimed until that
* process exits. See "Crash Safety" in the POD. */
static inline int tw_pid_alive(uint32_t pid) {
if (pid == 0) return 1; /* no owner recorded, assume alive */
if (kill((pid_t)pid, 0) == -1 && errno == ESRCH) return 0; /* definitely dead */
return !tw_pid_is_zombie(pid); /* kill() also succeeds for a zombie -> treat as dead */
}
/* Force-recover a stale WRITE lock left by a dead writer (held or mid-drain).
timingwheel.h view on Meta::CPAN
* if its rdepth>0: clearing pid drops the dead reader's entire contribution
* (a writer scan ignores rdepth when pid==0) and we reset rdepth to 0 as we
* claim it. */
for (uint32_t i = 0; i < TW_READER_SLOTS; i++) {
uint32_t dpid = __atomic_load_n(&h->reader_slots[i].pid, __ATOMIC_ACQUIRE);
if (dpid == 0 || dpid == now_pid || tw_pid_alive(dpid)) continue;
uint32_t expected = dpid;
if (__atomic_compare_exchange_n(&h->reader_slots[i].pid, &expected, now_pid, 0,
__ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) {
__atomic_store_n(&h->reader_slots[i].rdepth, 0, __ATOMIC_RELAXED);
tw_occ_set(h, i);
timingwheel.h view on Meta::CPAN
* wlock drains readers, and it clears dead readers inline in its own scan. */
static inline void tw_recover_after_timeout(TwHandle *h) {
uint32_t val = __atomic_load_n(&h->hdr->wlock, __ATOMIC_RELAXED);
if (val >= TW_RWLOCK_WRITER_BIT) {
uint32_t pid = val & TW_RWLOCK_PID_MASK;
if (!tw_pid_alive(pid))
tw_recover_stale_lock(h, val);
}
}
/* Bump/drop the parked-waiter hint. Both readers (blocked at the gate) and
timingwheel.h view on Meta::CPAN
spin = 0;
continue;
}
/* wlock != 0: a writer holds or is acquiring. Recover if it is dead. */
if (cur >= TW_RWLOCK_WRITER_BIT &&
!tw_pid_alive(cur & TW_RWLOCK_PID_MASK)) {
tw_recover_stale_lock(h, cur);
spin = 0;
continue;
}
if (__builtin_expect(spin < TW_RWLOCK_SPIN_LIMIT, 1)) {
timingwheel.h view on Meta::CPAN
if (__atomic_compare_exchange_n(&hdr->wlock, &expected, mypid,
0, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED))
break;
/* Contended: expected now holds the current wlock value. */
if (expected >= TW_RWLOCK_WRITER_BIT &&
!tw_pid_alive(expected & TW_RWLOCK_PID_MASK)) {
tw_recover_stale_lock(h, expected);
spin = 0;
continue;
}
if (__builtin_expect(spin < TW_RWLOCK_SPIN_LIMIT, 1)) {
timingwheel.h view on Meta::CPAN
word &= word - 1; /* consume this bit (local copy) */
uint32_t rd = __atomic_load_n(&h->reader_slots[i].rdepth, __ATOMIC_SEQ_CST);
if (rd == 0) continue; /* occupied but not read-locking now */
uint32_t pid = __atomic_load_n(&h->reader_slots[i].pid, __ATOMIC_ACQUIRE);
if (pid == 0) continue; /* stale rdepth on a freed slot */
if (!tw_pid_alive(pid)) {
/* Dead reader: drop its pid so the slot no longer counts. Leave
* the occ bit set (harmless -- a later scan hits pid==0 and skips,
* a re-claim re-sets it) to avoid racing a concurrent claimant. */
uint32_t ep = pid;
__atomic_compare_exchange_n(&h->reader_slots[i].pid, &ep, 0,
Data-TopK-Shared
view release on metacpan or search on metacpan
/* Writer word encoding: WRITER_BIT|pid when write-locked, 0 when free. */
#define TK_RWLOCK_WRITER_BIT 0x80000000U
#define TK_RWLOCK_PID_MASK 0x7FFFFFFFU
#define TK_RWLOCK_WR(pid) (TK_RWLOCK_WRITER_BIT | ((uint32_t)(pid) & TK_RWLOCK_PID_MASK))
/* A zombie (dead but not yet reaped) still answers kill(pid,0) as alive, so a
* process that crashed while holding the lock and lingers unreaped would never
* be recovered. Treat /proc/<pid>/stat state 'Z' as dead. Linux-only (as is
* this module); if /proc is unreadable we fall back to "alive" (safe: we never
* force-recover a possibly-live holder). */
static inline int tk_pid_is_zombie(uint32_t pid) {
char path[32], buf[256];
snprintf(path, sizeof(path), "/proc/%u/stat", (unsigned)pid);
int fd = open(path, O_RDONLY | O_CLOEXEC);
/* "pid (comm) state ..."; comm may contain ')', so scan to the last one. */
char *rp = strrchr(buf, ')');
if (!rp || rp + 2 >= buf + n) return 0; /* need ") X" within the bytes read */
return rp[1] == ' ' && rp[2] == 'Z';
}
/* 1 if alive or unknown, 0 if definitely dead. Cannot detect PID reuse: a
* recycled PID reports "alive" and the slot is not reclaimed until that
* process exits. See "Crash Safety" in the POD. */
static inline int tk_pid_alive(uint32_t pid) {
if (pid == 0) return 1; /* no owner recorded, assume alive */
if (kill((pid_t)pid, 0) == -1 && errno == ESRCH) return 0; /* definitely dead */
return !tk_pid_is_zombie(pid); /* kill() also succeeds for a zombie -> treat as dead */
}
/* Force-recover a stale WRITE lock left by a dead writer (held or mid-drain).
* if its rdepth>0: clearing pid drops the dead reader's entire contribution
* (a writer scan ignores rdepth when pid==0) and we reset rdepth to 0 as we
* claim it. */
for (uint32_t i = 0; i < TK_READER_SLOTS; i++) {
uint32_t dpid = __atomic_load_n(&h->reader_slots[i].pid, __ATOMIC_ACQUIRE);
if (dpid == 0 || dpid == now_pid || tk_pid_alive(dpid)) continue;
uint32_t expected = dpid;
if (__atomic_compare_exchange_n(&h->reader_slots[i].pid, &expected, now_pid, 0,
__ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) {
__atomic_store_n(&h->reader_slots[i].rdepth, 0, __ATOMIC_RELAXED);
tk_occ_set(h, i);
* wlock drains readers, and it clears dead readers inline in its own scan. */
static inline void tk_recover_after_timeout(TkHandle *h) {
uint32_t val = __atomic_load_n(&h->hdr->wlock, __ATOMIC_RELAXED);
if (val >= TK_RWLOCK_WRITER_BIT) {
uint32_t pid = val & TK_RWLOCK_PID_MASK;
if (!tk_pid_alive(pid))
tk_recover_stale_lock(h, val);
}
}
/* Bump/drop the parked-waiter hint. Both readers (blocked at the gate) and
spin = 0;
continue;
}
/* wlock != 0: a writer holds or is acquiring. Recover if it is dead. */
if (cur >= TK_RWLOCK_WRITER_BIT &&
!tk_pid_alive(cur & TK_RWLOCK_PID_MASK)) {
tk_recover_stale_lock(h, cur);
spin = 0;
continue;
}
if (__builtin_expect(spin < TK_RWLOCK_SPIN_LIMIT, 1)) {
if (__atomic_compare_exchange_n(&hdr->wlock, &expected, mypid,
0, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED))
break;
/* Contended: expected now holds the current wlock value. */
if (expected >= TK_RWLOCK_WRITER_BIT &&
!tk_pid_alive(expected & TK_RWLOCK_PID_MASK)) {
tk_recover_stale_lock(h, expected);
spin = 0;
continue;
}
if (__builtin_expect(spin < TK_RWLOCK_SPIN_LIMIT, 1)) {
word &= word - 1; /* consume this bit (local copy) */
uint32_t rd = __atomic_load_n(&h->reader_slots[i].rdepth, __ATOMIC_SEQ_CST);
if (rd == 0) continue; /* occupied but not read-locking now */
uint32_t pid = __atomic_load_n(&h->reader_slots[i].pid, __ATOMIC_ACQUIRE);
if (pid == 0) continue; /* stale rdepth on a freed slot */
if (!tk_pid_alive(pid)) {
/* Dead reader: drop its pid so the slot no longer counts. Leave
* the occ bit set (harmless -- a later scan hits pid==0 and skips,
* a re-claim re-sets it) to avoid racing a concurrent claimant. */
uint32_t ep = pid;
__atomic_compare_exchange_n(&h->reader_slots[i].pid, &ep, 0,
Data-Transform-SSL
view release on metacpan or search on metacpan
lib/Data/Transform/SSL.pm view on Meta::CPAN
my ($self) = @_;
my %args = ();
if ($self->[TYPE] == TYPE_CLIENT) {
# don't reference $self, so there isn't an extra reference keeping
# it alive too long
my $flags = $self->[FLAGS];
$args{SSL_verify_callback} = sub {
my ($ok, $ctx_store) = @_;
my $cert = Net::SSLeay::X509_STORE_CTX_get_current_cert($ctx_store);
my $error = Net::SSLeay::X509_STORE_CTX_get_error($ctx_store);
Data-Validation
view release on metacpan or search on metacpan
'No field def 1';
is test_val( $f, 'test', 1), "Field 'test' validation configuration not found",
'No field def 2';
$f->{fields}->{test}->{validate} = q(isHexadecimal);
is test_val( $f, q(test), q(alive) ), q(Hexadecimal), 'Not hexadecimal';
is test_val( $f, q(test), q(dead) ), q(dead), 'Is hexadecimal';
my ($value, $e) = new_e( $f, q(test), q(alive) );
like $e->explain, qr{ \Qcan only contain\E }imx, 'Explains error';
$f->{fields}->{test}->{validate} = q(isMandatory);
is test_val( $f, q(test), undef ), q(Mandatory), 'Missing field';
DataCube
view release on metacpan or search on metacpan
pc^descent ii^interplay^parallax software^action^8^t (teen)^02/29/1996
pc^descent ii^interplay^parallax software^action^8^t (teen)^02/29/1996
pc^desert rats vs. afrika korps^encore software / monte cristo^digital reality^real-time strategy^4^t (teen)^03/30/2004
pc^desert thunder^groove games^brainbox games^third-person shooter^1^t (teen)^11/18/2003
pc^desperados 2: cooper's revenge^atari^spellbound^real-time strategy^1^t (teen)^05/02/2006
pc^desperados: wanted dead or alive^infogrames^spellbound^real-time strategy^1^t (teen)^07/24/2001
pc^desperate housewives^buena vista games^liquid entertainment^simulation^1^t (teen)^10/05/2006
pc^destination: treasure island^dreamcatcher interactive^kheops studio^adventure^1^t (teen)^08/21/2007
pc^destroyer command^ubi soft^ultimation^simulation^8^e (everyone)^02/18/2002
pc^destroyer command^ubi soft^ultimation^simulation^8^e (everyone)^02/18/2002
pc^determinance^mode 7 games^mode 7 games^fighting, action^8^rp (rating pending)^02/14/2007
pc^wacky races^infogrames^appaloosa interactive^racing^2^e (everyone)^01/15/2001
pc^wakeboarding unleashed featuring shaun murray^aspyr media^shaba games^extreme sports^2^e (everyone)^12/22/2003
pc^wall-e^thq^heavy iron studios^action, adventure^2^e (everyone)^06/24/2008
pc^wanted guns^fusion labs^iridon interactive^third-person action, first-person shooter^1^rp (rating pending)^03/04/2005
pc^wanted: a wild western adventure^planeta deagostini / the adventure company^revistronic^third-person adventure^1^e (everyone)^10/03/2004
pc^wanted: dead or alive^xs games^iridon interactive^third-person shooter^1^t (teen)^02/03/2004
pc^war engine, the^shrapnel games^boku strategy games^wargame, turn-based strategy^2^^10/23/2001
pc^war front: turning point^cdv software^digital reality^real-time strategy^10^t (teen)^02/19/2007
pc^war in the pacific: the struggle against japan 1941-1945^matrix games^2 by 3 games^turn-based strategy, wargame^2^rp (rating pending)^07/08/2004
pc^war leaders: clash of nations^cdv software^enigma software^real-time strategy^8^rp (rating pending)^10/01/2008
pc^war on terror^deep silver / monte cristo^digital reality^real-time strategy^8^rp (rating pending)^05/12/2006
pc^waterloo: napoleon's last battle^strategy first, inc.^breakaway games^real-time strategy, turn-based strategy^8^e (everyone)^03/26/2001
pc^weakest link, the^activision^activision^gameshow, puzzle^7^e (everyone)^10/02/2001
pc^weird war: the unknown episode of world war ii^strategy first inc. / techland software^mirage interactive^role-playing game^1^rp (rating pending)^08/01/2004
pc^weird worlds: return to infinite space^shrapnel games^digital eel^turn-based strategy^1^rp (rating pending)^11/03/2005
pc^welcome to merriweather farm^bold games^gabriel interactive^edutainment^1^e (everyone)^09/01/2005
pc^western outlaw: wanted dead or alive^groove games^jarhead games^first-person shooter, action^1^m (mature)^09/28/2003
pc^wheelman, the^midway games^midway newcastle - tigon studios^action, driving^1^rp (rating pending)^11/01/2008
pc^whirlwind over vietnam^evolved games^g5 software^helecopter simulation^1^t (teen)^04/09/2007
pc^who wants to be a millionaire? party edition^eidos interactive^climax studios^trivia, game show^4^rp (rating pending)^11/24/2006
pc^wik & the fable of souls^reflexive entertainment^reflexive entertainment^action, platform, puzzle^1^e (everyone)^10/19/2004
pc^wild earth: photo safari^super x studios^super x studios^adventure^1^e (everyone)^05/02/2006
pc^wildfire^global star software^global star software^action, strategy^1^e (everyone)^10/11/2004
pc^wildlife park^encore software / jowood productions^deep silver^economic simulation, strategy^1^e (everyone)^12/08/2003
pc^wildlife park 2^deep silver^b-alive^economic simulation, strategy, simulation^1^e (everyone)^07/17/2006
pc^wildlife tycoon: venture africa^pocketwatch games^pocketwatch games^real-time strategy, simulation, tycoon^1^rp (rating pending)^02/24/2006
pc^wildlife zoo^dreamcatcher interactive^dreamcatcher interactive^strategy^1^e10+ (everyone 10 and older)^10/04/2006
pc^will of steel^gmx media^gmx media^real-time strategy^1^t (teen)^02/01/2005
pc^will rock^ubi soft^saber interactive^first-person shooter, action^16^m (mature)^06/03/2003
pc^williams pinball classics^encore software, inc.^encore software, inc.^pinball, puzzle^1^e (everyone)^09/30/2001
playstation 1^danger girl^thq^n-space^action^1^t (teen)^09/27/2000
playstation 1^darkstone^take 2 interactive^delphine^action^1^t (teen)^01/31/2001
playstation 1^dave mirra freestyle bmx^acclaim^z-axis^racing^2^e (everyone)^09/27/2000
playstation 1^dave mirra freestyle bmx: maximum remix^acclaim^z-axis^sports^2^e (everyone)^05/22/2001
playstation 1^david beckham soccer^rage software^rage software^sports^2^^11/23/2001
playstation 1^dead or alive^tecmo^tecmo^fighting, action^2^t (teen)^05/01/1998
playstation 1^delta force: urban warfare^novalogic^rebellion^first-person shooter, action^1^t (teen)^07/01/2002
playstation 1^destruction derby raw^midway^studio 33^racing^4^e (everyone)^09/27/2000
playstation 1^dexter's laboratory: mandark's lab?^bam! entertainment^red lemon studios^puzzle, arcade^2^e (everyone)^05/01/2002
playstation 1^digimon digital card battle^bandai^bandai^turn-based strategy^2^t (teen)^06/29/2001
playstation 1^digimon rumble arena^bandai^hudson^fighting^2^e (everyone)^02/21/2002
playstation 2^dawn of mana^square enix^square enix^third-person action, role-playing game^1^t (teen)^05/22/2007
playstation 2^ddrmax: dance dance revolution^konami^konami tokyo^dancing^2^e (everyone)^10/29/2002
playstation 2^ddrmax: dance dance revolution^konami^konami tokyo^dancing^2^e (everyone)^10/29/2002
playstation 2^ddrmax2: dance dance revolution^konami^konami computer entertainment tokyo^dancing, music^2^e (everyone)^09/23/2003
playstation 2^ddrmax2: dance dance revolution^konami^konami computer entertainment tokyo^dancing, music^2^e (everyone)^09/23/2003
playstation 2^dead or alive 2: hardcore^tecmo^tecmo^fighting^4^t (teen)^10/26/2000
playstation 2^dead to rights^namco^namco^action^1^m (mature)^11/18/2002
playstation 2^dead to rights ii: hell to pay^namco^namco^third-person action^1^m (mature)^04/12/2005
playstation 2^deadly skies iii^konami^konami^flight action^1^rp (rating pending)^05/14/2004
playstation 2^death by degrees^namco^namco^third-person action, adventure, fighting^1^m (mature)^02/08/2005
playstation 2^death by degrees^namco^namco^third-person action, adventure, fighting^1^m (mature)^02/08/2005
xbox^dark summit^thq^radical entertainment^sports^2^t (teen)^11/12/2001
xbox^darkwatch^capcom entertainment^high moon studios^first-person shooter, action^16^m (mature)^08/16/2005
xbox^dave mirra freestyle bmx 2^acclaim^z-axis^sports^2^t (teen)^11/15/2001
xbox^david beckham soccer^majesco sales inc.^rage software^sports^4^e (everyone)^08/19/2002
xbox^dead man's hand^atari^human head studios^first-person shooter, action, adventure^8^t (teen)^03/02/2004
xbox^dead or alive 3^tecmo^tecmo^fighting^4^t (teen)^11/15/2001
xbox^dead or alive 3^tecmo^tecmo^fighting^4^t (teen)^11/15/2001
xbox^dead or alive ultimate^tecmo^team ninja^fighting, action^8^m (mature)^10/27/2004
xbox^dead or alive ultimate^tecmo^team ninja^fighting, action^8^m (mature)^10/27/2004
xbox^dead or alive xtreme beach volleyball^tecmo^tecmo^sports^2^m (mature)^01/21/2003
xbox^dead to rights^namco^namco^action, adventure^1^m (mature)^08/20/2002
xbox^dead to rights^namco^namco^action, adventure^1^m (mature)^08/20/2002
xbox^dead to rights ii: hell to pay^namco^namco^third-person action^1^m (mature)^04/12/2005
xbox^dead to rights ii: hell to pay^namco^namco^third-person action^1^m (mature)^04/12/2005
xbox^deathrow^ubi soft^southend interactive^sports, action^8^m (mature)^10/22/2002
xbox 360^dark sector^d3 publisher of america^digital extremes^third-person shooter^10^m (mature)^03/25/2008
xbox 360^dark void^capcom^airtight games^third-person action^1^rp (rating pending)^11/01/2008
xbox 360^darkness, the^2k games^starbreeze studios^first-person shooter^1^m (mature)^06/25/2007
xbox 360^darksiders: wrath of war^thq^vigil games^action, adventure^1^rp (rating pending)^11/01/2008
xbox 360^dead island^tba^techland^first-person shooter, survival horror^multi^rp (rating pending)^11/01/2008
xbox 360^dead or alive 4^tecmo^team ninja^action, fighting^4^m (mature)^12/29/2005
xbox 360^dead or alive xtreme 2^tecmo^team ninja^sports^2^m (mature)^11/13/2006
xbox 360^dead rising^capcom^capcom production studio 1^survival horror, action, adventure^1^m (mature)^08/08/2006
xbox 360^dead space^electronic arts^ea redwood shores^third-person action, survival horror^1^rp (rating pending)^10/31/2008
xbox 360^deadliest catch: alaskan storm^greenwave games^liquid dragon studios^simulation^multi^t (teen)^06/17/2008
xbox 360^def jam: icon^electronic arts^ea chicago^fighting, wrestling^2^m (mature)^03/06/2007
xbox 360^defender^midway^midway^action, shooter^2^e (everyone)^11/15/2006
DataLoader
view release on metacpan or search on metacpan
lib/DataLoader.pm view on Meta::CPAN
# We prefer an idle watcher as it will execute after all Promises are
# resolved (batching as much as possible). But Mojo::IOLoop's API does
# not provide this. And we cannot assume AnyEvent can be used.
# The best we can do is detect the EV backend and use EV::idle.
if (Mojo::IOLoop->singleton->reactor->isa('Mojo::Reactor::EV')) {
# Capture the lexical inside the coderef to keep it alive until
# the callback is finished.
my $w; $w = EV::idle(sub {
$self->_dispatch_queue;
undef $w;
});
Database-Abstraction
view release on metacpan or search on metacpan
lib/Database/Abstraction.pm view on Meta::CPAN
close($fin);
$fin = File::Temp->new(SUFFIX => '.csv', UNLINK => 1);
print $fin Gzip::Faster::gunzip_file($gz_file);
$fin->flush();
$slurp_file = $fin->filename();
$self->{'_temp_fh'} = $fin; # Keep object alive; auto-unlinks at DESTROY
} else {
my $psv = File::Spec->catfile($dir, "$dbname.psv");
if(-r $psv) {
open($fin, '<', $psv);
# Pipe separated file
Database-Async-Engine-PostgreSQL
view release on metacpan or search on metacpan
lib/Database/Async/Engine/PostgreSQL.pm view on Meta::CPAN
# Everything else is handled via query parameters, this list is non-exhaustive and likely to be
# extended in future (e.g. text/binary protocol mode)
$uri->query_param($_ => delete $cfg->{$_}) for grep exists $cfg->{$_}, qw(
application_name
fallback_application_name
keepalives
options
sslmode
replication
);
$uri
( run in 4.042 seconds using v1.01-cache-2.11-cpan-14f38c9f855 )