All perguntas(coding)

Ao atualizar nosso projeto do Java 17 para o Java 21, notamos um aumento no consumo de memória. Depois de despejar o heap e analisar as diferenças, descobri que há milhares de strings vazias armazenadas na memória.

Consegui reproduzir o problema com o seguinte código:

import java.lang.management.ManagementFactory;
import java.text.DecimalFormat;

public class DecimalFormating {
    
    static DecimalFormat decimalFormat = new DecimalFormat("#.##");
    static DecimalFormat decimalFormat2 = new DecimalFormat();
    
    public static void main(String[] args) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];
                Process p = Runtime.getRuntime().exec("D:\\JAVA\\jdk-17.0.2\\bin\\jmap.exe -dump:format=b,file=heapdump_string_decimal_17.hprof " + pid);
                p.waitFor();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }));
    }
}

O código a seguir é direto, pois define duas instâncias de DecimalFormat, que por sua vez definem múltiplas strings vazias, como visto aqui e aqui . Ele então despeja o heap em um arquivo.

Compilei e executei o código com Java 17.0.2 e Java 21.0.6, e aqui está a aparência da memória:

• No Java 17, você pode ver que todas as strings que deveriam estar vazias apontam para o mesmo endereço de memória, o que é um comportamento esperado devido ao String Constant Pool:
• No Java 21, cada string tem um endereço de memória diferente, resultando na string vazia sendo definida seis vezes e consumindo seis vezes mais memória do que no Java anterior:

Esse comportamento é normal? Não consigo encontrar nenhuma menção a esse tipo de mudança nas notas de lançamento do Java entre as versões 18 e 21.

Existe uma maneira de calcular a soma (ou média, etc.) de um intervalo de valores definidos para aquela linha em outra coluna?

Aqui estão alguns dados de exemplo:

structure(list(start = c("cmi_apr", "cmi_may", "cmi_may"), end = c("cmi_oct", 
"cmi_oct", "cmi_dec"), cmi_jan = c(2.35, 2.24, 37.66), cmi_feb = c(1.33, 
5.65, 43.23), cmi_mar = c(0.08, 4.43, 22.2), cmi_apr = c(0.17, 
6.48, 18.56), cmi_may = c(-5.61, 0.54, 21.52), cmi_jun = c(-6.37, 
-0.92, 13.86), cmi_jul = c(-6.53, 5.18, 2.81), cmi_aug = c(-2.37, 
4.4, 21.32), cmi_sep = c(1.28, 0.92, 19.48), cmi_oct = c(0.33, 
11.21, 26.43), cmi_nov = c(1.41, 9.18, 43.87), cmi_dec = c(2.21, 
10.96, 30.54)), row.names = c(NA, -3L), class = c("tbl_df", "tbl", 
"data.frame"))

Quero gerar somas de intervalo com base na variável startand endassim:

Eu tenho uma solução, porém meu conjunto de dados real tem mais de 60.000 linhas e demora muito para concluir o cálculo. Imagino que isso deva ser muito mais rápido, já que a adição é vetorizada. Aqui está minha solução atual:

compute_growing_season <- function(df, start_colname, end_colname, FUN) {
  # Generate column index vectors
  start_idx = sapply(start_colname, function(x) { which(x == names(df))} )
  end_idx = sapply(end_colname, function(x) { which(x == names(df))} )
  
  # Generate computed vector
  results <- numeric(nrow(df))
  for (i in 1:nrow(df)) {
    results[i] <- FUN(df[i, start_idx[i]:end_idx[i]], na.rm = F)
  }
  
  return(results)
}

output <- sample %>%
  mutate(
    cmi_growingseason_sum = compute_growing_season(., start, end, sum)
  )

Com uma estrutura como a seguinte

typedef struct
{
  size_t StringLength;
  char   String[1];
} mySTRING;

e uso desta estrutura ao longo destas linhas

mySTRING * CreateString(char * Input)
{
  size_t     Len     = strlen(Input);
  int        Needed  = sizeof(mySTRING) + Len;
  mySTRING * pString = malloc(Needed);
  :
  strcpy(pString->String, Input); 
}

resultados, no compilador Red Hat Linux cc, no aviso a seguir, o que é justo.

strings.c:59:3: warning: âstrcpyâ writing 14 bytes into a region of size 1 overflows the destination [-Wstringop-overflow=]
   strcpy(pString->String, Input);

