Comment puis-je accélérer ce tri par insertion? (asm en ligne en C)

Question

Donc ce tri par insertion est écrit en x86, mais intégré en C. Il a également un indicateur que nous définissons pour quitter après avoir trié la moitié du tableau. Y a-t-il un moyen d'augmenter les performances?

void asmInsSort(int *liste, int longueurTableau, int moitie) {
 _asm
 {
    mov ecx, longueurTableau
    mov esi, liste
    mov ebx, moitie
    mov eax, 0

    more:
        cmp ecx, 0              // Comparer la longueur actuelle du tableau avec 0
            je  done            // Si c'est égal, nous avons terminé
        mov edi, eax            // J = I
        push eax                // Pousser eax (i) pour libérer le registre pour key
        mov eax, [esi + edi]    // Key = Array[i] techniquement j
        sub edi, 4              // J - 1
        mov edx, longueurTableau       // K = Longueur tableau
        sar edx, 1              // Décalage signé vers la droite de K par 1
        cmp ecx, edx            // SI Longueur tableau > K
            jg  cont1           // Sauter à cont1 hey
        cmp moitie, 1        // SI moitie = 1
            je  done2           // Sortie SINON cont1

    cont1 :
        cmp edi, 0              // Si j <= 0, sortir de la boucle
            je cont2
        cmp[esi + edi], eax     // Si Array[J] <= key, sortir de la boucle
        jle cont2
        mov edx, [esi + edi]    // k = Array[j]
        mov[esi + edi + 4], edx // Array[j+1] = Array j
        sub edi, 4              // J--               
        jmp cont1

    cont2 :
        mov[esi + edi + 4], eax // Array[j+1] = key              
        pop eax                 // Pop eax pour récupérer i précédent pour l'utiliser ci-dessus
        add eax, 4              // Incrémenter i
        dec ecx                 // Décrémenter Longueur tableau
        jmp more

    done2 :             // Réinitialisation de la pile moitie
        pop eax;
 done:
 }
}

edit:

Donc je pensais avoir optimisé correctement comme ceci:

void asmSort(int *liste, int longueurTableau, int moitie) {
 _asm
 {
    mov ecx, longueurTableau                   // n
    mov esi, liste
    mov ebx, moitie                  // D'abord moitié, puis j
    mov eax, 4                          // i = 1

    cmp ebx, 1                          // si(!moitie)
        jne main_loop                   // aller à la boucle principale
    mov ebx, ecx                        // sinon copier longueur tableau en temporaire
    and ebx, 1                          // n%2
    shr ecx, 1                          // n/2
    add ecx, ebx                        // ajouter les deux pour obtenir la quantité de boucles

    main_loop:
        cmp ecx, 0                      // tant que n > 0
            je end
        mov edx, [esi + eax]            // key = arr[i]
        mov ebx, [eax - 4]              // j = i - 1
        inner_loop:                     // tant que ( j >= 0 && arr[j] > key )
            cmp ebx, 0                  // (si j < 0, sortir)
                jl end_inner
            cmp [esi + ebx], edx        // (si arr[j] <= key, sortir )
                jle end_inner
            mov edi, [esi + ebx]        // edi = arr[j]
            mov [esi + ebx + 4], edi    // arr[j + 1] = edi;
            sub ebx, 4                  // j = j - 1;
            jmp inner_loop
        end_inner:
        mov [esi + ebx + 4], edx        // arr[j + 1] = key;
        dec ecx                         // n--
        add eax, 4                      // i++
        jmp main_loop
        end:
 }
 return;
}

Mais cela ne fonctionne pas du tout maintenant. Je ne sais pas ce que j'ai fait de mal.