Print indd

1
Introduction
In recent years, more and more many-core processors appeared. Typically, they
are connected via a network-on-chip (NoC). In a typical NoC [
1
,
2
] all nodes are
connected to the network via a network interface (NI) containing a send and a
receive buffer. As buffers occupy a high amount of hardware logic [
18
], hardware
designers tend to minimize the number of possible buffer entries. Especially the
receive buffers need to be of an appropriate size to avoid performance degradation
when they are full.
Parallel programs often diverge during their execution, causing some proces-
sors executing program parts being far ahead of other processors. In distributed
systems, it is often a strategy to send data to some other node without wait-
ing for that node to be at the same part of the program, i.e. needing this data
yet [
15
]. The receiver node just stores this data away in its memory and gets
it from there when it actually processes it. This strategy is important because
communication is a major bottleneck in distributed systems. However, in NoCs
receive buffers are quite small and core-local memory is limited. Therefore, send-
ing data to some node without checking if this node is ready to handle this data
might lead to buffer overflows and deadlocks.
c
 Springer International Publishing AG, part of Springer Nature 2018
M. Berekovic et al. (Eds.): ARCS 2018, LNCS 10793, pp. 112–126, 2018.
https://doi.org/10.1007/978-3-319-77610-1
_
9

---

Lightweight Hardware Synchronization for Avoiding Buffer Overflows in NoC
113