Comparação de desempenho do JavaScript nativo com o WASM

Autora:Inventor de quantificação, Data: 23 de Fevereiro de 2023 17:35:24
Tags:Multidireção

Os inventores quantificaram a tentativa de fazer com que o Javascript suportasse threads verdadeiramente significativos a partir do nível inferior nativo, e incorporaram a funcionalidade WASM. Abaixo está uma demonstração para os mais recentes hosts poderem experimentar. Esta função é uma função Worker não JavaScript, que pode ser usada para se comunicar entre si dentro de vários fios ou para se comunicar com o principal.

A tradução para o idioma C pode ser feita a partir deste site:https://wasdk.github.io/WasmFiddle/

O código da linguagem C compilado como wasm é:

int fib(int f) {
  if (f < 2) return f;
  return fib(f - 1) + fib(f - 2);
}

Compilar e baixar o arquivo wasm e convertê-lo em string hex em Python

python -c "print('data:hex,'+bytes.hex(open('program.wasm','rb').read()))"

Substitua o conteúdo por trás das variáveis no código.

__Thread ((função, argumentos...)

Criar um thread e retornar o threadtid, funções de funções principais de thread aceites devem completar todo o código de funções dentro da função do thread, não suporta referências a outras funções de fechamento, todas as APIs podem ser chamadas dentro do thread, mas não outras funções personalizadas pelo usuário

Um exemplo simples:

let tid = __Thread(function(x, y) {
    return x + y
}, 1, 2)
Log(__threadJoin(tid))

Exemplos de solicitações de múltiplos fios:

function main() {
    let threads = [
        "https://www.baidu.com",
        "https://www.163.com"
    ].map(function(url) {
        return __Thread(function(url) {
            Log("GET", url)
            return HttpQuery(url)
        }, url)
    })
    threads.forEach(function(tid) {
        Log(__threadJoin(tid))
    })
}

Variáveis de armazenamento local do thread

Suporte para o armazenamento local de variáveis de threads para facilitar o compartilhamento de dados que não são armazenados em threads__threadJoinEsperar que a saída seja bem sucedida ou__threadTerminateEm caso de cessação

__threadGetData(tid, key)
__threadSetData(tid, key, value)

tid é 0 para indicar o atual thread, value não especificado para indicar a chave de exclusão, suporte a variáveis compartilhadas de acesso mútuo entre os threads, o valor deve ser variável serializável

Comunicação por fio

__threadPostMessage(tid, msg) // 向指定线程发送消息, tid为0是向主线程即当前主函数发送, 在线程内部调用指向主线程回复消息, 该消息可以被EventLoop捕获
__threadPeekMessage(tid, timeout) // 从指定线程接收消息, 如果不指定timeout(毫秒)就一直等待, tid为0指等待主线程的消息

Junta-te a ele.

Especificar o timeout para especificar o tempo de espera que não pode ser especificado, ou seja, esperar até o final do thread, retornar com sucesso uma estrutura que contém o valor de retorno da função e recuperar recursos, a estrutura é a seguinte:

{
    id: tid, // 线程id
    elapsed: 1111, // 线程的运行时间(纳秒)
    terminated: false, // 线程是否被强制结束 
    ret: 123, // 线程函数的返回值
}

Se o timeout retornar indefinido

__threadTerminate ((tid)

Forçar o término do thread e recuperar recursos (não é possível usar mais __threadJoin até o término)

Cuidado.

A função __Thread não suporta referências a variáveis fora da função (para operar em ambientes isolados), e a referência a variáveis externas irá compila-la com um fracasso.

function main() {
    let cycle = 100
    let input = 30
    let threads = [
        __Thread(function(cycle, input) {
            function fib(f) {
                if (f < 2) return f
                return fib(f - 1) + fib(f - 2)
            }
            let ret = 0
            for (let i = 0; i < cycle; i++) {
                ret = fib(input);
                Log("javascript progress: ", i)
            }
            return 'javascript fib: ' + ret
        }, cycle, input),
        
        __Thread(function(cycle, input) {
            let data = 'data:hex,0061736d010000000186808080000160017f017f0382808080000100048480808000017000000583808080000100010681808080000007908080800002066d656d6f727902000366696200000aa480808000019e80808000000240200041024e0d0020000f0b2000417f6a10002000417e6a10006a0b'
            let m = wasm.parseModule(data)

            let instance = wasm.buildInstance(m, {
                stack_size: 65 * 1024 * 1024,
            })

            let ret = 0
            for (let i = 0; i < cycle; i++) {
                ret = instance.callFunction('fib', input)
                Log("wasm progress: ", i)
            }

            return 'wasm fib: ' + ret
        }, cycle, input)
    ]

    threads.forEach(function(tid) {
        let info = __threadJoin(tid)
        Log('#'+tid, info.ret, 'elapsed:', info.elapsed / 1e6, "#ff0000")
    })
}

Relacionados

Mais.

EsfregaçoCorreção de erro ReferenceError: '__Thread' is not defined at main (FILE:5)

Inventor de quantificaçãoAtualizar para o mais recente administrador