Changeset 1234


Ignore:
Timestamp:
Jul 28, 2011, 4:46:11 PM (8 years ago)
Author:
huah
Message:

Library Generator for SSE2

Location:
trunk/lib/libgen
Files:
5 added
1 deleted
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/lib/libgen/Library_Generator/BuiltIns.py

    r1188 r1234  
    2424                #return only the intrinsic of operation
    2525                        return self.builtInsTable[operation]["Pattern"]
    26                        
     26       
    2727        def IsOperationBuiltIn(self, operation):
    2828                '''Check whether this operation is a built-in operation
     
    3838                        return self.builtInsTable.has_key(operation)
    3939                return False
     40       
     41        def IsCompileTimeConstant(self, operation):
     42                '''Check if the built-in operation is a compile-time constant
     43                '''
     44                if isinstance(operation, Operation.Operation):
     45                        pattern = self.builtInsTable[operation.fullName]["Pattern"]
     46                        args = pattern[pattern.find("(")+1:]
     47                        if "arg" in args or "shift_mask" in args or "val1" in args:
     48                                return False
     49                        return True
     50                else:
     51                        return False
     52       
     53        def GetOperationReturnType(self, operation):
     54                '''Get the return type of the given operation
     55                '''
     56                if isinstance(operation, Operation.Operation):
     57                        return self.builtInsTable[operation.fullName]["returnType"]
     58                elif isinstance(operation, str):
     59                        return self.builtInsTable[operation]["returnType"]
     60                return None
  • trunk/lib/libgen/Library_Generator/CppTranslator.py

    r1188 r1234  
    1717                #calls store all the operations which are called by the current operation in the format of class_func_fw
    1818                self.calls = []
     19                #prevCall used to construct the tree structure of calling procedure
     20                self.prevCall = self.calls
     21                self.isCompileTimeConstant = True
     22               
     23                #print "cur strategy is ", strategyBody
    1924               
    2025                abstractSyntaxTree = ast.parse(strategyBody)
     
    3237                classType = ""
    3338                opName = ""
    34                 if "simd_" in funcName:
    35                         classType = "simd"
    36                         opName = funcName.replace('simd_', '')
    37                 elif "hsimd_" in funcName:
     39                if "hsimd_" in funcName:
    3840                        classType = "hsimd"
    3941                        opName = funcName.replace('hsimd_', '')
     
    4446                        classType = "mvmd"
    4547                        opName = funcName.replace('mvmd_', '')
     48                elif "simd_" in funcName:
     49                        classType = "simd"
     50                        opName = funcName.replace('simd_', '')
    4651                #print opName, " maps to ",
    4752                if opName == 'op':
    4853                        #This is a general operation which should be replaced by one of the strategy's applicable operations
    4954                        #print self.operation.classType + "_" + self.operation.name
    50                         return Utility.definedOperations[self.operation.classType + "_" + self.operation.name]
     55                        return Utility.definedOperations[self.operation.classType + "_" + self.operation.name][self.operation.fieldWidth]
    5156                elif opName == 'uop':
    5257                        #This is an unsigned version of the general operation
    5358                        #print self.operation.classType + "_" + "u" + self.operation.name
    54                         return Utility.definedOperations[self.operation.classType + "_" + "u" + self.operation.name]
    55                 else:
    56                         #This is a specific operation
     59                        return Utility.definedOperations[self.operation.classType + "_" + "u" + self.operation.name][self.operation.fieldWidth]
     60                else:
     61                        #This is a specific operation, field width is set to 1
    5762                        #print classType + "_" + opName
    58                         return Utility.definedOperations[classType + "_" + opName]
     63                        return Utility.definedOperations[classType + "_" + opName][1]
    5964
    6065        def Traverse(self, tree):
     
    8186                                        returnType = callRet["returnType"]
    8287                                else:
    83                                         print "This strategy can not be parsed!"
     88                                        print "This strategy can not be parsed and will be ignored!"
    8489                                        return {"codes":None, "returnType":None}
    8590                        else:
     
    100105                        codes += "\t" + self.Traverse(statement)["codes"] + ";\n"
    101106                return {"codes":codes, "returnType":ModuleType}
     107       
     108        def GetReturnType(self, returnType):
     109                #print "cur return type = ", returnType
     110                if returnType == IntType:
     111                        return "int"
     112                elif returnType == LongType:
     113                        return "long long"
     114                elif returnType == "SIMD_type":
     115                        return "SIMD_type"
     116                else:
     117                        return returnType
    102118       
    103119        def IsAssign(self, tree):
     
    114130                        returnType = valRet["returnType"]
    115131                        if returnType and (variableName not in self.variablesTable):
    116                                 codes += returnType + " "
     132                                codes += self.GetReturnType(returnType) + " "
    117133                                self.variablesTable[variableName] = returnType
    118134                        codes += variableName
     
    137153                '''
    138154                Process the tree node with conditional operator 'IfExp'
     155                Must consider the branches due to the 'IfExp'
     156                It ignores the cost of test branch while keeping body branch and oresle branch
    139157                '''
    140158               
    141159                testRet = self.Traverse(tree.test)
     160               
     161                #back up prevCall
     162                backupCall = self.prevCall
     163                self.prevCall.append([[], []])
     164               
     165                bodyCall = self.prevCall[-1][0]
     166                orelseCall = self.prevCall[-1][1]
     167               
     168                self.prevCall = bodyCall
    142169                bodyRet = self.Traverse(tree.body)
     170                self.prevCall = orelseCall
    143171                orBodyRet = self.Traverse(tree.orelse)
    144172               
     173                #restore the prevCall
     174                self.prevCall = backupCall
     175               
    145176                #codes = "(" + "(" + testCodes + ")" + " ? " + bodyCodes + " : " + orBodyCodes + ")"
    146177               
    147                 codes = "(" + testRet["codes"] + ")" + " ? " + bodyRet["codes"] + " : " + orBodyRet["codes"]
     178                codes = "(" + "(" + testRet["codes"] + ")" + " ? " + bodyRet["codes"] + " : " + orBodyRet["codes"] + ")"
    148179                returnType = bodyRet["returnType"]
    149180               
     
    175206                        codes = repr(self.operation.fieldWidth)
    176207                        returnType = IntType
     208                elif "curRegSize" == tree.id:
     209                        codes = repr(Utility.curRegisterSize)
     210                        returnType = IntType
    177211                else:
    178212                        codes = tree.id
     
    208242               
    209243                return {"codes":codes, "returnType":IntType}
     244       
     245        def CheckArgs(self, args):
     246                for arg in args:
     247                        if "arg" in str(arg) or "shift_mask" in str(arg) or "val1" in str(arg):
     248                                return False
     249                return True
    210250
    211251        def IsCall(self, tree):
     
    233273                        if op.opPattern == 0:
    234274                                codes += op.CallingStatementToCppText(argList[0], argList[1:])
    235                         else:
     275                                if self.isCompileTimeConstant == True:
     276                                        self.isCompileTimeConstant = self.CheckArgs(argList[1:])
     277                        elif op.opPattern == 1:
    236278                                codes += op.CallingStatementToCppText(argList[0], argList[2:], argList[1])
     279                                if self.isCompileTimeConstant == True:
     280                                        self.isCompileTimeConstant = self.CheckArgs(argList[2:])
     281                        elif op.opPattern == 2:
     282                                codes += op.CallingStatementToCppText(1, argList[0:])
     283                                if self.isCompileTimeConstant == True:
     284                                        self.isCompileTimeConstant = self.CheckArgs(argList[0:])
     285                       
    237286                        #Add the op into calls in the format of class_op_fw
    238                         self.calls.append(op.fullName + "_" + str(argList[0]))
     287                        if op.opPattern == 0 or op.opPattern == 1:
     288                                #self.calls.append(op.fullName + "_" + str(eval(argList[0])))
     289                                self.prevCall.append(op.fullName + "_" + str(eval(argList[0])))
     290                        elif op.opPattern == 2:
     291                                #logic operation always has field width 1
     292                                #self.calls.append(op.fullName + "_" + str(1))
     293                                self.prevCall.append(op.fullName + "_" + str(1))
    239294                else:
    240295                        #func is not a simd operation and then it must be one of functions specified in built-ins
    241296                        #print "else funcName", funcName
    242                         if Utility.builtIns.IsOperationBuiltIn(funcName) == False:
     297                        if Utility.builtIns.IsOperationBuiltIn(funcName) == False and Utility.functionSupport.has_key(funcName) == False:
    243298                                print "This function " + funcName + " is unknown!"
    244299                                return {"codes":None, "returnType":None}
     300                       
    245301                        codes = Utility.CallingStatement(funcName, argList)
    246                         returnType = "SIMD_type"
     302                        returnType = None
     303                        if Utility.builtIns.IsOperationBuiltIn(funcName) == True:
     304                                returnType = Utility.builtIns.GetOperationReturnType(funcName)
     305                        elif Utility.functionSupport.has_key(funcName) == True:
     306                                returnType = Utility.functionSupport[funcName]["returnType"]
     307                                Utility.usedFunctionSupport[funcName] = True
     308                       
     309                        if self.isCompileTimeConstant == True:
     310                                self.isCompileTimeConstant = self.CheckArgs(argList)
    247311                        #For other operations, just add its name as it is
    248                         self.calls.append(funcName)
     312                        #self.calls.append(funcName)
     313                        self.prevCall.append(funcName)
    249314                #print "func is " + codes + " with type ", returnType
    250315                return {"codes":codes, "returnType":returnType}
    251316               
    252 #if __name__ == "__main__":
    253 #       for op in configure.AllOperations:
    254 #               oop = Operation.Operation(configure.AllOperations[op], "SSE2")
    255 #               operationSet[oop.classType+"_"+oop.name] = oop
    256                 #print "add " + oop.classType+"_"+oop.name
    257 #       for st in StrategyPool.Strategies:
    258 #               sst = StrategyPool.Strategies[st]
    259 #               CppTranslator(sst["body"], operationSet["simd_add"], SSEInstruction.SSE2_BuiltIns)
    260 #               print "==================================================="
  • trunk/lib/libgen/Library_Generator/LibraryGenerator.py

    r1188 r1234  
    11import sys
    22
    3 import configure
    43import UI
    54import Utility
     5from Utility import configure
    66import Operation
    77import Strategy
     
    1010import OperationSetAnalyzer
    1111
    12 def Init(arch):
     12def Init(arch, lang):
    1313        '''Initialization work
    1414        '''
     
    3535        '''
    3636       
     37        #Get the size of current register
     38        Utility.curRegisterSize = configure.RegisterSize[arch]
     39       
     40        #Load function support
     41        Utility.functionSupport = Utility.LoadFunctionSupport(arch, lang)
     42       
    3743def main(args):
    3844        #print args
     
    4147        #print arch, lang
    4248       
    43         Init(arch)
     49        Init(arch, lang)
    4450
    4551        operationSet = OperationSet.LoadOperationSet(arch, lang)
  • trunk/lib/libgen/Library_Generator/Makefile

    r1188 r1234  
    33all:    $(SRCFILE)
    44        python $(SRCFILE) -sse2 -cpp
     5        rm -f *.out *.pyc
    56
    67clean: 
  • trunk/lib/libgen/Library_Generator/Operation.py

    r1188 r1234  
    22import sys
    33import traceback
     4import math
    45
    5 import configure
    66import Utility
     7from Utility import configure
    78
    89def LoadDefinedOperations(allOperations, arch):
    910        definedOperations = {}
    1011        for opName in allOperations:
     12                operationTmp = Operation(allOperations[opName], arch)
     13                definedOperations[operationTmp.fullName] = {}
     14                fws = Utility.GetValidFieldWidth(configure.RegisterSize[arch])
     15                for fw in fws:
    1116                        #Get an operation object given the information of operation description and architecture
    12                         operation = Operation(allOperations[opName], arch)
     17                        operation = Operation(allOperations[opName], arch, fw)
    1318                        #Add this operation object into the operationSet dictionary
    14                         definedOperations[operation.fullName] = operation
     19                        definedOperations[operation.fullName][fw] = operation
    1520        return definedOperations
    1621
     
    1924An operation contains operation name, field width, operation type, operation pattern, return type, arguments and template arguments.
    2025        '''
    21         def __init__(self, opDescription, arch):
     26        def __init__(self, opDescription, arch, fw=0):
    2227                '''
    23                 the constructor for class Operation
     28                the constructor for Operation
    2429                '''
    2530                self.name = ""
    26                 self.fieldWidth = 0
     31                self.arch = arch
     32                self.fieldWidth = fw
    2733                self.classType = ""
    2834                self.opPattern = -1
     
    3238                self.ParseOpDescription(opDescription, arch)
    3339                self.fullName = ""
     40                self.valueRange = {}
     41               
     42                #fullName looks like "class_op"
    3443                if self.classType not in self.name:
    3544                        self.fullName = self.classType + "_" + self.name
     
    3746                        self.fullName = self.name
    3847               
     48                #call GetValueRange after we get the value for fullName
     49                if fw > 0:
     50                        self.valueRange = self.GetValueRange(arch, fw)
     51       
     52        def GetValueRange(self, arch, fw):
     53                if self.fullName not in configure.ValueRanges:
     54                        return {}
     55                else:
     56                        valueRange = {}
     57                        for val in configure.ValueRanges[self.fullName]:
     58                                ranges = configure.ValueRanges[self.fullName][val]
     59                                minVal = eval(ranges[0].replace("fw", str(fw)).replace("curRegSize", str(configure.RegisterSize[arch])))
     60                                maxVal = eval(ranges[1].replace("fw", str(fw)).replace("curRegSize", str(configure.RegisterSize[arch])))
     61                                minVal = minVal if minVal>= -2**31 else -2*31
     62                                maxVal = maxVal if maxVal<= 2**31-1 else 2**31-1
     63                                valueRange[val] = {"min":minVal, "max":maxVal}
     64                        return valueRange
     65       
    3966        def ParseOpDescription(self, opDescription, arch):
    4067                r'''Parse the operation description string to get classType, opPattern and the list of arguments
     
    5582                        #print "At Operation -> ParseOpDescription:\n\tThe operation description = " +\
    5683                        #       opDescription + " is not valid.\n\tThe problems maybe '::' is not included or the class is not templated class."
    57                         traceback.print_exc()
    58                         sys.exit()
     84                        #traceback.print_exc()
     85                        #sys.exit()
     86                        #This operation has no class type which means it's a logic operation
     87                        pass
    5988               
    60                 funcMatchObj = re.search("([a-zA-Z_]+)<*([a-zA-Z]+)*>*\(", opDescription)
     89                funcMatchObj = re.search("([a-zA-Z_0-9]+)<*([a-zA-Z]+)*>*\(", opDescription)
    6190                #print funcMatchObj.group(0, 1, 2)
    6291                try:
    6392                        self.name = funcMatchObj.group(1)
    64                         if funcMatchObj.group(2):
     93                        if self.classType == "":
     94                        #This operation is a logic operation
     95                                self.opPattern = 2
     96                        elif funcMatchObj.group(2):
    6597                                self.opPattern = 1
    6698                                self.templateArg.type = "int"
     
    82114                                        argPart0 = re.search("[a-zA-Z_]+ ", arg).group().strip()
    83115                                        #argPart0 is the data type of the first argument. By now, only SIMD_type will be replaced.
    84                                         argPart0 = configure.SIMD_type[arch] if argPart0 == "SIMD_type" else argPart0
    85                                         argPart1 = re.search("[a-zA-Z_]+\s([a-zA-Z0-9&]+)", arg).group(1).strip()
    86                                         self.arguments.append( Utility.LibVariable("SIMD_type", argPart1) )
     116                                        #argPart0 = configure.SIMD_type[arch] if argPart0 == "SIMD_type" else argPart0
     117                                        argPart1 = re.search("[a-zA-Z_]+\s([a-zA-Z0-9_&]+)", arg).group(1).strip()
     118                                        #print argPart1
     119                                        self.arguments.append( Utility.LibVariable(argPart0, argPart1) )
    87120                                #print self.arguments
    88121                except Exception, e:
     
    91124       
    92125        def CallingPrefixToCppText(self):
     126                if self.opPattern == 2:
     127                #This is a logic operation, return its name as the calling prefix
     128                        return self.name
     129                       
    93130                cppText = self.classType + "<" + "$fw$" + ">" + "::" + self.name
    94131                if self.opPattern == 1:
     
    97134       
    98135        def CallingStatementToCppText(self, fw, args=[], templateArg=""):
    99                 #print "in args ", args, " self args", self.arguments, " cur op ", self.name
     136                #print "in args ", args, " self args", self.arguments, " cur op ", self.name, "curlen= ", len(args)
    100137                if len(args) != len(self.arguments):
    101138                        print "The operation " + self.classType + "::" + self.name + " doesn't accept this many arguments!"
     
    105142                if self.opPattern == 1:
    106143                        #simd<fw>::op<val>(...)
    107                         cppText += "<" + templateArg + ">"
     144                        cppText += "<" + str(templateArg) + ">"
     145                elif self.opPattern == 2:
     146                        cppText = self.name
    108147                cppText += "("
    109148                for arg in args:
    110149                        cppText += str(arg) + ", "
    111150                if len(args) > 0:
    112                 #if there are some arguments
     151                #if there is at least one argument
    113152                        cppText = cppText[0:len(cppText)-2]
    114153                cppText += ")"
  • trunk/lib/libgen/Library_Generator/OperationSet.py

    r1188 r1234  
     1import copy
    12
    23import BuiltIns
    34import Utility
    4 import configure
     5from Utility import configure
    56
    67def LoadOperationSet(arch, lang):
     
    2021               
    2122                for op in Utility.definedOperations:
    22                         operation = Utility.definedOperations[op]
    2323                        for fw in validFws:
    24                                 operation.fieldWidth = fw
     24                               
     25                                operation = Utility.definedOperations[op][fw]
     26                                #operation.fieldWidth = fw
    2527                                operationSet[operation.fullName + "_" + str(operation.fieldWidth)]  = []
    2628                                if Utility.builtIns.IsOperationBuiltIn(operation):
    2729                                        content = {}
    2830                                        content["body"] = "{\n" + "\treturn " + Utility.builtIns.PackAnOperation(operation) + ";\n" + "}\n"
    29                                         content["calls"] = [Utility.builtIns.PackAnOperation(operation)]
     31                                        content["calls"] = [operation]
     32                                        content["isCompileTimeConstant"] = Utility.builtIns.IsCompileTimeConstant(operation)
     33                                        #print operation.fullName + "_" + str(operation.fieldWidth), " calls have ", operation.fullName, operation.fieldWidth
    3034                                        operationSet[operation.fullName + "_" + str(operation.fieldWidth)].append(content)
    3135                                else:
    32                                 #Only Assemble the built-in operations at this moment
    33                                         continue
     36                                #Only assemble the built-in operations at this moment
     37                                        #continue
    3438                                        for strgyId in strategies:
    3539                                                strgy = strategies[strgyId]
    3640                                                if strgy.DoesStrategySupport(operation):
     41                                                        #print strgy.body, operation.fullName
    3742                                                        #If strgy supports this operation, we then translate    the strgy with operation
    3843                                                        content = strgy.Parse(operation, lang)
     44                                                       
    3945                                                        #Add the content returned by Translate routine into operationSet
    4046                                                        #The format of keys is class_name_fw
  • trunk/lib/libgen/Library_Generator/OperationSetAnalyzer.py

    r1188 r1234  
    11import sys
     2
     3import Utility
     4from Operation import *
    25
    36def Analyze(operationSet):
     
    1417                        self.optOpCount[opId] = self.opMaxCount
    1518                self.IterationAlgorithm(operationSet)
    16                        
     19       
     20        def CheckFunc(self, func):
     21                if  Utility.builtIns.IsOperationBuiltIn(func):
     22                        #The functions which are not shown up in the operationSet are supposed to be the built-ins
     23                        #The cost for each built-in is set to 1 at this moment
     24                        return 1
     25                elif Utility.functionSupport.has_key(func):
     26                        #each function in function support has cost of 0
     27                        return 0
     28                elif (func not in self.optOpCount) or (self.optOpCount[func] >= self.opMaxCount):
     29                        return self.opMaxCount
     30                else:
     31                        return self.optOpCount[func]
     32       
     33        def CheckIfElseBranch(self, branch):
     34                '''
     35                Find the maximum cost between if branch and else branch
     36                '''
     37                ifBranch = branch[0]
     38                ifCost = 0
     39                if len(ifBranch)<=0:
     40                        pass
     41                elif type(ifBranch[0]) != list:
     42                        for func in ifBranch:
     43                                ifCost += self.CheckFunc(func)
     44                else:
     45                        ifCost += self.CheckIfElseBranch(ifBranch)
     46
     47                elseBranch = branch[1]
     48                elseCost = 0
     49                if len(elseBranch) <= 0:
     50                        pass
     51                elif type(elseBranch[0]) != list:
     52                        for func in elseBranch:
     53                                elseCost += self.CheckFunc(func)
     54                else:
     55                        elseCost += self.CheckIfElseBranch(elseBranch[0])
     56               
     57                return ifCost if ifCost > elseCost else elseCost
     58       
    1759        def OneIteration(self, operationSet):
    1860                changed = False
     
    2163                                codes = opUnit["body"]
    2264                                calls = opUnit["calls"]
    23                                 #calls is empty, pass
     65                                isCompileTimeConstant = opUnit["isCompileTimeConstant"]
     66                               
     67                                opTotalNum = 0
     68                               
     69                                #calls is empty, cost should be 0
    2470                                if calls == None or len(calls) <= 0:
    25                                         continue
    26                                 opTotalNum = 0
    27                                 for func in calls:
    28                                         if func not in self.optOpCount:
    29                                         #The functions which are not shown up in the operationSet are supposed to be the built-ins
    30                                         #The cost for each built-in is set to 1 at this moment
    31                                                 opTotalNum += 1
    32                                         elif self.optOpCount[func] >= self.opMaxCount:
    33                                                 opTotalNum = self.opMaxCount
    34                                                 break
    35                                         else:
    36                                                 opTotalNum += self.optOpCount[func]
     71                                        opTotalNum = 0
     72                                #if it is compile time constant, set its cost to 0
     73                                elif isCompileTimeConstant == True:
     74                                        opTotalNum = 0
     75                                else:
     76                                        for func in calls:
     77                                                if type(func) != list:
     78                                                        opTotalNum += self.CheckFunc(func)
     79                                                else:
     80                                                        #we meet a if-else branch
     81                                                        opTotalNum += self.CheckIfElseBranch(func)
     82       
    3783                                if opTotalNum < self.optOpCount[class_op_fw]:
    3884                                        self.optOpCount[class_op_fw] = opTotalNum
  • trunk/lib/libgen/Library_Generator/SSEInstruction.py

    r1188 r1234  
     1from types import *
    12
    2 import configure
     3import Utility
     4from Utility import configure
    35
    46SSE2_BuiltIns = \
     
    810                "Pattern":"_mm_and_si128(arg1, arg2)",
    911                "Fws":[1],
     12                "returnType":"SIMD_type",
    1013        },
    1114        "simd_andc":\
     
    1316                "Pattern":"_mm_andnot_si128(arg2, arg1)",
    1417                "Fws":[1],
     18                "returnType":"SIMD_type",
    1519        },
    1620        "simd_or":\
     
    1822                "Pattern":"_mm_or_si128(arg1, arg2)",
    1923                "Fws":[1],
     24                "returnType":"SIMD_type",
    2025        },
    2126        "simd_xor":\
     
    2328                "Pattern":"_mm_xor_si128(arg1, arg2)",
    2429                "Fws":[1],
     30                "returnType":"SIMD_type",
    2531        },
    2632        "simd_add":\
     
    2834                "Pattern":"_mm_add_epi$fw$(arg1, arg2)",
    2935                "Fws":[8, 16, 32, 64],
     36                "returnType":"SIMD_type",
    3037        },
    3138        "simd_sub":\
     
    3340                "Pattern":"_mm_sub_epi$fw$(arg1, arg2)",
    3441                "Fws":[8, 16, 32, 64],
     42                "returnType":"SIMD_type",
    3543        },
    3644        "simd_umult":\
     
    3846                "Pattern":"_mm_mul_epu$fw$(arg1, arg2)",
    3947                "Fws":[32],
     48                "returnType":"SIMD_type",
    4049        },
    4150        "simd_mult":\
     
    4352                "Pattern":"_mm_mullo_epi$fw$(arg1, arg2)",
    4453                "Fws":[16],
     54                "returnType":"SIMD_type",
    4555        },
    4656        "simd_eq":\
     
    4858                "Pattern":"_mm_cmpeq_epi$fw$(arg1, arg2)",
    4959                "Fws":[8, 16, 32],
     60                "returnType":"SIMD_type",
    5061        },
    5162        "simd_gt":\
     
    5364                "Pattern":"_mm_cmpgt_epi$fw$(arg1, arg2)",
    5465                "Fws":[8, 16, 32],
     66                "returnType":"SIMD_type",
    5567        },
    5668        "simd_max":\
     
    5870                "Pattern":"_mm_max_epi$fw$(arg1, arg2)",
    5971                "Fws":[16],
     72                "returnType":"SIMD_type",
    6073        },
    6174        "simd_umax":\
     
    6376                "Pattern":"_mm_max_epu$fw$(arg1, arg2)",
    6477                "Fws":[8],
     78                "returnType":"SIMD_type",
    6579        },
    6680        "simd_min":\
     
    6882                "Pattern":"_mm_min_epi$fw$(arg1, arg2)",
    6983                "Fws":[16],
     84                "returnType":"SIMD_type",
    7085        },
    7186        "simd_umin":\
     
    7388                "Pattern":"_mm_min_epu$fw$(arg1, arg2)",
    7489                "Fws":[8],
    75         },
     90                "returnType":"SIMD_type",
     91        },
     92        #SSSE3 dependency
     93        #"simd_abs":\
     94        #{
     95        #       "Pattern":"_mm_abs_epi$fw$(arg1, arg2)",
     96        #       "Fws":[8, 16, 32],
     97        #},
    7698        "simd_srli":\
    7799        {
    78100                "Pattern":"_mm_srli_epi$fw$(arg1, sh)",
    79101                "Fws":[16, 32, 64],
    80         },
    81         "simd_srl":\
    82         {
    83                 "Pattern":"_mm_srl_epi$fw$(arg1, sh)",
    84                 "Fws":[16, 32, 64],
    85         },
     102                "returnType":"SIMD_type",
     103        },
     104        #"simd_srl":\
     105        #{
     106        #       "Pattern":"_mm_srl_epi$fw$(arg1, sh)",
     107        #       "Fws":[16, 32, 64],
     108        #},
    86109        "simd_slli":\
    87110        {
    88111                "Pattern":"_mm_slli_epi$fw$(arg1, sh)",
    89112                "Fws":[16, 32, 64],
    90         },
    91         "simd_sll":\
    92         {
    93                 "Pattern":"_mm_sll_epi$fw$(arg1, sh)",
    94                 "Fws":[16, 32, 64],
    95         },
     113                "returnType":"SIMD_type",
     114        },
     115        #"simd_sll":\
     116        #{
     117        #       "Pattern":"_mm_sll_epi$fw$(arg1, sh)",
     118        #       "Fws":[16, 32, 64],
     119        #},
    96120        "simd_srai":\
    97121        {
    98122                "Pattern":"_mm_srai_epi$fw$(arg1, sh)",
    99123                "Fws":[16, 32],
    100         },
    101         "simd_sra":\
    102         {
    103                 "Pattern":"_mm_sra_epi$fw$(arg1, sh)",
    104                 "Fws":[16, 32],
    105         },
     124                "returnType":"SIMD_type",
     125        },
     126        #"simd_sra":\
     127        #{
     128        #       "Pattern":"_mm_sra_epi$fw$(arg1, sh)",
     129        #       "Fws":[16, 32],
     130        #},
    106131        "simd_constant":\
    107132        {
    108133                "Pattern":"_mm_set1_epi$fw$(val)",
    109134                "Fws":[8, 16, 32],
     135                "returnType":"SIMD_type",
    110136        },
    111137        "hsimd_packus":\
    112138        {
    113                 "Pattern":"_mm_packus_epi$fw$(arg1, arg2)",
    114                 "Fws":[16],
     139                "Pattern":"_mm_packus_epi$fw$(arg2, arg1)",
     140                "Fws":[16],
     141                "returnType":"SIMD_type",
    115142        },
    116143        "hsimd_packss":\
    117144        {
    118                 "Pattern":"_mm_packs_epi$fw$(arg1, arg2)",
    119                 "Fws":[16, 32],
     145                "Pattern":"_mm_packs_epi$fw$(arg2, arg1)",
     146                "Fws":[16, 32],
     147                "returnType":"SIMD_type",
     148        },
     149        "hsimd_signmask":\
     150        {
     151                "Pattern":"_mm_movemask_epi$fw$(arg1)",
     152                "Fws":[8],
     153                "returnType":IntType,
    120154        },
    121155        "esimd_mergeh":\
     
    123157                "Pattern":"_mm_unpackhi_epi$fw$(arg2, arg1)",
    124158                "Fws":[8, 16, 32, 64],
     159                "returnType":"SIMD_type",
    125160        },
    126161        "esimd_mergel":\
     
    128163                "Pattern":"_mm_unpacklo_epi$fw$(arg2, arg1)",
    129164                "Fws":[8, 16, 32, 64],
    130         },
    131         "esimd_multh":\
    132         {
    133                 "Pattern":"_mm_mulhi_epi$fw$(arg1, arg2)",
    134                 "Fws":[16],
    135         },
    136         "esimd_multl":\
    137         {
    138                 "Pattern":"_mm_mullo_epi$fw$(arg1, arg2)",
    139                 "Fws":[16],
     165                "returnType":"SIMD_type",
     166        },
     167#       "esimd_multh":\
     168#       {
     169#               "Pattern":"_mm_mulhi_epi$fw$(arg1, arg2)",
     170#               "Fws":[16],
     171#       },
     172#       "esimd_multl":\
     173#       {
     174#               "Pattern":"_mm_mullo_epi$fw$(arg1, arg2)",
     175#               "Fws":[16],
     176#       },
     177        "mvmd_fill":\
     178        {
     179                "Pattern":"_mm_set1_epi$fw$(val1)",
     180                "Fws":[8, 16, 32],
     181                "returnType":"SIMD_type",
     182        },
     183        "mvmd_fill4":\
     184        {
     185                "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4)",
     186                "Fws":[32],
     187                "returnType":"SIMD_type",
     188        },
     189        "mvmd_fill8":\
     190        {
     191                "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4, val5, val6, val7, val8)",
     192                "Fws":[16],
     193                "returnType":"SIMD_type",
     194        },
     195        "mvmd_fill16":\
     196        {
     197                "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4, val5, val6, val7, val8, val9, val10, val11, val12, val13, val14, val15, val16)",
     198                "Fws":[8],
     199                "returnType":"SIMD_type",
    140200        },
    141201        "mvmd_shufflei":\
    142202        {
    143                 "Pattern":"_mm_shuffle_epi$fw$(arg1, val)",
    144                 "Fws":[32],
     203                "Pattern":"_mm_shuffle_epi$fw$(arg1, msk)",
     204                "Fws":[32],
     205                "returnType":"SIMD_type",
    145206        },
    146207        #SSSE3 dependency
     
    150211        #       "Fws":[8],
    151212        #},
     213        "_mm_sll_epi64":\
     214        {
     215                "Pattern":"_mm_sll_epi64(arg1, sh)",
     216                "Fws":[64],
     217                "returnType":"SIMD_type",
     218        },
    152219        "_mm_slli_si128":\
    153220        {
    154221                "Pattern":"_mm_slli_si128(arg1, arg2)",
    155222                "Fws":[128],
     223                "returnType":"SIMD_type",
     224        },
     225        "_mm_srl_epi64":\
     226        {
     227                "Pattern":"_mm_srl_epi64(arg1, sh)",
     228                "Fws":[64],
     229                "returnType":"SIMD_type",
    156230        },
    157231        "_mm_srli_si128":\
     
    159233                "Pattern":"_mm_srli_si128(arg1, arg2)",
    160234                "Fws":[128],
     235                "returnType":"SIMD_type",
    161236        },
    162237        "_mm_set_epi32":\
     
    164239                "Pattern":"_mm_set_epi32(val)",
    165240                "Fws":[32],
     241                "returnType":"SIMD_type",
    166242        },
    167243        "_mm_set1_epi32":\
     
    169245                "Pattern":"_mm_set1_epi32(val)",
    170246                "Fws":[32],
    171         },
     247                "returnType":"SIMD_type",
     248        },
     249        "_mm_cvtsi32_si128":\
     250        {
     251                "Pattern":"_mm_cvtsi32_si128(val)",
     252                "Fws":[128],
     253                "returnType":"SIMD_type",
     254        },
     255        "_mm_shufflehi_epi16":\
     256        {
     257                "Pattern":"_mm_shufflehi_epi16(arg1, msk)",
     258                "Fws":[16],
     259                "returnType":"SIMD_type",
     260        },
     261        "_mm_shufflelo_epi16":\
     262        {
     263                "Pattern":"_mm_shufflelo_epi16(arg1, msk)",
     264                "Fws":[16],
     265                "returnType":"SIMD_type",
     266        },
     267        "_MM_SHUFFLE":\
     268        {
     269                "Pattern":"_MM_SHUFFLE(pos1, pos2, pos3, pos4)",
     270                "Fws":[32],
     271                "returnType":IntType,
     272        }
    172273}
    173274
     
    266367        "simd_packus":\
    267368        {
    268                 "Pattern":"_mm_packus_epi$fw$(arg1, arg2)",
     369                "Pattern":"_mm_packus_epi$fw$(arg2, arg1)",
    269370                "Fws":[16, 32],
    270371        },
  • trunk/lib/libgen/Library_Generator/Strategy.py

    r1188 r1234  
    22
    33from StrategyPool import *
    4 import configure
     4import Utility
     5from Utility import configure
    56from CppTranslator import CppTranslator
    67
    78def LoadStrategies(arch):
    89        strategies = {}
    9         for strgyId in StrategyPool:
    10                 strategies[strgyId] = Strategy(StrategyPool[strgyId], arch)
     10        allStrategies = StrategyPool(configure.RegisterSize[arch])
     11        for strgyId in allStrategies:
     12                strategies[strgyId] = Strategy(allStrategies[strgyId], arch)
    1113        return strategies
    1214
     
    2426                if len(strategy["Fws"]) == 1:
    2527                        self.applicableFws = range(1, configure.RegisterSize[arch]+1) if strategy["Fws"][0] < 0 else range(strategy["Fws"][0], strategy["Fws"][0]+1)
    26                 elif len(strategy["Fws"]) == 2:
    27                         self.applicableFws = range(strategy["Fws"][0], strategy["Fws"][1]+1)
     28                elif len(strategy["Fws"]) >= 2:
     29                        self.applicableFws = strategy["Fws"]
    2830                else:
    29                         print "This strategy " + body + " is not well written!"
     31                        print "This strategy " + self.body + " is not well written!"
    3032       
    3133        def Parse(self, operation, lang):
     
    4446                parsedResult["body"] = translator.codes
    4547                parsedResult["calls"] = translator.calls
     48                parsedResult["isCompileTimeConstant"] = translator.isCompileTimeConstant
    4649
    4750                return parsedResult
  • trunk/lib/libgen/Library_Generator/StrategyPool.py

    r1188 r1234  
    11
    2 StrategyPool = \
    3 {
    4         #The below strategies have no specific meanings and are only for testing.
    5         "test1":\
     2def StrategyPool(curRegisterSize):
     3        strategies = \
    64        {
    7                 "body":r'''
    8 hiMask = simd_himask(2*fw)''',
     5                "in_place_if_doubling":\
     6                {
     7                "body":r'''
     8hiMask = simd_himask(2*fw)
     9return simd_ifh(1, hiMask, simd_op(2*fw, arg1, simd_and(hiMask, arg2)), simd_op(2*fw, arg1, arg2))''',
     10                "Ops":["simd_add", "simd_sub"],
     11                "Fws":[-1],
     12                },
     13       
     14                "in_place_hmask_post_lmask_pre":\
     15                {
     16                "body":r'''
     17hiMask = simd_himask(2*fw)
     18loMask = simd_lomask(2*fw)
     19return simd_or(simd_and(hiMask, simd_op(2*fw, arg1, arg2)), simd_op(2*fw, simd_and(loMask, arg1), simd_and(loMask, arg2)))''',
     20                "Ops":["simd_umax", "simd_umin"],
     21                "Fws":[-1],
     22                },
     23       
     24                "in_place_or_doubling":\
     25                {
     26                "body":r'''
     27hiMask = simd_himask(2*fw)
     28loMask = simd_lomask(2*fw)
     29return simd_or(simd_and(hiMask, simd_op(2*fw, simd_and(hiMask, arg1), simd_and(hiMask, arg2))), simd_and(loMask, simd_op(2*fw, simd_and(loMask, arg1), simd_and(loMask, arg2))))''',
     30                "Ops":["simd_eq", "simd_ugt", "simd_ult", "simd_umax", "simd_umin"],
     31                "Fws":[-1],
     32                },
     33       
     34                "in_place_sign_extension_doubling":\
     35                {
     36                "body":r'''
     37hiMask = simd_himask(2*fw)
     38loMask = simd_lomask(2*fw)
     39zero = simd_constant(2*fw, 0)
     40cMask = simd_constant(2*fw, 1<<(fw-1))
     41return simd_or(simd_op(2*fw, simd_and(hiMask, arg1), simd_and(hiMask, arg2)), simd_and(simd_op(2*fw, simd_or(simd_and(arg1, loMask), simd_sub(2*fw, zero, simd_and(cMask, arg1))), simd_or(simd_and(arg2, loMask), simd_sub(2*fw, zero, simd_and(cMask, arg2)))), loMask))''',
     42                "Ops":["simd_gt", "simd_lt", "simd_max", "simd_min"],
     43                "Fws":range(2, 32+1),
     44                },
     45       
     46                "shift_if_doubling":\
     47                {
     48                "body":r'''
     49hiMask = simd_himask(2*fw)
     50return simd_ifh(1, hiMask, simd_op(2*fw, simd_and(hiMask, arg1), simd_and(hiMask, arg2)), simd_srli(2*fw, fw, simd_op(2*fw, simd_slli(2*fw, fw, arg1), simd_slli(2*fw, fw, arg2))))''',
     51                "Ops":["simd_gt", "simd_lt", "simd_max", "simd_min"],
     52                "Fws":[-1],
     53                },
     54       
     55                "umult_doubling":\
     56                {
     57                "body":r'''
     58loMask = simd_lomask(2*fw)
     59tmpAns1 = simd_umult(2*fw, simd_and(loMask, arg1), simd_and(loMask, arg2))
     60tmpAns2 = simd_umult(2*fw, simd_and(loMask, simd_srli(4*fw, 2*fw, arg1)), simd_and(loMask, simd_srli(4*fw, 2*fw, arg2)))
     61return simd_or(tmpAns1, simd_slli(4*fw, 2*fw, tmpAns2))''',
     62                "Ops":["simd_umult"],
     63                "Fws":[-1],
     64                },
     65       
     66                "mult_doubling":\
     67                {
     68                "body":r'''
     69loMask = simd_lomask(2*fw)
     70tmpAns1 = simd_mult(2*fw, simd_and(loMask, arg1), simd_and(loMask, arg2))
     71tmpAns2 = simd_mult(2*fw, simd_srli(2*fw, fw, arg1), simd_srli(2*fw, fw, arg2))
     72return simd_ifh(1, loMask, tmpAns1, simd_slli(2*fw, fw, tmpAns2))''',
     73                "Ops":["simd_mult"],
     74                "Fws":[-1],
     75                },
     76       
     77                "umult_halving":\
     78                {
     79                "body":r'''
     80loMask1 = simd_lomask(2*fw)
     81arg11 = simd_and(arg1, loMask1)
     82arg22 = simd_and(arg2, loMask1)
     83loMask2 = simd_lomask(fw)
     84arg1_low = simd_and(arg11, loMask2)
     85arg1_high = simd_srli(fw, fw/2, arg11)
     86arg2_low = simd_and(arg22, loMask2)
     87arg2_high = simd_srli(fw, fw/2, arg22)
     88tmpAns1 = simd_umult(fw/2, arg1_low, arg2_low)
     89tmpAns2 = simd_slli(2*fw, fw/2, simd_umult(fw/2, arg1_low, arg2_high))
     90tmpAns3 = simd_slli(2*fw, fw/2, simd_umult(fw/2, arg1_high, arg2_low))
     91tmpAns4 = simd_slli(2*fw, fw, simd_umult(fw/2, arg1_high, arg2_high))
     92return simd_add(2*fw, tmpAns1, simd_add(2*fw, tmpAns2, simd_add(2*fw, tmpAns3, tmpAns4)))''',
     93                "Ops":["simd_umult"],
     94                "Fws":[-1],
     95                },
     96       
     97                "mult_halving":\
     98                {
     99                "body":r'''
     100loMask = simd_lomask(fw)
     101arg1_low = simd_and(arg1, loMask)
     102arg1_high = simd_srli(fw, fw/2, arg1)
     103arg2_low = simd_and(arg2, loMask)
     104arg2_high = simd_srli(fw, fw/2, arg2)
     105tmpAns1 = simd_umult(fw/2, arg1_low, arg2_low)
     106tmpAns2 = simd_slli(fw, fw/2, simd_umult(fw/2, arg1_low, arg2_high))
     107tmpAns3 = simd_slli(fw, fw/2, simd_umult(fw/2, arg1_high, arg2_low))
     108return simd_add(fw, tmpAns1, simd_add(fw, tmpAns2, tmpAns3))''',
     109                "Ops":["simd_mult"],
     110                "Fws":[-1],
     111                },
     112
     113                "add_halving":\
     114                {
     115                "body":r'''
     116ans = simd_add(fw/2, arg1, arg2)
     117carryMask = simd_or(simd_and(arg1, arg2), simd_and(simd_xor(arg1, arg2), simd_not(ans)))
     118loMask = simd_lomask(fw)
     119carry = simd_slli(fw, 1, simd_and(carryMask, loMask))
     120return simd_ifh(1, loMask, ans, simd_add(fw/2, ans, carry))''',
    9121                "Ops":["simd_add"],
    10122                "Fws":[-1],
    11         },
    12        
    13         "in_place_if_doubling":\
    14         {\
    15         "body":r'''
     123                },
     124
     125                "sub_halving":\
     126                {
     127                "body":r'''
     128ans = simd_sub(fw/2, arg1, arg2)
     129borrowMask = simd_or(simd_andc(arg2, arg1), simd_and(simd_not(simd_xor(arg1, arg2)), ans))
     130loMask = simd_lomask(fw)
     131borrow = simd_slli(fw, 1, simd_and(borrowMask, loMask))
     132return simd_ifh(1, loMask, ans, simd_sub(fw/2, ans, borrow))''',
     133                "Ops":["simd_sub"],
     134                "Fws":[-1],
     135                },
     136
     137                "eq_halving":\
     138                {
     139                "body":r'''
     140tmpAns = simd_eq(fw/2, arg1, arg2)
     141loMask = simd_and(tmpAns, simd_srli(fw, fw/2, tmpAns))
     142hiMask = simd_slli(fw, fw/2, loMask)
     143return simd_or(loMask, hiMask)''',
     144                "Ops":["simd_eq"],
     145                "Fws":[-1],
     146                },
     147       
     148                "gt_lt_halving":\
     149                {
     150                "body":r'''
     151hiAns = simd_op(fw/2, arg1, arg2)
     152loAns = simd_uop(fw/2, arg1, arg2)
     153mask = simd_and(loAns, simd_srli(fw, fw/2, simd_eq(fw/2, arg1, arg2)))
     154mask = simd_or(mask, simd_slli(fw, fw/2, mask))
     155return simd_or(simd_srai(fw, fw/2, hiAns), mask)''',
     156                "Ops":["simd_gt", "simd_lt"],
     157                "Fws":[-1],
     158                },
     159
     160                "ugt_ult_halving":\
     161                {
     162                "body":r'''
     163tmpAns = simd_op(fw/2, arg1, arg2)
     164mask = simd_and(tmpAns, simd_srli(fw, fw/2, simd_eq(fw/2, arg1, arg2)))
     165mask = simd_or(mask, simd_slli(fw, fw/2, mask))
     166return simd_or(simd_srai(fw, fw/2, tmpAns), mask)''',
     167                "Ops":["simd_ugt", "simd_ult"],
     168                "Fws":[-1],
     169                },
     170       
     171                "max_min_halving":\
     172                {
     173                "body":r'''
     174hiMask = simd_himask(fw)
     175hiAns = simd_op(fw/2, arg1, arg2)
     176loAns = simd_uop(fw/2, arg1, arg2)
     177eqMask1 = simd_srli(fw, fw/2, simd_eq(fw/2, hiAns, arg1))
     178eqMask2 = simd_srli(fw, fw/2, simd_eq(fw/2, hiAns, arg2))
     179return simd_ifh(1, hiMask, hiAns, simd_ifh(1, eqMask1, simd_ifh(1, eqMask2, loAns, arg1), arg2))''',
     180                "Ops":["simd_max", "simd_min"],
     181                "Fws":[-1],
     182                },
     183               
     184                "max_gt_blend":\
     185                {
     186                "body":r'''
     187return simd_ifh(1, simd_gt(fw, arg1, arg2), arg1, arg2)''',
     188                "Ops":["simd_max"],
     189                "Fws":[-1],
     190                },
     191               
     192                "max_lt_blend":\
     193                {
     194                "body":r'''
     195return simd_ifh(1, simd_lt(fw, arg1, arg2), arg2, arg1)''',
     196                "Ops":["simd_max"],
     197                "Fws":[-1],
     198                },
     199               
     200                "min_lt_blend":\
     201                {
     202                "body":r'''
     203return simd_ifh(1, simd_lt(fw, arg1, arg2), arg1, arg2)''',
     204                "Ops":["simd_min"],
     205                "Fws":[-1],
     206                },
     207               
     208                "min_gt_blend":\
     209                {
     210                "body":r'''
     211return simd_ifh(1, simd_gt(fw, arg1, arg2), arg2, arg1)''',
     212                "Ops":["simd_min"],
     213                "Fws":[-1],
     214                },
     215
     216                "umax_umin_halving":\
     217                {
     218                "body":r'''
     219hiMask = simd_himask(fw)
     220tmpAns = simd_op(fw/2, arg1, arg2)
     221eqMask1 = simd_srli(fw, fw/2, simd_eq(fw/2, tmpAns, arg1))
     222eqMask2 = simd_srli(fw, fw/2, simd_eq(fw/2, tmpAns, arg2))
     223return simd_ifh(1, hiMask, tmpAns, simd_ifh(1, eqMask1, simd_ifh(1, eqMask2, tmpAns, arg1), arg2))''',
     224                "Ops":["simd_umax", "simd_umin"],
     225                "Fws":[-1],
     226                },
     227
     228                "srai_halving":\
     229                {
     230                "body":r'''
     231hiMask = simd_himask(fw)
     232tmpAns = simd_and(hiMask, simd_srai(fw/2, sh, arg1))
     233gtMask = simd_gt(32, simd_constant(32, sh), simd_constant(32, fw/2))
     234return simd_or(tmpAns, simd_ifh(1, gtMask, simd_srai(fw/2, sh-(fw/2), simd_srli(fw, fw/2, arg1)), simd_srli(fw, sh, arg1)))''',
     235                "Ops":["simd_srai"],
     236                "Fws":[-1],
     237                },
     238       
     239                "ugt_blend":\
     240                {
     241                "body":r'''
     242tmp = simd_sub(fw, arg1, arg2)
     243mask = simd_not(simd_eq(fw, arg1, arg2))
     244nonBorrow = simd_or(simd_and(arg1, simd_not(arg2)), simd_and(simd_not(simd_xor(arg1, arg2)), simd_not(tmp)))
     245return simd_and(simd_srai(fw, fw-1, nonBorrow), mask)''',
     246                "Ops":["simd_ugt"],
     247                "Fws":[-1],
     248                },
     249       
     250                "lt_blend":\
     251                {
     252                "body":r'''
     253tmpAns = simd_not(simd_gt(fw, arg1, arg2))
     254mask = simd_not(simd_eq(fw, arg1, arg2))
     255return simd_and(tmpAns, mask)''',
     256                "Ops":["simd_lt"],
     257                "Fws":[-1],
     258                },
     259       
     260                "ult_blend":\
     261                {
     262                "body":r'''
     263tmp = simd_sub(fw, arg1, arg2)
     264mask = simd_not(simd_eq(fw, arg1, arg2))
     265borrow = simd_or(simd_and(simd_not(arg1), arg2), simd_and(simd_not(simd_xor(arg1, arg2)), tmp))
     266return simd_and(simd_srai(fw, fw-1, borrow), mask)''',
     267                "Ops":["simd_ult"],
     268                "Fws":[-1],
     269                },
     270               
     271                "abs_blend":\
     272                {
     273                "body":r'''
     274zero = simd_constant(fw, 0)
     275gtMask = simd_gt(fw, arg1, zero)
     276tmpAns = simd_sub(fw, gtMask, arg1)
     277return simd_ifh(1, gtMask, arg1, tmpAns)''',
     278                "Ops":["simd_abs"],
     279                "Fws":[-1]
     280                },
     281               
     282                "abs_halving":\
     283                {
     284                "body":r'''
     285tmpAbs = simd_ifh(1, simd_himask(fw), simd_abs(fw/2, arg1), arg1)
     286eqMask = simd_eq(fw, tmpAbs, arg1)
     287tmpAns = simd_sub(fw, eqMask, arg1)
     288return simd_ifh(1, eqMask, arg1, tmpAns)''',
     289                "Ops":["simd_abs"],
     290                "Fws":[-1]
     291                },
     292               
     293                "neg_blend":\
     294                {
     295                "body":r'''
     296return simd_sub(fw, simd_constant(fw, 0), arg1)''',
     297                "Ops":["simd_neg"],
     298                "Fws":[-1]
     299                },
     300       
     301                "srai_2_blend":\
     302                {
     303                "body":r'''
     304hiMask = simd_himask(2)
     305tmpAns = simd_or(simd_and(hiMask, arg1), simd_srli(fw, 1, arg1))
     306eqMask = simd_eq(32, simd_constant(32, sh), simd_constant(32, 0))
     307return simd_ifh(1, eqMask, arg1, tmpAns)''',
     308                "Ops":["simd_srai"],
     309                "Fws":[2],
     310                },
     311               
     312                "srai_2_blend_1":\
     313                {
     314                "body":r'''
     315hiMask = simd_himask(2)
     316tmpAns = simd_or(simd_and(hiMask, arg1), simd_srli(fw, 1, arg1))
     317return arg1 if sh==0 else tmpAns''',
     318                "Ops":["simd_srai"],
     319                "Fws":[2],
     320                },
     321               
     322                "srai_blend_subtract":\
     323                {
     324                "body":r'''
     325tmp = simd_srli(fw, (fw-1 if sh>=fw else 0 if sh<0 else sh), arg1)
     326return simd_or(tmp, simd_sub(fw, simd_constant(fw, 0), simd_and(simd_constant(fw, 1<<(fw-(fw-1 if sh>=fw else 0 if sh<0 else sh)-1)), tmp)))''',
     327                "Ops":["simd_srai"],
     328                "Fws":[2, 4, 8, 16, 32],
     329                },
     330               
     331                "srai_blend_substract_1":\
     332                {
     333                "body":r'''
     334tmp = simd_srli(fw, (fw-1 if sh>=fw else 0 if sh<0 else sh), arg1)
     335return simd_or(tmp, simd_sub(fw, simd_constant(fw, 0), simd_and(simd_slli(fw, (fw-(fw-1 if sh>=fw else 0 if sh<0 else sh)-1), simd_constant(fw, 1)), tmp)))''',
     336                "Ops":["simd_srai"],
     337                "Fws":[-1],
     338                },
     339
     340                "slli_increment_blend":\
     341                {
     342                "body":r'''
     343tmpAns = simd_slli(32, sh, arg1)
     344mask = simd_constant(fw, (((1<<fw)-1)<<sh)&((1<<fw)-1))
     345return simd_and(tmpAns, mask)''',
     346                "Ops":["simd_slli"],
     347                "Fws":[2, 4, 8],
     348                },
     349       
     350                "sll_64_blend":\
     351                {
     352                "body":r'''
     353hiMask = simd_himask(128)
     354return simd_ifh(1, hiMask, _mm_sll_epi64(arg1, _mm_srli_si128(shift_mask, 8)), _mm_sll_epi64(arg1, simd_andc(shift_mask, hiMask)))''',
     355                "Ops":["simd_sll"],
     356                "Fws":[64],
     357                },
     358               
     359                "sll_128_blend":\
     360                {
     361                "body":r'''
     362return simd_or(_mm_sll_epi64(arg1, shift_mask), simd_or(_mm_slli_si128(_mm_sll_epi64(arg1, simd_sub(32, shift_mask, _mm_cvtsi32_si128(64))), 8),  _mm_slli_si128(_mm_srl_epi64(arg1, simd_sub(32, _mm_cvtsi32_si128(64), shift_mask)), 8)))''',
     363                "Ops":["simd_sll"],
     364                "Fws":[128],
     365                },
     366               
     367                "slli_128_blend":\
     368                {
     369                "body":r'''
     370return  _mm_slli_si128(arg1, sh/8) if (sh%8==0) else (simd_slli(64, sh-64, _mm_slli_si128(arg1, 8)) if (sh>=64) else simd_or(simd_slli(64, sh, arg1), _mm_slli_si128(simd_srli(64, 64-sh, arg1), 8)))''',
     371                "Ops":["simd_slli"],
     372                "Fws":[128],
     373                },
     374               
     375                "srl_64_blend":\
     376                {
     377                "body":r'''
     378hiMask = simd_himask(128)
     379return simd_ifh(1, hiMask, _mm_srl_epi64(arg1, _mm_srli_si128(shift_mask, 8)), _mm_srl_epi64(arg1, simd_andc(shift_mask, hiMask)))''',
     380                "Ops":["simd_srl"],
     381                "Fws":[64],
     382                },
     383               
     384                "srl_128_blend":\
     385                {
     386                "body":r'''
     387return simd_or(_mm_srl_epi64(arg1, shift_mask), simd_or(_mm_srli_si128(_mm_srl_epi64(arg1, simd_sub(32, shift_mask, _mm_cvtsi32_si128(64))), 8),  _mm_srli_si128(_mm_sll_epi64(arg1, simd_sub(32, _mm_cvtsi32_si128(64), shift_mask)), 8)))''',
     388                "Ops":["simd_srl"],
     389                "Fws":[128],
     390                },
     391       
     392                "srli_increment_blend":\
     393                {
     394                "body":r'''
     395tmpAns = simd_srli(32, sh, arg1)
     396mask = simd_constant(fw, ((1<<fw)-1)>>sh)
     397return simd_and(tmpAns, mask)''',
     398                "Ops":["simd_srli"],
     399                "Fws":[2, 4, 8],
     400                },
     401       
     402                "srli_128_blend":\
     403                {
     404                "body":r'''
     405return  _mm_srli_si128(arg1, sh/8) if (sh%8==0) else (simd_srli(64, sh-64, _mm_srli_si128(arg1, 8)) if (sh>=64) else simd_or(simd_srli(64, sh, arg1), _mm_srli_si128(simd_slli(64, 64-sh, arg1), 8)))''',
     406                "Ops":["simd_srli"],
     407                "Fws":[128],
     408                },
     409       
     410                "not_blend":\
     411                {
     412                "body":r'''
     413return simd_xor(arg1, simd_constant(32, -1))''',
     414                "Ops":["simd_not"],
     415                "Fws":[1],
     416                },
     417       
     418                "nor_blend":\
     419                {
     420                "body":r'''
     421return simd_not(simd_or(arg1, arg2))''',
     422                "Ops":["simd_nor"],
     423                "Fws":[1],
     424                },
     425               
     426                "popcount_1_blend":\
     427                {
     428                "body":r'''
     429return arg1''',
     430                "Ops":["simd_popcount"],
     431                "Fws":[1]
     432                },
     433               
     434                "popcount_halving":\
     435                {
     436                "body":r'''
     437return simd_add_hl(fw, simd_popcount(fw/2, arg1))''',
     438                "Ops":["simd_popcount"],
     439                "Fws":[-1]
     440                },
     441               
     442                "ctz_blend":\
     443                {
     444                "body":r'''
     445return simd_popcount(fw, simd_andc(simd_sub(fw, arg1, simd_constant(fw, 1)), arg1))''',
     446                "Ops":["simd_ctz"],
     447                "Fws":range(2, curRegisterSize+1)
     448                },
     449               
     450                "ctz_1_blend":\
     451                {
     452                "body":r'''
     453return simd_not(arg1)''',
     454                "Ops":["simd_ctz"],
     455                "Fws":[1]
     456                },
     457       
     458                "if_1":\
     459                {
     460                "body":r'''
     461return simd_or(simd_and(arg2, arg1), simd_andc(arg3, arg1))''',
     462                "Ops":["simd_ifh"],
     463                "Fws":[1],
     464                },
     465               
     466                "if_blend":\
     467                {
     468                "body":r'''
     469gtMask = simd_gt(fw, simd_constant(fw, 0), arg1)
     470return simd_ifh(1, gtMask, arg2, arg3)''',
     471                "Ops":["simd_ifh"],
     472                "Fws":[-1]
     473                },
     474               
     475                "if_havling":\
     476                {
     477                "body":r'''
     478ifMask = simd_ifh(1, simd_himask(fw), arg1, simd_srli(fw, fw/2, arg1))
     479return simd_ifh(fw/2, ifMask, arg2, arg3)''',
     480                "Ops":["simd_ifh"],
     481                "Fws":[-1]
     482                },
     483
     484                "lomask_blend":\
     485                {
     486                "body":r'''
     487return simd_constant(fw, (1<<(fw/2))-1)''',
     488                "Ops":["simd_lomask"],
     489                "Fws":range(2, 32+1),
     490                },
     491
     492                "lomask_64_blend":\
     493                {
     494                "body":r'''
     495return _mm_set_epi32(0,-1, 0, -1)''',
     496                "Ops":["simd_lomask"],
     497                "Fws":[64],
     498                },
     499
     500                "lomask_128_blend":\
     501                {
     502                "body":r'''
     503return _mm_set_epi32(0, 0, -1, -1)''',
     504                "Ops":["simd_lomask"],
     505                "Fws":[128],
     506                },
     507
     508                "himask_blend":\
     509                {
     510                "body":r'''
     511return simd_constant(fw, (0-(1<<(fw/2)))&((1<<fw)-1))''',
     512                "Ops":["simd_himask"],
     513                "Fws":range(2, 16+1),
     514                },
     515
     516                "himask_32_blend":\
     517                {
     518                "body":r'''
     519return simd_constant(fw, -65536)''',
     520                "Ops":["simd_himask"],
     521                "Fws":[32],
     522                },
     523
     524                "himask_64_blend":\
     525                {
     526                "body":r'''
     527return _mm_set_epi32(-1, 0, -1, 0)''',
     528                "Ops":["simd_himask"],
     529                "Fws":[64],
     530                },
     531
     532                "himask_128_blend":\
     533                {
     534                "body":r'''
     535return _mm_set_epi32(-1, -1, 0, 0)''',
     536                "Ops":["simd_himask"],
     537                "Fws":[128],
     538                },
     539
     540                "constant_doubling":\
     541                {
     542                "body":r'''
     543return simd_constant(2*fw, (val<<fw)|(val^(-1<<fw))) if val<0 else simd_constant(2*fw, (val<<fw)|val)
     544''',
     545                "Ops":["simd_constant"],
     546                "Fws":range(2, 16+1),
     547                },
     548
     549                "constant_1_blend":\
     550                {
     551                #simd<1>::constant only accepts 0 or -1
     552                "body":r'''
     553return simd_constant(32, val)
     554''',
     555                "Ops":["simd_constant"],
     556                "Fws":[1],
     557                },
     558
     559                "constant_64_blend":\
     560                {
     561                "body":r'''
     562return _mm_set_epi32(0, val, 0, val) if val>=0 else _mm_set_epi32(-1, val, -1, val)
     563''',
     564                "Ops":["simd_constant"],
     565                "Fws":[64],
     566                },
     567       
     568                "constant_128_blend":\
     569                {
     570                "body":r'''
     571return _mm_set_epi32(0, 0, 0, val) if val>=0 else _mm_set_epi32(-1, -1, -1, val)
     572''',
     573                "Ops":["simd_constant"],
     574                "Fws":[128],
     575                },
     576
     577                "hsimd_add_hl":\
     578                {
     579                "body":r'''
     580return simd_add(fw/2, hsimd_packh(fw, arg1, arg2), hsimd_packl(fw, arg1, arg2))
     581''',
     582                "Ops":["hsimd_add_hl"],
     583                "Fws":[-1],
     584                },
     585               
     586                "simd_add_hl_2":\
     587                {
     588                "body":r'''
     589return simd_ifh(1, simd_himask(fw), simd_and(simd_slli(16, 1, arg1), arg1), simd_xor(simd_srli(16, 1, arg1), arg1))''',
     590                "Ops":["simd_add_hl"],
     591                "Fws":[2]
     592                },
     593               
     594                "simd_add_hl":\
     595                {
     596                "body":r'''
     597return simd_add(fw, simd_srli(fw, fw/2, arg1), simd_and(arg1, simd_lomask(fw)))
     598''',
     599                "Ops":["simd_add_hl"],
     600                "Fws":range(2, curRegisterSize+1),
     601                },
     602               
     603                "simd_xor_hl":\
     604                {
     605                "body":r'''
     606return simd_xor(simd_srli(fw, fw/2, arg1), simd_and(arg1, simd_lomask(fw)))
     607''',
     608                "Ops":["simd_xor_hl"],
     609                "Fws":[-1],
     610                },
     611               
     612                "hsimd_min_hl":\
     613                {
     614                "body":r'''
     615return simd_min(fw/2, hsimd_packh(fw, arg1, arg2), hsimd_packl(fw, arg1, arg2))''',
     616                "Ops":["hsimd_min_hl"],
     617                "Fws":[-1]
     618                },
     619               
     620                "hsimd_umin_hl":\
     621                {
     622                "body":r'''
     623return simd_umin(fw/2, hsimd_packh(fw, arg1, arg2), hsimd_packl(fw, arg1, arg2))''',
     624                "Ops":["hsimd_umin_hl"],
     625                "Fws":[-1]
     626                },
     627
     628                "packh_blend":\
     629                {
     630                "body":r'''
     631return hsimd_packl(fw, simd_srli(64, fw/2, arg1), simd_srli(64, fw/2, arg2))
     632''',
     633                "Ops":["hsimd_packh"],
     634                "Fws":range(2, 64+1),
     635                },
     636               
     637                "packh_packus_blend":\
     638                {
     639                "body":r'''
     640return hsimd_packus(fw, simd_srli(fw, fw/2, arg1), simd_srli(fw, fw/2, arg2))
     641''',
     642                "Ops":["hsimd_packh"],
     643                "Fws":[-1],
     644                },
     645               
     646                "packh_regSize_blend":\
     647                {
     648                "body":r'''
     649return simd_ifh(1, simd_himask(fw), arg1, simd_srli(fw, fw/2, arg2))
     650''',
     651                "Ops":["hsimd_packh"],
     652                "Fws":[curRegisterSize]
     653                },
     654
     655                "packl_double":\
     656                {
     657                "body":r'''
     658hiMask = simd_himask(fw)
     659return hsimd_packl(2*fw, simd_ifh(1, hiMask, simd_srli(128, fw/2, arg1), arg1), simd_ifh(1, hiMask, simd_srli(128, fw/2, arg2), arg2))
     660''',
     661                "Ops":["hsimd_packl"],
     662                "Fws":[-1],
     663                },
     664
     665                "packl_blend":\
     666                {
     667                "body":r'''
     668hiMask = simd_himask(fw)
     669return hsimd_packus(fw, simd_andc(arg1, hiMask), simd_andc(arg2, hiMask))
     670''',
     671                "Ops":["hsimd_packl"],
     672                "Fws":[-1],
     673                },
     674       
     675                "packl_64_blend":\
     676                {
     677                "body":r'''
     678hiMask = simd_himask(64)
     679return simd_or(mvmd_shufflei(32, shufflemask4(2,0,3,3), simd_andc(arg1, hiMask)), mvmd_shufflei(32, shufflemask4(3, 3, 2, 0), simd_andc(arg2, hiMask)))
     680''',
     681                "Ops":["hsimd_packl"],
     682                "Fws":[64]
     683                },
     684       
     685                "packl_regSize_blend":\
     686                {
     687                "body":r'''
     688hiMask = simd_himask(fw)
     689return simd_ifh(1, hiMask, simd_slli(fw, fw/2, arg1), arg2)
     690''',
     691                "Ops":["hsimd_packl"],
     692                "Fws":[curRegisterSize],
     693                },
     694               
     695                "packus_packl_blend":\
     696                {
     697                "body":r'''
     698zero = simd_constant(fw, 0)
     699loMask = simd_lomask(fw)
     700arg11 = simd_ifh(fw, arg1, zero, arg1)
     701arg12 = simd_and(loMask, arg11)
     702tmpArg1 = simd_ifh(1, simd_eq(fw, arg12, arg11), arg12, loMask)
     703arg21 = simd_ifh(fw, arg2, zero, arg2)
     704arg22 = simd_and(loMask, arg21)
     705tmpArg2 = simd_ifh(1, simd_eq(fw, arg22, arg21), arg22, loMask)
     706return hsimd_packl(fw, tmpArg1, tmpArg2)''',
     707                "Ops":["hsimd_packus"],
     708                "Fws":[-1],
     709                },
     710               
     711                "packus_blend":\
     712                {
     713                "body":r'''
     714zero = simd_constant(fw, 0)
     715hiPart = hsimd_packh(fw, arg1, arg2)
     716loPart = hsimd_packl(fw, arg1, arg2)
     717return simd_ifh(fw, hiPart, zero, simd_or(simd_gt(fw, hiPart, zero), loPart))''',
     718                "Ops":["hsimd_packus"],
     719                "Fws":[-1]
     720                },
     721               
     722                "packss_packl_blend":\
     723                {
     724                "body":r'''
     725hiBound = simd_srli(fw, 1, simd_lomask(fw))
     726loBound = simd_not(hiBound)
     727tmpArg1 = simd_ifh(1, simd_gt(fw, arg1, hiBound), hiBound, simd_ifh(1, simd_gt(fw, arg1, loBound), arg1, loBound))
     728tmpArg2 = simd_ifh(1, simd_gt(fw, arg2, hiBound), hiBound, simd_ifh(1, simd_gt(fw, arg2, loBound), arg2, loBound))
     729return hsimd_packl(fw, tmpArg1, tmpArg2)''',
     730                "Ops":["hsimd_packss"],
     731                "Fws":[-1]
     732                },
     733               
     734                "signmask_halving":\
     735                {
     736                "body":r'''
     737return hsimd_signmask(fw/2, hsimd_packh(fw, simd_constant(fw, 0), arg1))''',
     738                "Ops":["hsimd_signmask"],
     739                "Fws":[-1]
     740                },
     741               
     742                "signmask_doubling":\
     743                {
     744                "body":r'''
     745zero = simd_constant(fw, 0)
     746tmpAns1 = hsimd_signmask(2*fw, esimd_mergeh(fw, arg1, zero))
     747tmpAns2 = hsimd_signmask(2*fw, esimd_mergel(fw, arg1, zero))
     748return (tmpAns1<<(curRegSize/(2*fw))) + tmpAns2''',
     749                "Ops":["hsimd_signmask"],
     750                "Fws":range(curRegisterSize/32, curRegisterSize+1),
     751                },
     752                       
     753                "merge_doubling":\
     754                {
     755                "body":r'''
    16756hiMask = simd_himask(2*fw)
    17 return simd_if(1, hiMask, simd_op(2*fw, arg1, simd_and(1, hiMask, arg2)), simd_op(2*fw, arg1, arg2))''',\
    18         "Ops":["simd_add", "simd_sub"],\
    19         "Fws":[-1],\
    20         },
    21 
    22         "slli_128":\
    23         {
    24         "body":r'''
    25 return  _mm_slli_si128(arg1, sh/8) if (sh%8==0) else (simd_slli(64, sh-64, _mm_slli_si128(arg1, 8)) if (sh>=64) else simd_or(1, simd_slli(64, sh, arg1), _mm_slli_si128(simd_srli(64, 64-sh, arg1), 8)))''',\
    26         "Ops":["simd_slli"],\
    27         "Fws":[128],\
     757return esimd_op(2*fw, simd_ifh(1, hiMask, arg1, simd_srli(2*fw, fw, arg2)), simd_ifh(1, hiMask, simd_slli(2*fw, fw, arg1), arg2))
     758''',
     759                "Ops":["esimd_mergel", "esimd_mergeh"],
     760                "Fws":[-1],
     761                },
     762       
     763                "merge_havling":\
     764                {
     765                "body":r'''
     766hiMask = simd_himask(fw)
     767return esimd_op(fw/2, simd_ifh(1, hiMask, arg1, simd_srli(fw, fw/2, arg2)), simd_ifh(1, hiMask, simd_slli(fw, fw/2, arg1), arg2))
     768''',
     769                "Ops":["esimd_mergel", "esimd_mergeh"],
     770                "Fws":range(1, curRegisterSize/2),
     771                },
     772               
     773                "signextendh_blend":\
     774                {
     775                "body":r'''
     776tmpAns1 = simd_srai(2*fw, fw, arg1)
     777tmpAns2 = simd_srai(2*fw, fw, simd_slli(2*fw, fw, arg1))
     778return esimd_mergeh(2*fw, tmpAns1, tmpAns2)''',
     779                "Ops":["esimd_signextendh"],
     780                "Fws":range(1, curRegisterSize/2),
     781                },
     782               
     783                "singextendh_half_curRegSize_blend":\
     784                {
     785                "body":r'''
     786return simd_srai(2*fw, fw, arg1)''',
     787                "Ops":["esimd_signextendh"],
     788                "Fws":[curRegisterSize/2]
     789                },
     790               
     791                "signextendl_blend":\
     792                {
     793                "body":r'''
     794tmpAns1 = simd_srai(2*fw, fw, arg1)
     795tmpAns2 = simd_srai(2*fw, fw, simd_slli(2*fw, fw, arg1))
     796return esimd_mergel(2*fw, tmpAns1, tmpAns2)''',
     797                "Ops":["esimd_signextendl"],
     798                "Fws":range(1, curRegisterSize/2),
     799                },
     800               
     801                "singextendl_half_curRegSize_blend":\
     802                {
     803                "body":r'''
     804return simd_srai(2*fw, fw, simd_slli(2*fw, fw, arg1))''',
     805                "Ops":["esimd_signextendl"],
     806                "Fws":[curRegisterSize/2]
     807                },
     808               
     809                "zeroextendh_blend":\
     810                {
     811                "body":r'''
     812tmpAns1 = simd_srli(2*fw, fw, arg1)
     813tmpAns2 = simd_and(simd_lomask(2*fw), arg1)
     814return esimd_mergeh(2*fw, tmpAns1, tmpAns2)''',
     815                "Ops":["esimd_zeroextendh"],
     816                "Fws":range(1, curRegisterSize/2),
     817                },
     818               
     819                "zeroextendh_half_curRegSize_blend":\
     820                {
     821                "body":r'''
     822return simd_srli(2*fw, fw, arg1)''',
     823                "Ops":["esimd_zeroextendh"],
     824                "Fws":[curRegisterSize/2],
     825                },
     826               
     827                "zeroextendl_blend":\
     828                {
     829                "body":r'''
     830tmpAns1 = simd_srli(2*fw, fw, arg1)
     831tmpAns2 = simd_and(simd_lomask(2*fw), arg1)
     832return esimd_mergel(2*fw, tmpAns1, tmpAns2)''',
     833                "Ops":["esimd_zeroextendl"],
     834                "Fws":range(1, curRegisterSize/2),
     835                },
     836               
     837                "zeroextendl_half_curRegSize_blend":\
     838                {
     839                "body":r'''
     840return simd_and(simd_lomask(2*fw), arg1)''',
     841                "Ops":["esimd_zeroextendl"],
     842                "Fws":[curRegisterSize/2],
     843                },
     844               
     845                "fill_doubling":\
     846                {
     847                "body":r'''
     848return mvmd_fill(2*fw, (val1<<fw)|(val1^(-1<<fw))) if val1<0 else mvmd_fill(2*fw, (val1<<fw)|val1)
     849''',
     850                "Ops":["mvmd_fill"],
     851                "Fws":range(2, 16+1),
     852                },
     853
     854                "fill_1_blend":\
     855                {
     856                #mvmd<1>::fill only accepts 0 or -1
     857                "body":r'''
     858return mvmd_fill(32, val1)
     859''',
     860                "Ops":["mvmd_fill"],
     861                "Fws":[1],
     862                },
     863
     864                "fill_64_blend":\
     865                {
     866                "body":r'''
     867return _mm_set_epi32(0, val1, 0, val1) if val1>=0 else _mm_set_epi32(-1, val1, -1, val1)
     868''',
     869                "Ops":["mvmd_fill"],
     870                "Fws":[64],
     871                },
     872       
     873                "fill_128_blend":\
     874                {
     875                "body":r'''
     876return _mm_set_epi32(0, 0, 0, val1) if val1>=0 else _mm_set_epi32(-1, -1, -1, val1)
     877''',
     878                "Ops":["mvmd_fill"],
     879                "Fws":[128],
     880                },
     881               
     882                "fill2_blend":\
     883                {
     884                "body":r'''
     885return mvmd_fill(2*fw, (val1<<fw)|(val2&((1<<fw)-1)))''',
     886                "Ops":["mvmd_fill2"],
     887                "Fws":range(1, 16+1),
     888                },
     889               
     890                "fill2_himask_blend":\
     891                {
     892                "body":r'''
     893return simd_ifh(1, simd_himask(2*fw), mvmd_fill(fw, val1), mvmd_fill(fw, val2))''',
     894                "Ops":["mvmd_fill2"],
     895                "Fws":range(32, curRegisterSize/2+1),
     896                },
     897               
     898                "fill4_fill2_blend":\
     899                {
     900                "body":r'''
     901return simd_ifh(1, simd_himask(4*fw), mvmd_fill2(fw, val1, val2), mvmd_fill2(fw, val3, val4))''',
     902                "Ops":["mvmd_fill4"],
     903                "Fws":range(1, curRegisterSize/4+1),
     904                },
     905               
     906                "fill4_doubling":\
     907                {
     908                "body":r'''
     909return simd_or(mvmd_fill4(2*fw, val1<<fw, val3<<fw, val1<<fw, val3<<fw), mvmd_fill4(2*fw, val2&((1<<fw)-1), val4&((1<<fw)-1), val2&((1<<fw)-1), val4&((1<<fw)-1)))''',
     910                "Ops":["mvmd_fill4"],
     911                "Fws":range(1, curRegisterSize/8+1),
     912                },
     913               
     914                "fill8_fill4_blend":\
     915                {
     916                "body":r'''
     917return simd_ifh(1, simd_himask(8*fw), mvmd_fill4(fw, val1, val2, val3, val4), mvmd_fill4(fw, val5, val6, val7, val8))''',
     918                "Ops":["mvmd_fill8"],
     919                "Fws":range(1, curRegisterSize/8+1),
     920                },
     921               
     922                "fill8_doubling":\
     923                {
     924                "body":r'''
     925return simd_or(mvmd_fill8(2*fw, val1<<fw, val3<<fw, val5<<fw, val7<<fw, val1<<fw, val3<<fw, val5<<fw, val7<<fw), mvmd_fill8(2*fw, val2&((1<<fw)-1), val4&((1<<fw)-1), val6&((1<<fw)-1), val8&((1<<fw)-1), val2&((1<<fw)-1), val4&((1<<fw)-1), val6&((1<<fw)-1), val8&((1<<fw)-1)))''',
     926                "Ops":["mvmd_fill8"],
     927                "Fws":range(1, curRegisterSize/16+1),
     928                },
     929               
     930                "fill16_fill8_blend":\
     931                {
     932                "body":r'''
     933return simd_ifh(1, simd_himask(16*fw), mvmd_fill8(fw, val1, val2, val3, val4, val5, val6, val7, val8), mvmd_fill8(fw, val9, val10, val11, val12, val13, val14, val15, val16))''',
     934                "Ops":["mvmd_fill16"],
     935                "Fws":range(1, curRegisterSize/16+1),
     936                },
     937               
     938                "fill16_doubling":\
     939                {
     940                "body":r'''
     941return simd_or(mvmd_fill16(2*fw, val1<<fw, val3<<fw, val5<<fw, val7<<fw, val9<<fw, val11<<fw, val13<<fw, val15<<fw, val1<<fw, val3<<fw, val5<<fw, val7<<fw, val9<<fw, val11<<fw, val13<<fw, val15<<fw), mvmd_fill16(2*fw, val2&((1<<fw)-1), val4&((1<<fw)-1), val6&((1<<fw)-1), val8&((1<<fw)-1), val10&((1<<fw)-1), val12&((1<<fw)-1), val14&((1<<fw)-1), val16&((1<<fw)-1), val2&((1<<fw)-1), val4&((1<<fw)-1), val6&((1<<fw)-1), val8&((1<<fw)-1), val10&((1<<fw)-1), val12&((1<<fw)-1), val14&((1<<fw)-1), val16&((1<<fw)-1)))''',
     942                "Ops":["mvmd_fill16"],
     943                "Fws":range(1, curRegisterSize/32+1),
     944                },
     945               
     946                "splat_1_blend":\
     947                {
     948                "body":r'''
     949tmp = simd_and(simd_constant(curRegSize, 1), simd_srli(curRegSize, pos, arg1))
     950return simd_sub(curRegSize, simd_constant(curRegSize, 0), tmp)''',
     951                "Ops":["mvmd_splat"],
     952                "Fws":[1],
     953                },
     954               
     955                "splat_doubling":\
     956                {
     957                "body":r'''
     958tmpArg = simd_slli(2*fw, fw, arg1) if pos%2==0 else simd_srli(2*fw, fw, arg1)
     959arg11 = simd_and(simd_lomask(2*fw), arg1) if pos%2==0 else simd_and(simd_himask(2*fw), arg1)
     960return mvmd_splat(2*fw, pos/2, simd_or(tmpArg, arg11))''',
     961                "Ops":["mvmd_splat"],
     962                "Fws":range(1, curRegisterSize/2+1),
     963                },
     964               
     965                "splat_halving":\
     966                {
     967                "body":r'''
     968return simd_ifh(1, simd_himask(fw), mvmd_splat(fw/2, 2*pos+1, arg1), mvmd_splat(fw/2, 2*pos, arg1))''',
     969                "Ops":["mvmd_splat"],
     970                "Fws":range(2, curRegisterSize+1),
     971                },
     972               
     973                "splat_32_blend":\
     974                {
     975                "body":r'''
     976return mvmd_shufflei(32, shufflemask4(pos, pos, pos, pos), arg1)''',
     977                "Ops":["mvmd_splat"],
     978                "Fws":[32],
     979                },
     980               
     981                "mvmd_slli_blend":\
     982                {
     983                "body":r'''
     984return simd_slli(curRegSize, sh*fw, arg1)''',
     985                "Ops":["mvmd_slli"],
     986                "Fws":range(2, curRegisterSize+1),
     987                },
     988               
     989                "mvmd_srli_blend":\
     990                {
     991                "body":r'''
     992return simd_srli(curRegSize, sh*fw, arg1)''',
     993                "Ops":["mvmd_srli"],
     994                "Fws":range(2, curRegisterSize+1),
     995                },
     996               
     997                "shufflei_64_blend":\
     998                {
     999                "body":r'''
     1000return mvmd_shufflei(32, shufflemask4_from_shufflemask2(msk), arg1)''',
     1001                "Ops":["mvmd_shufflei"],
     1002                "Fws":[64],
     1003                },
     1004               
     1005                "shufflei_16_blend":\
     1006                {
     1007                "body":r'''
     1008tmphi = _mm_shufflehi_epi16(arg1, shufflemask8_to_shufflemask4(msk)>>8)
     1009tmpAns = _mm_shufflelo_epi16(tmphi, shufflemask8_to_shufflemask4(msk)&255)
     1010tmplh = _mm_shufflehi_epi16(simd_slli(128, 64, arg1), shufflemask8_to_shufflemask4(msk)>>8)
     1011tmphl = _mm_shufflelo_epi16(simd_srli(128, 64, arg1), shufflemask8_to_shufflemask4(msk)&255)
     1012a1 = 0 if ((msk>>21)&4)==0 else ((1<<(fw+1))-1)
     1013a2 = 0 if ((msk>>18)&4)==0 else ((1<<(fw+1))-1)
     1014a3 = 0 if ((msk>>15)&4)==0 else ((1<<(fw+1))-1)
     1015a4 = 0 if ((msk>>12)&4)==0 else ((1<<(fw+1))-1)
     1016a5 = ((1<<(fw+1))-1) if ((msk>>9)&4)==0 else 0
     1017a6 = ((1<<(fw+1))-1) if ((msk>>6)&4)==0 else 0
     1018a7 = ((1<<(fw+1))-1) if ((msk>>3)&4)==0 else 0
     1019a8 = ((1<<(fw+1))-1) if (msk&4)==0 else 0
     1020return simd_ifh(1, mvmd_fill8(fw, a1, a2, a3, a4, a5, a6, a7, a8), tmpAns, simd_or(tmplh, tmphl))''',
     1021                "Ops":["mvmd_shufflei"],
     1022                "Fws":[16],
     1023                },
     1024               
     1025                "dslli_blend":\
     1026                {
     1027                "body":r'''
     1028return simd_or(mvmd_slli(fw, sh, arg1), mvmd_srli(fw, curRegSize/fw-sh, arg2))''',
     1029                "Ops":["mvmd_dslli"],
     1030                "Fws":range(2, curRegisterSize+1),
     1031                },
     1032               
     1033                "dsrli_blend":\
     1034                {
     1035                "body":r'''
     1036return simd_or(mvmd_srli(fw, sh, arg1), mvmd_slli(fw, curRegSize/fw-sh, arg2))''',
     1037                "Ops":["mvmd_dsrli"],
     1038                "Fws":range(2, curRegisterSize+1),
     1039                },
     1040               
     1041                "shuffle_halving":\
     1042                {
     1043                "body":r'''
     1044tmp1 = simd_and(simd_constant(fw, curRegSize/fw-1), arg2)
     1045msk1 = simd_add(fw, tmp1, tmp1)
     1046msk2 = simd_add(fw, msk1, simd_constant(fw, 1))
     1047msk = simd_or(msk1, simd_slli(fw, fw/2, msk2))
     1048return simd_ifh(fw, arg2, simd_constant(fw, 0), mvmd_shuffle(fw/2, arg1, msk))''',
     1049                "Ops":["mvmd_shuffle"],
     1050                "Fws":range(2, curRegisterSize/2+1),
     1051                },
     1052               
     1053                "simd_add_2_logic":\
     1054                {
     1055                #f0 = (a1b1)^(a0^b0)
     1056                #f1 = a1^b1
     1057                "body":r'''
     1058tmp = simd_xor(arg1, arg2)
     1059return simd_ifh(1, simd_himask(fw), simd_xor(tmp, simd_slli(curRegSize, 1, simd_and(arg1, arg2))), tmp)''',
     1060                "Ops":["simd_add"],
     1061                "Fws":[2],
     1062                },
     1063               
     1064                "simd_sub_2_logic":\
     1065                {
     1066                "body":r'''
     1067tmp = simd_xor(arg1, arg2)
     1068return simd_ifh(1, simd_himask(fw), simd_xor(tmp, simd_slli(curRegSize, 1, simd_and(simd_not(arg1), arg2))), tmp)''',
     1069                "Ops":["simd_sub"],
     1070                "Fws":[2],
     1071                },
     1072               
     1073                "simd_mult_2_logic":\
     1074                {
     1075                "body":r'''
     1076tmp1 = simd_slli(curRegSize, 1, arg1)
     1077tmp2 = simd_slli(curRegSize, 1, arg2)
     1078return simd_ifh(1, simd_himask(fw), simd_or(simd_and(tmp1, simd_and(arg2, simd_or(simd_not(arg1), simd_not(tmp2)))), simd_and(arg1, simd_and(tmp2, simd_or(simd_not(tmp1), simd_not(arg2))))), simd_and(arg1, arg2))''',
     1079                "Ops":["simd_mult"],
     1080                "Fws":[2],
     1081                },
     1082               
     1083                "simd_eq_2_logic":\
     1084                {
     1085                "body":r'''
     1086tmp = simd_xor(arg1, arg2)
     1087tmpAns = simd_and(simd_not(simd_slli(curRegSize, 1, tmp)), simd_not(tmp))
     1088return simd_ifh(1, simd_himask(fw), tmpAns, simd_srli(curRegSize, 1, tmpAns))''',
     1089                "Ops":["simd_eq"],
     1090                "Fws":[2],
     1091                },
     1092               
     1093                "simd_gt_2_logic":\
     1094                {
     1095                "body":r'''
     1096tmp = simd_not(arg1)
     1097tmpAns = simd_or(simd_and(tmp, arg2), simd_and(simd_slli(curRegSize, 1, simd_and(arg1, simd_not(arg2))), simd_or(tmp, arg2)))
     1098return simd_ifh(1, simd_himask(fw), tmpAns, simd_srli(curRegSize, 1, tmpAns))''',
     1099                "Ops":["simd_gt"],
     1100                "Fws":[2],
     1101                },
     1102               
     1103                "simd_ugt_2_logic":\
     1104                {
     1105                "body":r'''
     1106tmp = simd_not(arg2)
     1107tmpAns = simd_or(simd_and(arg1, tmp), simd_and(simd_slli(curRegSize, 1, simd_and(arg1, tmp)), simd_or(arg1, tmp)))
     1108return simd_ifh(1, simd_himask(fw), tmpAns, simd_srli(curRegSize, 1, tmpAns))''',
     1109                "Ops":["simd_ugt"],
     1110                "Fws":[2],
     1111                },
     1112               
     1113                "simd_lt_2_logic":\
     1114                {
     1115                "body":r'''
     1116tmp = simd_not(arg2)
     1117tmpAns = simd_or(simd_and(arg1, tmp), simd_and(simd_slli(curRegSize, 1, simd_and(simd_not(arg1), arg2)), simd_or(arg1, tmp)))
     1118return simd_ifh(1, simd_himask(fw), tmpAns, simd_srli(curRegSize, 1, tmpAns))''',
     1119                "Ops":["simd_lt"],
     1120                "Fws":[2],
     1121                },
     1122               
     1123                "simd_ult_2_logic":\
     1124                {
     1125                "body":r'''
     1126tmp = simd_not(arg1)
     1127tmpAns = simd_or(simd_and(tmp, arg2), simd_and(simd_slli(curRegSize, 1, simd_and(tmp, arg2)), simd_or(tmp, arg2)))
     1128return simd_ifh(1, simd_himask(fw), tmpAns, simd_srli(curRegSize, 1, tmpAns))''',
     1129                "Ops":["simd_ult"],
     1130                "Fws":[2],
     1131                },
     1132               
     1133                "simd_max_2_logic":\
     1134                {
     1135                "body":r'''
     1136return simd_ifh(1, simd_himask(fw), simd_and(arg1, arg2), simd_or(simd_and(arg2, simd_srli(curRegSize, 1, simd_or(arg1, simd_not(arg2)))), simd_and(arg1, simd_srli(curRegSize, 1, simd_or(simd_not(arg1), arg2)))))''',
     1137                "Ops":["simd_max"],
     1138                "Fws":[2],
     1139                },
     1140               
     1141                "simd_umax_2_logic":\
     1142                {
     1143                "body":r'''
     1144return simd_ifh(1, simd_himask(fw), simd_or(arg1, arg2), simd_or(simd_and(arg2, simd_srli(curRegSize, 1, simd_or(simd_not(arg1), arg2))), simd_and(arg1, simd_srli(curRegSize, 1, simd_or(arg1, simd_not(arg2))))))''',
     1145                "Ops":["simd_umax"],
     1146                "Fws":[2],
     1147                },
     1148               
     1149                "simd_min_2_logic":\
     1150                {
     1151                "body":r'''
     1152tmp1 = simd_srli(curRegSize, 1, arg1)
     1153tmp2 = simd_srli(curRegSize, 1, arg2)
     1154return simd_ifh(1, simd_himask(fw), simd_or(arg1, arg2), simd_or(simd_and(arg1, simd_and(tmp1, simd_not(tmp2))), simd_and(arg2, simd_or(simd_and(simd_not(tmp1), tmp2), arg1))))''',
     1155                "Ops":["simd_min"],
     1156                "Fws":[2],
     1157                },
     1158               
     1159                "simd_umin_2_logic":\
     1160                {
     1161                "body":r'''
     1162tmp1 = simd_srli(curRegSize, 1, arg1)
     1163tmp2 = simd_srli(curRegSize, 1, arg2)
     1164return simd_ifh(1, simd_himask(fw), simd_and(arg1, arg2), simd_or(simd_and(simd_and(tmp1, simd_not(tmp2)), arg2), simd_and(arg1, simd_or(simd_and(simd_not(tmp1), tmp2), arg2))))''',
     1165                "Ops":["simd_umin"],
     1166                "Fws":[2],
     1167                },
     1168               
     1169                "simd_abs_2_logic":\
     1170                {
     1171                "body":r'''
     1172return simd_ifh(1, simd_himask(fw), simd_and(arg1, simd_slli(curRegSize, 1, simd_not(arg1))), arg1)''',
     1173                "Ops":["simd_abs"],
     1174                "Fws":[2],
     1175                },
     1176               
     1177                "simd_neg_2_logic":\
     1178                {
     1179                "body":r'''
     1180return simd_ifh(1, simd_himask(fw), simd_xor(arg1, simd_slli(curRegSize, 1, arg1)), arg1)''',
     1181                "Ops":["simd_neg"],
     1182                "Fws":[2],
     1183                },
     1184               
     1185                "simd_add_hl_2_logic":\
     1186                {
     1187                "body":r'''
     1188return simd_ifh(1, simd_himask(fw), simd_and(arg1, simd_slli(curRegSize, 1, arg1)), simd_xor(simd_srli(curRegSize, 1, arg1), arg1))''',
     1189                "Ops":["simd_add_hl"],
     1190                "Fws":[2],
     1191                },
     1192               
     1193                "simd_xor_hl_2_logic":\
     1194                {
     1195                "body":r'''
     1196return simd_and(simd_lomask(fw), simd_xor(simd_srli(curRegSize, 1, arg1), arg1))''',
     1197                "Ops":["simd_xor_hl"],
     1198                "Fws":[2],
     1199                },
     1200               
     1201                "simd_ctz_2_logic":\
     1202                {
     1203                "body":r'''
     1204tmp = simd_not(arg1)
     1205return simd_ifh(1, simd_himask(fw), simd_and(tmp, simd_slli(curRegSize, 1, tmp)), simd_and(simd_srli(curRegSize, 1, arg1), tmp))''',
     1206                "Ops":["simd_ctz"],
     1207                "Fws":[2],
     1208                },
     1209               
    281210        }
    29 
    30 }
     1211       
     1212        return strategies
  • trunk/lib/libgen/Library_Generator/UI.py

    r1188 r1234  
    11import sys
    2 
    3 import configure
     2import copy
     3
     4import Utility
    45import Operation
    5 import Utility
     6from Utility import configure
    67
    78#from OperationSet import neededOps, neededFws, logicOps
     
    7677        def __init__(self, operationSetResult, arch, lang):
    7778                self.WriteCodes(operationSetResult, arch, lang)
    78        
     79                self.WriteValidOperations(operationSetResult, arch)
     80               
    7981        def PreliminaryCodes(self, arch, lang):
    8082                codes = ""
     
    8789                        pass
    8890                elif lang == configure.Language_CPP:
     91                        codes += "#ifndef " + "_IDISA_" + arch.upper() + "_" + "H" + "\n"
     92                        codes += "#define " + "_IDISA_" + arch.upper() + "_" + "H" + "\n"
    8993                        codes += '''#include "''' + configure.InstructionSetLibrary[arch] + '''"\n\n'''
    9094                        codes += "typedef " + configure.SIMD_type[arch] + " SIMD_type;\n"
     
    119123                        operationDecla[classType] = {}
    120124                        for opName in Utility.definedOperations:
    121                                 operation = Utility.definedOperations[opName]
    122                                 if operation.classType == classType:
    123                                         curClass.Append( Utility.LibFunction(operation) )
    124                                         operationImp[classType][operation.fullName] = []
    125                                         operationDecla[classType][operation.fullName] = []
     125                                operationImp[classType][opName] = []
     126                                operationDecla[classType][opName] = []
     127                               
     128                                operationTmp = Utility.definedOperations[opName][1]
     129                               
     130                                if operationTmp.classType == classType:
     131                                        curClass.Append( Utility.LibFunction(operationTmp) )
    126132                                        for fw in Utility.GetValidFieldWidth(configure.RegisterSize[arch]):
     133                                                operation = Utility.definedOperations[opName][fw]
    127134                                                if optOpCount[operation.fullName + "_" + str(fw)] < opMaxCount:
    128                                                         operation.fieldWidth = fw
    129                                                         curOperation = Utility.LibFunction(operation, optOpCount[operation.fullName + "_" + str(fw)], optOpCodes[operation.fullName + "_" + str(fw)])
    130                                                         #curOperation.SetBodyContent(optOpCodes[operation.fullName + "_" + str(fw)])
    131                                                         operationImp[classType][operation.fullName].append(curOperation.ToCppText())
    132                                                         operationDecla[classType][operation.fullName].append(curOperation.FunctionDeclarationToCppText())
     135                                                                curOperation = Utility.LibFunction(operation, optOpCount[operation.fullName + "_" + str(fw)], optOpCodes[operation.fullName + "_" + str(fw)])
     136                                                                #curOperation.SetBodyContent(optOpCodes[operation.fullName + "_" + str(fw)])
     137                                                                operationImp[classType][operation.fullName].append(curOperation.ToCppText())
     138                                                                operationDecla[classType][operation.fullName].append(curOperation.FunctionDeclarationToCppText())
     139                                               
    133140                        fileOut.write(curClass.ToCppText())
    134141               
    135142                fileOut.write("//Declaration Part" + "\n")
     143                for opName in Utility.definedOperations:
     144                        operationTmp = Utility.definedOperations[opName][1]
     145                        if operationTmp.classType == "":
     146                        #logic operations
     147                                curOperation = Utility.LibFunction(operationTmp)
     148                                if optOpCount[operationTmp.fullName + "_" + str(1)] < opMaxCount:
     149                                        fileOut.write(curOperation.FunctionDeclarationToCppText() + ";\n")
     150                               
    136151                for classType in allClasses:
    137152                        for op in operationDecla[classType]:
    138153                                for decla in operationDecla[classType][op]:
    139154                                        fileOut.write(decla + ";\n")
    140                
    141155                fileOut.write("\n")
    142156               
    143157                fileOut.write("//Implementation Part" + "\n")
     158                #write pre-defined functions first
     159                for func in Utility.usedFunctionSupport:
     160                        fileOut.write(Utility.functionSupport[func]["body"] + "\n")
     161               
     162                for opName in Utility.definedOperations:
     163                        operationTmp = Utility.definedOperations[opName][1]
     164                        if operationTmp.classType == "" and optOpCount[operationTmp.fullName + "_" + str(1)] < opMaxCount:
     165                        #logic operations
     166                                curOperation = Utility.LibFunction(operationTmp, optOpCount[operationTmp.fullName + "_" + str(1)], optOpCodes[operationTmp.fullName + "_" + str(1)])
     167                                fileOut.write(curOperation.ToCppText() + "\n")
     168                               
    144169                for classType in allClasses:
    145170                        for op in operationImp[classType]:
     
    147172                                        fileOut.write(imp + "\n")
    148173               
     174                fileOut.write("#endif")                 
    149175                fileOut.close()
    150176               
     
    157183                #                       fileOut.write(imp)
    158184                #fileOut.close()
    159 
     185       
     186        def WriteValidOperations(self, operationSetResult, arch):
     187                fileOut = open("idisa"+"_"+arch.lower()+".db", 'w')
     188                (optOpCount, opMaxCount) = (operationSetResult.optOpCount, operationSetResult.opMaxCount)
     189               
     190                for opName in Utility.definedOperations:
     191                        thisOpName = ""
     192                        thisOpFws = []
     193                        thisOpCosts = []
     194                        for fw in Utility.GetValidFieldWidth(configure.RegisterSize[arch]):
     195                                operation = Utility.definedOperations[opName][fw]
     196                                if optOpCount[operation.fullName + "_" + str(fw)] < opMaxCount:
     197                                        thisOpName = operation.fullName
     198                                        thisOpFws.append(fw)
     199                                        thisOpCosts.append(optOpCount[operation.fullName + "_" + str(fw)])
     200                       
     201                        if thisOpName != "" :
     202                                fileOut.write(thisOpName+":\n")
     203                                fileOut.write("fw=")
     204                                for fw in thisOpFws:
     205                                        fileOut.write(str(fw) + " ")
     206                                fileOut.write("\n")
     207                                fileOut.write("cost=")
     208                                for cost in thisOpCosts:
     209                                        fileOut.write(str(cost) + " ")
     210                                fileOut.write("\n")
     211
     212                fileOut.close()
    160213'''
    161214if __name__ == "__main__":
  • trunk/lib/libgen/Library_Generator/Utility.py

    r1188 r1234  
     1import sys
     2
     3#import the configure module
     4sys.path.append("../")
     5import configure
    16
    27#This dictionary stores all the simd operations with class_func as the format for keys
    38#It should be initialized by Operation.GetDefinedOperations() at Main()
     9#{class_func:{fw1:operation1, fw2:operation2, ...}}
    410definedOperations = {}
    511
     
    1016#This is all the strategy instances created by Strategy.LoadStrategies() at Main()
    1117strategies = {}
     18
     19#It records the register size of current architecture
     20curRegisterSize = 0
     21
     22#it stores some functions which support codes generation
     23functionSupport = {}
     24
     25#used function support
     26usedFunctionSupport = {}
    1227
    1328#This is an interface for returning the calling statements of a function given its all arguments
     
    3247        return ret
    3348
    34 #####################################################################
     49#Load some pre-defined functions
     50def LoadFunctionSupport(arch, lang):
     51        retFuncs = {}
     52        allFuncs = {}
     53       
     54        if lang == configure.Language_C:
     55                pass
     56        elif lang == configure.Language_CPP:
     57                import CppFunctionSupport
     58                allFuncs = CppFunctionSupport.Functions
     59
     60        for func in allFuncs:
     61                if "all" in allFuncs[func]["platform"] or arch in allFuncs[func]["platform"]:
     62                        retFuncs[func] = allFuncs[func]
     63
     64        return retFuncs
     65       
    3566# This part is about definition of LibClass, LibFunction and LibVariable, in which,
    3667# LibClass is the class to describe general interfaces of classes(such as simd, hsimd, esimd, mvmd);
    3768# LibFunction is the class to describe general interfaces of functions(such as add, sub, pack, merge);
    3869# LibVariable is the class to describe general interfaces of variables(it only has two fields, variable type & name)
    39 #####################################################################
    4070class LibClass:
    4171        def __init__(self, name, body=[]):
     
    96126                        text += "inline " + self.returnType + " " + self.classType + "<" + str(self.fieldWidth) + ">" + "::" + self.name + "(" + self.ArgumentsToCppText() + ")"
    97127                elif self.opPattern == 1:
    98                         text += "template <" + self.templateArg.type + " " + self.templateArg.name + "> " + " inline " + self.returnType + " " + self.classType + "<" + str(self.fieldWidth) + ">" + "::" + self.name + "(" + self.ArgumentsToCppText() + ")"
     128                        text += "template <" + self.templateArg.type + " " + self.templateArg.name + ">" + " inline " + self.returnType + " " + self.classType + "<" + str(self.fieldWidth) + ">" + "::" + self.name + "(" + self.ArgumentsToCppText() + ")"
     129                elif self.opPattern == 2:
     130                        text = "inline " + self.returnType + " " + self.name + "(" + self.ArgumentsToCppText() + ")"
    99131                return text
    100132               
Note: See TracChangeset for help on using the changeset viewer.