Optimize your code. (Tips and techniques)

This topic is the child of me reworking some code and speed/memory use is now my focus. (code works, but takes 25 minutes on reboot ) I figured that since I am massaging the code, I might as well make some simple changes that won't change the functionality, only the speed in which it happens. I am also consolidating ports and renumbering devices to fit a standard I have created.

As for the timing, I have two methods I have used. The method listed above is done by parsing strings and calculating time based on when the string arrives. This was written by someone else (unknown to me), but it was what I had around. I have also done testing using a timeline. I start the timeline just before executing the code, then pause it right after the code finishes. I then use the timeline time to decide how long things took. I'm am not sure which is more accurate, but I believe that in either case, you are only talking a couple of ms room for error. I would love to know for sure, but I figure as long as I use the same method for all variations being tested, the overhead involved should be irrelevant in the final comparison.

One thing becomes clear tho, the processor is very fast. I like to make things happen a LOT (loops over 50000 times) so that most of the tests take at least 1 second (give or take a little). This helps to magnify the actual difference. Right now, the test is the only code running on the processor, but in the future I might start injecting the test code into a work code chunk to see if there is a difference in speed.

Jeff

vining wrote: »

Doesn't that apply to non virtual devices also?

Well, I don't think you have a choice on non-virtual devices. If you need to use port 17 on an NI-3100, you have to use it. I am not aware of any way to remap the physical device.


I also updated the for loop tests and added benchmark test code to a separate thread in Tips and Tricks.

#########################
# Squeeze EVERY last bit out of the processor
#########################

tip - If you need to make every single processor cycle count, use ON[variable] and OFF[variable] instead of variable=TRUE and variable=FALSE.

Proof - see the other post as the information is there. Over 70,000 cycles, ON and OFF were 95ms faster.





P.S.
Anyone know of any other competing code bits that would be fun to test?

alexanbo wrote: »

How about adding to the on off test, setting the variable to 1 and 0 instead of true and false?

Believe it or not, 1 and 0 are slower than TRUE and FALSE!

Line    122 (19:05:53):: *********************************************************
Line    123 (19:05:53):: * TEST 8 REPORT: ON[nInfo[nLoop]] .. OFF[nInfo[nLoop]]
Line    124 (19:05:53):: * Most recent 5 runs:
Line    125 (19:05:53):: * 1: 1903ms
Line    126 (19:05:53):: * 2: 1903ms
Line    127 (19:05:53):: * 3: 1904ms
Line    128 (19:05:53):: * 4: 1904ms
Line    129 (19:05:53):: * 5: 1902ms
Line    130 (19:05:53):: *----------------------------------------------------------
Line    131 (19:05:53):: * Average run time: 1902ms - over 5 tests
Line    132 (19:05:53):: *********************************************************
Line    133 (19:05:53):: *********************************************************
Line    134 (19:05:53):: * TEST 9 REPORT: nInfo[nLoop]=TRUE .. nInfo[nLoop]=FALSE
Line    135 (19:05:53):: * Most recent 5 runs:
Line    136 (19:05:53):: * 1: 1999ms
Line    137 (19:05:53):: * 2: 1998ms
Line    138 (19:05:53):: * 3: 1997ms
Line    139 (19:05:53):: * 4: 1996ms
Line    140 (19:05:53):: * 5: 1998ms
Line    141 (19:05:53):: *----------------------------------------------------------
Line    142 (19:05:53):: * Average run time: 1996ms - over 5 tests
Line    143 (19:05:53):: *********************************************************
Line    144 (19:05:53):: *********************************************************
Line    145 (19:05:53):: * TEST 10 REPORT: nInfo[nLoop]=1 .. nInfo[nLoop]=0
Line    146 (19:05:53):: * Most recent 5 runs:
Line    147 (19:05:53):: * 1: 2024ms
Line    148 (19:05:53):: * 2: 2024ms
Line    149 (19:05:53):: * 3: 2024ms
Line    150 (19:05:53):: * 4: 2025ms
Line    151 (19:05:53):: * 5: 2024ms
Line    152 (19:05:53):: *----------------------------------------------------------
Line    153 (19:05:53):: * Average run time: 2024ms - over 5 tests
Line    154 (19:05:53):: *********************************************************

