Esempio n. 1
0
 def __init__(self, numcoarsechannels, numfinechannels, accumulation_length, bandwidth, input_bitwidth, fft_coarse_out_bitwidth, antennas=1):
     self.maxdesigns=0
     self.blocks = {}
     self.blockalgs = {}
     self.totalblocks = 0
     
     self.maxdesigns = 1
     self.singleimplementation = 1
     
     #add the platform array
     self.platforms = {}
     
     # add platforms: cost, inputbw, outputbw, resources
     self.platforms['ROACH'] = Platform('ROACH',6700,40,40,['registers','luts','dsp','bram'])
     self.platforms['GTX580'] = Platform('GTX580',3500,10,1,['time'])
     
     
     
     for i in range(0,antennas):
         # add the ADC
         adc_bw = bandwidth*input_bitwidth
         self.blocks['ADC'+`i`] = CBlock('ADC', CBlock.getADCModel(self.platforms, bandwidth, input_bitwidth),-1,0,0,'PFB'+`i`,0,adc_bw,1)
         self.totalblocks += 1
     
         # add the PFB
         pfb_bw = bandwidth*32
         self.blocks['PFB'+`i`] = CBlock('PFB',CBlock.getPFBWModel(self.platforms, bandwidth, pfb_bw, numcoarsechannels),'ADC'+`i`,0,adc_bw,'FFT_coarse'+`i`,0,adc_bw,1)
         self.totalblocks += 1
     
         # add the FFT
         #print CBlock.getFFTModel(self.platforms, bandwidth, input_bitwidth, numchannels)
         fft_coarse_out_bandwidth = bandwidth* fft_coarse_out_bitwidth*2
         self.blocks['FFT_coarse'+`i`] = CBlock('FFT_coarse',CBlock.getFFTWModel(self.platforms, bandwidth, numcoarsechannels),'PFB'+`i`,0,pfb_bw,'Transpose'+`i`,0,fft_coarse_out_bandwidth,1)
         self.totalblocks += 1
         
         # adjust to ensure the block fits on the gpu
         fft_fine_in_bandwidth = fft_coarse_out_bandwidth/numcoarsechannels
         finemodel = CBlock.getFFTModel(self.platforms, fft_fine_in_bandwidth, numfinechannels)
         if(finemodel['GTX580']['time']<0.1):
             multiplier = pow(2,int(log(0.1/finemodel['GTX580']['time'],2)))
         else:
             multiplier = 1
         finemodel['GTX580']['time'] = finemodel['GTX580']['time']*multiplier
         fine_blocks = int(numcoarsechannels/multiplier)
         
         fine_sky_bandwidth = bandwidth/fineblocks
         fine_block_bandwidth = fft_coarse_out_bandwidth/fine_blocks
         
         
         self.blocks['Transpose'+`i`] = CBlock('Transpose', CBlock.getTransposeModel(self.platforms, bandwidth, numcoarsechannels, numfinechannels), 'FFT_coarse'+`i`,0,fft_coarse_out_bandwidth,'FFT_fine'+`i`,1,fft_coarse_out_bandwidth,1)
         self.totalblocks += 1
     
         self.blocks['FFT_fine'+`i`] = CBlock('FFT_fine',finemodel,'Transpose'+`i`,0,fine_block_bandwidth,'VAcc'+`i`,0,fft_fine_in_bandwidth,fine_blocks)
         self.totalblocks += fine_blocks
     
         self.blocks['VAcc'+`i`] = CBlock('VAcc',{'ROACH': {'registers': 0.2, 'luts': 0.1, 'dsp': 0, 'bram':0.4}, 'GTX580': {'time': 0.001}},'FFT_fine'+`i`,0,fine_block_bandwidth,-1,0,0,fine_blocks)
         self.totalblocks += fine_blocks
