Exemplo n.º 1
0
	virtual void stream_body(wi_run_state &run_state) override {
		
		run_state.start_substream(0.0);
		thread main_t(&vdif_assembler::run, assembler);
			
		for (;;) {	
			float *intensity;
			float *weights;
			ssize_t stride;
			bool zero_flag = false;
			
			run_state.setup_write(nt_maxwrite, intensity, weights, stride, zero_flag);
			
			assembler->get_intensity_chunk(intensity,stride);
			
			//initialize weight to 1.0
			for (int i = 0; i < nfreq; i++) {
				for (int j = 0; j < nt_maxwrite; j++) {		
					weights[i*stride + j] = 1.0;
				}
			}
			//cout << "Bonsai received a chunk." << endl;

			run_state.finalize_write(nt_maxwrite);
					
		}
		run_state.end_substream();
		
		main_t.join();
	}
Exemplo n.º 2
0
void psrfits_stream::stream_body(wi_run_state &run_state)
{
    // FIXME psrfits_stream currently sets the initial time of the stream to zero.
    // What's a sensible way to determine an initial time from a 'struct psrfits'?
    double t0 = 0.0;
    run_state.start_substream(t0);

    while (!p->eof) {
	float *intensity;
	float *weights;
	ssize_t stride;
	bool zero_flag = false;
	run_state.setup_write(this->nt_maxwrite, intensity, weights, stride, zero_flag);

	// Transpose and convert uint8 -> float
	for (ssize_t it = 0; it < nt_maxwrite; it++)
	    for (ssize_t ifreq = 0; ifreq < nfreq; ifreq++)
		intensity[ifreq*stride + it] = (float)p->data[it*nfreq + ifreq];

	// psrfits weights are per-(frequency,chunk), not per-(frequency,sample)
	for (ssize_t ifreq = 0; ifreq < nfreq; ifreq++) {
	    float w = p->freq_weights[ifreq];
	    if (w < 0.0)
		throw runtime_error(p->filename + ": negative weight in file, this is currently treated as an error");
	
	    for (ssize_t it = 0; it < nt_maxwrite; it++)
		weights[ifreq*stride + it] = w;
	}

	run_state.finalize_write(this->nt_maxwrite);
	p->read_next_row();
    }

    run_state.end_substream();
}
    //
    // This overrides the pure virtual function wi_stream::stream_body() and defines the stream.
    // For a high-level overview, see comments in rf_pipelines.hpp (in class wi_stream).
    // The 'run_state' argument contains ring buffers which the stream will write data into.
    //
    virtual void stream_body(wi_run_state &run_state) override
    {
	std::random_device rd;
	std::mt19937 rng(rd());
	std::normal_distribution<float> dist(0, sample_rms);

	// In general a stream can be composed of multiple "substreams" (see rf_pipelines.hpp).
	// Here we put everything into a single stream, with nominal starting time t=0.
	run_state.start_substream(0.0);
	
	// Current position in stream (such that 0 <= it0 < nt_tot, where nt_tot is the stream length)
	ssize_t it0 = 0;

	while (it0 < nt_tot) {
	    // Number of samples to write in this block
	    ssize_t nt = min(nt_maxwrite, nt_tot-it0);
	    
	    // Call wi_run_state::setup_write() to reserve space in the ring buffers.
	    // For details, see comments in rf_pipelines.hpp (in class wi_run_state).
	    float *intensity;
	    float *weights;
	    ssize_t stride;
	    bool zero_flag = false;   // no need to zero buffers, since we'll overwrite them shortly
	    run_state.setup_write(nt, intensity, weights, stride, zero_flag);

	    // After setup_write() returns, the 'intensity' and 'weights' pointers point to memory
	    // regions in the ring buffers.  These are logical 2D arrays of shape (nfreq,nt), laid
	    // out in memory so that time samples are adjacent, but frequencies are separated by
	    // offset 'stride'.  Therefore, the memory location of the intensity array element with
	    // (frequency,time) indices (ifreq,it) is intensity[ifreq*stride+it], and similarly for
	    // the weights.

	    // Fill the intensity array with Gaussian random numbers, and initialize the weights to 1.
	    for (ssize_t ifreq = 0; ifreq < nfreq; ifreq++) {
		for (ssize_t it = 0; it < nt; it++) {
		    intensity[ifreq*stride + it] = dist(rng);
		    weights[ifreq*stride + it] = 1.0;
		}
	    }

	    // Call wi_run_state::finalize_write() after filling the arrays, to advance the ring buffers.
	    // After finalize_write() returns, the intensity and weights pointers are no longer valid.
	    run_state.finalize_write(nt);

	    it0 += nt;
	}

	run_state.end_substream();
    }