Курилка программистов, Флуд на около программерские темы Опции

[1001v]

А значит лучше его заменить на нормальные компилируемые ЯП

Скажу по секрету, многие интерпретируемые языки компилируются внутри своих виртуальных машин во время выполнения, причем зачастую в весьма производительный код. И не надо забывать, что язык это просто инструмент, каждый хорош чем-то в своем.

[RayTwitty]

аналогичный софт на js\lua станет концом света в котором уже никто не разберется.

Зависит от рук пишущего. Тот же жабаскрипт сейчас используется везде, от простых сайтиков до сервера и мобильных приложений. Для него даже ассемблер сделали

пока у нас тут правил и правит паскаль на западе и европах дефакто С использовали и используют как вводный ЯП

Говнопаскаль остался только в разного рода колледжах и качество обучения там такое, что отобьет любое желание заниматься программированием в принципе. В нормальных образовательных учреждениях (высших) начинают именно с С/С++ и на последних курсах обычно добавляют Java. Впрочем, мне повезло, у нас изменили программу и вместо Java был курс по Apple Swift.

То есть использования псевдооператора #end для завершения блока, так привычней.

Ахахах.

Сообщение отредактировал RayTwitty - 12.04.2019, 15:29

[jamakasi]

Мне гораздо больше нравятся, end и } а необходимые отступы я и сам делаю.

дело не в том нравится\не нравится и сделаешь отступы. Тут хочешь или нет отступы делать придется причем "стандартно" а не следуя своим хотелкам и принципам.

Достаточно посмотреть на "я сам сделаю ...."

Код

some{... return}

some {... return}

some
{... return}

some{
... return}

some
       {
... return
       }
и еще тонна вариантов

аналогичная ситуация и с пробелами и табулярами почти во всех ЯП, одни ставят пробел, другие 5 проблелов, третьи 2 табуляра ...
В питоне это так или иначе загоняет в конкретные рамки стиля и любой открытый код сразу как минимум понятен блочно что откуда и где заканчивается.

[NanoBot-AMK]

Ахахах.

Что хаха?
Посмотри как улучшился код.

СуперПитух

Код

"""pyversioncheck - Module to help with checking versions"""
import types
import rfc822
import urllib
import sys

# Verbose options
VERBOSE_SILENT=0        # Single-line reports per package
VERBOSE_NORMAL=1        # Single-line reports per package, more info if outdated
VERBOSE_EACHFILE=2        # Report on each URL checked
VERBOSE_CHECKALL=3        # Check each URL for each package

# Test directory
## urllib bug: _TESTDIR="ftp://ftp.cwi.nl/pub/jack/python/versiontestdir/"
_TESTDIR="http://www.cwi.nl/~jack/versiontestdir/"

def versioncheck(package, url, version, verbose=0):
    ok, newversion, fp = checkonly(package, url, version, verbose)
    if verbose > VERBOSE_NORMAL:
        return ok
    #end
    if ok < 0:
        print '%s: No correctly formatted current version file found'%(package)
    elif ok == 1:
        print '%s: up-to-date (version %s)'%(package, version)
    else:
        print '%s: version %s installed, version %s found:' % (package, version, newversion)
        if verbose > VERBOSE_SILENT:
            while True:
                line = fp.readline()
                if not line: break
                sys.stdout.write('\t'+line)
            #end
        #end
    #end
    return ok
#end

def checkonly(package, url, version, verbose=0):
    if verbose >= VERBOSE_EACHFILE:
        print '%s:'%package
    #end
    if type(url) == types.StringType:
        ok, newversion, fp = _check1version(package, url, version, verbose)
    else:
        for u in url:
            ok, newversion, fp = _check1version(package, u, version, verbose)
            if ok >= 0 and verbose < VERBOSE_CHECKALL:
                break
            #end
        #end
    #end
    return ok, newversion, fp
#end

