On 24 Aug 2024, at 9:02 PM, Alex Balashov via sr-users <sr-users(a)lists.kamailio.org> wrote: Not overtly related to your most immediate question, but: 1) "we're hitting a limit where all children become busy waiting for the API to answer." 2) "So i decided to move to http_async_client" I'm not sure this is really going to solve your problem. You've hit fundamental, thermodynamic kind of limits here. Using async here just squeezes the balloon in one place and causes it to inflate in another. It would be different if some of your workload were HTTP-dependent and other parts of the workload were not. Doing the HTTP queries would free up the core SIP workers to process other kinds of requests. That doesn't sound like it's the case, so all you're really liberating is reply processing, which, if this is a redirect server, is nonexistent anyway. This matter might occasion some deeper reflection. -- Alex -- Alex Balashov Principal Consultant Evariste Systems LLC Web: https://evaristesys.com Tel: +1-706-510-6800 __________________________________________________________ Kamailio - Users Mailing List - Non Commercial Discussions To unsubscribe send an email to sr-users-leave(a)lists.kamailio.org Important: keep the mailing list in the recipients, do not reply only to the sender! Edit mailing list options or unsubscribe:

-----Original Message----- From: Alex Balashov via sr-users <sr-users(a)lists.kamailio.org> Sent: Sonntag, 25. August 2024 06:18 To: Kamailio (SER) - Users Mailing List <sr-users(a)lists.kamailio.org> Cc: Alex Balashov <abalashov(a)evaristesys.com> Subject: [SR-Users] Re: http_async and tm A few hundred CPS per node is impressive, but especially so when anything with HTTP is involved! Kamailio has HTTP client modules, but there's no pretending that being an HTTP client is natural or particularly performant for Kamailio. Since most--not all, but most--of the workload is I/O wait, you could get away with just adding more children. The general principle that children should not exceed CPUs, because they'd just fight for CPU, applies when the workload is CPU-bound, or computational in nature. However, if most of the time is spent waiting on something to come across a socket, e.g. from a database or an HTTP server, you can overbook quite a bit relative to the CPUs. You still don't want too many child processes, and I would be hard-pressed to say exactly how many is too many, but 2:1 or 3:1 should be safe. -- Alex cpu’s and more children and play with queues, timeouts, etc etc. but i know, im pretty sure that there’s a limit i can't surpass. would be great (and easy for me) if the execution pipelines can at least have some part where in can execute in parallel, but … a pipeline, why to execute following steps if not needed vs ‘execute and discard’ (and worst, some consumed webservices in the pipeline are transactional charged). users(a)lists.kamailio.org> wrote: to answer." fundamental, thermodynamic kind of limits here. Using async here just squeezes the balloon in one place and causes it to inflate in another. other parts of the workload were not. Doing the HTTP queries would free up the core SIP workers to process other kinds of requests. That doesn't sound like it's the case, so all you're really liberating is reply processing, which, if this is a redirect server, is nonexistent anyway. users(a)lists.kamailio.org> wrote: external devices in the network (diameter to DRA's, REST to different servers) and based on n conditions returns the content for a Contact header to be used in a SIP 302. there's no way to speed up the API (pipeline executions, delays on external api's etc etc) we're hitting a limit where all children become busy waiting for the API to answer. lab with this first and base concept to test. replied and then an ACK (ignored by now). Request: right after the 302 will be appreciated. sender! sender! -- Alex Balashov Principal Consultant Evariste Systems LLC Web: https://evaristesys.com Tel: +1-706-510-6800 __________________________________________________________ Kamailio - Users Mailing List - Non Commercial Discussions To unsubscribe send an email to sr-users-leave(a)lists.kamailio.org Important: keep the mailing list in the recipients, do not reply only to the sender! Edit mailing list options or unsubscribe:

