mirrors
/
gnss-sdr
mirror of https://github.com/gnss-sdr/gnss-sdr
1
0
Fork 0
Code Issues Releases Wiki Activity

Improve source code visualization in some code editors

This commit is contained in:
Carles Fernandez 2022-06-02 21:41:19 +02:00
parent 918477d61f
commit cfa7a4af48
No known key found for this signature in database
GPG Key ID: 4C583C52B0C3877D
9 changed files with 29 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/algorithms/PVT/gnuradio_blocks/rtklib_pvt_gs.cc
View File

@ -1951,7 +1951,7 @@ void rtklib_pvt_gs::initialize_and_apply_carrier_phase_offset()
int rtklib_pvt_gs::work(int noutput_items, gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items __attribute__((unused)))
{
//**************** time tags ****************
// *************** time tags ****************
if (d_enable_rx_clock_correction == false) // todo: currently only works if clock correction is disabled
{
std::vector<gr::tag_t> tags_vec;
@ -1978,7 +1978,7 @@ int rtklib_pvt_gs::work(int noutput_items, gr_vector_const_void_star& input_item
}
}
}
//************* end time tags **************
// ************ end time tags **************
for (int32_t epoch = 0; epoch < noutput_items; epoch++)
{

2
src/algorithms/libs/beidou_b1i_signal_replica.cc
View File

@ -75,7 +75,7 @@ void beidou_b1i_code_gen_int(own::span<int32_t> dest, int32_t prn, uint32_t chip
}
// Set the delay
delay = code_length - delays[prn_idx] * 0; //**********************************
delay = code_length - delays[prn_idx] * 0; // *********************************
delay += chip_shift;
delay %= code_length;

4
src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.cc
View File

@ -717,7 +717,7 @@ int hybrid_observables_gs::general_work(int noutput_items __attribute__((unused)
// Push the tracking observables into buffers to allow the observable interpolation at the desired Rx clock
for (uint32_t n = 0; n < d_nchannels_out; n++)
{
//**************** time tags ****************
// *************** time tags ****************
// std::vector<gr::tag_t> tags_vec;
// this->get_tags_in_range(tags_vec, n, this->nitems_read(n), this->nitems_read(n) + ninput_items[n]);
// for (std::vector<gr::tag_t>::iterator it = tags_vec.begin(); it != tags_vec.end(); ++it)
@ -741,7 +741,7 @@ int hybrid_observables_gs::general_work(int noutput_items __attribute__((unused)
// }
// }
//************* end time tags **************
// ************ end time tags **************
for (int32_t m = 0; m < ninput_items[n]; m++)
{
// Push the valid tracking Gnss_Synchros to their corresponding deque

12
src/algorithms/tracking/libs/cuda_multicorrelator.cu
View File

@ -189,12 +189,12 @@ bool cuda_multicorrelator::init_cuda_integrated_resampler(
// ALLOCATE GPU MEMORY FOR INPUT/OUTPUT and INTERNAL vectors
size_t size = signal_length_samples * sizeof(GPU_Complex);
//********* ZERO COPY VERSION ************
// ******** ZERO COPY VERSION ************
// Set flag to enable zero copy access
// Optimal in shared memory devices (like Jetson K1)
//cudaSetDeviceFlags(cudaDeviceMapHost);
// cudaSetDeviceFlags(cudaDeviceMapHost);
//******** CudaMalloc version ***********
// ******* CudaMalloc version ***********
// input signal GPU memory (can be mapped to CPU memory in shared memory devices!)
// cudaMalloc((void **)&d_sig_in, size);
@ -237,7 +237,7 @@ bool cuda_multicorrelator::set_local_code_and_taps(
int n_correlators)
{
cudaSetDevice(selected_gps_device);
//********* ZERO COPY VERSION ************
// ******** ZERO COPY VERSION ************
// // Get device pointer from host memory. No allocation or memcpy
// cudaError_t code;
// // local code CPU -> GPU copy memory
@ -253,7 +253,7 @@ bool cuda_multicorrelator::set_local_code_and_taps(
// printf("cuda cudaHostGetDevicePointer error in set_local_code_and_taps \r\n");
// }
//******** CudaMalloc version ***********
// ******* CudaMalloc version ***********
//local code CPU -> GPU copy memory
cudaMemcpyAsync(d_local_codes_in, local_codes_in, sizeof(GPU_Complex) * code_length_chips, cudaMemcpyHostToDevice, stream1);
d_code_length_chips = code_length_chips;
@ -315,7 +315,7 @@ bool cuda_multicorrelator::Carrier_wipeoff_multicorrelator_resampler_cuda(
// input signal CPU -> GPU copy memory
//cudaMemcpyAsync(d_sig_in, d_sig_in_cpu, memSize,
// cudaMemcpyHostToDevice, stream2);
//***** NOTICE: NCO is computed on-the-fly, not need to copy NCO into GPU! ****
// **** NOTICE: NCO is computed on-the-fly, not need to copy NCO into GPU! ****
//launch the multitap correlator with integrated local code resampler!

4
src/core/libs/gnss_sdr_sample_counter.cc
View File

@ -144,7 +144,7 @@ int gnss_sdr_sample_counter::work(int noutput_items __attribute__((unused)),
out[0].Tracking_sample_counter = sample_counter;
current_T_rx_ms += interval_ms;
//**************** time tags ****************
// *************** time tags ****************
std::vector<gr::tag_t> tags_vec;
// notice that nitems_read is updated in decimation blocks after leaving work() with return 1, equivalent to call consume_each
this->get_tags_in_range(tags_vec, 0, this->nitems_read(0), this->nitems_read(0) + samples_per_output);
@ -182,7 +182,7 @@ int gnss_sdr_sample_counter::work(int noutput_items __attribute__((unused)),
}
}
//************* end time tags **************
// ************ end time tags **************
return 1;
}

8
src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_ambiguous_acquisition_test_fpga.cc
View File

@ -126,9 +126,9 @@ void* handler_DMA_galileo_e1_pcps_ambiguous_acq_test(void* arguments)
return nullptr;
}
//**************************************************************************
// *************************************************************************
// Open DMA device
//**************************************************************************
// *************************************************************************
tx_fd = open("/dev/loop_tx", O_WRONLY);
if (tx_fd < 0)
{
@ -136,9 +136,9 @@ void* handler_DMA_galileo_e1_pcps_ambiguous_acq_test(void* arguments)
return nullptr;
}
//**************************************************************************
// *************************************************************************
// Open input file
//**************************************************************************
// *************************************************************************
uint32_t skip_samples = 0; // static_cast<uint32_t>(FLAGS_skip_samples);
if (skip_samples + skip_used_samples > 0)

8
src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_acquisition_test_fpga.cc
View File

@ -125,9 +125,9 @@ void* handler_DMA_gps_l1_acq_test(void* arguments)
return nullptr;
}
//**************************************************************************
// *************************************************************************
// Open DMA device
//**************************************************************************
// *************************************************************************
tx_fd = open("/dev/loop_tx", O_WRONLY);
if (tx_fd < 0)
{
@ -135,9 +135,9 @@ void* handler_DMA_gps_l1_acq_test(void* arguments)
return nullptr;
}
//**************************************************************************
// *************************************************************************
// Open input file
//**************************************************************************
// *************************************************************************
uint32_t skip_samples = 0; // static_cast<uint32_t>(FLAGS_skip_samples);
if (skip_samples + skip_used_samples > 0)

8
src/tests/unit-tests/signal-processing-blocks/observables/hybrid_observables_test_fpga.cc
View File

@ -399,9 +399,9 @@ void* handler_DMA_obs_test(void* arguments)
return nullptr;
}
//**************************************************************************
// *************************************************************************
// Open DMA device
//**************************************************************************
// *************************************************************************
tx_fd = open("/dev/loop_tx", O_WRONLY);
if (tx_fd < 0)
{
@ -409,9 +409,9 @@ void* handler_DMA_obs_test(void* arguments)
return nullptr;
}
//**************************************************************************
// *************************************************************************
// Open input file
//**************************************************************************
// *************************************************************************
uint32_t skip_samples = static_cast<uint32_t>(FLAGS_skip_samples);

8
src/tests/unit-tests/signal-processing-blocks/tracking/tracking_pull-in_test_fpga.cc
View File

@ -191,9 +191,9 @@ void* handler_DMA_trk_pull_in_test(void* arguments)
return nullptr;
}
//**************************************************************************
// *************************************************************************
// Open DMA device
//**************************************************************************
// *************************************************************************
tx_fd = open("/dev/loop_tx", O_WRONLY);
if (tx_fd < 0)
{
@ -201,9 +201,9 @@ void* handler_DMA_trk_pull_in_test(void* arguments)
return nullptr;
}
//**************************************************************************
// *************************************************************************
// Open input file
//**************************************************************************
// *************************************************************************
uint32_t skip_samples = static_cast<uint32_t>(FLAGS_skip_samples);
if (skip_samples + skip_used_samples > 0)