def _check1version(package, url, version, verbose=0):
    if verbose >= VERBOSE_EACHFILE:
        print '     Checking %s'%url
    #end
    try:
        fp = urllib.urlopen(url)
    except IOError, arg:
        if verbose >= VERBOSE_EACHFILE:
            print '       Cannot open:', arg
        #end
        return -1, None, None
    #end
    msg = rfc822.Message(fp, seekable=0)
    newversion = msg.getheader('current-version')
    if not newversion:
        if verbose >= VERBOSE_EACHFILE:
            print '       No "Current-Version:" header in URL or URL not found'
        #end
        return -1, None, None
    #end
    version = version.lower().strip()
    newversion = newversion.lower().strip()
    if version == newversion:
        if verbose >= VERBOSE_EACHFILE:
            print '       Version identical (%s)'%newversion
        #end
        return 1, version, fp
    else:
        if verbose >= VERBOSE_EACHFILE:
            print '       Versions different (installed: %s, new: %s)'% (version, newversion)
        #end
        return 0, newversion, fp
    #end
#end

def _test():
    print '--- TEST VERBOSE=1'
    print '--- Testing existing and identical version file'
    versioncheck('VersionTestPackage', _TESTDIR+'Version10.txt', '1.0', verbose=1)
    print '--- Testing existing package with new version'
    versioncheck('VersionTestPackage', _TESTDIR+'Version11.txt', '1.0', verbose=1)
    print '--- Testing package with non-existing version file'
    versioncheck('VersionTestPackage', _TESTDIR+'nonexistent.txt', '1.0', verbose=1)
    print '--- Test package with 2 locations, first non-existing second ok'
    versfiles = [_TESTDIR+'nonexistent.txt', _TESTDIR+'Version10.txt']
    versioncheck('VersionTestPackage', versfiles, '1.0', verbose=1)
    print '--- TEST VERBOSE=2'
    print '--- Testing existing and identical version file'
    versioncheck('VersionTestPackage', _TESTDIR+'Version10.txt', '1.0', verbose=2)
    print '--- Testing existing package with new version'
    versioncheck('VersionTestPackage', _TESTDIR+'Version11.txt', '1.0', verbose=2)
    print '--- Testing package with non-existing version file'
    versioncheck('VersionTestPackage', _TESTDIR+'nonexistent.txt', '1.0', verbose=2)
    print '--- Test package with 2 locations, first non-existing second ok'
    versfiles = [_TESTDIR+'nonexistent.txt', _TESTDIR+'Version10.txt']
    versioncheck('VersionTestPackage', versfiles, '1.0', verbose=2)
#end

if __name__ == '__main__':
    _test()
#end

Теперь почти как привычный Lua, только оператор функций называются def. В общем, как я и говорил: Lua - это упрощенный Си интерпретатор, Python - это слегка упрощенный интерпретатор С++, совсем слегка.

Сообщение отредактировал NanoBot-AMK - 12.04.2019, 16:29

[iOrange]

Осталось разобраться с for in это больше всего напрягает.

Аналогичен С++

Код

for (x : some)

[RayTwitty]

Посмотри как улучшился код.

Ты какой-то хренью занимаешься Пиши тогда уж на делфи. Хотя, там же эти, begin-ы

Достаточно посмотреть на "я сам сделаю ...."

Справедливости ради надо сказать, что в питоне можно тоже в одну строчку написать условие и сам блок кода с одним оператором)) Но так редко пишут.

Код

if выражение: оператор

Вообще, как уже сказали выше - для своей задачи свой язык. Где-то хороши плюсы, где-то можно побыстрому наваять на js, а где-то лучше на питоне. Все языки нужны. Есть конечно фриковые истории вроде Брейнфак, но мы их в расчет не берем.

Сообщение отредактировал RayTwitty - 12.04.2019, 16:42

[NanoBot-AMK]

Осталось разобраться с for in это больше всего напрягает.

Аналогичен С++

Код

for (x : some)

Забыл спросить. А как эта хрень работает?

[abramcumner]

Аналогичен С++

Код

for (x : some)

Забыл спросить. А как эта хрень работает?

сиплюсплюсная?
синтаксический сахар для:

Код

for (iterator i = std::begin(some); i != std::end(some); ++i) {
  x = *i;
  ...
}

[iOrange]

синтаксический сахар для:

не только, есть отличный доклад от чувака из Facebook, коротый показывает что `for (x : some)` работает эффективнее.
К тому же, код `for (iterator i = std::begin(some); i != std::end(some); ++i)` плох тем, что `end` вызывается на каждом шаге, а в новом варианте - нет.
К тому же современный вариант работает и для обычных статических массивов.

[abramcumner]

не только, есть отличный доклад от чувака из Facebook, коротый показывает что `for (x : some)` работает эффективнее.

Должно быть без разницы.