On Aug 25, 2024, at 3:11 AM, Henning Westerholt &lt;hw(a)gilawa.com&gt; wrote: Hello Alex, are you saying that using Kamailio with HTTP is not performant at all? This has not been my experience so far. I think many people are using it for large infrastructures. Your remarks regarding the latency and addressing the bottlenecks first are of course valid. Regarding children to CPU core ratios, the default configuration is already giving you a 2:1 ratio (8 children for a standard 4 core server). As frequently suggested, the OP should probably investigate the UDP receiver queue (netstat/ss etc..) and increase the number of children if there is a significant and stable queue building up. Cheers, Henning -- Henning Westerholt – https://skalatan.de/blog/ Kamailio services – https://gilawa.com > -----Original Message----- > From: Alex Balashov via sr-users &lt;sr-users(a)lists.kamailio.org&gt; > Sent: Sonntag, 25. August 2024 06:18 > To: Kamailio (SER) - Users Mailing List &lt;sr-users(a)lists.kamailio.org&gt; > Cc: Alex Balashov &lt;abalashov(a)evaristesys.com&gt; > Subject: [SR-Users] Re: http_async and tm > > A few hundred CPS per node is impressive, but especially so when anything > with HTTP is involved! Kamailio has HTTP client modules, but there's no > pretending that being an HTTP client is natural or particularly performant for > Kamailio. > > Since most--not all, but most--of the workload is I/O wait, you could get away > with just adding more children. The general principle that children should not > exceed CPUs, because they'd just fight for CPU, applies when the workload is > CPU-bound, or computational in nature. However, if most of the time is spent > waiting on something to come across a socket, e.g. from a database or an > HTTP server, you can overbook quite a bit relative to the CPUs. > > You still don't want too many child processes, and I would be hard-pressed to > say exactly how many is too many, but 2:1 or 3:1 should be safe. > > -- Alex > >>> On Aug 24, 2024, at 10:35 PM, Alexis Fidalgo &lt;alzrck(a)gmail.com&gt; wrote: >> >> it is. im dealing with this issue since a few weeks, i can push and add more > cpu’s and more children and play with queues, timeouts, etc etc. but i know, > im pretty sure that there’s a limit i can't surpass. >> >> at this point im struggling on how to modify the http part (the api server) it > would be great (and easy for me) if the execution pipelines can at least have > some part where in can execute in parallel, but … a pipeline, why to execute > following steps if not needed vs ‘execute and discard’ (and worst, some > consumed webservices in the pipeline are transactional charged). >> >> im happy, more that that, a docker swarm with 4 nodes with >> 10cpu/children each are handling ~1300 call attempls >> (invite,100,302,ack) per second, thats more than ok (and cpu/mem are >> low, really low, problem is the wait, no the power), but we need more >> (ill move to more cores/childrens and appeal to brute force by now to >> gain some time) >> >> still seeing there’s no point to start using TM for a 100% stateless >> flow >> >> >>> On 24 Aug 2024, at 9:02 PM, Alex Balashov via sr-users <sr- > users(a)lists.kamailio.org&gt; wrote: >>> >>> Not overtly related to your most immediate question, but: >>> >>> 1) "we're hitting a limit where all children become busy waiting for the API > to answer." >>> >>> 2) "So i decided to move to http_async_client" >>> >>> I'm not sure this is really going to solve your problem. You've hit > fundamental, thermodynamic kind of limits here. Using async here just > squeezes the balloon in one place and causes it to inflate in another. >>> >>> It would be different if some of your workload were HTTP-dependent and > other parts of the workload were not. Doing the HTTP queries would free up > the core SIP workers to process other kinds of requests. That doesn't sound > like it's the case, so all you're really liberating is reply processing, which, if this is > a redirect server, is nonexistent anyway. >>> >>> This matter might occasion some deeper reflection. >>> >>> -- Alex >>> >>>> On Aug 24, 2024, at 6:48 PM, alexis via sr-users <sr- > users(a)lists.kamailio.org&gt; wrote: >>>> >>>> Hello all, context first, we have an REST API that performs queries to > external devices in the network (diameter to DRA's, REST to different servers) > and based on n conditions returns the content for a Contact header to be used > in a SIP 302. >>>> >>>> Now we're consuming this API with http_client (synchronously) and as > there's no way to speed up the API (pipeline executions, delays on external > api's etc etc) we're hitting a limit where all children become busy waiting for > the API to answer. >>>> >>>> So i decided to move to http_async_client and started working on it on the > lab with this first and base concept to test. >>>> >>>> request_route { >>>> >>>> >>>> #for testing purposes only >>>> if(is_method("ACK")){ >>>> exit; >>>> } >>>> $http_req(all) = $null; >>>> $http_req(suspend) = 1; >>>> $http_req(timeout) = 500; >>>> $http_req(method) = "POST"; >>>> $http_req(hdr) = "Content-Type: application/json"; >>>> jansson_set("string", "event", "sip-routing", "$var(cre_query)"); >>>> xlog("L_INFO","API ASYNC ROUTING REQUEST: $var(cre_query)\n"); >>>> $http_req(body) = $var(cre_query); >>>> t_newtran(); >>>> http_async_query("http://192.168.86.128:8000/", "CRE_RESPONSE"); } >>>> >>>> http://192.168.86.128:8000/ receives the POST, randomly creates a >>>> delay between 0.5 and 1 second and responds (simulating the real api >>>> with an excess delay to probe the concept) >>>> >>>> Then >>>> >>>> route[CRE_RESPONSE] { >>>> if ($http_ok && $http_rs == 200) { >>>> xlog("L_INFO","CRE RESPONSE: $http_rb\n"); # for testing >>>> purpose, Contact content will be replaced from the received api >>>> response >>>> append_to_reply("Contact: <sip:1234@google.com>\r\n"); >>>> send_reply(302,"Moved Temporarily"); exit; >>>> } >>>> send_reply(500, "Internal error"); >>>> exit; >>>> } >>>> >>>> INVITE is received and processed, API is called, after API response, 302 is > replied and then an ACK (ignored by now). >>>> >>>> Situation is that the 302 retransmitted >>>> >>>> 37 1519.846253067 192.168.86.34 → 192.168.86.128 SIP/SDP 585 >>>> Request: INVITE sip:service@192.168.86.128:5060 | >>>> 38 1519.848100380 192.168.86.128 → 192.168.86.34 SIP 318 Status: >>>> 100 Trying | >>>> 39 1520.094997642 192.168.86.128 → 192.168.86.34 SIP 407 Status: >>>> 302 Moved Temporarily | >>>> 40 1520.102323728 192.168.86.34 → 192.168.86.128 SIP 453 > Request: >>>> ACK sip:service@192.168.86.128:5060 | >>>> 41 1520.591300933 192.168.86.128 → 192.168.86.34 SIP 407 Status: >>>> 302 Moved Temporarily | >>>> 42 1521.591061065 192.168.86.128 → 192.168.86.34 SIP 407 Status: >>>> 302 Moved Temporarily | >>>> 43 1523.591227956 192.168.86.128 → 192.168.86.34 SIP 407 Status: >>>> 302 Moved Temporarily | >>>> >>>> >>>> 18(24) DEBUG: tm [t_reply.c:1703]: t_retransmit_reply(): reply >>>> retransmitted. buf=0x7f6d79745dc0: SIP/2.0 3..., >>>> shmem=0x7f6d75187fd8: SIP/2.0 3 >>>> 18(24) DEBUG: tm [t_reply.c:1703]: t_retransmit_reply(): reply >>>> retransmitted. buf=0x7f6d79745dc0: SIP/2.0 3..., >>>> shmem=0x7f6d75187fd8: SIP/2.0 3 >>>> 18(24) DEBUG: tm [t_reply.c:1703]: t_retransmit_reply(): reply >>>> retransmitted. buf=0x7f6d79745dc0: SIP/2.0 3..., >>>> shmem=0x7f6d75187fd8: SIP/2.0 3 >>>> 18(24) DEBUG: tm [timer.c:634]: wait_handler(): finished >>>> transaction: 0x7f6d75184cc8 (p:0x7f6d74f600c8/n:0x7f6d74f600c8) >>>> 18(24) DEBUG: tm [h_table.c:132]: free_cell_helper(): freeing >>>> transaction 0x7f6d75184cc8 from timer.c:643 >>>> >>>> Any help to avoid the retransmission and make the transaction just finish > right after the 302 will be appreciated. >>>> >>>> regards >>>> >>>> >>>> >>>> >>>> >>>> __________________________________________________________ >>>> Kamailio - Users Mailing List - Non Commercial Discussions To >>>> unsubscribe send an email to sr-users-leave(a)lists.kamailio.org >>>> Important: keep the mailing list in the recipients, do not reply only to the > sender! >>>> Edit mailing list options or unsubscribe: >>> >>> -- >>> Alex Balashov >>> Principal Consultant >>> Evariste Systems LLC >>> Web: https://evaristesys.com >>> Tel: +1-706-510-6800 >>> >>> __________________________________________________________ >>> Kamailio - Users Mailing List - Non Commercial Discussions To >>> unsubscribe send an email to sr-users-leave(a)lists.kamailio.org >>> Important: keep the mailing list in the recipients, do not reply only to the > sender! >>> Edit mailing list options or unsubscribe: >> > > -- > Alex Balashov > Principal Consultant > Evariste Systems LLC > Web: https://evaristesys.com > Tel: +1-706-510-6800 > > __________________________________________________________ > Kamailio - Users Mailing List - Non Commercial Discussions To unsubscribe > send an email to sr-users-leave(a)lists.kamailio.org > Important: keep the mailing list in the recipients, do not reply only to the > sender! > Edit mailing list options or unsubscribe:

