| /////////////////////////////////////////////////////////////////////////////// |
| // // |
| // Copyright (c) 2000-2019 Ericsson Telecom AB // |
| // // |
| // All rights reserved. This program and the accompanying materials // |
| // are made available under the terms of the Eclipse Public License v2.0 // |
| // which accompanies this distribution, and is available at // |
| // https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////// |
| // Module: EPTF_Transport_Test_perfTestcases |
| // |
| // Purpose: |
| // This module contains the performance test functions of generic EPTF Transport. |
| // |
| // Module depends on: |
| // <EPTF_CLL_TransportMessageBufferManager_Functions> |
| // <EPTF_CLL_FBQ_Functions> |
| // <EPTF_CLL_TransportRouting_Functions> |
| // <EPTF_CLL_TransportCommPortIPL4_Functions> |
| // <IPL4asp_Types> |
| // <EPTF_Transport_Test_Functions> |
| // <EPTF_Transport_Test_Definitions> |
| // <EPTF_CLL_Common_Definitions> |
| // <EPTF_CLL_Base_Functions> |
| // <TCCConversion_Functions> |
| // <EPTF_CLL_TransportCommPortIPL2_Definitions> |
| // <EPTF_CLL_TransportCommPortIPL2_Functions> |
| // <EPTF_CLL_Transport_Definitions> |
| // <EPTF_CLL_Transport_Functions> |
| // <EPTF_CLL_Transport_CommonDefinitions> |
| // <TCCFileIO_Functions> |
| // |
| // Current Owner: |
| // Balazs Lugossy (EBALLUG) |
| // |
| // Last Review Date: |
| // 2012-11-07 |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////// |
| module EPTF_Transport_Test_perfTestcases |
| { |
| |
| //========================================================================= |
| // Import Part |
| //========================================================================= |
| |
| import from IPL4asp_Types all; |
| import from EPTF_Transport_Test_Definitions all; |
| import from EPTF_CLL_Common_Definitions all; |
| import from EPTF_CLL_Base_Functions all; |
| import from TCCConversion_Functions all; |
| import from EPTF_CLL_TransportIPL2_Definitions all; |
| import from EPTF_CLL_TransportIPL2_Functions all; |
| import from EPTF_CLL_Transport_Functions all; |
| import from EPTF_CLL_Transport_CommonDefinitions all; |
| import from TCCFileIO_Functions all; |
| import from EPTF_CLL_Variable_Functions all; |
| import from EPTF_SIP_Transport_Definitions all; |
| import from EPTF_SIP_Transport_Functions all; |
| import from EPTF_SIP_LGen_Definitions all; |
| |
| modulepar { |
| charstring tsp_LocalHostIP := "159.107.193.33" |
| charstring tsp_RemoteHostIP := "159.107.193.33" |
| integer tsp_LocalHostPort := 10005 |
| integer tsp_RemoteHostPort := 10006 |
| float tsp_PerfTestDuration := 10.0; |
| } |
| |
| group SegmentBuffer_Tests { |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_EPTF_SegmentBuffer_PerfTest |
| // Random |
| // Purpose: |
| // to measure the performance of the f_EPTF_SegmentBuffer_initBuffer function, with both inorder,outoforder and mixed data. |
| // |
| // Requirement: |
| // - |
| // |
| // Action: |
| // - calls the above function many times and measure time. |
| // |
| // Expected Result: |
| // ... |
| /////////////////////////////////////////////////////////// |
| testcase tc_EPTF_SegmentBuffer_PerfTest() runs on EPTF_Transport_Test_CT |
| { |
| |
| f_EPTF_SegmentBuffer_init_CT("SegmentBuffer_Test_PerfTest"); |
| |
| var EPTF_SegmentBuffer vl_buffer; |
| var integer vl_result; |
| var integer vl_size; |
| var octetstring vl_content; |
| const integer c_messageLength := 1000; |
| var integer vl_arrayOfIndex[c_messageLength]; |
| const integer c_numberOfReplaces := 2000; |
| const integer c_numberOfReplacesMixed := 20; |
| const integer c_patternLength := 1; |
| var integer i; |
| var integer vl_rndIndex1; |
| var integer vl_rndIndex2; |
| var float r; |
| var integer vl_temp, v_sendCounter := 0; |
| var charstring vl_message; |
| var boolean v_loop := true; |
| |
| for (i := 0; i < c_messageLength; i := i + 1) { |
| vl_arrayOfIndex[i] := i; |
| vl_message[i] := int2char(char2int("A") + float2int(rnd() * 26.0)); |
| } |
| for (i := 0; i < c_numberOfReplaces; i := i + 1) { |
| vl_rndIndex1 := float2int(rnd() * int2float(c_messageLength)); |
| vl_rndIndex2 := float2int(rnd() * int2float(c_messageLength)); |
| vl_temp := vl_arrayOfIndex[vl_rndIndex1]; |
| vl_arrayOfIndex[vl_rndIndex1] := vl_arrayOfIndex[vl_rndIndex2]; |
| vl_arrayOfIndex[vl_rndIndex2] := vl_temp; |
| |
| } |
| |
| |
| setverdict(pass); |
| // Initiates the buffer |
| f_EPTF_SegmentBuffer_initBuffer( vl_buffer); |
| |
| timer T_testDuration := tsp_PerfTestDuration; |
| T_testDuration.start; |
| // run default time for measuring the in-order performance |
| while(v_loop) { |
| // insert the whole message in a lot of segments |
| for (i := 0; i < c_messageLength; i := i + 1) { |
| vl_size := f_EPTF_SegmentBuffer_getContinousLen( pl_buffer := vl_buffer); |
| vl_result := f_EPTF_SegmentBuffer_insertSegment( |
| pl_buffer := vl_buffer, |
| pl_payload := char2oct(vl_message[i]), |
| pl_seqNum := i - vl_size, |
| pl_size := vl_size ); |
| v_sendCounter := v_sendCounter + 1; |
| } |
| // get the content and truncate the buffer |
| f_EPTF_SegmentBuffer_getBuffer( |
| pl_buffer := vl_buffer, |
| pl_content := vl_content); |
| vl_size := f_EPTF_SegmentBuffer_truncBuffer( pl_buffer := vl_buffer ); |
| timer T_dummy := 0.001; |
| T_dummy.start; |
| // repeat the whole process till duration timeout |
| alt { |
| []T_testDuration.timeout { |
| v_loop := false; |
| } |
| []T_dummy.timeout { } |
| } |
| |
| } |
| action("Inserted to buffer in-order: ", v_sendCounter); |
| action("Average buffer in-order insertation/sec: ", int2float(v_sendCounter)/tsp_PerfTestDuration); |
| |
| v_sendCounter := 0; |
| timer T_testDuration2 := tsp_PerfTestDuration; |
| T_testDuration2.start; |
| v_loop := true; |
| // run default time for measuring the out-of-order performance |
| while(v_loop) { |
| for (i := 0; i < c_messageLength; i := i + 1) { |
| vl_size := f_EPTF_SegmentBuffer_getContinousLen( pl_buffer := vl_buffer); |
| vl_result := f_EPTF_SegmentBuffer_insertSegment( |
| pl_buffer := vl_buffer, |
| pl_payload := char2oct(vl_message[vl_arrayOfIndex[i]]), |
| pl_seqNum := vl_arrayOfIndex[i] - vl_size, |
| pl_size := vl_size ); |
| v_sendCounter := v_sendCounter + 1; |
| } |
| |
| f_EPTF_SegmentBuffer_getBuffer( |
| pl_buffer := vl_buffer, |
| pl_content := vl_content); |
| vl_size := f_EPTF_SegmentBuffer_truncBuffer( pl_buffer := vl_buffer ); |
| timer T_dummy := 0.0; |
| T_dummy.start; |
| |
| alt { |
| []T_testDuration2.timeout { |
| v_loop := false; |
| } |
| []T_dummy.timeout { } |
| } |
| } |
| |
| action("Inserted to buffer out-of-order: ", v_sendCounter); |
| action("Average buffer out-of-order insertation/sec: ", int2float(v_sendCounter)/tsp_PerfTestDuration); |
| |
| //rearrange the message to create the mixed scenario |
| for (i := 0; i < c_messageLength; i := i + 1) { |
| vl_arrayOfIndex[i] := i; |
| vl_message[i] := int2char(char2int("A") + float2int(rnd() * 26.0)); |
| } |
| for (i := 0; i < c_numberOfReplacesMixed; i := i + 1) { |
| vl_rndIndex1 := float2int(rnd() * int2float(c_messageLength)); |
| vl_rndIndex2 := float2int(rnd() * int2float(c_messageLength)); |
| vl_temp := vl_arrayOfIndex[vl_rndIndex1]; |
| vl_arrayOfIndex[vl_rndIndex1] := vl_arrayOfIndex[vl_rndIndex2]; |
| vl_arrayOfIndex[vl_rndIndex2] := vl_temp; |
| |
| } |
| |
| v_sendCounter := 0; |
| timer T_testDuration3 := tsp_PerfTestDuration; |
| T_testDuration3.start; |
| v_loop := true; |
| // run default time for measuring the mix performance |
| while(v_loop) { |
| for (i := 0; i < c_messageLength; i := i + 1) { |
| vl_size := f_EPTF_SegmentBuffer_getContinousLen( pl_buffer := vl_buffer); |
| vl_result := f_EPTF_SegmentBuffer_insertSegment( |
| pl_buffer := vl_buffer, |
| pl_payload := char2oct(vl_message[vl_arrayOfIndex[i]]), |
| pl_seqNum := vl_arrayOfIndex[i] - vl_size, |
| pl_size := vl_size ); |
| v_sendCounter := v_sendCounter + 1; |
| } |
| |
| f_EPTF_SegmentBuffer_getBuffer( |
| pl_buffer := vl_buffer, |
| pl_content := vl_content); |
| vl_size := f_EPTF_SegmentBuffer_truncBuffer( pl_buffer := vl_buffer ); |
| timer T_dummy := 0.0; |
| T_dummy.start; |
| |
| alt { |
| []T_testDuration3.timeout { |
| v_loop := false; |
| } |
| []T_dummy.timeout { } |
| } |
| } |
| |
| action("Inserted to buffer mixed: ", v_sendCounter); |
| action("Average buffer mixed insertation/sec: ", int2float(v_sendCounter)/tsp_PerfTestDuration); |
| } |
| |
| } |
| |
| group IPL2_SimpleTests { |
| |
| function f_EPTF_IPL2_Test_messageProcess( |
| in EPTF_Transport_TransportType pl_transportType, |
| in integer pl_connId, |
| in charstring pl_remHost, |
| in integer pl_remPort, |
| in charstring pl_locHost, |
| in integer pl_locPort, |
| in ProtoTuple pl_proto, |
| in integer pl_userData, |
| in octetstring pl_msg) |
| runs on EPTF_Transport_Test_CT |
| { |
| log(%definitionId&":", |
| " pl_connId=", pl_connId, |
| ", pl_remHost=", pl_remHost, |
| ", pl_remPort=", pl_remPort, |
| ", pl_locHost=", pl_locHost, |
| ", pl_locPort=", pl_locPort, |
| ", pl_proto=", pl_proto, |
| ", pl_userData=", pl_userData, |
| ", pl_msg=", pl_msg); |
| } |
| |
| function f_EPTF_IPL2_Test_eventCallback( |
| in EPTF_Transport_TransportType pl_transportType, |
| in ConnectionId pl_connId, |
| in ASP_Event pl_event) |
| runs on EPTF_Transport_Test_CT |
| { |
| log(%definitionId&":", |
| " pl_connId=", pl_connId, |
| ", pl_event=", pl_event); |
| } |
| |
| function f_EPTF_IPL2_Test_getMsgLen( |
| in EPTF_Transport_TransportType pl_transportType, |
| in octetstring pl_stream, |
| inout EPTF_IntegerList pl_args // variadic list of user defined parameters |
| ) |
| return integer |
| { |
| return lengthof(pl_stream); |
| } |
| |
| function f_EPTF_IPL2_Test_messageProcess_perf( |
| in EPTF_Transport_TransportType pl_transportType, |
| in integer pl_connId, |
| in charstring pl_remHost, |
| in integer pl_remPort, |
| in charstring pl_locHost, |
| in integer pl_locPort, |
| in ProtoTuple pl_proto, |
| in integer pl_userData, |
| in octetstring pl_msg) |
| runs on EPTF_Transport_Test_CT |
| { |
| var Result vl_dummy; |
| if(not EPTF_CLL_TransportIPL2_Functions.f_EPTF_Transport_send( |
| IPL2, |
| pl_connId, |
| pl_msg, |
| vl_dummy)) { |
| } |
| v_msgCount := v_msgCount + 1; |
| } |
| |
| testcase tc_EPTF_IPL2_Test_tcpPerf1Socket() |
| runs on EPTF_Transport_Test_CT |
| { |
| |
| |
| var Result vl_result; |
| EPTF_CLL_TransportIPL2_Functions.f_EPTF_Transport_init(IPL2, "mtc"); |
| EPTF_CLL_TransportIPL2_Functions.f_EPTF_Transport_registerMsgCallback( |
| IPL2, |
| "myLgenType", |
| refers(f_EPTF_IPL2_Test_messageProcess_perf), |
| refers(f_EPTF_IPL2_Test_eventCallback)); |
| EPTF_CLL_TransportIPL2_Functions.f_EPTF_Transport_registerMsgLenCallback4LGenType( |
| IPL2, |
| refers(f_EPTF_IPL2_Test_getMsgLen), {}, "myLgenType"); |
| var integer vl_socketId := EPTF_CLL_TransportIPL2_Functions.f_EPTF_Transport_connect(IPL2, {tcp := {}}, tsp_LocalHostIP, tsp_LocalHostPort, tsp_RemoteHostIP, tsp_RemoteHostPort, "myLgenType", |
| vl_result); |
| if(vl_socketId < 0) { |
| log("f_EPTF_TransportIPL2_connect returned ", vl_socketId); |
| f_EPTF_Base_stop(fail); |
| } |
| timer T_wait; |
| T_wait.start(1.0);T_wait.timeout; |
| |
| v_msgCount := 0; |
| var octetstring vl_msg := ''O; |
| var integer i; |
| for(i:=0 ;i<tsp_EPTF_TransportIPL2_tcpMSS/10; i:=i+1) { |
| vl_msg := vl_msg & int2oct(i mod 256, 1); |
| } |
| for(i:=0 ;i<10; i:=i+1) { |
| EPTF_CLL_TransportIPL2_Functions.f_EPTF_Transport_send(IPL2, vl_socketId, vl_msg, vl_result); |
| } |
| |
| timer T_test := tsp_PerfTestDuration; |
| T_test.start; |
| T_test.timeout; |
| |
| action("msg/sec = ", int2float(v_msgCount) / tsp_PerfTestDuration); |
| EPTF_CLL_TransportIPL2_Functions.f_EPTF_Transport_registerMsgCallback( |
| IPL2, |
| "myLgenType", |
| refers(f_EPTF_IPL2_Test_messageProcess), |
| refers(f_EPTF_IPL2_Test_eventCallback)); |
| |
| EPTF_CLL_TransportIPL2_Functions.f_EPTF_Transport_close(IPL2, vl_socketId, vl_result); |
| T_wait.start(tsp_EPTF_TransportIPL2_tcpMSL * 2.0 + 0.5); |
| T_wait.timeout; |
| |
| f_EPTF_Base_stop(pass); |
| } |
| |
| |
| modulepar charstring tsp_perf2test_messageFileName := ""; |
| modulepar charstring tsp_perf2test_messageSaveName := "tcp_recv.txt"; |
| |
| function f_EPTF_IPL2_Test_messageProcess_perf2( |
| in EPTF_Transport_TransportType pl_transportType, |
| in integer pl_connId, |
| in charstring pl_remHost, |
| in integer pl_remPort, |
| in charstring pl_locHost, |
| in integer pl_locPort, |
| in ProtoTuple pl_proto, |
| in integer pl_userData, |
| in octetstring pl_msg) |
| runs on EPTF_Transport_Test_CT |
| { |
| v_msgCount := v_msgCount + lengthof(pl_msg); |
| v_recvBuff := v_recvBuff & pl_msg; |
| } |
| |
| testcase tc_EPTF_IPL2_Test_tcpPerf_sendFile() |
| runs on EPTF_Transport_Test_CT |
| { |
| |
| |
| var Result vl_result; |
| EPTF_CLL_TransportIPL2_Functions.f_EPTF_Transport_init(IPL2, "mtc"); |
| EPTF_CLL_TransportIPL2_Functions.f_EPTF_Transport_registerMsgCallback( |
| IPL2, |
| "myLgenType", |
| refers(f_EPTF_IPL2_Test_messageProcess_perf2), |
| refers(f_EPTF_IPL2_Test_eventCallback)); |
| EPTF_CLL_TransportIPL2_Functions.f_EPTF_Transport_registerMsgLenCallback4LGenType( |
| IPL2, |
| refers(f_EPTF_IPL2_Test_getMsgLen), {}, "myLgenType"); |
| var integer vl_socketId := EPTF_CLL_TransportIPL2_Functions.f_EPTF_Transport_connect(IPL2, {tcp := {}}, tsp_LocalHostIP, tsp_LocalHostPort, tsp_RemoteHostIP, tsp_RemoteHostPort, "myLgenType", |
| vl_result); |
| if(vl_socketId < 0) { |
| log("f_EPTF_TransportIPL2_connect returned ", vl_socketId); |
| f_EPTF_Base_stop(fail); |
| } |
| timer T_wait; |
| T_wait.start(1.0);T_wait.timeout; |
| |
| v_msgCount := 0; |
| var octetstring vl_msg := ''O; |
| var integer i; |
| var integer vl_msgLen := 0; |
| action("loading message"); |
| if(tsp_perf2test_messageFileName == "") { |
| f_EPTF_Base_stop(inconc); |
| } |
| var integer vl_fd := f_FIO_open_rdonly(tsp_perf2test_messageFileName); |
| if(vl_fd < 0) { |
| action("couldn't open file "&tsp_perf2test_messageFileName); |
| f_EPTF_Base_stop(fail); |
| } |
| while(true) { |
| var octetstring vl_tmp := ''O; |
| i := f_FIO_read_data(vl_fd, vl_tmp, 100000); |
| vl_msg := vl_msg & vl_tmp; |
| if(i < 1000) { break; } |
| } |
| vl_msgLen := lengthof(vl_msg); |
| f_FIO_close(vl_fd); |
| action("message loaded, length: ", vl_msgLen); |
| var float vl_start := f_EPTF_Base_getRelTimeInSecs(); |
| EPTF_CLL_TransportIPL2_Functions.f_EPTF_Transport_send(IPL2, vl_socketId, vl_msg, vl_result); |
| |
| T_wait.start(100.0); |
| timer T_dummy; |
| T_dummy.start(0.0); |
| alt { |
| []T_wait.timeout { f_EPTF_Base_stop(inconc); } |
| [v_msgCount == vl_msgLen]T_dummy.timeout { } |
| } |
| T_wait.stop; |
| var float vl_end := f_EPTF_Base_getRelTimeInSecs(); |
| action("Transmitted ", vl_msgLen, " bytes in ", vl_end-vl_start, " seconds"); |
| action(int2float(vl_msgLen) / (vl_end-vl_start), " bytes/sec"); |
| |
| action("saving message"); |
| if(tsp_perf2test_messageSaveName == "") { |
| f_EPTF_Base_stop(inconc); |
| } |
| vl_fd := f_FIO_open_trunc_wronly(tsp_perf2test_messageSaveName); |
| if(vl_fd < 0) { |
| action("couldn't open file "&tsp_perf2test_messageSaveName); |
| f_EPTF_Base_stop(fail); |
| } |
| f_FIO_write_data(vl_fd, v_recvBuff); |
| f_FIO_close(vl_fd); |
| |
| EPTF_CLL_TransportIPL2_Functions.f_EPTF_Transport_close(IPL2, vl_socketId, vl_result); |
| T_wait.start(tsp_EPTF_TransportIPL2_tcpMSL * 2.0 + 0.5); |
| T_wait.timeout; |
| |
| f_EPTF_Base_stop(pass); |
| } |
| |
| |
| group IPL2_PerfTest { |
| |
| modulepar integer tsp_messagePayloadSize := 530; |
| modulepar LocalAddrConfigList tsp_LocalAddrConfigList := {}; |
| modulepar RemoteAddrConfigList tsp_RemoteAddrConfigList := {{"", -1}}; |
| modulepar boolean tsp_startServers := true; |
| modulepar integer tsp_maxPendingMsgPerUser := 10; |
| modulepar EPTF_Transport_TransportType tsp_perfTest_transportType := IPL2; |
| modulepar ProtoTuple tsp_perfTest_proto := {tcp := {}}; |
| modulepar boolean tsp_perfTest_wait4response := false; |
| modulepar boolean tsp_perfTest_openListenSockets := true; // open the same number of (unused) listen sockets for client as the number of connections |
| |
| function f_EPTF_IPL2_PerfTest_getMsgLen( |
| in EPTF_Transport_TransportType pl_transportType, |
| in octetstring pl_stream, |
| inout EPTF_IntegerList pl_args |
| ) |
| return integer |
| { |
| return tsp_messagePayloadSize; |
| } |
| |
| function f_EPTF_IPL2_PerfTest_messageProcess( |
| in EPTF_Transport_TransportType pl_transportType, |
| in integer pl_connId, |
| in charstring pl_remHost, |
| in integer pl_remPort, |
| in charstring pl_locHost, |
| in integer pl_locPort, |
| in ProtoTuple pl_proto, |
| in integer pl_userData, |
| in octetstring pl_msg) |
| runs on PerfTestClient_CT |
| { |
| v_recvCounter := v_recvCounter + 1; |
| v_responseReceived := true; |
| v_pendingMsgs[pl_userData] := v_pendingMsgs[pl_userData] - 1; |
| if(v_pendingMsgs[pl_userData]<0) { v_pendingMsgs[pl_userData] := 0 } |
| } |
| |
| modulepar EPTF_Transport_InterfaceInformationList tsp_perfTest_interfaceInformationList := {}; |
| |
| function f_EPTF_IPL2_PerfTest_clientInit(in LocalAddrConfigElem pl_LocalAddrConfigElem, in integer pl_Id) |
| runs on PerfTestClient_CT |
| { |
| var Result vl_result := c_emptyResult; |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_init(tsp_perfTest_transportType, "client" & int2str(pl_Id), tsp_perfTest_interfaceInformationList); |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_registerMsgCallback( |
| tsp_perfTest_transportType, |
| "client" & int2str(pl_Id), |
| refers(f_EPTF_IPL2_PerfTest_messageProcess)/*, |
| refers(f_EPTF_IPL2_PerfTest_eventCallback)*/); |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_registerMsgLenCallback4LGenType( |
| tsp_perfTest_transportType, |
| refers(f_EPTF_IPL2_PerfTest_getMsgLen), {}, "client" & int2str(pl_Id)); |
| var integer i, j, k; |
| var integer vl_userIdx := 0; |
| |
| var integer startIp := oct2int(f_OctetIpv4(pl_LocalAddrConfigElem.startIPAddr)); |
| for(j:=0; j<pl_LocalAddrConfigElem.nofAddr; j:=j+1) { |
| var charstring ipAddr := f_EPTF_TransportIPL2_ip2str(int2oct(startIp + j, 4)); |
| log(%definitionId&": IP Address: ", ipAddr); |
| var integer portNum := pl_LocalAddrConfigElem.startPort; |
| for(k:=0; k<pl_LocalAddrConfigElem.nofPorts; k:=k+1) { |
| // log(%definitionId&": Port number: ", portNum); |
| action("Start initing: ",ipAddr, " ", portNum); |
| if(ischosen(tsp_perfTest_proto.udp)) { |
| v_connectionIds[vl_userIdx] := EPTF_CLL_Transport_Functions.f_EPTF_Transport_listen( |
| tsp_perfTest_transportType, |
| tsp_perfTest_proto, |
| ipAddr, portNum, "client" & int2str(pl_Id), |
| vl_result); |
| } else { |
| v_connectionIds[vl_userIdx] := EPTF_CLL_Transport_Functions.f_EPTF_Transport_connect( |
| tsp_perfTest_transportType, |
| tsp_perfTest_proto, |
| ipAddr, |
| portNum, |
| tsp_RemoteAddrConfigList[pl_Id].IPAddr, |
| tsp_RemoteAddrConfigList[pl_Id].portNumber, |
| "client" & int2str(pl_Id), |
| vl_result); |
| if(tsp_perfTest_openListenSockets) { |
| portNum := portNum + 1; |
| var Result vl_listenRes := c_emptyResult; |
| v_tcpListenIds[vl_userIdx] := EPTF_CLL_Transport_Functions.f_EPTF_Transport_listen( |
| tsp_perfTest_transportType, |
| tsp_perfTest_proto, |
| ipAddr, portNum, "client" & int2str(pl_Id), |
| vl_result); |
| if(v_tcpListenIds[vl_userIdx] < 0) { |
| action("listen "& ipAddr&":"&int2str(portNum)); |
| action("f_EPTF_Transport_listen returned ", v_tcpListenIds[vl_userIdx]); |
| action("f_EPTF_Transport_listen result ", vl_listenRes); |
| f_EPTF_Base_stopAll(fail); |
| } |
| } |
| } |
| portNum := portNum + 1; |
| timer T_wait := 0.0001; |
| T_wait.start; T_wait.timeout; |
| if(v_connectionIds[vl_userIdx] < 0) { |
| action(ipAddr&":"&int2str(portNum)& |
| " -> "&tsp_RemoteAddrConfigList[pl_Id].IPAddr&":"&int2str(tsp_RemoteAddrConfigList[pl_Id].portNumber)); |
| action("f_EPTF_Transport_connect returned ", v_connectionIds[vl_userIdx]); |
| action("f_EPTF_Transport_connect result ", vl_result); |
| f_EPTF_Base_stopAll(fail); |
| } |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_setUserData(tsp_perfTest_transportType, v_connectionIds[vl_userIdx], vl_userIdx, vl_result); |
| v_pendingMsgs[vl_userIdx] := 0; |
| vl_userIdx := vl_userIdx + 1; |
| } |
| } |
| |
| action("Opened ", sizeof(v_connectionIds), " connections"); |
| action("Opened ", sizeof(v_tcpListenIds), " listen sockets"); |
| |
| action("Started up in ", f_EPTF_Base_getRelTimeInSecs(), " seconds."); |
| |
| f_EPTF_Base_registerCleanup(refers(f_EPTF_IPL2_PerfTest_clientCleanup)); |
| |
| sync_PCO.send(pl_Id); |
| sync_PCO.receive; |
| } |
| |
| function f_EPTF_IPL2_PerfTest_clientCleanup() |
| runs on PerfTestClient_CT |
| { |
| var Result vl_result; |
| timer T_wait; |
| for(var integer i:=0; i<sizeof(v_connectionIds); i:=i+1) { |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_close( tsp_perfTest_transportType, v_connectionIds[i], vl_result ); |
| T_wait.start(0.0001);T_wait.timeout; |
| } |
| for(var integer i:=0; i<sizeof(v_tcpListenIds); i:=i+1) { |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_close( tsp_perfTest_transportType, v_tcpListenIds[i], vl_result ); |
| T_wait.start(0.0001);T_wait.timeout; |
| } |
| T_wait.start(1.0);T_wait.timeout; |
| } |
| |
| function f_EPTF_IPL2_PerfTest_clientBehavior(in LocalAddrConfigElem pl_LocalAddrConfigElem, in integer pl_Id) |
| runs on PerfTestClient_CT |
| { |
| var Result vl_result := c_emptyResult; |
| f_EPTF_IPL2_PerfTest_clientInit(pl_LocalAddrConfigElem, pl_Id); |
| |
| v_sendCounter := 0; |
| timer T_testDuration := tsp_PerfTestDuration; |
| T_testDuration.start; |
| v_loop := true; |
| var integer vl_connIdx := 0; |
| var octetstring vl_msg := ''O; |
| for(var integer i:=0; i < tsp_messagePayloadSize; i:=i+1) { |
| vl_msg := vl_msg & int2oct(i mod 256, 1); |
| } |
| |
| action("Starting to send messages"); |
| var integer vl_skippedSends := 0; |
| while(v_loop) { |
| timer T_dummy := 0.00001; |
| |
| v_responseReceived := false; |
| |
| T_dummy.start; |
| alt { |
| []T_testDuration.timeout { v_loop := false; } |
| [] T_dummy.timeout {} |
| } |
| |
| if(ischosen(tsp_perfTest_proto.udp)) { |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_sendTo( |
| tsp_perfTest_transportType, |
| v_connectionIds[vl_connIdx], |
| tsp_RemoteAddrConfigList[pl_Id].IPAddr, |
| tsp_RemoteAddrConfigList[pl_Id].portNumber, |
| vl_msg, |
| vl_result); |
| if(ispresent(vl_result.errorCode)) { |
| action("send result: ", vl_result); |
| } |
| if(v_pendingMsgs[vl_connIdx] < tsp_maxPendingMsgPerUser) { |
| v_pendingMsgs[vl_connIdx] := v_pendingMsgs[vl_connIdx] + 1; |
| v_sendCounter := v_sendCounter + 1; |
| } else { |
| // UDP -> needs retransmit |
| vl_skippedSends := vl_skippedSends + 1; |
| } |
| } else { |
| if(v_pendingMsgs[vl_connIdx] < tsp_maxPendingMsgPerUser) { |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_send( |
| tsp_perfTest_transportType, |
| v_connectionIds[vl_connIdx], |
| vl_msg, |
| vl_result); |
| v_pendingMsgs[vl_connIdx] := v_pendingMsgs[vl_connIdx] + 1; |
| v_sendCounter := v_sendCounter + 1; |
| } else { |
| vl_skippedSends := vl_skippedSends + 1; |
| } |
| } |
| |
| vl_connIdx := vl_connIdx + 1; |
| if(vl_connIdx >= sizeof(v_connectionIds)) { vl_connIdx := 0; } |
| } |
| |
| action("Finished sending messages"); |
| |
| action("Messages sent: ", v_sendCounter); |
| action("Messages received: ", v_recvCounter); |
| if(ischosen(tsp_perfTest_proto.udp)) { |
| action("Retransmissions: ", vl_skippedSends); |
| } else { |
| action("Skipped sends: ", vl_skippedSends); |
| } |
| |
| action("Elapsed time: ", tsp_PerfTestDuration); |
| action("Average send msg/sec: ", int2float(v_sendCounter)/tsp_PerfTestDuration); |
| action("Average recv msg/sec: ", int2float(v_recvCounter)/tsp_PerfTestDuration); |
| timer T_wait := 2.0; |
| T_wait.start;T_wait.timeout; |
| f_EPTF_Base_stopAll(pass); |
| //f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| |
| function f_EPTF_IPL2_PerfTest_clientBehavior_wait4response(in LocalAddrConfigElem pl_LocalAddrConfigElem, in integer pl_Id) |
| runs on PerfTestClient_CT |
| { |
| var Result vl_result := c_emptyResult; |
| f_EPTF_IPL2_PerfTest_clientInit(pl_LocalAddrConfigElem, pl_Id); |
| |
| v_sendCounter := 0; |
| timer T_testDuration := tsp_PerfTestDuration; |
| T_testDuration.start; |
| v_loop := true; |
| var integer vl_connIdx := 0; |
| var octetstring vl_msg := ''O; |
| for(var integer i:=0; i < tsp_messagePayloadSize; i:=i+1) { |
| vl_msg := vl_msg & int2oct(i mod 256, 1); |
| } |
| |
| action("Starting to send messages"); |
| var integer vl_skippedSends := 0; |
| while(v_loop) { |
| v_responseReceived := false; |
| |
| if(ischosen(tsp_perfTest_proto.udp)) { |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_sendTo( |
| tsp_perfTest_transportType, |
| v_connectionIds[vl_connIdx], |
| tsp_RemoteAddrConfigList[pl_Id].IPAddr, |
| tsp_RemoteAddrConfigList[pl_Id].portNumber, |
| vl_msg, |
| vl_result); |
| } else { |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_send( |
| tsp_perfTest_transportType, |
| v_connectionIds[vl_connIdx], |
| vl_msg, |
| vl_result); |
| } |
| // v_pendingMsgs[vl_connIdx] := v_pendingMsgs[vl_connIdx] + 1; |
| |
| timer T_dummy := 0.0; |
| timer T_retransmit := 0.001; |
| T_dummy.start; |
| if(ischosen(tsp_perfTest_proto.udp)) { T_retransmit.start; } |
| alt { |
| []T_testDuration.timeout { v_loop := false; } |
| [v_responseReceived] T_dummy.timeout { |
| vl_connIdx := vl_connIdx + 1; |
| if(vl_connIdx >= sizeof(v_connectionIds)) { vl_connIdx := 0; } |
| v_sendCounter := v_sendCounter + 1; |
| } |
| []T_retransmit.timeout { vl_skippedSends := vl_skippedSends + 1; } |
| } |
| } |
| |
| action("Finished sending messages"); |
| |
| action("Messages sent: ", v_sendCounter); |
| action("Messages received: ", v_recvCounter); |
| if(ischosen(tsp_perfTest_proto.udp)) { |
| action("Retransmissions: ", vl_skippedSends); |
| } else { |
| action("Skipped sends: ", vl_skippedSends); |
| } |
| |
| action("Elapsed time: ", tsp_PerfTestDuration); |
| action("Average send msg/sec: ", int2float(v_sendCounter)/tsp_PerfTestDuration); |
| action("Average recv msg/sec: ", int2float(v_recvCounter)/tsp_PerfTestDuration); |
| f_EPTF_Base_stopAll(pass); |
| } |
| |
| function f_EPTF_IPL2_PerfTest_serverInit(in RemoteAddrConfig pl_RemoteAddrConfig, in integer pl_Id) |
| runs on PerfTestServer_CT |
| { |
| var Result vl_result; |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_init(tsp_perfTest_transportType, "server" & int2str(pl_Id), tsp_perfTest_interfaceInformationList); |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_registerMsgCallback( |
| tsp_perfTest_transportType, |
| "server" & int2str(pl_Id), |
| refers(f_EPTF_IPL2_PerfTest_messageProcess_echo)/*, |
| refers(f_EPTF_IPL2_PerfTest_eventCallback)*/); |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_registerMsgLenCallback4LGenType( |
| tsp_perfTest_transportType, |
| refers(f_EPTF_IPL2_PerfTest_getMsgLen), {}, "server" & int2str(pl_Id)); |
| |
| var integer vl_userIdx := 0; |
| |
| v_connectionIds[vl_userIdx] := EPTF_CLL_Transport_Functions.f_EPTF_Transport_listen( |
| tsp_perfTest_transportType, |
| tsp_perfTest_proto, |
| pl_RemoteAddrConfig.IPAddr, pl_RemoteAddrConfig.portNumber, "server" & int2str(pl_Id), |
| vl_result); |
| // debug |
| v_connectionIds[vl_userIdx] := EPTF_CLL_Transport_Functions.f_EPTF_Transport_listen( |
| tsp_perfTest_transportType, |
| tsp_perfTest_proto, |
| "192.168.20.1", pl_RemoteAddrConfig.portNumber, "server" & int2str(pl_Id), |
| vl_result); |
| //~debug |
| if(v_connectionIds[vl_userIdx] < 0) { |
| log("f_EPTF_Transport_listen returned ", v_connectionIds[vl_userIdx]); |
| log("f_EPTF_Transport_listen result ", vl_result); |
| f_EPTF_Base_stopAll(fail); |
| } |
| |
| f_EPTF_Base_registerCleanup(refers(f_EPTF_IPL2_PerfTest_serverCleanup)); |
| } |
| |
| function f_EPTF_IPL2_PerfTest_serverCleanup() |
| runs on PerfTestServer_CT |
| { |
| var Result vl_result; |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_close( tsp_perfTest_transportType, v_connectionIds[0], vl_result ); |
| timer T_wait; |
| T_wait.start(1.0);T_wait.timeout; |
| } |
| |
| |
| function f_EPTF_IPL2_PerfTest_messageProcess_echo( |
| in EPTF_Transport_TransportType pl_transportType, |
| in integer pl_connId, |
| in charstring pl_remHost, |
| in integer pl_remPort, |
| in charstring pl_locHost, |
| in integer pl_locPort, |
| in ProtoTuple pl_proto, |
| in integer pl_userData, |
| in octetstring pl_msg) |
| runs on PerfTestServer_CT |
| { |
| var Result vl_dummy; |
| if(ischosen(tsp_perfTest_proto.udp)) { |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_sendTo( |
| tsp_perfTest_transportType, |
| pl_connId, |
| pl_remHost, |
| pl_remPort, |
| pl_msg, |
| vl_dummy); |
| } else { |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_send( |
| tsp_perfTest_transportType, |
| pl_connId, |
| pl_msg, |
| vl_dummy); |
| } |
| } |
| |
| function f_EPTF_IPL2_PerfTest_serverBehavior(in RemoteAddrConfig pl_RemoteAddrConfig, in integer pl_Id) |
| runs on PerfTestServer_CT |
| { |
| f_EPTF_IPL2_PerfTest_serverInit(pl_RemoteAddrConfig, pl_Id); |
| |
| action("Starting to receive messages"); |
| |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| |
| |
| testcase tc_EPTF_IPL2_PerfTest() |
| runs on PerfTestClient_CT |
| { |
| |
| |
| f_EPTF_Base_init_CT("mtc"); |
| |
| // var PerfTestServer_CT vl_server := PerfTestServer_CT.create; |
| // vl_server.start(f_EPTF_IPL2_PerfTest_serverBehavior()); |
| |
| var PerfTestClient_CTList vl_clients; |
| var PerfTestServer_CTList vl_servers; |
| var integer i; |
| |
| if(tsp_startServers) { |
| for(i := 0; i < sizeof(tsp_RemoteAddrConfigList); i:= i+ 1){ |
| vl_servers[i] := PerfTestServer_CT.create; |
| vl_servers[i].start(f_EPTF_IPL2_PerfTest_serverBehavior(tsp_RemoteAddrConfigList[i],i)); |
| } |
| } |
| |
| for(i := 0; i < sizeof(tsp_LocalAddrConfigList); i:= i+ 1){ |
| vl_clients[i] := PerfTestClient_CT.create; |
| connect(self : sync_PCO, vl_clients[i] : sync_PCO); |
| if(tsp_perfTest_wait4response) { |
| vl_clients[i].start(f_EPTF_IPL2_PerfTest_clientBehavior_wait4response(tsp_LocalAddrConfigList[i],i)); |
| } else { |
| vl_clients[i].start(f_EPTF_IPL2_PerfTest_clientBehavior(tsp_LocalAddrConfigList[i],i)); |
| } |
| } |
| |
| i := 0; |
| if(sizeof(tsp_LocalAddrConfigList) > 0) { |
| alt{ |
| []sync_PCO.receive { |
| i := i + 1; |
| if (i < sizeof(tsp_LocalAddrConfigList)) { repeat; |
| } |
| } |
| } |
| } |
| |
| for(i := 0; i < sizeof(tsp_LocalAddrConfigList); i:= i+ 1){ |
| sync_PCO.send(integer : i) to vl_clients[i]; |
| } |
| |
| // f_EPTF_Base_wait4Shutdown(); |
| timer T_wait := tsp_PerfTestDuration + 10.0; |
| T_wait.start; T_wait.timeout; |
| f_EPTF_Base_stop(pass); |
| } |
| |
| } // group IPL2_PerfTest |
| |
| } //group IPL2_SimpleTests |
| |
| testcase tc_EPTF_UniqueId_PerfTest() |
| runs on EPTF_Transport_Test_CT |
| { |
| |
| |
| var EPTF_IntegerList vl_uniqueIds := {}; |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_init(IPL4, "UniqueId_PerfTest"); |
| |
| timer T_meas := 10000.0; |
| T_meas.start; |
| for(var integer i := 0; i<100000; i:=i+1) { |
| vl_uniqueIds[i] := f_EPTF_Transport_newUniqueConnId(IPL4, i); |
| } |
| log("allocated 100000 unique IDs in ", T_meas.read, " seconds"); |
| T_meas.stop; |
| // timer T_wait := 10.0; |
| // T_wait.start;T_wait.timeout; |
| |
| var EPTF_Transport_TransportType vl_transportType; |
| var integer vl_connId; |
| T_meas.start; |
| var Result vl_result; |
| for(var integer i := 0; i<100000; i:=i+1) { |
| f_EPTF_Transport_getConnIdFromUniqueId(vl_uniqueIds[i], vl_transportType, vl_connId, vl_result); |
| } |
| log("f_EPTF_Transport_getConnIdFromUniqueId for 100000 unique IDs in ", T_meas.read, " seconds"); |
| T_meas.stop; |
| |
| var integer vl_dummy; |
| T_meas.start; |
| for(var integer i := 0; i<100000; i:=i+1) { |
| vl_dummy := f_EPTF_Transport_getUniqueIdFromConnId(IPL4, i); |
| } |
| log("f_EPTF_Transport_getUniqueIdFromConnId for 100000 unique IDs in ", T_meas.read, " seconds"); |
| T_meas.stop; |
| |
| T_meas.start; |
| for(var integer i := 0; i<100000; i:=i+1) { |
| f_EPTF_Transport_freeUniqueConnId(i); |
| } |
| log("f_EPTF_Transport_freeUniqueConnId for 100000 unique IDs in ", T_meas.read, " seconds"); |
| T_meas.stop; |
| |
| f_EPTF_Base_stop(pass); |
| } |
| // ~tests of transport unique connection IDs |
| |
| function f_EPTF_TransportIPL2_TCPEncDec_genPayload( |
| in integer pl_length) |
| return octetstring { |
| var octetstring vl_payload := ''O; |
| if (pl_length < 0) { |
| pl_length := 0; |
| } |
| |
| for (var integer i := 0; i < pl_length; i := i + 1) { |
| vl_payload := vl_payload&int2oct(i mod 256, 1); |
| } |
| |
| return vl_payload; |
| } |
| |
| function f_EPTF_TransportIPL2_TCPEncDec_genRawTcp( |
| in integer pl_payloadLength) |
| return octetstring { |
| var EPTF_TransportIPL2_PDU_TCP vl_pdu_new := { |
| source_port := 1000, |
| dest_port := 2000, |
| sequence_number := 0, |
| acknowledgment_number := 0, |
| control_bits := c_EPTF_TransportIPL2_TCPControlBit_ack + c_EPTF_TransportIPL2_TCPControlBit_psh, |
| window := 1024, |
| options := 'AABB'O, |
| data := f_EPTF_TransportIPL2_TCPEncDec_genPayload(pl_payloadLength) |
| } |
| |
| return f_EPTF_TransportIPL2_encodeTCPWithChecksum( |
| f_OctetIpv4("221.0.0.1"), |
| f_OctetIpv4("192.168.0.1"), |
| vl_pdu_new); |
| } |
| |
| group SIP_Transport_PerfTest { |
| |
| function f_EPTF_SIP_Transport_PerfTest_getMsgLen( |
| in EPTF_Transport_TransportType pl_transportType, |
| in octetstring pl_stream, |
| inout EPTF_IntegerList pl_args |
| ) |
| return integer |
| { |
| return tsp_messagePayloadSize; |
| } |
| |
| function f_EPTF_SIP_ReceiveMessage(inout EPTF_SIP_Message_IN pl_message) |
| runs on SIPTransport_Client_CT { |
| v_recvCounter := v_recvCounter + 1; |
| v_responseReceived := true; |
| //action("Receive userid :", pl_message.userId); |
| //action("connid :", pl_message.transportParams.connId); |
| if(v_pendingMsgs[pl_message.userId] > 0) { |
| v_pendingMsgs[pl_message.userId] := v_pendingMsgs[pl_message.userId] - 1; |
| } |
| } |
| |
| function f_EPTF_SIP_Transport_PerfTest_clientInit(in LocalAddrConfigElem pl_LocalAddrConfigElem, in integer pl_Id) |
| runs on SIPTransport_Client_CT |
| { |
| var charstring vl_proto; |
| if (tsp_perfTest_proto == {tcp := {}}) { vl_proto := "tcp"; } else { vl_proto := "udp"; } |
| f_EPTF_SIP_LocalTransport_init(vl_proto, "SIP_Transport_PerfTest", tsp_perfTest_transportType); |
| |
| var Result vl_result := c_emptyResult; |
| var integer j, k; |
| var integer vl_userIdx := 0; |
| |
| var integer startIp := oct2int(f_OctetIpv4(pl_LocalAddrConfigElem.startIPAddr)); |
| for(j:=0; j<pl_LocalAddrConfigElem.nofAddr; j:=j+1) { |
| var charstring ipAddr := f_EPTF_TransportIPL2_ip2str(int2oct(startIp + j, 4)); |
| //log(%definitionId&": IP Address: ", ipAddr); |
| var integer portNum := pl_LocalAddrConfigElem.startPort; |
| for(k:=0; k<pl_LocalAddrConfigElem.nofPorts; k:=k+1) { |
| action("Start initing: ",ipAddr, " ", portNum); |
| f_EPTF_SIP_IPL4asp_SetUserData( |
| vl_userIdx, |
| ipAddr, |
| {portNum, portNum }, |
| vl_proto, |
| tsp_RemoteAddrConfigList[pl_Id].IPAddr, |
| tsp_RemoteAddrConfigList[pl_Id].portNumber); |
| //f_EPTF_SIP_addSipUserToTransportUserData(vl_userIdx,vl_userIdx); |
| // action("vg_SIP_userDB = ", vg_SIP_userDB) |
| v_connectionIds[vl_userIdx] := -1; |
| if(ischosen(tsp_perfTest_proto.udp)) { |
| /*f_EPTF_SIP_listen( |
| vl_userIdx, |
| ipAddr, |
| portNum, |
| tsp_perfTest_proto, |
| {}, |
| v_connectionIds[vl_userIdx], |
| tsp_perfTest_transportType);*/ |
| f_EPTF_SIP_connect( |
| vl_userIdx, |
| tsp_RemoteAddrConfigList[pl_Id].IPAddr, |
| tsp_RemoteAddrConfigList[pl_Id].portNumber, |
| ipAddr, |
| portNum, |
| -1, |
| tsp_perfTest_proto, |
| {}, |
| v_connectionIds[vl_userIdx], |
| tsp_perfTest_transportType); |
| |
| } else { |
| f_EPTF_SIP_connect( |
| vl_userIdx, |
| tsp_RemoteAddrConfigList[pl_Id].IPAddr, |
| tsp_RemoteAddrConfigList[pl_Id].portNumber, |
| ipAddr, |
| portNum, |
| -1, |
| tsp_perfTest_proto, |
| {}, |
| v_connectionIds[vl_userIdx], |
| tsp_perfTest_transportType); |
| if(tsp_perfTest_openListenSockets) { |
| portNum := portNum + 1; |
| var Result vl_listenRes := c_emptyResult; |
| f_EPTF_SIP_listen( |
| vl_userIdx, |
| ipAddr, |
| portNum, |
| tsp_perfTest_proto, |
| {}, |
| v_tcpListenIds[vl_userIdx], |
| tsp_perfTest_transportType); |
| } |
| } |
| portNum := portNum + 1; |
| timer T_wait := 0.0001; |
| T_wait.start; T_wait.timeout; |
| if(v_connectionIds[vl_userIdx] < 0) { |
| action(ipAddr&":"&int2str(portNum)& |
| " -> "&tsp_RemoteAddrConfigList[pl_Id].IPAddr&":"&int2str(tsp_RemoteAddrConfigList[pl_Id].portNumber)); |
| action("f_EPTF_Transport_connect returned ", v_connectionIds[vl_userIdx]); |
| action("f_EPTF_Transport_connect result ", vl_result); |
| f_EPTF_Base_stopAll(fail); |
| } |
| v_pendingMsgs[vl_userIdx] := 0; |
| vl_userIdx := vl_userIdx + 1; |
| } |
| } |
| |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_registerMsgLenCallback4LGenType(tsp_perfTest_transportType, refers(f_PerfTest_getMsgLen), {}, c_SIP_Transport_LGenType); |
| f_SIP_setLocalTransportReceiveFunction( refers(f_EPTF_SIP_ReceiveMessage) ); |
| |
| action("Opened ", sizeof(v_connectionIds), " connections"); |
| action("Opened ", sizeof(v_tcpListenIds), " listen sockets"); |
| action("Started up in ", f_EPTF_Base_getRelTimeInSecs(), " seconds."); |
| |
| f_EPTF_Base_registerCleanup(refers(f_EPTF_SIP_Transport_PerfTest_clientCleanup)); |
| |
| sync_PCO.send(pl_Id); |
| sync_PCO.receive; |
| } |
| |
| function f_EPTF_SIP_Transport_PerfTest_clientCleanup() |
| runs on SIPTransport_Client_CT |
| { |
| var Result vl_result; |
| timer T_wait; |
| for(var integer i:=0; i<sizeof(v_connectionIds); i:=i+1) { |
| f_EPTF_SIP_CloseConnection( v_connectionIds[i] ); |
| T_wait.start(0.0001);T_wait.timeout; |
| } |
| for(var integer i:=0; i<sizeof(v_tcpListenIds); i:=i+1) { |
| f_EPTF_SIP_CloseConnection( v_tcpListenIds[i] ); |
| T_wait.start(0.0001);T_wait.timeout; |
| } |
| T_wait.start(1.0);T_wait.timeout; |
| } |
| |
| function f_EPTF_SIP_Transport_PerfTest_clientBehavior(in LocalAddrConfigElem pl_LocalAddrConfigElem, in integer pl_Id) |
| runs on SIPTransport_Client_CT |
| { |
| var Result vl_result := c_emptyResult; |
| f_EPTF_SIP_Transport_PerfTest_clientInit(pl_LocalAddrConfigElem, pl_Id); |
| var integer vl_userIdx := 0; |
| |
| v_sendCounter := 0; |
| timer T_testDuration := tsp_PerfTestDuration; |
| T_testDuration.start; |
| v_loop := true; |
| var integer vl_connIdx := v_connectionIds[vl_userIdx]; |
| var octetstring vl_msg := ''O; |
| for(var integer i:=0; i < tsp_messagePayloadSize; i:=i+1) { |
| vl_msg := vl_msg & int2oct(i mod 256, 1); |
| } |
| |
| action("Starting to send messages"); |
| // action("vg_SIP_userDB = ", vg_SIP_userDB) |
| var integer vl_skippedSends := 0; |
| while(v_loop) { |
| timer T_dummy := 0.00001; |
| |
| v_responseReceived := false; |
| |
| T_dummy.start; |
| alt { |
| []T_testDuration.timeout { v_loop := false; } |
| [] T_dummy.timeout {} |
| } |
| |
| if(ischosen(tsp_perfTest_proto.udp)) { |
| f_EPTF_SIP_send(vl_userIdx, vl_connIdx, vl_msg); |
| if(v_pendingMsgs[vl_userIdx] < tsp_maxPendingMsgPerUser) { |
| v_pendingMsgs[vl_userIdx] := v_pendingMsgs[vl_userIdx] + 1; |
| v_sendCounter := v_sendCounter + 1; |
| } else { |
| // UDP -> needs retransmit |
| vl_skippedSends := vl_skippedSends + 1; |
| } |
| } else { |
| if(v_pendingMsgs[vl_userIdx] < tsp_maxPendingMsgPerUser) { |
| |
| /*if (ischosen(v_connections.data[vl_connIdx].proto.tcp) and |
| TEMPORARY_UNAVAILABLE == v_connections.data[vl_connIdx].connState) |
| { |
| f_EPTF_SIP_MessageBufferAdd(vl_userIdx, vl_connIdx, vl_msg); |
| }else{*/ |
| f_EPTF_SIP_send(vl_userIdx, vl_connIdx, vl_msg); |
| //} |
| v_pendingMsgs[vl_userIdx] := v_pendingMsgs[vl_userIdx] + 1; |
| v_sendCounter := v_sendCounter + 1; |
| } else { |
| vl_skippedSends := vl_skippedSends + 1; |
| } |
| } |
| |
| // vl_connIdx := vl_connIdx + 1; |
| vl_userIdx := vl_userIdx + 1; |
| // if(vl_connIdx >= sizeof(v_connectionIds)) { vl_connIdx := 0; } |
| if(vl_userIdx >= sizeof(v_connectionIds)) { vl_userIdx := 0; } |
| vl_connIdx := v_connectionIds[vl_userIdx]; |
| |
| } |
| |
| action("Finished sending messages"); |
| |
| action("Messages sent: ", v_sendCounter); |
| action("Messages received: ", v_recvCounter); |
| if(ischosen(tsp_perfTest_proto.udp)) { |
| action("Retransmissions: ", vl_skippedSends); |
| } else { |
| action("Skipped sends: ", vl_skippedSends); |
| } |
| |
| action("Elapsed time: ", tsp_PerfTestDuration); |
| action("Average send msg/sec: ", int2float(v_sendCounter)/tsp_PerfTestDuration); |
| action("Average recv msg/sec: ", int2float(v_recvCounter)/tsp_PerfTestDuration); |
| action("vg_EPTF_SIP_IPL4asp_stats: ", vg_EPTF_SIP_IPL4asp_stats); |
| |
| action("f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofOpenConnections_k): ", f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofOpenConnections_k)); |
| action("f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofTransportWarnings_k): ", f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofTransportWarnings_k)); |
| action("f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofReceivedMessages_k): ", f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofReceivedMessages_k)); |
| action("f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofSentMessages_k): ", f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofSentMessages_k)); |
| action("f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofReceivedBytes_k): ", f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofReceivedBytes_k)); |
| action("f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofSentBytes_k): ", f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofSentBytes_k)); |
| |
| timer T_wait := 2.0; |
| T_wait.start;T_wait.timeout; |
| f_EPTF_Base_stopAll(pass); |
| } |
| |
| |
| function f_EPTF_SIP_Transport_PerfTest_clientBehavior_wait4response(in LocalAddrConfigElem pl_LocalAddrConfigElem, in integer pl_Id) |
| runs on SIPTransport_Client_CT |
| { |
| var Result vl_result := c_emptyResult; |
| var integer vl_userIdx := 0; |
| f_EPTF_SIP_Transport_PerfTest_clientInit(pl_LocalAddrConfigElem, pl_Id); |
| |
| v_sendCounter := 0; |
| timer T_testDuration := tsp_PerfTestDuration; |
| T_testDuration.start; |
| v_loop := true; |
| var integer vl_connIdx := 0; |
| var octetstring vl_msg := ''O; |
| for(var integer i:=0; i < tsp_messagePayloadSize; i:=i+1) { |
| vl_msg := vl_msg & int2oct(i mod 256, 1); |
| } |
| |
| action("Starting to send messages"); |
| var integer vl_skippedSends := 0; |
| while(v_loop) { |
| v_responseReceived := false; |
| |
| if(ischosen(tsp_perfTest_proto.udp)) { |
| f_EPTF_SIP_send(vl_userIdx, vl_connIdx, vl_msg); |
| } else { |
| if (ischosen(v_connections.data[vl_connIdx].proto.tcp) and |
| TEMPORARY_UNAVAILABLE == v_connections.data[vl_connIdx].connState) |
| { |
| f_EPTF_SIP_MessageBufferAdd(vl_userIdx, vl_connIdx, vl_msg); |
| }else{ |
| f_EPTF_SIP_send(vl_userIdx, vl_connIdx, vl_msg); |
| } |
| } |
| |
| timer T_dummy := 0.0; |
| timer T_retransmit := 0.001; |
| T_dummy.start; |
| if(ischosen(tsp_perfTest_proto.udp)) { T_retransmit.start; } |
| /* FIXME Something is really wrong here, if the v_responseReceived is between [], then dynamic test case error happend. |
| alt { |
| []T_testDuration.timeout { v_loop := false; } |
| [v_responseReceived] T_dummy.timeout { |
| vl_connIdx := vl_connIdx + 1; |
| if(vl_connIdx >= sizeof(v_connectionIds)) { vl_connIdx := 0; } |
| vl_userIdx := vl_userIdx + 1; |
| if(vl_userIdx >= sizeof(v_connectionIds)) { vl_userIdx := 0; } |
| v_sendCounter := v_sendCounter + 1; |
| } |
| []T_retransmit.timeout { vl_skippedSends := vl_skippedSends + 1; } |
| } |
| */ |
| alt { |
| []T_testDuration.timeout { v_loop := false; } |
| [] T_dummy.timeout { vl_connIdx := vl_connIdx + 1; |
| if(vl_connIdx >= sizeof(v_connectionIds)) { vl_connIdx := 0; } |
| vl_userIdx := vl_userIdx + 1; |
| if(vl_userIdx >= sizeof(v_connectionIds)) { vl_userIdx := 0; } |
| v_sendCounter := v_sendCounter + 1; } |
| []T_retransmit.timeout { vl_skippedSends := vl_skippedSends + 1; } |
| } |
| } |
| |
| action("Finished sending messages"); |
| |
| action("Messages sent: ", v_sendCounter); |
| action("Messages received: ", v_recvCounter); |
| if(ischosen(tsp_perfTest_proto.udp)) { |
| action("Retransmissions: ", vl_skippedSends); |
| } else { |
| action("Skipped sends: ", vl_skippedSends); |
| } |
| |
| action("Elapsed time: ", tsp_PerfTestDuration); |
| action("Average send msg/sec: ", int2float(v_sendCounter)/tsp_PerfTestDuration); |
| action("Average recv msg/sec: ", int2float(v_recvCounter)/tsp_PerfTestDuration); |
| action("vg_EPTF_SIP_IPL4asp_stats: ", vg_EPTF_SIP_IPL4asp_stats); |
| action("f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofOpenConnections_k): ", f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofOpenConnections_k)); |
| action("f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofTransportWarnings_k): ", f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofTransportWarnings_k)); |
| action("f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofReceivedMessages_k): ", f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofReceivedMessages_k)); |
| action("f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofSentMessages_k): ", f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofSentMessages_k)); |
| action("f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofReceivedBytes_k): ", f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofReceivedBytes_k)); |
| action("f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofSentBytes_k): ", f_EPTF_Var_getIntValue(v_EPTF_SIP_Transport_stats.nofSentBytes_k)); |
| f_EPTF_Base_stopAll(pass); |
| } |
| |
| function f_EPTF_SIP_Transport_PerfTest_serverInit(in RemoteAddrConfig pl_RemoteAddrConfig, in integer pl_Id) |
| runs on PerfTestServer_CT |
| { |
| var Result vl_result; |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_init(tsp_perfTest_transportType, "server" & int2str(pl_Id)); //, {}, false); |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_registerMsgCallback( |
| tsp_perfTest_transportType, |
| "server" & int2str(pl_Id), |
| refers(f_EPTF_SIP_Transport_PerfTest_messageProcess_echo)/*, |
| refers(f_EPTF_SIP_Transport_PerfTest_eventCallback)*/); |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_registerMsgLenCallback4LGenType( |
| tsp_perfTest_transportType, |
| refers(f_EPTF_SIP_Transport_PerfTest_getMsgLen), {}, "server" & int2str(pl_Id)); |
| |
| var integer vl_userIdx := 0; |
| |
| v_connectionIds[vl_userIdx] := EPTF_CLL_Transport_Functions.f_EPTF_Transport_listen( |
| tsp_perfTest_transportType, |
| tsp_perfTest_proto, |
| pl_RemoteAddrConfig.IPAddr, pl_RemoteAddrConfig.portNumber, "server" & int2str(pl_Id), |
| vl_result); |
| if(v_connectionIds[vl_userIdx] < 0) { |
| log("f_EPTF_Transport_listen returned ", v_connectionIds[vl_userIdx]); |
| log("f_EPTF_Transport_listen result ", vl_result); |
| f_EPTF_Base_stopAll(fail); |
| } |
| |
| f_EPTF_Base_registerCleanup(refers(f_EPTF_SIP_Transport_PerfTest_serverCleanup)); |
| } |
| |
| function f_EPTF_SIP_Transport_PerfTest_serverCleanup() |
| runs on PerfTestServer_CT |
| { |
| var Result vl_result; |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_close( tsp_perfTest_transportType, v_connectionIds[0], vl_result ); |
| timer T_wait; |
| T_wait.start(1.0);T_wait.timeout; |
| } |
| |
| |
| function f_EPTF_SIP_Transport_PerfTest_messageProcess_echo( |
| in EPTF_Transport_TransportType pl_transportType, |
| in integer pl_connId, |
| in charstring pl_remHost, |
| in integer pl_remPort, |
| in charstring pl_locHost, |
| in integer pl_locPort, |
| in ProtoTuple pl_proto, |
| in integer pl_userData, |
| in octetstring pl_msg) |
| runs on PerfTestServer_CT |
| { |
| var Result vl_dummy; |
| //action("server echo connid:", pl_connId); |
| if(ischosen(tsp_perfTest_proto.udp)) { |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_sendTo( |
| tsp_perfTest_transportType, |
| pl_connId, |
| pl_remHost, |
| pl_remPort, |
| pl_msg, |
| vl_dummy); |
| } else { |
| EPTF_CLL_Transport_Functions.f_EPTF_Transport_send( |
| tsp_perfTest_transportType, |
| pl_connId, |
| pl_msg, |
| vl_dummy); |
| } |
| } |
| |
| function f_EPTF_SIP_Transport_PerfTest_serverBehavior(in RemoteAddrConfig pl_RemoteAddrConfig, in integer pl_Id) |
| runs on PerfTestServer_CT |
| { |
| f_EPTF_SIP_Transport_PerfTest_serverInit(pl_RemoteAddrConfig, pl_Id); |
| action("Starting to receive messages"); |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| |
| |
| testcase tc_EPTF_SIP_Transport_PerfTest() |
| runs on SIPTransport_Client_CT |
| { |
| |
| |
| f_EPTF_Base_init_CT("mtc"); |
| |
| var SIPTransport_Client_CTList vl_clients; |
| var PerfTestServer_CTList vl_servers; |
| var integer i; |
| |
| if(tsp_startServers) { |
| for(i := 0; i < sizeof(tsp_RemoteAddrConfigList); i:= i+ 1){ |
| vl_servers[i] := PerfTestServer_CT.create; |
| vl_servers[i].start(f_EPTF_SIP_Transport_PerfTest_serverBehavior(tsp_RemoteAddrConfigList[i],i)); |
| } |
| } |
| for(i := 0; i < sizeof(tsp_LocalAddrConfigList); i:= i+ 1){ |
| vl_clients[i] := SIPTransport_Client_CT.create; |
| connect(self : sync_PCO, vl_clients[i] : sync_PCO); |
| if(tsp_perfTest_wait4response) { |
| vl_clients[i].start(f_EPTF_SIP_Transport_PerfTest_clientBehavior_wait4response(tsp_LocalAddrConfigList[i],i)); |
| } else { |
| vl_clients[i].start(f_EPTF_SIP_Transport_PerfTest_clientBehavior(tsp_LocalAddrConfigList[i],i)); |
| } |
| } |
| i := 0; |
| if(sizeof(tsp_LocalAddrConfigList) > 0) { |
| alt{ |
| []sync_PCO.receive { |
| i := i + 1; |
| if (i < sizeof(tsp_LocalAddrConfigList)) { repeat; |
| } |
| } |
| } |
| } |
| |
| for(i := 0; i < sizeof(tsp_LocalAddrConfigList); i:= i+ 1){ |
| sync_PCO.send(integer : i) to vl_clients[i]; |
| } |
| |
| timer T_wait := tsp_PerfTestDuration + 10.0; |
| T_wait.start; T_wait.timeout; |
| f_EPTF_Base_stop(pass); |
| } |
| |
| } |
| |
| private function f_PerfTest_getMsgLen( |
| in EPTF_Transport_TransportType pl_transportType, |
| in octetstring stream, |
| inout EPTF_IntegerList args) // variadic list of user defined parameters |
| return integer { |
| return 520; |
| } |
| |
| control { |
| execute(tc_EPTF_SegmentBuffer_PerfTest()); |
| execute(tc_EPTF_IPL2_Test_tcpPerf1Socket()); |
| execute(tc_EPTF_IPL2_Test_tcpPerf_sendFile()); |
| execute(tc_EPTF_IPL2_PerfTest()); |
| execute(tc_EPTF_UniqueId_PerfTest()); |
| execute(tc_EPTF_SIP_Transport_PerfTest()); |
| |
| } |
| |
| } // end of module |
