Polymorphism, Dynamic Binding & VTable Mechanics

+-------------------------------------------------------------------------+
|                  THE CARDELLI-WEGNER POLYMORPHISM TAXONOMY              |
+-------------------------------------------------------------------------+
|                                                                         |
|                         POLYMORPHISM SPECTRUM                           |
|                                   |                                     |
|         +-------------------------+-------------------------+           |
|         |                                                   |           |
|  UNIVERSAL POLYMORPHISM                              AD-HOC POLYMORPHISM|
|  (Executes identical logic                           (Different logic   |
|   across infinite types)                              per specific type)|
|         |                                                   |           |
|    +----+----+                                         +----+----+      |
|    |         |                                         |         |      |
| PARAMETRIC  INCLUSION                             OVERLOADING COERCION  |
| (Generics,  (Subtyping,                           (Compile-   (Implicit |
|  Templates)  Virtual                               time name   type     |
|              Dispatch)                             resolution) casting) |
|                                                                         |
+-------------------------------------------------------------------------+

+-------------------------------------------------------------------------+
|                  VIRTUAL METHOD TABLE (VTABLE) ARCHITECTURE             |
+-------------------------------------------------------------------------+
|                                                                         |
|  OBJECT INSTANCE (Heap Memory)             VTABLE (Static Read-Only Data)
|  +---------------------------+             +---------------------------+|
|  | vptr (8 bytes)            | ----------> | Slot 0: &Shape::draw()    ||
|  +---------------------------+             +---------------------------+|
|  | int x_coordinate          |             | Slot 1: &Shape::area()    ||
|  +---------------------------+             +---------------------------+|
|  | int y_coordinate          |             | Slot 2: &Shape::~Shape()  ||
|  +---------------------------+             +---------------------------+|
|                                                                         |
+-------------------------------------------------------------------------+

Shape* s = get_runtime_shape();
s->draw();

1. Fetch the vptr from the object instance:
   VTable* vt = s->__vptr;

2. Fetch the function pointer from Slot 0 (offset 0):
   FunctionPtr func = vt->slots[0];

3. Invoke the function indirectly, passing the object as the implicit 'this' pointer:
   func(s);

; Input: Pointer 's' is in register rdi (first argument / this pointer)
mov rax, qword ptr [rdi]        ; Step 1: Read vptr from object offset 0 into rax
call qword ptr [rax + 0]         ; Step 2 & 3: Read Slot 0 from vtable and execute indirect call

class InterfaceA {
public:
    virtual void methodA(); // Slot 0
};

class InterfaceB {
public:
    virtual void methodB(); // Slot 0
};

class Composite : public InterfaceA, public InterfaceB {
public:
    void methodA() override;
    void methodB() override;
    virtual void methodComposite(); // Slot 1 in primary vtable
};