On Aug 26, 2024, at 5:13 AM, Henning Westerholt &lt;hw(a)gilawa.com&gt; wrote: Hello Alex, I agree. If you can avoid e.g. using some cloud-based API server architecture that requires the extensive use of synchronous or asynchronous HTTP requests in Kamailio, this will be of course easier and probably also more performant. But sometimes you don't have the choice, e.g. if the customer prefer to also adapt the VoIP infrastructure to a (in his world) more modern architecture.

On Aug 24, 2024, at 6:48 PM, alexis via sr-users &lt;sr-users(a)lists.kamailio.org&gt; wrote: Hello all, context first, we have an REST API that performs queries to external devices in the network (diameter to DRA's, REST to different servers) and based on n conditions returns the content for a Contact header to be used in a SIP 302. Now we're consuming this API with http_client (synchronously) and as there's no way to speed up the API (pipeline executions, delays on external api's etc etc) we're hitting a limit where all children become busy waiting for the API to answer. So i decided to move to http_async_client and started working on it on the lab with this first and base concept to test. request_route { #for testing purposes only if(is_method("ACK")){ exit; } $http_req(all) = $null; $http_req(suspend) = 1; $http_req(timeout) = 500; $http_req(method) = "POST"; $http_req(hdr) = "Content-Type: application/json"; jansson_set("string", "event", "sip-routing", "$var(cre_query)"); xlog("L_INFO","API ASYNC ROUTING REQUEST: $var(cre_query)\n"); $http_req(body) = $var(cre_query); t_newtran(); http_async_query("https://nam11.safelinks.protection.outlook.com/?url=http%3A%2F%2F192.168.86.128%3A8000%2F&data=05%7C02%7Cbkaufman%40bcmone.com%7Cbb95cbcc458744f2b3fa08dcc49aee7a%7Cafc1818e7b6848568913201b9396c4fc%7C1%7C0%7C638601416959677303%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C60000%7C%7C%7C&sdata=022%2FjZEmUuj2RpGEkQiGfLeVHMp30X1jjT3sf3%2FWLRc%3D&reserved=0<http://192.168.86.128:8000/>", "CRE_RESPONSE"); } https://nam11.safelinks.protection.outlook.com/?url=http%3A%2F%2F192.168.86… receives the POST, randomly creates a delay between 0.5 and 1 second and responds (simulating the real api with an excess delay to probe the concept) Then route[CRE_RESPONSE] { if ($http_ok && $http_rs == 200) { xlog("L_INFO","CRE RESPONSE: $http_rb\n"); # for testing purpose, Contact content will be replaced from the received api response append_to_reply("Contact: <sip:1234@google.com>\r\n"); send_reply(302,"Moved Temporarily"); exit; } send_reply(500, "Internal error"); exit; } INVITE is received and processed, API is called, after API response, 302 is replied and then an ACK (ignored by now). Situation is that the 302 retransmitted 37 1519.846253067 192.168.86.34 → 192.168.86.128 SIP/SDP 585 Request: INVITE sip:service@192.168.86.128:5060 | 38 1519.848100380 192.168.86.128 → 192.168.86.34 SIP 318 Status: 100 Trying | 39 1520.094997642 192.168.86.128 → 192.168.86.34 SIP 407 Status: 302 Moved Temporarily | 40 1520.102323728 192.168.86.34 → 192.168.86.128 SIP 453 Request: ACK sip:service@192.168.86.128:5060 | 41 1520.591300933 192.168.86.128 → 192.168.86.34 SIP 407 Status: 302 Moved Temporarily | 42 1521.591061065 192.168.86.128 → 192.168.86.34 SIP 407 Status: 302 Moved Temporarily | 43 1523.591227956 192.168.86.128 → 192.168.86.34 SIP 407 Status: 302 Moved Temporarily | 18(24) DEBUG: tm [t_reply.c:1703]: t_retransmit_reply(): reply retransmitted. buf=0x7f6d79745dc0: SIP/2.0 3..., shmem=0x7f6d75187fd8: SIP/2.0 3 18(24) DEBUG: tm [t_reply.c:1703]: t_retransmit_reply(): reply retransmitted. buf=0x7f6d79745dc0: SIP/2.0 3..., shmem=0x7f6d75187fd8: SIP/2.0 3 18(24) DEBUG: tm [t_reply.c:1703]: t_retransmit_reply(): reply retransmitted. buf=0x7f6d79745dc0: SIP/2.0 3..., shmem=0x7f6d75187fd8: SIP/2.0 3 18(24) DEBUG: tm [timer.c:634]: wait_handler(): finished transaction: 0x7f6d75184cc8 (p:0x7f6d74f600c8/n:0x7f6d74f600c8) 18(24) DEBUG: tm [h_table.c:132]: free_cell_helper(): freeing transaction 0x7f6d75184cc8 from timer.c:643 Any help to avoid the retransmission and make the transaction just finish right after the 302 will be appreciated. regards __________________________________________________________ Kamailio - Users Mailing List - Non Commercial Discussions To unsubscribe send an email to sr-users-leave(a)lists.kamailio.org Important: keep the mailing list in the recipients, do not reply only to the sender! Edit mailing list options or unsubscribe:

