Stef1611's questions

Desde o OpenMP 4.5, arrays podem ser reduzidos usando pragmas. Mas, eu enfrentei um problema quando tentei usá-lo em arrays de tipo derivado porque !$OMP DECLARE REDUCTION não foi encontrado para este tipo. Eu entendo o problema. Depois de muitas tentativas, eu finalmente encontrei um programa que parece funcionar. Este é o código:

O módulo ( module.f90):

module my_mod
    implicit none
    
    type :: my_type_t
        integer :: x
        integer :: y
    end type my_type_t
    
    interface operator(+)
    module procedure add_my_type_t_vec
    end interface
    
!$OMP DECLARE REDUCTION (+ : my_type_t : omp_out = omp_out + omp_in) INITIALIZER (omp_priv = omp_orig)
    
contains
    
    function add_my_type_t_vec(a,b) result(res)
        type(my_type_t), dimension(:),intent(in) :: a, b
        type(my_type_t), dimension(size(a)) :: res
        
        res(:)%x = a(:)%x + b(:)%x
        res(:)%y = a(:)%y + b(:)%y
    end function add_my_type_t_vec
    
end module my_mod

E o programa ( pgm.f90) que o utiliza:

program parallel
    use omp_lib
    use my_mod
    implicit none
    
    type(my_type_t), dimension(:), allocatable :: private_var, shared_var
    integer :: i
    
    allocate(private_var(5), shared_var(5))
    shared_var%x=0
    shared_var%y=0
    

!$OMP PARALLEL NUM_THREADS(4) PRIVATE(private_var,i) REDUCTION (+ : shared_var) 

    !$OMP DO
    
    do i=1,1000
        private_var%x = 1
        private_var%y = 2
        shared_var = shared_var + private_var
    end do
    
    !$OMP END DO

!$OMP END PARALLEL
    print *, "Total : ", shared_var

end program parallel

Compilação com:gfortran -fopenmp module.f90 pgm.f90

Para encontrar essa solução, usei a seguinte resposta https://stackoverflow.com/a/61148205/7462275 .

Funciona, mas não tenho certeza de que não terei comportamento indefinido em certas circunstâncias. E não entendo completamente a sintaxe e o mecanismo dos pragmas DECLARE REDUCTION e INITIALIZER. De fato, fiz uma cópia/colagem da resposta mencionada acima e não há explicação nela. Obrigado pelos conselhos e explicações.

Com o seguinte código:

nb_vars=4

fig, axs = plt.subplots(4,4,figsize=(8,8), gridspec_kw = {'wspace':0.20, 'hspace':0.20}, dpi= 100)
for i_ax in axs:
    for ii_ax in i_ax:
        ii_ax.set_yticklabels([])
for i_ax in axs:
    for ii_ax in i_ax:
        ii_ax.set_xticklabels([])

O espaço entre os subplots é branco. Como é possível colori-los? E com cores diferentes? Veja por exemplo esta figura:

Tentei inicializar uma estrutura por meio de um literal composto em uma função. Depois de resolver uma parte do meu problema (veja Uso de literal composto dentro de uma função para iniciar uma variável em C ), tenho um novo problema com um membro ( ptr_mb) que deve ser um ponteiro para uma variável.

Este é o código:

typedef struct {
  int i_mb;
  int * ptr_mb;
} my_struct_t;

void init_struct(my_struct_t **my_struct, int * const ptr) {
  *my_struct=&(static my_struct_t) {.i_mb=3, .ptr_mb= ptr};
}

int main() {
  int a;
  my_struct_t *my_struct;
  
  // my_struct = &(my_struct_t) {.i_mb=3, .ptr_mb=&a}; It is OK

  // Try to initialize it in a function
  init_struct(&my_struct, &a);
  
}

Em main(), funciona (cf linha comentada no programa)

