All perguntas(coding)

Assim como a pergunta diz. Existe uma maneira mais rápida de fazer o que é feito abaixo quando o tamanho do vetor é muito grande (> 10M entradas) usando a base R?

O código abaixo funciona, mas quando o tamanho do vetor cresce, ele se torna lento por razões que deveriam ser óbvias. Neste exemplo em particular, um loop for pode ser mais rápido, mas se o primeiro valor NA estiver muito longe do início do vetor, talvez não...

set.seed(1)
x <- c(rep(NA, 3), sample(c(T,F), size=5e7, replace=T))
min(which(!is.na(x))) #4

Eu me deparei com esse problema ao analisar mônadas livres, mas o reduzi a um exemplo muito menor.

Em Haskell temos o seguinte tipo:

fmap :: Functor f => (a -> b) -> f a -> f b

Suponha também que temos a seguinte função:

foo :: Num a => p -> a
foo = \_ -> 1

Então

fmap foo :: (Functor f, Num b) => f a -> f b
-- and
fmap (fmap foo)
  :: (Functor f1, Functor f2, Num b) => f1 (f2 a) -> f1 (f2 b)

Então seria de se esperar que pudéssemos aplicar fmap (fmap foo)somente a algo do tipo (Functor f1, Functor f2) => f1 (f2 a), mas

fmap (fmap foo) foo :: (Functor f, Num b, Num (f a)) => p -> f b

O quê? Por que esse tipo verifica e por que ele tem o tipo fornecido?

Se alguém pudesse explicar o que está acontecendo aqui, isso seria muito apreciado. Peço desculpas pelo título vago, mas não entendo o suficiente o que está acontecendo aqui para torná-lo mais específico. Ficarei feliz em atualizá-lo para algo mais pesquisável depois que uma resposta esclarecer.

Se olharmos para algumas convenções de chamada modernas, como o estilo SysV x86-64 ou o estilo AArch64 (documento aapcs64.pdf intitulado "Procedure Call Standard for the Arm® 64-bit Architecture"), vemos notas explícitas de que argumentos variádicos são passados ​​da mesma forma que outros argumentos. Por exemplo, uma chamada de função open(path, mode, cflags)em x86-64 obterá path em RDI, mode em RSI e (o único variádico) cflags em RDX.

Não há dúvida sobre passar conjunto de argumentos estáticos em registradores, é bom para economizar recursos. Mas se olharmos para uma função que então interpreta argumentos e então va_startos chama, veremos que va_starté convertido em colocar todos os argumentos possíveis (tipicamente, muito mais do que realmente presente) na pilha; por exemplo, a emulação completa de printfvia vfprintfcomeça com (eu compactei linhas semelhantes para evitar listagens muito longas):

my_printf:
        endbr64
; nearly unconditional saving
        subq    $216, %rsp
        movq    %rsi, 40(%rsp)
<...>
        movq    %r9, 72(%rsp)
        testb   %al, %al
        je      .L2
        movaps  %xmm0, 80(%rsp)
<...>
        movaps  %xmm7, 192(%rsp)
; repacking into registers for enclosed vfprintf
.L2:
        movq    %fs:40, %rax
        movq    %rax, 24(%rsp)
        xorl    %eax, %eax
        movl    $8, (%rsp)
        movl    $48, 4(%rsp)
        leaq    224(%rsp), %rax
        movq    %rax, 8(%rsp)
        leaq    32(%rsp), %rax
        movq    %rax, 16(%rsp)
        movq    %rsp, %rcx
        movq    %rdi, %rdx
        movl    $1, %esi
; finally, call the function
        movq    stdout(%rip), %rdi
        call    __vfprintf_chk@PLT
... skipped epilogue

Aqui 192 bytes de quadro VA. Similarmente, a versão AArch64 empurra 184 bytes (x1..x7 e q0..q7).

Se a cauda variádica de qualquer chamada de função tivesse sido sempre colocada na pilha, as coisas teriam ficado muito mais simples no código e mais baratas no tempo de execução, porque todo o empacotamento e cópia não teriam sido necessários. va_startteria sido reduzido a uma única movimentação da localização inicial da lista variádica (na pilha) para uma variável. É assim que realmente funcionava com o i386 (onde todos os argumentos eram passados ​​na pilha). Saída de assembly do mesmo wrapper trivial para Linux/i386:

my_printf:
        pushl   %ebx
        subl    $8, %esp
        call    __x86.get_pc_thunk.bx
        addl    $_GLOBAL_OFFSET_TABLE_, %ebx
        leal    20(%esp), %eax ; <--- This is va_start
        pushl   %eax ; VA pointer pushed for vfprintf
        pushl   20(%esp)
        pushl   $1
        movl    stdout@GOT(%ebx), %eax
        pushl   (%eax)
        call    __vfprintf_chk@PLT