On Aug 24, 2024, at 6:48 PM, alexis via sr-users <sr-users@lists.kamailio.org<mailto:sr-users@lists.kamailio.org>> wrote: Hello all, context first, we have an REST API that performs queries to external devices in the network (diameter to DRA's, REST to different servers) and based on n conditions returns the content for a Contact header to be used in a SIP 302. Now we're consuming this API with http_client (synchronously) and as there's no way to speed up the API (pipeline executions, delays on external api's etc etc) we're hitting a limit where all children become busy waiting for the API to answer. So i decided to move to http_async_client and started working on it on the lab with this first and base concept to test. request_route { #for testing purposes only if(is_method("ACK")){ exit; } $http_req(all) = $null; $http_req(suspend) = 1; $http_req(timeout) = 500; $http_req(method) = "POST"; $http_req(hdr) = "Content-Type: application/json"; jansson_set("string", "event", "sip-routing", "$var(cre_query)"); xlog("L_INFO","API ASYNC ROUTING REQUEST: $var(cre_query)\n"); $http_req(body) = $var(cre_query); t_newtran(); http_async_query("https://nam11.safelinks.protection.outlook.com/?url=http%3A%2F%2F192.168.86.128%3A8000%2F&data=05%7C02%7Cbkaufman%40bcmone.com%7Cbb95cbcc458744f2b3fa08dcc49aee7a%7Cafc1818e7b6848568913201b9396c4fc%7C1%7C0%7C638601416959677303%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C60000%7C%7C%7C&sdata=022%2FjZEmUuj2RpGEkQiGfLeVHMp30X1jjT3sf3%2FWLRc%3D&reserved=0<http://192.168.86.128:8000/>", "CRE_RESPONSE"); } https://nam11.safelinks.protection.outlook.com/?url=http%3A%2F%2F192.168.86… receives the POST, randomly creates a delay between 0.5 and 1 second and responds (simulating the real api with an excess delay to probe the concept) Then route[CRE_RESPONSE] { if ($http_ok && $http_rs == 200) { xlog("L_INFO","CRE RESPONSE: $http_rb\n"); # for testing purpose, Contact content will be replaced from the received api response append_to_reply("Contact: <sip:1234@google.com>\r\n"); send_reply(302,"Moved Temporarily"); exit; } send_reply(500, "Internal error"); exit; } INVITE is received and processed, API is called, after API response, 302 is replied and then an ACK (ignored by now). Situation is that the 302 retransmitted 37 1519.846253067 192.168.86.34 → 192.168.86.128 SIP/SDP 585 Request: INVITE sip:service@192.168.86.128:5060 | 38 1519.848100380 192.168.86.128 → 192.168.86.34 SIP 318 Status: 100 Trying | 39 1520.094997642 192.168.86.128 → 192.168.86.34 SIP 407 Status: 302 Moved Temporarily | 40 1520.102323728 192.168.86.34 → 192.168.86.128 SIP 453 Request: ACK sip:service@192.168.86.128:5060 | 41 1520.591300933 192.168.86.128 → 192.168.86.34 SIP 407 Status: 302 Moved Temporarily | 42 1521.591061065 192.168.86.128 → 192.168.86.34 SIP 407 Status: 302 Moved Temporarily | 43 1523.591227956 192.168.86.128 → 192.168.86.34 SIP 407 Status: 302 Moved Temporarily | 18(24) DEBUG: tm [t_reply.c:1703]: t_retransmit_reply(): reply retransmitted. buf=0x7f6d79745dc0: SIP/2.0 3..., shmem=0x7f6d75187fd8: SIP/2.0 3 18(24) DEBUG: tm [t_reply.c:1703]: t_retransmit_reply(): reply retransmitted. buf=0x7f6d79745dc0: SIP/2.0 3..., shmem=0x7f6d75187fd8: SIP/2.0 3 18(24) DEBUG: tm [t_reply.c:1703]: t_retransmit_reply(): reply retransmitted. buf=0x7f6d79745dc0: SIP/2.0 3..., shmem=0x7f6d75187fd8: SIP/2.0 3 18(24) DEBUG: tm [timer.c:634]: wait_handler(): finished transaction: 0x7f6d75184cc8 (p:0x7f6d74f600c8/n:0x7f6d74f600c8) 18(24) DEBUG: tm [h_table.c:132]: free_cell_helper(): freeing transaction 0x7f6d75184cc8 from timer.c:643 Any help to avoid the retransmission and make the transaction just finish right after the 302 will be appreciated. regards __________________________________________________________ Kamailio - Users Mailing List - Non Commercial Discussions To unsubscribe send an email to sr-users-leave@lists.kamailio.org<mailto:sr-users-leave@lists.kamailio.org> Important: keep the mailing list in the recipients, do not reply only to the sender! Edit mailing list options or unsubscribe:

On 27 Aug 2024, at 8:57 AM, Alex Balashov via sr-users &lt;sr-users(a)lists.kamailio.org&gt; wrote: Indeed. It's also worth reiterating that the meaning of "asynchronous" is somewhat environmentally and implementationally specific. As the term has entered general use with the popularity of single-threaded / single event loop multiplexing systems, such as Node and JavaScript, it has come to refer to a programming and processing pattern in which the waiting and detection of I/O is delegated to the OS kernel network stack. The OS takes care of this juggling and calls event hooks or callbacks in your program when there is I/O to consume, or sets some flag or condition to indicate this so that you can read the I/O from some OS buffer at your convenience. In this way, your program is able to proceed executing other kinds of things while the OS is taking care of waiting on I/O. Provided that the workload consists of waiting on I/O and also other things, this is to the general benefit of "other things", not the I/O. In Kamailio, asynchronous processing just means liberating the transaction from the main worker processes, which are part of a relatively small fixed-size pool, by suspending it and shipping it to another set of ancillary worker processes, also part of a relatively small, fixed-size pool. Within those ancillary worker processes, the execution is as linear, synchronous and blocking as it would be in the main worker processes. This does not cause the processing to enter some generally more asynchronous mode in any other respect, and in that sense, is quite different to what most people have in mind when they think of asynchronous processing in the context of general-purpose programming runtimes. The only real footnote to this is about situations in which the resumption of the transaction in the async workers is mediated by external events, e.g. a POST-back into Kamailio's `xhttp` server. While this does not change the nature of the subsequent synchronous execution of the route logic, it does mean that neither a core CIP worker nor an async worker is tied up while some kind of external processing is playing out. -- Alex -- Alex Balashov Principal Consultant Evariste Systems LLC Web: https://evaristesys.com Tel: +1-706-510-6800 __________________________________________________________ Kamailio - Users Mailing List - Non Commercial Discussions To unsubscribe send an email to sr-users-leave(a)lists.kamailio.org Important: keep the mailing list in the recipients, do not reply only to the sender! Edit mailing list options or unsubscribe:

