christoph/wamr
1
Fork 0
Code Releases Activity

Refine Fast JIT accessing memory/table instance and global data (#1623)

Browse Source 
Some offsets can be directly gotten at the compilation stage after the interp/AOT
module instance refactoring PR was merged, so as to reduce some unnecessary
load instructions and improve the Fast JIT performance:
- Access fields of wasm memory instance structure
- Access fields of wasm table instance structure
- Access the global data
This commit is contained in:
Wenyong Huang
2022-10-21 09:32:51 +08:00
committed by GitHub
parent 4c61bfd10d
commit bbfa39c32c
7 changed files with 199 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

265
core/iwasm/fast-jit/jit_frontend.c
View File

@ -93,20 +93,6 @@ get_func_type_indexes_reg(JitFrame *frame)
return frame->func_type_indexes_reg;
}
JitReg
get_global_data_reg(JitFrame *frame)
{
JitCompContext *cc = frame->cc;
JitReg module_inst_reg = get_module_inst_reg(frame);
if (!frame->global_data_reg) {
frame->global_data_reg = cc->global_data_reg;
GEN_INSN(LDPTR, frame->global_data_reg, module_inst_reg,
NEW_CONST(I32, offsetof(WASMModuleInstance, global_data)));
}
return frame->global_data_reg;
}
JitReg
get_aux_stack_bound_reg(JitFrame *frame)
{
@ -135,48 +121,22 @@ get_aux_stack_bottom_reg(JitFrame *frame)
return frame->aux_stack_bottom_reg;
}
JitReg
get_memories_reg(JitFrame *frame)
{
JitCompContext *cc = frame->cc;
JitReg module_inst_reg = get_module_inst_reg(frame);
if (!frame->memories_reg) {
frame->memories_reg = cc->memories_reg;
GEN_INSN(LDPTR, frame->memories_reg, module_inst_reg,
NEW_CONST(I32, offsetof(WASMModuleInstance, memories)));
}
return frame->memories_reg;
}
JitReg
get_memory_inst_reg(JitFrame *frame, uint32 mem_idx)
{
JitCompContext *cc = frame->cc;
JitReg memories_reg = get_memories_reg(frame);
if (!frame->memory_regs[mem_idx].memory_inst) {
frame->memory_regs[mem_idx].memory_inst =
cc->memory_regs[mem_idx].memory_inst;
GEN_INSN(
LDPTR, frame->memory_regs[mem_idx].memory_inst, memories_reg,
NEW_CONST(I32, (uint32)sizeof(WASMMemoryInstance *) * mem_idx));
}
return frame->memory_regs[mem_idx].memory_inst;
}
JitReg
get_memory_data_reg(JitFrame *frame, uint32 mem_idx)
{
JitCompContext *cc = frame->cc;
JitReg memory_inst_reg = get_memory_inst_reg(frame, mem_idx);
JitReg module_inst_reg = get_module_inst_reg(frame);
uint32 memory_data_offset =
(uint32)offsetof(WASMModuleInstance, global_table_data.bytes)
+ (uint32)offsetof(WASMMemoryInstance, memory_data);
bh_assert(mem_idx == 0);
if (!frame->memory_regs[mem_idx].memory_data) {
frame->memory_regs[mem_idx].memory_data =
cc->memory_regs[mem_idx].memory_data;
GEN_INSN(LDPTR, frame->memory_regs[mem_idx].memory_data,
memory_inst_reg,
NEW_CONST(I32, offsetof(WASMMemoryInstance, memory_data)));
module_inst_reg, NEW_CONST(I32, memory_data_offset));
}
return frame->memory_regs[mem_idx].memory_data;
}
@ -185,14 +145,18 @@ JitReg
get_memory_data_end_reg(JitFrame *frame, uint32 mem_idx)
{
JitCompContext *cc = frame->cc;
JitReg memory_inst_reg = get_memory_inst_reg(frame, mem_idx);
JitReg module_inst_reg = get_module_inst_reg(frame);
uint32 memory_data_end_offset =
(uint32)offsetof(WASMModuleInstance, global_table_data.bytes)
+ (uint32)offsetof(WASMMemoryInstance, memory_data_end);
bh_assert(mem_idx == 0);
if (!frame->memory_regs[mem_idx].memory_data_end) {
frame->memory_regs[mem_idx].memory_data_end =
cc->memory_regs[mem_idx].memory_data_end;
GEN_INSN(LDPTR, frame->memory_regs[mem_idx].memory_data_end,
memory_inst_reg,
NEW_CONST(I32, offsetof(WASMMemoryInstance, memory_data_end)));
module_inst_reg, NEW_CONST(I32, memory_data_end_offset));
}
return frame->memory_regs[mem_idx].memory_data_end;
}
@ -201,21 +165,22 @@ JitReg
get_mem_bound_check_1byte_reg(JitFrame *frame, uint32 mem_idx)
{
JitCompContext *cc = frame->cc;
JitReg memory_inst_reg = get_memory_inst_reg(frame, mem_idx);
JitReg module_inst_reg = get_module_inst_reg(frame);
uint32 mem_bound_check_1byte_offset =
(uint32)offsetof(WASMModuleInstance, global_table_data.bytes)
+ (uint32)offsetof(WASMMemoryInstance, mem_bound_check_1byte);
bh_assert(mem_idx == 0);
if (!frame->memory_regs[mem_idx].mem_bound_check_1byte) {
frame->memory_regs[mem_idx].mem_bound_check_1byte =
cc->memory_regs[mem_idx].mem_bound_check_1byte;
#if UINTPTR_MAX == UINT64_MAX
GEN_INSN(LDI64, frame->memory_regs[mem_idx].mem_bound_check_1byte,
memory_inst_reg,
NEW_CONST(
I32, offsetof(WASMMemoryInstance, mem_bound_check_1byte)));
module_inst_reg, NEW_CONST(I32, mem_bound_check_1byte_offset));
#else
GEN_INSN(LDI32, frame->memory_regs[mem_idx].mem_bound_check_1byte,
memory_inst_reg,
NEW_CONST(
I32, offsetof(WASMMemoryInstance, mem_bound_check_1byte)));
module_inst_reg, NEW_CONST(I32, mem_bound_check_1byte_offset));
#endif
}
return frame->memory_regs[mem_idx].mem_bound_check_1byte;
@ -225,21 +190,24 @@ JitReg
get_mem_bound_check_2bytes_reg(JitFrame *frame, uint32 mem_idx)
{
JitCompContext *cc = frame->cc;
JitReg memory_inst_reg = get_memory_inst_reg(frame, mem_idx);
JitReg module_inst_reg = get_module_inst_reg(frame);
uint32 mem_bound_check_2bytes_offset =
(uint32)offsetof(WASMModuleInstance, global_table_data.bytes)
+ (uint32)offsetof(WASMMemoryInstance, mem_bound_check_2bytes);
bh_assert(mem_idx == 0);
if (!frame->memory_regs[mem_idx].mem_bound_check_2bytes) {
frame->memory_regs[mem_idx].mem_bound_check_2bytes =
cc->memory_regs[mem_idx].mem_bound_check_2bytes;
#if UINTPTR_MAX == UINT64_MAX
GEN_INSN(LDI64, frame->memory_regs[mem_idx].mem_bound_check_2bytes,
memory_inst_reg,
NEW_CONST(I32, offsetof(WASMMemoryInstance,
mem_bound_check_2bytes)));
module_inst_reg,
NEW_CONST(I32, mem_bound_check_2bytes_offset));
#else
GEN_INSN(LDI32, frame->memory_regs[mem_idx].mem_bound_check_2bytes,
memory_inst_reg,
NEW_CONST(I32, offsetof(WASMMemoryInstance,
mem_bound_check_2bytes)));
module_inst_reg,
NEW_CONST(I32, mem_bound_check_2bytes_offset));
#endif
}
return frame->memory_regs[mem_idx].mem_bound_check_2bytes;
@ -249,21 +217,24 @@ JitReg
get_mem_bound_check_4bytes_reg(JitFrame *frame, uint32 mem_idx)
{
JitCompContext *cc = frame->cc;
JitReg memory_inst_reg = get_memory_inst_reg(frame, mem_idx);
JitReg module_inst_reg = get_module_inst_reg(frame);
uint32 mem_bound_check_4bytes_offset =
(uint32)offsetof(WASMModuleInstance, global_table_data.bytes)
+ (uint32)offsetof(WASMMemoryInstance, mem_bound_check_4bytes);
bh_assert(mem_idx == 0);
if (!frame->memory_regs[mem_idx].mem_bound_check_4bytes) {
frame->memory_regs[mem_idx].mem_bound_check_4bytes =
cc->memory_regs[mem_idx].mem_bound_check_4bytes;
#if UINTPTR_MAX == UINT64_MAX
GEN_INSN(LDI64, frame->memory_regs[mem_idx].mem_bound_check_4bytes,
memory_inst_reg,
NEW_CONST(I32, offsetof(WASMMemoryInstance,
mem_bound_check_4bytes)));
module_inst_reg,
NEW_CONST(I32, mem_bound_check_4bytes_offset));
#else
GEN_INSN(LDI32, frame->memory_regs[mem_idx].mem_bound_check_4bytes,
memory_inst_reg,
NEW_CONST(I32, offsetof(WASMMemoryInstance,
mem_bound_check_4bytes)));
module_inst_reg,
NEW_CONST(I32, mem_bound_check_4bytes_offset));
#endif
}
return frame->memory_regs[mem_idx].mem_bound_check_4bytes;
@ -273,21 +244,24 @@ JitReg
get_mem_bound_check_8bytes_reg(JitFrame *frame, uint32 mem_idx)
{
JitCompContext *cc = frame->cc;
JitReg memory_inst_reg = get_memory_inst_reg(frame, mem_idx);
JitReg module_inst_reg = get_module_inst_reg(frame);
uint32 mem_bound_check_8bytes_offset =
(uint32)offsetof(WASMModuleInstance, global_table_data.bytes)
+ (uint32)offsetof(WASMMemoryInstance, mem_bound_check_8bytes);
bh_assert(mem_idx == 0);
if (!frame->memory_regs[mem_idx].mem_bound_check_8bytes) {
frame->memory_regs[mem_idx].mem_bound_check_8bytes =
cc->memory_regs[mem_idx].mem_bound_check_8bytes;
#if UINTPTR_MAX == UINT64_MAX
GEN_INSN(LDI64, frame->memory_regs[mem_idx].mem_bound_check_8bytes,
memory_inst_reg,
NEW_CONST(I32, offsetof(WASMMemoryInstance,
mem_bound_check_8bytes)));
module_inst_reg,
NEW_CONST(I32, mem_bound_check_8bytes_offset));
#else
GEN_INSN(LDI32, frame->memory_regs[mem_idx].mem_bound_check_8bytes,
memory_inst_reg,
NEW_CONST(I32, offsetof(WASMMemoryInstance,
mem_bound_check_8bytes)));
module_inst_reg,
NEW_CONST(I32, mem_bound_check_8bytes_offset));
#endif
}
return frame->memory_regs[mem_idx].mem_bound_check_8bytes;
@ -297,81 +271,118 @@ JitReg
get_mem_bound_check_16bytes_reg(JitFrame *frame, uint32 mem_idx)
{
JitCompContext *cc = frame->cc;
JitReg memory_inst_reg = get_memory_inst_reg(frame, mem_idx);
JitReg module_inst_reg = get_module_inst_reg(frame);
uint32 mem_bound_check_16bytes_offset =
(uint32)offsetof(WASMModuleInstance, global_table_data.bytes)
+ (uint32)offsetof(WASMMemoryInstance, mem_bound_check_16bytes);
bh_assert(mem_idx == 0);
if (!frame->memory_regs[mem_idx].mem_bound_check_16bytes) {
frame->memory_regs[mem_idx].mem_bound_check_16bytes =
cc->memory_regs[mem_idx].mem_bound_check_16bytes;
#if UINTPTR_MAX == UINT64_MAX
GEN_INSN(LDI64, frame->memory_regs[mem_idx].mem_bound_check_16bytes,
memory_inst_reg,
NEW_CONST(I32, offsetof(WASMMemoryInstance,
mem_bound_check_16bytes)));
module_inst_reg,
NEW_CONST(I32, mem_bound_check_16bytes_offset));
#else
GEN_INSN(LDI32, frame->memory_regs[mem_idx].mem_bound_check_16bytes,
memory_inst_reg,
NEW_CONST(I32, offsetof(WASMMemoryInstance,
mem_bound_check_16bytes)));
module_inst_reg,
NEW_CONST(I32, mem_bound_check_16bytes_offset));
#endif
}
return frame->memory_regs[mem_idx].mem_bound_check_16bytes;
}
JitReg
get_tables_reg(JitFrame *frame)
static uint32
get_table_inst_offset(const WASMModule *module, uint32 tbl_idx)
{
JitCompContext *cc = frame->cc;
JitReg inst_reg = get_module_inst_reg(frame);
uint32 module_inst_struct_size =
(uint32)offsetof(WASMModuleInstance, global_table_data.bytes);
uint32 mem_inst_size =
(uint32)sizeof(WASMMemoryInstance)
* (module->import_memory_count + module->memory_count);
uint32 offset, i = 0;
if (!frame->tables_reg) {
frame->tables_reg = cc->tables_reg;
GEN_INSN(LDPTR, frame->tables_reg, inst_reg,
NEW_CONST(I32, offsetof(WASMModuleInstance, tables)));
#if WASM_ENABLE_JIT != 0
/* If the module dosen't have memory, reserve one mem_info space
with empty content to align with llvm jit compiler */
if (mem_inst_size == 0)
mem_inst_size = (uint32)sizeof(WASMMemoryInstance);
#endif
/* Offset of the first table: size of module inst, memory instances
and global data */
offset = module_inst_struct_size + mem_inst_size + module->global_data_size;
while (i < tbl_idx && i < module->import_table_count) {
WASMTableImport *import_table = &module->import_tables[i].u.table;
offset += (uint32)offsetof(WASMTableInstance, elems);
#if WASM_ENABLE_MULTI_MODULE != 0
offset += (uint32)sizeof(uint32) * import_table->max_size;
#else
offset += (uint32)sizeof(uint32)
* (import_table->possible_grow ? import_table->max_size
: import_table->init_size);
#endif
i++;
}
return frame->tables_reg;
if (i == tbl_idx) {
return offset;
}
tbl_idx -= module->import_table_count;
i -= module->import_table_count;
while (i < tbl_idx && i < module->table_count) {
WASMTable *table = module->tables + i;
offset += (uint32)offsetof(WASMTableInstance, elems);
#if WASM_ENABLE_MULTI_MODULE != 0
offset += (uint32)sizeof(uint32) * table->max_size;
#else
offset += (uint32)sizeof(uint32)
* (table->possible_grow ? table->max_size : table->init_size);
#endif
i++;
}
return offset;
}
JitReg
get_table_inst_reg(JitFrame *frame, uint32 tbl_idx)
get_table_elems_reg(JitFrame *frame, uint32 tbl_idx)
{
JitCompContext *cc = frame->cc;
JitReg tables_reg = get_tables_reg(frame);
JitReg module_inst = get_module_inst_reg(frame);
uint32 offset = get_table_inst_offset(cc->cur_wasm_module, tbl_idx)
+ (uint32)offsetof(WASMTableInstance, elems);
if (!frame->table_regs[tbl_idx].table_inst) {
frame->table_regs[tbl_idx].table_inst =
cc->table_regs[tbl_idx].table_inst;
GEN_INSN(LDPTR, frame->table_regs[tbl_idx].table_inst, tables_reg,
NEW_CONST(I32, sizeof(WASMTableInstance *) * tbl_idx));
if (!frame->table_regs[tbl_idx].table_elems) {
frame->table_regs[tbl_idx].table_elems =
cc->table_regs[tbl_idx].table_elems;
GEN_INSN(ADD, frame->table_regs[tbl_idx].table_elems, module_inst,
NEW_CONST(PTR, offset));
}
return frame->table_regs[tbl_idx].table_inst;
}
JitReg
get_table_data_reg(JitFrame *frame, uint32 tbl_idx)
{
JitCompContext *cc = frame->cc;
JitReg table_reg = get_table_inst_reg(frame, tbl_idx);
if (!frame->table_regs[tbl_idx].table_data) {
frame->table_regs[tbl_idx].table_data =
cc->table_regs[tbl_idx].table_data;
GEN_INSN(ADD, frame->table_regs[tbl_idx].table_data, table_reg,
NEW_CONST(I64, offsetof(WASMTableInstance, elems)));
}
return frame->table_regs[tbl_idx].table_data;
return frame->table_regs[tbl_idx].table_elems;
}
JitReg
get_table_cur_size_reg(JitFrame *frame, uint32 tbl_idx)
{
JitCompContext *cc = frame->cc;
JitReg table_reg = get_table_inst_reg(frame, tbl_idx);
JitReg module_inst = get_module_inst_reg(frame);
uint32 offset = get_table_inst_offset(cc->cur_wasm_module, tbl_idx)
+ (uint32)offsetof(WASMTableInstance, cur_size);
if (!frame->table_regs[tbl_idx].table_cur_size) {
frame->table_regs[tbl_idx].table_cur_size =
cc->table_regs[tbl_idx].table_cur_size;
GEN_INSN(LDI32, frame->table_regs[tbl_idx].table_cur_size, table_reg,
NEW_CONST(I32, offsetof(WASMTableInstance, cur_size)));
GEN_INSN(LDI32, frame->table_regs[tbl_idx].table_cur_size, module_inst,
NEW_CONST(I32, offset));
}
return frame->table_regs[tbl_idx].table_cur_size;
}
@ -387,15 +398,11 @@ clear_fixed_virtual_regs(JitFrame *frame)
frame->import_func_ptrs_reg = 0;
frame->fast_jit_func_ptrs_reg = 0;
frame->func_type_indexes_reg = 0;
frame->global_data_reg = 0;
frame->aux_stack_bound_reg = 0;
frame->aux_stack_bottom_reg = 0;
frame->memories_reg = 0;
frame->tables_reg = 0;
count = module->import_memory_count + module->memory_count;
for (i = 0; i < count; i++) {
frame->memory_regs[i].memory_inst = 0;
frame->memory_regs[i].memory_data = 0;
frame->memory_regs[i].memory_data_end = 0;
frame->memory_regs[i].mem_bound_check_1byte = 0;
@ -407,8 +414,7 @@ clear_fixed_virtual_regs(JitFrame *frame)
count = module->import_table_count + module->table_count;
for (i = 0; i < count; i++) {
frame->table_regs[i].table_inst = 0;
frame->table_regs[i].table_data = 0;
frame->table_regs[i].table_elems = 0;
frame->table_regs[i].table_cur_size = 0;
}
}
@ -576,11 +582,8 @@ create_fixed_virtual_regs(JitCompContext *cc)
cc->import_func_ptrs_reg = jit_cc_new_reg_ptr(cc);
cc->fast_jit_func_ptrs_reg = jit_cc_new_reg_ptr(cc);
cc->func_type_indexes_reg = jit_cc_new_reg_ptr(cc);
cc->global_data_reg = jit_cc_new_reg_ptr(cc);
cc->aux_stack_bound_reg = jit_cc_new_reg_I32(cc);
cc->aux_stack_bottom_reg = jit_cc_new_reg_I32(cc);
cc->memories_reg = jit_cc_new_reg_ptr(cc);
cc->tables_reg = jit_cc_new_reg_ptr(cc);
count = module->import_memory_count + module->memory_count;
if (count > 0) {
@ -592,7 +595,6 @@ create_fixed_virtual_regs(JitCompContext *cc)
}
for (i = 0; i < count; i++) {
cc->memory_regs[i].memory_inst = jit_cc_new_reg_ptr(cc);
cc->memory_regs[i].memory_data = jit_cc_new_reg_ptr(cc);
cc->memory_regs[i].memory_data_end = jit_cc_new_reg_ptr(cc);
cc->memory_regs[i].mem_bound_check_1byte = jit_cc_new_reg_ptr(cc);
@ -613,8 +615,7 @@ create_fixed_virtual_regs(JitCompContext *cc)
}
for (i = 0; i < count; i++) {
cc->table_regs[i].table_inst = jit_cc_new_reg_ptr(cc);
cc->table_regs[i].table_data = jit_cc_new_reg_ptr(cc);
cc->table_regs[i].table_elems = jit_cc_new_reg_ptr(cc);
cc->table_regs[i].table_cur_size = jit_cc_new_reg_I32(cc);
}
}