From 0027946f9023b8afe8753ef06c02fb97e4a341b1 Mon Sep 17 00:00:00 2001 From: Eyck-Alexander Jentzsch Date: Sun, 16 Feb 2025 01:06:25 +0100 Subject: [PATCH] renames mask operations to distinguish from vector integer compare instructions --- gen_input/templates/interp/CORENAME.cpp.gtl | 28 +++++ src/vm/vector_functions.h | 5 + src/vm/vector_functions.hpp | 110 ++++++++++++++++++-- 3 files changed, 135 insertions(+), 8 deletions(-) diff --git a/gen_input/templates/interp/CORENAME.cpp.gtl b/gen_input/templates/interp/CORENAME.cpp.gtl index ad1a96b..7f92743 100644 --- a/gen_input/templates/interp/CORENAME.cpp.gtl +++ b/gen_input/templates/interp/CORENAME.cpp.gtl @@ -303,6 +303,34 @@ if(vector != null) {%> void vector_imm_m(uint8_t* V, uint8_t funct, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, uint8_t vd, uint8_t vs2, int64_t imm, uint8_t sew_val, int8_t carry){ vector_imm_op(V, funct, vl, vstart, vtype, 0, vd, vs2, imm, sew_val, carry); } + void carry_mask_vector_vector_op(uint8_t* V, unsigned funct, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, unsigned vd, unsigned vs2, unsigned vs1, uint8_t sew_val){ + switch(sew_val){ + case 0b000: + return softvector::carry_mask_vector_vector_op<${vlen}, uint8_t>(V, funct, vl, vstart, vtype, vm, vd, vs2, vs1); + case 0b001: + return softvector::carry_mask_vector_vector_op<${vlen}, uint16_t>(V, funct, vl, vstart, vtype, vm, vd, vs2, vs1); + case 0b010: + return softvector::carry_mask_vector_vector_op<${vlen}, uint32_t>(V, funct, vl, vstart, vtype, vm, vd, vs2, vs1); + case 0b011: + return softvector::carry_mask_vector_vector_op<${vlen}, uint64_t>(V, funct, vl, vstart, vtype, vm, vd, vs2, vs1); + default: + throw new std::runtime_error("Unsupported sew bit value"); + } + } + void carry_mask_vector_imm_op(uint8_t* V, unsigned funct, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, unsigned vd, unsigned vs2, int64_t imm, uint8_t sew_val){ + switch(sew_val){ + case 0b000: + return softvector::carry_mask_vector_imm_op<${vlen}, uint8_t>(V, funct, vl, vstart, vtype, vm, vd, vs2, imm); + case 0b001: + return softvector::carry_mask_vector_imm_op<${vlen}, uint16_t>(V, funct, vl, vstart, vtype, vm, vd, vs2, imm); + case 0b010: + return softvector::carry_mask_vector_imm_op<${vlen}, uint32_t>(V, funct, vl, vstart, vtype, vm, vd, vs2, imm); + case 0b011: + return softvector::carry_mask_vector_imm_op<${vlen}, uint64_t>(V, funct, vl, vstart, vtype, vm, vd, vs2, imm); + default: + throw new std::runtime_error("Unsupported sew bit value"); + } + } void mask_vector_vector_op(uint8_t* V, unsigned funct, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, unsigned vd, unsigned vs2, unsigned vs1, uint8_t sew_val){ switch(sew_val){ case 0b000: diff --git a/src/vm/vector_functions.h b/src/vm/vector_functions.h index 12c42f9..c437a4c 100644 --- a/src/vm/vector_functions.h +++ b/src/vm/vector_functions.h @@ -81,6 +81,11 @@ void vector_imm_op(uint8_t* V, unsigned funct6, uint64_t vl, uint64_t vstart, vt template void vector_unary_op(uint8_t* V, unsigned unary_op, uint64_t vl, uint64_t vstart, vtype_t vtype, bool vm, unsigned vd, unsigned vs2); template +void carry_mask_vector_vector_op(uint8_t* V, unsigned funct, uint64_t vl, uint64_t vstart, vtype_t vtype, bool vm, unsigned vd, + unsigned vs2, unsigned vs1); +template +void carry_mask_vector_imm_op(uint8_t* V, unsigned funct, uint64_t vl, uint64_t vstart, vtype_t vtype, bool vm, unsigned vd, unsigned vs2, + typename std::make_signed::type imm); void mask_vector_vector_op(uint8_t* V, unsigned funct, uint64_t vl, uint64_t vstart, vtype_t vtype, bool vm, unsigned vd, unsigned vs2, unsigned vs1); template diff --git a/src/vm/vector_functions.hpp b/src/vm/vector_functions.hpp index ecc3e1c..88de862 100644 --- a/src/vm/vector_functions.hpp +++ b/src/vm/vector_functions.hpp @@ -194,7 +194,7 @@ void vector_imm_op(uint8_t* V, unsigned funct6, uint64_t vl, uint64_t vstart, vt } return; } -template std::function get_mask_funct(unsigned funct) { +template std::function get_carry_mask_funct(unsigned funct) { switch(funct) { case 0b010001: // VMADC return [](elem_t vs2, elem_t vs1, elem_t carry) { @@ -205,18 +205,18 @@ template std::function get_mask_ return vs2 < static_cast(vs1 + carry) || (vs1 == std::numeric_limits::max() && carry); }; default: - throw new std::runtime_error("Uknown funct in get_mask_funct"); + throw new std::runtime_error("Uknown funct in get_carry_mask_funct"); } } template -void mask_vector_vector_op(uint8_t* V, unsigned funct, uint64_t vl, uint64_t vstart, vtype_t vtype, bool vm, unsigned vd, unsigned vs2, - unsigned vs1) { +void carry_mask_vector_vector_op(uint8_t* V, unsigned funct, uint64_t vl, uint64_t vstart, vtype_t vtype, bool vm, unsigned vd, + unsigned vs2, unsigned vs1) { uint64_t elem_count = VLEN * vtype.lmul() / vtype.sew(); vmask_view mask_reg = read_vmask(V, elem_count); auto vs1_view = get_vreg(V, vs1, elem_count); auto vs2_view = get_vreg(V, vs2, elem_count); vmask_view vd_mask_view = read_vmask(V, elem_count, vd); - auto fn = get_mask_funct(funct); + auto fn = get_carry_mask_funct(funct); // elements w/ index smaller than vstart are in the prestart and get skipped // body is from vstart to min(elem_count, vl) for(unsigned idx = vstart; idx < std::min(elem_count, vl); idx++) { @@ -234,13 +234,13 @@ void mask_vector_vector_op(uint8_t* V, unsigned funct, uint64_t vl, uint64_t vst return; } template -void mask_vector_imm_op(uint8_t* V, unsigned funct, uint64_t vl, uint64_t vstart, vtype_t vtype, bool vm, unsigned vd, unsigned vs2, - typename std::make_signed::type imm) { +void carry_mask_vector_imm_op(uint8_t* V, unsigned funct, uint64_t vl, uint64_t vstart, vtype_t vtype, bool vm, unsigned vd, unsigned vs2, + typename std::make_signed::type imm) { uint64_t elem_count = VLEN * vtype.lmul() / vtype.sew(); vmask_view mask_reg = read_vmask(V, elem_count); auto vs2_view = get_vreg(V, vs2, elem_count); vmask_view vd_mask_view = read_vmask(V, elem_count, vd); - auto fn = get_mask_funct(funct); + auto fn = get_carry_mask_funct(funct); // elements w/ index smaller than vstart are in the prestart and get skipped // body is from vstart to min(elem_count, vl) for(unsigned idx = vstart; idx < std::min(elem_count, vl); idx++) { @@ -257,6 +257,100 @@ void mask_vector_imm_op(uint8_t* V, unsigned funct, uint64_t vl, uint64_t vstart } return; } +template std::function get_mask_funct(unsigned funct) { + switch(funct) { + case 0b011000: // VMSEQ + return [](elem_t vs2, elem_t vs1) { return vs2 == vs1; }; + case 0b011001: // VMSNE + return [](elem_t vs2, elem_t vs1) { return vs2 != vs1; }; + case 0b011010: // VMSLTU + return [](elem_t vs2, elem_t vs1) { return vs2 < vs1; }; + case 0b011011: // VMSLT + return [](elem_t vs2, elem_t vs1) { + return static_cast>(vs2) < static_cast>(vs1); + }; + case 0b011100: // VMSLEU + return [](elem_t vs2, elem_t vs1) { return vs2 <= vs1; }; + case 0b011101: // VMSLE + return [](elem_t vs2, elem_t vs1) { + return static_cast>(vs2) <= static_cast>(vs1); + }; + case 0b011110: // VMSGTU + return [](elem_t vs2, elem_t vs1) { return vs2 > vs1; }; + case 0b011111: // VMSGT + return [](elem_t vs2, elem_t vs1) { + return static_cast>(vs2) > static_cast>(vs1); + }; + + default: + throw new std::runtime_error("Uknown funct in get_mask_funct"); + } +} +template +void mask_vector_vector_op(uint8_t* V, unsigned funct, uint64_t vl, uint64_t vstart, vtype_t vtype, bool vm, unsigned vd, unsigned vs2, + unsigned vs1) { + uint64_t elem_count = VLEN * vtype.lmul() / vtype.sew(); + vmask_view mask_reg = read_vmask(V, elem_count); + auto vs1_view = get_vreg(V, vs1, elem_count); + auto vs2_view = get_vreg(V, vs2, elem_count); + vmask_view vd_mask_view = read_vmask(V, elem_count, vd); + auto fn = get_mask_funct(funct); + // elements w/ index smaller than vstart are in the prestart and get skipped + // body is from vstart to min(elem_count, vl) + for(unsigned idx = vstart; idx < std::min(elem_count, vl); idx++) { + bool mask_active = vm ? 1 : mask_reg[idx]; + if(mask_active) { + bool new_bit_value = fn(vs2_view[idx], vs1_view[idx]); + uint8_t* cur_mask_byte_addr = vd_mask_view.start + idx / 8; + unsigned cur_bit = idx % 8; + *cur_mask_byte_addr = *cur_mask_byte_addr & ~(1U << cur_bit) | static_cast(new_bit_value) << cur_bit; + } else { + uint8_t* cur_mask_byte_addr = vd_mask_view.start + idx / 8; + unsigned cur_bit = idx % 8; + *cur_mask_byte_addr = vtype.vma() ? *cur_mask_byte_addr : *cur_mask_byte_addr; + } + } + // elements w/ index larger than elem_count are in the tail (fractional LMUL) + // elements w/ index larger than vl are in the tail + for(unsigned idx = std::min(elem_count, vl); idx < VLEN; idx++) { + uint8_t* cur_mask_byte_addr = vd_mask_view.start + idx / 8; + unsigned cur_bit = idx % 8; + *cur_mask_byte_addr = vtype.vta() ? *cur_mask_byte_addr : *cur_mask_byte_addr; + } + return; +} +template +void mask_vector_imm_op(uint8_t* V, unsigned funct, uint64_t vl, uint64_t vstart, vtype_t vtype, bool vm, unsigned vd, unsigned vs2, + typename std::make_signed::type imm) { + uint64_t elem_count = VLEN * vtype.lmul() / vtype.sew(); + vmask_view mask_reg = read_vmask(V, elem_count); + auto vs2_view = get_vreg(V, vs2, elem_count); + vmask_view vd_mask_view = read_vmask(V, elem_count, vd); + auto fn = get_mask_funct(funct); + // elements w/ index smaller than vstart are in the prestart and get skipped + // body is from vstart to min(elem_count, vl) + for(unsigned idx = vstart; idx < std::min(elem_count, vl); idx++) { + bool mask_active = vm ? 1 : mask_reg[idx]; + if(mask_active) { + bool new_bit_value = fn(vs2_view[idx], imm); + uint8_t* cur_mask_byte_addr = vd_mask_view.start + idx / 8; + unsigned cur_bit = idx % 8; + *cur_mask_byte_addr = *cur_mask_byte_addr & ~(1U << cur_bit) | static_cast(new_bit_value) << cur_bit; + } else { + uint8_t* cur_mask_byte_addr = vd_mask_view.start + idx / 8; + unsigned cur_bit = idx % 8; + *cur_mask_byte_addr = vtype.vma() ? *cur_mask_byte_addr : *cur_mask_byte_addr; + } + } + // elements w/ index larger than elem_count are in the tail (fractional LMUL) + // elements w/ index larger than vl are in the tail + for(unsigned idx = std::min(elem_count, vl); idx < VLEN; idx++) { + uint8_t* cur_mask_byte_addr = vd_mask_view.start + idx / 8; + unsigned cur_bit = idx % 8; + *cur_mask_byte_addr = vtype.vta() ? *cur_mask_byte_addr : *cur_mask_byte_addr; + } + return; +} template std::function get_unary_fn(unsigned unary_op) { switch(unary_op) {