Esempio n. 2
0
    def __init__(self,
                 numchannels,
                 accumulation_length,
                 bandwidth,
                 input_bitwidth,
                 fft_out_bitwidth,
                 antennas=1):
        self.maxdesigns = 1
        self.blocks = {}
        self.totalblocks = 0

        #add the platform array
        self.platforms = {}

        # add platforms: cost, inputbw, outputbw, resources
        self.platforms['ROACH'] = Platform.createRoach('dollars')
        self.platforms['GTX580'] = Platform.createGTX580Server('dollars')
        #self.platforms['IBOB'] = Platform('IBOB',2000,10,1,['resources'])

        # add the ADC
        adc_bw = bandwidth * input_bitwidth
        self.blocks['ADC'] = CBlock(
            'ADC', CBlock.getADCModel(self.platforms, bandwidth,
                                      input_bitwidth), -1, 0, 0, 'PFB', 0,
            adc_bw, antennas)
        self.totalblocks += antennas

        # add the PFB
        pfb_bw = bandwidth * 32
        self.blocks['PFB'] = CBlock(
            'PFB',
            CBlock.getPFBModel(self.platforms, bandwidth, input_bitwidth,
                               numchannels), 'ADC', 0, pfb_bw, 'FFT', 0,
            adc_bw, antennas)
        self.totalblocks += antennas

        # add the FFT
        fft_out_bandwidth = bandwidth * fft_out_bitwidth
        self.blocks['FFT'] = CBlock(
            'FFT', CBlock.getFFTModel(self.platforms, bandwidth, numchannels),
            'PFB', 0, pfb_bw, 'VAcc', 0, fft_out_bandwidth, antennas)
        self.totalblocks += antennas

        #add the Vacc
        self.blocks['VAcc'] = CBlock(
            'VAcc',
            CBlock.getVAccModel(self.platforms, bandwidth, fft_out_bitwidth,
                                accumulation_length), 'FFT', 0,
            fft_out_bandwidth, -1, 0, 0, antennas)
        self.totalblocks += antennas
Esempio n. 3
0
    def __init__(self,
                 numcoarsechannels,
                 numfinechannels,
                 accumulation_length,
                 bandwidth,
                 input_bitwidth,
                 fft_coarse_out_bitwidth,
                 antennas=1):
        self.maxdesigns = 0
        self.blocks = {}
        self.blockalgs = {}
        self.totalblocks = 0

        self.maxdesigns = 1
        self.singleimplementation = 1

        #add the platform array
        self.platforms = {}

        # add platforms: cost, inputbw, outputbw, resources
        self.platforms['ROACH'] = Platform(
            'ROACH', 6700, 40, 40, ['registers', 'luts', 'dsp', 'bram'])
        self.platforms['GTX580'] = Platform('GTX580', 3500, 10, 1, ['time'])

        for i in range(0, antennas):
            # add the ADC
            adc_bw = bandwidth * input_bitwidth
            self.blocks['ADC' + ` i `] = CBlock(
                'ADC',
                CBlock.getADCModel(self.platforms, bandwidth, input_bitwidth),
                -1, 0, 0, 'PFB' + ` i `, 0, adc_bw, 1)
            self.totalblocks += 1

            # add the PFB
            pfb_bw = bandwidth * 32
            self.blocks['PFB' + ` i `] = CBlock(
                'PFB',
                CBlock.getPFBWModel(self.platforms, bandwidth, pfb_bw,
                                    numcoarsechannels), 'ADC' + ` i `, 0,
                adc_bw, 'FFT_coarse' + ` i `, 0, adc_bw, 1)
            self.totalblocks += 1

            # add the FFT
            #print CBlock.getFFTModel(self.platforms, bandwidth, input_bitwidth, numchannels)
            fft_coarse_out_bandwidth = bandwidth * fft_coarse_out_bitwidth * 2
            self.blocks['FFT_coarse' + ` i `] = CBlock(
                'FFT_coarse',
                CBlock.getFFTWModel(self.platforms, bandwidth,
                                    numcoarsechannels), 'PFB' + ` i `, 0,
                pfb_bw, 'Transpose' + ` i `, 0, fft_coarse_out_bandwidth, 1)
            self.totalblocks += 1

            # adjust to ensure the block fits on the gpu
            fft_fine_in_bandwidth = fft_coarse_out_bandwidth / numcoarsechannels
            finemodel = CBlock.getFFTModel(self.platforms,
                                           fft_fine_in_bandwidth,
                                           numfinechannels)
            if (finemodel['GTX580']['time'] < 0.1):
                multiplier = pow(
                    2, int(log(0.1 / finemodel['GTX580']['time'], 2)))
            else:
                multiplier = 1
            finemodel['GTX580'][
                'time'] = finemodel['GTX580']['time'] * multiplier
            fine_blocks = int(numcoarsechannels / multiplier)

            fine_sky_bandwidth = bandwidth / fineblocks
            fine_block_bandwidth = fft_coarse_out_bandwidth / fine_blocks

            self.blocks['Transpose' + ` i `] = CBlock(
                'Transpose',
                CBlock.getTransposeModel(self.platforms, bandwidth,
                                         numcoarsechannels, numfinechannels),
                'FFT_coarse' + ` i `, 0, fft_coarse_out_bandwidth,
                'FFT_fine' + ` i `, 1, fft_coarse_out_bandwidth, 1)
            self.totalblocks += 1

            self.blocks['FFT_fine' + ` i `] = CBlock('FFT_fine', finemodel,
                                                     'Transpose' + ` i `, 0,
                                                     fine_block_bandwidth,
                                                     'VAcc' + ` i `, 0,
                                                     fft_fine_in_bandwidth,
                                                     fine_blocks)
            self.totalblocks += fine_blocks

            self.blocks['VAcc' + ` i `] = CBlock(
                'VAcc', {
                    'ROACH': {
                        'registers': 0.2,
                        'luts': 0.1,
                        'dsp': 0,
                        'bram': 0.4
                    },
                    'GTX580': {
                        'time': 0.001
                    }
                }, 'FFT_fine' + ` i `, 0, fine_block_bandwidth, -1, 0, 0,
                fine_blocks)
            self.totalblocks += fine_blocks
