Dr.Jit error

[IBRAAHHIIMM]

Hi,
I am experimenting with new Sionna version to generate channels for different frequencies, user placements, antenna sizes and Monte carlo samples. That's why I loop over different frequencies, user placements, antenna sizes and monte carlo samples on the single loaded scene. I get the warning as follows:

 RuntimeWarning: The AST-transforming decorator @drjit.syntax was called more than 1000 times by your program. Since transforming and recompiling Python code is a relatively expensive operation, it should not be used within loops or subroutines. Please move the function to be transformed to the top program level and decorate it there.
  warnings.warn(

When I enabled the drjit debug, I get the following warning successively.

drjit.Local.write(): out-of-bounds write to position 7 in an array of size 7. (typing.py:1835)

Even though I call the function below only one, the same warning persists. After running for some iterations, the code breaks with
CUDA_ERROR_ILLEGAL_ADDRESS

As far as I understand, this is related to the built-in functions in Mitsuba and Sionna. Is there a way to get around this issue?

def generate_channels(scene,chan_cfg,tx_pos,rx_pos,rx_orient_offsets,is_render=False,scene_dir=None):
    
    fc_values = np.linspace(chan_cfg.min_fc,chan_cfg.max_fc,chan_cfg.N_bands+1) + (chan_cfg.max_fc-chan_cfg.min_fc)/2/chan_cfg.N_bands
    fc_values = fc_values[0:-1]
    
    # fc_values = fc_values[0:1]
    
    
    tx_batch_size = chan_cfg.batch_size_tx
    num_tx_batch = int(np.ceil(num_tx_rx_pairs/chan_cfg.batch_size_tx))
    num_rx_batch = int(np.ceil(num_tx_rx_pairs/chan_cfg.batch_size_rx))
    # for idx_tx in tqdm(range(num_tx_rx_pairs),"Generating channels for each TX"):

    H_all = []
    
    for idx_tx_batch in tqdm(range(num_tx_batch),"Generating channels for each TX batch"):
        
        batch_tx = [f"tx_{i+idx_tx_batch*tx_batch_size}" for i in range(tx_batch_size) if i+idx_tx_batch*tx_batch_size<= num_tx_rx_pairs-1]
    
        H_tx_freq = []
        
        for idx_fc in range(len(fc_values)):
            
            #set the carrier frequency of the simulation
            scene.frequency = fc_values[idx_fc]
    
    
            H_freq_batch = []
            for idx_rx_batch in range(num_rx_batch):
                # print(f"Batch {idx_batch}")
                batch_rx = [f"rx_{i+idx_rx_batch*chan_cfg.batch_size_rx}" for i in range(chan_cfg.batch_size_rx) if i+idx_rx_batch*chan_cfg.batch_size_rx<= num_tx_rx_pairs-1]
    
                #remove all tx and rx from the scene
                x_names = list(scene.receivers.keys()) + list(scene.transmitters.keys())
                [scene.remove(x_names[i]) for i in range(len(x_names))]
            
                
                #add all tx and rx to the scene 
                for idx_rx in range(num_tx_rx_pairs):
                    #configure the scene for the channel generation
                    tx = Transmitter(name=f"tx_{idx_rx}", position=tx_pos[idx_rx])
                    rx = Receiver(name=f"rx_{idx_rx}", position = rx_pos[idx_rx],) #random position to be able to assign an antenan
                    #add the receiver adn transmitter to the scene
                    scene.add(tx)
                    scene.add(rx)
                    rx.look_at(tx)
            
                    rx.orientation += rx_orient_offsets[idx_rx]
                    tx.look_at(rx)


                if(is_render):
                    # Create new camera with different configuration
                    my_cam = Camera(position=[0,0,900], look_at=[0,0,0])

                    scene.render_to_file(camera=my_cam,
                     filename=scene_dir,
                     resolution=[650,500],
                    show_devices=True)

                    
                #remove all the tx except the desired one. We first add all pairs in order to assign orientation the same orientation randomness 
                #within the scene to preserve consistency
                x_names = list(scene.transmitters.keys())
                [scene.remove(x_names[i]) for i in range(len(x_names)) if x_names[i] not in batch_tx]
        
                #remove the rx outside of the batch
                x_names = list(scene.receivers.keys())
                [scene.remove(x_names[i]) for i in range(len(x_names)) if x_names[i] not in batch_rx]
                
                # Compute paths
                # paths = scene.compute_paths(
                    # max_depth= chan_cfg.max_depth,
                    # num_samples=chan_cfg.num_samples,
                    # diffraction=chan_cfg.en_diff,
                    # scattering=chan_cfg.en_scat,
                    # scat_keep_prob=chan_cfg.scat_prob
                # )
                # Compute paths
                solver = PathSolver()
                paths = solver(scene,
                                max_depth= chan_cfg.max_depth,
                                diffuse_reflection=chan_cfg.en_diff,
                                synthetic_array=True,
                                seed = 543)
                                # scattering=chan_cfg.en_scat,
                                # scat_keep_prob=chan_cfg.scat_prob 
                              
    
                a,tau = paths.cir()
        
                #[batch size, num_rx, num_rx_ant, num_tx, num_tx_ant, num_time_steps, fft_size]
                # h_freq = sionna.channel.cir_to_ofdm_channel(chan_cfg.frequencies[:chan_cfg.K], a, tau, normalize=False)
    
                # num_rx, num_rx_ant, num_tx, num_tx_ant,num_time_steps, num_frequencies
                h_freq = paths.cfr([0],normalize=False,normalize_delays=False,out_type='numpy')
            
                H_freq_batch.append(h_freq)
    
            H_freq_batch = np.concatenate(H_freq_batch,axis=0) #all the rx for a single tx
     
            H_tx_freq.append(H_freq_batch) #add the channels for idx_tx and all rx to the array for a single freq
            
        H_tx_freq = np.concatenate(H_tx_freq,axis=-1) #combine the channels for all freq, all rx and a single tx into an array
    
        H_all.append(H_tx_freq)
    
    
    H_all = np.concatenate(H_all,axis=2)
    return H_all,scene

[merlinND]

Hello @IBRAAHHIIMM,

Thank you for reporting this issue. Does it happen on one of the built-in Sionna scenes?
Could you please share a minimal (but complete) version of your code needed to reproduce this issue?

[IBRAAHHIIMM]

Hi @merlinND,

No, it happens on the scene I created. It seems that is not about the scene because I was running the same code with previous version without any issues. I do not have a minimal code now since I am calling many functions in the loop before channel generation.

I can spend some time to create a clean and short script that generate the issue. As I said, it occurs if you have a loop as in the function I posted here.

[merlinND]

It would be very difficult for us to help without a reproducer script & the scene data.