From 106c5b95d1d981cce3ac86de6511f38aaafd04ea Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Daniel=20Kochma=C5=84ski?= Date: Thu, 3 Mar 2016 22:43:05 +0100 Subject: [PATCH] new-doc: dev: Manipulating objects --- src/doc/new-doc/developer-guide/objects.txi | 230 ++++ src/doc/new-doc/figures/immediate-types.png | Bin 0 -> 8909 bytes src/doc/new-doc/figures/immediate-types.svg | 1216 +++++++++++++++++++ src/doc/new-doc/standards/overview.txi | 10 +- 4 files changed, 1449 insertions(+), 7 deletions(-) create mode 100644 src/doc/new-doc/figures/immediate-types.png create mode 100644 src/doc/new-doc/figures/immediate-types.svg diff --git a/src/doc/new-doc/developer-guide/objects.txi b/src/doc/new-doc/developer-guide/objects.txi index f7c3f759c..1ee9057c2 100644 --- a/src/doc/new-doc/developer-guide/objects.txi +++ b/src/doc/new-doc/developer-guide/objects.txi @@ -1,7 +1,237 @@ @node Manipulating Lisp objects @section Manipulating Lisp objects + +If you want to extend, fix or simply customize ECL for your own needs, +you should understand how the implementation works. + @cppindex cl_lispunion @deftp {C/C++ index} cl_lispunion cons big ratio SF DF longfloat complex symbol pack hash array vector base_string string stream random readtable pathname bytecodes bclosure cfun cfunfixed cclosure d instance process queue lock rwlock condition_variable semaphore barrier mailbox cblock foreign frame weak sse Union containing all first-class ECL types. @end deftp + +@subsection Objects representation +In ECL a lisp object is represented by a type called +@code{cl_object}. This type is a word which is long enough to host both +an integer and a pointer. The least significant bits of this word, also +called the tag bits, determine whether it is a pointer to a C structure +representing a complex object, or whether it is an immediate data, such +as a fixnum or a character. + +@float Figure,fig:immediate_types +@caption{Immediate types} +@image{figures/immediate-types,,1in} +@end float + +The topic of the immediate values and bit fiddling is nicely described +in +@url{http://www.more-magic.net/posts/internals-data-representation.html, +Peter Bex's blog} describing @url{http://www.call-cc.org/,Chicken +Scheme} internal data representation. We could borrow some ideas from it +(like improving @code{fixnum} bitness and providing more immediate +values). All changes to code related to immediate values should be +carefully @strong{benchmarked}. + +The @code{fixnums} and characters are called immediate data types, +because they require no more than the @code{cl_object} datatype to store +all information. All other ECL objects are non-immediate and they are +represented by a pointer to a cell that is allocated on the heap. Each +cell consists of several words of memory and contains all the +information related to that object. By storing data in multiples of a +word size, we make sure that the least significant bits of a pointer are +zero, which distinguishes pointers from immediate data. + +In an immediate datatype, the tag bits determine the type of the +object. In non-immediate datatypes, the first byte in the cell contains +the secondary type indicator, and distinguishes between different types +of non immediate data. The use of the remaining bytes differs for each +type of object. For instance, a cons cell consists of three words: + +@verbatim ++---------+----------+ +| CONS | | ++---------+----------+ +| car-pointer | ++--------------------+ +| cdr-pointer | ++--------------------+ +@end verbatim + +@cfindex --enable-small-cons [YES|no] + +Note, that this is on of the possible implementations of +@code{cons}. The second one (currently default) uses the immediate value +for the @code{list} and consumes two words instead of three. Such +implementation is more memory and speed efficient (according to the +comments in the source code): + +@verbatim +/* + * CONSES + * + * We implement two variants. The "small cons" type carries the type + * information in the least significant bits of the pointer. We have + * to do some pointer arithmetics to find out the CAR / CDR of the + * cons but the overall result is faster and memory efficient, only + * using two words per cons. + * + * The other scheme stores conses as three-words objects, the first + * word carrying the type information. This is kept for backward + * compatibility and also because the oldest garbage collector does + * not yet support the smaller datatype. + * + * To make code portable and independent of the representation, only + * access the objects using the common macros below (that is all + * except ECL_CONS_PTR or ECL_PTR_CONS). + */ +@end verbatim + +@cppindex cl_object +@deftp {@cind} cl_object +This is the type of a lisp object. For your C/C++ program, a cl_object +can be either a fixnum, a character, or a pointer to a union of +structures (See @code{cl_lispunion} in the header object.h). The actual +interpretation of that object can be guessed with the macro +@code{ecl_t_of}. + +@subsubheading Example +@exindex @code{cl_object} checking the type with @code{ecl_t_of} + +For example, if x is of type cl_object, and it is of type fixnum, we may +retrieve its value: + +@example +if (ecl_t_of(x) == t_fixnum) + printf("Integer value: %d\n", fix(x)); +@end example + +@subsubheading Example +@exindex Accessing underlying @code{cl_object} structure + +If @code{x} is of type cl_object and it does not contain an immediate +datatype, you may inspect the cell associated to the lisp object using +@code{x} as a pointer. For example: + +@example +if (ecl_t_of(x) == t_vector) + printf("Vector's dimension is: %d\n", x->dim); +@end example + +You should see the following sections and the header object.h to learn +how to use the different fields of a cl_object pointer. +@end deftp + +@deftp {@cind} cl_type +Enumeration type which distinguishes the different types of lisp +objects. The most important values are: + +@cppindex t_start +@cppindex t_list +@cppindex t_character +@cppindex t_fixnum +@cppindex t_bignum +@cppindex t_ratio +@c @cppindex t_shortfloat +@cppindex t_singlefloat +@c #ifdef ECL_LONG_FLOAT +@cppindex t_longfloat +@c #endif +@cppindex t_complex +@cppindex t_symbol +@cppindex t_package +@cppindex t_hashtable +@cppindex t_array +@cppindex t_vector +@c #ifdef ECL_UNICODE +@cppindex t_string +@c #endif +@cppindex t_base_string +@cppindex t_bitvector +@cppindex t_stream +@cppindex t_random +@cppindex t_readtable +@cppindex t_pathname +@cppindex t_bytecodes +@cppindex t_bclosure +@cppindex t_cfun +@cppindex t_cfunfixed +@cppindex t_cclosure +@cppindex t_instance +@cppindex t_structure = t_instance +@c #ifdef ECL_THREADS +@cppindex t_process +@cppindex t_lock +@cppindex t_rwlock +@cppindex t_condition_variable +@cppindex t_semaphore +@cppindex t_barrier +@cppindex t_mailbox +@c #endif +@cppindex t_codeblock +@cppindex t_foreign +@cppindex t_frame +@cppindex t_weak_pointer +@c #ifdef ECL_SSE2 +@cppindex t_sse_pack +@c #endif +@cppindex t_end +@cppindex t_other +@cppindex t_contiguous – contiguous block + +@code{t_cons} @code{t_fixnum}, @code{t_character}, @code{t_bignum}, +@code{t_ratio}, @code{t_singlefloat}, @code{t_doublefloat}, +@code{t_complex}, @code{t_symbol}, @code{t_package}, @code{t_hashtable}, +@code{t_array}, @code{t_vector}, @code{t_string}, @code{t_bitvector}, +@code{t_stream}, @code{t_random}, @code{t_readtable}, @code{t_pathname}, +@code{t_bytecodes}, @code{t_cfun}, @code{t_cclosure}, @code{t_gfun}, +@code{t_instance}, @code{t_foreign} and @code{t_thread}. +@end deftp + +@cppindex ecl_t_of +@deftypefun cl_type ecl_t_of (cl_object x) +If @var{x} is a valid lisp object, @code{ecl_t_of(x)} returns an integer +denoting the type that lisp object. That integer is one of the values of +the enumeration type @code{cl_type}. +@end deftypefun + +@cppindex ECL_FIXNUMP +@cppindex ECL_CHARACTERP +@cppindex ECL_BASE_CHAR_P +@cppindex ECL_NUMBER_TYPE_P +@cppindex ECL_REAL_TYPE_P +@cppindex ECL_REAL_TYPE_P +@cppindex ECL_CONSP +@cppindex ECL_LISTP +@cppindex ECL_ATOM +@cppindex ECL_SYMBOLP +@cppindex ECL_ARRAYP +@cppindex ECL_VECTORP +@cppindex ECL_BIT_VECTOR_P +@cppindex ECL_STRINGP + +@deftypefun bool ECL_FIXNUMP (cl_object o) +@deftypefunx bool ECL_CHARACTERP (cl_object o) +@deftypefunx bool ECL_BASE_CHAR_P (cl_object o) +@deftypefunx bool ECL_NUMBER_TYPE_P (cl_object o) +@deftypefunx bool ECL_REAL_TYPE_P (cl_object o) +@deftypefunx bool ECL_CONSP (cl_object o) +@deftypefunx bool ECL_LISTP (cl_object o) +@deftypefunx bool ECL_ATOM (cl_object o) +@deftypefunx bool ECL_SYMBOLP (cl_object o) +@deftypefunx bool ECL_ARRAYP (cl_object o) +@deftypefunx bool ECL_VECTORP (cl_object o) +@deftypefunx bool ECL_BIT_VECTOR_P (cl_object o) +@deftypefunx bool ECL_STRINGP (cl_object o) + +Different macros that check whether @var{o} belongs to the specified +type. These checks have been optimized, and are preferred over several +calls to @code{ecl_t_of}. +@end deftypefun + +@deftypefun bool ECL_IMMEDIATE (cl_object o) +Tells whether @var{x} is an immediate datatype. +@end deftypefun + +@deftp {@cind} cl_objectxx +@end deftp +@subsection Constructing objects diff --git a/src/doc/new-doc/figures/immediate-types.png b/src/doc/new-doc/figures/immediate-types.png new file mode 100644 index 0000000000000000000000000000000000000000..2c7c1f3266b8e3d71ff9d2a38ca09b450a4988e4 GIT binary patch literal 8909 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 + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + Po + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + 0 + + + Pointer + Fixnum + + + + + + + + + + 1 + + + + 1 + + + Character + + + + + + + + + + 1 + + + + 0 + + + + + + + + + + + + 1 + + + + 0 + + + List + + + diff --git a/src/doc/new-doc/standards/overview.txi b/src/doc/new-doc/standards/overview.txi index 14fa3f115..d9766239e 100644 --- a/src/doc/new-doc/standards/overview.txi +++ b/src/doc/new-doc/standards/overview.txi @@ -58,11 +58,7 @@ book. @node C Reference (Overview) @subsection C Reference (Overview) @subsubsection One type for everything: @code{cl_object} -@cppindex cl_object -@deftp {@cind} cl_object -Pointer to the @code{cl_lispunion} union which represents all -first-class types defined in @ecl{}. -@end deftp +@cindex One type for everything: @code{cl_object} ECL is designed around the basic principle that Common Lisp already provides everything that a programmer could need, orienting itself @@ -107,8 +103,8 @@ Global variables or pointers that have been registered with the garbage collector. @end itemize -Further details will be provided in the section [[#ext.memory][Memory -Management]]. +For memory allocation details @xref{Memory Management}. +For object implementation details @xref{Manipulating Lisp objects}. @subsubsection Naming conventions As explained in the introduction, each of the chapters in the Common