К тому же, код `for (iterator i = std::begin(some); i != std::end(some); ++i)` плох тем, что `end` вызывается на каждом шаге, а в новом варианте - нет.

Если хочется поработать оптимизатором, всегда можно писать: for (iterator i = std::begin(some), end = std::end(some); i != end; ++i)

К тому же современный вариант работает и для обычных статических массивов.

std::begin/end как раз и сделали, чтобы работало и с си-массивами.

Сообщение отредактировал abramcumner - 01.05.2019, 00:42

[iOrange]

Должно быть без разницы.

В идеале - да.
Но по факту - вот она реальность vs ожидание:

https://godbolt.org/z/WlVySU

Можно попереключать USE_ITERATORS и посмотреть что генерит msvc.
И сделать выводы.

Я же не из вредности дополнил твой ответ

[abramcumner]

Можно попереключать USE_ITERATORS и посмотреть что генерит msvc.
И сделать выводы.

1. Забавная опция -O3

cl : Command line warning D9002 : ignoring unknown option '-O3'

Видно же, что компилятор не раскрыл ни одного инлайна.
Если поставить, -01 или -02 ассемблер приходит в нормальный вид. И абсолютно одинаковый.

2. Даже с -o3 генерит одно и тоже, если с for (iterator i = std::begin(some), end = std::end(some); i != end; ++i)

3. Ну и в стандарте четко прописано, что эквивалентны, например http://eel.is/c++draft/stmt.ranged

Сообщение отредактировал abramcumner - 01.05.2019, 01:52

[iOrange]

1. Забавная опция -O3

Вот блин, пробовал GCC перед этим, забыл на -Ox поменять

Даже с -o3 генерит одно и тоже, если с for (iterator i = std::begin(some), end = std::end(some); i != end; ++i)

если с

Если хочется поработать оптимизатором, всегда можно писать

C for-range вариантом это получается автоматически.

Ок, я согласен что инфа про разную скорость не есть актуальной, но согласись что с for-range писать "правильный код" стало проще, и не надо париться, что какой-то джун не закеширует `end`

[abramcumner]

Несомненно, я всеми руками и ногами за range-for.

[iOrange]

Несомненно, я всеми руками и ногами за range-for.

Ра уж тут "курилка", давайте обсудим комитет, который умудрился завалить голосование по модулям, и их в С++20 мы не получим
Материться на форуме можно, кстати?

[Mirus]

Материться на форуме можно, кстати?

Все еще нет)

[NanoBot-AMK]

Ассемблер это быстро.

TestSort.asm

Код

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Тест radixsort
;; (с) Intro        13.05.2019
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
.x64
.model    flat, fastcall
option     casemap:none
option     frame:auto
OPTION    LITERALS:ON

APP_WIN64        equ <>;;for windows x64
PATHMASM        textequ    <C:\assemblers\EasyCode>;;настроить пути

%include PATHMASM\Include\Masm\x64\types.inc
%include PATHMASM\Include\Masm\x64\windows.inc
%include PATHMASM\Include\Masm\x64\user32.inc
%include PATHMASM\Include\Masm\x64\kernel32.inc
%include PATHMASM\Include\Masm\x64\msvcrt.inc
%includelib PATHMASM\Lib\x64\user32.lib
%includelib PATHMASM\Lib\x64\kernel32.lib
%includelib PATHMASM\Lib\x64\msvcrt.lib
    
main                    PROTO :qword, :ptr, :ptr

;-------------------------------------------------------------
align_proc MACRO
    align 16
ENDM
;;%echo @CatStr(%sizeof(HGLOBAL))
; -------------
; memory macros
; ------------- or GMEM_ZEROINIT
alloc MACRO bsize:req
    invoke    GlobalAlloc, GMEM_FIXED, bsize
    EXITM <rax>
ENDM

mfree MACRO hndl:req
    invoke    GlobalFree, hndl
ENDM

REQUEST_MEMORY MACRO pMem:req, bsize:req
    push    bsize
    mov        pMem, alloc(bsize)
    pop        rax
    .if (!pMem)
        printf("Out of memory. Memory request: %d bytes\n", rax);;Нехватка памяти. Запрос был %d байт
        exit(1)
    .endif
    EXITM <>
ENDM
;-------------------------------------------------------------
_QWORD struct; (sizeof=8, align=4)
    lo            dword ?; 0
    hi            dword ?; 4
