English (United Kingdom)

https://curated-unify.zendy.io/wp-json/zendy-region/v1/featured_content/oa?rat=en

https://curated-unify.zendy.io/wp-json/zendy-region/v1/highlighted_journal/

Global: Zendy Plus annual

Presents the access of premium content as premium feature

Premium Content

Presents the keyphrase highlighting as premium feature

Keyphrase Highlighting

Presents the summarisation as premium feature

Summarisation

Insights

Presents the pdf analysis as premium feature

PDF Analysis

Presents the zaia usage as premium feature

ZAIA

Global: Zendy Plus monthly

Global: Zendy Tools annual

Global: Zendy Tools monthly

Global: Zendy Free Plan

Generic simulation code for spiking neuronal networks spends the major partof time in the phase where spikes have arrived at a compute node and need to bedelivered to their target neurons. These spikes were emitted over the lastinterval between communication steps by source neurons distributed across manycompute nodes and are inherently irregular with respect to their targets. Forfinding the targets, the spikes need to be dispatched to a three-dimensionaldata structure with decisions on target thread and synapse type to be made onthe way. With growing network size a compute node receives spikes from anincreasing number of different source neurons until in the limit each synapseon the compute node has a unique source. Here we show analytically how thissparsity emerges over the practically relevant range of network sizes from ahundred thousand to a billion neurons. By profiling a production code weinvestigate opportunities for algorithmic changes to avoid indirections andbranching. Every thread hosts an equal share of the neurons on a compute node.In the original algorithm all threads search through all spikes to pick out therelevant ones. With increasing network size the fraction of hits remainsinvariant but the absolute number of rejections grows. An alternative algorithmequally divides the spikes among the threads and sorts them in parallelaccording to target thread and synapse type. After this every thread completesdelivery solely of the section of spikes for its own neurons. The new algorithmhalves the number of instructions in spike delivery which leads to a reductionof simulation time of up to 40 %. Thus, spike delivery is a fullyparallelizable process with a single synchronization point and thereby wellsuited for many-core systems. Our analysis indicates that further progressrequires a reduction of the latency instructions experience in accessingmemory.

Routing brain traffic through the von Neumann bottleneck: Parallel sorting and refactoring