Canister Output Message Queue Limits, and IC Management Canister Throttling Limits

icme · December 5, 2022, 7:29am

Was further looking into queues, and found DEFAULT_OUTPUT_REQUEST_LIFETIME

dfinity/ic/blob/a52bb83dd6fc99072db070ccc905478f5ce4bee4/rs/replicated_state/src/canister_state/queues.rs#L34


      
              convert::{From, TryFrom},
              ops::{AddAssign, SubAssign},
              sync::Arc,
              time::Duration,
          };
          
          
pub const DEFAULT_QUEUE_CAPACITY: usize = 500;
          
          
/// The default lifetime of a request in OutputQueue from which the deadline
          /// is computed as time + DEFAULT_OUTPUT_REQUEST_LIFETIME.
          pub const DEFAULT_OUTPUT_REQUEST_LIFETIME: Duration = Duration::from_secs(300);
          
          
/// Encapsulates information about `CanisterQueues`,
          /// used in detecting a loop when consuming the input messages.
          #[derive(Clone, Debug, Default, PartialEq, Eq)]
          pub struct CanisterQueuesLoopDetector {
              pub local_queue_skip_count: usize,
              pub remote_queue_skip_count: usize,
              pub skipped_ingress_queue: bool,
          }

There’s also reference to a deadline and requests “timing out”

github.com

dfinity/ic/blob/a52bb83dd6fc99072db070ccc905478f5ce4bee4/rs/replicated_state/src/canister_state/queues/queue.rs#L547


      
                      q: self,
                      current_time,
                  }
              }
          }
          
          
/// Iterator over timed out requests in an OutputQueue.
          ///
          /// This extracts timed out requests by removing them from the queue,
          /// leaving `None` in their place and returning them one by one.
          pub(super) struct TimedOutRequestsIter<'a> {
              /// A mutable reference to the queue whose requests are to be timed out and returned.
              q: &'a mut OutputQueue,
              /// The time used to determine which requests should be considered timed out.
              /// This is compared to deadlines in q.deadline_range_ends.
              current_time: Time,
          }
          
          
impl<'a> Iterator for TimedOutRequestsIter<'a> {
              type Item = Arc<Request>;

Is there a certain point at which inter-canister messages could be dropped (timed out) if the deadline has passed? Let’s say I have a canister or subnet that’s completely overloaded with messages and has a bunch of these messages in my canister’s output queue. What happens to these messages if the 300 second deadline has passed?

Topic		Replies	Views
[Discussion] Approaches for preventing canisters from hitting memory limits Developers Discussing	5	543	October 5, 2022
Can some one do a YouTube video on optimizing cross canister calls? Developers	3	505	February 2, 2023
Canister:limit for single message execution Developers	6	792	July 4, 2022
Scalable Messaging Model Roadmap community-consideration	63	1419	February 13, 2024
More info about "Locally timing out canister requests (Core Protocol)" Developers	9	309	April 24, 2023

Canister Output Message Queue Limits, and IC Management Canister Throttling Limits

Related Topics