_QWORD ends; 8

;-------------------------------------------------------------
true                equ 1
false                equ 0
NULL                equ 0
_CRLF                equ 13, 10

;-------------------------------------------------------------
.data
g_startTicks        _QWORD {0,0}
g_fTimeTicks        real8 0.0

.const
fConst0p001            real8 0.001
fConst1000p0        real8 1000.0

.code
mainCRTStartup proc
local argc:qword, argv:ptr, environ:ptr, _si:STARTUPINFOA
    mov        _si.cb, sizeof STARTUPINFOA
    invoke    GetStartupInfoA, addr _si
    lea        rdx, _si
    __getmainargs(&argc, &argv, &environ, rdx, rdx)
    exit(main(argc, argv, environ))
mainCRTStartup endp
include utils.asm
;-------------------------------------------------------------
align_proc
GetFrequencyCPU proc uses rdi rsi rbx;(real8)
local ticks:_QWORD, tm:qword
;    while ((tm1 = clock()) == tm0){}
;    ticks = RDTSC();
;    tm0 = tm1;
;;//Определим конец интервала
;    while ((tm1 = clock()) < tm0 + 250){}
;//Определим начало интервала
    xor        rsi, rsi
    xor        rdi, rdi
    clock()
    mov        edi, eax
    .repeat
        clock()
        mov        esi, eax
    .until (esi!=edi)
    rdtsc
    mov        ticks.lo, eax
    mov        ticks.hi, edx
;;//Определим конец интервала
    mov        edi, esi
    lea        ebx, [edi+250]
    .repeat
        clock()
        mov        esi, eax
    .until (esi>=ebx)
;;//вычислим частоту
;    ticks = RDTSC() - ticks;
    rdtsc
    shl        rdx, 32
    or        rax, rdx
    sub        rax, ticks
    mov        ticks, rax
;    return (double)ticks / (double(tm1 - tm0)*(1.0 / CLOCKS_PER_SEC));
    sub        rsi, rdi
    mov        tm, rsi
    fild    ticks
    fild    tm
    fmul    fConst0p001
    fdiv
    ret
GetFrequencyCPU endp

align_proc
Time proc (real8)
local ticks:_QWORD
;return (RDTSC() - g_startTicks)*g_fTimeTicks;
    rdtsc
    sub        eax, g_startTicks.lo
    sbb        edx, g_startTicks.hi
    mov        ticks.lo, eax
    mov        ticks.hi, edx
    fild    ticks
    fmul    g_fTimeTicks
    ret
Time endp

