The pounds Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The pounds Reference Manual

This is the pounds Reference Manual, version 0.2.1, generated automatically by Declt version 2.3 "Robert April" on Tue Feb 20 09:11:36 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

Pounds

Pounds is intended to provide a collection of tools for operations on block storage. At present its only useful features is a stream class over the top of mmaped files and (yet another) logging system which writes to a circular mmaped log.

1. File mappings

The base functionality is provided by mmap'ing files and defining a stream class to read/write them.

1.1 Usage

;; open a 1MB file and mmap it
(defparameter *mymap* (open-mapping "mymap.dat" (* 1024 1024)))

;; make a stream from the mapping and write to it
(with-mapping-stream (s *mymap*)
  (write-sequence #(1 2 3 4) s))

(close-mapping *mymap*)

If the file does not exist it is created and extended to by SIZE bytes. If the file already exists it is simply opened with the original contents intact, the file will be extended if required.

1.2 Platform support

It works on Windows and Linux. I've not tried on other platforms (BSD, Darwin etc) but since they use the same POSIX APIs as Linux it should work without problem.

2. Circular logs

The package POUNDS.LOG (nickname PLOG) implements a circular log by writing to the mmap'ed file.

2.1 Motivation

Long running services need to record their activity. For instance, who mounted an NFS, what files they accessed etc. This is needed for two reasons: both for auditing service usage, and as a record of what the service actually did. We need this because when things go wrong, you need a record of what happened to analyze.

We therefore need a logging system which has the following properties:

We can use the file mapping stream to satisfy the above requirements.

2.2 Usage

Open a log file (creating it if it doesn't exist) by calling OPEN-LOG. If no pathname is provided, a file in the local directory named "pounds.log" will be created. The defualt size is 16k blocks of 128 bytes each (so a 2MB file). This means it can store a maximum of 16k messages. If a message is larger than the block size it will use multiple contiguous blocks.

Write a message to the log using WRITE-MESSAGE.

E.g.

(defvar *mylog* (pounds.log:open-log))

(pounds.log:write-message *mylog* :info (format nil "Hello from Lisp. 1 + 2 == ~A" (+ 1 2)))

(pounds.log:close-log *mylog*)

Follow the log's output by using the command:

(pounds.log:start-following *mylog*)

(pounds.log:stop-following)

This starts a thread which monitors the log and prints messages to the output stream as they are written to the log.

You may dump the contents of the log to a stream, e.g.

(with-open-file (f "output.txt" :direction :output :if-exists :supersede)
  (pounds.log:dump-log *mylog* :stream f))

The log operators (READ-MESSAGE and WRITE-MESSAGE) support both multi-thread and multi-process access to the log files.

2.3 Sharing logs

It is often the case that different modules of the same program want to write to the same log, but with a tag to differentiate them.

(defvar *the-log* (open-log))

(let ((tag (babel:string-to-octets "LOG1")))
  (defun write1 (lvl format-control &rest args)
    (write-message *the-log* lvl (apply #'format nil format-control args) 
                   :tag tag)))
(let ((tag (babel:string-to-octets "LOG2")))
  (defun write2 (lvl format-control &rest args)
    (write-message *the-log* lvl (apply #'format nil format-control args)
                   :tag tag)))

2.4 Performance

I've not done any rigorous benchmarking but performance feels sufficiently good. I tested on my crummy old laptop (1.5Ghz core 2 duo, 1GB RAM running Windows 8.1).

I wrote 100,000 messages to a standard 2MB (16k/128) log and it took 100 seconds, SBCL maxed out 1 of my cores. Taking 1ms per write seems acceptable.

(time
  (dotimes (i 100000)
    (pounds.log:write-message :info *mylog* (format nil "Hello ~A" i))))

The equivalent experiment using LOG4CL took over 200 seconds to write 10,000 messages before I gave up waiting. Both SBCL and emacs were maxing out a core each.

(time  
  (dotimes (i 100000)
    (log:debug "Hello ~A" i)))

3. Fixed block-size database

The package POUNDS.DB provides a simple fixed block-size database. See the example in example/db-test.lisp. It can be used to provide shared access to a mmaped array of fixed-sized blocks, each of which stores a value. You can lookup, add and delete entries.

4. Notes

The primary development platform was SBCL 1.2.7 on Windows 8.1. It has also been used on 32 and 64-bit Linux without any trouble. It may work on other unix-like platforms (e.g. BSD, Darwin) but I've not tested it there.

License

Released under the terms of the MIT license.

Frank James March 2015.


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 pounds

Author

Frank James <frank.a.james@gmail.com>

License

MIT

Description

Provides portable file mappings and related utilities.

Version

0.2.1

Dependencies
Source

pounds.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 pounds.asd

Location

pounds.asd

Systems

pounds (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 pounds/package.lisp

Parent

pounds (system)

Location

package.lisp

Packages

pounds


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.3 pounds/ffi.lisp

Dependency

package.lisp (file)

Parent

pounds (system)

Location

ffi.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.4 pounds/mappings.lisp

Dependency

ffi.lisp (file)

Parent

pounds (system)

Location

mappings.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.5 pounds/log.lisp

Dependency

mappings.lisp (file)

Parent

pounds (system)

Location

log.lisp

Packages

pounds.log

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.6 pounds/database.lisp

Dependency

log.lisp (file)

Parent

pounds (system)

Location

database.lisp

Packages

pounds.db

Exported Definitions
Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

3.1.7 pounds/blog.lisp

Dependency

database.lisp (file)

Parent

pounds (system)

Location

blog.lisp

Packages

pounds.blog

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

4.1 pounds

Source

package.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

4.2 pounds.log

Source

log.lisp (file)

Nickname

plog

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

4.3 pounds.db

Source

database.lisp (file)

Use List
Exported Definitions
Internal Definitions

Previous: , Up: Packages   [Contents][Index]

4.4 pounds.blog

Source

blog.lisp (file)

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Macros

Macro: doentries (VAR DB &optional RESULT) &body BODY

Iterate over all entries in the database, evaluating the body forms with VAR bound to each entry.

VAR ::= symbol bound to the entry.
DB ::= database, as returned from OPEN-DB.
RESULT ::= optional result form.

The body forms are evaluated in the context of two local macros:
CLEAR-ENTRY ::= delete the current entry
UPDATE-ENTRY val ::= overwrite the current entry with VAL.

Package

pounds.db

Source

database.lisp (file)

Macro: with-locked-mapping (MAPPING-STREAM) &body BODY

Evaluate the body with the mapping lock held.

Package

pounds

Source

mappings.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Functions

Function: blog-properties BLOG

Read the current blog properties.

Package

pounds.blog

Source

blog.lisp (file)

Function: close-blog BLOG

Close the binary log and free all resources.

Package

pounds.blog

Source

blog.lisp (file)

Function: close-db DB

Close the database.

Package

pounds.db

Source

database.lisp (file)

Function: close-log LOG

Close the log and its associated file mapping.

Package

pounds.log

Source

log.lisp (file)

Function: close-mapping MAPPING

Close the file mapping.

Package

pounds

Source

ffi.lisp (file)

Function: db-seqno DB

Read the database sequence number.

Package

pounds.db

Source

database.lisp (file)

Function: dump-log LOG &key STREAM TAG LEVELS

Dump the contents of the log to the stream. Filters the messages on tag and levels, if provided.

Package

pounds.log

Source

log.lisp (file)

Function: find-entry ITEM DB &key KEY TEST

Search for the item in the database.

Package

pounds.db

Source

database.lisp (file)

Writer

(setf find-entry) (function)

Function: (setf find-entry) VALUE ITEM DB &key KEY TEST
Package

pounds.db

Source

database.lisp (file)

Reader

find-entry (function)

Function: find-entry-if PREDICATE DB &key KEY

Find the item in the database.

Package

pounds.db

Source

database.lisp (file)

Function: header DB READER
Function: (setf header) VALUE DB WRITER
Package

pounds.db

Source

database.lisp (file)

Function: make-mapping-stream MAPPING
Package

pounds

Source

mappings.lisp (file)

Function: mapentries FUNCTION DB

Map over the entries in the database.

Package

pounds.db

Source

database.lisp (file)

Function: mapping-size INSTANCE
Function: (setf mapping-size) VALUE INSTANCE
Package

pounds

Source

ffi.lisp (file)

Function: open-blog PATHSPEC &key NBLOCKS BLOCK-SIZE HEADER-SIZE

Open the binary log.
PATHSPEC ::= path to the file.
NBLOCKS ::= number of blocks in the log.
BLOCK-SIZE ::= number of bytes in each block.
HEADER-SIZE ::= number of bytes to assign to user customizable header.

Returns the BLOG structure. Close using CLOSE-BLOG.

Package

pounds.blog

Source

blog.lisp (file)

Function: open-db PATHSPEC READER WRITER &key COUNT BLOCK-SIZE

Open the database.
PATHSPEC ::= pathspec to the file.
READER ::= function (stream) which reads an entry.
WRITER ::= function (stream entry) which writes the entry to the stream. COUNT ::= default initial number of entries.
BLOCK-SIZE ::= agreed block size. Must be at least 16.

Returns the database.

Package

pounds.db

Source

database.lisp (file)

Function: open-log &key PATH COUNT SIZE TAG

Open a log file, creating it if it doesn’t exist.

PATH should be a string representing a pathname to the log file to use. THe file will be created if it doesn’t exist. The pathname MUST be in the local system format.

COUNT, if provided, is the number of blocks to use in the log file. Default is 16k.

SIZE is the size of each block. Default is 128 bytes. The total filesize is (* SIZE COUNT).

TAG, if provided, should be a string of exactly 4 characters which is used to tag each message written to the log file.

Returns a PLOG structure.

Package

pounds.log

Source

log.lisp (file)

Function: open-mapping PATH SIZE

Opens the file named by PATH and maps it into memory. SIZE is the size in bytes of the file to map.

Package

pounds

Source

ffi.lisp (file)

Function: read-entries BLOG ID NMSGS SEQUENCE &key START END

Read a set of messages starting from message ID.

BLOG ::= the binary log
ID ::= starting ID.
NMSGS ::= number of messages to read.
SEQUENCE ::= octet vector to receive the messages.
START, END ::= region of sequence to read into.

Returns a list of (count id start end) for each message.
COUNT ::= the length of the message, even if it couldn’t fit into the buffer.
ID ::= message ID.
START, END ::= region of SEQUENCE that the message was written into. If the message may have only been partially read into SEQUENCE if insufficient space was provided.

Note that this function does not update the internal properties and therefore does not affect subsequent calls to READ-ENTRY.

Package

pounds.blog

Source

blog.lisp (file)

Function: read-entry BLOG SEQUENCE &key START END

Read the entry starting at the index currently pointed to by the log properties.

BLOG ::= binary log
SEQUENCE ::= octet vector
START, END ::= region of sequence to read into.

If the message is larger than the sequence provided will read as much as it can, returning the truncated message in the sequence. You can use READ-ENTRY-DETAILS before calling this to ensure you have allocated sufficient space.

Updates the blog properties (but does not persist the updated properties) to the index of the next message to read.

Returns (values count id) where
COUNT ::= the number of bytes in the message.
ID ::= message ID

Package

pounds.blog

Source

blog.lisp (file)

Function: read-entry-details BLOG

Read the properties of the next entry. BLOG ::= the binary log.
Returns (values count id) where COUTN ::= length of the message
ID ::= the ID of the message.

Package

pounds.blog

Source

blog.lisp (file)

Function: read-header BLOG SEQUENCE &key START END

Read the user header data.
BLOG ::= binary log
SEQUENCE ::= octet vector
START, END ::= region of sequence to read into.

Package

pounds.blog

Source

blog.lisp (file)

Function: read-message LOG

Read the next message from the log

Package

pounds.log

Source

log.lisp (file)

Function: remap MAPPING SIZE

Remap the file. SIZE should be the new size.

Package

pounds

Source

ffi.lisp (file)

Function: remove-entry ITEM DB &key KEY TEST

Delete the item from the database.

Package

pounds.db

Source

database.lisp (file)

Function: reset-blog BLOG

Reset the binary log. Clears all data blocks and assigns new tag and seqno.

Package

pounds.blog

Source

blog.lisp (file)

Function: start-following LOG &key STREAM TAG LEVELS

Start following the log. If TAG is provided, only those messages with a matching tag will be displayed.

Package

pounds.log

Source

log.lisp (file)

Function: stop-following ()

Stop following the log.

Package

pounds.log

Source

log.lisp (file)

Function: sync-blog BLOG

Synchronize the binary log. Flushes the file mapping, reads and sets current properties.

Package

pounds.blog

Source

blog.lisp (file)

Function: write-entry BLOG SEQUENCE &key START END

Write a new message into the log.
BLOG ::= binary log
SEQUENCE ::= octet vector
START, END ::= region of sequence to write.

Writes the data into the log starting at the currently persisted index. Updates the persisted properties to the next index, ID and increments the seqno.

Returns the ID of the message that was written.

Package

pounds.blog

Source

blog.lisp (file)

Function: write-header BLOG SEQUENCE &key START END

Write the user header data.
BLOG ::= binary log
SEQUENCE ::= octet vector
START, END ::= region of sequence to write.

Note that the header is a free-access region with no record of how much of the allocated space (if any) is actually in use.

Package

pounds.blog

Source

blog.lisp (file)

Function: write-message LOG LVL MESSAGE &key TAG

Write a message to the log. Updates the log header information and advances the underlying mapping stream.

LVL should be a keyword namign a log level.

MESSAGE should be a string with the message to write.

TAG, if provided, will be the message tag, otherwise the default tag for the log will be used.

Package

pounds.log

Source

log.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Generic functions

Generic Function: mapping-stream-mapping OBJECT
Package

pounds

Methods
Method: mapping-stream-mapping (MAPPING-STREAM mapping-stream)

automatically generated reader method

Source

mappings.lisp (file)

Generic Function: mapping-stream-position OBJECT
Generic Function: (setf mapping-stream-position) NEW-VALUE OBJECT
Package

pounds

Methods
Method: mapping-stream-position (MAPPING-STREAM mapping-stream)
Method: (setf mapping-stream-position) NEW-VALUE (MAPPING-STREAM mapping-stream)

Stores the current position in the remote file.

Source

mappings.lisp (file)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 Classes

Class: mapping-stream ()
Package

pounds

Source

mappings.lisp (file)

Direct superclasses
  • fundamental-binary-output-stream (class)
  • fundamental-binary-input-stream (class)
  • trivial-gray-stream-mixin (class)
Direct methods
  • stream-force-output (method)
  • stream-finish-output (method)
  • stream-write-byte (method)
  • stream-read-byte (method)
  • stream-write-sequence (method)
  • stream-read-sequence (method)
  • stream-file-position (method)
  • stream-file-position (method)
  • stream-listen (method)
  • stream-element-type (method)
  • mapping-stream-position (method)
  • mapping-stream-position (method)
  • mapping-stream-mapping (method)
Direct slots
Slot: mapping
Initargs

:mapping

Readers

mapping-stream-mapping (generic function)

Slot: position

Stores the current position in the remote file.

Initform

0

Readers

mapping-stream-position (generic function)

Writers

(setf mapping-stream-position) (generic function)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Constants

Constant: +blog-version+
Package

pounds.blog

Source

blog.lisp (file)

Constant: +default-block-size+
Package

pounds.db

Source

database.lisp (file)

Constant: +default-count+
Package

pounds.log

Source

log.lisp (file)

Constant: +default-count+
Package

pounds.db

Source

database.lisp (file)

Constant: +default-size+
Package

pounds.log

Source

log.lisp (file)

Constant: +eintr+
Package

pounds

Source

ffi.lisp (file)

Constant: +entry-size+
Package

pounds.blog

Source

blog.lisp (file)

Constant: +flag-more+
Package

pounds.blog

Source

blog.lisp (file)

Constant: +lock-ex+
Package

pounds

Source

ffi.lisp (file)

Constant: +lock-un+
Package

pounds

Source

ffi.lisp (file)

Constant: +msg-magic+

Magic number placed at the start of a message block to make it easy to identify value messages in the log.

Package

pounds.log

Source

log.lisp (file)

Constant: +props-block+
Package

pounds.blog

Source

blog.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Special variables

Special Variable: *default-log-file*
Package

pounds.log

Source

log.lisp (file)

Special Variable: *follower*
Package

pounds.log

Source

log.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Symbol macros

Symbol Macro: *errno*
Package

pounds

Source

ffi.lisp (file)

Expansion

(pounds::%var-accessor-*errno*)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Macros

Macro: with-locked-db (DB) &body BODY
Package

pounds.db

Source

database.lisp (file)

Macro: with-mapping (VAR FILENAME SIZE) &body BODY
Package

pounds

Source

mappings.lisp (file)

Macro: with-mapping-stream (VAR MAPPING) &body BODY
Package

pounds

Source

mappings.lisp (file)

Macro: with-open-mapping (VAR FILENAME SIZE) &body BODY

Evaluate the body in the contect of a mapping stream.

Package

pounds

Source

mappings.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.5 Functions

Function: %close FD
Package

pounds

Source

ffi.lisp (file)

Function: %copy-plog INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: %flock FD OP
Package

pounds

Source

ffi.lisp (file)

Function: %fsync FD
Package

pounds

Source

ffi.lisp (file)

Function: %lseek FD OFFSET WHENCE
Package

pounds

Source

ffi.lisp (file)

Function: %make-follower &key (THREAD THREAD) (EXIT-P EXIT-P) (LOG LOG) (OUTPUT OUTPUT) (TAG TAG) (LVL LVL)
Package

pounds.log

Source

log.lisp (file)

Function: %make-plog &key (STREAM STREAM) (COUNT COUNT) (SIZE SIZE) (TAG TAG)
Package

pounds.log

Source

log.lisp (file)

Function: %mmap ADDR LENGTH PROT FLAGS FD OFFSET
Package

pounds

Source

ffi.lisp (file)

Function: %munmap P LEN
Package

pounds

Source

ffi.lisp (file)

Function: %open PATH FLAGS MODE
Package

pounds

Source

ffi.lisp (file)

Function: %pread FD BUFFER COUNT OFFSET
Package

pounds

Source

ffi.lisp (file)

Function: %pwrite FD BUFFER COUNT OFFSET
Package

pounds

Source

ffi.lisp (file)

Function: %read FD BUFFER COUNT
Package

pounds

Source

ffi.lisp (file)

Function: %strerror CODE
Package

pounds

Source

ffi.lisp (file)

Function: %var-accessor-*errno* ()
Function: (setf %var-accessor-*errno*) VALUE
Package

pounds

Source

ffi.lisp (file)

Function: %write FD BUFFER COUNT
Package

pounds

Source

ffi.lisp (file)

Function: advance-to-block LOG INDEX

Set the stream position to the block index

Package

pounds.log

Source

log.lisp (file)

Function: advance-to-id STREAM PROPS ID
Package

pounds.blog

Source

blog.lisp (file)

Function: advance-to-next LOG

Reset the log position of the next message.

Package

pounds.log

Source

log.lisp (file)

Function: advance-to-next-block LOG

Advance the stream position to the start of the next block.

Package

pounds.log

Source

log.lisp (file)

Function: blog-index BLOG
Function: (setf blog-index) INDEX BLOG
Package

pounds.blog

Source

blog.lisp (file)

Function: blog-mapping INSTANCE
Function: (setf blog-mapping) VALUE INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: blog-p OBJECT
Package

pounds.blog

Source

blog.lisp (file)

Function: blog-props INSTANCE
Function: (setf blog-props) VALUE INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: blog-stream INSTANCE
Function: (setf blog-stream) VALUE INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: check-if-open STREAM

Checks if STREAM is open and signals an error otherwise.

Package

pounds

Source

mappings.lisp (file)

Function: copy-blog INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: copy-db INSTANCE
Package

pounds.db

Source

database.lisp (file)

Function: copy-entry INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: copy-follower INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: copy-log LOG &key TAG COPY-STREAM

Make a copy of the log stream, possibly changing the log tag

Package

pounds.log

Source

log.lisp (file)

Function: copy-log-header INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: copy-log-message INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: copy-mapping INSTANCE
Package

pounds

Source

ffi.lisp (file)

Function: copy-props INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: copy-xdr-block INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: db-bsize INSTANCE
Function: (setf db-bsize) VALUE INSTANCE
Package

pounds.db

Source

database.lisp (file)

Function: db-count DB
Package

pounds.db

Source

database.lisp (file)

Function: db-header INSTANCE
Function: (setf db-header) VALUE INSTANCE
Package

pounds.db

Source

database.lisp (file)

Function: db-mapping INSTANCE
Function: (setf db-mapping) VALUE INSTANCE
Package

pounds.db

Source

database.lisp (file)

Function: db-p OBJECT
Package

pounds.db

Source

database.lisp (file)

Function: db-reader INSTANCE
Function: (setf db-reader) VALUE INSTANCE
Package

pounds.db

Source

database.lisp (file)

Function: db-stream INSTANCE
Function: (setf db-stream) VALUE INSTANCE
Package

pounds.db

Source

database.lisp (file)

Function: db-writer INSTANCE
Function: (setf db-writer) VALUE INSTANCE
Package

pounds.db

Source

database.lisp (file)

Function: decode-entry BLK
Package

pounds.blog

Source

blog.lisp (file)

Function: decode-props BLK
Package

pounds.blog

Source

blog.lisp (file)

Function: decode-uint32 BLK
Package

pounds.blog

Source

blog.lisp (file)

Function: encode-entry BLK VAL
Package

pounds.blog

Source

blog.lisp (file)

Function: encode-props BLK VAL
Package

pounds.blog

Source

blog.lisp (file)

Function: encode-uint32 BLK INT32
Package

pounds.blog

Source

blog.lisp (file)

Function: ensure-file-exists PATH SIZE

Ensures the file exists with specified size.

Package

pounds

Source

ffi.lisp (file)

Function: entry-count INSTANCE
Function: (setf entry-count) VALUE INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: entry-id INSTANCE
Function: (setf entry-id) VALUE INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: entry-p OBJECT
Package

pounds.blog

Source

blog.lisp (file)

Function: flush-buffers MAPPING

Ensure changes to the file mappign are written to disk

Package

pounds

Source

ffi.lisp (file)

Function: follow-log FOLLOWER

Print the log messages to the output stream until the exit-p flag is signalled.

Package

pounds.log

Source

log.lisp (file)

Function: follower-exit-p INSTANCE
Function: (setf follower-exit-p) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: follower-log INSTANCE
Function: (setf follower-log) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: follower-lvl INSTANCE
Function: (setf follower-lvl) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: follower-output INSTANCE
Function: (setf follower-output) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: follower-p OBJECT
Package

pounds.log

Source

log.lisp (file)

Function: follower-tag INSTANCE
Function: (setf follower-tag) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: follower-thread INSTANCE
Function: (setf follower-thread) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: get-last-error ()
Package

pounds

Source

ffi.lisp (file)

Function: header-id LOG

Read the current message ID from the log header

Package

pounds.log

Source

log.lisp (file)

Function: header-index LOG

Read the current block index from the header

Package

pounds.log

Source

log.lisp (file)

Function: int-level INT
Package

pounds.log

Source

log.lisp (file)

Function: invalid-pointer-p HANDLE
Package

pounds

Source

ffi.lisp (file)

Function: level-int LVL
Package

pounds.log

Source

log.lisp (file)

Function: lock-mapping MAP
Package

pounds

Source

ffi.lisp (file)

Function: log-header-count INSTANCE
Function: (setf log-header-count) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: log-header-id INSTANCE
Function: (setf log-header-id) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: log-header-index INSTANCE
Function: (setf log-header-index) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: log-header-p OBJECT
Package

pounds.log

Source

log.lisp (file)

Function: log-header-size INSTANCE
Function: (setf log-header-size) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: log-message-id INSTANCE
Function: (setf log-message-id) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: log-message-lvl INSTANCE
Function: (setf log-message-lvl) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: log-message-magic INSTANCE
Function: (setf log-message-magic) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: log-message-msg INSTANCE
Function: (setf log-message-msg) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: log-message-p OBJECT
Package

pounds.log

Source

log.lisp (file)

Function: log-message-tag INSTANCE
Function: (setf log-message-tag) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: log-message-time INSTANCE
Function: (setf log-message-time) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: make-blog &key (MAPPING MAPPING) (STREAM STREAM) (PROPS PROPS)
Package

pounds.blog

Source

blog.lisp (file)

Function: make-db &key (MAPPING MAPPING) (STREAM STREAM) (HEADER HEADER) (BSIZE BSIZE) (READER READER) (WRITER WRITER)
Package

pounds.db

Source

database.lisp (file)

Function: make-entry &key (ID ID) (COUNT COUNT)
Package

pounds.blog

Source

blog.lisp (file)

Function: make-follower LOG &key STREAM TAG LEVELS

Make a follower for the log streeam specified. Will output the messages to the stream provided.

Package

pounds.log

Source

log.lisp (file)

Function: make-log-header &key (ID ID) (INDEX INDEX) (COUNT COUNT) (SIZE SIZE)
Package

pounds.log

Source

log.lisp (file)

Function: make-log-message &key (MAGIC MAGIC) (ID ID) (LVL LVL) (TIME TIME) (TAG TAG) (MSG MSG)
Package

pounds.log

Source

log.lisp (file)

Function: make-mapping &key (FD FD) (PTR PTR) (SIZE SIZE) (LOCK LOCK)
Package

pounds

Source

ffi.lisp (file)

Function: make-plog MAPPING-STREAM SIZE &key TAG

Make a plog instance from a mapping stream. SIZE should be the size of each block.

Package

pounds.log

Source

log.lisp (file)

Function: make-props &key (VERSION VERSION) (NBLOCKS NBLOCKS) (ID ID) (INDEX INDEX) (TAG TAG) (SEQNO SEQNO) (HEADER-SIZE HEADER-SIZE) (BLOCK-SIZE BLOCK-SIZE)
Package

pounds.blog

Source

blog.lisp (file)

Function: make-xdr-block &key (BUFFER BUFFER) (COUNT COUNT) (OFFSET OFFSET)
Package

pounds.blog

Source

blog.lisp (file)

Function: mapping-fd INSTANCE
Function: (setf mapping-fd) VALUE INSTANCE
Package

pounds

Source

ffi.lisp (file)

Function: mapping-lock INSTANCE
Function: (setf mapping-lock) VALUE INSTANCE
Package

pounds

Source

ffi.lisp (file)

Function: mapping-p OBJECT
Package

pounds

Source

ffi.lisp (file)

Function: mapping-ptr INSTANCE
Function: (setf mapping-ptr) VALUE INSTANCE
Package

pounds

Source

ffi.lisp (file)

Function: maybe-remap DB
Package

pounds.db

Source

database.lisp (file)

Function: next-index I NBLOCKS
Package

pounds.blog

Source

blog.lisp (file)

Function: plog-count INSTANCE
Function: (setf plog-count) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: plog-p OBJECT
Package

pounds.log

Source

log.lisp (file)

Function: plog-size INSTANCE
Function: (setf plog-size) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: plog-stream INSTANCE
Function: (setf plog-stream) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: plog-tag INSTANCE
Function: (setf plog-tag) VALUE INSTANCE
Package

pounds.log

Source

log.lisp (file)

Function: prev-index I NBLOCKS
Package

pounds.blog

Source

blog.lisp (file)

Function: props-block-size INSTANCE
Function: (setf props-block-size) VALUE INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: props-header-size INSTANCE
Function: (setf props-header-size) VALUE INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: props-id INSTANCE
Function: (setf props-id) VALUE INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: props-index INSTANCE
Function: (setf props-index) VALUE INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: props-nblocks INSTANCE
Function: (setf props-nblocks) VALUE INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: props-p OBJECT
Package

pounds.blog

Source

blog.lisp (file)

Function: props-seqno INSTANCE
Function: (setf props-seqno) VALUE INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: props-tag INSTANCE
Function: (setf props-tag) VALUE INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: props-version INSTANCE
Function: (setf props-version) VALUE INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: read-blog-entry-props STREAM
Package

pounds.blog

Source

blog.lisp (file)

Function: read-blog-props STREAM
Package

pounds.blog

Source

blog.lisp (file)

Function: read-entry STREAM READER
Package

pounds.db

Source

database.lisp (file)

Function: read-entry-locked PROPS STREAM BLK SET-PROPS-P
Package

pounds.blog

Source

blog.lisp (file)

Function: read-file FD SEQUENCE OFFSET &key START END
Package

pounds

Source

ffi.lisp (file)

Function: read-header LOG
Package

pounds.log

Source

log.lisp (file)

Function: read-header STREAM
Package

pounds.db

Source

database.lisp (file)

Function: read-log-header STREAM
Package

pounds.log

Source

log.lisp (file)

Function: read-log-message STREAM BLOCK-SIZE FSIZE
Package

pounds.log

Source

log.lisp (file)

Function: read-mapping-block SEQUENCE MAPPING OFFSET &key START END

Read from the mapping offset into the sequence.

Package

pounds

Source

ffi.lisp (file)

Function: reset-xdr-block BLK
Package

pounds.blog

Source

blog.lisp (file)

Function: set-header-id-index LOG ID INDEX

Set the log header message id and block index

Package

pounds.log

Source

log.lisp (file)

Function: space-or-lose BLK N
Package

pounds.blog

Source

blog.lisp (file)

Function: unlock-mapping MAP
Package

pounds

Source

ffi.lisp (file)

Function: write-blog-entry STREAM E BLK
Package

pounds.blog

Source

blog.lisp (file)

Function: write-blog-entry-props STREAM E
Package

pounds.blog

Source

blog.lisp (file)

Function: write-blog-props STREAM PROPS
Package

pounds.blog

Source

blog.lisp (file)

Function: write-entry STREAM WRITER OBJ
Package

pounds.db

Source

database.lisp (file)

Function: write-file FD OFFSET SEQUENCE &key START END
Package

pounds

Source

ffi.lisp (file)

Function: write-header HEADER LOG
Package

pounds.log

Source

log.lisp (file)

Function: write-header STREAM HEADER
Package

pounds.db

Source

database.lisp (file)

Function: write-log-header STREAM HEADER
Package

pounds.log

Source

log.lisp (file)

Function: write-log-message STREAM ID LVL TAG MSG BLOCK-SIZE FSIZE
Package

pounds.log

Source

log.lisp (file)

Function: write-mapping-block SEQUENCE MAPPING OFFSET &key START END

Write the sequence into the mapping.

Package

pounds

Source

ffi.lisp (file)

Function: write-message-to-stream STREAM MSG

Format a message tothe stream

Package

pounds.log

Source

log.lisp (file)

Function: write-zero-at FD OFFSET
Package

pounds

Source

ffi.lisp (file)

Function: xdr-block &optional COUNT
Package

pounds.blog

Source

blog.lisp (file)

Function: xdr-block-buffer INSTANCE
Function: (setf xdr-block-buffer) VALUE INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: xdr-block-count INSTANCE
Function: (setf xdr-block-count) VALUE INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: xdr-block-offset INSTANCE
Function: (setf xdr-block-offset) VALUE INSTANCE
Package

pounds.blog

Source

blog.lisp (file)

Function: xdr-block-p OBJECT
Package

pounds.blog

Source

blog.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.6 Structures

Structure: blog ()
Package

pounds.blog

Source

blog.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: mapping
Readers

blog-mapping (function)

Writers

(setf blog-mapping) (function)

Slot: stream
Readers

blog-stream (function)

Writers

(setf blog-stream) (function)

Slot: props
Readers

blog-props (function)

Writers

(setf blog-props) (function)

Structure: db ()
Package

pounds.db

Source

database.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: mapping
Readers

db-mapping (function)

Writers

(setf db-mapping) (function)

Slot: stream
Readers

db-stream (function)

Writers

(setf db-stream) (function)

Slot: header
Readers

db-header (function)

Writers

(setf db-header) (function)

Slot: bsize
Readers

db-bsize (function)

Writers

(setf db-bsize) (function)

Slot: reader
Readers

db-reader (function)

Writers

(setf db-reader) (function)

Slot: writer
Readers

db-writer (function)

Writers

(setf db-writer) (function)

Structure: entry ()
Package

pounds.blog

Source

blog.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: id
Readers

entry-id (function)

Writers

(setf entry-id) (function)

Slot: count
Readers

entry-count (function)

Writers

(setf entry-count) (function)

Structure: follower ()
Package

pounds.log

Source

log.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: thread
Readers

follower-thread (function)

Writers

(setf follower-thread) (function)

Slot: exit-p
Readers

follower-exit-p (function)

Writers

(setf follower-exit-p) (function)

Slot: log
Readers

follower-log (function)

Writers

(setf follower-log) (function)

Slot: output
Readers

follower-output (function)

Writers

(setf follower-output) (function)

Slot: tag
Readers

follower-tag (function)

Writers

(setf follower-tag) (function)

Slot: lvl
Readers

follower-lvl (function)

Writers

(setf follower-lvl) (function)

Structure: log-header ()
Package

pounds.log

Source

log.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: id
Readers

log-header-id (function)

Writers

(setf log-header-id) (function)

Slot: index
Readers

log-header-index (function)

Writers

(setf log-header-index) (function)

Slot: count
Readers

log-header-count (function)

Writers

(setf log-header-count) (function)

Slot: size
Readers

log-header-size (function)

Writers

(setf log-header-size) (function)

Structure: log-message ()
Package

pounds.log

Source

log.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: magic
Readers

log-message-magic (function)

Writers

(setf log-message-magic) (function)

Slot: id
Readers

log-message-id (function)

Writers

(setf log-message-id) (function)

Slot: lvl
Readers

log-message-lvl (function)

Writers

(setf log-message-lvl) (function)

Slot: time
Readers

log-message-time (function)

Writers

(setf log-message-time) (function)

Slot: tag
Readers

log-message-tag (function)

Writers

(setf log-message-tag) (function)

Slot: msg
Readers

log-message-msg (function)

Writers

(setf log-message-msg) (function)

Structure: mapping ()
Package

pounds

Source

ffi.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: fd
Readers

mapping-fd (function)

Writers

(setf mapping-fd) (function)

Slot: ptr
Readers

mapping-ptr (function)

Writers

(setf mapping-ptr) (function)

Slot: size
Readers

mapping-size (function)

Writers

(setf mapping-size) (function)

Slot: lock
Initform

(bordeaux-threads:make-lock)

Readers

mapping-lock (function)

Writers

(setf mapping-lock) (function)

Structure: plog ()
Package

pounds.log

Source

log.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: stream
Readers

plog-stream (function)

Writers

(setf plog-stream) (function)

Slot: count
Readers

plog-count (function)

Writers

(setf plog-count) (function)

Slot: size
Readers

plog-size (function)

Writers

(setf plog-size) (function)

Slot: tag
Readers

plog-tag (function)

Writers

(setf plog-tag) (function)

Structure: props ()
Package

pounds.blog

Source

blog.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: version
Readers

props-version (function)

Writers

(setf props-version) (function)

Slot: nblocks
Readers

props-nblocks (function)

Writers

(setf props-nblocks) (function)

Slot: id
Readers

props-id (function)

Writers

(setf props-id) (function)

Slot: index
Readers

props-index (function)

Writers

(setf props-index) (function)

Slot: tag
Readers

props-tag (function)

Writers

(setf props-tag) (function)

Slot: seqno
Readers

props-seqno (function)

Writers

(setf props-seqno) (function)

Slot: header-size
Readers

props-header-size (function)

Writers

(setf props-header-size) (function)

Slot: block-size
Readers

props-block-size (function)

Writers

(setf props-block-size) (function)

Structure: xdr-block ()
Package

pounds.blog

Source

blog.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: buffer
Type

(vector (unsigned-byte 8))

Initform

(make-array pounds.blog::+props-block+ :element-type (quote (unsigned-byte 8)) :initial-element 0)

Readers

xdr-block-buffer (function)

Writers

(setf xdr-block-buffer) (function)

Slot: count
Type

integer

Initform

pounds.blog::+props-block+

Readers

xdr-block-count (function)

Writers

(setf xdr-block-count) (function)

Slot: offset
Type

integer

Initform

0

Readers

xdr-block-offset (function)

Writers

(setf xdr-block-offset) (function)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   P  
Index Entry  Section

F
File, Lisp, pounds.asd: The pounds<dot>asd file
File, Lisp, pounds/blog.lisp: The pounds/blog<dot>lisp file
File, Lisp, pounds/database.lisp: The pounds/database<dot>lisp file
File, Lisp, pounds/ffi.lisp: The pounds/ffi<dot>lisp file
File, Lisp, pounds/log.lisp: The pounds/log<dot>lisp file
File, Lisp, pounds/mappings.lisp: The pounds/mappings<dot>lisp file
File, Lisp, pounds/package.lisp: The pounds/package<dot>lisp file

L
Lisp File, pounds.asd: The pounds<dot>asd file
Lisp File, pounds/blog.lisp: The pounds/blog<dot>lisp file
Lisp File, pounds/database.lisp: The pounds/database<dot>lisp file
Lisp File, pounds/ffi.lisp: The pounds/ffi<dot>lisp file
Lisp File, pounds/log.lisp: The pounds/log<dot>lisp file
Lisp File, pounds/mappings.lisp: The pounds/mappings<dot>lisp file
Lisp File, pounds/package.lisp: The pounds/package<dot>lisp file

P
pounds.asd: The pounds<dot>asd file
pounds/blog.lisp: The pounds/blog<dot>lisp file
pounds/database.lisp: The pounds/database<dot>lisp file
pounds/ffi.lisp: The pounds/ffi<dot>lisp file
pounds/log.lisp: The pounds/log<dot>lisp file
pounds/mappings.lisp: The pounds/mappings<dot>lisp file
pounds/package.lisp: The pounds/package<dot>lisp file

Jump to:   F   L   P  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   R   S   U   W   X  
Index Entry  Section

%
%close: Internal functions
%copy-plog: Internal functions
%flock: Internal functions
%fsync: Internal functions
%lseek: Internal functions
%make-follower: Internal functions
%make-plog: Internal functions
%mmap: Internal functions
%munmap: Internal functions
%open: Internal functions
%pread: Internal functions
%pwrite: Internal functions
%read: Internal functions
%strerror: Internal functions
%var-accessor-*errno*: Internal functions
%write: Internal functions

(
(setf %var-accessor-*errno*): Internal functions
(setf blog-index): Internal functions
(setf blog-mapping): Internal functions
(setf blog-props): Internal functions
(setf blog-stream): Internal functions
(setf db-bsize): Internal functions
(setf db-header): Internal functions
(setf db-mapping): Internal functions
(setf db-reader): Internal functions
(setf db-stream): Internal functions
(setf db-writer): Internal functions
(setf entry-count): Internal functions
(setf entry-id): Internal functions
(setf find-entry): Exported functions
(setf follower-exit-p): Internal functions
(setf follower-log): Internal functions
(setf follower-lvl): Internal functions
(setf follower-output): Internal functions
(setf follower-tag): Internal functions
(setf follower-thread): Internal functions
(setf header): Exported functions
(setf log-header-count): Internal functions
(setf log-header-id): Internal functions
(setf log-header-index): Internal functions
(setf log-header-size): Internal functions
(setf log-message-id): Internal functions
(setf log-message-lvl): Internal functions
(setf log-message-magic): Internal functions
(setf log-message-msg): Internal functions
(setf log-message-tag): Internal functions
(setf log-message-time): Internal functions
(setf mapping-fd): Internal functions
(setf mapping-lock): Internal functions
(setf mapping-ptr): Internal functions
(setf mapping-size): Exported functions
(setf mapping-stream-position): Exported generic functions
(setf mapping-stream-position): Exported generic functions
(setf plog-count): Internal functions
(setf plog-size): Internal functions
(setf plog-stream): Internal functions
(setf plog-tag): Internal functions
(setf props-block-size): Internal functions
(setf props-header-size): Internal functions
(setf props-id): Internal functions
(setf props-index): Internal functions
(setf props-nblocks): Internal functions
(setf props-seqno): Internal functions
(setf props-tag): Internal functions
(setf props-version): Internal functions
(setf xdr-block-buffer): Internal functions
(setf xdr-block-count): Internal functions
(setf xdr-block-offset): Internal functions

A
advance-to-block: Internal functions
advance-to-id: Internal functions
advance-to-next: Internal functions
advance-to-next-block: Internal functions

B
blog-index: Internal functions
blog-mapping: Internal functions
blog-p: Internal functions
blog-properties: Exported functions
blog-props: Internal functions
blog-stream: Internal functions

C
check-if-open: Internal functions
close-blog: Exported functions
close-db: Exported functions
close-log: Exported functions
close-mapping: Exported functions
copy-blog: Internal functions
copy-db: Internal functions
copy-entry: Internal functions
copy-follower: Internal functions
copy-log: Internal functions
copy-log-header: Internal functions
copy-log-message: Internal functions
copy-mapping: Internal functions
copy-props: Internal functions
copy-xdr-block: Internal functions

D
db-bsize: Internal functions
db-count: Internal functions
db-header: Internal functions
db-mapping: Internal functions
db-p: Internal functions
db-reader: Internal functions
db-seqno: Exported functions
db-stream: Internal functions
db-writer: Internal functions
decode-entry: Internal functions
decode-props: Internal functions
decode-uint32: Internal functions
doentries: Exported macros
dump-log: Exported functions

E
encode-entry: Internal functions
encode-props: Internal functions
encode-uint32: Internal functions
ensure-file-exists: Internal functions
entry-count: Internal functions
entry-id: Internal functions
entry-p: Internal functions

F
find-entry: Exported functions
find-entry-if: Exported functions
flush-buffers: Internal functions
follow-log: Internal functions
follower-exit-p: Internal functions
follower-log: Internal functions
follower-lvl: Internal functions
follower-output: Internal functions
follower-p: Internal functions
follower-tag: Internal functions
follower-thread: Internal functions
Function, %close: Internal functions
Function, %copy-plog: Internal functions
Function, %flock: Internal functions
Function, %fsync: Internal functions
Function, %lseek: Internal functions
Function, %make-follower: Internal functions
Function, %make-plog: Internal functions
Function, %mmap: Internal functions
Function, %munmap: Internal functions
Function, %open: Internal functions
Function, %pread: Internal functions
Function, %pwrite: Internal functions
Function, %read: Internal functions
Function, %strerror: Internal functions
Function, %var-accessor-*errno*: Internal functions
Function, %write: Internal functions
Function, (setf %var-accessor-*errno*): Internal functions
Function, (setf blog-index): Internal functions
Function, (setf blog-mapping): Internal functions
Function, (setf blog-props): Internal functions
Function, (setf blog-stream): Internal functions
Function, (setf db-bsize): Internal functions
Function, (setf db-header): Internal functions
Function, (setf db-mapping): Internal functions
Function, (setf db-reader): Internal functions
Function, (setf db-stream): Internal functions
Function, (setf db-writer): Internal functions
Function, (setf entry-count): Internal functions
Function, (setf entry-id): Internal functions
Function, (setf find-entry): Exported functions
Function, (setf follower-exit-p): Internal functions
Function, (setf follower-log): Internal functions
Function, (setf follower-lvl): Internal functions
Function, (setf follower-output): Internal functions
Function, (setf follower-tag): Internal functions
Function, (setf follower-thread): Internal functions
Function, (setf header): Exported functions
Function, (setf log-header-count): Internal functions
Function, (setf log-header-id): Internal functions
Function, (setf log-header-index): Internal functions
Function, (setf log-header-size): Internal functions
Function, (setf log-message-id): Internal functions
Function, (setf log-message-lvl): Internal functions
Function, (setf log-message-magic): Internal functions
Function, (setf log-message-msg): Internal functions
Function, (setf log-message-tag): Internal functions
Function, (setf log-message-time): Internal functions
Function, (setf mapping-fd): Internal functions
Function, (setf mapping-lock): Internal functions
Function, (setf mapping-ptr): Internal functions
Function, (setf mapping-size): Exported functions
Function, (setf plog-count): Internal functions
Function, (setf plog-size): Internal functions
Function, (setf plog-stream): Internal functions
Function, (setf plog-tag): Internal functions
Function, (setf props-block-size): Internal functions
Function, (setf props-header-size): Internal functions
Function, (setf props-id): Internal functions
Function, (setf props-index): Internal functions
Function, (setf props-nblocks): Internal functions
Function, (setf props-seqno): Internal functions
Function, (setf props-tag): Internal functions
Function, (setf props-version): Internal functions
Function, (setf xdr-block-buffer): Internal functions
Function, (setf xdr-block-count): Internal functions
Function, (setf xdr-block-offset): Internal functions
Function, advance-to-block: Internal functions
Function, advance-to-id: Internal functions
Function, advance-to-next: Internal functions
Function, advance-to-next-block: Internal functions
Function, blog-index: Internal functions
Function, blog-mapping: Internal functions
Function, blog-p: Internal functions
Function, blog-properties: Exported functions
Function, blog-props: Internal functions
Function, blog-stream: Internal functions
Function, check-if-open: Internal functions
Function, close-blog: Exported functions
Function, close-db: Exported functions
Function, close-log: Exported functions
Function, close-mapping: Exported functions
Function, copy-blog: Internal functions
Function, copy-db: Internal functions
Function, copy-entry: Internal functions
Function, copy-follower: Internal functions
Function, copy-log: Internal functions
Function, copy-log-header: Internal functions
Function, copy-log-message: Internal functions
Function, copy-mapping: Internal functions
Function, copy-props: Internal functions
Function, copy-xdr-block: Internal functions
Function, db-bsize: Internal functions
Function, db-count: Internal functions
Function, db-header: Internal functions
Function, db-mapping: Internal functions
Function, db-p: Internal functions
Function, db-reader: Internal functions
Function, db-seqno: Exported functions
Function, db-stream: Internal functions
Function, db-writer: Internal functions
Function, decode-entry: Internal functions
Function, decode-props: Internal functions
Function, decode-uint32: Internal functions
Function, dump-log: Exported functions
Function, encode-entry: Internal functions
Function, encode-props: Internal functions
Function, encode-uint32: Internal functions
Function, ensure-file-exists: Internal functions
Function, entry-count: Internal functions
Function, entry-id: Internal functions
Function, entry-p: Internal functions
Function, find-entry: Exported functions
Function, find-entry-if: Exported functions
Function, flush-buffers: Internal functions
Function, follow-log: Internal functions
Function, follower-exit-p: Internal functions
Function, follower-log: Internal functions
Function, follower-lvl: Internal functions
Function, follower-output: Internal functions
Function, follower-p: Internal functions
Function, follower-tag: Internal functions
Function, follower-thread: Internal functions
Function, get-last-error: Internal functions
Function, header: Exported functions
Function, header-id: Internal functions
Function, header-index: Internal functions
Function, int-level: Internal functions
Function, invalid-pointer-p: Internal functions
Function, level-int: Internal functions
Function, lock-mapping: Internal functions
Function, log-header-count: Internal functions
Function, log-header-id: Internal functions
Function, log-header-index: Internal functions
Function, log-header-p: Internal functions
Function, log-header-size: Internal functions
Function, log-message-id: Internal functions
Function, log-message-lvl: Internal functions
Function, log-message-magic: Internal functions
Function, log-message-msg: Internal functions
Function, log-message-p: Internal functions
Function, log-message-tag: Internal functions
Function, log-message-time: Internal functions
Function, make-blog: Internal functions
Function, make-db: Internal functions
Function, make-entry: Internal functions
Function, make-follower: Internal functions
Function, make-log-header: Internal functions
Function, make-log-message: Internal functions
Function, make-mapping: Internal functions
Function, make-mapping-stream: Exported functions
Function, make-plog: Internal functions
Function, make-props: Internal functions
Function, make-xdr-block: Internal functions
Function, mapentries: Exported functions
Function, mapping-fd: Internal functions
Function, mapping-lock: Internal functions
Function, mapping-p: Internal functions
Function, mapping-ptr: Internal functions
Function, mapping-size: Exported functions
Function, maybe-remap: Internal functions
Function, next-index: Internal functions
Function, open-blog: Exported functions
Function, open-db: Exported functions
Function, open-log: Exported functions
Function, open-mapping: Exported functions
Function, plog-count: Internal functions
Function, plog-p: Internal functions
Function, plog-size: Internal functions
Function, plog-stream: Internal functions
Function, plog-tag: Internal functions
Function, prev-index: Internal functions
Function, props-block-size: Internal functions
Function, props-header-size: Internal functions
Function, props-id: Internal functions
Function, props-index: Internal functions
Function, props-nblocks: Internal functions
Function, props-p: Internal functions
Function, props-seqno: Internal functions
Function, props-tag: Internal functions
Function, props-version: Internal functions
Function, read-blog-entry-props: Internal functions
Function, read-blog-props: Internal functions
Function, read-entries: Exported functions
Function, read-entry: Exported functions
Function, read-entry: Internal functions
Function, read-entry-details: Exported functions
Function, read-entry-locked: Internal functions
Function, read-file: Internal functions
Function, read-header: Exported functions
Function, read-header: Internal functions
Function, read-header: Internal functions
Function, read-log-header: Internal functions
Function, read-log-message: Internal functions
Function, read-mapping-block: Internal functions
Function, read-message: Exported functions
Function, remap: Exported functions
Function, remove-entry: Exported functions
Function, reset-blog: Exported functions
Function, reset-xdr-block: Internal functions
Function, set-header-id-index: Internal functions
Function, space-or-lose: Internal functions
Function, start-following: Exported functions
Function, stop-following: Exported functions
Function, sync-blog: Exported functions
Function, unlock-mapping: Internal functions
Function, write-blog-entry: Internal functions
Function, write-blog-entry-props: Internal functions
Function, write-blog-props: Internal functions
Function, write-entry: Exported functions
Function, write-entry: Internal functions
Function, write-file: Internal functions
Function, write-header: Exported functions
Function, write-header: Internal functions
Function, write-header: Internal functions
Function, write-log-header: Internal functions
Function, write-log-message: Internal functions
Function, write-mapping-block: Internal functions
Function, write-message: Exported functions
Function, write-message-to-stream: Internal functions
Function, write-zero-at: Internal functions
Function, xdr-block: Internal functions
Function, xdr-block-buffer: Internal functions
Function, xdr-block-count: Internal functions
Function, xdr-block-offset: Internal functions
Function, xdr-block-p: Internal functions

G
Generic Function, (setf mapping-stream-position): Exported generic functions
Generic Function, mapping-stream-mapping: Exported generic functions
Generic Function, mapping-stream-position: Exported generic functions
get-last-error: Internal functions

H
header: Exported functions
header-id: Internal functions
header-index: Internal functions

I
int-level: Internal functions
invalid-pointer-p: Internal functions

L
level-int: Internal functions
lock-mapping: Internal functions
log-header-count: Internal functions
log-header-id: Internal functions
log-header-index: Internal functions
log-header-p: Internal functions
log-header-size: Internal functions
log-message-id: Internal functions
log-message-lvl: Internal functions
log-message-magic: Internal functions
log-message-msg: Internal functions
log-message-p: Internal functions
log-message-tag: Internal functions
log-message-time: Internal functions

M
Macro, doentries: Exported macros
Macro, with-locked-db: Internal macros
Macro, with-locked-mapping: Exported macros
Macro, with-mapping: Internal macros
Macro, with-mapping-stream: Internal macros
Macro, with-open-mapping: Internal macros
make-blog: Internal functions
make-db: Internal functions
make-entry: Internal functions
make-follower: Internal functions
make-log-header: Internal functions
make-log-message: Internal functions
make-mapping: Internal functions
make-mapping-stream: Exported functions
make-plog: Internal functions
make-props: Internal functions
make-xdr-block: Internal functions
mapentries: Exported functions
mapping-fd: Internal functions
mapping-lock: Internal functions
mapping-p: Internal functions
mapping-ptr: Internal functions
mapping-size: Exported functions
mapping-stream-mapping: Exported generic functions
mapping-stream-mapping: Exported generic functions
mapping-stream-position: Exported generic functions
mapping-stream-position: Exported generic functions
maybe-remap: Internal functions
Method, (setf mapping-stream-position): Exported generic functions
Method, mapping-stream-mapping: Exported generic functions
Method, mapping-stream-position: Exported generic functions

N
next-index: Internal functions

O
open-blog: Exported functions
open-db: Exported functions
open-log: Exported functions
open-mapping: Exported functions

P
plog-count: Internal functions
plog-p: Internal functions
plog-size: Internal functions
plog-stream: Internal functions
plog-tag: Internal functions
prev-index: Internal functions
props-block-size: Internal functions
props-header-size: Internal functions
props-id: Internal functions
props-index: Internal functions
props-nblocks: Internal functions
props-p: Internal functions
props-seqno: Internal functions
props-tag: Internal functions
props-version: Internal functions

R
read-blog-entry-props: Internal functions
read-blog-props: Internal functions
read-entries: Exported functions
read-entry: Exported functions
read-entry: Internal functions
read-entry-details: Exported functions
read-entry-locked: Internal functions
read-file: Internal functions
read-header: Exported functions
read-header: Internal functions
read-header: Internal functions
read-log-header: Internal functions
read-log-message: Internal functions
read-mapping-block: Internal functions
read-message: Exported functions
remap: Exported functions
remove-entry: Exported functions
reset-blog: Exported functions
reset-xdr-block: Internal functions

S
set-header-id-index: Internal functions
space-or-lose: Internal functions
start-following: Exported functions
stop-following: Exported functions
sync-blog: Exported functions

U
unlock-mapping: Internal functions

W
with-locked-db: Internal macros
with-locked-mapping: Exported macros
with-mapping: Internal macros
with-mapping-stream: Internal macros
with-open-mapping: Internal macros
write-blog-entry: Internal functions
write-blog-entry-props: Internal functions
write-blog-props: Internal functions
write-entry: Exported functions
write-entry: Internal functions
write-file: Internal functions
write-header: Exported functions
write-header: Internal functions
write-header: Internal functions
write-log-header: Internal functions
write-log-message: Internal functions
write-mapping-block: Internal functions
write-message: Exported functions
write-message-to-stream: Internal functions
write-zero-at: Internal functions

X
xdr-block: Internal functions
xdr-block-buffer: Internal functions
xdr-block-count: Internal functions
xdr-block-offset: Internal functions
xdr-block-p: Internal functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   R   S   U   W   X  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *   +  
B   C   E   F   H   I   L   M   N   O   P   R   S   T   V   W  
Index Entry  Section

*
*default-log-file*: Internal special variables
*errno*: Internal symbol macros
*follower*: Internal special variables

+
+blog-version+: Internal constants
+default-block-size+: Internal constants
+default-count+: Internal constants
+default-count+: Internal constants
+default-size+: Internal constants
+eintr+: Internal constants
+entry-size+: Internal constants
+flag-more+: Internal constants
+lock-ex+: Internal constants
+lock-un+: Internal constants
+msg-magic+: Internal constants
+props-block+: Internal constants

B
block-size: Internal structures
bsize: Internal structures
buffer: Internal structures

C
Constant, +blog-version+: Internal constants
Constant, +default-block-size+: Internal constants
Constant, +default-count+: Internal constants
Constant, +default-count+: Internal constants
Constant, +default-size+: Internal constants
Constant, +eintr+: Internal constants
Constant, +entry-size+: Internal constants
Constant, +flag-more+: Internal constants
Constant, +lock-ex+: Internal constants
Constant, +lock-un+: Internal constants
Constant, +msg-magic+: Internal constants
Constant, +props-block+: Internal constants
count: Internal structures
count: Internal structures
count: Internal structures
count: Internal structures

E
exit-p: Internal structures

F
fd: Internal structures

H
header: Internal structures
header-size: Internal structures

I
id: Internal structures
id: Internal structures
id: Internal structures
id: Internal structures
index: Internal structures
index: Internal structures

L
lock: Internal structures
log: Internal structures
lvl: Internal structures
lvl: Internal structures

M
magic: Internal structures
mapping: Exported classes
mapping: Internal structures
mapping: Internal structures
msg: Internal structures

N
nblocks: Internal structures

O
offset: Internal structures
output: Internal structures

P
position: Exported classes
props: Internal structures
ptr: Internal structures

R
reader: Internal structures

S
seqno: Internal structures
size: Internal structures
size: Internal structures
size: Internal structures
Slot, block-size: Internal structures
Slot, bsize: Internal structures
Slot, buffer: Internal structures
Slot, count: Internal structures
Slot, count: Internal structures
Slot, count: Internal structures
Slot, count: Internal structures
Slot, exit-p: Internal structures
Slot, fd: Internal structures
Slot, header: Internal structures
Slot, header-size: Internal structures
Slot, id: Internal structures
Slot, id: Internal structures
Slot, id: Internal structures
Slot, id: Internal structures
Slot, index: Internal structures
Slot, index: Internal structures
Slot, lock: Internal structures
Slot, log: Internal structures
Slot, lvl: Internal structures
Slot, lvl: Internal structures
Slot, magic: Internal structures
Slot, mapping: Exported classes
Slot, mapping: Internal structures
Slot, mapping: Internal structures
Slot, msg: Internal structures
Slot, nblocks: Internal structures
Slot, offset: Internal structures
Slot, output: Internal structures
Slot, position: Exported classes
Slot, props: Internal structures
Slot, ptr: Internal structures
Slot, reader: Internal structures
Slot, seqno: Internal structures
Slot, size: Internal structures
Slot, size: Internal structures
Slot, size: Internal structures
Slot, stream: Internal structures
Slot, stream: Internal structures
Slot, stream: Internal structures
Slot, tag: Internal structures
Slot, tag: Internal structures
Slot, tag: Internal structures
Slot, tag: Internal structures
Slot, thread: Internal structures
Slot, time: Internal structures
Slot, version: Internal structures
Slot, writer: Internal structures
Special Variable, *default-log-file*: Internal special variables
Special Variable, *follower*: Internal special variables
stream: Internal structures
stream: Internal structures
stream: Internal structures
Symbol Macro, *errno*: Internal symbol macros

T
tag: Internal structures
tag: Internal structures
tag: Internal structures
tag: Internal structures
thread: Internal structures
time: Internal structures

V
version: Internal structures

W
writer: Internal structures

Jump to:   *   +  
B   C   E   F   H   I   L   M   N   O   P   R   S   T   V   W  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   B   C   D   E   F   L   M   P   S   X  
Index Entry  Section

B
blog: Internal structures

C
Class, mapping-stream: Exported classes

D
db: Internal structures

E
entry: Internal structures

F
follower: Internal structures

L
log-header: Internal structures
log-message: Internal structures

M
mapping: Internal structures
mapping-stream: Exported classes

P
Package, pounds: The pounds package
Package, pounds.blog: The pounds<dot>blog package
Package, pounds.db: The pounds<dot>db package
Package, pounds.log: The pounds<dot>log package
plog: Internal structures
pounds: The pounds system
pounds: The pounds package
pounds.blog: The pounds<dot>blog package
pounds.db: The pounds<dot>db package
pounds.log: The pounds<dot>log package
props: Internal structures

S
Structure, blog: Internal structures
Structure, db: Internal structures
Structure, entry: Internal structures
Structure, follower: Internal structures
Structure, log-header: Internal structures
Structure, log-message: Internal structures
Structure, mapping: Internal structures
Structure, plog: Internal structures
Structure, props: Internal structures
Structure, xdr-block: Internal structures
System, pounds: The pounds system

X
xdr-block: Internal structures

Jump to:   B   C   D   E   F   L   M   P   S   X