Eu sei que, nesta instância do código, este aviso é algo que não preciso corrigir. Como posso dizer isso ao compilador sem desligar esses avisos que podem encontrar algo útil, em algum outro lugar, no futuro.

Que alterações posso fazer no código para mostrar ao compilador que isso está correto?

Preciso trabalhar com arrays que podem ter zeros em suas formas. No entanto, estou encontrando um problema. Aqui está um exemplo:

import numpy as np

arr = np.array([[]])
assert arr.shape == (1,0)
arr.reshape((1,0))  # No problem (nothing changes)
arr.reshape((-1,0))  # ValueError: cannot reshape array of size 0 into shape (0)

Eu sempre pensei que -1para uma operação de remodelação significa o produto de todas as dimensões restantes, ou seja, 1 neste caso. Isso é um bug ou não estou entendendo como isso deveria funcionar?

Estou escrevendo uma biblioteca C++, que trabalha com dados que têm alguns valores de tempo neles - valores que não se originam no sistema em que a biblioteca é executada. Quero colocar esses valores em std::chrono::time_point's (que serão expostos aos usuários da biblioteca).

Agora, para fazer isso, preciso especificar um Clocktipo. Ok, isso não deve ser um problema, certo? Posso atender a todos os requisitos de , não posso? ... hmm, não, não realmente, tenho um obstáculo: a now()função. Não posso fornecer um now()valor para o sistema onde os valores de ponto de tempo que estou olhando foram gerados! Não tenho acesso a ele, e talvez ele nem exista mais; e pode ter parado, ou sido reiniciado, ou deixado de existir completamente.

Isso significa que eu não devo usar std::chronotipos? Ou devo criar um tipo de relógio cuja now()função retorna um valor fictício fixo? Ou um valor artificialmente crescente?

Ao pesquisar sobre E/S de arquivos em C, me deparei com duas funções: fgetc()e read().

//code1.c
#include <stdio.h>

int main(void)
{
  char ch;
  
  ch = fgetc(stdin);

  return 0;
}

//code2.c
#include <unistd.h>

int main(void)
{
  char ch;

  read(STDIN_FILENO, &ch, 1);

  return 0;
}

Em ambos os programas acima, se eu digitar hello:

• O primeiro, armazenará a entrada do teclado (stdin) che o programa simplesmente terminará. O que significa que chconterá he os caracteres restantes simplesmente desaparecerão.

• No segundo programa, a entrada do teclado também será armazenada em ch. Mas os caracteres restantes ( ello) não desaparecerão. Em vez disso, eles serão passados ​​para o terminal como um comando após o término do programa.

Não consigo entender por que isso está acontecendo? É algo relacionado a como as entradas são armazenadas em buffer em C (e por computadores em geral)?

C++23 permite definir um lambda como static. ou seja, se um lambda não captura nada, então ele pode ser definido como static:

// with superfluous argument `this`, less efficient.
auto fn1 = [](int a, int b) { return a + b; }; 

// no argument `this`, more efficient!
auto fn2 = [](int a, int b) static { return a + b; }; 

Eu só me pergunto:

Por que o padrão C++ não define implicitamente um lambda que não captura nada como staticpadrão?

C++26 fornece std::copyable_function [cppref link] . No entanto, o existente std::functionjá é copyable. Então, tenho 3 perguntas:

1. Quais são as principais vantagens de std::copyable_functionmais de std::function?

2. Invocar um vazio std::copyable_functioné indefinido, enquanto invocar um vazio std::functionlançará uma exceção. Qual é a lógica por trás disso?

3. Foi std::functiondescontinuado std::copyable_functionem C++26?

Veja este trecho:

int main() {
    double v = 1.1;
    return v == 1.1;
}

Em compilações de 32 bits, este programa retorna 0, se -fexcess-precision=standardfor especificado. Sem ele, o programa retorna 1.

Por que há uma diferença? Olhando para o código assembly ( godbolt ), parece que com -fexcess-precision=standard, o gcc usa 1.1como uma long doubleconstante (ele carrega a constante como TBYTE). Por que ele faz isso?

Primeiro pensei que fosse um bug, mas encontrei este comentário de bug do gcc , parece que esse comportamento é intencional, ou pelo menos não é inesperado.

Isso é um problema de QoI? Eu entendo que a comparação é executada usando long doubleprecisão, mas ainda assim, my 1.1não é um long doubleliteral. O estranho é que se eu lançar o 1.1at na comparação to double(que já é um double), o problema desaparece.

