Use a concurrent strategy to speed up BLS Public Keys and Signature aggregation

[autholykos]

Benchmarks conducted on dusk-network/dusk-crypto#14 show a substantial performance improvement when parallelizing the aggregation operations. Given the criticality of such aggregation when creating Agreement messages, it would be good to apply the concurrent strategy to minimize event production time and avoid slacking behind when in terms of steps (or even round) just because Agreement creation is slow.

Following function should serve as an inspiration for exploiting concurrency when aggregating Signature:

func aggregateSignatures(sigs []*Signature) *Signature {
    const W = 4
    C := len(sigs)

    M := C / W
    R := C % W

    if C < M {
        return aggregateSignaturesSequential(sigs)
    }

    var wg sync.WaitGroup
    var last *Signature

    // goroutines will fill this slice concurrently
    sgs := make([]*Signature, W) 

    wg.Add(W)
    // w workers for n couples
    for w := 0; w < W; w++ {
        // each goroutine will execute a sequential Aggregation of M signatures
        lo, hi := w*M, (w+1)*M 

        go func(i int, set []*Signature) {
            sgs[i] = aggregateSignaturesSequential(set)
            wg.Done()
        }(w, sigs[lo:hi])
    }

    // aggregating the remaining chunks not fitting in the worker count
    if R > 0 { 
        last = aggregateSignaturesSequential(sigs[C-R:])
    }

    wg.Wait() // waiting for all the goroutines to be done

    if last != nil {
        sgs = append(sgs, last)
    }

    return aggregateSignaturesSequential(sgs)
}

func aggregateSignaturesSequential(sigs []*Signature) *Signature {
    s, sigmas := sigs[0], sigs[1:]
    for _, sig := range sigmas {
        s = s.Aggregate(sig)
    }
    return s
}

[autholykos]

This depends on the capability to benchmark the Reducer, which might be greatly simplified by #72

[autholykos]

Although the proposal is actually valid, the Reducer no longer performs batch signature aggregation. Therefore, there is no opportunity for parallelizing signature aggregation through a worker mechanism.