Kamailio SIP Server Wiki

User Tools

Site Tools

Trace:
kemi:performance-tests:5.2.x

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
kemi:performance-tests:5.2.x [2018/11/28 10:36] – micondakemi:performance-tests:5.2.x [2019/01/07 08:05] (current) – [Remarks] miconda
Line 112: Line 112:
 </code> </code>
  
-Testing command:+These users have to be added to Kamailio subscriber table. To add them from the source code tree of Kamailio: 
 + 
 +<code> 
 +cd utils/kamctl/ 
 +DBENGINE=MYSQL ./kamdbctl create 
 +DBENGINE=MYSQL ./kamctl add test0@127.0.0.1 test0 
 +DBENGINE=MYSQL ./kamctl add test1@127.0.0.1 test1 
 +DBENGINE=MYSQL ./kamctl add test2@127.0.0.1 test2 
 +DBENGINE=MYSQL ./kamctl add test3@127.0.0.1 test3 
 +DBENGINE=MYSQL ./kamctl add test4@127.0.0.1 test4 
 +DBENGINE=MYSQL ./kamctl add test5@127.0.0.1 test5 
 +DBENGINE=MYSQL ./kamctl add test6@127.0.0.1 test6 
 +DBENGINE=MYSQL ./kamctl add test7@127.0.0.1 test7 
 +DBENGINE=MYSQL ./kamctl add test8@127.0.0.1 test8 
 +DBENGINE=MYSQL ./kamctl add test9@127.0.0.1 test9 
 +DBENGINE=MYSQL ./kamctl db show subscriber 
 +</code> 
 + 
 +===== SIPP Testing Command ===== 
 + 
 +SIPP was run on the same system with Kamailio. The command is:
  
 <code> <code>
Line 125: Line 145:
  
 ==== Common Config File ==== ==== Common Config File ====
 +
 +File: ../etc/kamailio-basic-kemi.cfg
  
 <code c> <code c>
 #!KAMAILIO #!KAMAILIO
 # #
-# Kamailio (OpenSER) SIP Server v5.0 - default configuration script+# Kamailio (OpenSER) SIP Server v5.3 - default configuration script
 #     - web: http://www.kamailio.org #     - web: http://www.kamailio.org
 #     - git: http://sip-router.org #     - git: http://sip-router.org
Line 485: Line 507:
  
 #!ifdef WITH_CFGPYTHON #!ifdef WITH_CFGPYTHON
-modparam("app_python", "script_name", "/usr/local/etc/kamailio/kamailio-basic-kemi-python.py")+modparam("app_python", "script_name", "../etc/kamailio-basic-kemi-python.py")
 cfgengine "python" cfgengine "python"
 #!else #!else
Line 491: Line 513:
 #!ifdef WITH_CFGLUA #!ifdef WITH_CFGLUA
 modparam("app_lua", "reload", 1) modparam("app_lua", "reload", 1)
-modparam("app_lua", "load", "/home/dublin/work/sip/esr/etc/kamailio-basic-kemi-lua.lua")+modparam("app_lua", "load", "../etc/kamailio-basic-kemi-lua.lua")
 cfgengine "lua" cfgengine "lua"
 #!else #!else
  
 #!ifdef WITH_CFGJSDT #!ifdef WITH_CFGJSDT
-modparam("app_jsdt", "load", "/usr/local/etc/kamailio/kamailio-basic-kemi-jsdt.js")+modparam("app_jsdt", "load", "../etc/kamailio-basic-kemi-jsdt.js")
 cfgengine "jsdt" cfgengine "jsdt"
 #!else #!else
 #!ifdef WITH_CFGSQLANG #!ifdef WITH_CFGSQLANG
-modparam("app_sqlang", "load", "/usr/local/etc/kamailio/kamailio-basic-kemi-sqlang.sq")+modparam("app_sqlang", "load", "../etc/kamailio-basic-kemi-sqlang.sq")
 cfgengine "sqlang" cfgengine "sqlang"
 #!else #!else
 cfgengine "native" cfgengine "native"