Um erro de compilação foi emitido. Na função init_struct, ptr não é uma constante (linha *my_struct=&(static my_struct_t) {.i_mb=3, .ptr_mb= ptr};:).

aé uma variável declarada em main(). Assim, seu endereço é constante. Tentei lançar a afetação com (int const *), (int * const), (int const * const), .... Às vezes era bobagem, mas só para tentar e nada funcionou.

É possível fazer tal inicialização em uma função, do jeito que ela funciona main()?

(Rq. staticé usado. Eu sei que é um padrão C23 e esse padrão ainda não foi publicado; para obter detalhes, consulte esta resposta: Uso de literal composto dentro de uma função para iniciar uma variável em C .)

Li muitas perguntas antigas, muitas respostas sobre constpalavras-chave em uma declaração para entender profundamente a sintaxe das declarações.

Eu brinquei conste agora estou um pouco confuso com este exemplo:

int i;
i=1;
int const *ptr_i;
ptr_i=&i;
printf("%d\n",*ptr_i);
i=2;
printf("%d\n",*ptr_i);

Se int const *é um ponteiro para um número inteiro constante , por que ptr_i=&i;é permitido? inão é um número inteiro constante.

Além disso, se o valor de ifor alterado de 1 para 2 (obviamente, é possível porque inão é um número inteiro constante), o segundo printfexibirá 2. Não estou surpreso porque o valor de ifoi alterado e ptr_ié um ponteiro para i.

Também verifiquei se o valor de ptr_i não mudou ( printf("%p ",ptr_i)).

Onde está meu mal-entendido?

Eu escrevi um programa fortran para simular o sistema molecular. Eu o desenvolvi em um computador desktop cujo processador é um Intel(R) Core(TM) i7-6700 CPU @ 3.40GHz. Depois, para iniciar a simulação em larga escala, usei blades de computação cujos processadores são AMD Opteron(tm) Processor 6176 @ 2.3 GHz. Fiquei surpreso porque o tempo de execução é aumentado por um fator de cerca de 3.

Então, decidi aprender a usar perf, asm, ... para otimizar o programa. Depois de muita coisa, finalmente escrevi este pequeno programa e ainda tenho um fator de cerca de 3.

program simple_pgm

    integer :: i, res
    
    res = 0
    do i=1,1000000000
        res = res + i
    enddo
    write(*,*) res

end program simple_pgm

Comando de compilação:gfortran -g -Wall -O2 simple.f90 -o simple

Quando olhei annotate MAIN__no perf report -n, o código assembler é mais ou menos o mesmo.

No processador i7:

     │    res = 0
     │    do i=1,1000000000
     │      mov  $0x1,%eax
     │      xchg %ax,%ax
     │    res = res + i
1095 │10:   add  %eax,%edx
     │    do i=1,1000000000
 1   │      add  $0x1,%eax
     │      cmp  $0x3b9aca01,%eax
     │    ↑ jne  10
     │    enddo

E no Opteron:

     │    res = 0                                                                                                                                  
     │    do i=1,1000000000                                                                                                                         
     │      mov    $0x1,%eax                                                                                                                        
     │    program simple_pgm                                                                                                                        
     │      sub    $0x220,%rsp                                                                                                                      
     │      nop                                                                                                                                     
     │    res = res + i
1972 │10:   add    %eax,%edx                                          
     │    do i=1,1000000000
1524 │      add    $0x1,%eax                                          
     │      cmp    $0x3b9aca01,%eax                                                                                                                 
     │    ↑ jne    10                                                                                                                               
     │    enddo

Gostaria de saber porque na samplecoluna, para a instrução add $0x1,%eax, o valor é muito grande para o processador Opteron ( 1524). E isso poderia explicar o fator de velocidade de execução?

Obrigado pela resposta. Como estou aprendendo ASM, processador e arquitetura de computador, perf, ... (muitas coisas para um iniciante), quaisquer comentários, sugestões serão apreciadas. Estou ciente de que posso estar no caminho errado.