Aqui, a questão : por que a implementação de argumentos variáveis, pelo menos para x86-64 e aarch64, é tão complicada e desperdiça recursos?

(Eu poderia imaginar que havia casos em que dois estilos, ambos com argumentos fixos e com uma lista variádica, deveriam ter sido igualmente permitidos em declarações de função da mesma função. Mas não conheço um caso para isso. O mencionado opené improvável que seja o único.)

Parece resolvido : o fator que levou a esse design é a necessidade de dar suporte ao legado C de funções "sem protótipo" (detalhes na resposta de @fuz) da maneira como elas são declaradas, em lugares diferentes, com ou sem protótipo, mas o uso é consistente com a assinatura realmente aplicada.

Tenho uma classe Colorque é um wrapper fino em torno de std::array. Gostaria de poder usá-la de duas maneiras:

1. Color<5> color{1,2,3,4,5}deve produzircolor.values = [1,2,3,4,5]
2. Color<5> color{3}deve produzircolor.values = [3,3,3,3,3]

O que eu tenho atualmente é:

template <size_t N>
class Color {
public:
    Color() = default;
    Color(std::array<float, N> values) : values{ values } {};

    template <IsNumeric... T>
    Color(T... v) : values{ static_cast<float>(v)... } { };

    ....

private:
    std::array<float, N> values;
}

Isso funciona corretamente para meu primeiro caso. No entanto, para o segundo caso, ele só produz: color.values = [3,0,0,0,0]. Estou perdido sobre como fazer o segundo caso funcionar. Eu tentei:

template <size_t N>
class Color {
public:
    Color() = default;
    Color(std::array<float, N> values) : values{ values } {};

    template <IsNumeric... T, typename std::enable_if<(sizeof...(T) == N), bool>::type = true>
    Color(T... v) : values{ static_cast<float>(v)... } { };

    template <IsNumeric T>
    Color(T v) : values{ std::array<float, N>{ static_cast<float>(v) } } { };

    ...
}

Mas isso não muda nada.

Estou escrevendo um aplicativo com dois threads: um UI thread e um compute thread. Quero que eles compartilhem um vetor de buffers com o tipo T. Como é 90% de leitura, escolhi usar um ArcSwap para sincronização. O layout de memória que quero atingir é assim:

Quero usar um tipo como ArcSwap<Arc<[T]>>mas o compilador rust está reclamando que [T]não implementa Sized. Isso faz sentido para mim (já que é um slice), mas por que é um erro de compilação?

Eu olhei para a implementação do ArcSwap e parece que o ponteiro atômico precisa apontar para um tipo Sized, mas por quê? (Copiei a definição abaixo)

pub struct ArcSwapAny<T: RefCnt, S: LockStorage = Global> {
    // Notes: AtomicPtr needs Sized
    /// The actual pointer, extracted from the Arc.
    ptr: AtomicPtr<T::Base>,

    /// We are basically an Arc in disguise. Inherit parameters from Arc by pretending to contain
    /// it.
    _phantom_arc: PhantomData<T>,

    lock_storage: S,
}

É a maneira de atingir o layout de memória ArcSwap<Arc<Box<[T]>>>? Isso parece muito desajeitado (e estou preocupado com indireções triplas). Além disso, por que parece ArcSwap[T; 100]funcionar? O que significa ser um tipo Sized em termos de memória?

Gostaria de poder decompor uma ligação estruturada, digamos, std::pair<T, U>em uma variável não constante e uma variável constante:

Por exemplo

std::pair<int, int> anExamplePair = std::make_pair(1, 2);
auto [nonConstVariable, constVariable] = anExamplePair;

Isso é possível ou mesmo sensato ou preciso tornar ambas as variáveis ​​na ligação estruturada const ou não const?

Em um grande monorepo (diretório .git de 10 GB), observei o seguinte comportamento.

# When outputing to a file, it is very fast:
time git  log   -2  > /tmp/X

real    0m0.076s
user    0m0.007s
sys     0m0.046s

# When outputting to the tty, it is more than 10x slower:
time git  log   -2
# ... Output omitted

real    0m0.830s
user    0m0.078s
sys     0m0.586s

Aqui estão todas as minhas configurações relacionadas ao log:

$ git config -l | grep log

log.mailmap=true
core.logallrefupdates=true

O que causa a diferença no desempenho e como posso obter o mesmo desempenho quando o git log está gerando saída para um tty?

Mais observações:

• Em um repositório menor, git log -2é rápido mesmo ao enviar para tty, então o problema parece estar correlacionado com um repositório grande.

  real    0m0.057s
  user    0m0.008s
  sys     0m0.022s
  

• O Cat no arquivo de saída é rápido, então não é apenas a escrita no stdout que é lenta.

  time cat /tmp/X
  real    0m0.015s
  user    0m0.001s
  sys     0m0.005s
  