Esempio n. 4
0
    def __init__(self, numchannels, numantpol, accumulation_length, skybandwidth, input_bitwidth, fft_out_bitwidth):
        self.blocks = {}
        self.totalblocks = 0
        self.maxdesigns = 1
        self.singleimplementation = 1
        self.windowsize = 1024
        cost = 'dollars'
        #cost = 'power'
        
        #add the platforms
        self.platforms = {}
        #self.platforms['GTX580'] = Platform.createGTX580Server(cost)
        #self.platforms['ROACH'] = Platform.createRoach(cost)
        self.platforms['DualGTX690'] = Platform.createDualGTX690Server(cost)
        self.platforms['ROACH2'] = Platform.createRoach2(cost)
        
        
        # add the ADC
        adc_bw = skybandwidth*2*input_bitwidth
        #self.blocks['ADC'] = CBlock('ADC',CBlock.getADCModel(self.platforms, skybandwidth, input_bitwidth),-1,0,0,'FIR',0,4*adc_bw,numantpol/4)
        # we are using a 16 input adc board
        # multiplier needs to be a multiple of 4 because the benchmarks do 4 parallel firs and ffts
        adcmultiplier = 4   # process 4 streams at a time
        self.blocks['ADC'] = CBlock('ADC',CBlock.getADCModel(self.platforms, skybandwidth, input_bitwidth), -1,0,0,'PFB',0,adcmultiplier*adc_bw,numantpol/adcmultiplier, CBlock.getADCMaximums(self.platforms, adcmultiplier))
        self.totalblocks += numantpol/adcmultiplier
        

        #use pfb to process 4 channels at a time
        fft_out_bandwidth = skybandwidth * 2 * fft_out_bitwidth
        pfb_model = CBlock.getPFBModel(self.platforms, skybandwidth, input_bitwidth, numchannels)
        fft_model = CBlock.getFFTRealModel(self.platforms, skybandwidth, numchannels)
        firfftmodel = CBlock.combineModels(pfb_model, fft_model)
        #print firfftmodel
        #firfft2xmodel = CBlock.combineModels(firfftmodel, firfftmodel)
        #print firfft2xmodel
        self.blocks['PFB'] = CBlock('PFB',firfftmodel,'ADC',0,adcmultiplier*adc_bw,'Transpose',0,adcmultiplier*fft_out_bandwidth,numantpol/adcmultiplier)
        self.totalblocks += numantpol/adcmultiplier
        
        transposemodel = CBlock.getTransposeModel(self.platforms, skybandwidth, numchannels, self.windowsize)
        self.blocks['Transpose'] = CBlock('Transpose',transposemodel,'PFB',0,adcmultiplier*fft_out_bandwidth,'XEng',0,adcmultiplier*fft_out_bandwidth,numantpol/adcmultiplier)
        self.totalblocks += numantpol/adcmultiplier

        
        # add the PFBTranspose
        #fft_out_bandwidth = skybandwidth * 2 * fft_out_bitwidth
        #firmodel = CBlock.getPFBModel(self.platforms, skybandwidth, input_bitwidth, numchannels)
        #fftmodel = CBlock.getFFTRealModel(self.platforms, skybandwidth, numchannels)
        #transposemodel = CBlock.getTransposeModel(self.platforms, skybandwidth, numchannels, self.windowsize)
        #combinedmodel = CBlock.combineModels(firmodel, CBlock.combineModels(fftmodel, transposemodel))
        #we need 4 of these for our 16 input adc
        #self.blocks['PFBTranspose'] = CBlock('PFBTranspose',combinedmodel,'ADC',0,adcmultiplier*adc_bw,'XEng',1,adcmultiplier * fft_out_bandwidth,numantpol/adcmultiplier)
        #self.totalblocks += numantpol/adcmultiplier
        
        
        
        # add the XEngines
        gtx580_max_bw = {32:0.06914, 64:0.03095, 96:0.01748, 128:0.01069, 192:0.00536, 256:0.00318, 512:0.00087, 1024:0.00023}
        # the minimum number of xengines we need
        # if we use any fewer, they will not fit on the gpu
        mingpuxengines = int(numpy.power(2,numpy.ceil(numpy.log2(skybandwidth/gtx580_max_bw[numantpol]))))
        
        # assume xengine is running at 200MHz, takes nantpol clock cycles to get the data out for a single frequency channel
        # maximum bandwidth it can process is 200MHz/nantpol
        maxfpgaxengbw = .2/numantpol
        
        #the maximum amount of bandwidth we can process in an xengine and still support our platforms
        maxxenginebw = min(maxfpgaxengbw,gtx580_max_bw[numantpol])
        
        # we need to create this many xengines to meet the spec
        minxengines = int(skybandwidth/maxxenginebw)
        
        #note: this needs to be a power of 2
        numxengines = 8*minxengines
        
        #numxengines = 4*mingpuxengines
        #print 'Num xengines is: ' + `numxengines`
        #numxengines = mingpuxengines*4
        xengine_sky_bandwidth = skybandwidth/numxengines
        #print 'Sky bw is: ' + `xengine_sky_bandwidth`
        #print xengine_sky_bandwidth
        xengine_in_bandwidth = numantpol*fft_out_bandwidth/numxengines
        #print CBlock.getXEngModel(self.platforms, xengine_sky_bandwidth, numantpol)
        self.blocks['XEng'] = CBlock('XEng',CBlock.getXEngModel(self.platforms, xengine_sky_bandwidth, numantpol) ,'Transpose', 1,xengine_in_bandwidth,-1,0,0,numxengines)
        self.totalblocks += numxengines
