Optimization techniques for ARM 7 microcontroller based embedded ...

Optimization techniques for ARM 7
microcontroller based embedded systems
presented on gamma correction algorithm
implementation
Kosta Karpuzovski
FEIT Skopje

We will discuss
Motivation
General C code optimization
techniques
Optimization of the algorithm
Gamma correction
Fast power calculation
Results
General discussion for improvement

Motivation
Allow ARM7 processor to make real
time processing
◦ Make algorithm simple enough
ARM7TDMI processor to execute it for the
whole picture in less then 1/25 seconds
Green power
◦ Faster execution leaves more time for
sleep mode operation
Lower costs
◦ Use cheaper components in design

General C code optimization
techniques
Optimization of loops by
countdown from max to zero
Use of lookup tables
instead of calculation
◦ Use
for (ArrayIndex = ImageLength; ArrayIndex !=
0;)
{
ArrayIndex--;
m = ImageArray[ArrayIndex];
ImageArray[ArrayIndex] = LookupTable[m];
}
◦ Instead of
for (ArrayIndex = 0; ArrayIndex = 254.5f)
q=255.0f;
ImageArray[ArrayIndex] = (unsigned int)q;
}

General C code optimization
techniques (2)
Loop unrolling to minimize branching in code
Use of Do While instead of For loop in the cases
when we know that the loop will be executed at
least once
Use of ternary operator
◦ MinRange = (MinRange > 255) MinRange : MinValue; is better
then
◦ MinRange = (255 < MinRange) MinValue : MinRange;
Use of local variables in loops
Use local variables in all calculations with global ones and
return the value in the global variables once all calculations
are done
Use of break for premature loop exit

General C code optimization
techniques (3)
techniques (3)
LoopCounter = ImageLength;
Do {
InputValue = *ImageArray_p;
ImageArray_p++;
MaxValue = (InputValue > MaxValue) InputValue : MaxValue;
MinValue = (InputValue < MinValue) InputValue : MinValue;
InputValue = *ImageArray_p;
ImageArray_p++;
MaxValue = (InputValue > MaxValue) InputValue : MaxValue;
MinValue = (InputValue < MinValue) InputValue : MinValue;
...
InputValue = *ImageArray_p;
ImageArray_p++;
MaxValue = (InputValue > MaxValue) InputValue : MaxValue;
MinValue = (InputValue < MinValue) InputValue : MinValue;
LoopCounter -= 8;
if ((0 == MinValue) && (0xff == MaxValue))
break;
} while (LoopCounter != 0);
*MinValue_p = MinValue;
*MaxValue_p = MaxValue;

General C code optimization
techniques (4)
Use of enumerated constants for switch() cases, to
make it continuous from max to 0
typedef enum {
PARSER_EXECUTE_COMMAND = 0, /*< State to execute command */
PARSER_WAIT_PAYLOAD, /*< State to receive payload */
PARSER_WAIT_COMMAND, /*< State to receive command */
PARSER_IDLE, /*< State for all initializations */
} ParserState_e;
static ParserState_e State = PARSER_IDLE;

General C code optimization
techniques (5)
techniques (5)
switch(State) {
case PARSER_IDLE:
if (NULL == ReceiverContext_p)
ReceiverContext_p=(ReceiverContext_t*)malloc(sizeof(ReceiverContext_t));
assert(NULL != ReceiverContext_p);
InitialiseReceiver(ReceiverContext_p, &State);
State = PARSER_WAIT_COMMAND;
case PARSER_WAIT_COMMAND:
ReceiveCommand(ReceiverContext_p, &State, ReceivedChar);
break;
case PARSER_WAIT_PAYLOAD:
ReceiveCommand(ReceiverContext_p, &State, ReceivedChar);
ReceivePayload(ReceiverContext_p, &State, ReceivedChar);
if (PARSER_WAIT_PAYLOAD == State)
break;
case PARSER_EXECUTE_COMMAND:
ExecuteCommand(ReceiverContext_p, &State);
break;
default:
State = PARSER_IDLE;
break;
}

General C code optimization
techniques (6)
Keep number of parameters transferred in function
call to less or equal to 4
◦ To allow compiler to transfer all parameters in registers
Number of local variables to be 7 or less
◦ To allow compiler to use registers for local calculations
Use compiler invocation settings with optimization
level set to maximum
Optimization of the algorithm
◦ Most important part of the process of optimization

Optimization of the algorithm
Use open-minded approach when solving
problems
◦ Read about the subject and what is already done in the field
◦ Choose algorithm that will potentially give best results on the platform you
use
◦ Try to find alternative solutions for all computational parts in the algorithm
Avoid division in the case of ARM controllers
Use faster or less memory demanding solutions then the ones offered by the generic libraries
◦ Find the botomnecks and then optimize
Do not optimize code that is executed only once, the gain will probably not mach the effort
Specifics of gamma correction algorithm we are implementing
◦ First we make range correction
Input values in the range from InMin to InMax we transfer in OutMin to OutMax
◦ We limit the range of values
Input and output values are in the range between 0 and 255
◦ We saturate the signal
There are no values bigger then 255
◦ We define optimization target
Our main concern is speed of execution

Optimization of the algorithm (2)

Optimization of the algorithm (3)
Gamma correct
Find Minimum/
Maximum
Index = ImageLength
Index != 0
yes
Exit
no
Index--;
Value = ImageArray[Index];
Value = (Value – ImgMin)*ExtRange/ImgRange
+ ExtMinValue;
Value = powf(Value,Gamma);
Value = 255;
yes
Value >=254,5
ImageArray[Index] = Value;
no

Optimization of the algorithm (4)
Fast gamma correct
Find Minimum/
Maximum
Create corrected
range power
lookup
Index = ImageLength
Index != 0
yes
no
Index--;
Value = ImageArray[Index];
Value = LookupTable[Value];
ImageArray[Index] = Value;
Exit

Optimization of the algorithm (5)
Find minimum/maximum
Check if all
elements in image
are passed
yes
no
Value = *ImageArray_p;
ImageArray_p++;
Value >
MaxValue
yes
MaxValue = Value;
One of eight “Find min/max” units
unrolled in this function
no
Value < MinValue
yes
MinValue = Value;
no
.
.
.
Check if
MinValue = 0 and
MaxValue = 255
yes
no
Exit

Optimization of the algorithm (5)

Gamma correction
Gamma correction
◦ General definition
s
= c( r −ε )
◦ Simplified formula
γ
s = r
Fast power calculation
γ

Fast power calculation
Basic idea for fast power calculation
◦ Use of IEEE-754 float representation
format
◦ Bit manipulations
◦ Table lookup
IEEE-754 floating point numbers
representation
sign exponent mantissa
S EEEEEEEE MMMMMMMMMMMMMMMMMMMMMMM
31 23 0

Fast power calculation (2)
IEEE-754 floating point numbers
representation
◦ (+/-)(1 + mantissa/2 23 ) * 2
(exponent - 127)
◦ Number math
( b+
c)
b
a = a *
2
a
( WholeNumber + DecimalPart )
c
WholeNumber
*2
DecimalPart
◦ 2 DecimalPart is in the range 1

Fast power calculation (3)
Mantissa table precision
◦ Average error of 0,01% for 11bit table
(8kB)
◦ With 9bit table we experience shift of 1 in
two values in the range (0-255)

Results
Amount of data
No C code
optimizations
Execution time gain
19200 Byte (forest) high
compiler optimization
19200 Byte (tire) high
compiler optimization
19200 Byte (forest) no
compiler optimization
19200 Byte (tire) no
compiler optimization
C code
optimized
Ratio
14,6s 0,083 176
14,67s 0,085 173
14,6s 0,1157 126
14,67s 0,1183 124

General discussion for
improvement
Better results with board with more
RAM to keep both pictures
Optimize Max/Min function with
additional check if we reached 255 or
0
Limit gamma range from 0,3 to 3 and
optimize further
Time under 40ms