blob: 2212151528eff172a4f6af3d06786d89b59df6d5 [file] [log] [blame]
""" vec_test_helpers
This module is for reusable helper functions used by the templates.
"""
import collections
import enum
import re
import numpy as np
class VecTemplateHelper:
"""Given op and sew provide template with necessary parameters."""
class OperandType(enum.Enum):
"""RISC-V V operand type options."""
VECTOR = enum.auto()
SCALAR = enum.auto()
IMMEDIATE = enum.auto()
FLOATSCALAR = enum.auto()
class OperandWidth(enum.Enum):
"""RISC-V V operand width type option."""
STANDARD = enum.auto()
WIDENING = enum.auto()
NARROWING = enum.auto()
mnemonic_suffix = {
OperandType.VECTOR : {
OperandWidth.STANDARD: "vv",
OperandWidth.WIDENING: "vv",
OperandWidth.NARROWING: "wv",
},
OperandType.SCALAR : {
OperandWidth.STANDARD: "vx",
OperandWidth.WIDENING: "vx",
OperandWidth.NARROWING: "wx",
},
OperandType.IMMEDIATE : {
OperandWidth.STANDARD: "vi",
OperandWidth.WIDENING: "vi",
OperandWidth.NARROWING: "wi",
},
OperandType.FLOATSCALAR : {
OperandWidth.STANDARD: "vf",
OperandWidth.WIDENING: "vf",
OperandWidth.NARROWING: "wf",
},
}
"""Helper class for providing params for use in templates"""
def __init__(self, op_code, sew=None):
self._op_code = op_code
self._sew = sew
self.force_unsigned = False
self.signed_np_types = {
8:np.int8,
16:np.int16,
32:np.int32}
self.unsigned_np_types = {
8:np.uint8,
16:np.uint16,
32:np.uint32}
self.float_np_types = {
32:np.float32}
@property
def op_code(self):
"""Return the op_code."""
if self._op_code is None:
raise ValueError("OP CODE was not set.")
return self._op_code
@op_code.setter
def op_code(self, value):
"""Set the op_code"""
self._op_code = value
def is_floating(self):
"""check if a particular op_code is a floating type."""
if self.op_code[1] == 'm':
return self.op_code[2] == 'f'
return self.op_code[1] == 'f'
@property
def sew(self):
"""Return the selected element width."""
if self._sew is None:
raise ValueError("SEW was not set.")
return self._sew
@sew.setter
def sew(self, value):
"""Set the selected element width."""
if self.is_floating():
if not (value == 32):
raise ValueError("Invalid SEW")
if not value in (8, 16, 32):
raise ValueError("Invalid SEW")
self._sew = value
def is_widening(self):
"""Check if a particular op_code is a widening type."""
if self.is_floating():
raise ValueError("Widening is not supported with this template for floating point values")
return self.op_code[1] == 'w'
def is_narrowing(self):
"""Check if a particular op_code is a narrowing type."""
if self.is_floating():
raise ValueError("Narrowing is not supported with this template for floating point values")
return self.op_code[1] == 'n'
def is_destination_mask_register(self):
"""Check if a particular op_code has a mask output."""
if self.is_floating():
comparison_ops = ('vmfeq', 'vmfle', 'vmflt', 'vmfne', 'vmfgt', 'vmfge')
else:
comparison_ops = ('vmseq', 'vmsne', 'vmsltu', 'vmsleu', 'vmsle', 'vmsgtu', 'vmsgt')
return self.op_code in comparison_ops
def is_unsigned(self):
"""Check if a particular op_code is a unsigned type."""
if self.is_floating():
raise ValueError("Invalid unsigned type op code")
return self.op_code[-1] == 'u'
def get_sews(self):
"""Given an op_code return a list of valid element widths."""
if self.is_floating():
return [32]
if self.is_widening() or self.is_narrowing():
return [8, 16]
return [8, 16, 32]
def get_sew_sizes(self):
"""Return size of types.
imm is not used for floating point op codes.
"""
dest_sew = self.sew
src2_sew = self.sew
src1_sew = self.sew
imm_sew = self.sew
if not self.is_floating() and self.is_narrowing():
src2_sew = self.sew * 2
elif not self.is_floating() and self.is_widening():
dest_sew = self.sew * 2
return dest_sew, src2_sew, src1_sew, imm_sew
def get_var_types(self):
"""Return types for an op_code and element width.
imm_type won't be used for floating point values.
"""
VarTypes = collections.namedtuple(
"VarTypes",
('dest_type', 'src2_type', 'src1_type', 'imm_type'))
if self.is_floating():
"""dest_type is defined as int32_t instead of float
to use "set_bit_in_dest_mask" (in softrvv/include/softrvv_internal.h)
, which has bitwise operations in it.
"""
if self.is_destination_mask_register():
var_types = VarTypes("int32_t", "float", "float", "float")
else:
var_types = VarTypes("float", "float", "float", "float")
else:
type_fmt = "%sint%d_t"
sign_type = "u" if self.is_unsigned() or self.force_unsigned else ""
dest_sew, src2_sew, src1_sew, imm_sew = self.get_sew_sizes()
dest_type = type_fmt % (sign_type, dest_sew)
src1_type = type_fmt % (sign_type, src1_sew)
src2_type = type_fmt % (sign_type, src2_sew)
imm_type = type_fmt % (sign_type, imm_sew)
var_types = VarTypes(dest_type, src2_type, src1_type, imm_type)
return var_types
def get_mnemonic(self, operand_type):
"""Generate the correct mnemonic given a opcode and operand type."""
operand_width = self.OperandWidth.STANDARD
if self.is_floating():
if operand_type == self.OperandType.SCALAR:
operand_type = self.OperandType.FLOATSCALAR
else:
if self.is_narrowing():
operand_width = self.OperandWidth.NARROWING
elif self.is_widening():
operand_width = self.OperandWidth.WIDENING
op_suffix = self.mnemonic_suffix[operand_type][operand_width]
return "%s.%s" % (self.op_code, op_suffix)
def get_lmuls(self):
"""Given an op_code return an iterable of valid lmuls."""
if not self.is_floating():
if self.is_widening() or self.is_narrowing():
return [1, 2, 4]
return [1, 2, 4, 8]
@staticmethod
def get_sew_from_dtype(dtype):
"""Extract the selected element width from a data type."""
match = re.match(r"[a-z]+(?P<sew>[\d]+)", dtype)
return int(match['sew'])
def get_softrvv_template_data_type(self):
"""Return types """
var_types = self.get_var_types()
if not self.is_floating():
if self.is_narrowing() or self.is_widening():
return "%s, %s" % (var_types.dest_type, var_types.src2_type)
return var_types.src1_type
def get_ref_opcode(self):
"""Return the name of the reference code in the softrvv library."""
if self.is_floating():
return self.op_code
return self.op_code[:-1] if self.is_unsigned() else self.op_code
def get_imms(self):
"""Return a list of valid immediate values for a op code."""
if self.is_floating():
raise ValueError("imm is not available.")
if self.op_code in ['vsll', 'vsrl', 'vsra', 'vnsrl', 'vnsra']:
# Left and right shift immediates must be [0,31]
return np.linspace(0, 31, 8, dtype=np.int32)
# Immediate values must be [-16, 15]
return np.linspace(-16, 15, 7, dtype=np.int32)
def get_np_dest_type(self):
"""Return numpy type for destination."""
if self.is_floating():
return self.float_np_types[self.sew]
if self.force_unsigned:
types = self.unsigned_np_types
else:
types = self.signed_np_types
if self.is_widening():
return types[self.sew * 2]
return types[self.sew]
def get_np_src1_type(self):
"""Return numpy type for src1."""
if self.is_floating():
return self.float_np_types[self.sew]
if self.force_unsigned:
types = self.unsigned_np_types
else:
types = self.signed_np_types
return types[self.sew]
def get_np_src2_type(self):
"""Return numpy type for src2."""
if self.is_floating():
return self.float_np_types[self.sew]
if self.force_unsigned:
types = self.unsigned_np_types
else:
types = self.signed_np_types
if self.is_narrowing():
return types[self.sew * 2]
return types[self.sew]
def get_test_inputs(self, n=5, allow_zero=True): # pylint: disable=invalid-name
"""Return test inputs."""
src1_np_type = self.get_np_src1_type()
src2_np_type = self.get_np_src2_type()
src2_np_type = self.get_np_src2_type()
# Return test inputs for floating points.
if self.is_floating():
type_info = np.finfo(src1_np_type)
src1_data = np.random.uniform(
type_info.min, type_info.max, n).astype(src1_np_type)
rs1 = self.get_np_src1_type()(np.random.uniform(
type_info.min, type_info.max))
type_info = np.finfo(src2_np_type)
src2_data = np.random.uniform(
type_info.min, type_info.max, n).astype(src2_np_type)
if not allow_zero:
src2_data[src2_data==0] = 1
rs1 = 1.0 if rs1 == 0.0 else rs1
return src2_data, src1_data, rs1
# Return test inputs for integers.
type_info = np.iinfo(src1_np_type)
src1_data = np.random.randint(
type_info.min, type_info.max, n).astype(src1_np_type)
rs1 = self.get_np_src1_type()(np.random.randint(
type_info.min, type_info.max))
type_info = np.iinfo(src2_np_type)
src2_data = np.random.randint(
type_info.min, type_info.max, n).astype(src2_np_type)
if not allow_zero:
src2_data[src2_data==0] = 1
rs1 = 1 if rs1 == 0 else rs1
return src2_data, src1_data, rs1
def pack_dest_mask(self, values):
"""Pack values into a single destination register."""
dest_type = self.get_np_dest_type()
return np.packbits(dest_type(values), bitorder='little')
def cast_to_unsigned(arr):
"""Cast a signed array to an unsigned array.
This should not be called with floating point values.
"""
udtypes = {np.int8:np.uint8,
np.int16:np.uint16,
np.int32:np.uint32,
np.int64:np.uint64}
if not arr.dtype.type in udtypes.keys():
raise TypeError
return arr.astype(udtypes[arr.dtype.type])
def to_carr_str(arr):
"""Simple function for turn array into comma separated list."""
return ", ".join(("%s" % x for x in arr))