Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the hyperluminal-mem Reference Manual, version 0.6.2, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 12:00:32 2018 GMT+0.
| • Introduction: | What hyperluminal-mem is all about | |
| • Systems: | The systems documentation | |
| • Modules: | The modules documentation | |
| • Files: | The files documentation | |
| • Packages: | The packages documentation | |
| • Definitions: | The symbols documentation | |
| • Indexes: | Concepts, functions, variables and data types |
Hyperluminal-mem is a high-performance serialization/deserialization library for Common Lisp, designed for untrusted data.
Hyperluminal-mem is designed and optimized for the following objectives:
Hyperluminal-mem 0.6.1 is included in the newest Quicklisp distribution.
You can now load it with: (ql:quickload "hyperluminal-mem")
Released version 0.5.2. License change from GPLv3 to LLGPL!
Older versions were bundled together with Hyperluminal-DB in a single GPLv3 package. Hyperluminal-DB is now a separate project, still under GPLv3.
See doc/NEWS.md
Hyperluminal-mem is currently tested on the following Common Lisp implementations:
Note: on ABCL, memory buffers are implemented using java.nio.ByteBuffer instead of CFFI-SYS
raw memory pointers due to currently limited compatibility between ABCL and CFFI/OSICAT libraries.
Memory-mapped files are supported, and internally use java.nio.channels.FileChannel.map()
instead of OSICAT-POSIX (mmap).
Futhermore, hyperluminal-mem test suite fails on ABCL versions up to 1.3.1 due to a bug in EQUALP implementation. The author contributed a fix to ABCL, which should included in the next release.
Hyperluminal-mem requires CFFI, OSICAT and STMX libraries to work. While reasonably portable, they exploit features well beyond ANSI Common Lisp and their support for the various Common Lisp implementations varies widely.
For this reason no general guarantees can be given: Hyperluminal-mem may or may not work on other, untested Common Lisp implementations.
Since 2nd March 2015, hyperluminal-mem is available from Quicklisp. The simplest way to obtain it is to first install Quicklisp then run these commands from REPL:
CL-USER> (ql:quickload "hyperluminal-mem")
;; lots of output...
CL-USER> (use-package :hlmem)
If all goes well, this will load Hyperluminal-mem and its dependencies, CFFI, OSICAT and STMX.
Since hyperluminal-mem was added to QuickLisp quite recently (2 March 2015), it may happen that your Quicklisp installation can't find it. In such case, you need to first update your QuickLisp installation as described here - search for "To get updated software" in the page.
In case you want to use the "latest and greatest" version directly from the author, in order to get the newest features, improvements, bug fixes, and occasionally new bugs, you need to download it into your Quicklisp local-projects folder. Open a shell and run the commands:
$ cd ~/quicklisp/local-projects
$ git clone git://github.com/cosmos72/hyperluminal-mem.git
then open a REPL and run:
CL-USER> (ql:quickload "hyperluminal-mem")
;; lots of output...
CL-USER> (use-package :hlmem)
If all goes well, this will load Hyperluminal-mem and its dependencies, CFFI, OSICAT and STMX.
In case you get errors:
check that Quicklisp is installed correctly, for example by executing at REPL:
CL-USER> (ql:quickload "osicat")
CL-USER> (ql:quickload "stmx")
if you tried to download the stable version from Quicklisp, check that your quicklisp is updated and knows about hyperluminal-mem:
CL-USER> (ql:system-apropos "hyperluminal-mem")
should print something like
#<SYSTEM hyperluminal-mem / hyperluminal-mem-20150302-git / quicklisp 2015-03-02>
#<SYSTEM hyperluminal-mem-test / hyperluminal-mem-20150302-git / quicklisp 2015-03-02>
If it doesn't, you need to update Quicklisp as described here - search for "To get updated software" in the page.
if you tried to download the latest version from Github,
check that you downloaded hyperluminal-mem creating an hyperluminal-mem/ folder
inside your Quicklisp local-projects folder, usually ~/quicklisp/local-projects
After loading Hyperluminal-mem for the first time, it is recommended to run the test suite to check that everything works as expected. From the REPL, run:
CL-USER> (ql:quickload "hyperluminal-mem-test")
;; lots of output...
CL-USER> (fiveam:run! 'hyperluminal-mem-test:suite)
;; even more output...
Did 3364 checks.
Pass: 3364 (100%)
Skip: 0 ( 0%)
Fail: 0 ( 0%)
Note: (ql:quickload "hyperluminal-mem-test") intentionally works only
after (ql:quickload "hyperluminal-mem") has completed successfuly.
The test suite should report zero Skip and zero Fail; the number of Pass may vary. You are welcome to report any failure you get while running the test suites, please include in the report:
See "Contacts, help, discussion" below for the preferred method to send the report.
Hyperluminal-mem reads and writes serialized data to raw memory, using CFFI foreign pointers - equivalent to C/C++ pointers.
The most direct way to save serialized data to disk, and to load it back, is to open a file then map it to memory with the POSIX mmap() system call provided by OSICAT library.
An alternative, suitable both for files and network sockets,
is to allocate a raw memory buffer with (hlmem:malloc-words)
then use the POSIX read() and write() calls provided by OSICAT library.
Hyperluminal-mem offers the following Lisp types, constants, macros and functions,
also documented in the sources - remember (describe 'some-symbol) at REPL.
MADDRESS is the type of raw memory pointers.
It is currently an alias for the type cffi-sys:foreign-pointer
MEM-WORD is the type of a word of raw memory.
It is normally autodetected to match the underlying CPU registers,
i.e. mem-word is normally (unsigned-byte 32) on 32-bit systems,
(unsigned-byte 64) on 64-bit systems, and so on... but it is also possible
to override such autodetection and configure it manually.
See the section File Format and ABI below for details.
+MSIZEOF-WORD+ is a constant equal to the number of bytes in a word.
It is autodetected to match the definition of mem-word.
MEM-SIZE is a type: it represents the length of a raw memory block,
counted in words (not in bytes). Used by all the functions that manipulate
raw memory in units of mem-words - which means most Hyperluminal-MEM functions.
For the curious, in practice it is (unsigned-byte 30) on 32-bit systems,
(unsigned-byte 61) on 64-bit systems, and so on...
(MALLOC n-bytes) is a function, it allocates raw memory and returns a raw pointer to it.
It is actually a simple alias for the function (cffi-sys:%foreign-alloc n-bytes)
and it is equivalent to the function void * malloc(size_t n_bytes) found in C/C++ languages.
Definition:
(defun malloc (n-bytes)
(declare (type unsigned-byte n-bytes))
(the maddress (cffi-sys:%foreign-alloc n-bytes)))
Remember that, as in C/C++, the memory returned by malloc must be deallocated manually:
call mfree on it when no longer needed.
(MALLOC-WORDS n-words) is a function, it allocates raw memory and returns
a raw pointer to it just like malloc.
It is usually more handy than malloc since almost all Hyperluminal-mem functions
count and expect memory length in words, not in bytes.
Definition:
(defun malloc-words (n-words)
(declare (type mem-size n-words))
(the maddress #| ...implementation... |# ))
(MFREE ptr) deallocates raw memory previously obtained with malloc-words, malloc
or cffi-sys:%foreign-alloc. It is actually a simple alias for the function
cffi-sys:foreign-free and it is equivalent to the function void free(void * ptr)
found in C/C++ languages.
Definition:
(defun mfree (ptr)
(declare (type maddress ptr))
(cffi-sys:foreign-free ptr))
(WITH-MEM-WORDS (ptr n-words [n-words-var]) &body body)
is a macro that binds PTR to N-WORDS words of raw memory while executing BODY.
The raw memory is automatically deallocated when BODY terminates.
with-mem-words is an alternative to malloc and malloc-words,
useful if you know in advance that the raw memory can be deallocated after BODY finishes.
It is a wrapper around the CFFI macro
(cffi-sys:with-foreign-pointer (var size &optional size-var) &body body)
which performs the same task but counts memory size in bytes, not in words.
Other alternatives to obtain raw memory include at least:
make-static-vector and static-vector-pointer
from STATIC-VECTORS library (remember to call free-static-vector when done)mmap
from OSICAT library (remember to call munmap when done)(MSIZE index value) is a function that examines a Lisp value, and tells
how many words of raw memory are needed to serialize it.
It is useful to know how large a raw memory block must be in order to write a serialized value into it. It is defined as:
(defun msize (index value)
(declare (type t value)
(type mem-size index))
(the mem-size (+ index
#| ...implementation... |#)))
The argument INDEX is useful to compute the total size of composite values,
as for example lists, arrays, hash-tables and objects: the value returned by msize
is increased by the value of index, so the following three code snippets are equivalent
(+ (msize 0 "foo") (msize 0 'bar))
(let ((index (msize 0 "foo")))
(msize index 'bar))
(msize (msize 0 "foo") 'bar)
with the advantage that the second and third versions automatically check for length overflows and can exploit tail-call optimizations.
msize supports the same types as MWRITE below, and can be extended similarly
to support arbitrary types, see MSIZE-OBJECT and MWRITE-OBJECT for details.
(MWRITE ptr index end-index value) serializes a Lisp value, writing it into raw memory.
It is defined as:
(defun mwrite (ptr index end-index value)
(declare (type maddress ptr)
(type mem-size index end-index)
(type t value))
(the mem-size #| ...implementation... |#))
To use it, you need three things beyond the value to serialize:
malloc-words, malloc or with-mem-words described above.index argumentend-index argumentmwrite returns an offset pointing immediately after the serialized value.
This allows to easily write consecutive serialized values into the raw memory.
Any kind of raw memory is supported, thus it is also possible to call mwrite
on memory-mapped files. This is actually the mechanism that allows Hyperluminal-mem
to implement an object store backed by memory-mapped files.
mwrite supports the following standard Lisp types:
It also supports the following types implemented by STMX (requires latest STMX from GitHub):
Finally, it can be easily extended to support arbitrary types,
see MWRITE-OBJECT for details.
(MREAD ptr index end-index) deserializes a Lisp value, reading it from raw memory.
It is defined as:
(defun mread (ptr index end-index)
(declare (type maddress ptr)
(type mem-size index end-index))
(the (values t mem-size)
#| ...implementation... |#))
It returns two values: the value itself, and an offset pointing immediately after the serialized value inside raw memory. This allows to easily read consecutive serialized values from the raw memory.
mread supports the same types as mwrite and it can be extended similarly,
see MREAD-OBJECT and MWRITE-OBJECT for details.
(MSIZE-OBJECT object index) is a generic function that examines a user-defined
Lisp object and tells how many words of raw memory are needed to serialize it.
Programmers can extend Hyperluminal-mem by defining specialized methods for it,
see MWRITE-OBJECT for details.
(MREAD-OBJECT type ptr index end-index &key) is a generic function that reads
a serialized user-defined object from raw memory, deserializes and returns it.
Programmers can extend Hyperluminal-mem by defining specialized methods for it,
see MWRITE-OBJECT for details.
(MWRITE-OBJECT object ptr index end-index) is a generic function
that serializes a user-defined Lisp object, writing it into raw memory.
Programmers can extend Hyperluminal-mem by defining specialized methods for
msize-object, mwrite-object and mread-object. Such methods are invoked
automatically by msize, mwrite and mread when they encounter a user-defined object,
i.e. an instance of structure-object or standard-object or their subclasses.
The task of msize-object, mwrite-object and mread-object is relatively
straightforward: they are supposed to cycle through the relevant instance slots
(or accessors) and recursively call msize, mwrite or mread on each slot.
For example, if a POINT3D class is defined as
(defclass point3d ()
((x :initarg :x :initform 0.0 :accessor point3d-x)
(y :initarg :y :initform 0.0 :accessor point3d-y)
(z :initarg :z :initform 0.0 :accessor point3d-z)))
then a reasonable specialization of msize-object is:
(defmethod msize-object ((p point3d) index)
(let* ((index-x (msize index (point3d-x p)))
(index-y (msize index-x (point3d-y p)))
(index-z (msize index-y (point3d-z p))))
index-z))
note how the result of each msize call is passed to the next call - this ensures
that the sum of the sizes is computed automatically, and also takes care of signalling
an error in case of overflow.
A shorter, slightly automagic alternative is to use the macro msize*
which expands to multiple calls of msize and correctly passes around the
intermediate index values:
(defmethod msize-object ((p point3d) index)
(msize* index (point3d-x p) (point3d-y p) (point3d-z p)))
Similarly, mwrite-object can be specialized as:
(defmethod mwrite-object ((p point3d) ptr index end-index)
(let* ((index-x (mwrite (point3d-x p) ptr index end-index))
(index-y (mwrite (point3d-y p) ptr index-x end-index))
(index-z (mwrite (point3d-z p) ptr index-y end-index)))
index-z))
which uses the same index-passing mechanism to compute the serialized value total size.
Again a shorter, slightly automagic alternative is to use the macro mwrite*
which expands to multiple calls of mwrite and correctly passes around the
intermediate index values:
(defmethod mwrite-object ((p point3d) ptr index end-index)
(mwrite* ptr index end-index (point3d-x p) (point3d-y p) (point3d-z p)))
Defining mread-object specialization is slightly more complicated, for two reasons:
first, it also needs to instantiate an appropriate object and fill its slots
and second, mread and mread-object return multiple values.
The result is a painstaking nest of multiple-value-bind:
(defmethod mread-object ((type (eql 'point3d)) ptr index end-index &key)
(multiple-value-bind (x index-x) (mread ptr index end-index)
(multiple-value-bind (y index-y) (mread ptr index-x end-index)
(multiple-value-bind (z index-z) (mread ptr index-y end-index)
(values
(make-instance 'point3d :x x :y y :z z)
index-z)))))
The with-mread* macro comes to the rescue, removing most boilerplate code:
(defmethod mread-object ((type (eql 'point3d)) ptr index end-index &key)
(with-mread* (x y z new-index) (ptr index end-index)
(values
(make-instance 'point3d :x x :y y :z z)
new-index)))))
An alternative approach to implement msize-object, mread-object and
mwrite-object for standard-objects is to take advantage of the generic
functions mlist-objects-slots, msize-object-slots, mread-object-slots
and mwrite-object-slots. See MWRITE-OBJECT-SLOTS for details.
MLIST-OBJECT-SLOTS is a generic function, useful to implement msize-object,
mread-object and mwrite-object when extending Hyperluminal-mem.
See MWRITE-OBJECT-SLOTS for details.
MSIZE-OBJECT-SLOTS is a generic function, useful to implement msize-object
when extending Hyperluminal-mem. See MWRITE-OBJECT-SLOTS for details.
MREAD-OBJECT-SLOTS is a generic function, useful to implement mread-object
when extending Hyperluminal-mem. See MWRITE-OBJECT-SLOTS for details.
MWRITE-OBJECT-SLOTS is a generic function, useful to implement mwrite-object
when extending Hyperluminal-mem. Details:
The mechanism described in MWRITE-OBJECT above is very powerful and general,
but sometimes all you need is to serialize/deserialize the slots of a standard-object:
in this case it surely feels overcomplicated.
For such purpose, Hyperluminal-mem provides the functions
msize-object-slots, mread-object-slots and mwrite-object-slots
which automatically obtain the slots of an object (more details below) and call
the appropriate function among msize, mread, mwrite on each slot.
This allows programmers to implement msize-object, mread-object
and mwrite-object with the following six lines of code:
(defmethod msize-object ((object point3d) index)
(msize-object-slots object index))
(defmethod mwrite-object ((object point3d) ptr index end-index)
(mwrite-object-slots object ptr index end-index))
(defmethod mread-object ((type (eql 'point3d) ptr index end-index &key)
(mread-object-slots (make-instance 'point3d) ptr index end-index))
This simplified approach has some limitations:
it only works on standard-objects, i.e. on classes defined with (defclass ...)
it can only serialize/deserialize (some or all) the object slots
with plain msize, mread and mwrite, i.e. it is not possible to
specify a customized logic to serialize/deserialize the slots.
it must be possible to construct the object with some initial, dummy
slot values in order to pass it to mread-object-slots.
This function will then set the actual slot values.
by default, all slots are serialized/deserialized. To override this
behaviour, programmers can specialize the generic function mlist-object-slots,
which must return the list of slots (either slot names or closer-mop:slot-definition)
to be serialized/deserialized. The methods on mlist-object-slots have the form:
(defmethod mlist-object-slots ((object point3d))
'(x y z))
i.e. they must be specialized on objects, not on their class names.
MWRITE-MAGIC to be documented...
MREAD-MAGIC to be documented...
(HLMEM-VERSION) is a function that returns the current version of
Hyperluminal-mem. The returned value is a list having the form
'(major minor patch) as for example '(0 5 2)
By default, Hyperluminal-mem serialization format and ABI is autodetected to match Lisp idea of CFFI-SYS pointers:
In other words, mem-word is normally autodetected to match the width
of underlying CPU registers (exposed through CFFI-SYS foreign-type :pointer)
and +msizeof-word+ is set accordingly.
It is possible to override such autodetection by adding an appropriate entry
in the global variable *FEATURES* before compiling and loading Hyperluminal-mem.
Doing so disables autodetection and either tells Hyperluminal-mem the desired size
of mem-word or, in alternative, the CFFI-SYS type it should use for mem-word.
For example, to force 64 bit (= 8 bytes) file format and ABI, execute the following form before compiling and loading Hyperluminal-mem:
(pushnew :hyperluminal-mem/word-size/8 *features*)
on the other hand, to force 32 bit (= 4 bytes) file format and ABI, execute the form
(pushnew :hyperluminal-mem/word-size/4 *features*)
in both cases, the Hyperluminal-mem internal function (choose-word-type)
will recognize the override and define mem-word and +msizeof-word+
to match a CFFI-SYS unsigned integer type having the specified size
among the following candidates:
In case it does not find a type with the requested size, it will signal an error.
Forcing the same value that would be autodetected is fine and harmless.
Also, the chosen type must be at least 32 bits wide, but there is no upper limit:
Hyperluminal-mem is designed to automatically support 64 bits systems,
128 bit systems, and anything else that will exist in the future.
It even supports 'unusual' configurations where the size of mem-word
is not a power of two (ever heard of 36-bit CPUs?).
For the far future (which arrives surprisingly quickly in software) where CFFI-SYS will know about further unsigned integer types, it is also possible to explicitly specify the type to use by executing a form like
(pushnew :hyperluminal-mem/word-type/<SOME-CFFI-SYS-TYPE> *features*)
as for example:
(pushnew :hyperluminal-mem/word-type/unsigned-long-long *features*)
Hyperluminal-mem will honour such override, intern the type name
to convert it to a keyword, use it as the definition of mem-word,
and derive +msizeof-word+ from it.
As of February 2015, Hyperluminal-mem is being written by Massimiliano Ghilardi and it is considered by the author to be fairly stable, tested and documented. It may still contain some rough edges and minor bugs.
As long as the traffic is low enough, GitHub Issues can be used to report test suite failures, bugs, suggestions, general discussion etc.
If the traffic becomes high, more appropriate discussion channels will be set-up.
The author will also try to answer support requests, but gives no guarantees.
Hyperluminal-mem is released under the terms of the Lisp Lesser General Public License, known as the LLGPL.
Next: Modules, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
| • The hyperluminal-mem system: |
Massimiliano Ghilardi
LLGPL
High-performance serialization library, designed for untrusted data
0.6.2
hyperluminal-mem.asd (file)
Modules are listed depth-first from the system components tree.
| • The hyperluminal-mem/lang module: | ||
| • The hyperluminal-mem/ffi module: | ||
| • The hyperluminal-mem/sbcl module: | ||
| • The hyperluminal-mem/mem module: | ||
| • The hyperluminal-mem/tree module: |
Next: The hyperluminal-mem/ffi module, Previous: Modules, Up: Modules [Contents][Index]
hyperluminal-mem (system)
lang/
Next: The hyperluminal-mem/sbcl module, Previous: The hyperluminal-mem/lang module, Up: Modules [Contents][Index]
lang (module)
hyperluminal-mem (system)
ffi/
Next: The hyperluminal-mem/mem module, Previous: The hyperluminal-mem/ffi module, Up: Modules [Contents][Index]
hyperluminal-mem (system)
sbcl/
Next: The hyperluminal-mem/tree module, Previous: The hyperluminal-mem/sbcl module, Up: Modules [Contents][Index]
hyperluminal-mem (system)
mem/
Previous: The hyperluminal-mem/mem module, Up: Modules [Contents][Index]
mem (module)
hyperluminal-mem (system)
tree/
Files are sorted by type and then listed depth-first from the systems components trees.
| • Lisp files: | ||
| • Other files: |
Next: Other files, Previous: Files, Up: Files [Contents][Index]
Next: The hyperluminal-mem/lang/package<dot>lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
hyperluminal-mem.asd
hyperluminal-mem (system)
Next: The hyperluminal-mem/lang/lang<dot>lisp file, Previous: The hyperluminal-mem<dot>asd file, Up: Lisp files [Contents][Index]
lang (module)
lang/package.lisp
Next: The hyperluminal-mem/lang/swap-bytes<dot>lisp file, Previous: The hyperluminal-mem/lang/package<dot>lisp file, Up: Lisp files [Contents][Index]
package.lisp (file)
lang (module)
lang/lang.lisp
unwrap-list-1 (function)
Next: The hyperluminal-mem/ffi/package<dot>lisp file, Previous: The hyperluminal-mem/lang/lang<dot>lisp file, Up: Lisp files [Contents][Index]
package.lisp (file)
lang (module)
lang/swap-bytes.lisp
Next: The hyperluminal-mem/ffi/ffi<dot>lisp file, Previous: The hyperluminal-mem/lang/swap-bytes<dot>lisp file, Up: Lisp files [Contents][Index]
ffi (module)
ffi/package.lisp
Next: The hyperluminal-mem/ffi/struct<dot>lisp file, Previous: The hyperluminal-mem/ffi/package<dot>lisp file, Up: Lisp files [Contents][Index]
package.lisp (file)
ffi (module)
ffi/ffi.lisp
Next: The hyperluminal-mem/ffi/os<dot>lisp file, Previous: The hyperluminal-mem/ffi/ffi<dot>lisp file, Up: Lisp files [Contents][Index]
ffi.lisp (file)
ffi (module)
ffi/struct.lisp
ffi-defstruct (macro)
Next: The hyperluminal-mem/sbcl/package<dot>lisp file, Previous: The hyperluminal-mem/ffi/struct<dot>lisp file, Up: Lisp files [Contents][Index]
ffi.lisp (file)
ffi (module)
ffi/os.lisp
Next: The hyperluminal-mem/sbcl/export<dot>lisp file, Previous: The hyperluminal-mem/ffi/os<dot>lisp file, Up: Lisp files [Contents][Index]
sbcl (module)
sbcl/package.lisp
Next: The hyperluminal-mem/sbcl/compiler<dot>lisp file, Previous: The hyperluminal-mem/sbcl/package<dot>lisp file, Up: Lisp files [Contents][Index]
package.lisp (file)
sbcl (module)
sbcl/export.lisp
Next: The hyperluminal-mem/sbcl/x86<dot>lisp file, Previous: The hyperluminal-mem/sbcl/export<dot>lisp file, Up: Lisp files [Contents][Index]
package.lisp (file)
sbcl (module)
sbcl/compiler.lisp
Next: The hyperluminal-mem/mem/package<dot>lisp file, Previous: The hyperluminal-mem/sbcl/compiler<dot>lisp file, Up: Lisp files [Contents][Index]
compiler.lisp (file)
sbcl (module)
sbcl/x86.lisp
Next: The hyperluminal-mem/mem/lang<dot>lisp file, Previous: The hyperluminal-mem/sbcl/x86<dot>lisp file, Up: Lisp files [Contents][Index]
mem (module)
mem/package.lisp
Next: The hyperluminal-mem/mem/version<dot>lisp file, Previous: The hyperluminal-mem/mem/package<dot>lisp file, Up: Lisp files [Contents][Index]
package.lisp (file)
mem (module)
mem/lang.lisp
Next: The hyperluminal-mem/mem/defs<dot>lisp file, Previous: The hyperluminal-mem/mem/lang<dot>lisp file, Up: Lisp files [Contents][Index]
lang.lisp (file)
mem (module)
mem/version.lisp
Next: The hyperluminal-mem/mem/native-mem<dot>lisp file, Previous: The hyperluminal-mem/mem/version<dot>lisp file, Up: Lisp files [Contents][Index]
lang.lisp (file)
mem (module)
mem/defs.lisp
Next: The hyperluminal-mem/mem/endianity<dot>lisp file, Previous: The hyperluminal-mem/mem/defs<dot>lisp file, Up: Lisp files [Contents][Index]
defs.lisp (file)
mem (module)
mem/native-mem.lisp
Next: The hyperluminal-mem/mem/float<dot>lisp file, Previous: The hyperluminal-mem/mem/native-mem<dot>lisp file, Up: Lisp files [Contents][Index]
native-mem.lisp (file)
mem (module)
mem/endianity.lisp
Next: The hyperluminal-mem/mem/mem<dot>lisp file, Previous: The hyperluminal-mem/mem/endianity<dot>lisp file, Up: Lisp files [Contents][Index]
endianity.lisp (file)
mem (module)
mem/float.lisp
Next: The hyperluminal-mem/mem/constants<dot>lisp file, Previous: The hyperluminal-mem/mem/float<dot>lisp file, Up: Lisp files [Contents][Index]
float.lisp (file)
mem (module)
mem/mem.lisp
Next: The hyperluminal-mem/mem/symbols<dot>lisp file, Previous: The hyperluminal-mem/mem/mem<dot>lisp file, Up: Lisp files [Contents][Index]
mem.lisp (file)
mem (module)
mem/constants.lisp
Next: The hyperluminal-mem/mem/int<dot>lisp file, Previous: The hyperluminal-mem/mem/constants<dot>lisp file, Up: Lisp files [Contents][Index]
constants.lisp (file)
mem (module)
mem/symbols.lisp
Next: The hyperluminal-mem/mem/unboxed<dot>lisp file, Previous: The hyperluminal-mem/mem/symbols<dot>lisp file, Up: Lisp files [Contents][Index]
symbols.lisp (file)
mem (module)
mem/int.lisp
Next: The hyperluminal-mem/mem/ffi-late<dot>lisp file, Previous: The hyperluminal-mem/mem/int<dot>lisp file, Up: Lisp files [Contents][Index]
int.lisp (file)
mem (module)
mem/unboxed.lisp
Next: The hyperluminal-mem/mem/box<dot>lisp file, Previous: The hyperluminal-mem/mem/unboxed<dot>lisp file, Up: Lisp files [Contents][Index]
unboxed.lisp (file)
mem (module)
mem/ffi-late.lisp
Next: The hyperluminal-mem/mem/magic<dot>lisp file, Previous: The hyperluminal-mem/mem/ffi-late<dot>lisp file, Up: Lisp files [Contents][Index]
mem (module)
mem/box.lisp
Next: The hyperluminal-mem/mem/unicode<dot>lisp file, Previous: The hyperluminal-mem/mem/box<dot>lisp file, Up: Lisp files [Contents][Index]
box.lisp (file)
mem (module)
mem/magic.lisp
Next: The hyperluminal-mem/mem/box/bignum<dot>lisp file, Previous: The hyperluminal-mem/mem/magic<dot>lisp file, Up: Lisp files [Contents][Index]
box.lisp (file)
mem (module)
mem/unicode.lisp
Next: The hyperluminal-mem/mem/box/ratio<dot>lisp file, Previous: The hyperluminal-mem/mem/unicode<dot>lisp file, Up: Lisp files [Contents][Index]
box.lisp (file)
mem (module)
mem/box/bignum.lisp
Next: The hyperluminal-mem/mem/box/float<dot>lisp file, Previous: The hyperluminal-mem/mem/box/bignum<dot>lisp file, Up: Lisp files [Contents][Index]
box/bignum.lisp (file)
mem (module)
mem/box/ratio.lisp
Next: The hyperluminal-mem/mem/box/complex<dot>lisp file, Previous: The hyperluminal-mem/mem/box/ratio<dot>lisp file, Up: Lisp files [Contents][Index]
box.lisp (file)
mem (module)
mem/box/float.lisp
Next: The hyperluminal-mem/mem/box/pathname<dot>lisp file, Previous: The hyperluminal-mem/mem/box/float<dot>lisp file, Up: Lisp files [Contents][Index]
mem (module)
mem/box/complex.lisp
Next: The hyperluminal-mem/mem/box/hash-table<dot>lisp file, Previous: The hyperluminal-mem/mem/box/complex<dot>lisp file, Up: Lisp files [Contents][Index]
box.lisp (file)
mem (module)
mem/box/pathname.lisp
Next: The hyperluminal-mem/mem/box/list<dot>lisp file, Previous: The hyperluminal-mem/mem/box/pathname<dot>lisp file, Up: Lisp files [Contents][Index]
box.lisp (file)
mem (module)
mem/box/hash-table.lisp
Next: The hyperluminal-mem/mem/box/array<dot>lisp file, Previous: The hyperluminal-mem/mem/box/hash-table<dot>lisp file, Up: Lisp files [Contents][Index]
box.lisp (file)
mem (module)
mem/box/list.lisp
Next: The hyperluminal-mem/mem/box/vector<dot>lisp file, Previous: The hyperluminal-mem/mem/box/list<dot>lisp file, Up: Lisp files [Contents][Index]
box.lisp (file)
mem (module)
mem/box/array.lisp
Next: The hyperluminal-mem/mem/box/string-utf-8<dot>lisp file, Previous: The hyperluminal-mem/mem/box/array<dot>lisp file, Up: Lisp files [Contents][Index]
box/array.lisp (file)
mem (module)
mem/box/vector.lisp
Next: The hyperluminal-mem/mem/box/string-ascii<dot>lisp file, Previous: The hyperluminal-mem/mem/box/vector<dot>lisp file, Up: Lisp files [Contents][Index]
mem (module)
mem/box/string-utf-8.lisp
Next: The hyperluminal-mem/mem/box/bit-vector<dot>lisp file, Previous: The hyperluminal-mem/mem/box/string-utf-8<dot>lisp file, Up: Lisp files [Contents][Index]
box/vector.lisp (file)
mem (module)
mem/box/string-ascii.lisp
Next: The hyperluminal-mem/mem/box/symbol<dot>lisp file, Previous: The hyperluminal-mem/mem/box/string-ascii<dot>lisp file, Up: Lisp files [Contents][Index]
box/vector.lisp (file)
mem (module)
mem/box/bit-vector.lisp
Next: The hyperluminal-mem/mem/mvar<dot>lisp file, Previous: The hyperluminal-mem/mem/box/bit-vector<dot>lisp file, Up: Lisp files [Contents][Index]
box.lisp (file)
mem (module)
mem/box/symbol.lisp
Next: The hyperluminal-mem/mem/struct<dot>lisp file, Previous: The hyperluminal-mem/mem/box/symbol<dot>lisp file, Up: Lisp files [Contents][Index]
box.lisp (file)
mem (module)
mem/mvar.lisp
Next: The hyperluminal-mem/mem/object<dot>lisp file, Previous: The hyperluminal-mem/mem/mvar<dot>lisp file, Up: Lisp files [Contents][Index]
mvar.lisp (file)
mem (module)
mem/struct.lisp
Next: The hyperluminal-mem/mem/object/gmap<dot>lisp file, Previous: The hyperluminal-mem/mem/struct<dot>lisp file, Up: Lisp files [Contents][Index]
struct.lisp (file)
mem (module)
mem/object.lisp
Next: The hyperluminal-mem/mem/object/ghash-table<dot>lisp file, Previous: The hyperluminal-mem/mem/object<dot>lisp file, Up: Lisp files [Contents][Index]
object.lisp (file)
mem (module)
mem/object/gmap.lisp
mread-object/gmap (function)
Next: The hyperluminal-mem/mem/object/tcell<dot>lisp file, Previous: The hyperluminal-mem/mem/object/gmap<dot>lisp file, Up: Lisp files [Contents][Index]
object.lisp (file)
mem (module)
mem/object/ghash-table.lisp
mread-object/ghash-table (function)
Next: The hyperluminal-mem/mem/object/tstack<dot>lisp file, Previous: The hyperluminal-mem/mem/object/ghash-table<dot>lisp file, Up: Lisp files [Contents][Index]
object.lisp (file)
mem (module)
mem/object/tcell.lisp
mlist-class-slots (method)
Next: The hyperluminal-mem/mem/boxed<dot>lisp file, Previous: The hyperluminal-mem/mem/object/tcell<dot>lisp file, Up: Lisp files [Contents][Index]
object.lisp (file)
mem (module)
mem/object/tstack.lisp
mlist-class-slots (method)
Next: The hyperluminal-mem/tree/package<dot>lisp file, Previous: The hyperluminal-mem/mem/object/tstack<dot>lisp file, Up: Lisp files [Contents][Index]
mem (module)
mem/boxed.lisp
Next: The hyperluminal-mem/tree/b+node<dot>lisp file, Previous: The hyperluminal-mem/mem/boxed<dot>lisp file, Up: Lisp files [Contents][Index]
tree (module)
tree/package.lisp
Next: The hyperluminal-mem/tree/b+leaf<dot>lisp file, Previous: The hyperluminal-mem/tree/package<dot>lisp file, Up: Lisp files [Contents][Index]
package.lisp (file)
tree (module)
tree/b+node.lisp
Next: The hyperluminal-mem/tree/b+tree<dot>lisp file, Previous: The hyperluminal-mem/tree/b+node<dot>lisp file, Up: Lisp files [Contents][Index]
b+node.lisp (file)
tree (module)
tree/b+leaf.lisp
Next: The hyperluminal-mem/tree/test-b+tree<dot>lisp file, Previous: The hyperluminal-mem/tree/b+leaf<dot>lisp file, Up: Lisp files [Contents][Index]
b+leaf.lisp (file)
tree (module)
tree/b+tree.lisp
Previous: The hyperluminal-mem/tree/b+tree<dot>lisp file, Up: Lisp files [Contents][Index]
b+tree.lisp (file)
tree (module)
tree/test-b+tree.lisp
Previous: Lisp files, Up: Files [Contents][Index]
| • The hyperluminal-mem/hyperluminal-mem.asd file: |
Previous: Other files, Up: Other files [Contents][Index]
hyperluminal-mem (system)
hyperluminal-mem.asd
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
Next: The hyperluminal-mem-ffi package, Previous: Packages, Up: Packages [Contents][Index]
package.lisp (file)
hlm-lang
common-lisp
unwrap-list-1 (function)
Next: The hyperluminal-mem-sbcl package, Previous: The hyperluminal-mem-lang package, Up: Packages [Contents][Index]
package.lisp (file)
hlm-ffi
common-lisp
Next: The hyperluminal-mem-asm package, Previous: The hyperluminal-mem-ffi package, Up: Packages [Contents][Index]
package.lisp (file)
hlm-sbcl
Next: The hyperluminal-mem package, Previous: The hyperluminal-mem-sbcl package, Up: Packages [Contents][Index]
export.lisp (file)
hlm-asm
Next: The hyperluminal-mem-tree package, Previous: The hyperluminal-mem-asm package, Up: Packages [Contents][Index]
package.lisp (file)
Previous: The hyperluminal-mem package, Up: Packages [Contents][Index]
package.lisp (file)
hlm-tree
common-lisp
Definitions are sorted by export status, category, package, and then by lexicographic order.
| • Exported definitions: | ||
| • Internal definitions: |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
| • Exported constants: | ||
| • Exported macros: | ||
| • Exported compiler macros: | ||
| • Exported functions: | ||
| • Exported generic functions: | ||
| • Exported structures: | ||
| • Exported types: |
Next: Exported macros, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
os.lisp (file)
native-mem.lisp (file)
defs.lisp (file)
ffi.lisp (file)
Next: Exported compiler macros, Previous: Exported constants, Up: Exported definitions [Contents][Index]
lang.lisp (file)
lang.lisp (file)
shortcut for (defmethod mread-object (...))
object.lisp (file)
shortcut for (decl-msize-class ...) (decl-mwrite-class ...) (decl-mread-class ...)
object.lisp (file)
shortcut for (defmethod msize-object ((class (eql CLASS-NAME)) index) ...)
object.lisp (file)
shortcut for (defmethod mwrite-object (...))
object.lisp (file)
x86.lisp (file)
x86.lisp (file)
x86.lisp (file)
x86.lisp (file)
x86.lisp (file)
x86.lisp (file)
x86.lisp (file)
x86.lisp (file)
struct.lisp (file)
ffi.lisp (file)
ffi.lisp (file)
box.lisp (file)
box.lisp (file)
ffi.lisp (file)
defs.lisp (file)
Bind PTR to N-WORDS words of raw memory while executing BODY. Raw memory is automatically deallocated when BODY terminates.
defs.lisp (file)
syntactic sugar for multiple calls to mread. Last name in MORE-VARS will be bound to the new value of INDEX
box.lisp (file)
ffi.lisp (file)
Next: Exported functions, Previous: Exported macros, Up: Exported definitions [Contents][Index]
ffi-late.lisp (file)
ffi-late.lisp (file)
ffi-late.lisp (file)
Next: Exported generic functions, Previous: Exported compiler macros, Up: Exported definitions [Contents][Index]
dump the contents of raw memory. useful for debugging
unboxed.lisp (file)
lang.lisp (file)
b+tree.lisp (file)
os.lisp (file)
Print the things to a string, the convert the string into a symbol interned in current package. Return the symbol
lang.lisp (file)
lang.lisp (file)
x86.lisp (file)
Allocate N-BYTES of raw memory and return raw pointer to it.
The obtained memory must be freed manually: call FFI-MEM-FREE on it when no longer needed.
ffi.lisp (file)
Deallocate a block of raw memory previously obtained with FFI-MEM-ALLOC.
ffi.lisp (file)
ffi.lisp (file)
ffi.lisp (file)
swap-bytes.lisp (file)
lang.lisp (file)
lang.lisp (file)
lang.lisp (file)
lang.lisp (file)
lang.lisp (file)
lang.lisp (file)
Return HYPERLUMINAL-MEM ABI version, in the form ’(major minor patch) as for example ’(0 1 0)
version.lisp (file)
Return HYPERLUMINAL-MEM version, in the form ’(major minor patch) as for example ’(0 4 0)
version.lisp (file)
Allocate N-BYTES of raw memory and return raw pointer to it.
The obtained memory must be freed manually: call MFREE on it when no longer needed.
ffi-late.lisp (file)
Allocate N-WORDS words of raw memory and return raw pointer to it. Usually more handy than MALLOC since almost all Hyperluminal-MEM functions count and expect memory lengths in words, not in bytes.
ffi-late.lisp (file)
ffi-late.lisp (file)
ffi-late.lisp (file)
Deallocate a block of raw memory previously obtained with MALLOC or MALLOC-WORDS.
ffi-late.lisp (file)
Try to read an unboxed value (boolean, unbound slot, character or mem-int)
from memory store (on 64 bit architectures, also single-floats are unboxed)
and return it.
If memory contains a pointer or a boxed value, return their value and fulltag as multiple values.
unboxed.lisp (file)
Read a value (boxed, unboxed or object) from the memory starting at (PTR+INDEX).
Return multiple values:
1) the value
2) the INDEX pointing to immediately after the value just read
box.lisp (file)
magic.lisp (file)
loop on specified object’s slots and call (mread) on each.
object.lisp (file)
unboxed.lisp (file)
Try to write an unboxed value to memory store. Supported types are:
boolean, unbound slots, character and medium-size integers
(on 64bit architectures can also write single-floats).
Return T on success, or NIL if VALUE is a pointer or must be boxed.
unboxed.lisp (file)
Compute and return the number of CPU words needed to store VALUE.
If VALUE can be stored unboxed, returns 1. Otherwise forwards the call
to MSIZE-BOX or, for user-defined types, to MSIZE-OBJECT.
Does NOT round up the returned value to a multiple of +MEM-BOX/MIN-WORDS+
box.lisp (file)
loop on specified object’s slots and call (msize) on each.
object.lisp (file)
Write a value (boxed, unboxed or object) into the memory starting at (PTR+INDEX).
Return the INDEX pointing to immediately after the value just written.
WARNING: enough memory must be already allocated at (PTR+INDEX) !!!
box.lisp (file)
magic.lisp (file)
object.lisp (file)
loop on specified object’s slots and call (mwrite-slot) on each.
object.lisp (file)
object.lisp (file)
unboxed.lisp (file)
ffi-late.lisp (file)
ffi.lisp (file)
lang.lisp (file)
os.lisp (file)
os.lisp (file)
os.lisp (file)
os.lisp (file)
os.lisp (file)
os.lisp (file)
os.lisp (file)
os.lisp (file)
compiler.lisp (file)
compiler.lisp (file)
Print the things to a string and return it
lang.lisp (file)
swap-bytes.lisp (file)
swap-bytes.lisp (file)
swap-bytes.lisp (file)
Next: Exported structures, Previous: Exported functions, Up: Exported definitions [Contents][Index]
Deserialize an object of type TYPE by reading it from the memory starting at (+ PTR INDEX).
Assumes OBJECT header was already read.
The available memory ends immediately before (+ PTR END-INDEX).
struct.lisp (file)
object/tstack.lisp (file)
object/tcell.lisp (file)
object/ghash-table.lisp (file)
object/ghash-table.lisp (file)
object/gmap.lisp (file)
object/gmap.lisp (file)
Compute and return the number of memory words needed to serialize OBJECT, not including its header
struct.lisp (file)
object/tstack.lisp (file)
object/tcell.lisp (file)
object/ghash-table.lisp (file)
object/gmap.lisp (file)
Serialize OBJECT by writing it into the memory starting at (+ PTR INDEX).
Assumes OBJECT header was already written.
The available memory ends immediately before (+ PTR END-INDEX).
struct.lisp (file)
object/tstack.lisp (file)
object/tcell.lisp (file)
object/ghash-table.lisp (file)
object/gmap.lisp (file)
Next: Exported types, Previous: Exported generic functions, Up: Exported definitions [Contents][Index]
b+tree.lisp (file)
structure-object (structure)
(or null hyperluminal-mem-tree::b+node)
b+tree-root (function)
(setf b+tree-root) (function)
hyperluminal-mem-tree::b+size
0
b+tree-depth (function)
(setf b+tree-depth) (function)
Previous: Exported structures, Up: Exported definitions [Contents][Index]
compiler.lisp (file)
compiler.lisp (file)
os.lisp (file)
ffi.lisp (file)
defs.lisp (file)
Type for offsets and sizes of serialized data. It is in units of a mem-word, i.e. 1 means one mem-word.
unboxed.lisp (file)
native-mem.lisp (file)
Previous: Exported definitions, Up: Definitions [Contents][Index]
Next: Internal special variables, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
native-mem.lisp (file)
native-mem.lisp (file)
native-mem.lisp (file)
native-mem.lisp (file)
native-mem.lisp (file)
defs.lisp (file)
compiler.lisp (file)
defs.lisp (file)
defs.lisp (file)
defs.lisp (file)
1+ mask of the low bits that are always ZERO in the representation of a FIXNUM
compiler.lisp (file)
defs.lisp (file)
defs.lisp (file)
box/hash-table.lisp (file)
version.lisp (file)
version.lisp (file)
native-mem.lisp (file)
native-mem.lisp (file)
Maximum number of CPU words in a mem-bignum.
constants.lisp (file)
box is a N-dimensional array
constants.lisp (file)
box is an ASCII string
constants.lisp (file)
box is a bignum
constants.lisp (file)
box is a bit-vector, i.e. a (vector bit)
constants.lisp (file)
box is a complex of double-floats
constants.lisp (file)
box is a complex of rationals
constants.lisp (file)
box is a complex of single-floats
constants.lisp (file)
box is a double-float
constants.lisp (file)
constants.lisp (file)
box is a hash-table
constants.lisp (file)
boxed values have a 1 CPU-word header
constants.lisp (file)
constants.lisp (file)
box is a cons or list
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
boxed values are allocated
in multiples of 4 CPU-words. This value must be a power of two.
constants.lisp (file)
box is a pathname
constants.lisp (file)
box is a ratio
constants.lisp (file)
box is a single-float
constants.lisp (file)
default string format is UTF-8
constants.lisp (file)
box is a string, i.e. a (vector character)
constants.lisp (file)
object is a symbol or keyword
constants.lisp (file)
box is unallocated
constants.lisp (file)
box is a 1-dimensional array, i.e. a vector
constants.lisp (file)
constants.lisp (file)
native-mem.lisp (file)
native-mem.lisp (file)
constants.lisp (file)
constants.lisp (file)
native-mem.lisp (file)
native-mem.lisp (file)
native-mem.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
type tag for user-defined objects or structs
constants.lisp (file)
constants.lisp (file)
persistent representation of the package COMMON-LISP
symbols.lisp (file)
persistent representation of the package COMMON-LISP-USER
symbols.lisp (file)
persistent representation of the package KEYWORD
symbols.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
native-mem.lisp (file)
constants.lisp (file)
constants.lisp (file)
persistent representation of NIL
constants.lisp (file)
persistent representation of T
constants.lisp (file)
persistent representation of unbound slot
constants.lisp (file)
first value available for user-defined symbols
symbols.lisp (file)
first value used by predefined symbols
symbols.lisp (file)
last value used for predefined symbols
symbols.lisp (file)
constants.lisp (file)
boxed value
constants.lisp (file)
unboxed character
constants.lisp (file)
unboxed double-float
constants.lisp (file)
unboxed mem-int i.e. small integer. Special case
constants.lisp (file)
constants.lisp (file)
unboxed, negative ratio. must be (1+ +mem-tag/ratio+)
constants.lisp (file)
alias for +MEM-TAG/REF+
constants.lisp (file)
unboxed, unsigned ratio. must be even.
constants.lisp (file)
unboxed reference to symbol, keyword, package, class...
constants.lisp (file)
unboxed single-float
constants.lisp (file)
constants.lisp (file)
alias for +MEM-TAG/REF+
constants.lisp (file)
unallocated memory
constants.lisp (file)
unboxed.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
native-mem.lisp (file)
native-mem.lisp (file)
endianity.lisp (file)
endianity.lisp (file)
endianity.lisp (file)
constants.lisp (file)
native-mem.lisp (file)
native-mem.lisp (file)
native-mem.lisp (file)
native-mem.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
constants.lisp (file)
box/complex.lisp (file)
box/complex.lisp (file)
box/float.lisp (file)
box/float.lisp (file)
defs.lisp (file)
defs.lisp (file)
defs.lisp (file)
defs.lisp (file)
Number of low bits that are always ZERO in the representation of a FIXNUM
compiler.lisp (file)
defs.lisp (file)
defs.lisp (file)
defs.lisp (file)
defs.lisp (file)
b+node.lisp (file)
Next: Internal symbol macros, Previous: Internal constants, Up: Internal definitions [Contents][Index]
boxed.lisp (file)
boxed.lisp (file)
boxed.lisp (file)
Next: Internal macros, Previous: Internal special variables, Up: Internal definitions [Contents][Index]
symbols.lisp (file)
stmx.util::+empty-tcell+
symbols.lisp (file)
stmx:+unbound-tvar+
Next: Internal compiler macros, Previous: Internal symbol macros, Up: Internal definitions [Contents][Index]
Warning: evaluates VECTOR multiple times
box/bit-vector.lisp (file)
Warning: evaluates VECTOR multiple times
box/bit-vector.lisp (file)
Warning: evaluates VECTOR multiple times. updates BYTE
box/bit-vector.lisp (file)
Warning: evaluates VECTOR multiple times.
box/bit-vector.lisp (file)
unicode.lisp (file)
unicode.lisp (file)
unicode.lisp (file)
unicode.lisp (file)
box/array.lisp (file)
box/array.lisp (file)
box/array.lisp (file)
box/vector.lisp (file)
box/vector.lisp (file)
box/vector.lisp (file)
native-mem.lisp (file)
native-mem.lisp (file)
Wrapper for (CFFI-SYS:%FOREIGN-TYPE-SIZE), interprets :SFLOAT :DFLOAT :BYTE AND :WORD
defs.lisp (file)
Warning: this macro expands multiple references to PTR and END-INDEX
box.lisp (file)
Warning: evaluates PTR, INDEX and VECTOR multiple times. Updates INDEX.
box/bit-vector.lisp (file)
unboxed.lisp (file)
box/array.lisp (file)
box/vector.lisp (file)
unboxed.lisp (file)
unboxed.lisp (file)
unboxed.lisp (file)
unboxed.lisp (file)
unboxed.lisp (file)
unboxed.lisp (file)
boxed.lisp (file)
box.lisp (file)
box.lisp (file)
box.lisp (file)
box.lisp (file)
box.lisp (file)
unboxed.lisp (file)
object.lisp (file)
object.lisp (file)
shortcut for (defmethod mread-object (...))
struct.lisp (file)
shortcut for (decl-msize-struct ...) (decl-mwrite-struct ...) (decl-mread-struct ...)
struct.lisp (file)
shortcut for (defmethod msize-object (...))
struct.lisp (file)
shortcut for (defmethod mwrite-object (...))
struct.lisp (file)
x86.lisp (file)
x86.lisp (file)
x86.lisp (file)
x86.lisp (file)
x86.lisp (file)
boxed.lisp (file)
compiler.lisp (file)
mem.lisp (file)
mem.lisp (file)
mem.lisp (file)
mem.lisp (file)
Warning: returns no values
mem.lisp (file)
Warning: returns no values
mem.lisp (file)
x86.lisp (file)
unboxed.lisp (file)
endianity.lisp (file)
constants.lisp (file)
int.lisp (file)
Used only by MREAD-MAGIC.
native-mem.lisp (file)
(setf mget-byte) (setf expander)
native-mem.lisp (file)
mget-byte (macro)
mset-byte (macro)
unboxed.lisp (file)
unboxed.lisp (file)
unboxed.lisp (file)
mem.lisp (file)
mem.lisp (file)
mem.lisp (file)
(setf mget-word) (setf expander)
mem.lisp (file)
(setf mget-word/native-endianity) (setf expander)
mem.lisp (file)
mget-word/native-endianity (macro)
mset-word/native-endianity (macro)
Read an object slot previously written WITHOUT its name. Note: slot-name will be evaluated - use ’foo, NOT foo Note: updates INDEX
object.lisp (file)
object.lisp (file)
Used only by MWRITE-MAGIC, and %DETECT-ENDIANITY, !MEMSET-BYTES and !MEMCPY-BYTES. Warning: evaluates VALUE before the other arguments!
native-mem.lisp (file)
(setf mget-byte) (setf expander)
unboxed.lisp (file)
unboxed.lisp (file)
unboxed.lisp (file)
mem.lisp (file)
mem.lisp (file)
Warning: evaluates VALUE before the other arguments!
mem.lisp (file)
(setf mget-word) (setf expander)
Warning: evaluates VALUE before the other arguments!
mem.lisp (file)
(setf mget-word/native-endianity) (setf expander)
Wrapper for (%MSIZEOF), computes (CFFI:%FOREIGN-TYPE-SIZE) at compile time whenever possible
defs.lisp (file)
Warning: this macro expands multiple references to FUNC, ARG1 and MORE-ARGS
box.lisp (file)
int.lisp (file)
mem.lisp (file)
object.lisp (file)
unboxed.lisp (file)
x86.lisp (file)
Next: Internal functions, Previous: Internal macros, Up: Internal definitions [Contents][Index]
int.lisp (file)
int.lisp (file)
Next: Internal generic functions, Previous: Internal compiler macros, Up: Internal definitions [Contents][Index]
unboxed.lisp (file)
ffi-late.lisp (file)
unboxed.lisp (file)
ffi-late.lisp (file)
ffi-late.lisp (file)
Used only for debugging.
box.lisp (file)
Used only for debugging.
box.lisp (file)
ffi-late.lisp (file)
b+tree.lisp (file)
Return the number of words needed to store bignum N in memory, not including BOX header nor the N-WORDS prefix.
box/bignum.lisp (file)
Convert Unicode codepoint to a character
unicode.lisp (file)
unicode.lisp (file)
unicode.lisp (file)
native-mem.lisp (file)
native-mem.lisp (file)
native-mem.lisp (file)
endianity.lisp (file)
native-mem.lisp (file)
constants.lisp (file)
Read (END-START) single-byte characters from the memory starting at (PTR+INDEX)
and write them into RESULT-STRING. Return RESULT-STRING and number of words
actually read as multiple values.
ABI: characters are read from memory using the compact, single-byte representation. For this reason only codes in the range 0 ... +most-positive-byte+ can be read (typically 0 ... 255)
box/string-ascii.lisp (file)
box/bignum.lisp (file)
box/bit-vector.lisp (file)
Read a boxed value from the memory starting at (PTR+INDEX) and return it. Return (1+ the offset of last word actually read) as additional value. Skips over BOX header.
boxed.lisp (file)
Read a negative bignum
box/bignum.lisp (file)
Read a package from the memory starting at (PTR+INDEX).
Return the package and INDEX pointing to immediately after words read.
ABI: package is stored as package reference if possible, otherwise as package name.
box/symbol.lisp (file)
Read an unsigned bignum
box/bignum.lisp (file)
box/string-utf-8.lisp (file)
Write the first N-CHARS single-byte characters of STRING into the memory starting at (PTR+INDEX). Return T.
box/string-ascii.lisp (file)
box/bignum.lisp (file)
box/bignum.lisp (file)
Write package PKG into the memory starting at (PTR+INDEX).
Return INDEX pointing to immediately after written words.
ABI: package is stored as package reference if possible, otherwise as package name.
box/symbol.lisp (file)
Write characters from string STRING to the memory starting at (PTR+INDEX).
Return the number of words actually written.
ABI: characters will be stored using UTF-8 encoding.
box/string-utf-8.lisp (file)
Return the number of words needed to store package PKG in mmap memory.
box/symbol.lisp (file)
box/symbol.lisp (file)
Return the expected length, in bytes, of a UTF-8 multi-byte sequence
given its first byte. Return 0 if BYTE is not a valid first byte for UTF-8 sequences
unicode.lisp (file)
unicode.lisp (file)
unicode.lisp (file)
unicode.lisp (file)
box.lisp (file)
box.lisp (file)
b+leaf.lisp (file)
b+leaf.lisp (file)
b+leaf.lisp (file)
b+node.lisp (file)
b+node.lisp (file)
b+node.lisp (file)
b+node.lisp (file)
b+node.lisp (file)
b+node.lisp (file)
b+node.lisp (file)
b+node.lisp (file)
b+node.lisp (file)
b+node.lisp (file)
b+tree.lisp (file)
b+tree.lisp (file)
b+tree.lisp (file)
b+tree.lisp (file)
find the largest integer in range LO...(1- HI) that satisfies PRED. Assumes that (funcall PRED LOw) = T and (funcall PRED HIGH) = NIL.
native-mem.lisp (file)
box.lisp (file)
box.lisp (file)
native-mem.lisp (file)
struct.lisp (file)
x86.lisp (file)
struct.lisp (file)
Return a triplet (values index scale offset) suitable for MOV addressing modes
x86.lisp (file)
Choose the serialized format ABI between little endian or big endian.
By default, Hyperluminal-MEM uses little-endian ABI.
It is possible to compile Hyperluminal-MEM for a different endianity by adding
an appropriate entry in the global variable ‘*FEATURES*‘ **before** compiling
and loading Hyperluminal-MEM.
To force native endianity:
(pushnew :hyperluminal-mem/endianity/native *features*)
To force non-native endianity:
(pushnew :hyperluminal-mem/endianity/inverted *features*)
To force little-endian ABI:
(pushnew :hyperluminal-mem/endianity/little *features*)
To force big-endian ABI:
(pushnew :hyperluminal-mem/endianity/big *features*)
endianity.lisp (file)
defs.lisp (file)
Choose the file format and ABI between 32 or 64 bit - and possibly more in the future.
By default, Hyperluminal-MEM file format and ABI is autodetected to match
Lisp idea of CFFI-SYS pointers:
* 32 bit when CFFI-SYS pointers are 32 bit,
* 64 bit when CFFI-SYS pointers are 64 bit,
* and so on...
In other words, ‘mem-word‘ is normally autodetected to match the width
of underlying CPU registers (exposed through CFFI-SYS foreign-type :pointer)
and ‘+msizeof-word+‘ is set accordingly.
It is possible to override such autodetection by adding an appropriate entry
in the global variable ‘*FEATURES*‘ **before** compiling and loading Hyperluminal-MEM.
Doing so disables autodetection and either tells Hyperluminal-MEM the desired size
of ‘mem-word‘, in alternative, the CFFI-SYS type it should use for ‘mem-word‘.
For example, to force 64 bit (= 8 bytes) file format and ABI even on 32-bit systems,
execute the following form before compiling and loading Hyperluminal-MEM:
(pushnew :hyperluminal-mem/word-size/8 *features*)
on the other hand, to force 32 bit (= 4 bytes) file format and ABI,
execute the form
(pushnew :hyperluminal-mem/word-size/4 *features*)
in both cases, the Hyperluminal-MEM internal function (choose-word-type)
will recognize the override and define ‘mem-word‘ and ‘+msizeof-word+‘
to match a CFFI-SYS unsigned integer type having the specified size
among the following candidates:
:unsigned-char
:unsigned-short
:unsigned-int
:unsigned-long
:unsigned-long-long
In case it does not find a type with the requested size, it will raise an error.
Forcing the same value that would be autodetected is fine and harmless.
Also, the chosen type must be 32 bits wide or more, but there is no upper limit:
Hyperluminal-MEM is designed to automatically support 64 bits systems,
128 bit systems, and anything else that will exist in the future.
It even supports ’unusual’ configurations where the size of ‘mem-word‘
is not a power of two (ever heard of 36-bit CPUs?).
For the far future (which arrives surprisingly quickly in software)
where CFFI-SYS will know about further unsigned integer types,
it is also possible to explicitly specify the type to use
by executing a form like
(pushnew :hyperluminal-mem/word-type/<SOME-CFFI-SYS-TYPE> *features*)
as for example:
(pushnew :hyperluminal-mem/word-type/unsigned-long-long *features*)
Hyperluminal-MEM will honour such override, intern the type name
to convert it to a keyword, use it as the definition of ‘mem-word‘,
and derive ‘+msizeof-word+‘ from it.
lang.lisp (file)
Return a sorted list containing all external symbols of a package.
symbols.lisp (file)
magic.lisp (file)
b+tree.lisp (file)
mvar.lisp (file)
float.lisp (file)
defs.lisp (file)
object.lisp (file)
object.lisp (file)
x86.lisp (file)
lang.lisp (file)
lang.lisp (file)
lang.lisp (file)
find the largest positive integer that satisfies PRED.
native-mem.lisp (file)
b+node.lisp (file)
b+node.lisp (file)
boxed.lisp (file)
defs.lisp (file)
unicode.lisp (file)
unicode.lisp (file)
Return T if VALUE can be written to mmap memory as an unboxed value.
unboxed.lisp (file)
float.lisp (file)
struct.lisp (file)
mvar.lisp (file)
float.lisp (file)
Detect the boxed-type of VALUE. Returns one of the constants +mem-box/...+
boxed.lisp (file)
unboxed.lisp (file)
unboxed.lisp (file)
constants.lisp (file)
constants.lisp (file)
unboxed.lisp (file)
box.lisp (file)
box.lisp (file)
unboxed.lisp (file)
unboxed.lisp (file)
unboxed.lisp (file)
unboxed.lisp (file)
unboxed.lisp (file)
unboxed.lisp (file)
unboxed.lisp (file)
(setf mget-character) (setf expander)
unboxed.lisp (file)
mget-character (function)
mset-character (function)
float.lisp (file)
Return the mem-int stored at (PTR+INDEX)
int.lisp (file)
(setf mget-int) (setf expander)
unboxed.lisp (file)
(setf mget-ratio) (setf expander)
unboxed.lisp (file)
mget-ratio (function)
mset-ratio (function)
float.lisp (file)
unboxed.lisp (file)
(setf mget-symbol-ref) (setf expander)
unboxed.lisp (file)
mget-symbol-ref (function)
mset-symbol-ref (function)
unboxed.lisp (file)
unboxed.lisp (file)
Return the two’s complement value of mem-int stored at (PTR+INDEX), ignoring any sign bit
int.lisp (file)
unboxed.lisp (file)
Read a boxed value from the memory starting at (PTR+INDEX).
Return the value and (1+ the offset of last word actually read) as multiple values.
boxed.lisp (file)
Read an array from the memory starting at (PTR+INDEX) and return it.
Also returns number of words actually read as additional value.
Assumes BOX header was already read.
box/array.lisp (file)
Read a boxed ascii-string from the memory starting at (PTR+INDEX) and return it.
Also return number of words actually read as addition value.
Assumes BOX header was already read.
box/string-ascii.lisp (file)
Read a bignum from the memory starting at (PTR+INDEX) and return it. Also returns the number of words actually written as additional value. Assumes the BOX header was read already.
box/bignum.lisp (file)
Read a bit-vector from the memory starting at (PTR+INDEX) and return it. Assumes BOX header was already read.
box/bit-vector.lisp (file)
Read a complex-dfloat from the memory starting at (PTR+INDEX) and return it. Assumes BOX header was already read.
box/complex.lisp (file)
Read a complex-rational from the memory starting at (PTR+INDEX) and return it. Assumes BOX header is already read.
box/complex.lisp (file)
Read a complex-sfloat from the memory starting at (PTR+INDEX) and return it. Assumes BOX header was already read.
box/complex.lisp (file)
Read a double-float from the memory starting at (PTR+INDEX) and return it. Assumes BOX header was already read.
box/float.lisp (file)
Read a hash-table from the boxed memory starting at (PTR+INDEX) and return it. Also returns as additional value INDEX pointing to immediately after read hash-table.
Assumes BOX header was already read.
box/hash-table.lisp (file)
Read from mmap area the header common to all boxed values. Return BOXED-TYPE and N-WORDS as multiple values
box.lisp (file)
Read a list from the memory starting at (PTR+INDEX) and return it.
Also returns as additional value the INDEX pointing to immediately after the list read.
Assumes BOX header was already read.
box/list.lisp (file)
Read a pathname from the memory starting at (PTR+INDEX) and return it. Assumes BOX header was already read.
box/pathname.lisp (file)
Read a ratio from the memory starting at (PTR+INDEX) and return it. Assumes BOX header is already read.
box/ratio.lisp (file)
Read a single-float from the memory starting at (PTR+INDEX) and return it. Assumes BOX header was already read.
box/float.lisp (file)
Read a string from the memory starting at (PTR+INDEX) and return it.
Also return as additional value INDEX pointing to immediately after words read.
Assumes BOX header was already read.
box/string-utf-8.lisp (file)
Read a symbol from the memory starting at (PTR+INDEX) and return it.
Return the symbol and the INDEX pointing to immediately after the words read.
Assumes BOX header is already read.
ABI: symbol is assumed to be stored as package followed by symbol name. To read symbol stored as unboxed reference, use MGET-UNBOXED or MREAD.
box/symbol.lisp (file)
boxed.lisp (file)
Read a vector from the memory starting at (PTR+INDEX) and return it.
Also returns number of words actually read as additional value.
Assumes BOX header was already read.
box/vector.lisp (file)
Read a boxed value from the memory starting at (PTR+INDEX).
Return the value and (1+ the offset of last word actually read) as multiple values.
boxed.lisp (file)
Deserialize an object of type TYPE by reading it from the memory starting at (+ PTR INDEX).
Also deserializes OBJECT header.
The available memory ends immediately before (+ PTR END-INDEX).
struct.lisp (file)
object.lisp (file)
object/ghash-table.lisp (file)
object/gmap.lisp (file)
unboxed.lisp (file)
(setf mget-character) (setf expander)
float.lisp (file)
Write mem-int VALUE into the memory at (PTR+INDEX)
int.lisp (file)
(setf mget-int) (setf expander)
unboxed.lisp (file)
(setf mget-ratio) (setf expander)
float.lisp (file)
unboxed.lisp (file)
(setf mget-symbol-ref) (setf expander)
unboxed.lisp (file)
Return the number of words needed to store boxed VALUE in memory,
also including BOX header.
Does NOT round up the returned value to a multiple of +MEM-BOX/MIN-WORDS+
boxed.lisp (file)
Return the number of words needed to store boxed VALUE in memory,
also including BOX header.
Rounds up the returned value to a multiple of +MEM-BOX/MIN-WORDS+
boxed.lisp (file)
Return the number of words needed to store ARRAY in mmap memory, not including BOX header.
box/array.lisp (file)
Return the number of words needed to store ascii-string STRING in mmap memory, not including BOX header words.
box/string-ascii.lisp (file)
Return the number of words needed to store bignum N in memory, not including BOX header.
box/bignum.lisp (file)
Return the number of words needed to store bit-vector VALUE in mmap memory, not including BOX header.
box/bit-vector.lisp (file)
Return the number of words needed to store a complex-dfloat VALUE in mmap memory. Does not count the space needed by BOX header.
box/complex.lisp (file)
Return the number of words needed to store a complex-rational VALUE in mmap memory. Does not count the space needed by BOX header.
box/complex.lisp (file)
Return the number of words needed to store a complex-sfloat VALUE in mmap memory. Does not count the space needed by BOX header.
box/complex.lisp (file)
Return the number of words needed to store a BOX containing double-float VALUE in memory.
box/float.lisp (file)
Return the number of words needed to store hash-table HTABLE in mmap memory, not including BOX header.
box/hash-table.lisp (file)
Return the number of words needed to store LIST in mmap memory, not including BOX header.
box/list.lisp (file)
Return the number of words needed to store pathname PATH in mmap memory, not including BOX header.
box/pathname.lisp (file)
Return the number of words needed to store a BOX containing ratio VALUE in mmap memory. Does not count the space needed by BOX header.
box/ratio.lisp (file)
Return the number of words needed to store single-float VALUE in memory, not including BOX header.
box/float.lisp (file)
Return the number of words needed to store STRING in memory, not including BOX header.
box/string-utf-8.lisp (file)
Return the number of words needed to store symbol SYM in mmap memory. Does not count the space needed by BOX header.
box/symbol.lisp (file)
boxed.lisp (file)
Return the number of words needed to store VECTOR in mmap memory, not including BOX header.
box/vector.lisp (file)
Compute and return the number of memory words needed to serialize OBJECT, including its header
struct.lisp (file)
Compute and return the number of CPU words needed to store VALUE.
If VALUE can be stored unboxed, returns 1. Otherwise forwards the call
to MSIZE-BOX or, for user-defined types, to MSIZE-OBJECT.
Also rounds up the returned value to a multiple of +MEM-BOX/MIN-WORDS+
boxed.lisp (file)
mvar.lisp (file)
mvar.lisp (file)
mvar.lisp (file)
mvar.lisp (file)
mvar.lisp (file)
mvar.lisp (file)
mvar.lisp (file)
mvar.lisp (file)
mvar.lisp (file)
mvar.lisp (file)
Write a boxed value into the mmap memory starting at (PTR+INDEX).
Also writes BOX header. Returns INDEX pointing to immediately after written value.
boxed.lisp (file)
Write ARRAY into the memory starting at (PTR+INDEX).
Return number of words actually written.
Assumes BOX header is already written, and that enough memory is available at (PTR+INDEX).
box/array.lisp (file)
Write STRING into the memory starting at (+ PTR INDEX)
and return the number of words written. Assumes BOX header is already written.
ABI: writes characters count as mem-int, followed by array of characters each occupying one byte
box/string-ascii.lisp (file)
Write bignum N into memory starting at (PTR+INDEX).
Assumes BOX header is already written.
Return INDEX pointing to immediately after written value.
ABI: writes mem-int N-WORDS, i.e. (%bignum-words N)
(if bignum is negative, writes (lognot N-WORDS) instead)
followed by an array of words containing N in two’s complement.
box/bignum.lisp (file)
Write bit-vector VECTOR into the memory starting at (+ PTR INDEX)
and return the number of words written. Assumes BOX header is already written.
ABI: writes element count as mem-int, followed by sequence of bits
box/bit-vector.lisp (file)
Reuse the memory starting at (PTR+INDEX) and write complex-dfloat VALUE into it.
Assumes BOX header is already written.
ABI: Writes real part, then imaginary part.
box/complex.lisp (file)
Write complex-rational VALUE into the memory starting at (PTR+INDEX).
Assumes BOX header is already written.
ABI: Writes real part, then imaginary part.
box/complex.lisp (file)
Reuse the memory starting at (PTR+INDEX) and write complex-sfloat VALUE into it.
Assumes BOX header is already written.
ABI: Writes real part, then imaginary part.
box/complex.lisp (file)
Write double-float VALUE into the memory starting at (+ PTR INDEX).
Assumes BOX header is already written.
ABI: double-float is stored raw (usually means IEEE format)
box/float.lisp (file)
Write hash-table HTABLE into the memory starting at (PTR+INDEX).
Return INDEX pointing to immediately after written hash-table.
Assumes BOX header is already written, and that enough memory is available at (PTR+INDEX).
box/hash-table.lisp (file)
Write to mmap area the header common to all boxed values. Return INDEX pointing to box payload
box.lisp (file)
Write LIST into the memory starting at (PTR+INDEX).
Return INDEX pointing to immediately after written list.
Assumes BOX header is already written, and that enough memory is available at (PTR+INDEX).
box/list.lisp (file)
write pathname PATH into the memory starting at (PTR+INDEX). Assumes BOX header is already written.
box/pathname.lisp (file)
Write ratio VALUE into the memory starting at (PTR+INDEX).
Assumes BOX header is already written.
ABI: Writes numerator, then denominator.
box/ratio.lisp (file)
Write single-float VALUE into the memory starting at (+ PTR INDEX).
Assumes BOX header is already written.
ABI: single-float is stored raw (usually means IEEE format)
box/float.lisp (file)
write STRING into the memory starting at (+ PTR INDEX).
Assumes BOX header is already written.
ABI: writes string length as mem-int, followed by packed array of UTF-8 encoded characters
box/string-utf-8.lisp (file)
Write symbol SYM into the memory starting at (PTR+INDEX).
Return INDEX pointing to immediately after words written.
ABI: symbol is stored as package followed by symbol name.
To store symbol as unboxed reference, use MSET-UNBOXED or MWRITE.
box/symbol.lisp (file)
boxed.lisp (file)
Write VECTOR into the memory starting at (PTR+INDEX).
Return number of words actually written.
Assumes BOX header is already written, and that enough memory is available at (PTR+INDEX).
box/vector.lisp (file)
Serialize OBJECT by writing it into the memory starting at (+ PTR INDEX).
Also serializes OBJECT header.
The available memory ends immediately before (+ PTR END-INDEX).
struct.lisp (file)
b+node.lisp (file)
os.lisp (file)
os.lisp (file)
defs.lisp (file)
struct.lisp (file)
b+node.lisp (file)
Round up N-WORDS to a multiple of +MEM-BOX/MIN-WORDS+
boxed.lisp (file)
float.lisp (file)
defs.lisp (file)
box.lisp (file)
magic.lisp (file)
symbols.lisp (file)
test-b+tree.lisp (file)
test-b+tree.lisp (file)
test-b+tree.lisp (file)
magic.lisp (file)
Remove the method (mlist-class-direct-slots) specialized for CLASS-NAME
object.lisp (file)
Remove the method (mlist-class-slots) specialized for CLASS-NAME
object.lisp (file)
Remove the method (mread-object) specialized for CLASS-NAME
object.lisp (file)
Remove the method (msize-object) specialized for CLASS-NAME
object.lisp (file)
Remove the method (mwrite-object) specialized for CLASS-NAME
object.lisp (file)
If LIST contains a single element which is itself a list, return that element. Otherwise return the whole LIST
lang.lisp (file)
Next: Internal conditions, Previous: Internal functions, Up: Internal definitions [Contents][Index]
List the direct slots of a class that must be serialized/deserialized.
Used by (msize-list-class-slots class) to reflectively obtain
the serializable slots list from a class.
Must return a list of either slot names or closer-mop:slot-definition.
This function is relatively slow, and it is expected to be invoked
only at compile-time.
Default implementation calls (closer-mop:class-direct-slots class), i.e. it assumes all slots must be serialized/deserialized.
object.lisp (file)
List all the serializable slots of a class.
Must return a list of either slot names or closer-mop:slot-definition.
If you specialize this generic function, remember to also list
all superclasses’ slots that must be serialized.
Invoked by the macros (decl-msize-class) (decl-mwrite-class) and (decl-mread-class)
to obtain the slots of a class that must be serialized/deserialized
and generate the methods (msize-object) (mwrite-object) and (mread-object).
Default implementation repeatedly calls (mlist-class-direct-slots)
on all the class’ superclasses and collects the result.
This function is relatively slow, and it is normally invoked
only at compile-time.
May be useful also at runtime if one chooses to use the slow, reflective functions
(msize-object-slots) (mwrite-object-slots) and (mread-object-slots).
object.lisp (file)
object/tstack.lisp (file)
object/tcell.lisp (file)
Next: Internal structures, Previous: Internal generic functions, Up: Internal definitions [Contents][Index]
native-mem.lisp (file)
simple-error (condition)
Next: Internal types, Previous: Internal conditions, Up: Internal definitions [Contents][Index]
a memory-mapped transactional variable (mvar) is the smallest unit of persistent,
transactional memory. it contains a single value that can be read or written during a transaction
using ($-slot var) and (setf ($-slot var) value).
The value of each mvar modified during a transaction is written to memory-mapped persistent store
while committing.
mvars are seldom used directly, since persistent transactional objects (mobjs)
wrap them with a more convenient interface: you can read and write normally
the slots of a persistent transactional object (with slot-value, accessors ...),
and behind the scenes the slots will be stored in mvars.
mvar.lisp (file)
tvar (structure)
hyperluminal-mem:mem-size
0
mvar-slot-address (function)
(setf mvar-slot-address) (function)
hyperluminal-mem:mem-size
0
mvar-box-address (function)
(setf mvar-box-address) (function)
hyperluminal-mem:mem-size
0
mvar-box-n-words (function)
(setf mvar-box-n-words) (function)
mvar-parent-obj (function)
(setf mvar-parent-obj) (function)
Previous: Internal structures, Up: Internal definitions [Contents][Index]
box/vector.lisp (file)
box/string-ascii.lisp (file)
box/string-ascii.lisp (file)
b+node.lisp (file)
b+node.lisp (file)
b+node.lisp (file)
native-mem.lisp (file)
box/complex.lisp (file)
box/complex.lisp (file)
box/complex.lisp (file)
A faster implementation of foreign pointers (sap).
Implementation note: for SBCL, FAST-SAP is identical to normal CFFI-SYS:FOREIGN-POINTER
i.e. they are SB-SYS:SYSTEM-AREA-POINTER
compiler.lisp (file)
mem.lisp (file)
Valid range for boxed-type tags
unboxed.lisp (file)
unboxed.lisp (file)
int.lisp (file)
Valid range for boxed-type or object tags
unboxed.lisp (file)
unboxed.lisp (file)
int.lisp (file)
Union of all types (except ratio) that can be stored as unboxed in memory store
unboxed.lisp (file)
Union of all types (except ratio and symbol) that can be stored as unboxed in memory store
unboxed.lisp (file)
unboxed.lisp (file)
defs.lisp (file)
b+node.lisp (file)
unicode.lisp (file)
compiler.lisp (file)
unicode.lisp (file)
x86.lisp (file)
x86.lisp (file)
Previous: Definitions, Up: Top [Contents][Index]
| • Concept index: | ||
| • Function index: | ||
| • Variable index: | ||
| • Data type index: |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
| Jump to: | F H L M O |
|---|
| Jump to: | F H L M O |
|---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
| Jump to: | !
%
(
A B C D E F G H I M N O P R S T U W X |
|---|