RunCode:
.loop:
        ; setup for next instruction byte code
        call @F
        jmp .loop
@@:
        lodsb
        ; any method works for dispatcher
        call Method_00
align $10000 ; no bytes generated, just informational
Method_00:
        test al,al
        jz .stop
        ; dispatch to byte code instruction
        mov [rsp+1],al
        retn
.stop: ; actual 00 method code
        pop rax ; discard instruction dispatch address
        pop rax ; discard .loop return to exit RunCode
        retn

align $100
Method_01:
        retn
...

align $100
Method_FF:
        retn    

struc(name) MakeFunctions
        match =?end?,name
                ; note: last function doesn't need a tail
                restruc MakeFunctions ; only one array of functions
                PreviousFunction reequ name
        else
                if ~ definite FirstFunction
                        FirstFunction := 1

                        FunctionMax = 0
                        postpone
                                match =?end?,PreviousFunction
                                else match any,PreviousFunction
                                        err 10,'"?End MakeFunctions" required to terminate function list (',`any,' was last function)'
                                end match
                                FunctionSize := FunctionMax
                        end postpone

                        macro CallFunction value*
                                imul eax,value,FunctionSize
                                lea rcx,[name] ; RIP relative
                                add rax,rcx
                                call rax
                        end macro
                else
                        .code_bytes := $ - PreviousFunction
                        if FunctionMax < .code_bytes
                                FunctionMax = .code_bytes
                        end if
                        rb FunctionSize - .code_bytes
                end if
                PreviousFunction reequ name
                name:
        end match
end struc    

; just being silly creating different sized functions

Grape MakeFunctions
        mov eax,0
        retn

Molly MakeFunctions
        xor qword [rdx*8+rbx+0x1234567],-0x01234568
        push 1
        pop rax
        retn

Jovial MakeFunctions
        retn

Yellow MakeFunctions
        mov ax,3
        retn

Bacon MakeFunctions
        mov al,4
        retn

?End MakeFunctions

; functions can be called directly from internal code:
        call Yellow

; or they can be called dynamically by index:
        YELLOW := 3
        fNum dd YELLOW

        CallFunction [fNum]    

Is there any experience coder who know the less worse answer?
Naively I would favor the first one.

I know, that's why I did mention the performance counters. But, there are obvious things to do or not to do, for instance aligned/unaligned data access
... and experienced coders may know something about more complex patterns like this one, hence my forum post!

Got my hands on AMD optimizing manual.

Got my hands on Adler performance counter assembly package too.
I am currently plugging asmlib memory functions into the heavything stuff... well, in the end I may have to go performance counter if I am not satisfied with the speed.

We can talk about the features of each method. The table method (unless it's in a loop) is guaranteed a code and data cache miss. Whereas the table-less method is just a code cache miss.