Ahmet Yazıcı's questions

Tenho duas estruturas T e K, e o tamanho de T é maior ou igual a K. Suponha o seguinte:

struct T {
    k: K,
    t_val: u32,
}

struct K {
    k_val: u64,
}

Quero mapear Vec para Vec sem nenhuma nova alocação de heap. Isso deve ser possível de forma otimizada, já que o Vec mapeado definitivamente exigirá menos memória do que o Vec, pois T tem 12 bytes e K tem 8 bytes, e os tipos estão lá apenas para calcular o deslocamento. Aqui está como imagino que ficaria:

*ptr -> [12(T) | 12(T) | 12(T)]
        |
      iter_k
      iter_t

*ptr -> [8(K) | 4(garbage) | 12(T) | 12(T)]
              |            |
            iter_k       iter_t

*ptr -> [8(K) | 8(K) | 8(garbage) | 12(T)]
                     |            |
                   iter_k       iter_t

*ptr -> [8(K) | 8(K) | 8(K) | 12(garbage)]
                            |            |
                          iter_k       iter_t

E os últimos 12 bytes de lixo são irrelevantes, pois o tamanho é 3 e pode permanecer como capacidade extra para o novo Vec.

Tenho 2 vetores que são do tipo Vec<(u32, Vec<u8>)>. Quero mesclar esses dois vetores e quero que o resultado tenha chaves únicas. No caso de chaves iguais, o 2º vetor deve sobrescrever o primeiro.

Aqui está minha tentativa de resolver esse problema:

pub fn merge(old_v: Vec<(u32, Vec<u8>)>, new_v: Vec<(u32, Vec<u8>)>) -> Vec<(u32, Vec<u8>)> {
    let mut new_map = HashMap::<u32, Vec<u8>>::from_iter(old_v);

    new_map.extend(new_v);
    new_map.into_iter().collect()
}

Isso funciona, mas o problema é que esses vetores carregam dados muito grandes, potencialmente de 500 KB a 1 MB de dados, com 1000s de entradas (especialmente old_v). E esse método cria bastante memória, considerando que eu chamo esse método com bastante frequência em meu aplicativo.

Há alguma maneira de melhorar a eficiência desse método? Estou OK em fazer mutações no local.

Eu tenho um servidor UDP simples que escuta pacotes, espera 50 milissegundos para se comportar como se houvesse uma operação em andamento e depois imprime a mensagem no terminal. Aqui está o código do servidor:

package main

import (
    "fmt"
    "log"
    "log/slog"
    "net"
    "time"
)

func main() {
    udpAddr, err := net.ResolveUDPAddr("udp", "0.0.0.0:8080")
    if err != nil {
        log.Fatal(err)
    }

    conn, err := net.ListenUDP("udp", udpAddr)
    if err != nil {
        log.Fatal(err)
    }

    slog.Info("UDP server listening", "addr", udpAddr, "workers", numCpu)

    go startWorker(0, conn)

    // Block forever
    <-make(chan struct{})
}

func startWorker(id int, conn *net.UDPConn) {
    slog.Info("Starting worker", "id", id)

    i := 0
    for {
        buf := make([]byte, 1024)
        _, _, err := conn.ReadFromUDP(buf)
        if err != nil {
            slog.Error("failed to read UDP message", "err", err, "worker", id)
            continue
        }

        time.Sleep(50 * time.Millisecond)

        fmt.Print(i, " > ", string(buf))
        i += 1
    }
}

Eu tenho um código de cliente go que simplesmente envia uma mensagem de string para este servidor uma vez. Aqui está o código do cliente:

package main

import (
    "log"
    "net"
)

func main() {
    udpAddr, err := net.ResolveUDPAddr("udp", "0.0.0.0:8080")
    if err != nil {
        log.Fatal(err)
    }

    conn, err := net.DialUDP("udp", nil, udpAddr)
    if err != nil {
        log.Fatal(err)
    }

    // Send a message to the server
    _, err = conn.Write([]byte("Hello UDP Server\n"))
    if err != nil {
        log.Fatal(err)
    }
}

Eu queria testar quantos pacotes podem ser manipulados no servidor. Então, o que fiz foi executar o código do cliente 10.000 vezes sequencialmente para ver quantos deles serão tratados. Mas sempre, apenas cerca de 400-500 pacotes são processados. Aqui está como fiz o teste no terminal:

time (for i in $(seq 10000); do ./client; done)

Não houve logs de erros e a saída foi:

real    0m12,538s
user    0m10,667s
sys     0m4,014s

Presumi que isso poderia ser um problema devido às limitações do buffer do sistema operacional. Então adicionei o seguinte código antes go startWorker(id, conn)no código do servidor:

// 1 GB
if err = conn.SetReadBuffer(1024 * 1024 * 1024); err != nil {
    log.Fatal(err)
}

Depois de fazer exatamente o mesmo teste, o número de pacotes processados ​​passou de 600 a 700. Não há como 1 GB de buffer não ser suficiente para 10.000 desta simples mensagem "Hello UDP Server\n". Alguém pode me explicar o motivo desse comportamento e como posso corrigi-lo?

PS : Estou usando Ubuntu 22.04