О разновидностях шитого кода

Преамбула...

До этого компилятор Д2 был реализован таким образом, что генерировался
как результат текст на ассемблере, при этом поддерживались три модели
компиляции, две из которых разновидности шитого кода (простого ;), в смысле, 
прямого и "сквозного" с отсутствием поля кода.

Версию эту я положил здесь, а далее маленькая выдержка из описания

1. Общие замечания
Ядром Д2 является адресный интерпретатор, в компиляторе 
используется две его модели: straight и throught. Которые представляют собой 
прямой шитый код и некий "сквозной некст" шитый код, идея которого мне была 
предложена для реализации V.P. Модель компиляции bootstrap представляет 
собой подпрограммный шитый код. Как видно, код достаточно прозрачен. 2. 

Исходники ядер 

 straight model
		

START:		cld
		xor	ax, ax
		sub	ax, 10h
		mov	bp, ax
		sub	ax, memSR
		mov	sp, ax
		mov	si, offset _STARTUP
		lodsw
		jmp	ax
;--------------------------------------------------------------
_CALLR:		dec	bp
		dec	bp
		mov	[bp], si
		pop	si

_NEXT:		lodsw
		jmp	ax				

_EXIT:		mov	si, [bp]
		inc	bp
		inc	bp
		lodsw
		jmp	ax
;----------------------------------------------------------------

_NULL:		lodsw
		jmp	ax

_LOD:		lodsw
		push	ax
		lodsw
		jmp	ax

_JMPTO:		lodsw
		mov	si, ax
		lodsw
		jmp	ax

_JMPCOND:	pop	ax
		cmp	ax, 0
		jz 	_JMPTO
		lodsw
		lodsw
		jmp	ax

_INITLOC:	lodsw
		sub	bp, ax
		lodsw
		jmp	ax

_CLRLOC:	lodsw
		add	bp, ax
		lodsw
		jmp	ax

_LODLOC:	lodsw
		add	ax, bp
		push	ax
		lodsw
		jmp	ax

_PARAM:		lodsw
		mov	bx, bp
		add	bx, ax
		pop	word ptr [bx]
		lodsw
		jmp	ax

_HALT:		mov	ax, 4C00h
		int	21h

_STARTUP:	dw	MAIN
		dw	offset _HALT



 throught model

START:
		cld
		xor	ax, ax
		sub	ax, 10h
		mov	bp, ax
		sub	ax, memSR
		mov	sp, ax
		sub	ax, memSA
		mov	PARAMS, ax
		mov	bx, offset _STARTUP
		jmp	_CALLR
;------------
PARAMS		dw	0	
;----------------------------------------------------------------------
_EXIT:		dw	0			; признак примитива
		inc	bp			; убрать уровень 
		inc	bp			; вложнности
_NEXT:		mov	bx, [bp]		; взять
		inc	bp			; адрес
		inc	bp			; возврата
_CALLR:		cmp	word ptr [bx], 0	; это 
		jz	_ATOM			; примитив?
		inc	bx			; получить адрес
		inc	bx			; следующего слова
		dec	bp			; сохранить адрес
		dec	bp			; возврата в текущий
		mov	[bp], bx		; уровень вложенности
		mov	bx, [bx-2]		; разобрать
		jmp	_CALLR			; текущее слово
_ATOM:		inc	bx			; пропустить 
		inc	bx			; признак примитива
		jmp	bx			; и выполнить
;------------------------------------------------------
_NULL:		dw	0
		jmp	_NEXT

_LOD:		dw	0
		mov	bx, [bp]
		push	word ptr [bx]
		add	word ptr [bp], 2
		jmp	_NEXT

_JMPTO:		dw	0
_JMPTO1:	mov	bx, [bp]
		push	word ptr [bx]
		pop	word ptr [bp]
		jmp	_NEXT

_JMPCOND:	dw	0
		pop	BX
		cmp	BX, 0
		jz	_JMPTO1
		add	word ptr [bp], 2
		jmp	_NEXT

_INITLOC:	dw	0
		mov	bx, [bp]
		add	word ptr [bp], 2
		mov	bx, [bx]
		sub	PARAMS, bx
		jmp	_NEXT

_CLRLOC:	dw	0
		mov	bx, [bp]
		add	word ptr [bp], 2
		mov	bx, [bx]
		add	PARAMS, bx
		jmp	_NEXT

_LODLOC:	dw	0
		mov	ax, PARAMS
		mov	bx, [bp]
		add	word ptr [bp], 2
		add	ax, [bx]
		push	ax
		jmp	_NEXT

_PARAM:		dw	0
		mov	bx, [bp]
		add	word ptr [bp], 2
		mov	bx, [bx]
		add	bx, PARAMS
		pop	ax
		mov	[bx], ax
		jmp	_NEXT

_HALT:		dw	0
		mov	ax, 4C00h
		int	21h

_STARTUP:	dw	MAIN
		dw	offset _HALT



 bootstrap model

START:
		cld
		xor	ax, ax
		sub	ax, 10h
		mov	bp, ax
		sub	ax, memSR
		mov	sp, ax
		sub	ax, memSA
		mov	PARAMS, ax
		mov	ax, MAIN
		call	ax
_HALT:		mov	ax, 4C00h
		int	21h
		PARAMS		dw	0	





3. Однако...
На мой взгляд, я мог криво написать некоторые части ядра, и поэтому с 
удовольствием приму все критические (и не очень) замечания по этому поводу. 
Особый бенчмарк мною не производился, однако из общих наблюдений можно построить 
примерно такую таблицу. 
КРИТЕРИЙ:        скорость            размер   

МЕСТО:           bootstrap	     throught
		 straight            straight
                 throught            bootstrap

ПРИМЕЧАНИЯ:      по-видимому, модель throught работает быстрее, при
                 коде с большой вложенностью вызовов процедур.

                 размер кода существенно зависит от его "состава", так
                 при преобладании низкоуровневых процедур больший выиг-
                 рыш дает модель straight, а при высокоуровневых - мо-
                 дель throught.