Crate alice_protocol_reader

This module contains mainly the InputScanner that reads the input data, and the CdpArray data structure that wraps the data read from the input. Additionally it contains a helper function spawn_reader that spawns a thread that reads input and sents it to a channel that is returned from the function.

The InputScanner is a generic type that can be instantiated with any type that implements the BufferedReaderWrapper trait. This trait is implemented for the StdInReaderSeeker and the BufReader types. Allowing the InputScanner to read from both stdin and files, in a convenient and efficient way.

The CdpArray is a wrapper for the data read from the input, it contains the data and the memory address of the first byte of the data.

Example

First add the alice_protocol_reader crate to your project

$ cargo add alice_protocol_reader

Then use the convenience init_reader()-function to add the appropriate reader (stdin or file) at runtime. Instantiate the InputScanner with the reader and start reading ALICE data.

use alice_protocol_reader::input_scanner::InputScanner;
use alice_protocol_reader::init_reader;
use alice_protocol_reader::rdh::RdhCru;

let reader = init_reader(&Some(test_file_path)).unwrap();

let mut input_scanner = InputScanner::minimal(reader);

let rdh = input_scanner.load_rdh_cru::<RdhCru<u8>>().unwrap();

println!("{rdh:?}");

Example output

RdhCru
        Rdh0 { header_id: 7, header_size: 64, fee_id: 20522, priority_bit: 0, system_id: 32, reserved0: 0 }
        offset_new_packet: 5088
        memory_size: 5088
        link_id: 0
        packet_counter: 0
        cruid_dw: 24
        Rdh1 { bc_reserved0: 0, orbit: 192796021 }
        dataformat_reserved0: 2
        Rdh2 { trigger_type: 27139, pages_counter: 0, stop_bit: 0, reserved0: 0 }
        reserved1: 0
        Rdh3 { detector_field: 0, par_bit: 0, reserved0: 0 }
        reserved2: 0

Customize InputScanner behaviour with a config

Implement the FilterOpt on your own config struct and pass it to the InputScanner to customize its behaviour

use alice_protocol_reader::filter::FilterOpt;

struct MyCfg;

impl FilterOpt for MyCfg {
    fn skip_payload(&self) -> bool {
        // Implement your config rules for determining if you're skipping the payload (only reading `RDH`s)
    }

    fn filter_link(&self) -> Option<u8> {
        // Implement your config rules for setting a link to filter by
    }

    fn filter_fee(&self) -> Option<u16> {
        // Implement your config rules for setting a FEE ID to filter by
    }

    fn filter_its_stave(&self) -> Option<u16> {
        // Implement your config rules for setting an ITS Stave to filter by
    }
}

use alice_protocol_reader::input_scanner::InputScanner;
use alice_protocol_reader::init_reader;
use alice_protocol_reader::rdh::RdhCru;
pub fn main() {}
    let reader = init_reader(&Some(test_file_path)).unwrap();

    let mut input_scanner = input_scanner::InputScanner::new(&MyCfg, reader, None); // None: Option<flume::Sender<InputStatType>>

    let rdh = input_scanner.load_cdp::<RdhCru<u8>>();
}

Modules

• bufreader_wrapper
  Wrapper trait for BufReader, requires that the reader implements Read and Seek
• cdp_wrapper
  Contains the wrappers for the loaded CDP batches.
• config
  Options for configuring the InputScanner
• input_scanner
  Contains the InputScanner & ScanCDP trait, responsible for reading and forwarding input data.
• mem_pos_tracker
  Contains the MemPosTracker struct that aids in tracking the memory position in the input data.
• prelude
  Includes all the basics for working with the ALICE DAQ input module.
• rdh
  This module contains all struct definitions for the words that are used in supported data formats.
• scan_cdp
  Contains the ScanCDP trait for reading CDPs from a file or stdin (readable instance)
• stats
  Contains the InputStatType enum for which kind of statistics are gathered, and the Stats struct for tracking and reporting statistics about the input data.
• stdin_reader
  Wrapper for a reader, implements BufferedReaderWrapper.

Macros

• load_bytes
  Macro to load a given number of bytes from a reader into a byte array buffer, to avoid heap allocation.

Functions

• init_reader
  Initializes the reader based on the input mode (file or stdin) and returns it
• spawn_reader
  Spawns a reader thread that reads CDPs from the input and sends them to a producer channel
• spawn_vec_reader
  Spawns a reader thread that reads CDPs from the input and sends them to a producer channel