201 - Coprocessor

All the code that you write has to be executed on the processor. With computers being ever more powerful, it is easy to forget about all the work a processor is doing. Irrespective of how simple a job might seem, it still needs to be executed. The example illustrates this. The only thing the processor needs to do is output 2 values. Nonetheless with the software as seen before, this takes 74 clock cycles.

#include "print.h"

void main(void) {
	print_str(";");
	print_str(".");
}

example

Offloading

When a processor is doing a lot of work, it can become useful if parts of that work could be delegated or offloaded to another processor. Which portions of the work need to be offloaded ? What will the performance gain be ? What is the price (€s, area in silicon, energy, … ) ? These are simple questions, but answering them is not straightforward !!

The first coprocessors saw the light of day in the 1970’s. It became clear that only doing calculations with integer numbers was to restrictive. The first coprocessors were floating-point units (FPUs). These coprocessor were so heavily used that their functionality got integrated in the processor itself.

Multiplication

The PicoRV32 implementation we’ve used so far only supports the RV32I instruction set. This means that only the basic integer operations are supported. Although the instruction set does not contain a multiplication operation, it can be used nonetheless.

#include "print.h"

void main(void) {
	volatile unsigned int value1, value2, product;

	value1 = 208;
	value2 = 3;

	product = value1 * value2;

	print_dec(product);
}

Running this C-code generates an output .dat file. After parsing the output looks like this.

00000000000000000000000000110110 - 054 - 0x36 - 6
00000000000000000000000000110010 - 050 - 0x32 - 2
00000000000000000000000000110100 - 052 - 0x34 - 4
The value 624 is the product of the (hardcoded) values 208 and 3.

The reason that this works without having a mul instruction is because of the compiler jumps. The compiler figures out what needs to be done and comes up with a recipe to achieve what the code prescribes.

00000174 <__mulsi3>:
 174:	00050613       	mv	a2,a0
 178:	00000513       	li	a0,0
 17c:	0015f693       	andi	a3,a1,1
 180:	00068463       	beqz	a3,188 <__mulsi3+0x14>
 184:	00c50533       	add	a0,a0,a2
 188:	0015d593       	srli	a1,a1,0x1
 18c:	00161613       	slli	a2,a2,0x1
 190:	fe0596e3       	bnez	a1,17c <__mulsi3+0x8>
 194:	00008067       	ret

build

00000274 <main>:
 274:	fe010113       	addi	sp,sp,-32
 278:	0d000793       	li	a5,208
 27c:	00f12223       	sw	a5,4(sp)
 280:	00300793       	li	a5,3
 284:	00f12423       	sw	a5,8(sp)
 288:	00412503       	lw	a0,4(sp)
 28c:	00812583       	lw	a1,8(sp)
 290:	00112e23       	sw	ra,28(sp)
 294:	ee1ff0ef       	jal	ra,174 <__mulsi3>

Changing one letter in the Makefile allows the compiler use the mul instruction.

ARCHITECTURE = rv32i$(subst C,c,$(COMPRESSED_ISA))
to 
ARCHITECTURE = rv32im$(subst C,c,$(COMPRESSED_ISA))
00000168 <main>:
 168:	ff010113          	addi	sp,sp,-16
 16c:	0d000793          	li	a5,208
 170:	00f12223          	sw	a5,4(sp)
 174:	00300793          	li	a5,3
 178:	00f12423          	sw	a5,8(sp)
 17c:	00412783          	lw	a5,4(sp)
 180:	00812703          	lw	a4,8(sp)
 184:	02e787b3          	mul	a5,a5,a4
 188:	00f12623          	sw	a5,12(sp)
 18c:	00c12503          	lw	a0,12(sp)
 190:	01010113          	addi	sp,sp,16
 194:	f29ff06f          	j	bc <print_dec>