Changeset 3396


Ignore:
Timestamp:
Jul 12, 2013, 1:09:25 PM (5 years ago)
Author:
linmengl
Message:

handle bitblock_iterator.hpp correctly now

Location:
trunk/lib_c/cpp2c
Files:
2 added
19 edited

Legend:

Unmodified
Added
Removed
  • trunk/lib_c/cpp2c/cpp2c.rb

    r3393 r3396  
    4848puts "Running with #{options.inspect}"
    4949
    50 class LineTranslator   
    51         # Those 3 functions are used as pipeline.       
     50# Translation Starts here
    5251
    53         # Basic regex translation, including head files, calling signatures
    54         def self.t_basic_line line
    55                 if line =~ /^\#/
    56                         line.gsub!(/_HPP/, "_H")
    57                         line.gsub!("idisa.hpp", "idisa128_c.h")
    58                         line.gsub!("idisa128.hpp", "idisa128_c.h")
    59                         line.gsub!(/.hpp\"/, ".h\"")
    60                 end
     52require_relative 'passes'
     53passes = [SharpPass.new, IDISAPass.new,
     54                        ConditionWrapPass.new("BLOCK_SIZE", [128, 256]),
     55                        ConditionWrapPass.new("FW", [8, 32]),
     56                        ConditionWrapPass1.new("sizeof(scanfield_t)", [1,2,4,8]),
     57                        EvaluationPass.new]
    6158
    62                 # format_2: opPattern = 0
    63                 #       class_name<fw>::op(data_type arg, ...)
    64                 f2 = /(simd\d*|hsimd\d*|esimd\d*|mvmd\d*|bitblock\d*)\<([^>]*)\>::(\w*)\(/
    65                 m = line.match f2
    66                 if m
    67                         calling = "#{m[1]}_#{m[3]}_{{{#{m[2]}}}}("
    68                         line.gsub!(m[0], calling)
    69                 end
    70 
    71                 # format_3: opPattern = 1
    72                 #       class_name<fw>::op<x>(data_type arg, ...)               
    73                 f3 = /(simd\d*|hsimd\d*|esimd\d*|mvmd\d*|bitblock\d*)\<([^>]*)\>::(\w*)\<([^>]*)\>\(/
    74                 m = line.match f3
    75                 if m
    76                         calling = "#{m[1]}_#{m[3]}_{{{#{m[2]}}}}(#{m[4]}, "
    77                         line.gsub! m[0], calling
    78                 end
    79 
    80                 # format_4: opPattern = 3
    81                 #       class_name::op(data_type arg, ...)
    82                 f4 = /(bitblock\d*)::(\w*)\(/
    83                 m = line.match f4
    84                 if m
    85                         calling = "#{m[1]}_#{m[2]}("
    86                         line.gsub! m[0], calling
    87                 end
    88 
    89                 # format_5: opPattern = 4
    90                 #       class_name::op<x>(data_type arg, ...)           
    91                 f5 = /(bitblock\d*)::(\w*)\<([^>]*)\>\(/
    92                 m = line.match f5
    93                 if m
    94                         calling = "#{m[1]}_#{m[2]}(#{m[3]}, "
    95                         line.gsub! m[0], calling
    96                 end
    97 
    98                 # remove redundant comma, e.g. simd_op(, 1) into simd_op(1)
    99                 line.gsub! /(?<=\(),\s(?=\w+)/, ""
    100                 # cont. bitblock_srli(sh, ) into bitlblock_srli()
    101                 line.gsub! /(?<=[\s\w]),\s+(?=\))/, ""
    102 
    103                 # Another hack here. simd128 class is basically simd in IDISA C
    104                 line.gsub! /\b(simd|hsimd|mvmd|esimd)128/, "\\1"
    105 
    106                 line
    107         end
    108 
    109         # Dealing with BLOCK_SIZE as a template variable.
    110         # Also merge continous lines into one "#if #else #endif" block.
    111         def self.t_with_line_store line         
    112                 begin
    113                         last = line.clone
    114                         line = self.t_basic_line line
    115                 end while last != line
    116 
    117                 if line =~ /\{\{\{BLOCK_SIZE\b/
    118                         LineStore.store_line line
    119                 else
    120                         dump = LineStore.dump                   
    121                         dump + line
    122                 end             
    123         end
    124 
    125         # Template Evaluation
    126         def self.t line
    127                 line = self.t_with_line_store line
    128 
    129                 # Eval all the math inside {{{ }}}, I LOVE RUBY!!!!
    130                 line.gsub!(/\{\{\{([^\{\}]*)\}\}\}/) { eval($1) }
    131 
    132                 line
    133         end
     59passes.each     do |pass|
     60        pass.translate options
     61        options[:input] = options[:output]
    13462end
    13563
    136 require_relative 'passes'
    137 
    138 class FullPass < BasePass
    139         def t line
    140                 LineTranslator.t line
    141         end
     64if options[:del_origin]
     65        puts `rm #{options[:input]}`   
    14266end
    143 
    144 # Translation Starts here
    145 
    146 begin
    147         passes = [SharpPass.new, IDISAPass.new,
    148                                 ConditionWrapPass.new("BLOCK_SIZE", [128, 256]),
    149                                 EvaluationPass.new]
    150 
    151         passes.each     do |pass|
    152                 pass.translate options
    153                 options[:input] = options[:output]
    154         end
    155 
    156         if options[:del_origin]
    157                 puts `rm #{options[:input]}`   
    158         end
    159 # rescue => err
    160 #       puts "Exception: #{err}"
    161 #       err
    162 end
  • trunk/lib_c/cpp2c/expected_output/allocator.hpp

    r3393 r3396  
    171171
    172172#endif // ALLOCATOR_H_
    173 
  • trunk/lib_c/cpp2c/expected_output/bitblock.hpp

    r3393 r3396  
    127127
    128128
    129 
  • trunk/lib_c/cpp2c/expected_output/bitblock128.hpp

    r3393 r3396  
    140140
    141141#endif // BITBLOCK128_H_
    142 
  • trunk/lib_c/cpp2c/expected_output/buffer.hpp

    r3393 r3396  
    5858
    5959#endif // BUFFER_H
    60 
  • trunk/lib_c/cpp2c/expected_output/builtins.hpp

    r3393 r3396  
    9696
    9797#endif // BUILTINS_H
    98 
  • trunk/lib_c/cpp2c/expected_output/byte_compare.hpp

    r3393 r3396  
    9999
    100100
    101 
  • trunk/lib_c/cpp2c/expected_output/byte_pool.hpp

    r3393 r3396  
    5353
    5454#endif // BYTE_POOL_H
    55 
  • trunk/lib_c/cpp2c/expected_output/carryQ.hpp

    r3393 r3396  
    6161    #define Carry0 simd_constant_128(0)
    6262    #define Carry1 simd_constant_128(1)
    63 #else
     63#else //BLOCK_SIZE == 256
    6464    #define Carry0 simd_constant_256(0)
    6565    #define Carry1 simd_constant_256(1)
     
    102102#if (BLOCK_SIZE == 128)
    103103                adc(simd_constant_128(0), simd_not(charclass), carryin, cq[carryno], marker);
    104 #else
     104#else //BLOCK_SIZE == 256
    105105                adc(simd_constant_256(0), simd_not(charclass), carryin, cq[carryno], marker);
    106106#endif
     
    151151#if (BLOCK_SIZE == 128)
    152152                return simd_or(simd_slli_128(32, strm), mvmd_fill_128((uint64_t)pending_in));
    153 #else
     153#else //BLOCK_SIZE == 256
    154154                return simd_or(simd_slli_256(32, strm), mvmd_fill_256((uint64_t)pending_in));
    155155#endif
     
    160160#if (BLOCK_SIZE == 128)
    161161                BitBlock half_block_shifted = esimd_mergel_64(strm, pending_in);
    162 #else
     162#else //BLOCK_SIZE == 256
    163163                BitBlock half_block_shifted = esimd_mergel_128(strm, pending_in);
    164164#endif
     
    168168                BitBlock result = simd_or(simd_srli_64((BLOCK_SIZE/2)-n, half_block_shifted),
    169169                               simd_slli_64(n, strm));
    170 #else
     170#else //BLOCK_SIZE == 256
    171171                BitBlock result = simd_or(simd_srli_128((BLOCK_SIZE/2)-n, half_block_shifted),
    172172                               simd_slli_128(n, strm));
     
    282282
    283283#endif // CARRYQ_H_
    284 
  • trunk/lib_c/cpp2c/expected_output/carrySet.hpp

    r3393 r3396  
    6060    #define Carry0 simd_constant_128(0)
    6161    #define Carry1 simd_constant_128(1)
    62 #else
     62#else //BLOCK_SIZE == 256
    6363    #define Carry0 simd_constant_256(0)
    6464    #define Carry1 simd_constant_256(1)
     
    150150
    151151#endif // CARRYQ_H_
    152 
  • trunk/lib_c/cpp2c/expected_output/config.hpp

    r3393 r3396  
    6464
    6565#endif // CONFIG_H_
    66 
  • trunk/lib_c/cpp2c/expected_output/debug.hpp

    r3393 r3396  
    2121
    2222#endif // DEBUG_H_
    23 
  • trunk/lib_c/cpp2c/expected_output/hash.hpp

    r3393 r3396  
    154154}
    155155*/
    156 
  • trunk/lib_c/cpp2c/expected_output/mmalloc.hpp

    r3393 r3396  
    3535
    3636#endif // ALIGNED_MMALLOC_H
    37 
  • trunk/lib_c/cpp2c/expected_output/p2s.hpp

    r3393 r3396  
    115115#endif // P2S_H
    116116
    117 
  • trunk/lib_c/cpp2c/expected_output/s2p.hpp

    r3393 r3396  
    213213#endif // S2P_H
    214214
    215 
  • trunk/lib_c/cpp2c/expected_output/stl_aligned_allocator.hpp

    r3393 r3396  
    7777
    7878#endif // STL_ALIGNED_ALLOCATOR_H_
    79 
  • trunk/lib_c/cpp2c/expected_output/transpose.hpp

    r3393 r3396  
    4949#endif // TRANSPOSE_H
    5050
    51 
  • trunk/lib_c/cpp2c/passes.rb

    r3393 r3396  
    121121end
    122122
    123 # use #if #else #end to wrap KEYs
     123# use #if #else #end to wrap KEYs as field width
    124124# e.g.
    125125#   #define Carry0 simd<BLOCK_SIZE>::constant<0>()
     
    137137        def initialize key, values             
    138138                @key = key
     139                @reg_key = Regexp.escape(key)
    139140                @values = values
    140141        end
     
    152153                                res += "#if (#{@key} == #{v}) \n"
    153154                        elsif i == @values.size - 1
    154                                 res += "#else\n"
     155                                res += "#else //#{@key} == #{v}\n"
    155156                        else
    156157                                res += "#elif (#{@key} == #{v})\n"
    157158                        end
    158159
    159                         res += @line_store.gsub /(\{\{\{[^}]*)#{@key}/, "\\1#{v}"
     160                        res += @line_store.gsub /(\{\{\{[^}]*)#{@reg_key}/, "\\1#{v}"
    160161                end
    161162                res += "#endif\n"
     
    166167
    167168        def output_tail outfile, options               
    168                 outfile.puts dump
    169         end
    170 
    171         def t line
    172                 if line =~ /\{\{\{.*#{@key}\b/
     169                res = dump
     170                outfile.puts res if res != ""
     171        end
     172
     173        def t line
     174                if line =~ /\{\{\{.*#{@reg_key}/
    173175                        @line_store += line
    174176                        "<empty>"
     
    179181end
    180182
     183# Slightly different wrap, use "if" insted of "#if"
     184# In order to enable "sizeof()" as wrap condition
     185class ConditionWrapPass1 < ConditionWrapPass
     186        def dump
     187                return "" if @line_store == ""
     188
     189                res = ""               
     190                @values.each_with_index do |v, i| 
     191                        if i == 0
     192                                res += "if (#{@key} == #{v}) {\n"
     193                        elsif i == @values.size - 1
     194                                res += "} else { //#{@key} == #{v}\n"
     195                        else
     196                                res += "} else if (#{@key} == #{v}) {\n"
     197                        end
     198
     199                        res += @line_store.gsub /(\{\{\{[^}]*)#{@reg_key}/, "\\1#{v}"
     200                end
     201                res += "}\n"
     202
     203                @line_store = ""
     204                res
     205        end
     206end
     207
    181208# Eval expressions inside {{{ }}}
    182209# e.g. {{{256 / 2}}} => 128
Note: See TracChangeset for help on using the changeset viewer.