PkDrew's questions

O código abaixo sempre imprime "Olá do início" antes de qualquer outra coisa, e "Olá do fim" depois de qualquer outra coisa. Por que isso?

Código:

#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <iostream>

#include "cuda_runtime.h"
#include "device_launch_parameters.h"


__global__ void add1InGPU( int *devArr, int n, int nx )
{
    int ix = blockIdx.x * blockDim.x + threadIdx.x;
    int iy = blockIdx.y * blockDim.y + threadIdx.y;
    int id = nx * iy + ix;

    int whateverNum = 5;

    if (id == whateverNum) printf("Hello from the start\n");
    
    if ( id < n ) {
        devArr[id] += 1; 
        printf("blockIdx.x: %d, threadIdx.x: %d, blockIdx.y: %d, threadIdx.y: %d, processing index %d\n", blockIdx.x, threadIdx.x, blockIdx.y, threadIdx.y, id );
    }
    else {
        printf("blockIdx.x: %d, threadIdx.x: %d, blockIdx.y: %d, threadIdx.y: %d, skipped\n", blockIdx.x, threadIdx.x, blockIdx.y, threadIdx.y);
    }

    if (id == whateverNum) printf("Hello from the end\n");
}

int main(void)
{
    
    int* d_arr = NULL;
    cudaMalloc(&d_arr, 16 * sizeof(int));
    cudaMemset(d_arr, 0, 16 * sizeof(int));

    int nElem = 16;
    dim3 block( 2, 2 );
    dim3 grid( 2, 2 );
    // dim3 grid( ( nElem + block.x - 1 ) / block.x );
    
    add1InGPU<<<grid, block>>> ( d_arr, nElem, 4 );
    cudaDeviceSynchronize();
    int *h_arr = (int*)malloc(16 * sizeof(int));
    cudaMemcpy(h_arr, d_arr, 10 * sizeof(int), cudaMemcpyDeviceToHost);
    cudaFree(d_arr);

    volatile int _ = 0;
    for (int i = 0; i < 10; i++) {
        _ += h_arr[i];
    }

    cudaDeviceReset();
    
    return 0;
}

Saída:

Hello from the start
blockIdx.x: 1, threadIdx.x: 0, blockIdx.y: 0, threadIdx.y: 0, processing index 2
blockIdx.x: 1, threadIdx.x: 1, blockIdx.y: 0, threadIdx.y: 0, processing index 3
blockIdx.x: 1, threadIdx.x: 0, blockIdx.y: 0, threadIdx.y: 1, processing index 6
blockIdx.x: 1, threadIdx.x: 1, blockIdx.y: 0, threadIdx.y: 1, processing index 7
blockIdx.x: 0, threadIdx.x: 0, blockIdx.y: 1, threadIdx.y: 0, processing index 8
blockIdx.x: 0, threadIdx.x: 1, blockIdx.y: 1, threadIdx.y: 0, processing index 9
blockIdx.x: 0, threadIdx.x: 0, blockIdx.y: 1, threadIdx.y: 1, processing index 12
blockIdx.x: 0, threadIdx.x: 1, blockIdx.y: 1, threadIdx.y: 1, processing index 13
blockIdx.x: 1, threadIdx.x: 0, blockIdx.y: 1, threadIdx.y: 0, processing index 10
blockIdx.x: 1, threadIdx.x: 1, blockIdx.y: 1, threadIdx.y: 0, processing index 11
blockIdx.x: 1, threadIdx.x: 0, blockIdx.y: 1, threadIdx.y: 1, processing index 14
blockIdx.x: 1, threadIdx.x: 1, blockIdx.y: 1, threadIdx.y: 1, processing index 15
blockIdx.x: 0, threadIdx.x: 0, blockIdx.y: 0, threadIdx.y: 0, processing index 0
blockIdx.x: 0, threadIdx.x: 1, blockIdx.y: 0, threadIdx.y: 0, processing index 1
blockIdx.x: 0, threadIdx.x: 0, blockIdx.y: 0, threadIdx.y: 1, processing index 4
blockIdx.x: 0, threadIdx.x: 1, blockIdx.y: 0, threadIdx.y: 1, processing index 5
Hello from the end

Digamos que eu tenha uma estrutura chamada Particlee gostaria que ela fosse alinhada em 32 bits. Devo usar a alignaspalavra-chave quando especificar a definição da estrutura, como no código abaixo:

struct alignas(32) Particle {
    // Total size: 16 bytes, but alignas(32) ensures 32-byte alignment
    float x; // 4 bytes
    float y; // 4 bytes
    float z; // 4 bytes
    float w; // 4 bytes 
};

ou devo especificá-lo na definição dos layouts onde as estruturas residem, assim:

alignas(32) Particle particles[8]; // Array of 8 particles, 32-byte aligned

ou devo fazer as duas coisas?

No meu ambiente de desenvolvimento, existe um alias que grava stdout em um arquivo específico.

Ele usa tubo com T, por exemplo, du -h | & tee /tmp/diskUsage.

Entendo que o operador AND torna tudo o que precede um descritor de arquivo em vez de um nome de arquivo, por exemplo, 2>&1redirecionando stderr para stdout em vez de um arquivo chamado "1" no diretório atual.

Entretanto, para o uso | & tee, não há nada significativo depois de '&' e antes de "tee", o que isso faz neste caso?

Recentemente, estou aprendendo alguns tópicos de HPC e descobri que os compiladores C/C++ modernos são capazes de detectar locais onde a otimização é necessária e conduzi-la usando técnicas correspondentes, como SIMD, desdobramento de loop, etc., especialmente sob o sinalizador -O3, com uma compensação entre desempenho de tempo de execução versus tempo de compilação e tamanho do arquivo de objeto.

Então, imediatamente me ocorreu que o CPython interpreta e executa em tempo real, então presumo que ele não pode se dar ao luxo de conduzir esses recursos do compilador porque o tempo de compilação para ele é equivalente ao tempo de execução, então fiz um experimento de brinquedo abaixo:

import time, random

n = 512
A = [[random.random() for _ in range(n)] for _ in range(n)]
B = [[random.random() for _ in range(n)] for _ in range(n)]
C = [[0] * n for _ in range(n)]

def matMul( A, B, C ):
    """ C = A .* B """
    for i in range(0, n - 4, 4):
        for j in range(0, n - 4, 4):
            for k in range(0, n - 4, 4):
                C[i][j] = A[i][k] * B[k][j]
                C[i + 1][j + 1] = A[i + 1][k + 1] * B[k + 1][j + 1]
                C[i + 2][j + 2] = A[i + 2][k + 2] * B[k + 2][j + 2]
                C[i + 3][j + 3] = A[i + 3][k + 3] * B[k + 3][j + 3]
                C[i + 4][j + 4] = A[i + 4][k + 4] * B[k + 4][j + 4]
    # return C

start = time.time()
matMul( A, B, C )
end = time.time()

print( f"Elapsed {end - start}" )

Com o loop se desenrolando, o programa termina em 3 segundos, sem ele, leva até quase 20 segundos.

Isso significa que é preciso prestar atenção e implementar manualmente essas técnicas opt ao escrever código Python? Ou o Python oferece a otimização em alguma configuração especial?

Aprendi recentemente que fork aplica COW (copy on write) até mesmo em registradores.

Brinquei com uma caixa de brinquedo simples para verificar:

(gdb) info inferiors
  Num  Description       Connection           Executable
* 1    process 59316     1 (native)           /home/Drew/mycode/a.out
  2    process 59386     1 (native)           /home/Drew/mycode/a.out
(gdb) print( $rdi )
$1 = 18874385
(gdb) set $rdi=42
(gdb) print( $rdi )
$2 = 42
(gdb) inferior 2
[Switching to inferior 2 [process 59386] (/home/Drew/mycode/a.out)]
[Switching to thread 2.1 (process 59386)]
#0  0x00002aaaab090291 in fork () from /lib64/libc.so.6
(gdb) print( $rdi )
$3 = 18874385

Como vocês podem ver, modificar o rdi no proc pai não interfere no proc filho.

Gostaria de saber como isso é feito? As CPUs modernas fornecem múltiplos registradores iguais exclusivamente para multiprocessos?

EDITAR:

Obrigado a vocês, companheiros, por comentarem. Responderei às perguntas nos comentários aqui coletivamente, espero que ajude a esclarecer.

A referência que estou usando é esta nota de aula .

Geralmente quero descobrir:

• O Linux alguma vez copia os registradores, seja COW ou não?
• Se a resposta for sim, isso é feito pelo hardware, ou seja, os fabricantes da CPU fornecem suporte de design como fazem para dar suporte a máquinas virtuais, ou pelo software, digamos, o sistema operacional armazena o valor do registro em algum lugar (na RAM?), então, em vez de operar nos próprios registros, ele efetivamente modifica a página, mas de alguma forma consegue imitar o comportamento do registro?
• Se fork não copia registradores de forma alguma, por que estou vendo o fenômeno no GDB?