Jeff

vining wrote: »

Actually I was thinking more in the lines of real TP device ports vs virtual TP ports. It might just be the way I personally think but when I think of a virtual device port and their resources and how I use them I think of them more as a virtual TP port not so much as a virtual NI device port. It might just be that the way I think is slightly abnormal.

However if your physical NI port aren't defined the same should hold true, they won't take up resources so use those ports sequentially as well and not use serial ports 1 & 7 leaving 2-6 un-used for example.

I see where you are coming from now. Yes, the same holds true for touch panels. While we are mentioning touch panels and ports, I just recalled another thing... I believe that the set_virtual_channel_count() command is done in blocks of 255 or was it 256. I will have to try to find the original post or the documentation to verify this. I guess the general rule of thumb is to start at the lowest number (generally 1) and try to go up sequentially in everything AMX.

The only exception that I have found is in actual device numbers. If it's not defined, it won't be tracked.

Jeff

Hedberg wrote: »

I don't see how TRUE and FALSE could run any faster than 1 and 0. TRUE and FALSE are constants which have the assigned values 1 and 0. I expect that at compile time TRUE and FALSE are replaced and that the token file is the same as if 1 and 0 had been entered. Don't know that for a fact, but that's my understanding of how constants are handled.

That is what I thought, the only thing I can think of is that maybe TRUE and FALSE are treated as boolean instead of integers? Or maybe the compiler is doing some sort of optimization on them.... or maybe my testing is flawed

I just finished playing HVAC guy (had to run a new wire to the roof top unit to hook the new Viewstat... 4 wires is just not enough ). I'm going to try to change the test method now.

Jeff

Ok, here is the code I am running for the tests. Take a look and let me know if I am overlooking something very obvious. Keep in mind, the report function has not been changed to distinguish between the two test types and simply appends ms to the times.

PROGRAM_NAME='MultipleTests'
DEFINE_DEVICE

dvTP	= 10001:1:0


DEFINE_CONSTANT  //Benchmark Constants
integer MAX_NUM_TESTS = 20;


DEFINE_CONSTANT//Place test constants below
DEFINE_TYPE //Place Test Types here


DEFINE_VARIABLE	//Benchmark Variables DO NOT CHANGE
char sTestDescription[MAX_NUM_TESTS][50]
VOLATILE LONG 	lTL_Times[5] = {10000,10000,10000,10000,10000}
LONG	lTestTime[MAX_NUM_TESTS][6] //1-5 = last values, 6 = running avg of all
LONG	lTestTimeStart[MAX_NUM_TESTS][6] //1-5 = last values, 6 = running avg of all
LONG	lTestTimeFinish[MAX_NUM_TESTS][6] //1-5 = last values, 6 = running avg of all
LONG  lTestAverageCount[MAX_NUM_TESTS] = 0
VOLATILE INTEGER nTestIndex[MAX_NUM_TESTS]
VOLATILE INTEGER nWORK_IN_PROGRESS[MAX_NUM_TESTS]

define_variable //Place Test Variables here
volatile LONG nInfo[70000]

LONG nLoop
LONG nMax
LONG Value1 = 1000;
Long Value2 = 1500;

//**********************
//Benchmark functions. 
//Call the TestStart function immediately before code to be tested.
//Call the TestFinish function immediately after code to be tested.
//**********************

define_function TestName(integer nMethod, char sName[50]){
	sTestDescription[nMethod] = sName;
}
define_function TestReset(integer nMethod){//Clears averages and sets pointers to first spot.
	stack_var integer x;
	
	nTestIndex[nMethod] = 1;
	nWORK_IN_PROGRESS[nMethod] = 0;
	timeline_kill(nMethod);
	lTestAverageCount[nMethod] = 0;
	for(x=6;x;x--){
		lTestTime[nMethod][x] = 0;
	}
	send_string 0,"'*********************************************************'";
	send_string 0,"'* TEST ',itoa(nMethod),' RESET: ',sTestDescription[nMethod]";
	send_string 0,"'*********************************************************'";
}
define_function TestStart(integer nMethod){
	IF((nTestIndex[nMethod] > 5) or (nTestIndex[nMethod] < 1))
		nTestIndex[nMethod] = 1;

	send_string 0,"'*********************************************************'";
	send_string 0,"'* TEST ',itoa(nMethod),' STARTING: ',sTestDescription[nMethod]";
	send_string 0,"'*********************************************************'";

	nWork_In_Progress[nMethod] = 1;
	lTestTimeStart[nMethod][nTestIndex[nMethod]] = GET_TIMER; 
	
//	TIMELINE_CREATE(type_cast(nMethod),lTL_Times,5,TIMELINE_RELATIVE,TIMELINE_REPEAT);

}
define_function TestFinish(integer nMethod){
	lTestTimeFinish[nMethod][nTestIndex[nMethod]] = GET_TIMER;
	
//	TIMELINE_PAUSE(nMethod);
	lTestTime[nMethod][nTestIndex[nMethod]] = lTestTimeFinish[nMethod][nTestIndex[nMethod]] - lTestTimeStart[nMethod][nTestIndex[nMethod]];
//	TIMELINE_KILL(nMethod);
	lTestTime[nMethod][6] = ((lTestTime[nMethod][6]*lTestAverageCount[nMethod]) + lTestTime[nMethod][nTestIndex[nMethod]])/(lTestAverageCount[nMethod] + 1);
	lTestAverageCount[nMethod]++;

	send_string 0,"'*********************************************************'";
	send_string 0,"'* TEST ',itoa(nMethod),' FINISHED: ',sTestDescription[nMethod]";
	send_string 0,"'* Last run time: ',itoa(lTestTime[nMethod][nTestIndex[nMethod]]/10),'.',itoa(lTestTime[nMethod][nTestIndex[nMethod]]%10),'sec - ',sTestDescription[nMethod]";
	send_string 0,"'* Average run time: ',itoa(lTestTime[nMethod][6]/10),'.',itoa(lTestTime[nMethod][6]%10),'sec - over ',itoa(lTestAverageCount[nMethod]),' tests - ',sTestDescription[nMethod]";
	send_string 0,"'*********************************************************'";
	
	IF((nTestIndex[nMethod] >= 5) or (nTestIndex[nMethod] < 1))
		nTestIndex[nMethod] = 1;
	ELSE
		nTestIndex[nMethod]++;
	nWORK_IN_PROGRESS[nMethod] = 0;

}
define_function TestStart2(integer nMethod){
	IF((nTestIndex[nMethod] > 5) or (nTestIndex[nMethod] < 1))
		nTestIndex[nMethod] = 1;

	send_string 0,"'*********************************************************'";
	send_string 0,"'* TEST ',itoa(nMethod),' STARTING: ',sTestDescription[nMethod]";
	send_string 0,"'*********************************************************'";

	nWork_In_Progress[nMethod] = 1;
//	lTestTimeStart[nMethod][nTestIndex[nMethod]] = GET_TIMER; 
	
	TIMELINE_CREATE(type_cast(nMethod),lTL_Times,5,TIMELINE_RELATIVE,TIMELINE_REPEAT);

}
define_function TestFinish2(integer nMethod){
//	lTestTimeFinish[nMethod][nTestIndex[nMethod]] = GET_TIMER;
	
	TIMELINE_PAUSE(nMethod);
	lTestTime[nMethod][nTestIndex[nMethod]] = TIMELINE_GET(nMethod);
	TIMELINE_KILL(nMethod);
	lTestTime[nMethod][6] = ((lTestTime[nMethod][6]*lTestAverageCount[nMethod]) + lTestTime[nMethod][nTestIndex[nMethod]])/(lTestAverageCount[nMethod] + 1);
	lTestAverageCount[nMethod]++;

	send_string 0,"'*********************************************************'";
	send_string 0,"'* TEST ',itoa(nMethod),' FINISHED: ',sTestDescription[nMethod]";
	send_string 0,"'* Last run time: ',itoa(lTestTime[nMethod][nTestIndex[nMethod]]),'ms - ',sTestDescription[nMethod]";
	send_string 0,"'* Average run time: ',itoa(lTestTime[nMethod][6]),'ms - over ',itoa(lTestAverageCount[nMethod]),' tests - ',sTestDescription[nMethod]";
	send_string 0,"'*********************************************************'";
	
	IF((nTestIndex[nMethod] >= 5) or (nTestIndex[nMethod] < 1))
		nTestIndex[nMethod] = 1;
	ELSE
		nTestIndex[nMethod]++;
	nWORK_IN_PROGRESS[nMethod] = 0;

}
define_function TestPrintReport(integer nMethod){
	stack_var integer x;
	
	if(nMethod){
		send_string 0,"'*********************************************************'";
		send_string 0,"'* TEST ',itoa(nMethod),' REPORT: ',sTestDescription[nMethod]";
		send_string 0,"'* Most recent 5 runs:'";
		send_string 0,"'* 1: ',itoa(lTestTime[nMethod][1]),'ms'";
		send_string 0,"'* 2: ',itoa(lTestTime[nMethod][2]),'ms'";
		send_string 0,"'* 3: ',itoa(lTestTime[nMethod][3]),'ms'";
		send_string 0,"'* 4: ',itoa(lTestTime[nMethod][4]),'ms'";
		send_string 0,"'* 5: ',itoa(lTestTime[nMethod][5]),'ms'";
		send_string 0,"'*----------------------------------------------------------'";
		send_string 0,"'* Average run time: ',itoa(lTestTime[nMethod][6]),'ms - over ',itoa(lTestAverageCount[nMethod]),' tests'";
		send_string 0,"'*********************************************************'";
	}
	else{
		for(x=1;x<=MAX_NUM_TESTS;x++){ 
			if(lTestTime[x][1]){
				send_string 0,"'*********************************************************'";
				send_string 0,"'* TEST ',itoa(x),' REPORT: ',sTestDescription[x]";
				send_string 0,"'* Most recent 5 runs:'";
				send_string 0,"'* 1: ',itoa(lTestTime[x][1]),'ms'";
				send_string 0,"'* 2: ',itoa(lTestTime[x][2]),'ms'";
				send_string 0,"'* 3: ',itoa(lTestTime[x][3]),'ms'";
				send_string 0,"'* 4: ',itoa(lTestTime[x][4]),'ms'";
				send_string 0,"'* 5: ',itoa(lTestTime[x][5]),'ms'";
				send_string 0,"'*----------------------------------------------------------'";
				send_string 0,"'* Average run time: ',itoa(lTestTime[x][6]),'ms - over ',itoa(lTestAverageCount[x]),' tests'";
				send_string 0,"'*********************************************************'";
			}
		}
	}
}
DEFINE_FUNCTION PutYourFunctionsBelow(){
//example function for testing
TestName(20,'Sample Test');//20 is the test ID. Change this accordingly. start at 1. MAX_NUM_TESTS is the highest ID allowed.
TestStart(20);
//Test code goes here!
TestFinish(20);

}
DEFINE_FUNCTION forLoop1(){
	TestName(1,'FOR (nLoop = 1; nLoop <= LENGTH_ARRAY(nInfo); nLoop++)');//20 is the test ID. Change this accordingly. start at 1. MAX_NUM_TESTS is the highest ID allowed.
	TestStart(1);
	FOR (nLoop = 1; nLoop <= LENGTH_ARRAY(nInfo); nLoop++)
	{  
		 nInfo[nLoop] = 1;
	}  
	TestFinish(1);

}
DEFINE_FUNCTION forLoop2(){
	TestName(3,'FOR (nLoop = 1; nLoop <= MAX_LENGTH_ARRAY(nInfo); nLoop++)');//20 is the test ID. Change this accordingly. start at 1. MAX_NUM_TESTS is the highest ID allowed.
	TestStart(3);
	  FOR (nLoop = 1; nLoop <= MAX_LENGTH_ARRAY(nInfo); nLoop++)
	  {  
		 nInfo[nLoop] = 2;
	  }  
	TestFinish(3);

}
DEFINE_FUNCTION forLoop3(){
	TestName(4,'FOR (nLoop = 1, nMax = MAX_LENGTH_ARRAY(nInfo); nLoop <= nMax; nLoop++)');//20 is the test ID. Change this accordingly. start at 1. MAX_NUM_TESTS is the highest ID allowed.
	TestStart(4);
	  FOR (nLoop = 1, nMax = MAX_LENGTH_ARRAY(nInfo); nLoop <= nMax; nLoop++)
	  {  
		 nInfo[nLoop] = 4;
	  }  
	TestFinish(4);

}
DEFINE_FUNCTION forLoop4(){
	TestName(5,'FOR (nLoop = MAX_LENGTH_ARRAY(nInfo); nLoop > 0; nLoop--)');//20 is the test ID. Change this accordingly. start at 1. MAX_NUM_TESTS is the highest ID allowed.
	TestStart(5);
	  FOR (nLoop = MAX_LENGTH_ARRAY(nInfo); nLoop > 0; nLoop--)
	  {  
		 nInfo[nLoop] = 8
	  }  
	TestFinish(5);

}
DEFINE_FUNCTION forLoop5(){
	TestName(6,'FOR (nLoop = MAX_LENGTH_ARRAY(nInfo); nLoop; nLoop--)');//20 is the test ID. Change this accordingly. start at 1. MAX_NUM_TESTS is the highest ID allowed.
	TestStart(6);
	  FOR (nLoop = MAX_LENGTH_ARRAY(nInfo); nLoop; nLoop--)
	  {
		 nInfo[nLoop] = 16
	  }
	TestFinish(6);

}
DEFINE_FUNCTION forLoop6(){
	stack_var long snLoop;

	TestName(7,'FOR (snLoop = MAX_LENGTH_ARRAY(nInfo); snLoop; snLoop--)');//20 is the test ID. Change this accordingly. start at 1. MAX_NUM_TESTS is the highest ID allowed.
	TestStart(7);
	  FOR (snLoop = MAX_LENGTH_ARRAY(nInfo); snLoop; snLoop--)
	  {
		 nInfo[snLoop] = 32
	  }
	TestFinish(7);

}
DEFINE_FUNCTION forLoop7(){
	stack_var long snLoop;
	
	TestName(2,'FOR (snLoop = 1; snLoop <= LENGTH_ARRAY(nInfo); snLoop++)');//20 is the test ID. Change this accordingly. start at 1. MAX_NUM_TESTS is the highest ID allowed.
	TestStart(2);
	  FOR (snLoop = 1; snLoop <= LENGTH_ARRAY(nInfo); snLoop++)
	  {  
		 nInfo[snLoop] = 64;
	  }  
	TestFinish(2);

}
DEFINE_FUNCTION onVsTrue(){
	stack_var long snLoop;
	
	TestName(8,'nInfo[nLoop]=TRUE .. nInfo[nLoop]=FALSE');//20 is the test ID. Change this accordingly. start at 1. MAX_NUM_TESTS is the highest ID allowed.
	TestStart(8);
	  FOR (nLoop = Value1; nLoop; nLoop--)
	  {
		nInfo[nLoop] = TRUE;
		nInfo[nLoop] = FALSE;
	  }
	TestFinish(8);
	TestName(9,'nInfo[nLoop]=TRUE .. nInfo[nLoop]=FALSE');//20 is the test ID. Change this accordingly. start at 1. MAX_NUM_TESTS is the highest ID allowed.
	TestStart(9);
	  FOR (nLoop = Value2; nLoop; nLoop--)
	  {
		nInfo[nLoop] = TRUE;//1;
		nInfo[nLoop] = FALSE;//0;
	  }
	TestFinish(9);
	TestName(10,'ON[nInfo[nLoop]] .. OFF[nInfo[nLoop]]');//20 is the test ID. Change this accordingly. start at 1. MAX_NUM_TESTS is the highest ID allowed.
	TestStart(10);
	  FOR (nLoop = MAX_LENGTH_ARRAY(nInfo); nLoop; nLoop--)
	  {
		ON[nInfo[nLoop]];
		OFF[nInfo[nLoop]];
	  }
	TestFinish(10);

	TestName(11,'nInfo[nLoop]=TRUE .. nInfo[nLoop]=FALSE');//20 is the test ID. Change this accordingly. start at 1. MAX_NUM_TESTS is the highest ID allowed.
	TestStart2(11);
	  FOR (nLoop = Value1; nLoop; nLoop--)
	  {
		nInfo[nLoop] = TRUE;
		nInfo[nLoop] = FALSE;
	  }
	TestFinish2(11);
	TestName(12,'nInfo[nLoop]=TRUE .. nInfo[nLoop]=FALSE');//20 is the test ID. Change this accordingly. start at 1. MAX_NUM_TESTS is the highest ID allowed.
	TestStart2(12);
	  FOR (nLoop = Value2; nLoop; nLoop--)
	  {
		nInfo[nLoop] = TRUE;//1;
		nInfo[nLoop] = FALSE;//0;
	  }
	TestFinish2(12);
	TestName(13,'ON[nInfo[nLoop]] .. OFF[nInfo[nLoop]]');//20 is the test ID. Change this accordingly. start at 1. MAX_NUM_TESTS is the highest ID allowed.
	TestStart2(13);
	  FOR (nLoop = MAX_LENGTH_ARRAY(nInfo); nLoop; nLoop--)
	  {
		ON[nInfo[nLoop]];
		OFF[nInfo[nLoop]];
	  }
	TestFinish2(13);

}


DEFINE_START
SET_LENGTH_ARRAY (nInfo,70000)


DEFINE_EVENT
BUTTON_EVENT[dvTP,1] {  //Run Test

   PUSH: {
		stack_var integer x;
		for(x=5;x;x--){
			forLoop1();
			forLoop2();
			forLoop3();
			forLoop4();
			forLoop5();
			forLoop6();
			forLoop7();
			onVsTrue();
		}
   }
}
BUTTON_EVENT[dvTP,2] { //Run Test
   PUSH: {
		stack_var integer x;
		for(x=5;x;x--){
			onVsTrue();
		}
   }
}
BUTTON_EVENT[dvTP,3] { //Run Test
   PUSH: {
   }
}

BUTTON_EVENT[dvTP,100] 
BUTTON_EVENT[dvTP,101] 
BUTTON_EVENT[dvTP,102] 
BUTTON_EVENT[dvTP,103] 
BUTTON_EVENT[dvTP,104] 
BUTTON_EVENT[dvTP,105] 
BUTTON_EVENT[dvTP,106] 
BUTTON_EVENT[dvTP,107] 
BUTTON_EVENT[dvTP,108] 
BUTTON_EVENT[dvTP,109] 
BUTTON_EVENT[dvTP,110] 
BUTTON_EVENT[dvTP,111] 
BUTTON_EVENT[dvTP,112] 
BUTTON_EVENT[dvTP,113] 
BUTTON_EVENT[dvTP,114] 
BUTTON_EVENT[dvTP,115] 
BUTTON_EVENT[dvTP,116] 
BUTTON_EVENT[dvTP,117] 
BUTTON_EVENT[dvTP,118] 
BUTTON_EVENT[dvTP,119] 
BUTTON_EVENT[dvTP,120]{  //Print reports. channel 100 prints all valid reports.
						//channel 101-120 print a report only for a single test (channel-100)
                 
   PUSH: {
		TestPrintReport(button.input.channel - 100);
   }
}
button_event[dvTp,255]{ //Reset Test Data
	push:{
		stack_var integer x;
		for(x=MAX_NUM_TESTS;x;x--){
			TestReset(x);
		}
	}            
}

Jeff