[ViewVC] Diff of: cvs/BDB/README

Comparing BDB/README (file contents):
Revision 1.3 by root, Tue Dec 4 10:14:34 2007 UTC vs.
Revision 1.4 by root, Fri Dec 7 13:39:04 2007 UTC

 NAME
     BDB - Asynchronous Berkeley DB access
 SYNOPSIS
      use BDB;
+     my $env = db_env_create;
+     mkdir "bdtest", 0700;
+     db_env_open
+        $env,
+        "bdtest",
+        BDB::INIT_LOCK | BDB::INIT_LOG | BDB::INIT_MPOOL
+        | BDB::INIT_TXN | BDB::RECOVER | BDB::USE_ENVIRON | BDB::CREATE,
+        0600;
+     $env->set_flags (BDB::AUTO_COMMIT | BDB::TXN_NOSYNC, 1);
+     my $db = db_create $env;
+     db_open $db, undef, "table", undef, BDB::BTREE, BDB::AUTO_COMMIT | BDB::CREATE
+                                         | BDB::READ_UNCOMMITTED, 0600;
+     db_put $db, undef, "key", "data", 0, sub {
+        db_del $db, undef, "key";
+     };
+     db_sync $db;
+     # automatic result processing with AnyEvent:
+     our $FH; open $FH, "<&=" . BDB::poll_fileno;
+     our $WATCHER = AnyEvent->io (fh => $FH, poll => 'r', cb => \&BDB::poll_cb);
+     # automatic result processing with EV:
+     my $WATCHER = EV::io BDB::poll_fileno, EV::READ, \&BDB::poll_cb;
+     # with Glib:
+     add_watch Glib::IO BDB::poll_fileno,
+               in => sub { BDB::poll_cb; 1 };
+     # or simply flush manually
+     BDB::flush;
 DESCRIPTION
     See the BerkeleyDB documentation
     (<http://www.oracle.com/technology/documentation/berkeley-db/db/index.ht
     ml>). The BDB API is very similar to the C API (the translation has been
        $int = $env->set_lk_max_lockers (U32 max)
        $int = $env->set_lk_max_locks (U32 max)
        $int = $env->set_lk_max_objects (U32 max)
        $int = $env->set_lg_bsize (U32 max)
        $int = $env->set_lg_max (U32 max)
+       $int = $env->mutex_set_increment (U32 increment)
+       $int = $env->mutex_set_tas_spins (U32 tas_spins)
+       $int = $env->mutex_set_max (U32 max)
+       $int = $env->mutex_set_align (U32 align)
        $txn = $env->txn_begin (DB_TXN_ornull *parent = 0, U32 flags = 0)
           flags: READ_COMMITTED READ_UNCOMMITTED TXN_NOSYNC TXN_NOWAIT TXN_SNAPSHOT TXN_SYNC TXN_WAIT TXN_WRITE_NOSYNC
    Example:
         interactiveness when perl is not fast enough to process all requests
         in time.
         For interactive programs, values such as 0.01 to 0.1 should be fine.
-        Example: Install an Event watcher that automatically calls
+        Example: Install an EV watcher that automatically calls BDB::poll_cb
-        BDB::poll_cb with low priority, to ensure that other parts of the
+        with low priority, to ensure that other parts of the program get the
-        program get the CPU sometimes even under high AIO load.
+        CPU sometimes even under high load.
            # try not to spend much more than 0.1s in poll_cb
            BDB::max_poll_time 0.1;
-           # use a low priority so other tasks have priority
+           my $bdb_poll = EV::io BDB::poll_fileno, EV::READ, \&BDB::poll_cb);
-           Event->io (fd => BDB::poll_fileno,
-                      poll => 'r', nice => 1,
-                      cb => &BDB::poll_cb);
     BDB::poll_wait
         If there are any outstanding requests and none of them in the result
         phase, wait till the result filehandle becomes ready for reading
         (simply does a "select" on the filehandle. This is useful if you
         equivalent to:
            BDB::poll_wait, BDB::poll_cb
     BDB::flush
-        Wait till all outstanding AIO requests have been handled.
+        Wait till all outstanding BDB requests have been handled.
         Strictly equivalent to:
            BDB::poll_wait, BDB::poll_cb
               while BDB::nreqs;
    CONTROLLING THE NUMBER OF THREADS
     BDB::min_parallel $nthreads
-        Set the minimum number of AIO threads to $nthreads. The current
+        Set the minimum number of BDB threads to $nthreads. The current
         default is 8, which means eight asynchronous operations can execute
         concurrently at any one time (the number of outstanding requests,
         however, is unlimited).
-        BDB starts threads only on demand, when an AIO request is queued and
+        BDB starts threads only on demand, when an BDB request is queued and
         no free thread exists. Please note that queueing up a hundred
         requests can create demand for a hundred threads, even if it turns
         out that everything is in the cache and could have been processed
         faster by a single thread.
         Under most circumstances you don't need to call this function, as
         the module selects a default that is suitable for low to moderate
         load.
     BDB::max_parallel $nthreads
-        Sets the maximum number of AIO threads to $nthreads. If more than
+        Sets the maximum number of BDB threads to $nthreads. If more than
         the specified number of threads are currently running, this function
         kills them. This function blocks until the limit is reached.
         While $nthreads are zero, aio requests get queued but not executed
         until the number of threads has been increased again.
         (executed, but not yet processed by poll_cb).
   FORK BEHAVIOUR
     This module should do "the right thing" when the process using it forks:
-    Before the fork, IO::AIO enters a quiescent state where no requests can
+    Before the fork, BDB enters a quiescent state where no requests can be
-    be added in other threads and no results will be processed. After the
+    added in other threads and no results will be processed. After the fork
-    fork the parent simply leaves the quiescent state and continues
+    the parent simply leaves the quiescent state and continues
     request/result processing, while the child frees the request/result
     queue (so that the requests started before the fork will only be handled
     in the parent). Threads will be started on demand until the limit set in
     the parent process has been reached again.
     In short: the parent will, after a short pause, continue as if fork had
-    not been called, while the child will act as if IO::AIO has not been
+    not been called, while the child will act as if BDB has not been used
-    used yet.
+    yet.
   MEMORY USAGE
     Per-request usage:
     Each aio request uses - depending on your architecture - around 100-200
        with an operating system error or DB_LOCK_NOTGRANTED, the internal
        TXN_DEADLOCK flag will be set on the transaction. See C<db_txn_finish>,
        above.
 SEE ALSO
-    Coro::AIO.
+    Coro::BDB, IO::AIO.
 AUTHOR
      Marc Lehmann <schmorp@schmorp.de>
      http://home.schmorp.de/

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing BDB/README (file contents): Revision 1.3 by root, Tue Dec 4 10:14:34 2007 UTC vs. Revision 1.4 by root, Fri Dec 7 13:39:04 2007 UTC

Diff Legend

Comparing BDB/README (file contents):
Revision 1.3 by root, Tue Dec 4 10:14:34 2007 UTC vs.
Revision 1.4 by root, Fri Dec 7 13:39:04 2007 UTC