• Forçar um tty com expect's unbuffertambém torna mais lento git log:

  time unbuffer git  log   -2 > /tmp/X
  
  real    0m1.007s
  user    0m0.104s
  sys     0m0.669s
  

• Em comparação, unbufferele próprio tem uma sobrecarga de ~240 ms:

  time unbuffer cat /tmp/X
  
  real    0m0.239s
  user    0m0.033s
  sys     0m0.111s
  

Quero calcular graus-dias crescentes com várias bases, usando temperatura diária mínima e temperatura diária máxima. Gostaria de fazer isso sem um loop for, se possível, para minimizar meu código.

bases <- c(40,45,50)
tmin <- runif(10,30,70)
tmax <- runif(10,55,95)

Quero encontrar o número de graus-dia de crescimento para cada base para cada um dos dez dias para os quais tenho dados falsos de temperatura. Deve haver 10 valores de saída para cada uma das 3 bases.
Tentei o mapply da seguinte forma:

gdd_func <- function(tmin,tmax,bases){
   (tmin + tmax)/2 - bases}

test <- mapply(gdd_func,tmin,tmax,bases)

Isso produz uma saída incorreta onde eu honestamente não sei o que está fazendo. Quero que a saída seja igual a executar a função acima 3 vezes diferentes com as diferentes bases. Cada saída teria 10 valores gdd correspondentes às diferentes bases. Como eu faria isso usando uma função apply de algum tipo? Ou preciso de algo mais?

Como posso imprimir algo quando não tenho memória?

Tenho um conjunto personalizado de funções malloc[, realloc e calloc] e free. Por enquanto, o projeto apenas as usa como um wrapper para as versões normais das funções. Essas funções wrapper encerram o programa e devem dar uma saída para indicar o erro.

No momento, a função para emitir a mensagem de erro se parece com isto:

#ifdef __linux__
void memory_error() {
    if (errno == ENOMEM)
        printf("%s\n", "Out of memory or memory is limited. Fatal error. The program needs to terminate.");
    else
        printf("%s\n", "Memory allocation failed. Fatal error. The program needs to terminate.");
}
#else
void memory_error() {
    printf("%s\n", "Memory allocation failed, likely due to being out of "
                   "memory or memory being limited for this program. "
                   "Fatal error. The program needs to terminate.");
}
#endif

O problema é que printf()às vezes aloca memória e se eu estiver sem memória, isso falhará. Aloca fwrite()memória? E se sim, há uma opção portátil (então sem chamada de sistema de gravação) para produzir algo sem ter que alocar mais memória?

Até agora, como solução funcional para sistemas Unix, eu poderia fazer isso:

#ifdef __unix__
#define write_str_no_alloc(str) write(STDERR_FILENO, str, sizeof(str))
#else
#define write_str_no_alloc(str) ???
#endif

Estou sentindo falta de uma solução para janelas. Eu preferiria uma solução geral para ambos, mas isso funcionaria para mim.

Neste código de exemplo, por que não está using IParameterBase<TYPE>::operator=; funcionando e o operador de atribuição de classe base está funcionando?

Mudei recentemente para esta versão de modelo; antes eu escrevia classes de tipos individuais onde esse mecanismo funcionava.

#include <cstdint>
#include <cstddef>
    
    class IParameter
    {
    public:
        explicit IParameter(const size_t size) : size_{size} {};
        virtual ~IParameter() = default;

        virtual void copy(uint8_t*& addr) = 0;
    private:
        const size_t size_;
    };

    template <class TYPE>
    class IParameterBase : public IParameter
    {
    public:
        explicit IParameterBase(const TYPE value) : IParameter{sizeof(TYPE)}, value_{value} {};
        ~IParameterBase() = default;

        virtual void update(const TYPE value) = 0;

        operator auto() const {return get();};

        TYPE operator= (const TYPE value) { update(value); return get(); };

        TYPE get() const {return value_;};

        protected:
        TYPE value_;
    };

    template <class TYPE>
    class ParameterTx : public IParameterBase<TYPE>
    {
    public:
        explicit ParameterTx(const TYPE value) : IParameterBase<TYPE>{value} {};

        using IParameterBase<TYPE>::operator=;

        void copy(uint8_t*& addr) override
        {
            /* copy stuff */
        }
        void update(const TYPE value) override
        {
            this->value_ = value;
        }
    };


int main ()
{
    ParameterTx<uint16_t> param1{0};
    ParameterTx<uint16_t> param2{1};

    param1 = 16;
    param2 = 5;

    param1 = param2;
}

Código aqui: https://godbolt.org/z/3vqd4ebYM

Espero que a atribuição na parte inferior param1 = param2;seja resolvida para uint16_t, em vez disso, ela está tentando copiar o objeto, o que não é o que eu quero.