+-------------------------------------------------------------------------+
|                  MULTIPLE INHERITANCE VTABLE & MEMORY LAYOUT            |
+-------------------------------------------------------------------------+
|                                                                         |
|  COMPOSITE OBJECT INSTANCE                                              |
|  +---------------------------+ <--- Address d (and InterfaceA* a = d)   |
|  | vptr_InterfaceA (8 bytes) | ----> [Composite's Primary VTable]       |
|  |                           |       - Slot 0: &Composite::methodA      |
|  |                           |       - Slot 1: &Composite::methodComposite
|  +---------------------------+                                          |
|  | InterfaceA data fields    |                                          |
|  +---------------------------+ <--- InterfaceB* b = d + 16 (Offset +16) |
|  | vptr_InterfaceB (8 bytes) | ----> [Composite's Secondary VTable]     |
|  |                           |       - Slot 0: &Thunk_to_Composite::methodB
|  +---------------------------+                                          |
|  | InterfaceB data fields    |                                          |
|  +---------------------------+                                          |
|  | Composite data fields     |                                          |
|  +---------------------------+                                          |
|                                                                         |
+-------------------------------------------------------------------------+

; Adjustor Thunk for Composite::methodB
sub rdi, 16                     ; Subtract 16 from 'this' pointer to restore address 'd'
jmp Composite::methodB          ; Jump directly to the real method!

+-------------------------------------------------------------------------+
|                  JVM BYTECODE DISPATCH INSTRUCTION MATRIX               |
+------------------+-----------------------+------------------------------+
| Instruction      | Target Type           | Dispatch Mechanics           |
+------------------+-----------------------+------------------------------+
| invokestatic     | Static class methods  | Static direct dispatch       |
| invokespecial    | Private methods, super| Non-virtual direct dispatch  |
|                  | calls, constructors   | (no polymorphic override)    |
| invokevirtual    | Public/protected class| Indexed vtable lookup        |
|                  | methods               | (fast, constant offset)      |
| invokeinterface  | Interface methods     | Itable lookup / Inline Cache |
|                  |                       | (variable table layout)      |
| invokedynamic    | Lambda expressions,   | Dynamic CallSite bootstrap   |
|                  | dynamic languages     | (JSR-292 method handles)     |
+------------------+-----------------------+------------------------------+

+-------------------------------------------------------------------------+
|                  HOTSPOT INLINE CACHING STATE TRANSITIONS               |
+-------------------------------------------------------------------------+
|                                                                         |
|      [UNINITIALIZED CALL SITE]                                          |
|                 |                                                       |
|                 | First Execution: Record receiver class T1             |
|                 v                                                       |
|      [MONOMORPHIC INLINE CACHE]                                         |
|      if (receiver.class == T1) -> Direct Call / INLINED CODE!           |
|                 |                                                       |
|                 | Second Receiver Observed (Class T2)                   |
|                 v                                                       |
|      [BIMORPHIC INLINE CACHE]                                           |
|      if (receiver.class == T1) -> Direct Call T1                        |
|      else if (receiver.class == T2) -> Direct Call T2                   |
|                 |                                                       |
|                 | Third Receiver Observed (>2 Classes)                  |
|                 v                                                       |
|      [MEGAMORPHIC CALL SITE]                                            |
|      Fallback to full table lookup (vtable / itable stub)               |
|                                                                         |
+-------------------------------------------------------------------------+

template <typename Derived>
class BaseProcessor {
public:
    void process() {
        // Static dispatch: Cast this to Derived at compile time!
        static_cast<Derived*>(this)->process_impl();
    }
};

class FastNetworkProcessor : public BaseProcessor<FastNetworkProcessor> {
public:
    void process_impl() {
        // High-velocity processing
    }
};

# ============================================================================
# LOW-LEVEL VTABLE EMULATOR & DISPATCH PERFORMANCE BENCHMARK
# ============================================================================

from typing import List, Dict, Callable, Any
import time

# ----------------------------------------------------------------------------
# 1. LOW-LEVEL VTABLE & OBJECT MEMORY EMULATION
# ----------------------------------------------------------------------------

class VTable:
    '''Simulates a compiler-generated static virtual method table in memory.'''
    def __init__(self, class_name: str, slots: List[Callable]):
        self.class_name = class_name
        self.slots: List[Callable] = slots

    def __repr__(self) -> str:
        names = [f[0].__name__ for f in self.slots]
        return f"VTable({self.class_name}, Slots={names})"


class EmulatedPolymorphicObject:
    '''
    Simulates a C++ memory layout containing:
    - Offset 0x00: vptr (Pointer to VTable)
    - Offset 0x08: Member data fields
    '''
    def __init__(self, vtable: VTable, data_fields: Dict[str, Any]):
        self._vptr: VTable = vtable
        self._data: Dict[str, Any] = data_fields

    def virtual_dispatch(self, slot_index: int, *args, **kwargs) -> Any:
        '''
        Simulates: call [vptr + slot_index * 8]
        Dereferences the vptr, retrieves function pointer, and passes self.
        '''
        # Step 1: Read function pointer from vtable slot
        func_entry = self._vptr.slots[slot_index]
        func_ptr, offset_adjustment = func_entry

        # Step 2: Execute function pointer (accounting for this-pointer thunks)
        return func_ptr(self, *args, **kwargs)


# ----------------------------------------------------------------------------
# 2. VIRTUAL METHODS & THUNK MECHANICS
# ----------------------------------------------------------------------------

def shape_draw(obj: EmulatedPolymorphicObject) -> str:
    return f"[Shape Base] Drawing base shape at ({obj._data.get('x')}, {obj._data.get('y')})"

def circle_draw(obj: EmulatedPolymorphicObject) -> str:
    radius = obj._data.get("radius", 1.0)
    return f"[Circle Override] Drawing circle with radius {radius} at ({obj._data.get('x')}, {obj._data.get('y')})"

def rect_draw(obj: EmulatedPolymorphicObject) -> str:
    w, h = obj._data.get("w", 1), obj._data.get("h", 1)
    return f"[Rectangle Override] Drawing rectangle {w}x{h}"

def audio_play_thunk(obj: EmulatedPolymorphicObject) -> str:
    # Simulates adjusting the this pointer by secondary base offset
    return f"[Audio Device Thunk] Adjusted pointer by -16 bytes. Playing stream: {obj._data.get('stream_id')}"

# Construct static VTables in simulated read-only memory
VTABLE_SHAPE = VTable("Shape", slots=[(shape_draw, 0)])
VTABLE_CIRCLE = VTable("Circle", slots=[(circle_draw, 0)])
VTABLE_RECTANGLE = VTable("Rectangle", slots=[(rect_draw, 0)])
VTABLE_AUDIO = VTable("AudioDevice", slots=[(audio_play_thunk, -16)])


# ----------------------------------------------------------------------------
# 3. STATIC VS. DYNAMIC DISPATCH MICROBENCHMARK
# ----------------------------------------------------------------------------

class DirectWorker:
    '''Class with direct static method call.'''
    def calculate(self, a: int, b: int) -> int:
        return a * b + 10


class PolymorphicBase:
    def calculate(self, a: int, b: int) -> int:
        raise NotImplementedError()


class DynamicWorker(PolymorphicBase):
    '''Class relying on dynamic virtual method dispatch.'''
    def calculate(self, a: int, b: int) -> int:
        return a * b + 10


def run_benchmark(iterations: int = 2_000_000) -> None:
    direct = DirectWorker()
    dynamic: PolymorphicBase = DynamicWorker()

    # Benchmark Static Call
    start_static = time.perf_counter()
    res_static = 0
    for i in range(iterations):
        res_static += direct.calculate(i, 2)
    time_static = time.perf_counter() - start_static

    # Benchmark Dynamic Call
    start_dynamic = time.perf_counter()
    res_dynamic = 0
    for i in range(iterations):
        res_dynamic += dynamic.calculate(i, 2)
    time_dynamic = time.perf_counter() - start_dynamic

    assert res_static == res_dynamic, "Benchmark calculations diverged!"

    print(f"Iterations: {iterations:,}")
    print(f"Direct / Static Call Time:  {time_static:.4f} seconds")
    print(f"Dynamic Dispatch Call Time: {time_dynamic:.4f} seconds")
    overhead_pct = ((time_dynamic - time_static) / time_static) * 100.0
    print(f"Dynamic Indirection Overhead: +{overhead_pct:.2f}%")


# ----------------------------------------------------------------------------
# 4. EXECUTION & VERIFICATION HARNESS
# ----------------------------------------------------------------------------

if __name__ == "__main__":
    print("=" * 70)
    print("1. SIMULATING COMPILER VTABLE DYNAMIC DISPATCH:")
    print("=" * 70)
    shapes: List[EmulatedPolymorphicObject] = [
        EmulatedPolymorphicObject(VTABLE_CIRCLE, {"x": 10, "y": 20, "radius": 5.5}),
        EmulatedPolymorphicObject(VTABLE_RECTANGLE, {"x": 0, "y": 0, "w": 40, "h": 60}),
        EmulatedPolymorphicObject(VTABLE_SHAPE, {"x": 5, "y": 5})
    ]

    for s in shapes:
        # Dynamic virtual call at Slot 0
        output = s.virtual_dispatch(0)
        print("  Dispatched Call:", output)

    print("\n" + "=" * 70)
    print("2. SIMULATING SECONDARY BASE THUNK DISPATCH:")
    print("=" * 70)
    multimedia_device = EmulatedPolymorphicObject(VTABLE_AUDIO, {"stream_id": "PCM_24BIT_96KHZ"})
    print("  Thunk Invocation:", multimedia_device.virtual_dispatch(0))

    print("\n" + "=" * 70)
    print("3. RUNNING DISPATCH MICROBENCHMARK:")
    print("=" * 70)
    run_benchmark(iterations=1_000_000)

for (Actor* actor : world.actors) {
    actor->update(delta_time); // Polymorphic virtual dispatch!
}

class Base {
public:
    Base() { initialize(); }
    virtual void initialize() { cout << "Base Init\n"; }
};
class Derived : public Base {
public:
    void initialize() override { cout << "Derived Init\n"; }
};

void process(Base b); // Passed by value!
Derived d;
process(d); // Object Slicing!

class Base {
public:
    virtual void run() = 0;
    // CRITICAL BUG: Non-virtual destructor!
    ~Base() { ... }
};

Base* b = new Derived();
delete b; // UNDEFINED BEHAVIOR!

class Stream {
public:
    virtual void open();        // Slot 0
    virtual void close();       // Slot 1
    virtual int read() = 0;     // Slot 2
    virtual ~Stream();          // Slot 3
};

class FileStream : public Stream {
public:
    void open() override;       // Overrides Slot 0
    int read() override;        // Overrides Slot 2
    virtual void flush();       // New virtual method!
    ~FileStream() override;     // Overrides Slot 3
};

+------------+-----------------------------------+
| Slot Index | Target Function Pointer           |
+------------+-----------------------------------+
| Slot 0     | &Stream::open()                   |
| Slot 1     | &Stream::close()                  |
| Slot 2     | &__cxa_pure_virtual (Pure virtual)|
| Slot 3     | &Stream::~Stream()                |
+------------+-----------------------------------+

+------------+-----------------------------------+
| Slot Index | Target Function Pointer           |
+------------+-----------------------------------+
| Slot 0     | &FileStream::open()               |
| Slot 1     | &Stream::close()                  |
| Slot 2     | &FileStream::read()               |
| Slot 3     | &FileStream::~FileStream()        |
| Slot 4     | &FileStream::flush()              |
+------------+-----------------------------------+

; Input: rdi contains the pointer 's'
mov rax, qword ptr [rdi]        ; Step 1: Dereference object offset 0 to retrieve vptr -> rax
mov rcx, qword ptr [rax + 16]    ; Step 2: Read function pointer from Slot 2 (offset +16) -> rcx
call rcx                         ; Step 3: Indirect call to FileStream::read(this)
; Return value 'byte' is returned in register eax
mov dword ptr [rbp - 4], eax    ; Store result into local variable

class Printable {
public:
    virtual void print() = 0;       // Slot 0
    virtual ~Printable() {}         // Slot 1
};

class Serializable {
public:
    virtual void serialize() = 0;   // Slot 0
    virtual ~Serializable() {}      // Slot 1
};

class Document : public Printable, public Serializable {
public:
    int doc_id;                     // 4 bytes
    void print() override;
    void serialize() override;
    ~Document() override;
};

Document* doc = new Document();
Serializable* s = doc;
s->serialize();

+-------------------------------------------------------------------------+
|                    DOCUMENT MEMORY & DUAL VTABLE LAYOUT                 |
+-------------------------------------------------------------------------+
|                                                                         |
|  DOCUMENT INSTANCE (Heap)                     PRIMARY VTABLE (Printable)|
|  +---------------------------+ <--- Address d +------------------------+|
|  | vptr_Printable (8 bytes)  | -------------> | Slot 0: &Doc::print    ||
|  +---------------------------+                | Slot 1: &Doc::~Doc     ||
|  | vptr_Serializable (8 bytes) <--- Addr s    +------------------------+|
|  +---------------------------+      (d + 8)                             |
|  | int doc_id (4 bytes)      |                SECONDARY VTABLE (Serial)||
|  +---------------------------+                +------------------------+|
|  | [Tail padding] (4 bytes)  | -------------> | Slot 0: &Thunk_Serial  ||
|  +---------------------------+                | Slot 1: &Thunk_Destr   ||
|                                               +------------------------+|
+-------------------------------------------------------------------------+

mov rax, qword ptr [rdi]        ; Reads vptr_Serializable from [d + 8]
mov rax, qword ptr [rax + 0]    ; Reads Slot 0 (points to &Thunk_Serial)
call rax                        ; Calls Thunk_Serial with rdi = d + 8

Thunk_to_Document_serialize:
    sub rdi, 8                  ; Subtract 8 bytes: rdi is now exactly 'd' (Document* this)!
    jmp Document::serialize     ; Tail-call jump directly to Document::serialize

class AudioBuffer {
public:
    virtual void process() = 0;
    // NON-VIRTUAL DESTRUCTOR!
    ~AudioBuffer() {
        std::cout << "[AudioBuffer] Cleaning base buffer.\n";
    }
};

class DmaAudioBuffer : public AudioBuffer {
private:
    int* dma_hardware_ring;
    int hardware_channel_id;
public:
    DmaAudioBuffer(int size, int channel) {
        hardware_channel_id = channel;
        dma_hardware_ring = new int[size]; // Allocates 4MB heap buffer
        acquire_hardware_lock(channel);
    }
    void process() override { /* ... */ }
    ~DmaAudioBuffer() {
        delete[] dma_hardware_ring;    // Free 4MB buffer
        release_hardware_lock(hardware_channel_id); // Release hardware channel
        std::cout << "[DmaAudioBuffer] Released hardware DMA channel.\n";
    }
};

AudioBuffer* buf = new DmaAudioBuffer(1024 * 1024, 3);
buf->process();
delete buf; // Dynamic polymorphic deletion

class AudioBuffer {
public:
    virtual void process() = 0;
    // Declaring destructor virtual ensures polymorphic deletion!
    virtual ~AudioBuffer() {
        std::cout << "[AudioBuffer] Cleaning base buffer.\n";
    }
};

// ARCHITECTURE 1: Dynamic Inclusion Polymorphism (VTable)
class IVectorTransform {
public:
    virtual void transform(float* data, int size) = 0;
    virtual ~IVectorTransform() {}
};

class FastScaleTransform : public IVectorTransform {
public:
    void transform(float* data, int size) override {
        for (int i = 0; i < size; ++i) data[i] *= 1.05f;
    }
};

// ARCHITECTURE 2: Curiously Recurring Template Pattern (CRTP Static Polymorphism)
template <typename Derived>
class CrtpTransform {
public:
    void transform(float* data, int size) {
        static_cast<Derived*>(this)->transform_impl(data, size);
    }
};

class CrtpFastScale : public CrtpTransform<CrtpFastScale> {
public:
    void transform_impl(float* data, int size) {
        for (int i = 0; i < size; ++i) data[i] *= 1.05f;
    }
};

+-------------------------------------------------------------------------+
|                  CRTP VS. VTABLE EMITTED ASSEMBLY CONTRAST              |
+-------------------------------------------------------------------------+
| CRTP STATIC INLINED LOOP (AVX-512)   | VTABLE DYNAMIC DISPATCH LOOP     |
+--------------------------------------+----------------------------------+
| ; Zero function call overhead!       | ; Must execute full call cycle   |
| .L_vector_loop:                      | .L_vtable_loop:                  |
|   vmovups zmm0, [rdi + rax]          |   mov rdi, [rbx + r12*8] ; Obj   |
|   vmulps  zmm0, zmm0, zmm1           |   mov rax, [rdi]         ; vptr  |
|   vmovups [rdi + rax], zmm0          |   mov rsi, [rsp + 16]    ; data  |
|   add rax, 64                        |   mov edx, 64            ; size  |
|   cmp rax, rdx                       |   call qword ptr [rax]   ; Call! |
|   jl .L_vector_loop                  |   inc r12                        |
|                                      |   cmp r12, 100000                |
|                                      |   jl .L_vtable_loop              |
+--------------------------------------+----------------------------------+

+-------------------------------------------------------------------------+
|                  ARCHITECTURAL SELECTION MATRIX: VTABLE VS. CRTP        |
+---------------------+---------------------------+-----------------------+
| CRITERION           | CHOOSE VTABLE (DYNAMIC)   | CHOOSE CRTP (STATIC)  |
+---------------------+---------------------------+-----------------------+
| Collection          | Heterogeneous collections | Homogeneous pipelines |
| Structure           | (std::vector<Shape*>)     | and templated engines |
+---------------------+---------------------------+-----------------------+
| Configuration Time  | Runtime dynamic selection | Compile-time static   |
|                     | (plugin loaded at runtime)| specialization        |
+---------------------+---------------------------+-----------------------+
| Performance Target  | Standard enterprise I/O   | High-frequency trading|
|                     | or UI workflows           | SIMD math, game loops |
+---------------------+---------------------------+-----------------------+
| Memory Constraint   | Can afford 8-byte vptr    | Zero memory overhead  |
|                     | per object instance       | (billions of structs) |
+---------------------+---------------------------+-----------------------+
| Compilation Time    | Fast incremental compiles | Slower due to template|
|                     |                           | code expansion        |
+---------------------+---------------------------+-----------------------+