रणनीति कार्यक्रम एक साथ निष्पादित होने दें, और जावास्क्रिप्ट रणनीति के लिए प्रणाली के नीचे बहु-थ्रेड समर्थन जोड़ें

जब जावास्क्रिप्ट भाषा का उपयोग करके एफएमजेड पर रणनीतियों का विकास करते हैं, क्योंकि रणनीति वास्तुकला को सर्वेक्षण किया जाता है।exchange.Gofunction का उपयोग कुछ इंटरफेस को समवर्ती कॉल करने के लिए किया जाता है, ताकि कुछ समवर्ती परिदृश्यों की आवश्यकताओं को पूरा किया जा सके। लेकिन यदि आप संचालन की एक श्रृंखला करने के लिए एक एकल थ्रेड बनाना चाहते हैं, तो यह असंभव है। उदाहरण के लिए पायथन भाषा की तरह,threadingकुछ समवर्ती डिजाइन करने के लिए पुस्तकालय.

इस आवश्यकता के आधार पर, एफएमजेड प्लेटफॉर्म ने सिस्टम की निचली परत को अपग्रेड किया है। जावास्क्रिप्ट भाषा में सच्चे मल्टीथ्रेडिंग समर्थन को भी जोड़ा गया है। विस्तृत सुविधाओं में शामिल हैंः

• कस्टम फ़ंक्शन को एक साथ निष्पादित करने के लिए थ्रेड बनाएं.
• इंटर-थ्रेड संचार।
• साझा किए गए थ्रेडों के बीच संग्रहीत चर.
• संसाधनों को पुनः प्राप्त करने और निष्पादन परिणाम वापस करने के लिए निष्पादन समाप्त करने के लिए थ्रेड की प्रतीक्षा करें.
• बलपूर्वक धागे को समाप्त करें और संसाधनों को पुनः प्राप्त करें।
• समवर्ती थ्रेड निष्पादन फ़ंक्शन में वर्तमान थ्रेड आईडी प्राप्त करें.

आगे, मैं आपको प्रत्येक फ़ंक्शन को एक-एक करके समझने के लिए ले जाऊंगा।

एक साथ कस्टम फ़ंक्शन निष्पादित करने के लिए थ्रेड बनाएँ

..__Threadfunction एक थ्रेड बना सकता है और एक साथ एक फ़ंक्शन निष्पादित कर सकता है. उदाहरण के लिए, आपको एक समवर्ती फ़ंक्शन बनाने की आवश्यकता हैfunc1, क्या करता हैfunc1हम इसे 0 से 9 तक जमा करने दे सकते हैं। क्रमिक जमा होने की प्रक्रिया को देखने के लिए, हम प्रत्येक बार ठहराव करने के लिए func1 फ़ंक्शन में for लूप का उपयोग करते हैं (स्लीप फ़ंक्शन का उपयोग निश्चित संख्या में मिलीसेकंड के लिए सोने के लिए किया जाता है) एक निश्चित अवधि के लिए।

function func1(sleepMilliseconds) {
    var sum = 0 
    for (var i = 0 ; i < 10 ; i++) {
        sum += i 
        Sleep(sleepMilliseconds)
        Log("sum:", sum)
    }
    
    return sum
}

function main() {
    // Use the __Thread function to create a thread concurrently, and the parameter 200 is the parameter of the func1 function,
    // If the func1 function has multiple parameters, here we pass the corresponding parameters.
    var thread1Id = __Thread(func1, 200)
    
    // Here we need to wait for the execution result of the thread whose thread Id is thread1Id, otherwise all threads will be released directly after the main function is executed.
    var ret = __threadJoin(thread1Id)
    Log("ret:", ret)
}

व्यावहारिक अनुप्रयोगों में, हम http अनुरोध एक साथ इस तरह कर सकते हैंः

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))
    })
}

संसाधनों को पुनः प्राप्त करने के लिए थ्रेड निष्पादन के अंत की प्रतीक्षा करें और निष्पादन परिणाम लौटाएं

उपरोक्त उदाहरण में, हम का उपयोग किया__threadJoinअंत में मुख्य फ़ंक्शन में समारोह के समवर्ती धागे निष्पादन समाप्त करने के लिए प्रतीक्षा करने के लिए। चरretरिटर्न मान प्राप्त करता है__threadJoinसमारोह, और हम वापसी मूल्य मुद्रित, हम समवर्ती धागे निष्पादन के विशिष्ट परिणाम देख सकते हैं।

// id: thread ID, terminated: whether it was forced to stop, elapsed: time-consuming (nanoseconds), ret: the return value of the thread execution function
ret: {"id":1,"terminated":false,"elapsed":2004884301,"ret":45}

बलपूर्वक धागे को समाप्त करें और संसाधनों को पुनः प्राप्त करें

function func1(sleepMilliseconds) {
    var sum = 0 
    for (var i = 0 ; i < 10 ; i++) {
        sum += i 
        Sleep(sleepMilliseconds)
        Log("sum:", sum)
    }
    
    return sum
}

