Changeset 3436


Ignore:
Timestamp:
Aug 29, 2013, 1:33:03 PM (6 years ago)
Author:
linmengl
Message:

Checkin simd_and/all, avx2 support

Location:
trunk/libgen
Files:
6 added
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/libgen/Configure/IDISAOperations.py

    r2825 r3436  
    9999     "args_type":{"sh":"range(0, fw)", "arg1":"SIMD_type"},
    100100     "return_type":"SIMD_type",
    101      "cpp_class_signature":"template <uint8_t sh> static inline SIMD_type srli(SIMD_type arg1)",
     101     "cpp_class_signature":"template <uint16_t sh> static inline SIMD_type srli(SIMD_type arg1)",
    102102    },
    103103   
     
    114114     "args_type":{"sh":"range(0, fw)", "arg1":"SIMD_type"},
    115115     "return_type":"SIMD_type",
    116      "cpp_class_signature":"template <uint8_t sh> static inline SIMD_type slli(SIMD_type arg1)",
     116     "cpp_class_signature":"template <uint16_t sh> static inline SIMD_type slli(SIMD_type arg1)",
    117117    },
    118118   
     
    129129     "args_type":{"sh":"range(0, fw)", "arg1":"SIMD_type"},
    130130     "return_type":"SIMD_type",
    131      "cpp_class_signature":"template <uint8_t sh> static inline SIMD_type srai(SIMD_type arg1)",
     131     "cpp_class_signature":"template <uint16_t sh> static inline SIMD_type srai(SIMD_type arg1)",
    132132    },
    133133   
     
    154154    },
    155155   
     156    # simd_umult may be defined differently from ordinary sense, use with care.     
    156157    "simd_umult":\
    157158    {
     
    282283    },
    283284
     285    "simd_any":\
     286    {
     287     "signature":"SIMD_type simd<fw>::any(SIMD_type arg1)",
     288     "args_type":{"arg1":"SIMD_type"},
     289     "return_type":"SIMD_type",
     290    },
     291
     292    "simd_all":\
     293    {
     294     "signature":"SIMD_type simd<fw>::all(SIMD_type arg1)",
     295     "args_type":{"arg1":"SIMD_type"},
     296     "return_type":"SIMD_type",
     297    },
     298
    284299    #horizontal operations
    285300    "hsimd_add_hl":\
     
    337352     "args_type":{"arg1":"SIMD_type"},
    338353     "return_type":"unsigned_int(64)",
    339      "cpp_class_signature": "static inline typename FieldType<128/fw>::T signmask(SIMD_type arg1)"
     354     "cpp_class_signature": "static inline typename FieldType<regw/fw>::T signmask(SIMD_type arg1)"
    340355    },
    341356
     
    452467     "args_type":{"pos":"range(0, curRegSize/fw-1)", "arg1":"SIMD_type"},
    453468     "return_type":"SIMD_type",
    454      "cpp_class_signature":"template <uint8_t pos> static inline SIMD_type splat(SIMD_type arg1)"
     469     "cpp_class_signature":"template <uint16_t pos> static inline SIMD_type splat(SIMD_type arg1)"
    455470    },
    456471   
     
    460475     "args_type":{"sh":"range(0, curRegSize/fw)", "arg1":"SIMD_type"},
    461476     "return_type":"SIMD_type",
    462      "cpp_class_signature":"template <uint8_t sh> static inline SIMD_type slli(SIMD_type arg1)",
     477     "cpp_class_signature":"template <uint16_t sh> static inline SIMD_type slli(SIMD_type arg1)",
    463478    },
    464479   
     
    468483     "args_type":{"sh":"range(0, curRegSize/fw)", "arg1":"SIMD_type"},
    469484     "return_type":"SIMD_type",
    470      "cpp_class_signature":"template <uint8_t sh> static inline SIMD_type srli(SIMD_type arg1)",
     485     "cpp_class_signature":"template <uint16_t sh> static inline SIMD_type srli(SIMD_type arg1)",
    471486    },
    472487   
     
    483498     "args_type":{"sh":"range(0, curRegSize/fw)", "arg1":"SIMD_type", "arg2":"SIMD_type"},
    484499     "return_type":"SIMD_type",
    485      "cpp_class_signature":"template <uint8_t sh> static inline SIMD_type dslli(SIMD_type arg1, SIMD_type arg2)"
     500     "cpp_class_signature":"template <uint16_t sh> static inline SIMD_type dslli(SIMD_type arg1, SIMD_type arg2)"
    486501    },
    487502   
     
    491506     "args_type":{"sh":"range(0, curRegSize/fw)", "arg1":"SIMD_type", "arg2":"SIMD_type"},
    492507     "return_type":"SIMD_type",
    493      "cpp_class_signature":"template <uint8_t sh> static inline SIMD_type dsrli(SIMD_type arg1, SIMD_type arg2)",
     508     "cpp_class_signature":"template <uint16_t sh> static inline SIMD_type dsrli(SIMD_type arg1, SIMD_type arg2)",
    494509    },
    495510   
     
    529544     "args_type":{"arg1":"SIMD_type"},
    530545     "return_type":"unsigned_int(64)",
    531      "cpp_class_signature":"static inline uint8_t popcount(SIMD_type arg1)"
     546     "cpp_class_signature":"static inline uint16_t popcount(SIMD_type arg1)"
    532547    },
    533548   
     
    550565     "args_type":{"sh":"range(0, fw)", "arg1":"SIMD_type"},
    551566     "return_type":"SIMD_type",
    552      "cpp_class_signature":"template <uint8_t sh> static inline SIMD_type srli(SIMD_type arg1)",
     567     "cpp_class_signature":"template <uint16_t sh> static inline SIMD_type srli(SIMD_type arg1)",
    553568    },
    554569   
     
    558573     "args_type":{"sh":"range(0, fw)", "arg1":"SIMD_type"},
    559574     "return_type":"SIMD_type",
    560      "cpp_class_signature":"template <uint8_t sh> static inline SIMD_type slli(SIMD_type arg1)"
     575     "cpp_class_signature":"template <uint16_t sh> static inline SIMD_type slli(SIMD_type arg1)"
    561576    },
    562577    "bitblock_load_aligned":\
  • trunk/libgen/Configure/configure.py

    r2131 r3436  
    1919NEON = "NEON"
    2020AVX = "AVX"
     21AVX2 = "AVX2"
    2122ALL = "ALL"
    2223SSE_SERIES = [SSE, SSE2, SSE3, SSSE3, SSE4_1, SSE4_2]
     24AVX_SERIES = [AVX, AVX2]
    2325
    2426#Languages and architectures
     
    110112
    111113#Register sizes for different instruction sets
    112 RegisterSize = {MMX:64, SSE:128, SSE2:128, SSE3:128, SSSE3:128, SSE4:128, SSE4_a:128, SSE4_1:128, SSE4_2:128, NEON:128, AVX:256}
     114RegisterSize = {MMX:64, SSE:128, SSE2:128, SSE3:128, SSSE3:128, SSE4:128, SSE4_a:128, SSE4_1:128, SSE4_2:128, NEON:128, AVX:256, AVX2:256}
    113115
    114116#Instruction set library
    115117InstructionSetLibrary = {MMX:"mmintrin.h", SSE:"xmmintrin.h", SSE2:"emmintrin.h", SSE3:"pmmintrin.h",\
    116         SSSE3:"tmmintrin.h", SSE4_a:"ammintrin.h", SSE4_1:"smmintrin.h", SSE4_2:"smmintrin.h", NEON:"arm_neon.h", AVX:"immintrin.h"}
     118        SSSE3:"tmmintrin.h", SSE4_a:"ammintrin.h", SSE4_1:"smmintrin.h", SSE4_2:"smmintrin.h", NEON:"arm_neon.h", \
     119        AVX:"immintrin.h", AVX2:"immintrin.h"}
    117120#Imports
    118 ExtraImports = {AVX:["idisa_sse2.cpp"]}
    119 
     121ExtraImports = {AVX:["idisa_sse2.cpp"], AVX2:["idisa_sse2.cpp"]}
    120122
    121123#SIMD types in C/C++ for different instruction sets
    122 SIMD_type = {MMX:"__m64", SSE:"__m128i", SSE2:"__m128i", SSE3:"__m128i", SSSE3:"__m128i", SSE4_a:"__m128i", SSE4_1:"__m128i", SSE4_2:"__m128i", NEON:"uint64x2_t", AVX:"__m256"}
     124SIMD_type = {MMX:"__m64", SSE:"__m128i", SSE2:"__m128i", SSE3:"__m128i", SSSE3:"__m128i", SSE4_a:"__m128i", SSE4_1:"__m128i", SSE4_2:"__m128i", NEON:"uint64x2_t", \
     125        AVX:"__m256", AVX2:"__m256i"}
    123126
    124127Bitblock_type = {MMX:"bitblock64_t", SSE:"bitblock128_t", SSE2:"bitblock128_t", SSE3:"bitblock128_t", SSSE3:"bitblock128_t", SSE4_1:"bitblock128_t", SSE4_2:"bitblock128_t",
    125                                 NEON:"bitblock128_t", AVX:"bitblock256_t"}
     128                                NEON:"bitblock128_t", AVX:"bitblock256_t", AVX2:"bitblock256_t"}
    126129
    127130Load_type = {MMX:"bitblock64_t*", SSE:"bitblock128_t*", SSE2:"bitblock128_t*", SSE3:"bitblock128_t*", SSSE3:"bitblock128_t*", SSE4_1:"bitblock128_t*", SSE4_2:"bitblock128_t*",
    128                         NEON:"uint64_t const*", AVX:"bitblock256_t*"}
     131                        NEON:"uint64_t const*", AVX:"bitblock256_t*", AVX2:"bitblock256_t*"}
    129132
    130133Store_type = {MMX:"bitblock64_t*", SSE:"bitblock128_t*", SSE2:"bitblock128_t*", SSE3:"bitblock128_t*", SSSE3:"bitblock128_t*", SSE4_1:"bitblock128_t*", SSE4_2:"bitblock128_t*",
    131                         NEON:"uint64_t*", AVX:"bitblock256_t*"}
     134                        NEON:"uint64_t*", AVX:"bitblock256_t*", AVX2:"bitblock256_t*"}
    132135
    133136AVXBuiltInVecWrapper = "AVXBuiltInVecWrapper"
  • trunk/libgen/Library_Generator/CTranslator.py

    r1767 r3436  
    1313
    1414import Utility
     15import StandardTypes
     16from Utility import configure
    1517from Operation import Operation
     18from IDISAFunctionSupport import IDISAFunction
    1619
    1720class CTranslator:
     
    3134                self.isCompileTimeConstant = True
    3235               
    33                 #print "cur strategy is ", strategyBody
    34                
     36                #print "cur strategy is ", strategyBody 
     37
    3538                abstractSyntaxTree = ast.parse(strategyBody)
    3639                body = self.Traverse(abstractSyntaxTree)["codes"]
     
    123126                codes = ""
    124127                for statement in tree.body:
    125                         codes += "\t" + self.Traverse(statement)["codes"] + ";\n"
     128                        tmpCodes = self.Traverse(statement)["codes"]
     129                        if tmpCodes != None:
     130                                codes += "\t" + tmpCodes + ";\n"
     131                        else:
     132                                return {"codes":None, "returnType":ModuleType}
    126133                return {"codes":codes, "returnType":ModuleType}
    127134       
     
    129136                #print "cur return type = ", returnType
    130137                if returnType == IntType:
    131                         return "int"
     138                        return "uint32_t"
    132139                elif returnType == LongType:
    133                         return "long long"
     140                        return "uint64_t"
    134141                elif returnType == "SIMD_type":
    135                         return "SIMD_type"
     142                        return configure.Bitblock_type[self.operation.arch]
    136143                else:
    137144                        return returnType
     
    166173                        #(tmpCodes, returnType) = self.Traverse(tree.value)
    167174                        valRet = self.Traverse(tree.value)
    168                         codes += " " + valRet["codes"]
    169175                        returnType = valRet["returnType"]
     176                        if valRet["codes"] != None:
     177                                codes += " " + valRet["codes"]
     178                                returnType = valRet["returnType"]
     179                                return {"codes":codes, "returnType":returnType}
    170180                return {"codes":codes, "returnType":returnType}
    171181       
     
    240250                '''
    241251                codes = repr(tree.n)
    242                 return {"codes":codes, "returnType":IntType}
     252                returnType = StandardTypes.GetAppropriatePythonType(codes)
     253                return {"codes":self.CheckNumCodes(codes), "returnType":returnType}
     254
     255        def CheckNumCodes(self, codes):
     256                if codes[-1] == "L":
     257                        return codes[0:-1] + "ULL"
     258                elif int(codes) >= (1<<31):
     259                        return codes + "ULL"
     260                return codes
    243261
    244262        binop = {"Add":"+", "Sub":"-", "Mult":"*", "Div":"/", "Mod":"%",\
     
    253271                codes += self.binop[tree.op.__class__.__name__]
    254272                codes += self.Traverse(tree.right)["codes"]
    255                
     273
    256274                try:
    257275                        codes = repr(eval(codes))
     276                        codes = self.CheckNumCodes(codes)
    258277                except:
    259278                        pass
    260                
     279
    261280                codes = "(" + codes + ")"
    262                
     281
    263282                return {"codes":codes, "returnType":IntType}
     283
     284        def IsStr(self, tree):
     285                '''
     286                process the tree node with "Str" type
     287                '''
     288                return {"codes":tree.s, "returnType":StringType}
    264289       
    265290        def CheckArgs(self, args):
     
    268293                                return False
    269294                return True
     295
     296        def ParseFuncName(self, funcName):
     297                if "$fw$" in funcName:
     298                        funcName = funcName.replace("$fw$", str(self.operation.fieldWidth))
     299                return funcName
    270300
    271301        def IsCall(self, tree):
     
    305335                        elif op.opPattern == 3:
    306336                                codes += op.CallingStatementToCText(Utility.curRegisterSize, argList[0:])
     337                                if self.isCompileTimeConstant == True:
     338                                        self.isCompileTimeConstant = self.CheckArgs(argList[0:])
     339
     340                        elif op.opPattern == 4:
     341                                codes += op.CallingStatementToCText(Utility.curRegisterSize, argList[1:], argList[0])
    307342                                if self.isCompileTimeConstant == True:
    308343                                        self.isCompileTimeConstant = self.CheckArgs(argList[0:])
     
    318353                        elif op.opPattern == 3:
    319354                                self.prevCall.append(op.fullName + "_" + str(Utility.curRegisterSize))
     355
     356                elif IDISAFunction.IsIDISAFunction(funcName):
     357                        (codes, returnType) = IDISAFunction(self.operation.arch).Parse(IDISAFunction(self.operation.arch), funcName, argList, self.operation.fieldWidth)
     358                        #print "func is " + codes + " with type ", returnType                   
    320359                else:
    321360                        #func is not a simd operation and then it must be one of functions specified in built-ins
     
    325364                                return {"codes":None, "returnType":None}
    326365                       
    327                         codes = Utility.CallingStatement(funcName, argList)
     366                        codes = Utility.CallingStatement(funcName, self.operation.arch, argList)
    328367                        returnType = None
    329368                        if Utility.builtIns.IsOperationBuiltIn(funcName) == True:
  • trunk/libgen/Library_Generator/CppFunctionSupport.py

    r1767 r3436  
    9191        "cost":1,
    9292        },
     93
     94        "avx2_select_hi128":\
     95        {
     96        "body":r'''
     97#define avx_select_hi128(x) \
     98        (_mm256_extractf128_si256(x, 1))''',
     99        "platform":[configure.AVX2],
     100        "returnType":"__m128i",
     101        "cost":1,
     102        },     
    93103       
    94104        "avx_select_lo128":\
     
    102112        },
    103113
     114        "avx2_select_lo128":\
     115        {
     116        "body":r'''
     117#define avx_select_lo128(x) \
     118        _mm256_castsi256_si128(x)''',
     119        "platform":[configure.AVX2],
     120        "returnType":configure.SIMD_type[configure.SSE2],
     121        "cost":0,
     122        },
     123
    104124        "avx_general_combine256":\
    105125        {
     
    111131        "cost":1,
    112132        },
     133
     134        "avx2_general_combine256":\
     135        {
     136        "body":r'''
     137#define avx_general_combine256(x, y) \
     138    (_mm256_insertf128_si256(_mm256_castsi128_si256(y), x, 1))''',
     139        "platform":[configure.AVX2],
     140        "returnType":configure.SIMD_type[configure.AVX2],
     141        "cost":1,
     142        },     
    113143       
    114144        "avx_byte_shift_left":\
     
    122152        },
    123153
     154        "avx2_byte_shift_left":\
     155        {
     156        "body":r'''
     157#define avx_byte_shift_left(x, y) \
     158        ((SIMD_type)avx_general_combine256(_mm_slli_si128(avx_select_hi128(x), y), _mm_slli_si128(avx_select_lo128(x), y)))''',
     159        "platform":[configure.AVX2],
     160        "returnType":configure.SIMD_type[configure.AVX2],
     161        "cost":4,
     162        },
     163
    124164        "avx_byte_shift_right":\
    125165        {
     
    131171        "cost":4,
    132172        },
    133        
     173
     174        "avx2_byte_shift_right":\
     175        {
     176        "body":r'''
     177#define avx_byte_shift_right(x, y) \
     178        ((SIMD_type)avx_general_combine256(_mm_srli_si128(avx_select_hi128(x), y), _mm_srli_si128(avx_select_lo128(x), y)))''',
     179        "platform":[configure.AVX2],
     180        "returnType":configure.SIMD_type[configure.AVX2],
     181        "cost":4,
     182        },
     183       
     184        # WTF is this?
    134185        "avx_move_lo128_to_hi128":\
    135186        {
     
    141192        "cost":1,
    142193        },
     194
     195        "avx2_move_lo128_to_hi128":\
     196        {
     197        "body":r'''
     198#define avx_move_lo128_to_hi128(x) \
     199        _mm256_permute2f128_si128(x, x, 0 + 8)''',
     200        "platform":[configure.AVX2],
     201        "returnType":configure.SIMD_type[configure.AVX2],
     202        "cost":1,
     203        },
    143204       
    144205        "avx_move_hi128_to_lo128":\
     
    149210        "platform":[configure.AVX],
    150211        "returnType":configure.SIMD_type[configure.AVX],
     212        "cost":1,
     213        },
     214
     215        "avx2_move_hi128_to_lo128":\
     216        {
     217        "body":r'''
     218#define avx_move_hi128_to_lo128(x) \
     219        _mm256_permute2f128_si256(x, x, 1 + 128)''',
     220        "platform":[configure.AVX2],
     221        "returnType":configure.SIMD_type[configure.AVX2],
    151222        "cost":1,
    152223        },
  • trunk/libgen/Library_Generator/InstructionSet.py

    r1767 r3436  
    1212import NEONInstructions
    1313import AVXInstructions
     14import AVX2Instructions
    1415
    1516from Utility import configure
     
    2829        elif arch == configure.AVX:
    2930                return AVXInstructions.AVXBuiltIns
     31        elif arch == configure.AVX2:
     32                return AVX2Instructions.AVX2BuiltIns
    3033        elif arch == configure.NEON:
    3134                return NEONInstructions.NEONBuiltIns
  • trunk/libgen/Library_Generator/LibraryGenerator.py

    r2825 r3436  
    1313import OperationSet
    1414import OperationSetAnalyzer
     15
     16import ipdb
     17
     18def operationInfo(definedOperations):
     19        # All options have full powers of 2 as field width
     20        ref_keys = [1, 2, 4, 8, 16, 32, 64, 128]
     21        generators = ["SIMDBuiltinGenerator", "SIMDConstantBuiltinGenerator", "SIMDLogicBuiltinGenerator", "SIMDBitblockBuiltinGenerator", "SIMDBitblockImmediateBuiltinGenerator"]     
     22        return_type = {"bool": "BOOL", "uint64_t": "BITFIELD", "bitblock128_t": "BITBLOCK", "void": "VOID"}
     23        for op_key in sorted(definedOperations):
     24                op_val = definedOperations[op_key]
     25                op_detail = op_val.values()[0]
     26                op_pattern = op_detail.opPattern
     27                op_generator = generators[op_pattern]
     28                op_upperBound = "BITBLOCK_SIZE"
     29
     30                if op_pattern == 4:
     31                        print op_key.upper(), "(makeAllSimpleSignatures(" + op_upperBound + ", new " + op_generator + "(), ",                                           
     32                        print len(op_detail.arguments) * "BITBLOCK, ",                 
     33                        print return_type[op_detail.returnType] + ")),"
     34                        # print "args:"
     35                        # for arg in op_detail.arguments:
     36                        #       print arg.type, ", ",
     37                        # print                 
    1538
    1639def Init(arch, lang):
     
    3053
    3154        #Get all strategies
    32         Utility.strategies = Strategy.LoadStrategies(arch)
     55        Utility.strategies = Strategy.LoadStrategies(arch)     
    3356
    3457def Main(arch, lang, outfile, whichContent, options):
  • trunk/libgen/Library_Generator/Operation.py

    r2825 r3436  
    7878                self.cpp_class_signature = ""
    7979                if "cpp_class_signature" in opDescription:
    80                         self.cpp_class_signature = opDescription["cpp_class_signature"].replace("SIMD_type", configure.Bitblock_type[self.arch])
     80                        self.cpp_class_signature = opDescription["cpp_class_signature"] \
     81                                                                                .replace("SIMD_type", configure.Bitblock_type[self.arch]) \
     82                                                                                .replace("regw", str(configure.RegisterSize[self.arch]))
    8183       
    8284        def PostParsing(self, opDescription):
     
    250252                return cppText
    251253       
    252         def CallingStatementToCText(self, fw, args=[], templateArg=""):
     254        def CallingStatementToCText(self, fw, args=[], templateArg="", testingFlag=False):
    253255                if len(args) != len(self.arguments):
    254256                        print "The operation " + self.classType + "::" + self.name + " doesn't accept this many arguments!"
     
    262264                elif self.opPattern == 2:
    263265                        cText = self.name
    264                 elif self.opPattern == 3:
     266                elif self.opPattern == 3 or self.opPattern == 4:
    265267                        cText = self.classType + "_" + self.name
    266268               
    267269                cText += "("
     270                if self.opPattern == 1 or self.opPattern == 4:
     271                        #simd<fw>::op<val>(...) or bitblock::op<val>(...)
     272                        if testingFlag:
     273                                cText += "(" + str(self.templateArg.type) + ")" + "(" + str(templateArg) + "ULL)" + ", "
     274                        else:
     275                                cText += str(templateArg) + ", "
     276
    268277                for arg in args:
    269278                        cText += str(arg) + ", "
    270                 if self.opPattern == 1 or self.opPattern == 4:
    271                         cText += str(templateArg) + ", "
    272                
    273                 if len(args) > 0 or self.opPattern == 1:
    274                 #if there is at least one argument
     279               
     280                if cText.endswith(", "):
    275281                        cText = cText[0:len(cText)-2]
    276282                cText += ")"
    277283               
    278284                return cText
     285               
  • trunk/libgen/Library_Generator/StrategyPool.py

    r2825 r3436  
    615615                "Ops":["simd_slli"],
    616616                "Fws":[128],
    617                 "Platforms":[configure.AVX],
    618                 },
    619 
     617                "Platforms":configure.AVX_SERIES,
     618                },
     619
     620                # This strategy is wrong. Together with simd_srli_256, when sh = 0
    620621                "slli_256_avx":\
    621622                {
    622623                "body":r'''
    623 return simd_or(simd_slli(128, sh, arg1), avx_move_lo128_to_hi128(simd_srli(128, (256-sh)&0x7F, arg1))) if (sh<128) else simd_slli(128, sh&127, avx_move_lo128_to_hi128(arg1))''',
     624return simd_or(simd_slli(128, sh, arg1), avx_move_lo128_to_hi128(simd_srli(128, (256-sh)&0x7F, arg1))) if (sh<128) else simd_slli(128, sh-128, avx_move_lo128_to_hi128(arg1))''',
    624625                "Ops":["simd_slli"],
    625626                "Fws":[256],
    626                 "Platforms":[configure.AVX],
     627                "Platforms":configure.AVX_SERIES,
    627628                },
    628629
     
    715716                "Ops":["simd_srli"],
    716717                "Fws":[128],
    717                 "Platforms":[configure.AVX],
     718                "Platforms":configure.AVX_SERIES,
    718719                },
    719720
     
    721722                {
    722723                "body":r'''
    723 return simd_or(simd_srli(128, sh, arg1), simd_slli(128, (256-sh)&0x7F, IDISA_CASTING("SIMD_type", _mm256_castsi128_si256(avx_select_hi128(arg1))))) if (sh<128) else simd_srli(128, (sh)&0x7F, avx_move_hi128_to_lo128(arg1))''',
     724return simd_or(simd_srli(128, sh, arg1), simd_slli(128, (256-sh)&0x7F, IDISA_CASTING("SIMD_type", _mm256_castsi128_si256(avx_select_hi128(arg1))))) if (sh<128) else simd_srli(128, (sh - 128)&0x7F, avx_move_hi128_to_lo128(arg1))''',
    724725                "Ops":["simd_srli"],
    725726                "Fws":[256],
    726                 "Platforms":[configure.AVX],
     727                "Platforms":configure.AVX_SERIES,
    727728                },
    728729
     
    834835                "Ops":["simd_popcount"],
    835836                "Fws":[64],
    836                 "Platforms":[configure.AVX],
     837                "Platforms":configure.AVX_SERIES,
    837838                },
    838839               
     
    898899                "Ops":["simd_ifh"],
    899900                "Fws":[curRegSize],
    900                 "Platforms":[configure.AVX],
     901                "Platforms":configure.AVX_SERIES,
    901902                },
    902903
     
    925926                "Ops":["simd_lomask"],
    926927                "Fws":[64],
    927                 "Platforms":[configure.AVX],
     928                "Platforms":configure.AVX_SERIES,
    928929                },
    929930
     
    952953                "Ops":["simd_lomask"],
    953954                "Fws":[128],
    954                 "Platforms":[configure.AVX],
     955                "Platforms":configure.AVX_SERIES,
    955956                },
    956957
     
    961962                "Ops":["simd_lomask"],
    962963                "Fws":[256],
    963                 "Platforms":[configure.AVX],
     964                "Platforms":configure.AVX_SERIES,
    964965                },
    965966
     
    10061007                "Ops":["simd_himask"],
    10071008                "Fws":[64],
    1008                 "Platforms":[configure.AVX],
     1009                "Platforms":configure.AVX_SERIES,
    10091010                },
    10101011               
     
    10331034                "Ops":["simd_himask"],
    10341035                "Fws":[128],
    1035                 "Platforms":[configure.AVX],
     1036                "Platforms":configure.AVX_SERIES,
    10361037                },
    10371038       
     
    10421043                "Ops":["simd_himask"],
    10431044                "Fws":[256],
    1044                 "Platforms":[configure.AVX],
     1045                "Platforms":configure.AVX_SERIES,
    10451046                },
    10461047
     
    10911092                "Ops":["simd_constant"],
    10921093                "Fws":[64],
    1093                 "Platforms":[configure.AVX],
     1094                "Platforms":configure.AVX_SERIES,
    10941095                },
    10951096       
     
    11101111                "Ops":["simd_constant"],
    11111112                "Fws":[128],
    1112                 "Platforms":[configure.AVX],
     1113                "Platforms":configure.AVX_SERIES,
    11131114                },
    11141115       
     
    11191120                "Ops":["simd_constant"],
    11201121                "Fws":[256],
    1121                 "Platforms":[configure.AVX],
     1122                "Platforms":configure.AVX_SERIES,
    11221123                },
    11231124       
     
    14861487                "Ops":["hsimd_signmask"],
    14871488                "Fws":[8],
    1488                 "Platforms":[configure.AVX],
     1489                "Platforms":configure.AVX_SERIES,
    14891490                },
    14901491               
     
    15441545                "Ops":["esimd_mergeh"],
    15451546                "Fws":[8, 16, 32, 64],
    1546                 "Platforms":[configure.AVX],
     1547                "Platforms":configure.AVX_SERIES,
    15471548                },
    15481549
     
    15551556                "Ops":["esimd_mergel"],
    15561557                "Fws":[8, 16, 32, 64],
    1557                 "Platforms":[configure.AVX],
     1558                "Platforms":configure.AVX_SERIES,
    15581559                },
    15591560
     
    18741875                },
    18751876               
     1877#               "splat_doubling":\
     1878#               {
     1879#               "body":r'''
     1880# tmpArg = simd_slli(2*fw, fw, arg1) if pos%2==0 else simd_srli(2*fw, fw, arg1)
     1881# arg11 = simd_and(simd_lomask(2*fw), arg1) if pos%2==0 else simd_and(simd_himask(2*fw), arg1)
     1882# return mvmd_splat(2*fw, pos/2, simd_or(tmpArg, arg11))''',
     1883#               "Ops":["mvmd_splat"],
     1884#               "Fws":range(1, curRegSize/2+1),
     1885#               "Platforms":[configure.ALL],
     1886#               },
    18761887                "splat_doubling":\
    18771888                {
    18781889                "body":r'''
    1879 tmpArg = simd_slli(2*fw, fw, arg1) if pos%2==0 else simd_srli(2*fw, fw, arg1)
    1880 arg11 = simd_and(simd_lomask(2*fw), arg1) if pos%2==0 else simd_and(simd_himask(2*fw), arg1)
    1881 return mvmd_splat(2*fw, pos/2, simd_or(tmpArg, arg11))''',
     1890return mvmd_splat(2*fw, pos/2, simd_or(simd_slli(2*fw, fw, arg1) if pos%2==0 else simd_srli(2*fw, fw, arg1), simd_and(simd_lomask(2*fw), arg1) if pos%2==0 else simd_and(simd_himask(2*fw), arg1)))''',
    18821891                "Ops":["mvmd_splat"],
    18831892                "Fws":range(1, curRegSize/2+1),
     
    19271936                "Ops":["mvmd_splat"],
    19281937                "Fws":[8],
    1929                 "Platforms":[configure.AVX],
     1938                "Platforms":configure.AVX_SERIES,
    19301939                },
    19311940               
     
    19451954                "Ops":["mvmd_splat"],
    19461955                "Fws":[16],
    1947                 "Platforms":[configure.AVX],
     1956                "Platforms":configure.AVX_SERIES,
    19481957                },
    19491958
     
    19631972                "Ops":["mvmd_splat"],
    19641973                "Fws":[32],
    1965                 "Platforms":[configure.AVX],
     1974                "Platforms":configure.AVX_SERIES,
    19661975                },
    19671976                       
     
    19932002                },
    19942003               
     2004#               "shufflei_16_blend":\
     2005#               {
     2006#               "body":r'''
     2007# tmphi = _mm_shufflehi_epi16(arg1, shufflemask8_to_shufflemask4(msk)>>8)
     2008# tmpAns = _mm_shufflelo_epi16(tmphi, shufflemask8_to_shufflemask4(msk)&255)
     2009# tmplh = _mm_shufflehi_epi16(simd_slli(128, 64, arg1), shufflemask8_to_shufflemask4(msk)>>8)
     2010# tmphl = _mm_shufflelo_epi16(simd_srli(128, 64, arg1), shufflemask8_to_shufflemask4(msk)&255)
     2011# a1 = 0 if ((msk>>21)&4)==0 else ((1<<(fw+1))-1)
     2012# a2 = 0 if ((msk>>18)&4)==0 else ((1<<(fw+1))-1)
     2013# a3 = 0 if ((msk>>15)&4)==0 else ((1<<(fw+1))-1)
     2014# a4 = 0 if ((msk>>12)&4)==0 else ((1<<(fw+1))-1)
     2015# a5 = ((1<<(fw+1))-1) if ((msk>>9)&4)==0 else 0
     2016# a6 = ((1<<(fw+1))-1) if ((msk>>6)&4)==0 else 0
     2017# a7 = ((1<<(fw+1))-1) if ((msk>>3)&4)==0 else 0
     2018# a8 = ((1<<(fw+1))-1) if (msk&4)==0 else 0
     2019# return simd_ifh(1, mvmd_fill8(fw, a1, a2, a3, a4, a5, a6, a7, a8), tmpAns, simd_or(tmplh, tmphl))''',
     2020#               "Ops":["mvmd_shufflei"],
     2021#               "Fws":[16],
     2022#               "Platforms":[arch for arch in configure.SSE_SERIES],
     2023#               },
     2024
     2025                # Changed to suit C generator
    19952026                "shufflei_16_blend":\
    19962027                {
    19972028                "body":r'''
    1998 tmphi = _mm_shufflehi_epi16(arg1, shufflemask8_to_shufflemask4(msk)>>8)
    1999 tmpAns = _mm_shufflelo_epi16(tmphi, shufflemask8_to_shufflemask4(msk)&255)
    2000 tmplh = _mm_shufflehi_epi16(simd_slli(128, 64, arg1), shufflemask8_to_shufflemask4(msk)>>8)
    2001 tmphl = _mm_shufflelo_epi16(simd_srli(128, 64, arg1), shufflemask8_to_shufflemask4(msk)&255)
    2002 a1 = 0 if ((msk>>21)&4)==0 else ((1<<(fw+1))-1)
    2003 a2 = 0 if ((msk>>18)&4)==0 else ((1<<(fw+1))-1)
    2004 a3 = 0 if ((msk>>15)&4)==0 else ((1<<(fw+1))-1)
    2005 a4 = 0 if ((msk>>12)&4)==0 else ((1<<(fw+1))-1)
    2006 a5 = ((1<<(fw+1))-1) if ((msk>>9)&4)==0 else 0
    2007 a6 = ((1<<(fw+1))-1) if ((msk>>6)&4)==0 else 0
    2008 a7 = ((1<<(fw+1))-1) if ((msk>>3)&4)==0 else 0
    2009 a8 = ((1<<(fw+1))-1) if (msk&4)==0 else 0
    2010 return simd_ifh(1, mvmd_fill8(fw, a1, a2, a3, a4, a5, a6, a7, a8), tmpAns, simd_or(tmplh, tmphl))''',
     2029return simd_ifh(1, mvmd_fill8(fw, 0 if ((msk>>21)&4)==0 else ((1<<(fw+1))-1), 0 if ((msk>>18)&4)==0 else ((1<<(fw+1))-1), 0 if ((msk>>15)&4)==0 else ((1<<(fw+1))-1), 0 if ((msk>>12)&4)==0 else ((1<<(fw+1))-1), ((1<<(fw+1))-1) if ((msk>>9)&4)==0 else 0, ((1<<(fw+1))-1) if ((msk>>6)&4)==0 else 0, ((1<<(fw+1))-1) if ((msk>>3)&4)==0 else 0, ((1<<(fw+1))-1) if (msk&4)==0 else 0), _mm_shufflelo_epi16(_mm_shufflehi_epi16(arg1, shufflemask8_to_shufflemask4(msk)>>8), shufflemask8_to_shufflemask4(msk)&255), simd_or(_mm_shufflehi_epi16(simd_slli(128, 64, arg1), shufflemask8_to_shufflemask4(msk)>>8), _mm_shufflelo_epi16(simd_srli(128, 64, arg1), shufflemask8_to_shufflemask4(msk)&255)))''',
    20112030                "Ops":["mvmd_shufflei"],
    20122031                "Fws":[16],
     
    20702089                "Ops":["mvmd_extract"],
    20712090                "Fws":[8],
    2072                 "Platforms":[configure.AVX],
     2091                "Platforms":configure.AVX_SERIES,
    20732092                },
    20742093       
     
    20892108                "Ops":["mvmd_extract"],
    20902109                "Fws":[16],
    2091                 "Platforms":[configure.AVX],
     2110                "Platforms":configure.AVX_SERIES,
    20922111                },
    20932112
     
    21082127                "Ops":["mvmd_extract"],
    21092128                "Fws":[32],
    2110                 "Platforms":[configure.AVX],
     2129                "Platforms":configure.AVX_SERIES,
    21112130                },
    21122131
     
    23182337                "Ops":["bitblock_any"],
    23192338                "Fws":[curRegSize],
    2320                 "Platforms":[configure.AVX],
     2339                "Platforms":configure.AVX_SERIES,
    23212340                },
    23222341       
     
    23532372                "Ops":["bitblock_all"],
    23542373                "Fws":[curRegSize],
    2355                 "Platforms":[configure.AVX],
     2374                "Platforms":configure.AVX_SERIES,
    23562375                },
    23572376               
     
    24162435                },
    24172436
    2418                
    2419         }
     2437                "simd_any":\
     2438                {
     2439                "body":r'''
     2440return simd_ugt(fw, arg1, simd_constant(8, 0))''',
     2441                "Ops":["simd_any"],
     2442                "Fws":range(2, curRegSize+1),
     2443                "Platforms":[configure.ALL],
     2444                },
     2445
     2446                "simd_all":\
     2447                {
     2448                "body":r'''
     2449return simd_eq(fw, arg1, simd_constant(8, 255))''',
     2450                "Ops":["simd_all"],
     2451                "Fws":range(2, curRegSize+1),
     2452                "Platforms":[configure.ALL],
     2453                },
     2454
     2455                "simd_any_bitblock_any":\
     2456                {
     2457                "body":r'''
     2458return simd_constant(8, 255) if bitblock_any(arg1) else simd_constant(8, 0)''',
     2459                "Ops":["simd_any"],
     2460                "Fws":[curRegSize],
     2461                "Platforms":[configure.ALL],
     2462                },
     2463
     2464                "simd_all_bitblock_all":\
     2465                {
     2466                "body":r'''
     2467return simd_constant(8, 255) if bitblock_all(arg1) else simd_constant(8, 0)''',
     2468                "Ops":["simd_all"],
     2469                "Fws":[curRegSize],
     2470                "Platforms":[configure.ALL],
     2471                },
     2472
     2473                "simd_any_2_logic":\
     2474                {
     2475                "body":r'''
     2476t0 = simd_srli(2, 1, arg1)
     2477f0 = simd_or(t0, simd_and(arg1, simd_xor(t0, simd_constant(8, 255))))
     2478return simd_or(f0, simd_slli(2,1,f0))''',
     2479                "Ops":["simd_any"],
     2480                "Fws":[2],
     2481                "Platforms":[configure.ALL],
     2482                },
     2483
     2484                "simd_all_2_logic":\
     2485                {
     2486                "body":r'''
     2487f0 = simd_and(arg1, simd_srli(2, 1, arg1))
     2488return simd_or(f0, simd_slli(2,1,f0))''',
     2489                "Ops":["simd_all"],
     2490                "Fws":[2],
     2491                "Platforms":[configure.ALL],
     2492                },
     2493        }       
    24202494       
    24212495        return strategies
  • trunk/libgen/Library_Generator/UI.py

    r2825 r3436  
    9090               
    9191                if lang == configure.Language_C:
    92                         self.WriteCCodes(operationSetResult, arch, lang, whichContent)
     92                        self.WriteCCodes(operationSetResult, arch, lang, outfile, whichContent)
     93                        self.WriteValidOperations(operationSetResult, arch, outfile)
    9394                elif lang == configure.Language_CPP:
    9495                        self.WriteCodes(operationSetResult, arch, lang, outfile, whichContent)
     
    101102                        codes += "#define " + "_IDISA_" + arch.upper() + "_" + "C" + "_" + "H" + "\n"
    102103                        codes += '''#include "''' + configure.InstructionSetLibrary[arch] + '''"\n\n'''
    103                         codes += "typedef " + configure.SIMD_type[arch] + " SIMD_type;\n"
     104                        codes += "#include <stdint.h>\n"
     105                        codes += "typedef " + configure.SIMD_type[arch] + " " + configure.Bitblock_type[arch] + ";\n"
     106                       
    104107                elif lang == configure.Language_CPP:
    105108                        #codes += "#ifndef " + "_IDISA_" + arch.upper() + "_" + "H" + "\n"
     
    137140template <> struct FieldType<64> {typedef uint64_t T;};
    138141template <> struct FieldType<128> {typedef uint64_t T;};
     142template <> struct FieldType<256> {typedef uint64_t T;};
    139143
    140144"""
     
    164168               
    165169                (optOpCount, optOpCodes, opMaxCount) = (operationSetResult.optOpCount, operationSetResult.optOpCodes, operationSetResult.opMaxCount)
    166                 fileOut.write(self.PreliminaryCodes(arch, lang, outfile, whichContent))
    167                
     170                fileOut.write(self.PreliminaryCodes(arch, lang, outfile, whichContent))         
     171
    168172                for classType in allClasses:
    169173                        if whichContent == configure.Body_All:
     
    185189                                                operation = Utility.definedOperations[opName][fw]
    186190                                                if optOpCount[operation.fullName + "_" + str(fw)] < opMaxCount:
    187                                                                 curOperation = Utility.LibFunction(operation, optOpCount[operation.fullName + "_" + str(fw)], optOpCodes[operation.fullName + "_" + str(fw)])
    188                                                                 curSignature = curOperation.ClassDeclarationToCppText()
    189                                                                 if curSignature not in opSignatures:
    190                                                                         opSignatures[curSignature] = True
    191                                                                         curClass.Append(curOperation)
    192                                                                 #curOperation.SetBodyContent(optOpCodes[operation.fullName + "_" + str(fw)])
    193                                                                 operationImp[classType][operation.fullName].append(curOperation.ToCppText())
    194                                                                 operationDecla[classType][operation.fullName].append(curOperation.FunctionDeclarationToCppText())
     191                                                        curOperation = Utility.LibFunction(operation, optOpCount[operation.fullName + "_" + str(fw)], optOpCodes[operation.fullName + "_" + str(fw)])
     192                                                        curSignature = curOperation.ClassDeclarationToCppText()
     193                                                        if curSignature not in opSignatures:
     194                                                                opSignatures[curSignature] = True
     195                                                                curClass.Append(curOperation)
     196                                                        #curOperation.SetBodyContent(optOpCodes[operation.fullName + "_" + str(fw)])
     197                                                        operationImp[classType][operation.fullName].append(curOperation.ToCppText())
     198                                                        operationDecla[classType][operation.fullName].append(curOperation.FunctionDeclarationToCppText())
    195199                       
    196200                        if whichContent != configure.Body_Declaration:         
     
    253257                        fileOut = open(outfile.replace(".cpp", ".db"), 'w')
    254258                else:
    255                         fileOut = open(outfile.replace(".h", ".db"), 'w')
     259                        fileOut = open(outfile.replace(".h", ".db"), 'w')               
     260
    256261                (optOpCount, opMaxCount) = (operationSetResult.optOpCount, operationSetResult.opMaxCount)
    257262                opNameFilter = ["bitblock_load_aligned", "bitblock_load_unaligned", "bitblock_store_aligned", "bitblock_store_unaligned"]
     
    283288                fileOut.close()
    284289       
    285         def WriteCCodes(self, operationSetResult, arch, lang, whichContent):
    286                 fileOut = open("idisa"+'_'+arch.lower()+"_"+"c.h", "w")
     290        def WriteCCodes(self, operationSetResult, arch, lang, outfile, whichContent):                   
     291                fileOut = open(outfile, "w")
    287292                (optOpCount, optOpCodes, opMaxCount) = (operationSetResult.optOpCount, operationSetResult.optOpCodes, operationSetResult.opMaxCount)
    288293               
    289294                #oper = Utility.definedOperations["simd_add_8"]
    290295                #print oper.CallingStatementToCText(8, oper.arguments, oper.):
    291                 fileOut.write(self.PreliminaryCodes(arch, lang))
     296                fileOut.write(self.PreliminaryCodes(arch, lang, outfile, whichContent))
    292297               
    293298                for func in Utility.usedFunctionSupport:
     
    295300
    296301                fileOut.write("\n")
    297                
     302                fileOut.write("//Declaration Starts here\n");
     303                for op in Utility.definedOperations:
     304                        for fw in Utility.definedOperations[op]:
     305                                opr = Utility.definedOperations[op][fw]
     306                                if optOpCount[op+"_"+str(fw)] < opMaxCount:                                     
     307                                        if (opr.opPattern == 1 or opr.opPattern == 4) and optOpCodes[op+"_"+str(fw)].count("\n") <= 1:
     308                                                libF = Utility.LibFunction(opr, optOpCount[op+"_"+str(fw)], optOpCodes[op+"_"+str(fw)])
     309                                                fileOut.write(libF.ToCMacro() + "\n")
     310                                        else:
     311                                                libF = Utility.LibFunction(opr, 0, optOpCodes[op+"_"+str(fw)])
     312                                                fileOut.write(libF.FunctionDeclarationToCText() + ";\n")
     313
     314                fileOut.write("\n//Implementation Starts here\n");
    298315                for op in Utility.definedOperations:
    299316                        for fw in Utility.definedOperations[op]:
    300317                                opr = Utility.definedOperations[op][fw]
    301318                                if optOpCount[op+"_"+str(fw)] < opMaxCount:
    302                                         libF = Utility.LibFunction(opr, 0, optOpCodes[op+"_"+str(fw)])
    303                                         fileOut.write(libF.FunctionDeclarationToCText() + ";\n")
    304                                        
    305                 for op in Utility.definedOperations:
    306                         for fw in Utility.definedOperations[op]:
    307                                 opr = Utility.definedOperations[op][fw]
    308                                 if optOpCount[op+"_"+str(fw)] < opMaxCount and optOpCodes[op+"_"+str(fw)].count("\n")<=1:
     319                                        if (opr.opPattern == 1 or opr.opPattern == 4) and optOpCodes[op+"_"+str(fw)].count("\n") <= 1:
     320                                                continue
    309321                                        libF = Utility.LibFunction(opr, optOpCount[op+"_"+str(fw)], optOpCodes[op+"_"+str(fw)])
    310322                                        fileOut.write(libF.ToCText())
    311323               
    312                
    313                
    314                 for op in Utility.definedOperations:
    315                         for fw in Utility.definedOperations[op]:
    316                                 opr = Utility.definedOperations[op][fw]
    317                                 if optOpCount[op+"_"+str(fw)] < opMaxCount and optOpCodes[op+"_"+str(fw)].count("\n")>1:
    318                                         libF = Utility.LibFunction(opr, optOpCount[op+"_"+str(fw)], optOpCodes[op+"_"+str(fw)])
    319                                         fileOut.write(libF.ToCText())
     324                # for op in Utility.definedOperations:
     325                #       for fw in Utility.definedOperations[op]:
     326                #               opr = Utility.definedOperations[op][fw]
     327                #               if optOpCount[op+"_"+str(fw)] < opMaxCount and optOpCodes[op+"_"+str(fw)].count("\n")>1:
     328                #                       libF = Utility.LibFunction(opr, optOpCount[op+"_"+str(fw)], optOpCodes[op+"_"+str(fw)])
     329                #                       fileOut.write(libF.ToCText())
    320330               
    321331                #opr = Utility.definedOperations["simd_add"][128]
  • trunk/libgen/Library_Generator/Utility.py

    r2825 r3436  
    209209                return cppText
    210210       
    211         def CMarcoText(self):
     211        def CMarcoSignature(self):
    212212                text = "#define "
    213213                if self.opPattern == 2:
    214214                        text += self.name
    215                 elif self.opPattern == 3:
    216                         text += self.classType + "_" + self.name
     215                elif self.opPattern == 3 or self.opPattern == 4:
     216                        text += self.classType + "_" + self.name               
    217217                else:
    218218                        text += self.classType + "_" + self.name + "_" + str(self.fieldWidth)
    219219               
    220220                text += "("
     221                if self.opPattern == 1 or self.opPattern == 4:
     222                        text += self.templateArg.name + ", "
    221223                for arg in self.arguments:
    222224                        text += arg.name + ", "
    223                 if self.opPattern == 1:
    224                         text += self.templateArg.name
    225                 elif len(self.arguments) > 0:
     225                if text.endswith(", "):
    226226                        text = text[0:len(text)-2]
    227227       
     
    233233                if self.opPattern == 2:
    234234                        text += self.name
    235                 elif self.opPattern == 3:
     235                elif self.opPattern == 3 or self.opPattern == 4:
    236236                        text += self.classType + "_" + self.name
    237237                else:
     
    239239                       
    240240                text += "("
     241                if self.opPattern == 1 or self.opPattern == 4:
     242                        text += self.templateArg.type + " " + self.templateArg.name + ", "
    241243                for arg in self.arguments:
    242244                        text += arg.type + " " + arg.name + ", "
    243                 if self.opPattern == 1:
    244                         text += self.templateArg.type + " " + self.templateArg.name
    245                 elif len(self.arguments) > 0:
     245                if text.endswith(", "):
    246246                        text = text[0:len(text)-2]
    247247               
     
    252252                text = ""
    253253                #if self.body.count("\n") <= 1:
    254                 #       text += self.CMarcoText()
     254                #       text += self.CMarcoSignature()
    255255                #else:
    256256                text += self.CStaticInlineText()
     
    263263                #       cText += self.body.replace("return", "").replace(";", "") + "\n"
    264264                #else:
    265                 cText += "\n{" + "\n" + self.body + "}\n"
     265                cText += "\n{" + "\n\t" + self.body.strip() + "\n}\n"
     266                return cText
     267
     268        def ToCMacro(self):
     269                cText = "//The total number of operations is " + str(self.cost) + "\n"
     270                cText += self.CMarcoSignature()
     271                cText += " \\\n\t" + self.body.replace("return", "").replace(";", "").strip() + "\n"
    266272                return cText
    267273
  • trunk/libgen/Library_Tester/LibraryTester.py

    r1767 r3436  
    99
    1010#import GenerateCppTesting
    11 import GenerateCppTests
     11import GenerateTests
    1212import TesterUtility
    1313from TesterUtility import configure, OptParser
     
    1616import ParseIdisaDB
    1717import AssemblyInstructionCount
     18from TestDriverGenerater import CppDriverGenerater, CDriverGenerater
     19
     20import ipdb
    1821
    1922def WriteTestingData(fileName, data):
     
    4750        elif arch == configure.AVX:
    4851                return "g++ -mavx -o"
     52        elif arch == configure.AVX2:
     53                return "g++ -mavx2 -o"
    4954
    5055def ReadContentAsOneLine(fileName):
     
    103108
    104109def Main(idisa_file, options):
    105        
    106         arch = idisa_file.replace("idisa_", "").upper()
     110        arch = options.arch.upper()     
    107111
    108112        if arch not in configure.RegisterSize:
     
    110114                sys.exit()
    111115       
    112         validOperations = ParseIdisaDB.Parse("idisa_" + arch.lower() + ".db")
    113         definedOperations = Operation.LoadDefinedOperations(configure.AllOperations, arch)
     116        validOperations = ParseIdisaDB.Parse(idisa_file + ".db")
     117        definedOperations = Operation.LoadDefinedOperations(configure.AllOperations, arch)     
    114118        #GenerateCppTesting.Generate(arch + "_" + "test" + ".cpp", arch, validOperations)
     119
    115120       
    116121        if options.instruction_count:
     
    119124                sys.exit()
    120125       
    121         testingData = GenerateCppTests.MakeTestdata(arch, definedOperations, validOperations)
     126        testingData = GenerateTests.MakeTestdata(arch, definedOperations, validOperations)
    122127        #print testingData
    123128       
     
    127132                CheckCorrectness(testingData)
    128133                sys.exit()
     134               
     135        if options.lang == 'cpp':
     136                driver = CppDriverGenerater()
     137        else:
     138                driver = CDriverGenerater()
    129139       
    130         cppText = GenerateCppTests.MakeCppText(arch, definedOperations, validOperations, testingData, options)
     140        cppText = driver.MakeText(arch, definedOperations, validOperations, testingData, options)
    131141       
    132         GenerateCppTests.WriteCppText(arch, arch+"_test.cpp", cppText)
     142        driver.WriteText(arch, arch+"_test.cpp", cppText)
    133143       
    134144        #write all testing data on the disk
  • trunk/libgen/Library_Tester/utility.h

    r2825 r3436  
    1 #include "idisa_sse4_2.h"
    2 #define USE_SSE
    3 typedef __m128i SIMD_type;
     1#include "idisa_avx2.h"
     2#define USE_AVX2
     3typedef __m256i SIMD_type;
     4#include <vector>
    45#include <iostream>
    56#include <sstream>
    6 #include <vector>
    77#include <string>
    88#include <cstring>
     
    155155                case 2:
    156156{
    157 #ifdef USE_AVX
    158157                        int buf[8];
    159158                        regSize = 256;
     
    164163                        }
    165164
     165#ifdef USE_AVX
    166166                        __m128i ans1 = _mm_loadu_si128((__m128i *)(buf+4));//high part
    167167                        __m128i ans2 = _mm_loadu_si128((__m128i *)(buf));//low part
    168168
    169169                        ans = _mm256_insertf128_ps(_mm256_castps128_ps256((__m128) ans2), (__m128) ans1, 1);
     170#endif
     171
     172#ifdef USE_AVX2
     173                        ans = _mm256_loadu_si256((__m256i *)(buf));
    170174#endif
    171175}
     
    229233                case 2:
    230234{
    231 #ifdef USE_AVX
    232235                        int buf[8];
    233236                        regSize = 256;
     
    235238                        buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = buf[7] = x;
    236239
     240#ifdef USE_AVX
    237241                        __m128i ans1 = _mm_loadu_si128((__m128i *)(buf+4));//high part
    238242                        __m128i ans2 = _mm_loadu_si128((__m128i *)(buf));//low part
     
    240244                        ans = _mm256_insertf128_ps(_mm256_castps128_ps256((__m128) ans2), (__m128) ans1, 1);
    241245#endif
     246
     247#ifdef USE_AVX2
     248                        ans = _mm256_loadu_si256((__m256i *)(buf));
     249#endif         
    242250}
    243251                        break;
     
    308316                        {
    309317                                ans = ans + Int2BitString(buf[i]);
     318                        }
     319#endif
     320
     321#ifdef USE_AVX2
     322                        int buf[8];
     323                        _mm256_storeu_si256((__m256i *)buf, v);
     324
     325                        //little endian
     326                        for (int i =7;i>=0;i--)
     327                        {
     328                                ans += Int2BitString(buf[i]);
    310329                        }
    311330#endif
  • trunk/libgen/Makefile

    r1740 r3436  
    66IDISA_LIB_DIR = idisa_lib
    77IDISA_LIB_CPP_DIR = $(IDISA_LIB_DIR)/idisa_cpp
     8IDISA_LIB_C_DIR = $(IDISA_LIB_DIR)/idisa_c
    89LIB_CPP_DIR = $(LIB_DIR)/idisa_cpp
    910
     
    2526
    2627IDISA_AVX_CPP_LIB = idisa_avx
     28IDISA_AVX2_CPP_LIB = idisa_avx2
    2729
    2830IDISA128 = idisa128
     
    3840sse2:
    3941        python $(IDISA_GENERATOR) -a sse2 -l cpp -f $(IDISA_SSE2_CPP_LIB).h -g
    40 
    4142sse2_c:
    4243        python $(IDISA_GENERATOR) -a sse2 -l c -f $(IDISA_SSE2_C_LIB).h -g
    43 
    4444sse2_test:
    4545        python $(IDISA_TESTER) -a sse2 -l cpp -f $(IDISA_SSE2_CPP_LIB) -t
     46sse2_c_test:
     47        python $(IDISA_TESTER) -a sse2 -l c -f $(IDISA_SSE2_C_LIB) -t
    4648
    4749#sse2_strategy_count:
     
    5658sse3:
    5759        python $(IDISA_GENERATOR) -a sse3 -l cpp -f $(IDISA_SSE3_CPP_LIB).h -g
     60sse3_c:
     61        python $(IDISA_GENERATOR) -a sse3 -l c -f $(IDISA_SSE3_CPP_LIB)_c.h -g
    5862sse3_test:
    5963        python $(IDISA_TESTER) -a sse3 -l cpp -f $(IDISA_SSE3_CPP_LIB) -t
     64sse3_c_test:
     65        python $(IDISA_TESTER) -a sse3 -l c -f $(IDISA_SSE3_CPP_LIB)_c -t
    6066
    6167ssse3:
     
    6369ssse3_test:
    6470        python $(IDISA_TESTER) -a ssse3 -l cpp -f $(IDISA_SSSE3_CPP_LIB) -t
     71ssse3_c:
     72        python $(IDISA_GENERATOR) -a ssse3 -l c -f $(IDISA_SSSE3_CPP_LIB)_c.h -g
     73ssse3_c_test:
     74        python $(IDISA_TESTER) -a ssse3 -l c -f $(IDISA_SSSE3_CPP_LIB)_c -t     
    6575
    6676sse4_1:
     
    6878sse4_1_test:
    6979        python $(IDISA_TESTER) -a sse4_1 -l cpp -f $(IDISA_SSE4_1_CPP_LIB) -t
     80sse4_1_c:
     81        python $(IDISA_GENERATOR) -a sse4_1 -l c -f $(IDISA_SSE4_1_CPP_LIB)_c.h -g
     82sse4_1_c_test:
     83        python $(IDISA_TESTER) -a sse4_1 -l c -f $(IDISA_SSE4_1_CPP_LIB)_c -t
    7084
    7185sse4_2:
     
    7387sse4_2_test:
    7488        python $(IDISA_TESTER) -a sse4_2 -l cpp -f $(IDISA_SSE4_2_CPP_LIB) -t
     89sse4_2_c:
     90        python $(IDISA_GENERATOR) -a sse4_2 -l c -f $(IDISA_SSE4_2_CPP_LIB)_c.h -g
     91sse4_2_c_test:
     92        python $(IDISA_TESTER) -a sse4_2 -l c -f $(IDISA_SSE4_2_CPP_LIB)_c -t   
    7593
    7694neon:
     
    90108avx_test:
    91109        python $(IDISA_TESTER) -a avx -l cpp -f $(IDISA_AVX_CPP_LIB) -t
     110avx2:
     111        python $(IDISA_GENERATOR) -a avx2 -l cpp -f $(IDISA_AVX2_CPP_LIB).h -g
     112avx2_test:
     113        python $(IDISA_TESTER) -a avx2 -l cpp -f $(IDISA_AVX2_CPP_LIB) -t
    92114#avx_strategy_count:
    93115#       python $(IDISA_GENERATOR) -a avx -l cpp -f $(IDISA_AVX_CPP_LIB).h -g --strategy_count = True
     
    139161        python $(IDISA_GENERATOR) -a sse2 -l cpp -f $(IDISA).hpp -g --body=$(BODY_DECLARATION)
    140162        mv $(GENERATOR_DIR)/$(IDISA).hpp $(LIB_DIR)/
    141        
     163
     164idisa128_c:
     165        make sse2_c
     166        make sse3_c
     167        make ssse3_c
     168        make sse4_1_c
     169        make sse4_2_c   
     170
     171        mv $(GENERATOR_DIR)/idisa_sse2_c.h $(LIB_DIR)/idisa_c
     172        mv $(GENERATOR_DIR)/idisa_sse3_c.h $(LIB_DIR)/idisa_c
     173        mv $(GENERATOR_DIR)/idisa_ssse3_c.h $(LIB_DIR)/idisa_c
     174        mv $(GENERATOR_DIR)/idisa_sse4_1_c.h $(LIB_DIR)/idisa_c
     175        mv $(GENERATOR_DIR)/idisa_sse4_2_c.h $(LIB_DIR)/idisa_c
    142176
    143177clean:
Note: See TracChangeset for help on using the changeset viewer.