Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2020 Cisco and/or its affiliates.
       3             :  * Licensed under the Apache License, Version 2.0 (the "License");
       4             :  * you may not use this file except in compliance with the License.
       5             :  * You may obtain a copy of the License at:
       6             :  *
       7             :  *     http://www.apache.org/licenses/LICENSE-2.0
       8             :  *
       9             :  * Unless required by applicable law or agreed to in writing, software
      10             :  * distributed under the License is distributed on an "AS IS" BASIS,
      11             :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      12             :  * See the License for the specific language governing permissions and
      13             :  * limitations under the License.
      14             :  */
      15             : 
      16             : #ifndef SRC_VNET_TCP_TCP_CC_H_
      17             : #define SRC_VNET_TCP_TCP_CC_H_
      18             : 
      19             : #include <vnet/tcp/tcp_types.h>
      20             : 
      21             : always_inline void
      22     1020150 : tcp_cc_rcv_ack (tcp_connection_t * tc, tcp_rate_sample_t * rs)
      23             : {
      24     1020150 :   tc->cc_algo->rcv_ack (tc, rs);
      25     1020150 :   tc->tsecr_last_ack = tc->rcv_opts.tsecr;
      26     1020150 : }
      27             : 
      28             : static inline void
      29           0 : tcp_cc_rcv_cong_ack (tcp_connection_t * tc, tcp_cc_ack_t ack_type,
      30             :                      tcp_rate_sample_t * rs)
      31             : {
      32           0 :   tc->cc_algo->rcv_cong_ack (tc, ack_type, rs);
      33           0 : }
      34             : 
      35             : static inline void
      36           0 : tcp_cc_congestion (tcp_connection_t * tc)
      37             : {
      38           0 :   tc->cc_algo->congestion (tc);
      39           0 : }
      40             : 
      41             : static inline void
      42           0 : tcp_cc_loss (tcp_connection_t * tc)
      43             : {
      44           0 :   tc->cc_algo->loss (tc);
      45           0 : }
      46             : 
      47             : static inline void
      48           0 : tcp_cc_recovered (tcp_connection_t * tc)
      49             : {
      50           0 :   tc->cc_algo->recovered (tc);
      51           0 : }
      52             : 
      53             : static inline void
      54           0 : tcp_cc_undo_recovery (tcp_connection_t * tc)
      55             : {
      56           0 :   if (tc->cc_algo->undo_recovery)
      57           0 :     tc->cc_algo->undo_recovery (tc);
      58           0 : }
      59             : 
      60             : static inline void
      61       25861 : tcp_cc_event (tcp_connection_t * tc, tcp_cc_event_t evt)
      62             : {
      63       25861 :   if (tc->cc_algo->event)
      64       25861 :     tc->cc_algo->event (tc, evt);
      65       25861 : }
      66             : 
      67             : static inline u64
      68       40937 : tcp_cc_get_pacing_rate (tcp_connection_t * tc)
      69             : {
      70       40937 :   if (tc->cc_algo->get_pacing_rate)
      71           0 :     return tc->cc_algo->get_pacing_rate (tc);
      72             : 
      73       40937 :   f64 srtt = clib_min ((f64) tc->srtt * TCP_TICK, tc->mrtt_us);
      74             : 
      75             :   /* TODO should constrain to interface's max throughput but
      76             :    * we don't have link speeds for sw ifs ..*/
      77       40937 :   return ((f64) tc->cwnd / srtt);
      78             : }
      79             : 
      80             : static inline void *
      81     1046280 : tcp_cc_data (tcp_connection_t * tc)
      82             : {
      83     1046280 :   return (void *) tc->cc_data;
      84             : }
      85             : 
      86             : /**
      87             :  * Register exiting cc algo type
      88             :  */
      89             : void tcp_cc_algo_register (tcp_cc_algorithm_type_e type,
      90             :                            const tcp_cc_algorithm_t * vft);
      91             : 
      92             : /**
      93             :  * Register new cc algo type
      94             :  */
      95             : tcp_cc_algorithm_type_e tcp_cc_algo_new_type (const tcp_cc_algorithm_t * vft);
      96             : tcp_cc_algorithm_t *tcp_cc_algo_get (tcp_cc_algorithm_type_e type);
      97             : 
      98             : 
      99             : void newreno_rcv_cong_ack (tcp_connection_t * tc, tcp_cc_ack_t ack_type,
     100             :                            tcp_rate_sample_t * rs);
     101             : 
     102             : 
     103             : #endif /* SRC_VNET_TCP_TCP_CC_H_ */
     104             : 
     105             : /*
     106             :  * fd.io coding-style-patch-verification: ON
     107             :  *
     108             :  * Local Variables:
     109             :  * eval: (c-set-style "gnu")
     110             :  * End:
     111             :  */