Changeset 520 for soft


Ignore:
Timestamp:
Mar 10, 2015, 3:12:37 PM (10 years ago)
Author:
alain
Message:

1) Simplification of the mapping objects: the coproc and cp_port objects
have been removedr.:A coprocessor is now described as a peripheral with MWR type,
and the coprocessor type is defined by the subtype argument.
The addPeriph() prototype has been modified to support 4 arguments: arg0, arg1, arg2, arg3
(the semanting depends on the peripheral type).

2) A new application, called "coproc", and using the GCD coprocessor and
the MWMR_DMA controller, has been introduced in genmap.

Location:
soft/giet_vm/giet_python
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • soft/giet_vm/giet_python/genmap

    r500 r520  
    66#   author : Alain Greiner
    77#######################################################################################
    8 # This generic script maps one or several multi-tasks applications on a specific
     8# This generic script maps one or several applications on a specific
    99# instance of the multi-processors/multi-clusters TSAR architecture.
    1010# It generates the files required for hardware and software compilation:
    11 # 1) The "hard_config.h" file is used to generate the top.cppnetbsd file (hardware),
     11# 1) The "hard_config.h" file is used to generate the top.cpp file (hardware),
    1212#    and to compile the tsar_preloader.elf, the GietVM boot.elf and kernel.elf files.
    1313# 2) The optionals "map.bin" and vsegs.ld" files are used to configure the GietVM.
     
    2727# - tsar_generic_iob
    2828# - tsar_generic_leti
     29# - tsar_geberic_mwmr
    2930#######################################################################################
    3031# The supported applications are:
     
    3637# - display
    3738# - gameoflife
     39# - coproc
    3840#######################################################################################
    3941
     
    123125                   default = False,
    124126                   help = 'map the "gameoflife" application for the GietVM' )
     127
     128parser.add_option( '--coproc', action = 'store_true', dest = 'coproc',     
     129                   default = False,
     130                   help = 'map the "coproc" application for the GietVM' )
    125131
    126132######################################################################################
     
    155161map_classif    = options.classif     # map "classif" application if True
    156162map_gameoflife = options.gameoflife  # map "gameoflife" application if True
     163map_coproc     = options.coproc      # map "coproc" application if True
    157164
    158165######################################################################################
     
    213220    print '[genmap] application "gameoflife" will be loaded'
    214221
     222if ( map_coproc ):
     223    app = __import__( 'coproc' )
     224    app.coproc( mapping )
     225    print '[genmap] application "coproc" will be loaded'
     226
    215227######################################################################################
    216228#   Generate xml file if required.
  • soft/giet_vm/giet_python/mapping.py

    r517 r520  
    1010#  This file contains the classes required to define a mapping for the GIET_VM.
    1111# - A 'Mapping' contains a set of 'Cluster'   (hardware architecture)
    12 #                        a set of 'Vseg'      (kernel virtual segments, called globals)
    13 #                        a set of 'Vspace'    (one or several user applications).
     12#                        a set of 'Vseg'      (kernel glogals virtual segments)
     13#                        a set of 'Vspace'    (one or several user applications)
    1414# - A 'Cluster' contains a set of 'Pseg'      (physical segments in cluster)
    1515#                        a set of 'Proc'      (processors in cluster)
    1616#                        a set of 'Periph'    (peripherals in cluster)
    17 #                        a set of 'Coproc'    (coprocessors in cluster)
    1817# - A 'Vspace' contains  a set of 'Vseg'      (user virtual segments)
    1918#                        a set of 'Task'      (user parallel tasks)
    2019# - A 'Periph' contains  a set of 'Irq'       (only for XCU and PIC types )
    21 # - A 'Coproc' contains  a set of 'Cpports'   (one port per MWMR channel)
    2220########################################################################################
    2321# Implementation Note
     
    4240VPN_ANTI_MASK     = 0x00000FFF    # mask virtual address to get offset in a small page
    4341BPN_MASK          = 0xFFE00000    # mask virtual address to get the BPN (big page)
    44 PERI_INCREMENT    = 0x10000       # virtual address increment for replicated global vsegs
     42PERI_INCREMENT    = 0x10000       # virtual address increment for replicated l vsegs
    4543RESET_ADDRESS     = 0xBFC00000    # Processor wired boot_address
    4644MAPPING_SIGNATURE = 0xDACE2014    # Magic number indicating a valid C binary struture
    4745
    4846########################################################################################
    49 # These global lists must be consistent with enums in mapping_info.h or irq_handler.
     47# These lists must be consistent with values defined in
     48# mapping_info.h / xml_driver.c /xml_parser.c
    5049########################################################################################
    5150PERIPHTYPES =    [
     
    6766                 ]
    6867
    69 PERIPHSUBTYPES = [
     68IOCSUBTYPES =    [
    7069                  'BDV',
    7170                  'HBA',
     
    7473                 ]
    7574
     75MWRSUBTYPES =    [
     76                  'GCD',
     77                  'DCT',
     78                 ]
     79   
     80######################################################################################
     81# These lists must be consistent with values defined in
     82# irq_handler.c / irq_handler.h / xml_driver.c / xml_parser.c
     83######################################################################################
    7684IRQTYPES =       [
    7785                  'HWI',
     
    94102                  'ISR_DMA',
    95103                  'ISR_SPI',
     104                  'ISR_MWR'
    96105                 ]
    97106
     
    132141PSEGTYPES =      [
    133142                  'RAM',
    134                   'ROM',        # deprecated => use PERI
    135143                  'PERI',
    136                  ]
    137 
    138 CP_PORT_DIRS =   [
    139                   'TO_COPROC',
    140                   'FROM_COPROC',
    141144                 ]
    142145
     
    194197        self.total_procs    = 0
    195198        self.total_irqs     = 0
    196         self.total_coprocs  = 0
    197         self.total_cpports  = 0
    198199        self.total_periphs  = 0
    199200
     
    247248                   subtype  = 'NONE',  # peripheral subtype
    248249                   channels = 1,       # number of channels
    249                    arg      = 0 ):     # optional argument (semantic depends on ptype)
     250                   arg0     = 0,       # optional argument (semantic depends on ptype)
     251                   arg1     = 0,       # optional argument (semantic depends on ptype)
     252                   arg2     = 0,       # optional argument (semantic depends on ptype)
     253                   arg3     = 0 ):     # optional argument (semantic depends on ptype)
    250254
    251255        # computes cluster index and coordinates from the base address
     
    261265        assert ptype in PERIPHTYPES
    262266
    263         assert subtype in PERIPHSUBTYPES
     267        if (ptype == 'IOC'): assert subtype in IOCSUBTYPES
     268        if (ptype == 'MWR'): assert subtype in MWRSUBTYPES
    264269
    265270        # add one pseg into mapping
     
    270275
    271276        # add one periph into mapping
    272         periph = Periph( pseg, ptype, subtype, channels, arg )
     277        periph = Periph( pseg, ptype, subtype, channels, arg0, arg1, arg2, arg3 )
    273278        self.clusters[cluster_id].periphs.append( periph )
    274279        periph.index = self.total_periphs
     
    300305                 x,                    # cluster x coordinate
    301306                 y,                    # cluster y coordinate
    302                  p ):                  # processor local index
     307                 lpid ):               # processor local index
    303308
    304309        assert (x < self.x_size) and (y < self.y_size)
     
    307312
    308313        # add one proc into mapping
    309         proc = Processor( x, y, p )
     314        proc = Processor( x, y, lpid )
    310315        self.clusters[cluster_id].procs.append( proc )
    311316        proc.index = self.total_procs
     
    313318
    314319        return proc
    315 
    316     ##############################    add a coprocessor in a cluster
    317     def addCoproc( self,
    318                    name,               # associated pseg name
    319                    base,               # associated pseg base address
    320                    size ):             # associated pseg length
    321 
    322         # check cluster coordinates (obtained from the base address)
    323         cluster_xy = base >> (self.paddr_width - self.x_width - self.y_width)
    324         x = cluster_xy >> (self.y_width);
    325         y = cluster_xy & ((1 << self.y_width) - 1)
    326 
    327         assert (x < self.x_size) and (y < self.y_size)
    328 
    329         cluster_id = (x * self.y_size) + y
    330 
    331         # add one pseg into mapping
    332         pseg = Pseg( name, base, size, x, y, 'PERI' )
    333         self.clusters[cluster_id].psegs.append( pseg )
    334         pseg.index = self.total_psegs
    335         self.total_psegs += 1
    336 
    337         # add one coproc into mapping
    338         periph = Coproc( pseg )
    339         self.clusters[cluster_id].coprocs.append( coproc )
    340         periph.index = self.total_coprocs
    341         self.total_coprocs += 1
    342 
    343         return coproc
    344 
    345     ##################################    add a port in a coprocessor
    346     def addPort( self,
    347                  coproc,               # coprocessor containing the port
    348                  direction,            # direction (TO_COPROC / FROM_COPROC)
    349                  vspacename,           # name of vspace using the coproc
    350                  mwmrname ):           # name of the vseg containing the MWMR channel
    351 
    352         assert direction in CP_PORT_DIRS
    353 
    354         # add one cpport into mapping
    355         port = Cpport( direction, vspacename, mwmrname )
    356         coproc.ports.append( port )
    357         port.index = self.total_cpports
    358         self.total_cpports += 1
    359 
    360         return port
    361320
    362321    ############################    add one global vseg into mapping
     
    547506        byte_stream += self.int2bytes(4,  self.total_procs)
    548507        byte_stream += self.int2bytes(4,  self.total_irqs)
    549         byte_stream += self.int2bytes(4,  self.total_coprocs)
    550         byte_stream += self.int2bytes(4,  self.total_cpports)
    551508        byte_stream += self.int2bytes(4,  self.total_periphs)
    552509        byte_stream += self.str2bytes(32, self.name)
     
    570527            print 'total_procs   = %d' % self.total_procs
    571528            print 'total_irqs    = %d' % self.total_irqs
    572             print 'total_coprocs = %d' % self.total_coprocs
    573             print 'total_cpports = %d' % self.total_cpports
    574529            print 'total_periphs = %d' % self.total_periphs
    575530            print '\n'
     
    640595        if ( verbose ): print '\n'
    641596
    642         # coprocs array
    643         index = 0
    644         for cluster in self.clusters:
    645             for coproc in cluster.coprocs:
    646                 byte_stream += coproc.cbin( self, verbose, index )
    647                 index += 1
    648 
    649         if ( verbose ): print '\n'
    650 
    651         # cpports array
    652         index = 0
    653         for cluster in self.clusters:
    654             for coproc in cluster.coprocs:
    655                 for port in coproc.ports:
    656                     byte_stream += port.cbin( self, verbose, index )
    657                     index += 1
    658 
    659         if ( verbose ): print '\n'
    660 
    661597        # periphs array
    662598        index = 0
     
    778714        nb_fbf       = 0
    779715        fbf_channels = 0
    780         fbf_arg      = 0
    781716        seg_fbf_base = 0xFFFFFFFF
    782717        seg_fbf_size = 0
     718        fbf_arg0     = 0
     719        fbf_arg1     = 0
    783720
    784721        nb_iob       = 0
     
    801738        seg_mwr_base = 0xFFFFFFFF
    802739        seg_mwr_size = 0
     740        mwr_arg0     = 0
     741        mwr_arg1     = 0
     742        mwr_arg2     = 0
     743        mwr_arg3     = 0
    803744
    804745        nb_nic       = 0
     
    834775        nb_xcu       = 0
    835776        xcu_channels = 0
    836         xcu_arg      = 0
    837777        seg_xcu_base = 0xFFFFFFFF
    838778        seg_xcu_size = 0
     779        xcu_arg0     = 0
    839780
    840781        nb_drom       = 0
     
    866807                    seg_fbf_size = periph.pseg.size
    867808                    fbf_channels = periph.channels
    868                     fbf_arg      = periph.arg
     809                    fbf_arg0     = periph.arg0
     810                    fbf_arg1     = periph.arg1
    869811                    nb_fbf +=1
    870812
     
    895837                elif ( periph.ptype == 'MWR' ):
    896838                    seg_mwr_base = periph.pseg.base & 0xFFFFFFFF
    897                     seg_wmr_size = periph.pseg.size
     839                    seg_mwr_size = periph.pseg.size
    898840                    mwr_channels = periph.channels
     841                    mwr_arg0     = periph.arg0
     842                    mwr_arg1     = periph.arg1
     843                    mwr_arg2     = periph.arg2
     844                    mwr_arg3     = periph.arg3
    899845                    nb_mwr +=1
    900846
     
    945891                    seg_xcu_size = periph.pseg.size
    946892                    xcu_channels = periph.channels
    947                     xcu_arg      = periph.arg
     893                    xcu_arg0     = periph.arg0
    948894                    nb_xcu +=1
    949895
     
    10781024        s += '#define USE_IOC_RDK            %d\n'    % self.use_ramdisk
    10791025        s += '\n'
    1080         s += '#define FBUF_X_SIZE            %d\n'    % fbf_arg
    1081         s += '#define FBUF_Y_SIZE            %d\n'    % fbf_arg
    1082         s += '\n'
    1083         s += '#define XCU_NB_INPUTS          %d\n'    % xcu_arg
     1026        s += '#define FBUF_X_SIZE            %d\n'    % fbf_arg0
     1027        s += '#define FBUF_Y_SIZE            %d\n'    % fbf_arg1
     1028        s += '\n'
     1029        s += '#define XCU_NB_INPUTS          %d\n'    % xcu_arg0
     1030        s += '\n'
     1031        s += '#define MWR_TO_COPROC          %d\n'    % mwr_arg0
     1032        s += '#define MWR_FROM_COPROC        %d\n'    % mwr_arg1
     1033        s += '#define MWR_CONFIG             %d\n'    % mwr_arg2
     1034        s += '#define MWR_STATUS             %d\n'    % mwr_arg3
    10841035        s += '\n'
    10851036
     
    17641715            nb_cpus = len( cluster.procs )
    17651716            nb_devs = len( cluster.periphs )
    1766             if ( len( cluster.coprocs ) != 0 ):
    1767                 print 'Error in almos_archinfo() coprocessors not supported yet'
    1768                 sys.exit(1)
    17691717
    17701718            # search a RAM
     
    18731821        self.psegs       = []            # filled by addRam() or addPeriph()
    18741822        self.procs       = []            # filled by addProc()
    1875         self.coprocs     = []            # filled by addCoproc()
    18761823        self.periphs     = []            # filled by addPeriph()
    18771824
     
    18841831        for pseg in self.psegs:   s += pseg.xml()
    18851832        for proc in self.procs:   s += proc.xml()
    1886         for copr in self.coprocs: s += copr.xml()
    18871833        for peri in self.periphs: s += peri.xml()
    18881834        s += '        </cluster>\n'
     
    19131859        else:
    19141860            proc_id = 0
    1915 
    1916         # compute global index for first coproc
    1917         if ( len(self.coprocs) > 0 ):
    1918             coproc_id = self.coprocs[0].index
    1919         else:
    1920             coproc_id = 0
    19211861
    19221862        # compute global index for first periph
     
    19331873        byte_stream += mapping.int2bytes( 4 , len( self.procs ) )   # number procs in cluster
    19341874        byte_stream += mapping.int2bytes( 4 , proc_id )             # first proc global index
    1935         byte_stream += mapping.int2bytes( 4 , len( self.coprocs ) ) # number coprocs in cluster
    1936         byte_stream += mapping.int2bytes( 4 , coproc_id )           # first coproc global index
    19371875        byte_stream += mapping.int2bytes( 4 , len( self.periphs ) ) # number periphs in cluster
    19381876        byte_stream += mapping.int2bytes( 4 , periph_id )           # first periph global index
     
    19431881            print 'nb_procs   = %d' %  len( self.procs )
    19441882            print 'proc_id    = %d' %  proc_id
    1945             print 'nb_coprocs = %d' %  len( self.coprocs )
    1946             print 'coproc_id  = %d' %  coproc_id
    19471883            print 'nb_periphs = %d' %  len( self.periphs )
    19481884            print 'periph_id  = %d' %  periph_id
     
    23702306                  subtype  = 'NONE',  # peripheral subtype
    23712307                  channels = 1,       # for multi-channels peripherals
    2372                   arg      = 0 ):     # optional argument (semantic depends on ptype)
    2373 
    2374         assert ptype in PERIPHTYPES
    2375 
    2376         assert subtype in PERIPHSUBTYPES
     2308                  arg0     = 0,       # optional argument (semantic depends on ptype)
     2309                  arg1     = 0,       # optional argument (semantic depends on ptype)
     2310                  arg2     = 0,       # optional argument (semantic depends on ptype)
     2311                  arg3     = 0 ):     # optional argument (semantic depends on ptype)
    23772312
    23782313        self.index    = 0            # global index ( set by addPeriph() )
     
    23802315        self.ptype    = ptype
    23812316        self.subtype  = subtype
    2382         self.arg      = arg
     2317        self.arg0     = arg0
     2318        self.arg1     = arg1
     2319        self.arg2     = arg2
     2320        self.arg3     = arg3
    23832321        self.pseg     = pseg
    23842322        self.irqs     = []
     
    23922330        s += ' psegname="%s"'                % self.pseg.name
    23932331        s += ' channels="%d"'                % self.channels
    2394         s += ' arg="%d" >\n'                 % self.arg
     2332        s += ' arg0="%d"'                    % self.arg0
     2333        s += ' arg1="%d"'                    % self.arg1
     2334        s += ' arg2="%d"'                    % self.arg2
     2335        s += ' arg3="%d"'                    % self.arg3
    23952336        if ( (self.ptype == 'PIC') or (self.ptype == 'XCU') ):
     2337            s += ' >\n'
    23962338            for irq in self.irqs: s += irq.xml()
    2397         s += '            </periph>\n'
    2398 
     2339            s += '            </periph>\n'
     2340        else:
     2341            s += ' />\n'
    23992342        return s
    24002343
     
    24332376        # compute numerical value for subtype
    24342377        subtype_id = 0xFFFFFFFF
    2435         for x in xrange( len(PERIPHSUBTYPES) ):
    2436             if ( self.subtype == PERIPHSUBTYPES[x] ):  subtype_id = x
    2437 
    2438         # compute
     2378        if (self.ptype == 'IOC'):
     2379            for x in xrange( len(IOCSUBTYPES) ):
     2380                if ( self.subtype == IOCSUBTYPES[x] ):  subtype_id = x
     2381        if (self.ptype == 'MWR'):
     2382            for x in xrange( len(MWRSUBTYPES) ):
     2383                if ( self.subtype == MWRSUBTYPES[x] ):  subtype_id = x
     2384       
    24392385        byte_stream = bytearray()
    24402386        byte_stream += mapping.int2bytes( 4 , ptype_id )         # peripheral type
     
    24422388        byte_stream += mapping.int2bytes( 4 , pseg_id )          # pseg global index
    24432389        byte_stream += mapping.int2bytes( 4 , self.channels )    # number of channels
    2444         byte_stream += mapping.int2bytes( 4 , self.arg )         # optionnal argument
     2390        byte_stream += mapping.int2bytes( 4 , self.arg0 )        # optionnal arg0
     2391        byte_stream += mapping.int2bytes( 4 , self.arg1 )        # optionnal arg1
     2392        byte_stream += mapping.int2bytes( 4 , self.arg2 )        # optionnal arg2
     2393        byte_stream += mapping.int2bytes( 4 , self.arg3 )        # optionnal arg3
    24452394        byte_stream += mapping.int2bytes( 4 , len( self.irqs ) ) # number of input irqs
    24462395        byte_stream += mapping.int2bytes( 4 , irq_id )           # first irq global index
     
    24482397        if ( verbose ):
    24492398            print 'ptype      = %d' %  ptype_id
     2399            print 'subtype    = %d' %  subtype_id
    24502400            print 'pseg_id    = %d' %  pseg_id
    24512401            print 'nb_irqs    = %d' %  len( self.irqs )
     
    25272477        return byte_stream
    25282478
    2529 ######################################################################################
    2530 class Coproc ( object ):
    2531 ######################################################################################
    2532     def __init__( self,
    2533                   pseg ):           # associated pseg
    2534 
    2535         self.index    = 0        # global index value set by addCoproc()
    2536         self.pseg     = pseg
    2537         self.ports    = []
    2538 
    2539         return
    2540 
    2541     ################
    2542     def xml( self ):    # xml for Coproc
    2543 
    2544         print '[genmap error] in Coproc.xml() : not defined yet'
    2545         sys.exit(1)
    2546 
    2547         return
    2548 
    2549     #############################################
    2550     def cbin( self, mapping, verbose, expected ):    # C binary structure for Coproc
    2551 
    2552         if ( verbose ):
    2553             print '*** cbin for coproc in cluster (%d,%d)' % (self.pseg.x, self.pseg.y)
    2554 
    2555         # check index
    2556         if (self.index != expected):
    2557             print '[genmap error] in Coproc.cbin()'
    2558             print '    coproc global index = %d / expected = %d' % (self.index,expected)
    2559             sys.exit(1)
    2560 
    2561         # compute pseg global index
    2562         pseg_id = self.pseg.index
    2563 
    2564         # compute first port global index
    2565         port_id = self.ports[0].index
    2566 
    2567         byte_stream = bytearray()
    2568         byte_stream += mapping.str2bytes( 32, self.pseg.name )    # probablement inutile (AG)
    2569         byte_stream += mapping.int2bytes( 4 , pseg_id )           # pseg global index
    2570         byte_stream += mapping.int2bytes( 4 , len( self.ports ) ) # number of input irqs
    2571         byte_stream += mapping.int2bytes( 4 , port_id )           # first port global index
    2572 
    2573         if ( verbose ):
    2574             print 'irqtype    = %s' %  self.irqtype
    2575             print 'pseg_id    = %d' %  pseg_id
    2576             print 'nb_ports   = %d' %  len( self.ports )
    2577             print 'port_id      %d' %  port_id
    2578 
    2579         return byte_stream
    2580 
    2581 ######################################################################################
    2582 class Cpport ( object ):
    2583 ######################################################################################
    2584     def __init__( self,
    2585                   direction,
    2586                   vspacename,
    2587                   mwmrname ):
    2588 
    2589         self.index      = 0           # global index ( set by addCpport() )
    2590         self.direction  = direction   # TO_COPROC / FROM_COPROC
    2591         self.vspacename = vspacename  # name of vspace containing mwmr channel
    2592         self.mwmrname   = mwmrname    # name of vseg defining mwmr channel
    2593 
    2594         return
    2595 
    2596     ################
    2597     def xml( self ):    # xml for Cpport
    2598 
    2599         print '[genmap error] in Cpport.xml() : not defined yet'
    2600         sys.exit(1)
    2601 
    2602         return
    2603 
    2604     #############################################
    2605     def cbin( self, mapping, verbose, expected ):    # C binary structure for Cpport
    2606 
    2607         if ( verbose ):
    2608             print '*** cbin for cpport[%d]' % (self.index)
    2609 
    2610         # check index
    2611         if ( self.index != expected ):
    2612             print '[genmap error] in Cpport.cbin()'
    2613             print '    port global index = %d / expected = %d' % (self.index,expected)
    2614             sys.exit(1)
    2615 
    2616         # compute numerical value for direction
    2617         if ( self.direction == 'TO_COPROC' ):
    2618              dir_int = 0
    2619         else:
    2620              dir_int = 1
    2621 
    2622         # compute vspace global index
    2623         vspace_id = 0xFFFFFFFF
    2624         for vspace in mapping.vspaces:
    2625             if ( self.vspacename == vspace.name ): vspace_id = vspace.index
    2626 
    2627         if (vspace_id == 0xFFFFFFFF):
    2628             print '[genmap error] in Cpport.cbin()'
    2629             print '    vspace name %s not found'  % ( self.vspacename )
    2630             sys.exit(1)
    2631 
    2632         # compute mwmr vseg global index
    2633         mwmr_id = 0xFFFFFFFF
    2634         for vseg in mapping.vspace[vspace_id].vsegs:
    2635                 if (self.mwmrname == vseg.name): mwmr_id = vseg.index
    2636 
    2637         if (mwmr_id == 0xFFFFFFFF):
    2638             print '[genmap error] in Cpport.cbin()'
    2639             print '    mwmr vseg name %s not found in vspace %s' \
    2640                   % ( self.mwmrname, self.vspacename )
    2641             sys.exit(1)
    2642 
    2643         byte_stream = bytearray()
    2644         byte_stream += mapping.int2bytes( 4 , dir_int )         # pseg global index
    2645         byte_stream += mapping.int2bytes( 4 , vspace_id )       # vspace global index
    2646         byte_stream += mapping.int2bytes( 4 , mwmr_id )         # mwmr vseg global index
    2647 
    2648         if ( verbose ):
    2649             print 'direction  = %s' %  self.direction
    2650             print 'vspace_id  = %d' %  vspace_id
    2651             print 'mwmr_id    = %d' %  mwmr_id
    2652 
    2653         return byte_stream
    2654 
    2655 
    26562479# Local Variables:
    26572480# tab-width: 4;
Note: See TracChangeset for help on using the changeset viewer.