(Outra coisa estranha é que o GCC faz o carregamento e a comparação duas vezes, veja as fucomipinstruções duplas. Mas ele faz isso mesmo no modo de 64 bits. Entendo que no meu link godbolt, a otimização está desativada, mas ainda assim, há apenas uma comparação no meu código, por que o GCC compara duas vezes?)

Aqui está o código asm, sem -fexcess-precision=standard:

main:
        push    ebp
        mov     ebp, esp
        and     esp, -8
        sub     esp, 16
        fld     QWORD PTR .LC0
        fstp    QWORD PTR [esp+8]
        fld     QWORD PTR [esp+8]
        fld     QWORD PTR .LC0
        fucomip st, st(1)
        fstp    st(0)
        setnp   al
        mov     edx, 0
        fld     QWORD PTR [esp+8]
        fld     QWORD PTR .LC0
        fucomip st, st(1)
        fstp    st(0)
        cmovne  eax, edx
        movzx   eax, al
        leave
        ret
.LC0:
        .long   -1717986918
        .long   1072798105

E aqui está:

main:
        push    ebp
        mov     ebp, esp
        and     esp, -8
        sub     esp, 16
        fld     QWORD PTR .LC0
        fstp    QWORD PTR [esp+8]
        fld     QWORD PTR [esp+8]
        fld     TBYTE PTR .LC1
        fucomip st, st(1)
        setnp   al
        mov     edx, 0
        fld     TBYTE PTR .LC1
        fucomip st, st(1)
        fstp    st(0)
        cmovne  eax, edx
        movzx   eax, al
        leave
        ret
.LC0:
        .long   -1717986918
        .long   1072798105
.LC1:
        .long   -858993459
        .long   -1932735284
        .long   16383

O que (eu acho) eu preciso

Como posso definir uma característica de tipo que verifica se, para um tipo T, a função ::foo(T)é declarada?

O que estou achando difícil é ter ::foouma maneira amigável ao SFINAE. Por exemplo, se o compilador chegou ao ponto em que o seguinte é definido,

template<typename T>
void f(T t) { foo(t); }

está tudo bem se nada foofoi visto até agora.

Mas assim que mudo foopara ::foo, recebo um erro grave.

O caso de uso (caso você ache que não preciso do acima)

Tenho um ponto de personalização como este:

// this is in Foo.hpp
namespace foos {
inline constexpr struct Foo {
    template <typename T, std::enable_if_t<AdlFooable<std::decay_t<T>>::value, int> = 0>
    constexpr bool operator()(T const& x) const {
        return foo(x);
    }
} foo{};
}

que permite personalizar o comportamento de uma chamada foos::foodefinindo uma foosobrecarga ADL para o tipo desejado.

A definição da característica é simples:

// this is in Foo.hpp
template <typename T, typename = void>
struct AdlFooable : std::false_type {};

template <typename T>
struct AdlFooable<T, std::void_t<decltype(foo(std::declval<T const&>()))>>
    : std::true_type {};

Dado que, se alguém define

// this is in Bar.hpp
namespace bar {
    struct Bar {};
    bool foo(bar::Bar);
}

então uma chamada para

// other includes
#include "Foo.hpp"
#include "Bar.hpp"
bool b = foos::foo(bar::Bar{});

funciona como esperado, com foos::fooroteamento da chamada para bar::foo(bar::Bar), que é encontrado via ADL. E isso funciona bem independentemente da ordem dos dois #includes, o que é bom, porque eles podem ser incluídos em qualquer ordem, se // other includestransitivamente os incluir.

Até agora tudo bem.

O que eu realmente não gosto dessa abordagem é que alguém poderia definir erroneamente, em vez do segundo trecho acima, o seguinte,

// this is in Bar.hpp
namespace bar {
    struct Bar {};
}
bool foo(bar::Bar);

com fooescopo global.

Nesse caso, se o #include "Bar.hpp"vier antes de #include "Foo.hpp", o programa de código funcionará, porque o corpo de Foo::operator()será selecionado ::foo(bar::Bar)por pesquisa comum.

Mas assim que a ordem do #includes é invertida, o código quebra.

Sim, o bug está na definição foo(bar::Bar)do namespace global, mas acho que também é um bug que pode passar despercebido por puro acaso.

É por isso que eu gostaria de mudar o traço de tipo para expressar que "uma chamada não qualificada para foo(T)é encontrada, mas não por meio de uma pesquisa comum " ou, mais diretamente, " foo(std::declval<T>())deve compilar, mas não::foo(std::declval<T>()) deve compilar" .