function main() {
    var thread1Id = __Thread(func1, 200)
    Sleep(1000)
    retThreadTerminate = __threadTerminate(thread1Id)
    Log(retThreadTerminate)   // true
}

हम अभी भी उदाहरण का उपयोग कर रहे हैं, एक धागा बनाने के बाद, आप 1 सेकंड के लिए प्रतीक्षा करने के बाद धागे के निष्पादन को जबरन समाप्त कर सकते हैं।

इंटर-थ्रेड संचार

इंटर-थ्रेड संचार मुख्य रूप से__threadPostMessageकार्य और__threadPeekMessageचलो निम्नलिखित सरल उदाहरण पर एक नज़र डालेंः

function func1() {
    var id = __threadId()
    while (true) {
        var postMsg = "Message from thread function func1" with "from id:" + id + 
        __threadPostMessage(0, postMsg)              // Send a message to the main thread
        var peekMsg = __threadPeekMessage(0)         // Receive messages from the main thread
        Log(peekMsg)
        Sleep(5000)
    }
}

function main() {
    var threadId = __Thread(func1)
    
    while (true) {
        var postMsg = "Messages from the main function of the main thread"
        __threadPostMessage(threadId, postMsg)
        var peekMsg = __threadPeekMessage(threadId)
        Log(peekMsg, "#FF0000")                     // #FF0000 , Set the log to red for distinction
        Sleep(5000)
    }
}

..__threadPostMessagefunction का उपयोग किसी थ्रेड को संदेश भेजने के लिए किया जाता है। पहला पैरामीटर विशिष्ट थ्रेड की आईडी है जिसे भेजा जाना है, और दूसरा पैरामीटर संदेश भेजा जाना है, जो एक स्ट्रिंग, एक मान, एक सरणी, या एक JSON ऑब्जेक्ट और इतने पर हो सकता है। संदेशों को समवर्ती थ्रेड कार्यों में मुख्य थ्रेड को भेजा जा सकता है, और मुख्य थ्रेड की आईडी 0 के रूप में परिभाषित की गई है।

..__threadPeekMessagefunction का उपयोग किसी निश्चित थ्रेड द्वारा भेजे गए संदेश की निगरानी करने के लिए किया जाता है। पहला पैरामीटर थ्रेड की विशिष्ट आईडी की निगरानी करना है। दूसरा पैरामीटर टाइमआउट समय (मिलीसेकंड में) सेट कर सकता है, या इसे -1 पर सेट किया जा सकता है, जिसका अर्थ है अवरोधित करना, और यह तब तक वापस नहीं आएगा जब तक कि कोई संदेश न हो। हम समवर्ती थ्रेड फ़ंक्शन में वर्तमान थ्रेड को मुख्य थ्रेड द्वारा भेजे गए संदेश को सुन सकते हैं, और मुख्य थ्रेड की आईडी को 0 के रूप में परिभाषित किया गया है।

बेशक, मुख्य धागे के साथ संवाद करने वाले समवर्ती धागे को छोड़कर। समवर्ती धागे भी एक दूसरे के साथ सीधे संवाद कर सकते हैं।

समवर्ती थ्रेड निष्पादन फ़ंक्शन में वर्तमान थ्रेड आईडी प्राप्त करें

उपरोक्त उदाहरण में,var id = __threadId()उपयोग किया जाता है, और__threadId()फ़ंक्शन वर्तमान थ्रेड की आईडी प्राप्त कर सकता है.

साझा किए गए थ्रेडों के बीच संग्रहीत चर

थ्रेडों के बीच संचार के अलावा, साझा चर का उपयोग बातचीत के लिए भी किया जा सकता है।

function testFunc() {
    __threadSetData(0, "testFunc", 100)   // Stored in the current thread environment, key-value pair testFunc : 100
    Log("testFunc execution completed")
}

function main() {
    // threadId is 1, the created thread with threadId 1 will be executed first, as long as the thread resources are not reclaimed, the variables stored locally in the thread will be valid
    var testThread = __Thread(testFunc)
    
    Sleep(1000)

    // export in main, get testFunc: 100
    Log("in main, get testFunc:", __threadGetData(testThread, "testFunc"))   // Take out the value whose key name is testFunc
}

उपरोक्त सभी कार्यों का एक सरल प्रदर्शन है। चलो थोड़ा अधिक जटिल परीक्षण उदाहरण देखें।

मूल बहु-थ्रेडेड जावास्क्रिप्ट और WASM के बीच प्रदर्शन तुलना

यह परीक्षण रणनीति पताःhttps://www.fmz.com/strategy/401463

एक नज़र में, आप यह नहीं जान सकते कि यह परीक्षण रणनीति क्या करती है। इससे कोई फर्क नहीं पड़ता, आइए इसे समझाते हैं। सबसे पहले, आइए जानें कि WASM क्या है।

Then the test strategy is to compare the execution efficiency of wasm and javascript, but when comparing, the two execution methods can be executed successively, and the time-consuming of each is counted. It is also possible to allow the two execution methods to execute concurrently, and the statistics are time-consuming. Now that the underlying concurrency implementation of the JavaScript language strategy has been supported, the test strategy uses a concurrent method to compare naturally and compare the execution speed of the same algorithm.

