46 TypeOpsMap

A PersistStore has a single TypeOpsMap recorded in the RootPersistStoreObject.

A TypeOpsMap is a bijective persistent map between an integer TypeOpsId and a ReflectionByteCodeValue.

                     (persistent
                      bijection)
        TypeOpsId       <--->      ReflectionByteCodeValue

It also caches a mapping from TypeOpsId to const TypeOps*.

                     lazy binding
                      (cached)
        TypeOpsId       --->       const TypeOps*

This is possible under the assumption that each ReflectionByteCodeValue recorded in the TypeOpsMap is also registered in the transient TypeOpsRegistry singleton in the cxObject library.

bool RegisterTypeOps(const ReflectionByteCodeValue& rbcv, const TypeOps* t)

as application libraries are loaded. Therefore the TypeOpsMap cannot assume calls to

const TypeOps* FindRegisteredTypeOps(const ReflectionByteCodeValue& rbcv)

can be made eagerly - i.e. at the time the TypeOpsMap is read from disk. Instead calls to FindRegisteredTypeOps are made lazily.

Purpose

Some persistent objects need to serialise some kind of type identifier. For example, the leaf nodes of a dynamically typed B+Tree first deserialise type information that identifies both the key and mapped value types, before deserialising an array of (key,mapped value) pairs. The latter can be performed efficiently using a TypeOps. Indeed what is needed is a space/time efficient mechanism to serialise some kind of type identifier that can be mapped to a const TypeOps*.

One approach is to serialise a ReflectionByteCodeValue and use the transient TypeOpsRegistry implemented in the cxObject library. However for better efficiency we introduce a new kind of persistent type identifier:

typedef ssize_t TypeOpsId;

This can be serialised as a variable length integer, so is very space efficient on disk. Futhermore, it can serve as an index in an array, to support very CPU efficient mapping to a const TypeOps*.

API usage

std::pair<const ReflectionByteCodeValue*, const TypeOps*> GetTypeOps(TypeOpsId tid);

in order to bind to the const TypeOps*, allowing it to deserialise the (key,value) pairs

This method can be backed up by a corresponding global function which access TLS in order to bind to the TypeOpsMap.

It is assumed the TypeOps for the ReflectionByteCode is registered when the DLLs are loaded. E.g.

$type+ int32[3];

This should allow for the following functions:

        const TypeOps& GetTypeOps<T>()
        ReflectionByteCode GetReflectionByteCode<T>();
        const TypeOps* FindTypeOps(ReflectionByteCode rbc);

            $new BTree
    -->     need to initialise TypeOpsId for K,V
    -->     can call GetReflectionByteCode() and GetTypeOps()
    -->     use PSpace in TLS to access PersistStore and hence the TypeOpsMap
    -->     register (ReflectionByteCodeValue,TypeOps) if not already.  Map to TypeOpsId
                TypeOpsId GetTypeOpsId(const ReflectionByteCodeValue& rbcv, const TypeOps* typeOps, bool& newEntry);

        $type int32;

        $typedef int32 MyInt;

    -->     GetReflectionByteCode_MyInt();
            GetTypeOps_MyInt();

        class _tag_MyInt;       // serves as a unique type, which can be used to provide
                                // information about a typedef.