LL first meta-model – ISA\LL\Elements\Identity

Parent

Elements

Data
Identity
Aliases None.
Information This  provides a support for Identity axiom and in particular for the Identification (). This in an architecture fully distributed and scalable.

It also provides a support for the addressing in the memory.
data
Edition
Version 1
Country None.
Language None.
Tirage 1
Dependencies None.
Inhibit all invariants False.
Scope Ideas.
Diagram

Identity Assembly

Classes
Identifier
Information
The  is identified by an Identifier. The Identifier have a set of properties allowing to retrieve it unambiguously. By default, the Identifier is connected to by a lazy relationship.

The Identifier type  is one of the most important one. It provides the features and properties expected by an Identifier () and coming from the OO Identity axiom. This in an architecture fully distributed and scalable. This features and properties are:

  • Identify an object all long its technical life cycle (in memory, over the network, on stable storage).
    This suppose to have versioning management including historical capabilities.
  • Designated it in all situations (textual link, binary address, on disk, over the network, etc.).
  • Help to scale in being both performing (thru technique like direct reference, partitioning or cursor) and small (this mean 64 bit memory foot print).
  • Help to secure in being attached to logical partitioning (organisation, universe).
  • Allows to search and retrieve an Object in an uniform way.
  • Clean: This mean not contaminated in its core by numerous peripheral information like localization or external identifiers.

The Identifier type fulfill these requirements:

  • Identify is the first feature. It is the Object id property role. While this is the final ID to identify an Object on any Node or state, it is complemented by its main Class, the one that never changes all long it's life: In other words, its Nature. The nature is also a property named Nature id. This ID is the Object id of the the object belongs to. The algorithm to manage Object id depends of the Type.
  • Versioning is supported thru the Object version id property and the New version query. The algorithm to manage Object version id also depends of the Type.
  • Designation in memory is done just by its physical address. Getting the full Identifier is a lazy treatment done thru the Identity property of the Object class. The Class object is loaded in memory and the object has a pointer to it.  A Class is a versioned object thru Edition, so its version is known.
    Designation of a stored object can be done in several ways. In short, if you have the Identifier then a direct reference to the Node operating system can be done. Ask to it to provide the object whenever it resides. If you don't have the Identifier completed, a search with available criteria can be done also to the Node operating system that will make its best effort to retrieve it.
  • Indexing and Partitioning are key factors for efficiency. Indexing is promoted to be applied for each Class and Interface, the storage being done by Nature of Objects. Identifier fields are all indexed. Other fields can be indexed thru a of the Operating System.
    Partitioning is supported over several axis. A Universe providing a complete isolation. A Zone allowing an organizational separation.  A Group giving a functional dependent partitioning capability.  It is also a of the O.S. Finally, archiving can also be seen as a form of partitioning where older objects are moved to slowest Nodes. Algorithms on allocating Object id and mostly Object version id can play a great role here.
  • While Identifier fields are available in a uniform way on every Objects, this provides a common basis to search any of them. This is the case in particular for the Business id, that can be of course composite.
Note
Kind Explanation
Text It is necessary to have a Nature for several reasons:
  • The Nature makes much more easier the object retrieval, because it gives a coarse grained partition of the object space (over other objects on a node, over nodes). This dramatically improve performance, and even makes the whole approach conceivable.
  • In order to generate an object id that doesn't collide with another one. Otherwise, it will be needed to have something like a GUID with 128 bits: doing things this way breaks the 64 bits principle. So it is rejected.
    Therefore references an object just require a 64 bit, that is to say the minimum permitted size in ISA.
  • In fact having a Nature also allows to ensure that an object will not become anything along its life. A car becoming a person for instance. This improve semantic consistency

How to handle the Nature identifier ? In particular for Objects has numerous has they are. Because the object must know of which class version it belongs to. Otherwise, it will be very difficult to manage class version to run side by side or and costly to manage migrations.

  • The ISA solution is to be both clean and efficient. To be clean, it is needed to have separated properties for all data (this consume space). To be efficient, it is needed to have the smallest memory foot print, therefore just a sbyte of 64 bits (this is quick for processing and the smallest possible).
  • 2 representations are foreseen:
    • A sbyte reference to class object. At runtime, in memory for instance, the O.S. points to the class object memory address.
    • An Identifier that is lazily loaded, containing a full identification across the Universes and their Nodes. Here the space is not a concern, on storage for instance.

The sbyte pointer to the Class is sufficient to supports versioning, because a class has an edition property (with a version).  The stable classification mechanism is supported by the Category metaclass.
Properties
Nature id: Sbyte ▣
 The Nature   id of the object. The Nature is the unchangeable metaclass to which it belongs all long its life cycle, because it is at root of Object identity (a Person will never becomes a Car).
