Hacktoberfest 2026: los issues que los mantenedores marcaron para octubre, abiertos y aptos para principiantes. Explorar issues de Hacktoberfest

Inline Assembly version of a Pipeline

Abierto
  • ¿Algo no está bien?
#20 0 comentarios 0 reacciones 0 asignados Ver en GitHub

Nadie ha tomado este issue todavía.

Evaluación

Dificultad
5/5
Tiempo estimado
Más de una semana
Aptitud para principiantes
25/100
Tipo de issue
Refactorización
Claridad
Necesita aclaración
Estado de actividad
Estancado
Stack tecnológico
c, cpp
Área
compilers, performance

Línea de trabajo

El issue muestra la función C99 pipeline_kernel_c99 y la salida de ensamblado de GCC 14.2, pero no indica ningún archivo del repositorio, prueba, benchmark ni objetivo de optimización. Empieza por localizar la implementación existente de la pipeline y comparar su ensamblado generado con esta salida. Done no está definido más allá de producir una versión de ensamblado inline aún más optimizada, así que primero aclara los criterios de rendimiento previstos.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

enhancement good first issue help wanted

We can rewrite the whole "pipeline" as a single C 99 version:

void pipeline_kernel_c99(unsigned long start, unsigned long end, unsigned long *sum_out, unsigned long *count_out) {
    unsigned long sum = 0;
    unsigned long count = 0;
    unsigned long max_power_of_three = 12157665459056928801ull;

    for (unsigned long value = start; value <= end; ++value) {
        // Check if the value is a power of two
        if (value > 0 && (value & (value - 1)) == 0) continue;
        // Check if the value is a power of three
        if (value > 0 && max_power_of_three % value == 0) continue;

        // Prime factorization
        unsigned long n = value;
        unsigned long factor = 2;

        // Handle factor 2 separately
        while (n % 2 == 0) {
            sum += 2;
            count += 1;
            n /= 2;
        }

        // Handle odd factors
        factor = 3;
        while (factor * factor <= n) {
            while (n % factor == 0) {
                sum += factor;
                count += 1;
                n /= factor;
            }
            factor += 2;
        }

        // If n is still greater than 1, it is a prime factor
        if (n > 1) {
            sum += n;
            count += 1;
        }
    }

    *sum_out = sum;
    *count_out = count;
}

GCC 14.2 produces the following Assembly:

pipeline_kernel_c99(unsigned long, unsigned long, unsigned long*, unsigned long*):
        push    rbp
        mov     rbp, rcx
        push    rbx
        mov     rbx, rdx
        cmp     rsi, rdi
        jb      .L15
        mov     r9, rdi
        mov     r10, rsi
        xor     edi, edi
        xor     r8d, r8d
        movabs  r11, -6289078614652622815
        jmp     .L14
.L7:
        add     r9, 1
        cmp     r10, r9
        jb      .L2
.L14:
        xor     ecx, ecx
        test    r9, r9
        je      .L9
        lea     rax, [r9-1]
        test    rax, r9
        je      .L7
        mov     rax, r11
        xor     edx, edx
        div     r9
        test    rdx, rdx
        je      .L7
        mov     rcx, r9
        test    r9b, 1
        jne     .L39
.L9:
        shr     rcx
        add     r8, 2
        add     rdi, 1
        test    cl, 1
        je      .L9
        cmp     rcx, 8
        jbe     .L10
.L5:
        mov     esi, 3
.L11:
        mov     rax, rcx
        xor     edx, edx
        div     rsi
        test    rdx, rdx
        jne     .L13
.L12:
        mov     rax, rcx
        xor     edx, edx
        add     r8, rsi
        add     rdi, 1
        div     rsi
        xor     edx, edx
        mov     rcx, rax
        div     rsi
        test    rdx, rdx
        je      .L12
.L13:
        add     rsi, 2
        mov     rax, rsi
        imul    rax, rsi
        cmp     rcx, rax
        jnb     .L11
.L10:
        cmp     rcx, 1
        je      .L7
.L6:
        add     r9, 1
        add     r8, rcx
        add     rdi, 1
        cmp     r10, r9
        jnb     .L14
.L2:
        mov     QWORD PTR [rbx], r8
        mov     QWORD PTR [rbp+0], rdi
        pop     rbx
        pop     rbp
        ret
.L39:
        cmp     r9, 8
        ja      .L5
        jmp     .L6
.L15:
        xor     edi, edi
        xor     r8d, r8d
        mov     QWORD PTR [rbx], r8
        mov     QWORD PTR [rbp+0], rdi
        pop     rbx
        pop     rbp
        ret

It seems like this can be further optimized. Who's up for the task?

Lenguaje dominante
C++
Estrellas
1.9k
Forks
85
Sin PR fusionados en 30 d

Preparar el entorno

Este proyecto no incluye contenedor de desarrollo, Dockerfile ni guía de contribución, así que la configuración corre por tu cuenta: empieza por su README y consulta nuestra guía para la primera contribución para los pasos generales.

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de ashvardanian/less_slow.cpp

Todos los issues de ashvardanian/less_slow.cpp

Issues similares

Más issues de C++

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.