Esempio n. 5
0
    def __init__(self, numchannels, numantpol, accumulation_length,
                 skybandwidth, input_bitwidth, fft_out_bitwidth):
        self.blocks = {}
        self.totalblocks = 0
        self.maxdesigns = 1
        self.singleimplementation = 1
        self.windowsize = 1024
        cost = 'dollars'
        #cost = 'power'

        #add the platforms
        self.platforms = {}
        #self.platforms['GTX580'] = Platform.createGTX580Server(cost)
        #self.platforms['ROACH'] = Platform.createRoach(cost)
        self.platforms['DualGTX690'] = Platform.createDualGTX690Server(cost)
        self.platforms['ROACH2'] = Platform.createRoach2(cost)

        # add the ADC
        adc_bw = skybandwidth * 2 * input_bitwidth
        #self.blocks['ADC'] = CBlock('ADC',CBlock.getADCModel(self.platforms, skybandwidth, input_bitwidth),-1,0,0,'FIR',0,4*adc_bw,numantpol/4)
        # we are using a 16 input adc board
        # multiplier needs to be a multiple of 4 because the benchmarks do 4 parallel firs and ffts
        adcmultiplier = 4  # process 4 streams at a time
        self.blocks['ADC'] = CBlock(
            'ADC',
            CBlock.getADCModel(self.platforms, skybandwidth,
                               input_bitwidth), -1, 0, 0, 'PFB', 0,
            adcmultiplier * adc_bw, numantpol / adcmultiplier,
            CBlock.getADCMaximums(self.platforms, adcmultiplier))
        self.totalblocks += numantpol / adcmultiplier

        #use pfb to process 4 channels at a time
        fft_out_bandwidth = skybandwidth * 2 * fft_out_bitwidth
        pfb_model = CBlock.getPFBModel(self.platforms, skybandwidth,
                                       input_bitwidth, numchannels)
        fft_model = CBlock.getFFTRealModel(self.platforms, skybandwidth,
                                           numchannels)
        firfftmodel = CBlock.combineModels(pfb_model, fft_model)
        #print firfftmodel
        #firfft2xmodel = CBlock.combineModels(firfftmodel, firfftmodel)
        #print firfft2xmodel
        self.blocks['PFB'] = CBlock('PFB', firfftmodel, 'ADC', 0,
                                    adcmultiplier * adc_bw, 'Transpose', 0,
                                    adcmultiplier * fft_out_bandwidth,
                                    numantpol / adcmultiplier)
        self.totalblocks += numantpol / adcmultiplier

        transposemodel = CBlock.getTransposeModel(self.platforms, skybandwidth,
                                                  numchannels, self.windowsize)
        self.blocks['Transpose'] = CBlock('Transpose', transposemodel, 'PFB',
                                          0, adcmultiplier * fft_out_bandwidth,
                                          'XEng', 0,
                                          adcmultiplier * fft_out_bandwidth,
                                          numantpol / adcmultiplier)
        self.totalblocks += numantpol / adcmultiplier

        # add the PFBTranspose
        #fft_out_bandwidth = skybandwidth * 2 * fft_out_bitwidth
        #firmodel = CBlock.getPFBModel(self.platforms, skybandwidth, input_bitwidth, numchannels)
        #fftmodel = CBlock.getFFTRealModel(self.platforms, skybandwidth, numchannels)
        #transposemodel = CBlock.getTransposeModel(self.platforms, skybandwidth, numchannels, self.windowsize)
        #combinedmodel = CBlock.combineModels(firmodel, CBlock.combineModels(fftmodel, transposemodel))
        #we need 4 of these for our 16 input adc
        #self.blocks['PFBTranspose'] = CBlock('PFBTranspose',combinedmodel,'ADC',0,adcmultiplier*adc_bw,'XEng',1,adcmultiplier * fft_out_bandwidth,numantpol/adcmultiplier)
        #self.totalblocks += numantpol/adcmultiplier

        # add the XEngines
        gtx580_max_bw = {
            32: 0.06914,
            64: 0.03095,
            96: 0.01748,
            128: 0.01069,
            192: 0.00536,
            256: 0.00318,
            512: 0.00087,
            1024: 0.00023
        }
        # the minimum number of xengines we need
        # if we use any fewer, they will not fit on the gpu
        mingpuxengines = int(
            numpy.power(
                2,
                numpy.ceil(numpy.log2(skybandwidth /
                                      gtx580_max_bw[numantpol]))))

        # assume xengine is running at 200MHz, takes nantpol clock cycles to get the data out for a single frequency channel
        # maximum bandwidth it can process is 200MHz/nantpol
        maxfpgaxengbw = .2 / numantpol

        #the maximum amount of bandwidth we can process in an xengine and still support our platforms
        maxxenginebw = min(maxfpgaxengbw, gtx580_max_bw[numantpol])

        # we need to create this many xengines to meet the spec
        minxengines = int(skybandwidth / maxxenginebw)

        #note: this needs to be a power of 2
        numxengines = 8 * minxengines

        #numxengines = 4*mingpuxengines
        #print 'Num xengines is: ' + `numxengines`
        #numxengines = mingpuxengines*4
        xengine_sky_bandwidth = skybandwidth / numxengines
        #print 'Sky bw is: ' + `xengine_sky_bandwidth`
        #print xengine_sky_bandwidth
        xengine_in_bandwidth = numantpol * fft_out_bandwidth / numxengines
        #print CBlock.getXEngModel(self.platforms, xengine_sky_bandwidth, numantpol)
        self.blocks['XEng'] = CBlock(
            'XEng',
            CBlock.getXEngModel(self.platforms, xengine_sky_bandwidth,
                                numantpol), 'Transpose', 1,
            xengine_in_bandwidth, -1, 0, 0, numxengines)
        self.totalblocks += numxengines