An object can be in several classification> affected either statically or dynamically. Its nature is always part of
the classification relationship (additionally to the other occurrences).
Nature : Metaclass The Nature metaclass instance corresponding to the Nature classifier id.
Object id: Sbyte
The identifier of the Object.
Object id is a Sbyte. It is built at construction time by an algorithm defined for its Nature for persisted objects. For volatile ones, the Object id is the memory address of its Smart Pointer because it is stable at run time (and also its hash code by default).

A post is dedicated to the generation algorithms of Object id: Generation algorithms of Object id
Object : Object An instance of the Object this Identifier identify.
Object version: Natural* [0..1]

Object version is a natural positive number starting a 1. It is built by an algorithm defined for its TODO.
A volatile object doesn't have version.

A post is dedicated to the generation algorithms of Object version id: TODO
Zone id: Sbyte [0..1] ▣ The Id of the zone the object and its identifier are member. The zone ID maps to a Zone object. See Zones assembly for details.

The zone is a way of partitioning the object space.

Note kind Explanation
Text Using a given Zone ID is not neutral. It is crucial in many cases to be able to prove that any object claiming to be of a given organization is really issued of it. That's why a Zone ID can be attributed associated with a public certificate.

In an Initializer, the hash check and encoding (at least of the hash check) with the private key ensure the object provenance.

Organization can also be more lax internally thru Uncertified organization,  or even completely free by not providing Zone ID.
Zone : Zone object The Zone object corresponding to the Zone id.
Group id: Sbyte [0..1] ▣ The Id of the group the object and its identifier are member.

The group is a way of partitioning the object space.
Group : Group [0..1] The Group corresponding to the Group id.
Universe id: Sbyte [0..1] The Id of the Universe the object and its identifier are member. If missing, the universe is the public domain.
Universe : Universe The Universe manager corresponding to the Universe id.
Attribute
Business id: String [0..1] ▣  The id of the Object for the business, an invoice number for instance.

Remark:
During the Object life, the business id format may evolve. It is recommended to avoid padding and to follow the policy below:

  1. If the rule change is important and asked by the business
    1. If it is generalization or a specialization applicable only to new instances
      ⇒ Add suffix or post-fix using a separator (no padding).
    2. Otherwise
      ⇒ Perform a migration and compute new business ids (produce a mapping table object as the result of the migration).
  2. Else it is just an overflow
    ⇒  Keep the existing values having variable business id length (no padding).
Constructor
Identifier(▣) Base constructor. The Object id is built at construction time by an algorithm defined for its Nature for persisted objects.
Query
New version() : Identifier Create a new Identifier for the next version of the Object.
Invariant
The Object id is unique for a given Nature in a Zone and a Group
The invariant guarantees the of the identity of an object. This invariant may be implicitly supported by the algorithms of Object id Cf. Generation algorithms of Object id.

Identifier
Long smart pointer
Information
The basic implementation of the Smart pointer interface for the Double optimization scheme.

There are 2 optimization schemes. The used one is set thru an Identity factory (System ) configuration parameter Smart pointer variant:

  1. Single Sbyte Smart pointer but with a limited address space and reference counter.
  2. Double Sbyte Smart pointer without limitation
Fields
State: Sbyte
The State has the reference counters.
  • b1 to b32   Object reference counter => 4 294 967 295 Rooms
  • b33 In Delete flag: 0 If not in Delete operation, 1 if the smart pointer is in the Delete operation (needed to stop delete recursion)
  • b34 to b64   reference counter => 2 147 483 647 Rooms
This space is so large for a single node that it is considered to be widely sufficient for any need.
Address: Sbyte
The effective 64 bit memory address of the Object pointed by this smart pointer
  • b1 to b64 Object address space => 1,84467E+19   Rooms (full address space)
Properties Refer to Smart pointer interface
Constructor
Long smart pointer(Address: Sbyte)
 Constructor of the Smart pointer to the Address
Commands Refer to Smart pointer interface
Destructor Refer to Smart pointer interface
Long smart pointer
Reference
Information A Reference to an Object thru a Smart pointer. The Reference is the run time way for an Object to point to another object. Therefore, this Element is not intended to be used in models.
Field
$: Sbyte ▣ This field is composite:
  • The Reference Sbyte upper bit, b64, is 0 for read only access and 1 for read write access. The remaining bit points to the Smart pointer address.
  • b63-b1: Pointer to Smart pointer memory address.
Note kind Explanation
Text Available rooms : 263 = 9,22337E+18
Theoretical maximum rooms: 264 = 1,84467E+19
This means that the smart pointer space must be in the first half of the 64 bits memory space
Properties
Access mode: Access mode ▣ Indicates if the access is read only or if read and write are allowed. Read only and Read and write are the only possible values.

This low level unmutable way acceding an object is one of the corner stone of the ISA security.
Constructor
Reference(▣)
 The constructor to build a reference
Query
Dereference(Access mode: Access mode): Type Give an access to the referenced Type (an object for instance).