- Algorithm of C language version, fib function

// सी भाषा में फिबोनाची संख्याओं का पुनरावर्ती एल्गोरिथ्म int fib ((int f) { यदि (f < 2) f लौटाता है; लौटाता है fib ((f - 1) + fib ((f - 2); }

- JavaScript language version of the algorithm, fib function

// एक ही फाइबोनैचि संख्याओं के लिए एक पुनरावर्ती एल्गोरिथ्म, जावास्क्रिप्ट में लिखा फ़ंक्शन fib ((f) { यदि (f < 2) f लौटाता है लौटाता है fib ((f - 1) + fib ((f - 2) }

It can be seen that the logic of the two fib function algorithms is exactly the same. The following is the source code of the test strategy:

मुख्य फंक्शन // यह कोड देखने के लिए आसान बनाने के लिए, मैं सीधे निम्नलिखित कोड पर टिप्पणी लिखते हैंः चलो चक्र = 100 // परीक्षण लूप 100 बार निष्पादित करता है let input = 30 // पैरामीटर है कि एल्गोरिथ्म fib समारोह के लिए पारित किया जाएगा थ्रेड = [ __Thread(function(cycle, input) { // फ़ंक्शन fib के जावास्क्रिप्ट संस्करण का उपयोग करके गणना करने के लिए एक थ्रेड एक साथ बनाया जाता है फ़ंक्शन fib(f) { // परीक्षण के लिए इस्तेमाल किया विशिष्ट एल्गोरिथ्म, fib फ़ंक्शन यदि (f < 2) f लौटाता है लौटाता है fib ((f - 1) + fib ((f - 2) } let ret = 0 for (let i = 0; i < cycle; i++) { // 100 बार लूप के लिए ret = fib(input); // जावास्क्रिप्ट भाषा के fib फ़ंक्शन को कॉल करें लॉग ((जावास्क्रिप्ट प्रगतिः , i) } रिटर्न जावास्क्रिप्ट फ़ाइब: + ret }, चक्र, इनपुट),

    __Thread(function(cycle, input) {           // Run a thread concurrently to perform calculations using the wasm version of the fib function
        let data = 'data:hex,0061736d010000000186808080000160017f017f0382808080000100048480808000017000000583808080000100010681808080000007908080800002066d656d6f727902000366696200000aa480808000019e80808000000240200041024e0d0020000f0b2000417f6a10002000417e6a10006a0b'
        let m = wasm.parseModule(data)          // The data variable is the hex string of the wasm-encoded C language fib function, and the wasm model m is created using wasm.parseModule

        let instance = wasm.buildInstance(m, {  // Model instantiation, allocate a certain stack space
            stack_size: 65 * 1024 * 1024,
        })

        let ret = 0
        for (let i = 0; i < cycle; i++) {                // loop for 100 times 
            ret = instance.callFunction('fib', input)    // Calling the fib function code in the wasm instance is equivalent to calling the int fib(int f) function 
            Log("wasm progress: ", i)
        }

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

// The elements in the threads array are the IDs returned by the __Thread function
threads.forEach(function(tid) {
    let info = __threadJoin(tid)                         // Use the __threadJoin function to wait for two concurrent threads to execute and get the execution result
    Log('#'+tid, info.ret, 'elapsed:', info.elapsed / 1e6, "#ff0000")   // output execution result
})

}

Simply put, WASM is a program code with higher execution efficiency. In the example, we convert the c language code of "Fibonacci number recursive algorithm" into WASM. The process is like this:

1. Compile a piece of C language function code into wasm code.

We can use the website to convert: https://wasdk.github.io/WasmFiddle/

// सी भाषा में फिबोनाची संख्याओं का पुनरावर्ती एल्गोरिथ्म int fib ((int f) { यदि (f < 2) f लौटाता है; लौटाता है fib ((f - 1) + fib ((f - 2); }

2. Further encode the wasm code into a hex string.

The following commands can be used:

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

The encoded hex string is ```let data = 'data:hex,0061736d0100000001868...``` in the code.

3. Then parse it into a wasm model through the function ```wasm.parseModule()``` integrated by FMZ.

4. Create a wasm model instance through the function ```wasm.buildInstance()``` integrated by FMZ.

5. Then call the ```fib``` function in this wasm model instance, namely: ```ret = instance.callFunction('fib', input)```.

## Create a real bot to run the test
This test strategy can only be used for real bot testing. JavaScript multi-threading functions do not support backtesting so far.

```wasm``` and ```JavaScript``` execution comparison, the final execution results:

2023-03-06 11:00:33 सूचना # 2 wasm fib: 832040 समाप्तः 13283.773019 2023-03-06 11:00:33 सूचना #1 जावास्क्रिप्ट फ़ाइबः 832040 समाप्तः 21266.326974 It seems thatwasm` कम समय लेता है और बेहतर है।