kernel.py

#
# Copyright (c) 2017 Texas Instruments Incorporated
#
# All rights reserved not granted herein.
#
# Limited License.
#
# Texas Instruments Incorporated grants a world-wide, royalty-free, non-exclusive
# license under copyrights and patents it now or hereafter owns or controls to make,
# have made, use, import, offer to sell and sell ("Utilize") this software subject to the
# terms herein.  With respect to the foregoing patent license, such license is granted
# solely to the extent that any such patent is necessary to Utilize the software alone.
# The patent license shall not apply to any combinations which include this software,
# other than combinations with devices manufactured by or for TI ("TI Devices").
# No hardware patent is licensed hereunder.
#
# Redistributions must preserve existing copyright notices and reproduce this license
# (including the above copyright notice and the disclaimer and (if applicable) source
# code license limitations below) in the documentation and/or other materials provided
# with the distribution
#
# Redistribution and use in binary form, without modification, are permitted provided
# that the following conditions are met:
#
#       No reverse engineering, decompilation, or disassembly of this software is
# permitted with respect to any software provided in binary form.
#
#       any redistribution and use are licensed by TI for use only with TI Devices.
#
#       Nothing shall obligate TI to provide you with source code for the software
# licensed and provided to you in object code.
#
# If software source code is provided to you, modification and redistribution of the
# source code are permitted provided that the following conditions are met:
#
#       any redistribution and use of the source code, including any resulting derivative
# works, are licensed by TI for use only with TI Devices.
#
#       any redistribution and use of any object code compiled from the source code
# and any resulting derivative works, are licensed by TI for use only with TI Devices.
#
# Neither the name of Texas Instruments Incorporated nor the names of its suppliers
#
# may be used to endorse or promote products derived from this software without
# specific prior written permission.
#
# DISCLAIMER.
#
# THIS SOFTWARE IS PROVIDED BY TI AND TI'S LICENSORS "AS IS" AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL TI AND TI'S LICENSORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
# OF THE POSSIBILITY OF SUCH DAMAGE.
#
#

from . import *

class KernelParams :
    def __init__(self, index, type, direction, state, name, data_types=[],  do_map=True, do_unmap=True, do_map_unmap_all_planes=False):
        self.index = index
        self.type = type
        self.direction = direction
        self.state = state
        self.name_upper = name.upper()
        self.name_lower = name.lower()
        self.name_camel = toCamelCase(name)
        self.data_types = data_types
        self.do_map = do_map
        self.do_unmap = do_unmap
        self.do_map_unmap_all_planes = do_map_unmap_all_planes
        if Type.is_scalar_type(type) :
            self.do_map = False;
            self.do_unmap = False;

    def __str__(self):
        return "Param " + str(self.index) + ": " + self.name_upper + " " + Type.get_vx_enum_name(self.type) + " " + Direction.get_vx_enum_name(self.direction) + " " + ParamState.get_vx_enum_name(self.state)

class KernelParamRelationship :
    def __init__(self, prm_list, attribute_list, type, state):
        self.attribute_list = attribute_list
        self.prm_list = prm_list
        self.type = type
        self.state = state

    def __str__(self) :
        rel_str = "Param Relationship:\n"
        for param in self.prm_list :
            rel_str += '\t' + str(param) + "\n"
        for attr in self.attribute_list :
            rel_str += '\t' + str(attr) + "\n"
        return rel_str

class KernelLocalMem :
    def __init__(self, prm, attribute_list, name, state):
        self.attribute_list = attribute_list
        self.prm = prm
        self.state = state
        self.name = name

    def __str__(self):
        mem_str = "Local Mem:\n\t" + self.name + "\n"
        mem_str += '\t' + str(self.prm) + "\n"
        mem_str += '\t' + str(self.state) + "\n"
        for attr in self.attribute_list :
            mem_str += '\t' + str(attr) + "\n"
        return mem_str