This operation is the only way to access an object. It is only intended to be used by the compiler.
Invariant
Immutable
To avoid unauthorized access by hacking a Reference.
Note
Note kind Explanation
Text See Smart pointer explanation to view how all these elements fit together.

Also refer to the post How to manage memory ?  to explain how the memory is managed in particular at end.
Reference
Short smart pointer
Information
The basic implementation of the Smart pointer interface for the Single optimization scheme.

There are 2 optimization schemes. The used one is set thru an Identity factory (System ) configuration parameter Smart pointer variant:

  1. Single Sbyte Smart pointer but with a limited address space and reference counter.
  2. Double Sbyte Smart pointer without limitation
Field
State and address: Sbyte
The single field to implements the state and the address.
Field usage:
  • b1 to b40   Object address space (48 on Intel x64) => 1,09951E+12 rooms. This gives 1 Tera rooms.
  • b41 In Delete flag: 0 If not in Delete operation, 1 if the smart pointer is in the Delete operation (needed to stop delete recursion)
  • b42 to b52 Smart pointer reference counting for Use cases (11 bits) => 2 047 rooms.
  • b53 to b64  Smart pointer reference counting for Objects (12 bits) => 4 095 rooms.
Note kind Explanation
Text
references
    Actually in 2019 on a Desktop PC the whole number of process is around 200
    But all objects are not referenced by use case => Says 10% are by UC
    12 bits => 205 times the actual usage
    11 bits => 102 times the actual usage
Object references
    Typically there are at maximum some tens of references between objects: says 30
    12 bits => 137 times the actual usage
    11 bits => 68 times the actual usage
    Exception: Singleton have many many objects that references them.
Conclusions
    These sizes should support efficiently the very large majority of the cases.
    The more pertinent is to have 11 bits for UC count and 12 for Object count.
    A solution have to be found in case of overflow, in particular for the Singleton case.
Solution for overflow
If a reference counter reach 4095 (or 2047), then a new secondary smart pointer is allocated referenced by the first smart pointer
the secondary smart pointer continue counting on the overflow counter but on the full 24 bits => 16 777 215 rooms.
This mechanism applies recurring to allow as needed references.
The reference counts is the sum of each smart pointer chain counters.
If both counters are in overflow, the pair (in the chain order) counter are for use case and the impair for object reference count.
Properties
Refer to Smart pointer interface
Constructor
Short smart pointer(Address: Sbyte)
Constructor of the Smart pointer to the Address
Commands Refer to Smart pointer interface
Destructor
 Refer to Smart pointer interface
Short smart pointer
Smart pointer
Information A Smart Pointer defines the type of all object reference in ISA. When both Reference counters value is zero, the Object destructor is called and the allocated memory released.
Smart pointer can references Object, Array, String and more generally any other Type that allocate memory externally to its container Object.There are 2 optimization schemes. The used one is set thru an Identity factory (System ) configuration parameter Smart pointer variant:
  1. Single Sbyte Smart pointer but with a limited address space and reference counter ranges.
  2. Double Sbyte Smart pointer without limitation
Properties
Object reference counter: Natural A reference from an Object to the Object pointed by this smart pointer.
Use case reference counter: Natural A reference from a Use case to the Object pointed by this smart pointer.
Address: Sbyte The Address of Object pointed by this smart pointer.
In delete: Boolean Indicator that the Delete operation is in progress.
Commands
Increment object reference count() Add one reference from an Object to the Object pointed by this smart pointer.
Decrement object reference count() Remove one reference from an Object to the Object pointed by this smart pointer.
Increment use case reference count() Add one reference from a Use case to the Object pointed by this smart pointer.
Decrement use case reference count(): Object [0..∞] Remove one reference from a Use case to the Object pointed by this smart pointer.
The Objects referenced by the Object pointed by this smart pointer are returned when the decrement results in the Use case reference counter to be equals to 0.
Destructor
Delete() Delete the Object pointed by this smart pointer, delete the smart pointer itself and release all the associated allocated memory.
See How to manage memory post for more details, in particular the sequence diagram.
Note
Note kind Explanation
Text The example below explains how 2 objects are mapped in run time memory. This mapping is for illustration purpose, it does take into account possible optimization in particular for the String Element.

Identity Assembly
Smart pointer
Assemblies

None.

Version and status

Version Date Description Status
V1R3 25-Mar-19 Initial. Candidate

 

Related posts:

  1. Relationships Assembly
  2. Containment Assembly
  3. Elements Assembly
  4. Textuals Assembly
  5. Model Assembly
Tags: 64 bits, Addressing, Assembly, Axiom, Class, Classifier, Functional, Identity, Instance, Interface, LL, Model, Object, OID, OO, Process, sbyte, Scope, State, Uniform, Uniqueness, Universe, Use Case, Versioning, View

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.