-include_file "/home/dublin/work/sip/esr/etc/kamailio-basic-kemi-native.cfg"+include_file "../etc/kamailio-basic-kemi-native.cfg"
 #!endif #!endif
  
Line 516: Line 538:
  
 ==== Native Scripting Routing Blocks ==== ==== Native Scripting Routing Blocks ====
 +
 +File: ../etc/kamailio-basic-kemi-native.cfg
  
 <code c> <code c>
Line 851: Line 875:
  
 ==== Lua Scripting Routing Functions ==== ==== Lua Scripting Routing Functions ====
 +
 +File: ../etc/kamailio-basic-kemi-lua.lua
  
 <code lua> <code lua>
Line 985: Line 1011:
 function ksr_route_reqinit() function ksr_route_reqinit()
  if not KSR.is_myself_srcip() then  if not KSR.is_myself_srcip() then
- if not KSR.htable.sht_has_name("ipban", "eq", K_si) then+ if KSR.htable.sht_has_name("ipban", "eq", K_si) > 0 then
  -- ip is already blocked  -- ip is already blocked
  KSR.dbg("request from blocked IP - " .. K_rm  KSR.dbg("request from blocked IP - " .. K_rm
Line 998: Line 1024:
  end  end
  end  end
- if KSR.corex.has_user_agent() then+ if KSR.corex.has_user_agent() > 0 then
  if string.find(K_ua, "friendly-scanner")  if string.find(K_ua, "friendly-scanner")
  or string.find(K_ua, "sipcli") then  or string.find(K_ua, "sipcli") then
Line 1243: Line 1269:
  K_ua = KSR.pv.gete("$ua");  K_ua = KSR.pv.gete("$ua");
 end end
 +
 +</code>
 +
 +==== Python Scripting Routing Functions ====
 +
 +File: ../etc/kamailio-basic-kemi-python.py
 +
 +<code python>
 +## Kamailio - equivalent of routing blocks in Python
 +##
 +## KSR - the new dynamic object exporting Kamailio functions
 +## Router - the old object exporting Kamailio functions
 +##
 +
 +## Relevant remarks:
 +##  * return code -255 is used to propagate the 'exit' behaviour to the
 +##  parent route block function. The alternative is to use the native
 +##  Python function os.exit() (or exit()) -- it throws an exception that
 +##  is caught by Kamailio and previents the stop of the interpreter.
 +
 +
 +import sys
 +import Router.Logger as Logger
 +import KSR as KSR
 +
 +# global variables corresponding to defined values (e.g., flags) in kamailio.cfg
 +FLT_ACC=1
 +FLT_ACCMISSED=2
 +FLT_ACCFAILED=3
 +FLT_NATS=5
 +
 +FLB_NATB=6
 +FLB_NATSIPPING=7
 +
 +
 +# global function to instantiate a kamailio class object
 +# -- executed when kamailio app_python module is initialized
 +def mod_init():
 +    KSR.info("===== from Python mod init\n");
 +    # dumpObj(KSR);
 +    return kamailio();
 +
 +
 +# -- {start defining kamailio class}
 +class kamailio:
 +    def __init__(self):
 +        KSR.info('===== kamailio.__init__\n');
 +
 +
 +    # executed when kamailio child processes are initialized
 +    def child_init(self, rank):
 +        KSR.info('===== kamailio.child_init(%d)\n' % rank);
 +        return 0;
 +
 +
 +    # SIP request routing
 +    # -- equivalent of request_route{}
 +    def ksr_request_route(self, msg):
 +        # KSR.info("===== request - from kamailio python script\n");
 +        # KSR.info("===== method [%s] r-uri [%s]\n" % (KSR.pv.get("$rm"),KSR.pv.get("$ru")));
 +
 +        # per request initial checks
 +        if self.ksr_route_reqinit(msg)==-255 :
 +            return 1;
 +
 +        # NAT detection
 +        if self.ksr_route_natdetect(msg)==-255 :
 +            return 1;
 +
 +        # CANCEL processing
 +        if KSR.is_CANCEL() :
 +            if KSR.tm.t_check_trans()>0 :
 +                self.ksr_route_relay(msg);
 +            return 1;
 +
 +        # handle requests within SIP dialogs
 +        if self.ksr_route_withindlg(msg)==-255 :
 +            return 1;
 +
 +        # -- only initial requests (no To tag)
 +
 +        # handle retransmissions
 +        if KSR.tmx.t_precheck_trans()>0 :
 +            KSR.tm.t_check_trans();
 +            return 1;
 +
 +        if KSR.tm.t_check_trans()==0 :
 +            return 1;
 +
 +        # authentication
 +        if self.ksr_route_auth(msg)==-255 :
 +            return 1
 +
 +        # record routing for dialog forming requests (in case they are routed)
 +        # - remove preloaded route headers
 +        KSR.hdr.remove("Route");
 +        if KSR.is_method_in("IS") :
 +            KSR.rr.record_route();
 +
 +
 +        # account only INVITEs
 +        if KSR.pv.get("$rm")=="INVITE" :
 +            KSR.setflag(FLT_ACC); # do accounting
 +
 +
 +        # dispatch requests to foreign domains
 +        if self.ksr_route_sipout(msg)==-255 :
 +            return 1;
 +
 +        # # requests for my local domains
 +
 +        # handle registrations
 +        if self.ksr_route_registrar(msg)==-255 :
 +            return 1;
 +
 +        if KSR.corex.has_ruri_user() < 0 :
 +            # request with no Username in RURI
 +            KSR.sl.sl_send_reply(484,"Address Incomplete");
 +            return 1;
 +
 +
 +        # user location service
 +        self.ksr_route_location(msg);
 +
 +        return 1;
 +
 +
 +    # wrapper around tm relay function
 +    def ksr_route_relay(self, msg):
 +        # enable additional event routes for forwarded requests
 +        # - serial forking, RTP relaying handling, a.s.o.
 +        if KSR.is_method_in("IBSU") :
 +            if KSR.tm.t_is_set("branch_route")<0 :
 +                KSR.tm.t_on_branch("ksr_branch_manage");
 +
 +        if KSR.is_method_in("ISU") :
 +            if KSR.tm.t_is_set("onreply_route")<0 :
 +                KSR.tm.t_on_reply("ksr_onreply_manage");
 +
 +        if KSR.is_INVITE() :
 +            if KSR.tm.t_is_set("failure_route")<0 :
 +                KSR.tm.t_on_failure("ksr_failure_manage");
 +
 +        if KSR.tm.t_relay()<0 :
 +            KSR.sl.sl_reply_error();
 +
 +        return -255;
 +
 +
 +    # Per SIP request initial checks
 +    def ksr_route_reqinit(self, msg):
 +        if not KSR.is_myself(KSR.pv.get("$si")) :
 +            if not KSR.pv.is_null("$sht(ipban=>$si)") :
 +                # ip is already blocked
 +                KSR.dbg("request from blocked IP - " + KSR.pv.get("$rm")
 +                        + " from " + KSR.pv.get("$fu") + " (IP:"
 +                        + KSR.pv.get("$si") + ":" + str(KSR.pv.get("$sp")) + ")\n");
 +                return -255;
 +
 +            if KSR.pike.pike_check_req()<0 :
 +                KSR.err("ALERT: pike blocking " + KSR.pv.get("$rm")
 +                        + " from " + KSR.pv.get("$fu") + " (IP:"
 +                        + KSR.pv.get("$si") + ":" + str(KSR.pv.get("$sp")) + ")\n");
 +                KSR.pv.seti("$sht(ipban=>$si)", 1);
 +                return -255;
 +
 +        if KSR.corex.has_user_agent() > 0 :
 +            ua = KSR.pv.gete("$ua")
 +            if (ua.find("friendly-scanner")!=-1
 +                    or ua.find("sipcli")!=-1) :
 +                KSR.sl.sl_send_reply(200, "Processed");
 +                return -255;
 +
 +        if KSR.maxfwd.process_maxfwd(10) < 0 :
 +            KSR.sl.sl_send_reply(483,"Too Many Hops");
 +            return -255;
 +
 +        if (KSR.is_OPTIONS()
 +                and KSR.is_myself_ruri()
 +                and KSR.corex.has_ruri_user() < 0) :
 +            KSR.sl.sl_send_reply(200,"Keepalive");
 +            return -255;
 +
 +        if KSR.sanity.sanity_check(1511, 7)<0 :
 +            KSR.err("Malformed SIP message from "
 +                    + KSR.pv.get("$si") + ":" + str(KSR.pv.get("$sp")) +"\n");
 +            return -255;
 +
 +
 +    # Handle requests within SIP dialogs
 +    def ksr_route_withindlg(self, msg):
 +        if KSR.siputils.has_totag()<0 :
 +            return 1;
 +
 +        # sequential request withing a dialog should
 +        # take the path determined by record-routing
 +        if KSR.rr.loose_route()>0 :
 +            if self.ksr_route_dlguri(msg)==-255 :
 +                return -255;
 +            if KSR.is_BYE() :
 +                # do accounting ...
 +                KSR.setflag(FLT_ACC);
 +                # ... even if the transaction fails
 +                KSR.setflag(FLT_ACCFAILED);
 +            elif KSR.is_ACK() :
 +                # ACK is forwarded statelessly
 +                if self.ksr_route_natmanage(msg)==-255 :
 +                    return -255;
 +            elif KSR.is_NOTIFY() :
 +                # Add Record-Route for in-dialog NOTIFY as per RFC 6665.
 +                KSR.rr.record_route();
 +
 +            self.ksr_route_relay(msg);
 +            return -255;
 +
 +        if KSR.is_ACK() :
 +            if KSR.tm.t_check_trans() >0 :
 +                # no loose-route, but stateful ACK;
 +                # must be an ACK after a 487
 +                # or e.g. 404 from upstream server
 +                self.ksr_route_relay(msg);
 +                return -255;
 +            else:
 +                # ACK without matching transaction ... ignore and discard
 +                return -255;
 +
 +        KSR.sl.sl_send_reply(404, "Not here");
 +        return -255;
 +
 +
 +    # Handle SIP registrations
 +    def ksr_route_registrar(self, msg):
 +        if not KSR.is_REGISTER() :
 +            return 1;
 +        if KSR.isflagset(FLT_NATS) :
 +            KSR.setbflag(FLB_NATB);
 +            # do SIP NAT pinging
 +            KSR.setbflag(FLB_NATSIPPING);
 +
 +        if KSR.registrar.save("location", 0)<0 :
 +            KSR.sl.sl_reply_error();
 +
 +        return -255;
 +
 +
 +    # User location service
 +    def ksr_route_location(self, msg):
 +        rc = KSR.registrar.lookup("location");
 +        if rc<0 :
 +            KSR.tm.t_newtran();
 +            if rc==-1 or rc==-3 :
 +                KSR.sl.send_reply(404, "Not Found");
 +                return -255;
 +            elif rc==-2 :
 +                KSR.sl.send_reply(405, "Method Not Allowed");
 +                return -255;
 +
 +        # when routing via usrloc, log the missed calls also
 +        if KSR.is_INVITE() :
 +            KSR.setflag(FLT_ACCMISSED);
 +
 +        self.ksr_route_relay(msg);
 +        return -255;
 +
 +
 +
 +    # IP authorization and user uthentication
 +    def ksr_route_auth(self, msg):
 +
 +        if not KSR.is_REGISTER() :
 +            if KSR.permissions.allow_source_address(1)>0 :
 +                # source IP allowed
 +                return 1;
 +
 +        if KSR.is_REGISTER() or KSR.is_myself_furi() :
 +            # authenticate requests
 +            if KSR.auth_db.auth_check(KSR.pv.get("$fd"), "subscriber", 1)<0 :
 +                KSR.auth.auth_challenge(KSR.pv.get("$fd"), 0);
 +                return -255;
 +
 +            # user authenticated - remove auth header
 +            if not KSR.is_method_in("RP") :
 +                KSR.auth.consume_credentials();
 +
 +        # if caller is not local subscriber, then check if it calls
 +        # a local destination, otherwise deny, not an open relay here
 +        if (not KSR.is_myself_furi()) and (not KSR.is_myself_ruri()) :
 +            KSR.sl.sl_send_reply(403,"Not relaying");
 +            return -255;
 +
 +        return 1;
 +
 +
 +    # Caller NAT detection
 +    def ksr_route_natdetect(self, msg):
 +        KSR.force_rport();
 +        if KSR.nathelper.nat_uac_test(19)>0 :
 +            if KSR.is_REGISTER() :
 +                KSR.nathelper.fix_nated_register();
 +            elif KSR.siputils.is_first_hop()>0 :
 +                KSR.nathelper.set_contact_alias();
 +
 +            KSR.setflag(FLT_NATS);
 +
 +        return 1;
 +
 +
 +    # RTPProxy control
 +    def ksr_route_natmanage(self, msg):
 +        if KSR.siputils.is_request()>0 :
 +            if KSR.siputils.has_totag()>0 :
 +                if KSR.rr.check_route_param("nat=yes")>0 :
 +                    KSR.setbflag(FLB_NATB);
 +
 +        if (not (KSR.isflagset(FLT_NATS) or KSR.isbflagset(FLB_NATB))) :
 +            return 1;
 +
 +        KSR.rtpproxy.rtpproxy_manage("co");
 +
 +        if KSR.siputils.is_request()>0 :
 +            if not KSR.siputils.has_totag() :
 +                if KSR.tmx.t_is_branch_route()>0 :
 +                    KSR.rr.add_rr_param(";nat=yes");
 +
 +        if KSR.siputils.is_reply()>0 :
 +            if KSR.isbflagset(FLB_NATB) :
 +                KSR.nathelper.set_contact_alias();
 +
 +        return 1;
 +
 +
 +    # URI update for dialog requests
 +    def ksr_route_dlguri(self, msg):
 +        if not KSR.isdsturiset() :
 +            KSR.nathelper.handle_ruri_alias();
 +
 +        return 1;
 +
 +
 +    # Routing to foreign domains
 +    def ksr_route_sipout(self, msg):
 +        if KSR.is_myself_ruri() :
 +            return 1;
 +
 +        KSR.hdr.append("P-Hint: outbound\r\n");
 +        self.ksr_route_relay(msg);
 +        return -255;
 +
 +
 +    # Manage outgoing branches
 +    # -- equivalent of branch_route[...]{}
 +    def ksr_branch_manage(self, msg):
 +        KSR.dbg("new branch ["+ str(KSR.pv.get("$T_branch_idx"))
 +                    + "] to "+ KSR.pv.get("$ru") + "\n");
 +        self.ksr_route_natmanage(msg);
 +        return 1;
 +
 +
 +    # Manage incoming replies
 +    # -- equivalent of onreply_route[...]{}
 +    def ksr_onreply_manage(self, msg):
 +        KSR.dbg("incoming reply\n");
 +        scode = KSR.pv.get("$rs");
 +        if scode>100 and scode<299 :
 +            self.ksr_route_natmanage(msg);
 +
 +        return 1;
 +
 +
 +    # Manage failure routing cases
 +    # -- equivalent of failure_route[...]{}
 +    def ksr_failure_manage(self, msg):
 +        if self.ksr_route_natmanage()==-255 : return 1;
 +
 +        if KSR.tm.t_is_canceled()>0 :
 +            return 1;
 +
 +        return 1;
 +
 +
 +    # SIP response handling
 +    # -- equivalent of reply_route{}
 +    def ksr_reply_route(self, msg):
 +        KSR.info("===== response - from kamailio python script\n");
 +        return 1;
 +
 +
 +# -- {end defining kamailio class}
 +
 +
 +# global helper function for debugging purposes
 +def dumpObj(obj):
 +    for attr in dir(obj):
 +        # KSR.info("obj.%s = %s\n" % (attr, getattr(obj, attr)));
 +        Logger.LM_INFO("obj.%s = %s\n" % (attr, getattr(obj, attr)));
 +
  
 </code> </code>
Line 1251: Line 1673:
  
 <code> <code>
-./src/kamailio -f ../etc/kamailio-basic-kemi.cfg -L src/modules/ -w . -A WITH_CFGLUA -a no -E -e -dd 2>&1 | tee /tmp/kamailio-register-lua.txt+./src/kamailio -f ../etc/kamailio-basic-kemi.cfg -L src/modules/ -w . -a no -E -e -dd 2>&1 | tee /tmp/kamailio-register-native.txt
 </code> </code>
  
Line 1257: Line 1679:
  
 <code> <code>
-./src/kamailio -f ../etc/kamailio-basic-kemi.cfg -L src/modules/ -w . -a no -E -e -dd 2>&1 | tee /tmp/kamailio-register-native.txt+./src/kamailio -f ../etc/kamailio-basic-kemi.cfg -L src/modules/ -w . -A WITH_CFGLUA -a no -E -e -dd 2>&1 | tee /tmp/kamailio-register-lua.txt 
 +</code>
  
 +Executed when running with Python scripting language:
 +
 +<code>
 +./src/kamailio -f ../etc/kamailio-basic-kemi.cfg -L src/modules/ -w . -A WITH_CFGPYTHON -a no -E -e -dd 2>&1 | tee /tmp/kamailio-register-python.txt
 </code> </code>
  
Line 1270: Line 1697:
   * max - the maximum execution time for request_route or ksr_request_route() (microseconds)   * max - the maximum execution time for request_route or ksr_request_route() (microseconds)
   * avg - the average execution time for request_route or ksr_request_route() (microseconds)   * avg - the average execution time for request_route or ksr_request_route() (microseconds)
 +
 +The metrics are extracted from the log messages using the next awk script:
 +
 +<code awk>
 +BEGIN {
 +        sum = 0
 +        avg = 0
 +        min = 1000000
 +        max = 0
 +        cnt = 0
 +}
 +
 +/request-route executed/ {
 +        sum += $(NF-1)
 +        cnt += 1
 +        if(min > $(NF-1)) {
 +                min = $(NF-1)
 +        }
 +        if(max < $(NF-1)) {
 +                max = $(NF-1)
 +        }
 +}
 +
 +END {
 +        print "cnt: ", cnt
 +        print "sum: ", sum
 +        print "min: ", min
 +        print "max: ", max
 +        if(cnt>0) {
 +                avg = sum/cnt
 +        }
 +        print "avg: ", avg
 +}
 +
 +</code>
 +
 +The results of several iterations running the tests:
  
 <code> <code>
Line 1278: Line 1742:
 max:  2028 max:  2028
 avg:  75.1823 avg:  75.1823
- 
-$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-lua.txt 
-cnt:  61080 
-sum:  4203512 
-min:  26 
-max:  1316 
-avg:  68.8198 
  
 $ awk -f kamailio-exec-report.awk /tmp/kamailio-register-native.txt $ awk -f kamailio-exec-report.awk /tmp/kamailio-register-native.txt
Line 1292: Line 1749:
 max:  1791 max:  1791
 avg:  75.0521 avg:  75.0521
- 
-$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-lua.txt 
-cnt:  61006 
-sum:  4852005 
-min:  25 
-max:  2535 
-avg:  79.5332 
  
 $ awk -f kamailio-exec-report.awk /tmp/kamailio-register-native.txt $ awk -f kamailio-exec-report.awk /tmp/kamailio-register-native.txt
Line 1306: Line 1756:
 max:  3226 max:  3226
 avg:  77.3734 avg:  77.3734
 +
 +$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-native.txt
 +cnt:  62752
 +sum:  4184315
 +min:  17
 +max:  1948
 +avg:  66.6802
 +
 +$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-native.txt
 +cnt:  63616
 +sum:  4255858
 +min:  17
 +max:  1619
 +avg:  66.8992
 +
 +$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-native.txt
 +cnt:  62420
 +sum:  3697635
 +min:  17
 +max:  2144
 +avg:  59.238
 +
 +$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-native.txt
 +cnt:  63595
 +sum:  4426750
 +min:  17
 +max:  3456
 +avg:  69.6085
 +
 +$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-lua.txt
 +cnt:  61080
 +sum:  4203512
 +min:  26
 +max:  1316
 +avg:  68.8198
 +
 +$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-lua.txt
 +cnt:  61006
 +sum:  4852005
 +min:  25
 +max:  2535
 +avg:  79.5332
  
 $ awk -f kamailio-exec-report.awk /tmp/kamailio-register-lua.txt $ awk -f kamailio-exec-report.awk /tmp/kamailio-register-lua.txt
Line 1313: Line 1805:
 max:  2159 max:  2159
 avg:  67.6884 avg:  67.6884
 +
 +$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-lua.txt
 +cnt:  61850
 +sum:  4466376
 +min:  23
 +max:  2110
 +avg:  72.213
 +
 +$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-lua.txt
 +cnt:  61197
 +sum:  3844555
 +min:  22
 +max:  1852
 +avg:  62.8226
 +
 +$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-lua.txt
 +cnt:  61445
 +sum:  4202427
 +min:  23
 +max:  1750
 +avg:  68.3933
 +
 +$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-lua.txt
 +cnt:  61103
 +sum:  4248753
 +min:  23
 +max:  2442
 +avg:  69.5343
 +
 +$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-python.txt 
 +cnt:  60846
 +sum:  4432028
 +min:  22
 +max:  2628
 +avg:  72.8401
 +
 +$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-python.txt 
 +cnt:  61031
 +sum:  4353501
 +min:  23
 +max:  3005
 +avg:  71.3326
 +
 +$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-python.txt 
 +cnt:  60785
 +sum:  4400362
 +min:  20
 +max:  2093
 +avg:  72.3922
 +
 +$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-python.txt 
 +cnt:  60836
 +sum:  4427855
 +min:  23
 +max:  3441
 +avg:  72.7835
 +
 +$ awk -f kamailio-exec-report.awk /tmp/kamailio-register-python.txt 
 +cnt:  60813
 +sum:  4591943
 +min:  20
 +max:  1751
 +avg:  75.5092
 +
 </code> </code>
 +
 +===== Remarks =====
 +
 +Mentioning it again, the target of the tests was not to measure the capacity of Kamailio processing, but how the execution time differs in more or less same conditions between native scripting configuration file and KEMI alternatives, so far being done for Lua and Python scripting.
 +
 +Testing was done on the same system, running first the test with native configuration file and immediately after, the one for Lua or Python scripting.
 +
 +It was observed that the execution of native scripting routing blocks and Lua scripting functions takes more or less same time. Sometimes is native scripting slightly faster, other times is Lua scripting slightly faster. The average (for both native and Lua scripts) is in the range of 60 to 80 microseconds ( 1 / 1 000 000 of a second) for processing the registration request. The minimum reflects more what it takes for the first REGISTER request without authorization header, which is quickly challenged with 401 response. The maximum reflect the processing of the REGISTER request with valid authorization header, which does a query to database to fetch the password as well as store/update the record in the location hash table (writing to database on timer - usrloc db_mode 2).
 +
 +There are variable number of retransmissions, being the reason for having cnt higher than 60000, a matter of sipp being able to match the response with the request at this high pace of stress testing (4 000 registrations per second, with a limit of 10 000 transactions at the same time, stopping after 20 000 sent messages). Note that each registration is challenged for authentication, so it is resent with authorization header.
 +
 +Comparing with the state of KEMI exports for version 5.1.x, in the v5.2.x were introduced some functions to be the equivalent of some conditions done with core keywords.
 +
 +For example, in the native scripting:
 +
 +<code c>
 +if(uri == myself)
 +</code>
 +
 +can be done in a KEMI scripting language with:
 +
 +<code lua>
 +if KSR.is_myself_ruri() then
 +</code>
 +
 +Tests for Python (using app_python module) were done couple of days later (the Debian Testing system was upgraded to latest version of packages). It was a pleasant surprise to see that the execution times were in the same range as for native and Lua routing scripts.
 +
 +The plan is to as run Lua tests using LuaJIT interpreter instead of the standard Lua (support for LuaJIT was also added for v5.2.x) as well as test for other KEMI itnerpreters (JavaScript, Ruby, Squirrel...).
 +
 +
 +
kemi/performance-tests/5.2.x.1543401389.txt.gz · Last modified: 2018/11/28 10:36 by miconda
Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki