Microcontroller Showdown, Part 2

Here are the results for the tests I did with the MSP430 and the LPC1114. Lately I have been busy with work so I haven't had a chance to do anything with the other three chips. I do have tool chains set up for them and I plan to run the same tests on them soon too.

To time the tests I used an MSP430 LaunchPad which waited for a pulse from the tested chips to begin and end timing. The timer was run from the VLO which is accurate to ±3% so the results are not exact but they give a rough idea of the difference in speed. The tests were done inside two nested loops which iterate altogether 2,400,000 times. Each operation is done once per iteration except adding and GPIO operations which are done 10 times since they should be much faster. At first I did each test 5 times and took the average but then I did them only once since the results were usually very close and some of the later tests took quite a while. To begin with I timed how long the empty loop took then I subtracted that time from the results to get the actual time the operations took. For both chips I used gcc to compile with both -Os and -O3, although there wasn't really a difference except for the BCD routine tests.

As you can see from the table, the LPC1114 was much faster than the MSP430, even running from the bottlenecked flash. The results would be even faster if the tests had been copied to RAM and run from there. I was also surprised to realize that the LPC1114 has a barrel shifter which is very handy. Another neat feature is GPIO masking. Each mask is memory mapped so individuals pins can be toggled with a single write to memory. This allows GPIO operations to be much faster than the traditional load, modify, and store routine.

These tests by themselves are a bit arbitrary and the results are not especially useful since they only measure calculation speed. Other operations such as branching are just as important and would affect the results in a real situation. Memory access is also not tested here since all of the data for tests probably fits into the registers. For this reason I also tested some of the BCD routines I am using for my calculator project since they are the kind of functions I would like to use these chips for. The LPC1114 turned out to be much faster for this too. For the BCD multiplication test I tried a version using the * operator and a version that repeatedly does adds instead. On the MSP430 the version not using * turned out to be a little faster. One strange thing about the BCD adding routines compiled for the MSP430 is that with -Os they are not only about half as big as when they are compiled with -O3 but they are also about 5% faster.

These tests are not a comprehensive benchmark. Many factors have to be taken into account to choose the right chip for a job. These tests only focus on a very narrow range of those factors.

		MSP430G2553		LPC1114
Loop overhead time	-O3	1.72		0.84
	-Os	1.72		0.91
Add unsigned 8 bit	-O3	9.826	8.106	4.64	3.8
	-Os	9.889	8.169	4.84	3.93
Add unsigned 16 bit	-O3	10.032	8.312	4.96	4.12
	-Os	10.071	8.351	5.15	4.24
Add unsigned 32 bit	-O3	29.592	27.872	4.23	3.39
	-Os	29.816	28.096	4.38	3.47
Add signed 8 bit	-O3	9.84	8.12	4.63	3.79
	-Os	9.909	8.189	4.82	3.91
Add signed 16 bit	-O3	10.02	8.3	4.63	3.79
	-Os	10.054	8.334	5.15	4.24
Add signed 32 bit	-O3	29.536	27.816	4.2	3.36
	-Os	29.637	27.917	4.38	3.47
Multiply unsigned 8 bit	-O3	19.65	17.93	1.28	0.44
	-Os	19.58	17.86	1.41	0.5
Multiply unsigned 16 bit	-O3	21.14	19.42	1.28	0.44
	-Os	21.07	19.35	1.41	0.5
Multiply unsigned 32 bit	-O3	40.36	38.64	1.33	0.49
	-Os	40.23	38.51	1.42	0.51
Multiply signed 8 bit	-O3	19.98	18.26	1.39	0.55
	-Os	19.91	18.19	1.53	0.62
Multiply signed 16 bit	-O3	20.65	18.93	1.39	0.55
	-Os	20.58	18.86	1.53	0.62
Multiply signed 32 bit	-O3	70.24	68.52	1.23	0.39
	-Os	69.97	68.25	1.41	0.5
Divide unsigned 8 bit	-O3	17.34	15.62	8.09	7.25
	-Os	17.27	15.55	8.33	7.42
Divide unsigned 16 bit	-O3	29.44	27.72	11	10.16
	-Os	29.32	27.6	11.14	10.23
Divide unsigned 32 bit	-O3	90.12	88.4	14.56	13.72
	-Os	89.75	88.03	14.65	13.74
Divide signed 8 bit	-O3	33.27	31.55	9.35	8.51
	-Os	33.13	31.41	9.38	8.47
Divide signed 16 bit	-O3	33.72	32	12.05	11.21
	-Os	33.47	31.75	12.29	11.38
Divide signed 32 bit	-O3	96.94	95.22	15.5	14.66
	-Os	96.54	94.82	15.58	14.67
Shift right unsigned 8 bit	-O3	14.86	13.14	1.83	0.99
	-Os	14.79	13.07	1.96	1.05
Shift right unsigned 16 bit	-O3	29.79	28.07	1.83	0.99
	-Os	29.66	27.94	1.97	1.06
Shift right unsigned 32 bit	-O3	69.62	67.9	1.72	0.88
	-Os	69.31	67.59	1.8	0.89
Shift right signed 8 bit	-O3	14.85	13.13	2.16	1.32
	-Os	14.8	13.08	2.29	1.38
Shift right signed 16 bit	-O3	25.15	23.43	2.16	1.32
	-Os	25.05	23.33	2.29	1.38
Shift right signed 32 bit	-O3	59.69	57.97	1.72	0.88
	-Os	59.42	57.7	1.8	0.89
Shift left unsigned 8 bit	-O3	14.86	13.14	1.83	0.99
	-Os	14.8	13.08	1.96	1.05
Shift left unsigned 16 bit	-O3	25.16	23.44	1.83	0.99
	-Os	25.04	23.32	1.97	1.06
Shift left unsigned 32 bit	-O3	59.67	57.98	1.72	0.88
	-Os	59.41	57.96	1.8	0.89
Shift left signed 8 bit	-O3	14.86	13.14	2.16	1.32
	-Os	14.8	13.08	2.29	1.38
Shift left signed 16 bit	-O3	25.17	23.45	2.16	1.32
	-Os	25.04	23.32	2.29	1.38
Shift left signed 32 bit	-O3	59.68	57.96	1.72	0.88
	-Os	59.41	57.69	1.8	0.89
GPIO	-O3	18.088	16.368	7.03	6.19
	-Os	18.056	16.336	7.26	6.35
GPIO Constant Generator	-O3	14.752	13.032
	-Os	14.758	13.038
GPIO Masked	-O3			3.22	2.38
	-Os			3.52	2.61
BCD Add 120+325	-O3	47.93	46.21	17.93	16.21
	-Os	50.05	48.33	20.83	19.11
BCD Multiply 24 * 13 (Without multiplies)	-O3	393.4	391.68	131.49	129.77
	-Os	375.21	373.49	149.84	148.12
BCD Multiply 24 * 13 (With multiplies)	-O3	405.64	403.92	131.88	130.16
	-Os	508.52	506.8	140.53	138.81