Gostaria de saber por que o código abaixo imprime "errado".

double x = 0x8000000000000000;
signed long long v1 = (signed long long)(x);
signed long long v2 = *(signed long long *)(&x);
printf( v1 == v2? "correct\n" : "wrong\n" );

Tentei imprimir a representação binária de v1 e v2 respectivamente pelo código abaixo:

printf( "v1 = 0b" );
for ( int i = 63; i > 0; i-- ) {
    printf( "%d", ( ( v1 >> i ) & 1 ) );
}
printf( "\n" );

printf( "v2 = 0b" );
for ( int i = 63; i > 0; i-- ) {
    printf( "%d", ( ( v2 >> i ) & 1 ) );
}
printf( "\n" );

Acontece que v1 está correto, mas v2 é 0b010000111110000000000000000000000000000000000000000000000000000.

Alguém poderia ser tão gentil em ensinar o que acontece aqui?

Também gostaria de saber se o padrão C oferece alguma maneira de imprimir a representação subjacente de binário ou hexadecimal, de modo que meu esquema de impressão possa ser substituído por uma chamada de função de uma linha?

Não consigo encontrar nenhuma definição oficial relacionada ao tratamento de std::nth_element(first, nth, last) se nth estiver fora do intervalo [first, last).

Para tentar descobrir, fiz um teste de brinquedo na minha máquina:

std::vector<int> arr{ 7, 3, 9, 6, 4 };
std::nth_element( arr.begin() + 1, arr.begin(), arr.end() );
for (int num : arr) {
    printf("%d", num);
}

O MSVC me dá falha de asserção no código stl src do vetor, dizendo "intervalo do iterador do vetor transposto". É um comportamento indefinido?

Digamos que agora tenho funções hash e equal prontas para um unordered_set

auto equalFunc = [](...){...};
auto hashFunc  = [](...){...};

Se o unordered_set for usado exclusivamente, sei que posso fazer o seguinte para especificar meu hash DIY e equal:

std::unordered_set<std::pair<int,int>, decltype( hashFunc ), decltype( equalFunc )> mySet( 0, hashFunc, equalFunc );

Entretanto, agora suponha que o unordered_set deve ser usado como valor de std::unordered_map, como posso especificar o hash e o equal?

std::unordered_map<int, std::unordered_set<std::pair<int,int>, decltype( hashFunc ), decltype( equalFunc )>> myMap( ...how? );

No GDB, posso fazer o seguinte e obter o endereço de uma string literal:

(gdb) p &"aaa"
$3 = (char (*)[4]) 0x614c20

Pelo que entendi, uma string literal é um rvalue sem nenhum símbolo ao qual se vincula, mas por que posso obter seu endereço?

Que tipo de endereço é esse? É algum lugar onde todos os literais de string são armazenados? Mas há literais de string infinitos, isso significa que o literal de string é "criado e colocado na memória" sob demanda?

Digamos que eu tenha um contêiner arbitrário e uma pergunta para saber se há um elemento nele, veja abaixo.

D = {(1, 2): "whatever"}
if (2, 1) in D:
    print( "Impossible" ) 

O que realmente acontece em termos de código subjacente? alguma função de membro específica, como find(), é chamada?

Além disso, posso usar um cmp/hash personalizado? digamos, se eu quiser comparar apenas a ocorrência de cada número na chave da tupla conforme mostrado no trecho de código, o que posso fazer para conseguir isso?

D = {(1, 2, 1): "whatever"}
if (2, 1, 1) in D:
    print( "As expected" ) # How to make it happen?

Um documento oficial do Py será muito apreciado, presumo que seja uma informação bastante fundamental, mas não consigo encontrar uma introdução oficial em lugar nenhum.

No Linux (não tenho certeza para Windows, qualquer conhecimento sobre isso também é apreciado), uma técnica chamada ligação lenta é usada para aumentar o desempenho quando apenas uma pequena parte da biblioteca compartilhada é necessária, imagine quando você invoca um programa com -h --help arg, etc.

Eu queria saber como isso é implementado? está relacionado à técnica de alocação lenta de gerenciamento de memória virtual do sistema operacional? ou seja, em vez de carregar todas as instruções na memória, um mapeamento para a memória não mapeada é conduzido primeiro, e a memória válida é carregada somente quando for realmente necessária/referida durante o tempo de execução.