I need an efficient way to describe the structure of classes and objects so that they may be allocated by the structure manager.
The information of what a current class is and the identity hash code will not be special outside details, they will just be standard fields within a class that are initialized to values on allocation.
In general, the representation of objects will be shared such as classes and their sizes and field alignments.
The question is though, an effective way to represent code and data sections.
There would potentially need to be two object allocation schemes. One that is
in the data section while another is in the code section. There is no reason
that a Harvard architecture has to be unmodifiable. So I suppose what I need
then is a memory space which is given an allocator and an accessor and then
pass that to the
StructureManager. Otherwise the structure manager will
only ever be capable of allocating structures in the data space which means
that Harvard architectures with separated code and data will never be able to
use a JIT.
It is a
MemoryManager but does not manage pages, I suppose for that instead
there could be something called a
pmmu for managing memory pages that extend
beyond the standard allocator and such.
However, having an extra class is rather ugly. The accessor may be tightly bound to an allocator however. So do I have an allocator that is returned by the accessor? Do I have the memory accessor perform primitive memory management in chunks? I can do the later however, since it may actually work out better. The accessor is very specific to a system anyway and there might be a system specific means of allocating chunks of memory. However instead of it just being allocation, it will be reserving for the most part or similar. The structure manager can have a slightly better accessor which can manage memory better anyway and the that can be used instead (ideally a new MemoryAccessor wrapper would be used with the given logic).
When it comes to the structure manager, I will need a representation for classes.
The structure manager is really a run-time assistance library for the most part. The kernel and the interpreter would use the same structure manager for the most part when it comes to objects. So I suppose it should be called as such. Runtime objects perhaps.