;__inline    int digit(int* n, int k){
;    return (((byte*)n)[k]);
;}
; align_proc
; _radixsortmsd proc uses rsi rdi rbx pBegin:ptr dword, pEnd:ptr dword, d:qword, pTemp:ptr dword
; local sz:dword, tmpEnd:dword, abc[258]:dword, run[256]:dword
;;//    ++num_call;
;;    const int    M = 256;
;;for (int i = 0; i <= M; ++i) abc[i] = 0;
; xor        rdx, rdx
; xor        rax, rax
; mov        rbx, d
; align 16
; .repeat
; mov        abc[edx*4], eax
; mov        abc[edx*4+4], eax
; add        edx, 2
; .until (edx >= 258)
; mov        rdi, pTemp
; mov        rcx, pBegin
; mov        rsi, pEnd
; sub        rsi, 4
; .if (rcx < rsi);for (int* i = pBegin,  *j = pTemp; i < pEnd; ++i, ++j) {
; align 16
; .repeat;// разворот цикла 2
;;*j = *i;                    //копируем pTemp в pBegin
; mov        eax, [rcx]
; mov        edx, [rcx+4]
; mov        [edi], eax
; mov        [edi+4], edx
;;abc[digit(j, i)+1]++;        //подсчитывает кол. букв    //*j
; movzx    eax, byte ptr[rcx+ebx]
; movzx    edx, byte ptr[rcx+4+ebx]
; inc        abc[eax*4+4]
; inc        abc[edx*4+4]
; add        rcx, 8
; add        edi, 8
; .until (rcx >= esi)
; .endif
; .if (rcx < pEnd);хвост массива
; mrm        [edi], [rcx]
; movzx    eax, byte ptr[rcx+ebx]
; inc        abc[eax*4+4]
; .endif
; .for (rcx = 1, edx=0: rcx <= 256: rcx++)
; .if (abc[rcx*4])
; lea        eax, [rcx-1]
; mov        run[edx*4], eax
; inc        edx
; .endif
; mov        eax, abc[rcx*4-4]
; add        abc[rcx*4], eax
; .endfor
; mov        sz, edx
;;//    for (int i = 0; i <= M; ++i)
;;//        abc[i] += pBegin;
; mov        edi, pBegin
;;int *tmpEnd = pTemp + (pEnd-pBegin)
; mov        eax, pEnd
; mov        esi, pTemp
; sub        eax, edi
; add        eax, esi
; mov        tmpEnd, eax
; .for (: esi < tmpEnd: esi+=4)
; movzx    eax, byte ptr[esi+ebx];int i = digit(tmpCur, d)
;;pBegin[abc[i]] = *tmpCur;
; mov        edx, abc[eax*4]
; mov        ecx, [esi]
; mov        [edi+edx*4], ecx
; inc        abc[eax*4];abc[i]++;
; .endfor
; .if (sdword ptr ebx>0)
; mov        edi, pBegin
; .for (esi = 0: esi < sz: esi++)
; mov        edx, run[esi*4]
; mov        eax, abc[edx*4]
; lea        ecx, [edi+eax*4]
; .if (edx)
; mov        edx, abc[edx*4-4]
; _radixsortmsd(&[edi+edx*4], ecx, &[ebx-1], pTemp)
; .else
; _radixsortmsd(edi, ecx, &[ebx-1], pTemp)
; .endif
; .endfor
; .endif
; ret
; _radixsortmsd endp

; align_proc
; radixsortmsd proc uses esi pBegin:ptr dword, pEnd:ptr dword
;;int* pTemp = new int[pEnd - pBegin];
; mov        eax, pEnd
; sub        eax, pBegin
; mov        esi, alloc(eax)
; _radixsortmsd(pBegin, pEnd, 3, esi)
; free    esi
; ret
; radixsortmsd endp

align_proc
check2 proc (byte) uses rbx rdi rsi pBegin1:ptr dword, pEnd1:ptr dword, pBegin2:ptr dword, pEnd2:ptr dword
;pBegin1:rcx, pEnd1:rdx, pBegin2:r8, pEnd2:r9
    mov        rbx, rdx
    mov        al, true
    .for (rsi = rcx: rsi < rbx: rsi+=4)
        mov        edx, [rsi]
        .for (rdi = r8: rdi < r9: rdi+=4)
            .if ([rdi] == edx)
                mov        edx, [r9-4]
                mov        [rdi], edx
                sub        r9, 4
                jmp        continue2
            .endif
        .endfor
        xor        al, al
        .break
    continue2:
    .endfor
    ret
check2 endp

Number MACRO n_plus_num:req, k:req
    EXITM <byte ptr[n_plus_num*4+k]>
ENDM

align_proc
_radixsort proc uses rsi rdi rbx r12 r13 r14 r15 pBegin:ptr dword, pEnd:ptr dword, pTmp:ptr dword
local abc[256]:qword
    mov        r15, rcx;pBegin
    mov        r14, rdx;pEnd
    mov        rsi, r8;pTmp
;k = sizeof(int), M = 256;
    mov        r13, r14;int size_arr = pEnd - pBegin;
    sub        r13, r15
    .for (rbx = 0: rbx < sizeof(dword): rbx++)
        xor        rax, rax
        lea        rdi, abc
        mov        rcx, 256
        rep stosq
        mov        rdi, r14
        mov        rcx, r15
        sub        rdi, 6*4
        .if (rcx < rdi);.for (rcx = pBegin: rcx < rdi: rcx+=8)
            align 16
            .repeat;// разворот цикла на 7
                movzx    rax, Number(rcx+0,rbx);a=Number(j+0, i);
                movzx    rdx, Number(rcx+1,rbx);b=Number(j+1, i);
                movzx    r12, Number(rcx+2,rbx);c=Number(j+2, i);
                movzx    r11, Number(rcx+3,rbx);d=Number(j+3, i);
                movzx    r10, Number(rcx+4,rbx);e=Number(j+4, i);
                movzx    r9,  Number(rcx+5,rbx);f=Number(j+5, i);
                movzx    r8,  Number(rcx+6,rbx);h=Number(j+6, i);
                inc        abc[rax*8];++abc[a];
                inc        abc[rdx*8];++abc[b];
                add        rcx, 7*4
                inc        abc[r12*8];++abc[c];
                inc        abc[r11*8];++abc[d];
                inc        abc[r10*8];++abc[e];
                inc        abc[r9*8];++abc[f];
                inc        abc[r8*8];++abc[h];
            .until (rcx >= rdi)
        .endif
        .while (rcx < r14);// выполняем хвост цикла
            movzx    rax, Number(rcx+0,rbx)
            inc        abc[rax*8]
            add        rcx, 4
        .endw
;.for (rdx = 0: rdx < 255: rdx++)
        lea        rdx, abc[0]
        lea        rcx, abc[255*8]
        align 16
        .repeat
            mov        rax, [rdx]
            add        rdx, 8
            add        [rdx], rax;abc[j+1] += abc[j];
        .until (rdx>=rcx)
        push    r15
        push    r13
        mov        rdi, r14
        add        r15, 2*4
        sub        rdi, 4
        .if (rdi >= r15)
            align 16
;.for (rdi = pEnd, rdi-=4: rdi >= pBegin: rdi-=4)
            .repeat;// разворот цикла на 3
;pTmp[--abc[Number(j, i)]] = *j;
                movzx    rax, Number(rdi-0,rbx);a=Number(j-0, i);
                mov        edx, [rdi-0]
                movzx    r10, Number(rdi-1,rbx);b=Number(j-1, i);
                mov        rcx, abc[rax*8]
                movzx    r11, Number(rdi-2,rbx);c=Number(j-2, i);
                mov        r8d, [rdi-4]
                dec        rcx
                mov        abc[rax*8], rcx
                mov        r9d, [rdi-8]
                mov        r12, abc[r10*8]
                mov        [rsi+rcx*4], edx
                dec        r12
                mov        abc[r10*8], r12
                mov        r13, abc[r11*8]
                sub        rdi, 3*4
                dec        r13
                mov        [rsi+r12*4], r8d
                mov        abc[r11*8], r13
                mov        [rsi+r13*4], r9d
            .until (rdi < r15)
        .endif
        pop        r13
        pop        r15
        .while (rdi >= r15)
            movzx    rax, byte ptr[rdi+rbx]
            mov        edx, [rdi]
            mov        rcx, abc[rax*8]
            dec        rcx
            sub        rdi, 4
            mov        abc[rax*8], rcx
            mov        [rsi+rcx*4], edx
        .endw
;//копируем из pTmp в pBegin
        xchg    rsi, r15;swap(pTmp, pBegin);
        lea        r14, [r15+r13];pEnd = pBegin+size_arr;
    .endfor
;    .if(!check2(r15, r14, rsi, &[rsi+r13]))
;        printf("TEST: ERROR\n")
;    .endif
    ret
_radixsort endp

align_proc
radixsort proc uses rsi pBegin:ptr dword, pEnd:ptr dword
local tmp[512]:dword
    mov        pBegin, rcx;
    mov        pEnd, rdx;
    sub        rdx, rcx;int size_arr = pEnd - pBegin;
    .if (rdx<=sizeof(tmp))
        _radixsort(pBegin, pEnd, &tmp)
    .else
        REQUEST_MEMORY(rsi, rdx)
        _radixsort(pBegin, pEnd, rsi)
        mfree(rsi)
    .endif
    ret
radixsort endp

align_proc
check proc (byte) uses rbx pBegin:ptr dword, pEnd:ptr dword
;pBegin:rcx, pEnd:rdx
    mov        pBegin, rcx
    mov        rbx, rdx
    mov        cl, true
    sub        rbx, 4
    .for (rdx = pBegin: rdx < rbx: rdx+=4)
        mov        eax, [rdx+4]
        .if ([rdx] > eax)
            sub        rdx, pBegin
            shr        rdx, 2
            printf("Incorrect: i=%d\n", rdx)
            xor        cl, cl
            .break
        .endif
    .endfor
    mov        al, cl
    ret
check endp

align_proc
fulltest proc uses rsi rdi rbx r15 size_arr:qword, type_sort:qword
local tm0:real8
    mov        size_arr, rcx
    mov        type_sort, rdx
    rdtsc
    mov        g_startTicks.lo, eax
    mov        g_startTicks.hi, edx
    GetFrequencyCPU()
    fld1
    fdivrp    
    fstp    g_fTimeTicks
;rdtsc
    srand(eax)
;    printf("g_fTimeTicks = %.12f\n", g_fTimeTicks)
    mov        rdi, size_arr
    shl        rdi, 2;*=4;    //размер массива в байтах
    REQUEST_MEMORY(rsi, rdi)
    .for (rbx=0:rbx<size_arr:rbx++);, r15=size_arr, r15--
        rand()
        imul    r15d, eax, 0FFFFh
        xor        eax, eax;rdtsc
        rand()
        add        eax, r15d
        mov        [rsi][rbx*4], eax
;        printf("[%04d] = %08X\n", rbx, eax)
    .endfor
;    printf("OK 1\n")
;//Test
    .switch type_sort
    .case 0
        Time()
        fstp    tm0
        radixsort(rsi, &[rsi+rdi])
;tm0 = Time()-tm0
        Time()
        fsub    tm0
        fstp    tm0
;    .break
    .case 1
        Time()
        fstp    tm0
;        radixsortmsd(rsi, &[rsi+rdi])
;tm0 = Time()-tm0
        Time()
        fsub    tm0
        fstp    tm0
;    .break
    .default
        printf("Unknown type of sorting: %d\n", type_sort);
        jmp        ret_
    .endswitch
;    .for (rbx=0:rbx<size_arr:rbx++)
;        printf("[%04d] = %08X\n", rbx, [rsi][rbx*4])
;    .endfor
;//Print result
    fld        fConst1000p0
    fmul    tm0
    fstp    tm0
    .if (check(rsi, &[rsi+rdi]))
        printf("TEST: type_sort[%d], size array[%d], time = %.3f msec\n", type_sort, size_arr, tm0)
    .else
        printf("TEST: Incorrect. time = %.3f msec\n", tm0)
    .endif
ret_:
    mfree(rsi)
    ret
fulltest endp

align_proc
main proc frame argc:qword, argv:ptr, envp:ptr
local size_arr:qword, type_sort:qword
;argc:rcx, argv:rdx, envp:r8
    mov        rsi, rdx
    .if (rcx!=3)
        printf("Usage: TestSort size_arr type_sort\n");
        jmp        ret_
    .endif
    Str2Int([rsi+1*8], &size_arr)
    Str2Int([rsi+2*8], &type_sort)
    .if (sqword ptr size_arr<0)
        printf("Error: size_arr is negative\n")
        mov        rax, 1
        ret
    .endif
    fulltest(size_arr, type_sort)
ret_:
    xor        rax, rax
    ret
main endp

end mainCRTStartup

Очень быстрая сортировка.
А теперь попробуй сделать быстрей.
Нет, сделай реально быстрей.
ЗЫ

utils.asm

Код

align_proc
str_len proc
; <ecx>str0:LPSTR
    xor        rax, rax
    .if (rcx)
        push    rdi
        mov        rdi, rcx
        or        rcx, -1;=-1
        repne scasb
        not        rcx
        lea        rax, [rcx-1]
        pop        rdi
    .endif
    ret
str_len endp

align_proc
Str2Int proc (byte) uses rsi rdi rbx str0:ptr, param:ptr
;rcx    str0
;rdx    param
    mov        r15, rdx
; (rsi)str0
    mov        rsi, rcx;=str0
;;;    printf$("str0[%s] param=%d\n", rsi, param)
    .if (rsi==NULL)
        jmp        exit_fail
    .endif
    ASSUME    rsi:ptr byte, rdi:ptr byte
; (rbx)digit_capacity
    xor        rbx, rbx
; (rax)size0=strlen(str0);
    mov        rcx, rsi
    call    str_len
    lea        rdi, [rsi+rax-1]
;-------------------
    .if (rax>1 && [rsi+0]=='-')
        mov        r8b, true
        .repeat
            dec        rax
            inc        rsi
        .until ([rsi]!=' ' && [rsi]!=9); минус можно разделять пробелом или табулятором
    .else
        mov        r8b, false
    .endif
    .if (rax>2 && [rsi+0]=='0' && ([rsi+1]=='x' || [rsi+1]=='X'));// style C, 0xFFFF
        add        rsi, 2
        mov        bl, 16
    .elseif (rax>1 && [rsi+0]=='$')                ;// style Pascal, $FFFF
        inc        rsi
        mov        bl, 16
    .elseif (rax>1 && ([rdi]=='h' || [rdi]=='H'));// style Assemler, FFFFh
        dec        rdi
        mov        bl, 16
    .elseif (rax>1 && ([rdi]=='o' || [rdi]=='O'))
        dec        rdi
        mov        bl, 8
    .elseif (rax>1 && ([rdi]=='b' || [rdi]=='B'))
        dec        rdi
        mov        bl, 2
    .elseif (rax>0);// десятичная система, 9999
        mov        bl, 10
    .else
        jmp        exit_fail
    .endif
; (rcx)num = 0;
    xor        rcx, rcx
; (rdx)zzz = 1;
    xor        rdx, rdx
    inc        rdx
; for(; it>=it_end; --it)
    .while (rdi>=rsi)
; int        rax, al = digit, bt;
; al = *rsi++
        movzx    rax, [rdi]
        sub        al, '0'
        .if (al>9)
            add        al, '0'-1
            and        al, 0DFh
            sub        al, 'A'-10-1
        .endif
        .if (rax>=rbx);(digit>=digit_capacity)
            jmp        exit_fail
        .endif
;num += digit*zzz;
        imul    rax, rdx
        add        rcx, rax
;zzz *= digit_capacity;
        imul    rdx, rbx
        dec        rdi
    .endw
    .if (r8b)
        neg        rcx
    .endif
;param^:=num;
;;;    mov        rax, param
    mov        [r15], rcx
;// успешно
; return true
    mov        al, 1
    jmp        exit_func
exit_fail:
;// преобразование не удалось!
; return false;
    xor        al, al
exit_func:
    ASSUME    rsi:nothing, rdi:nothing
    ret
Str2Int endp

Да без этой утилиты не получится собрать файл.
Ну и батник сам

makeit.bat

Код

@echo off

if exist TestSort.obj del TestSort.obj
if exist TestSort.exe del TestSort.exe

C:\Projects\UASM-master\Win32\Release\UASM.exe -win64 -c TestSort.asm
C:\assemblers\buildx64\bin64\Link.exe /SUBSYSTEM:CONSOLE /machine:x64  /LARGEADDRESSAWARE:NO TestSort.obj
rem ..\..\bin\PoLink.exe

if exist TestSort.obj del TestSort.obj

pause

Придётся поднапрячься скачал указаный ассемблер и настроить пути.
ЗЫЫ
Ой забыл, батник для запуска.

Test.bat

Код

@echo off

TestSort 10 0
TestSort 64 0
TestSort 100 0
TestSort 128 0
TestSort 1000 0
TestSort 10000 0
TestSort 100000 0
TestSort 1000000 0
TestSort 10000000 0
TestSort 100000000 0

pause

ЗЫЫЫ
Это к теме, зачем нужен ассемблер?
Порой это одна тема, чтобы создать реально быстрый код, быстрей не бывает.
ЗЫЫЫЫ
Да табулятор у меня 4 пробела, если что.

Сообщение отредактировал NanoBot-AMK - 17.05.2019, 03:09

[abramcumner]

Очень быстрая сортировка.
А теперь попробуй сделать быстрей.
Нет, сделай реально быстрей.

А где результаты замеров-то? Где сравнение с квиксорт, стд:сорт, с тем же радиксом на с/с++?
А то может твой ассемблер в хвосте плетется.
Где сортировка строк/флоатов? В движке они понужней будут.

Ассемблер это быстро.

Пока не видно.

Это к теме, зачем нужен ассемблер?

И все-таки зачем? Любой компилятор сгенерит код быстрее выложенного.

[cjayho]

Если хочется поработать оптимизатором, всегда можно писать: for (iterator i = std::begin(some), end = std::end(some); i != end; ++i)

может стать источником трудноуловимых багов, если содержимое массива поменялось во время перебора.

Впрочем, в Lua есть метатаблицы, а в Питоне нормальный ООП/классы из коробки

насколько я знаю, луа полностью объектно-ориентированный, до мозга костей. все типы данных там это объекты.

Зы. http://lua-users.org/wiki/SimpleLuaClasses

Сообщение отредактировал cjayho - 17.05.2019, 14:45

[atanda]

все типы данных там это объекты.

Точнее говоря всё в луа это таблицы. Даже в каком-то смысле простае типы данных.