class Kernel  :
    
    def __init__(self, name="default") :
        self.name_lower = name.lower()
        self.name_upper = name.upper()
        self.name_camel = toCamelCase(name)
        self.index = 0;
        self.params = []
        self.name_str_prefix = "com.ti."
        self.enum_str_prefix = "TIVX_KERNEL_"
        self.targets = []
        self.relationship_list = []
        self.relationship_list_index = 0
        self.local_mem_list = []
        self.local_mem_list_index = 0
        self.localMem = False
        self.local_mem_name_list = []
        self.parameter_name_list = []

    def setKernelPrefix(self, name_str_prefix, enum_str_prefix) :
        self.name_str_prefix = name_str_prefix
        self.enum_str_prefix = enum_str_prefix

    
    def setTarget(self, target) :
        self.targets.append(target)

    def __str__(self) :
        kernel_str = "Kernel: " + self.name_lower + " "+ self.name_upper + " "+ self.name_camel + "\n"
        kernel_str += "Targets: "
        for target in self.targets :
            if type(target) is Target :
                kernel_str += Target.get_vx_enum_name(target) + "(CPU: " + Cpu.get_vx_enum_name(Target.get_cpu(target)) + ") "
            else :
                sys.exit("target arguments have invalid type.")
        kernel_str += "\n"
        for prm in self.params :
            kernel_str += str(prm) + "\n"
        return kernel_str

    
    def setParameter(self, type, direction, state, name, data_types=[], do_map=True, do_unmap=True, do_map_unmap_all_planes=False):
        in_list = False

        if name in self.parameter_name_list :
            in_list = True
        else :
            self.parameter_name_list.append(name)

        assert in_list == False, "'%s' was already used as local memory name" % name

        params = KernelParams(self.index, type, direction, state, name, data_types, do_map, do_unmap, do_map_unmap_all_planes);
        self.params.append(params)
        self.index = self.index + 1

    
    def allocateLocalMemory(self, local_mem_name, attribute_list, parameter_name=""):
        self.localMem = True

        local_prm = Null()
        required = 0
        optional = 0
        first_required = 0
        in_list = False

        if local_mem_name in self.local_mem_name_list :
            in_list = True
        else :
            self.local_mem_name_list.append(local_mem_name)

        assert in_list == False, "'%s' was already used as local memory name" % local_mem_name

        # Get params from names
        if parameter_name :
            found = False
            for prm in self.params :
                if parameter_name.lower() == prm.name_lower :
                    if KernelExportCode.is_supported_type(self, prm.type):
                        local_prm = prm
                        found = True
                        break
            assert found == True, "'%s' was not found in image parameter list" % parameter_name

        if parameter_name :
            localmem = KernelLocalMem(local_prm, attribute_list, local_mem_name, local_prm.state)
        else :
            localmem = KernelLocalMem(local_prm, attribute_list, local_mem_name, ParamState.REQUIRED)
        self.local_mem_list.append(localmem)
        self.local_mem_list_index = self.local_mem_list_index + 1

    def getNumImages(self) :
        num_images = 0
        for prm in self.params :
            if prm.type == Type.IMAGE :
                num_images += 1
        return num_images

    def getNumRequiredImages(self) :
        num_images = 0
        for prm in self.params :
            if prm.type == Type.IMAGE and prm.state == ParamState.REQUIRED :
                num_images += 1
        return num_images

    def getNumOptionalImages(self) :
        num_images = 0
        for prm in self.params :
            if prm.type == Type.IMAGE and prm.state == ParamState.OPTIONAL :
                num_images += 1
        return num_images

    def getNumScalars(self) :
        num_scalars = 0
        for prm in self.params :
            if Type.is_scalar_type(prm.type) is True :
                num_scalars += 1
        return num_scalars

    def getNumInputImages(self) :
        num_input_images = 0
        for prm in self.params :
            if prm.type == Type.IMAGE and prm.direction == Direction.INPUT:
                num_input_images += 1
        return num_input_images

    def getNumRequiredInputImages(self) :
        num_input_images = 0
        for prm in self.params :
            if prm.type == Type.IMAGE and prm.direction == Direction.INPUT and prm.state == ParamState.REQUIRED :
                num_input_images += 1
        return num_input_images

    def getNumOutputImages(self) :
        num_output_images = 0
        for prm in self.params :
            if prm.type == Type.IMAGE and prm.direction == Direction.OUTPUT:
                num_output_images += 1
        return num_output_images

    def getNumRequiredOutputImages(self) :
        num_output_images = 0
        for prm in self.params :
            if prm.type == Type.IMAGE and prm.direction == Direction.OUTPUT and prm.state == ParamState.REQUIRED :
                num_output_images += 1
        return num_output_images

    
    def setParameterRelationship(self, name_list=[], attribute_list=["all"], type="equal") :
        assert len(name_list) > 1, "There should be more than 1 parameter in name_list"
        prm_list = []
        required = 0
        optional = 0
        first_required = 0

        # Get params from names
        for name in name_list :
            found = False
            for prm in self.params :
                if name.lower() == prm.name_lower :
                    prm_list.append(prm)
                    if prm.state == ParamState.REQUIRED :
                        if first_required == 0 :
                            first_required = prm
                        required += 1
                    elif prm.state == ParamState.OPTIONAL :
                        optional += 1
                    found = True
                    break
            assert found == True, "'%s' was not found in parameter list" % name

        # Divide list into multiple lists depending on if some of the parameters are optional or not
        if required > 1 :
            if optional == 0 :
                relationship = KernelParamRelationship(prm_list, attribute_list, type, ParamState.REQUIRED)
            else :
                sub_prm_list = []
                for prm in prm_list :
                    if prm.state == ParamState.REQUIRED :
                        sub_prm_list.append(prm)
                        prm_list.remove(prm)
                relationship = KernelParamRelationship(sub_prm_list, attribute_list, type, ParamState.REQUIRED)
            self.relationship_list.append(relationship)
            self.relationship_list_index = self.relationship_list_index + 1
        if required > 0 :
            while optional > 0 :
                optional -= 1
                sub_prm_list = []
                for prm in prm_list :
                    if prm.state == ParamState.OPTIONAL :
                        sub_prm_list.append(prm)
                        sub_prm_list.append(first_required)
                        relationship = KernelParamRelationship(sub_prm_list, attribute_list, type, ParamState.OPTIONAL)
                        self.relationship_list.append(relationship)
                        self.relationship_list_index = self.relationship_list_index + 1
                        prm_list.remove(prm)
                        break
        else :
            relationship = KernelParamRelationship(prm_list, attribute_list, type, ParamState.OPTIONAL)
            self.relationship_list.append(relationship)
            self.relationship_list_index = self.relationship_list_index + 1