In my case, problem is 100% in the REST API, trying to ‘fix’ it in

On Aug 27, 2024, at 4:17 AM, Henning Westerholt via sr-users &lt;sr-users(a)lists.kamailio.org&gt; wrote: The asynchronous HTTP client only helps you if you are having other traffic that can be handled without the need for HTTP API calls, and/or if you are having traffic fluctuations, so you can prevent blocking by buffering requests in memory basically.

On Aug 29, 2024, at 3:13 PM, Ben Kaufman &lt;bkaufman(a)bcmone.com&gt; wrote: I believe that there's a conflation of the http_async_client module and the async module going on here. My understanding (and testing bears out), that the http async client module works in the manner you describe as being "mediated by external events" in that the http reply is the external trigger that resumes the transaction. It appears that the module abstracts any actual calls to suspend/resume. I created a test project that demonstrates this: https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fgithub.co… Using the container deminy/delayed-http-response to create an http service that sleeps 1 second and then replies, and having Kamailio set with 2 child listening processes, and 1 http_async_client worker, a simple use of the http_async_query() function handles 300 cps sustained over a minute with no problems. This passes all of the latency load onto the http server. Yes, if the http server cannot handle the request load as the requests increase, that will be a problem, but I think the understanding of how this module works is incorrect. Kaufman Senior Voice Engineer E: bkaufman(a)bcmone.com SIP.US Client Support: 800.566.9810 | SIPTRUNK Client Support: 800.250.6510 | Flowroute Client Support: 855.356.9768 From: Alex Balashov via sr-users &lt;sr-users(a)lists.kamailio.org&gt; Sent: Tuesday, August 27, 2024 6:57 AM To: Kamailio (SER) - Users Mailing List &lt;sr-users(a)lists.kamailio.org&gt; Cc: Alex Balashov &lt;abalashov(a)evaristesys.com&gt; Subject: [SR-Users] Re: http_async and tm CAUTION: This email originated from outside the organization. Do not click links or open attachments unless you recognize the sender and know the content is safe. Indeed. It's also worth reiterating that the meaning of "asynchronous" is somewhat environmentally and implementationally specific. As the term has entered general use with the popularity of single-threaded / single event loop multiplexing systems, such as Node and JavaScript, it has come to refer to a programming and processing pattern in which the waiting and detection of I/O is delegated to the OS kernel network stack. The OS takes care of this juggling and calls event hooks or callbacks in your program when there is I/O to consume, or sets some flag or condition to indicate this so that you can read the I/O from some OS buffer at your convenience. In this way, your program is able to proceed executing other kinds of things while the OS is taking care of waiting on I/O. Provided that the workload consists of waiting on I/O and also other things, this is to the general benefit of "other things", not the I/O. In Kamailio, asynchronous processing just means liberating the transaction from the main worker processes, which are part of a relatively small fixed-size pool, by suspending it and shipping it to another set of ancillary worker processes, also part of a relatively small, fixed-size pool. Within those ancillary worker processes, the execution is as linear, synchronous and blocking as it would be in the main worker processes. This does not cause the processing to enter some generally more asynchronous mode in any other respect, and in that sense, is quite different to what most people have in mind when they think of asynchronous processing in the context of general-purpose programming runtimes. The only real footnote to this is about situations in which the resumption of the transaction in the async workers is mediated by external events, e.g. a POST-back into Kamailio's `xhttp` server. While this does not change the nature of the subsequent synchronous execution of the route logic, it does mean that neither a core CIP worker nor an async worker is tied up while some kind of external processing is playing out. -- Alex -- Alex Balashov Principal Consultant Evariste Systems LLC Web: https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fevaristes… Tel: +1-706-510-6800 __________________________________________________________ Kamailio - Users Mailing List - Non Commercial Discussions To unsubscribe send an email to sr-users-leave(a)lists.kamailio.org Important: keep the mailing list in the recipients, do not reply only to the sender! Edit mailing list options or unsubscribe:

On Aug 29, 2024, at 4:18 PM, Ben Kaufman &lt;bkaufman(a)bcmone.com&gt; wrote: I'm not sure I understand how it's not getting more throughput. Every request got its reply in only a little over a second, from the first request to the 18,000 request. Using a blocking http request this config (low number of workers) died quickly. The original post in this thread (i.e. the real-world example) was a 302-redirect server. My example traded that for a 404, because it was easier to implement than returning values from the web server to make a 302 reply, but certainly extracting information from the http reply and putting it into the SIP reply is trivial. Kaufman Senior Voice Engineer E: bkaufman(a)bcmone.com SIP.US Client Support: 800.566.9810 | SIPTRUNK Client Support: 800.250.6510 | Flowroute Client Support: 855.356.9768 From: Alex Balashov via sr-users &lt;sr-users(a)lists.kamailio.org&gt; Sent: Thursday, August 29, 2024 2:41 PM To: Kamailio (SER) - Users Mailing List &lt;sr-users(a)lists.kamailio.org&gt; Cc: Alex Balashov &lt;abalashov(a)evaristesys.com&gt; Subject: [SR-Users] Re: http_async and tm CAUTION: This email originated from outside the organization. Do not click links or open attachments unless you recognize the sender and know the content is safe. Ben, You're absolutely correct that the transaction is resumed upon receipt of an HTTP reply, and that the async workers do not block on this event. This is also true of a variety of other patterns and workflows which shuttle the transactions off to an async process pool, not really specific to the HTTP client modules. `tsilo` comes to mind. My overview was meant to make a more general point: once the transaction is resumed, the processing is otherwise linear and identical in every other respect to how it would unfold in the main SIP worker process. This is what I meant when I said: "This does not cause the processing to enter some generally more asynchronous mode in any other respect, and in that sense, is quite different to what most people have in mind when they think of asynchronous processing in the context of general-purpose programming runtimes." My over-arching point is that throughput is still limited by the (fixed) size of the async worker pool, and that the same considerations about its sizing apply in async land as in regular child process land. For this reason, I don't think you are correct to conclude from this exercise that using asynchronous mode / `http_async_client` increases _throughput_. Your example config has one async worker, and that worker can only handle one resumed transaction at a time. This is not a net increase in throughput. You say in your documentation: "Re-running the load test will result in heavily blocked and dropped SIP requests", which is absolutely true; in this paradigm, you are liberating the SIP workers from the congestion that would cause "blocked and dropped SIP requests", by doing what I described in my original message: "suspending it and shipping it to another set of ancillary worker processes". The real conflation here is between "not dropping SIP requests" and "increased throughput". There is no increased throughput, only a deep queue of suspended transactions lined up at the async worker pool. This goes back to the question I raised in a previous message: what exactly is meant by "handle"? Are you "not dropping" 300 CPS, or are you relaying 300 CPS worth of requests? I fully believe that one async worker can churn through hundreds of resumed transactions per second, driven by near-simultaneous HTTP replies, when the effect is simply to send a '404 Not Found', as in your config. Real-world workloads don't particularly resemble that in most cases. You're not getting more _throughput_. You're changing where the blocking occurs so as to not obstruct receipt of further SIP messages, which is precisely what I meant when I said: "suspending it and shipping it to another set of ancillary worker processes". From the perspective of not dropping SIP messages, sweeping these transactions out of the main worker pool is indeed quite effective, and if it is in that narrow sense of "not dropping" that you meant "keeping up with the requests", then you are quite right. I was thinking about bottom-line throughput capacity. I think there is a misconception out there that other config script operations also acquire an asynchronous character, beyond the initial "shipping", as it were, and this is the idea I meant to single out. -- Alex -- Alex Balashov Principal Consultant Evariste Systems LLC Web: https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fevaristes… Tel: +1-706-510-6800 __________________________________________________________ Kamailio - Users Mailing List - Non Commercial Discussions To unsubscribe send an email to sr-users-leave(a)lists.kamailio.org Important: keep the mailing list in the recipients, do not reply only to the sender! Edit mailing list options or unsubscribe:

On Aug 29, 2024, at 5:30 PM, Alex Balashov &lt;abalashov(a)evaristesys.com&gt; wrote: "Looks like success [with the tacit insinuation that it's actually not]" was probably uncharitable. You're right that

On Aug 29, 2024, at 6:35 PM, Ben Kaufman &lt;bkaufman(a)bcmone.com&gt; wrote: So, using kamailio's ASYNC module, the pattern would be to call async_task_route() in listener process A. This passes the transaction to async_worker process A. Then, in the async_worker process, the http request is made and that async worker process is blocked until the web server responds. And yes, if that's what is happening it is just moving the wait time from one process to another. With the http async client, however, my understanding is that the request is sent from listener process A, and then the transaction is suspened. The http async worker process, which not the same as async workers, is running an event loop (libevent is a requirement for http async client). When a http reply is received, the http async worker will resume the transaction that sent the request. The difference is that with the http async client, waiting for the http reply doesn't block anything. Supposing we have a single listener process and a single http async worker process. In very quick succession, 5 SIP requests are received, all requiring an http request. If the 5th http request is the first to receive an http response, then that response will be handled immediately - it's not blocked waiting for the prior 4 http replies.