// based on branch/port index.

    #[inline]

    fn mapped_index(&self, branch_idx: u32, port_idx: usize) -> usize {

        let branch_idx = branch_idx as usize;

        let num_ports = self.owned_ports.len();

        debug_assert!(port_idx < num_ports);

        debug_assert!((branch_idx + 1) * num_ports <= self.port_mapping.len());

        return branch_idx * num_ports + port_idx;

    }

}

        return Channel{ putter_id, getter_id };

    }

    /// Creates a new connector. Note that it is not scheduled immediately, but

    /// depends on the `ApplicationConnector` to run, followed by the created

    /// connector being scheduled.

    pub fn create_connector(&mut self, module: &str, routine: &str, arguments: ValueGroup) -> Result<(), ComponentCreationError> {

        // Retrieve ports and make sure that we own the ones that are currently

        // specified. This is also checked by the scheduler, but that is done

        // asynchronously.

        let mut initial_ports = Vec::new();

        find_ports_in_value_group(&arguments, &mut initial_ports);

        return Self{ runtime, scheduler_id };

    }

    pub fn run(&mut self) {

        // Setup global storage and workspaces that are reused for every

        // connector that we run

        let mut delta_state = RunDeltaState::new();

        'thread_loop: loop {

            // Retrieve a unit of work

            self.debug("Waiting for work");

            let connector_key = self.runtime.wait_for_work();

            // connector.

            let mut cur_schedule = ConnectorScheduling::Immediate;

            while cur_schedule == ConnectorScheduling::Immediate {

                // Check all the message that are in the shared inbox

                while let Some(message) = scheduled.public.inbox.take_message() {

                    // Check for rerouting

                    if let Some(other_connector_id) = scheduled.router.should_reroute(message.sending_connector, message.receiving_port) {

                        self.runtime.send_message(other_connector_id, message);

                        continue;

                    }

                    // Check for messages that requires special action from the

                    // scheduler.

                    if let MessageContents::Control(content) = message.contents {

                        match content.content {

                            ControlMessageVariant::ChangePortPeer(port_id, new_target_connector_id) => {

                                // Need to change port target

    }

}

    ");

    let mut api = rt.create_interface();

    let channel = api.create_channel();

    api.create_connector("", "putter", ValueGroup::new_stack(vec![

        Value::Output(PortId(Id{ connector_id: 0, u32_suffix: channel.putter_id.index })),

        Value::UInt32(num_loops)

    ])).expect("create putter");

    api.create_connector("", "getter", ValueGroup::new_stack(vec![

        Value::Input(PortId(Id{ connector_id: 0, u32_suffix: channel.getter_id.index })),

        Value::UInt32(num_loops)

    ])).expect("create getter");

}