ការកាត់បន្ថយការសម្តែង JavaScript ជាមួយនឹង Rust និង N-API: ការបង្កើតឧបករណ៍កាត់បន្ថយរូបភាពល្បឿនលឿន

The Moment JavaScript បានកាត់បន្ថយការអនុវត្តរបស់ខ្លួន ការធ្វើតេស្ត regression Visual គឺជាបញ្ហាមួយដែលមានភាពងាយស្រួលនៅពេលដែលអ្នកធ្វើតេស្តវាត្រូវបានកាត់បន្ថយវាត្រូវបានកាត់បន្ថយវាត្រូវបានកាត់បន្ថយវាត្រូវបានកាត់បន្ថយវាត្រូវបានកាត់បន្ថយវាត្រូវបានកាត់បន្ថយវាត្រូវបានកាត់បន្ថយវាត្រូវបានកាត់បន្ថយវាត្រូវបានកាត់បន្ថយវាត្រូវបានកាត់បន្ថយវាត្រូវបានកាត់បន្ថយវាត្រូវបានកាត់បន្ថយ។ ប្រព័ន្ធប្រតិបត្តិការ JavaScript មានឧបករណ៍ល្អឥតខ្ចោះសម្រាប់ការនេះ។ វាគឺជាសៀវភៅដែលបានសរសេរយ៉ាងល្អ។ ប៉ុន្តែ "រហ័សខ្លាំងណាស់" បានចាប់ផ្តើមកាត់បន្ថយនៅពេលដែលរូបថតរបស់អ្នកមានកំណត់ 2K / 4K, នៅពេលដែលអ្នកកំពុងធ្វើការប្រៀបធៀបធៀបធៀបធៀបទូទាត់ទូទាត់នៅលើរាប់ទំព័រ, និងនៅពេលដែលរាល់មីលីសប្តាហ៍នៅក្នុង CI មានតម្លៃមួយគត់។ ហ្គេម Pixel ខ្ញុំចង់បង្កើតអ្វីដែលមានប្រសិទ្ធិភាពជាងមុន។ ប្រតិបត្តិការ BlazeDiff Algorithm គំនិតដំបូងរបស់ខ្ញុំគឺដើម្បីផ្លាស់ប្តូររូបថតទៅក្នុងប្លុកនិងបង្វិលតំបន់ដែលមិនត្រូវបានផ្លាស់ប្តូរទាំងអស់។ លក្ខណៈពិសេសជាច្រើននៃរូបថត UI ក្នុងរវាងការដំណើរការគឺជា 95% + សាមញ្ញ។ ហេតុអ្វីបានជាការ scan 18 លានប៉ះពាល់សម្រាប់ការផ្លាស់ប្តូរពណ៌ប៊ូតុង? អ្នកមិនអាចដឹងអំពីការផ្លាស់ប្តូរប្លុកឬទេដោយមិនទាក់ទងនឹងកែច្នៃរបស់វា។ ប៉ុន្តែអ algorithms ទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំ ប៉ុន្តែការធ្វើការដែលមានតម្លៃគឺគ្រាន់តែនៅលើ 1-5% នៃប្លុកដែលពិតប្រាកដមានគុណភាពខុសគ្នា។ : ប្រព័ន្ធ ប្រតិបត្តិការ Double-Pass Architecture Cold Pass: ទាញយកប្លុកទាំងអស់ដោយប្រើការប្រៀបធៀបកម្រិតថ្លៃ។ ប្រសិនបើមានបីកែលណាមួយនៅក្នុងប្លុកណាមួយមានការផ្សេងគ្នានេះប្រសើរឡើង។ ប្រសិនបើប្លុកទាំងអស់គឺប្រសើរឡើងវិញ។ ប្រសិនបើប្លុកទាំងអស់គឺប្រសើរឡើងវិញប្រសើរឡើងវិញប្រសិនបើប្លុកទាំងអស់គឺប្រសើរឡើងវិញប្រសិនបើប្លុកទាំងអស់គឺប្រសើរឡើងវិញប្រសិនបើប្លុកទាំងអស់គឺប្រសើរឡើងវិញ។ ការដោះស្រាយរហ័ស: ការដោះស្រាយរហ័សប៉ុណ្ណោះនៅលើប្លុកដែលបានផ្លាស់ប្តូរ។ ការដោះស្រាយរហ័សរហ័សពេញលេញ: YIQ color delta calculation, anti-aliasing neighborhood detection, diff / AA color output rendering ។ នេះគឺជាការងារដែលមានតម្លៃហើយវាគ្រាន់តែឆ្លងកាត់ផ្នែកមួយតូចនៃរូបភាពដែលបានផ្លាស់ប្តូរពិតប្រាកដ។ ទំហំទំហំ Blocks ជាមួយនឹងទំហំរូបភាព: export function calculateOptimalBlockSize( width: number, height: number, ): number { const area = width * height; const scale = Math.sqrt(area) / 100; const rawSize = 16 * Math.sqrt(scale); // More efficient power-of-2 rounding using bit operations const log2Val = Math.log(rawSize) * LOG2_E; return 1 << Math.round(log2Val); // Bit shift instead of Math.pow(2, x) } រូបភាពតូចទទួលបាន 8×8 ប្លុក. រូបថត 4K ទទួលបាន 128×128 ប្លុក. គំរូនេះធានាថាមានប្លុកគឺជាការគ្រប់គ្រងនៃការពីរ (cache-line friendly) និងថាមានកម្រិតថ្នាំជាមួយនឹងតំបន់រូបថត។ សម្រាប់រូបថត 5600×3200 ជាមួយនឹងការផ្លាស់ប្តូរប្រព័ន្ធប្រតិបត្តិការទូទាត់តូចអ្នកអាចមានការផ្លាស់ប្តូរ 2,000 ប្លុករួមទាំងប៉ុន្តែមានការផ្លាស់ប្តូរតែ 15 ។ ការផ្លាស់ប្តូររហ័សដែលធ្វើការគណនានៃការទូទាត់ដែលមានតម្លៃទូទាត់មានតម្លៃតិចជាង 1% នៃរូបថត។ ការផ្លាស់ប្តូររហ័សរបស់ 99% បានទទួលបានការផ្លាស់ប្តូររហ័សយ៉ាងឆាប់រហ័សហើយបានផ្លាស់ប្តូរ។ នៅពេលដែលមិនមានការផ្លាស់ប្តូរណាមួយ, ការផ្លាស់ប្តូររហ័សនឹងបាត់បន្ថយការផ្លាស់ប្តូរទាំងអស់ដោយឥឡូវនេះ។ ការអនុវត្តកម្មវិធី JavaScript កំណែដំបូងនៃ ការរចនាសម្ព័ន្ធប្លុកដែលមានមូលដ្ឋានបានផ្តល់នូវការឆាប់រហ័សសំខាន់ជាងការសរសេរបន្ទាត់នៃ pixelmatch, ប៉ុន្តែ JavaScript ដោយខ្លួនឯងបានក្លាយជាការបង្វិលបន្ទាប់។ ប្លាស្ទិច ខ្ញុំបានធ្វើដំណើរតាមរយៈជំហានកម្រិតអតិបរមាជាច្រើន: . The image data is / , but the YIQ color comparison needs to work on 32-bit RGBA pixels. Casting to via lets you read a full pixel in one operation instead of four-byte reads. Typed arrays everywhere Uint8Array Uint8ClampedArray Uint32Array DataView . Pre-allocating the array, avoiding intermediate buffers, reusing output buffers across comparisons. Minimizing allocations changedBlocks . Before doing any work, check if the two image buffers are literally the same reference. This catches the “nothing changed” case in constant time: Buffer identity check Buffer.compare( Buffer.from(image1.data.buffer), Buffer.from(image2.data.buffer) ); . Keeping the hot inner loop as tight as possible with no function calls, no conditionals that the branch predictor can't handle, and no unnecessary property lookups. Loop structure ការអនុវត្ត JavaScript បានបញ្ចប់យ៉ាងឆាប់រហ័សជាងការ pixelmatch ក្នុងប្រមាណ 1.5 ដងនិងរហូតដល់ទៅ 88% នៅលើរូបថតដូចគ្នា។ លក្ខណៈពិសេសពីគោលដៅនៅលើ M1 Max: Benchmark pixelmatch BlazeDiff Improvement 4K image (different) 302.29ms 211.92ms 29.9% 4K image (identical) 19.18ms 2.39ms 87.5% Full page (different) 331.94ms 92.77ms 72.1% Full page (identical) 63.18ms 7.68ms 87.8% រូបភាព 4K (ប្រភេទផ្សេងទៀត) 302.29 មីនាទី 219 មីនាទី 29.9 លទ្ធផល រូបភាព 4K (ដូចគ្នា) 18 ល្ងាច 2.39 មីនាទី លទ្ធផល 85% ទំព័រទាំងអស់ (ប្រភេទផ្សេងទៀត) លទ្ធផល 331.94ms លក្ខខណ្ឌ 92.77ms 72.1 លទ្ធផល ទំព័រពេញលេញ (ដូចគ្នា) 18 មីនាទី 7,68 មីនាទី 87.8 លទ្ធផល ការធ្វើឱ្យប្រសើរឡើងដោយផ្អែកលើប្លុកបានធ្វើការយ៉ាងច្បាស់។ ប៉ុន្តែ 211ms សម្រាប់ការផ្លាស់ប្តូរ 4K មួយតែមានរយៈពេលវែងនៅពេលដែលអ្នកកំពុងធ្វើដំណើរការរបស់ពួកគេ។ ហើយនៅពេលនេះអ algorithm របស់ខ្លួនបានធ្វើឱ្យប្រសើរឡើង។ ពេលវេលាដំណើរការ JavaScript គឺជាការផ្លាស់ប្តូរ។ ការសាកល្បងនៃជញ្ជាំង: ការប្រៀបធៀបប្រឆាំងនឹង odiff នៅពេលដែលខ្ញុំបានរកឃើញ Benchmarking — ឧបករណ៍ចែកចាយរូបភាពដែលបានសរសេរនៅក្នុង Zig ជាមួយនឹងការភ្ជាប់ OCaml ។ វាត្រូវបានឆាប់រហ័សជាងការអនុវត្ត JavaScript របស់ខ្ញុំ។ បងបង នេះមិនមែនជាការអស្ចារ្យ។ លេខកូដដើមមានអត្ថប្រយោជន៍សំខាន់: ការចូលទៅក្នុងម៉ាស៊ីនថតដោយផ្ទាល់។ មិនមានការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយ។ វិញ្ញាបនប័ត្រ SIMD ។ JavaScript មិនមានការចូលទៅដោយផ្ទាល់ទៅនឹងបញ្ជី SIMD ដូចជា SSE4.1, AVX2 ឬ NEON ។ WebAssembly បានបង្ហាញនូវ SIMD ប៉ុន្តែវាមានការបន្ថែមការបន្ថែមប្រៀបធៀបទៅនឹងកូដដើមសម្រាប់ផ្ទុកការងារដូចនេះ។ មិនមានពេលវេលាដំណើរការ V8, មិនមានដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយ។ ទោះជាយ៉ាងណាក៏ដោយវាជាការពិតប្រាកដ: នៅពេលដែលអ algorithm ត្រូវបានប្រសើរឡើង, ប្រភេទនិងពេលវេលាដំណើរការក្លាយជាប្រសិទ្ធិភាពដែលកាត់បន្ថយ។ អ្នកមិនអាចប្រសើរឡើងប្រសិទ្ធិភាពជាមូលដ្ឋាននៃ JavaScript ។ ការផ្លាស់ប្តូរអេឡិចត្រូនិទៅ Rust ការជ្រើសរើស Rust បានក្លាយទៅជាកន្លែងមួយចំនួន: ការធ្វើឱ្យប្រសើរឡើង។ មិនមាន GC, មិនមានការកំដៅ JIT, មិនមានការបង្វិលបង្វិលបង្វិល។ អ្វីដែលអ្នកសរសេរគឺអ្វីដែលធ្វើការ។ ការគាំទ្រ SIMD ។ ការគាំទ្រ intrinsics ជាលើកដំបូងសម្រាប់ SSE4.1, AVX2/FMA, AVX-512 និង NEON ។ ការសុវត្ថិភាពការចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែកចែក Ecosystem. napi-rs សម្រាប់ Node.js bindings, rayon សម្រាប់ paralelism, សៀវភៅ cross-compilation ស្អាត។ Rust ប្រព័ន្ធ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ // Cold pass: identify changed blocks for by in 0..blocks_y { for bx in 0..blocks_x { let start_x = bx * block_size; let start_y = by * block_size; let end_x = (start_x + block_size).min(width); let end_y = (start_y + block_size).min(height); let has_diff = block_has_perceptual_diff( a32, b32, width, start_x, start_y, end_x, end_y, max_delta, ); if has_diff { changed_blocks.push((start_x, start_y, end_x, end_y)); } else if let Some(ref mut out) = output { if !options.diff_mask { fill_block_gray_optimized( image1, out, options.alpha, start_x, start_y, end_x, end_y, ); } } } } នេះជាកម្រិតខ្ពស់បំផុតនៃការកាត់បន្ថយកម្រិតខ្ពស់នៃការកាត់បន្ថយកម្រិតខ្ពស់នៃការកាត់បន្ថយកម្រិតខ្ពស់នៃការកាត់បន្ថយកម្រិតខ្ពស់នៃការកាត់បន្ថយកម្រិតខ្ពស់នៃការកាត់បន្ថយកម្រិតខ្ពស់នៃការកាត់បន្ថយកម្រិតខ្ពស់នៃការកាត់បន្ថយកម្រិតខ្ពស់នៃការកាត់បន្ថយកម្រិតខ្ពស់នៃការកាត់បន្ថយកម្រិតខ្ពស់នៃការកាត់បន្ថយកម្រិតខ្ពស់នៃការកាត់បន្ថយកម្រិតខ្ពស់នៃការកាត់បន្ថយកម្រិតខ្ពស់នៃការកាត់បន្ថយកម្រិតខ្ពស់នៃការកាត់បន្ថយកម្រិតខ្ពស់។ // Load four pixels at once and extracts RGB channels using vector instructions before computing the YIQ perceptual delta. #[cfg(target_arch = "aarch64")] unsafe fn yiq_delta_4_neon(pixels_a: *const u32, pixels_b: *const u32) { let pa = vld1q_u32(pixels_a); // Load 4 RGBA pixels let pb = vld1q_u32(pixels_b); // Extract channels let r_a = vandq_u32(pa, mask_ff); let g_a = vandq_u32(vshrq_n_u32(pa, 8), mask_ff); let b_a = vandq_u32(vshrq_n_u32(pa, 16), mask_ff); // Convert to float for YIQ transform let r_a_f = vcvtq_f32_u32(r_a); // Alpha blending with FMA let br_a = vfmaq_f32(v255, vsubq_f32(r_a_f, v255), alpha_norm_a); // YIQ: y²×0.5053 + i²×0.299 + q²×0.1957 } នៅលើ x86_64 គោលបំណងដូចគ្នាដូចជា SSE4.1 (4 កុំព្យូទ័រ) ឬ AVX2 + FMA (8 កុំព្យូទ័រ) ត្រូវបានជ្រើសរើសនៅពេលដំណើរការ។ ការរកឃើញលក្ខណៈសម្បត្តិមានប្រសិទ្ធភាពតែមួយដងក្នុងមួយ diff និងផ្លូវ SIMD ដែលមានល្បឿនលឿនបំផុតអាចប្រើបានសម្រាប់ប្រតិបត្តិការទាំងអស់។ មិនមានការផ្លាស់ប្តូរពេលដំណើរការក្នុងមួយកែច្នៃ។ ប្រព័ន្ធ ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ប្រតិបត្តិការ Rust ការបង្កើនប្រសិទ្ធិភាព: ការធ្វើឱ្យប្រសើរឡើងយ៉ាងឆាប់រហ័ស ការប្រកួតប្រជែង odiff គឺជាដំណោះស្រាយដំបូង។ ការបង្កើនប្រសិទ្ធិភាពជាច្រើនបានបង្ហាប់ BlazeDiff ទៅច្រើនជាងនេះ។ The cold pass block comparison got its own SIMD path. Instead of computing the full YIQ delta for every pixel in a block, use SIMD byte comparison first. If any bytes differ, fall through to the perceptual check. This makes the cold pass nearly free for identical blocks. SIMD tuning. Blocks are processed in row order to maximize L1/L2 cache hits. The image data is stored as contiguous RGBA bytes, so scanning blocks left-to-right, top-to-bottom follows the memory layout. Cache-aware block traversal. The image is interpreted as via a zero-copy cast. No allocation, no copy: Minimizing memory copies. &[u32] Image loading (PNG decoding via vendored libspng, JPEG decoding via libjpeg-turbo) runs in parallel using rayon: Parallel I/O. fn load_images(path1: P1, path2: P2) -> Result { if fmt1 == fmt2 { return match fmt1 { ImageFormat::Png => load_pngs(&path1, &path2), ImageFormat::Jpeg => load_jpegs(&path1, &path2), }; } let results: Vec = [ (path1.as_ref().to_path_buf(), fmt1), (path2.as_ref().to_path_buf(), fmt2), ] .par_iter() .map(|(path, fmt)| match fmt { ImageFormat::Png => load_png(path), ImageFormat::Jpeg => load_jpeg(path), }) .collect(); Ok((iter.next().unwrap()?, iter.next().unwrap()?)) } Fat LTO, single codegen unit, abort on panic, symbol stripping: Release profile. [profile.release] opt-level = 3 lto = "fat" codegen-units = 1 panic = "abort" strip = true លទ្ធផលប្រឆាំងនឹង odiff (រួមបញ្ចូលទាំងរូបភាពពេញលេញ I / O: decode, diff, encode): Benchmark odiff BlazeDiff Improvement 4K/1 (5600×3200) 1190.92ms 293.86ms 75.3% 4K/2 1530.21ms 363.50ms 76.2% 4K/3 1835.47ms 389.67ms 78.8% Full page/1 1035.20ms 472.99ms 54.3% Full page/2 598.79ms 263.90ms 55.9% 4K / 1 (5600 × 3200) 1190 មីនាទី លក្ខណៈពិសេស 75.3% កម្រិត 4K / 2 លក្ខណៈពិសេស 153021ms 3650 មីនាទី 76.2% 4K / 3 1845 មីនាទី 389 មីនាទី 78.8% ទំព័រដើម / 1 លទ្ធផល 105.20ms 472 មីនាទី 54.3% ទំព័រដើម / 2 លទ្ធផល 598.79ms លក្ខណៈពិសេស 55.9% ទាញយករូបថត 4K ដែលមានល្បឿនលឿនជាង 3-4x ។ ការរួមបញ្ចូលនៃការដោះស្រាយប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហ គោលបំណងនៃការរួមបញ្ចូល: ទទួលបាន Rust នៅក្នុង JavaScript ប៉ុន្តែអ្នកប្រើជាតម្រូវការគឺអ្នកអភិវឌ្ឍន៍ JavaScript ដែលបានសរសេរការធ្វើតេស្តរូបភាពជាមួយ Playwright, Cypress ឬ Vitest ។ ពួកគេត្រូវការ មិន . npm install cargo install គោលបំណងដំបូងគឺជាគួរឱ្យចាប់អារម្មណ៍: Node.js → spawn binary → run diff → return result ប្លុក Rust binary នៅក្នុងកញ្ចប់ Node.js, spawn វាជាដំណើរការកុមារ, និង parse ទិន្នផល JSON: try { await execFileAsync(binaryPath, args); return { match: true }; } catch (err) { // Parse exit codes: 0=identical, 1=pixel-diff, 2=error } វាគឺជាការធ្វើការ។ វាគឺជាការងាយស្រួល, ទាញយក, និងការបណ្តុះបណ្តាលបណ្តុះបណ្តាលបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្ត ហេតុអ្វីមិនមែនជាអ្នកផ្គត់ផ្គង់ Diff Server? អ្នកចាប់ផ្តើមវាត្រូវបានដោះស្រាយបញ្ហានេះដោយធ្វើការដំណើរការបណ្តាញដែលមានភាពធ្ងន់ធ្ងរ។ អ្នកចាប់ផ្តើមវាត្រូវបានដោះស្រាយបញ្ហា diff នៅលើការផ្លាស់ប្តូរនិងវាត្រូវបានដោះស្រាយបញ្ហានេះដោយគ្មានការផ្លាស់ប្តូរ spawn ។ ខ្ញុំបានគិតអំពីវិធីសាស្រ្តនេះហើយបានបាត់បង់វា។ ការជួញដូរមិនត្រឹមត្រូវជាមួយប្រសិនបើការប្រើប្រាស់នេះ: ប្រព័ន្ធ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ នេះជាដំណើរការដែលមានពេលវេលាដំណើរការបានកើនឡើង។ ការបាត់បន្ថយការចែកចាយការចែកចាយការចែកចាយការចែកចាយការចែកចាយការចែកចាយការចែកចាយការចែកចាយការចែកចាយការចែកចាយការចែកចាយការចែកចាយការចែកចាយការចែកចាយការចែកចាយការចែកចាយការចែកចាយការចែកចាយ។ ការរួមបញ្ចូលគ្នានៃការ CI ។ ការរួមបញ្ចូលគ្នានៃការរួមបញ្ចូលគ្នានៃការរួមបញ្ចូលគ្នានៃការរួមបញ្ចូលគ្នានៃការរួមបញ្ចូលគ្នានៃការរួមបញ្ចូលគ្នានៃការរួមបញ្ចូលគ្នានៃការរួមបញ្ចូលគ្នានៃការរួមបញ្ចូលគ្នានៃការរួមបញ្ចូលគ្នានៃការរួមបញ្ចូលគ្នានៃការរួមបញ្ចូលគ្នានៃការរួមបញ្ចូលគ្នានៃការរួមបញ្ចូលគ្នានៃការរួមបញ្ចូលគ្នានៃការរួមបញ្ចូលគ្នានៃការរួមបញ្ចូល។ ការរចនា API. ខ្ញុំចង់គ្រប់ប្រតិបត្តិការ diff ដែលមានអេឡិចត្រូនិងដោយខ្លួនឯង។ comparare(a, b) ត្រូវតែធ្វើការប៉ុណ្ណោះដោយមិនចាំបាច់អ្នកប្រើដើម្បីគ្រប់គ្រងប្រព័ន្ធប្រតិបត្តិការ server ។ គោលបំណងនៃការរចនាសម្ព័ន្ធគឺមានភាពជាក់លាក់: ការអនុវត្តដែលមានមូលដ្ឋានជាមួយនឹងភាពងាយស្រួលនៃការសរសេរកម្មវិធី។ ការរៀនពីឧបករណ៍ JavaScript Rust-Based ការសរសេរនេះបានមកពីការស្រាវជ្រាវពីរបៀបដែលឧបករណ៍ JavaScript ផ្សេងទៀតដែលមានប្រសិទ្ធិភាពដោយ Rust អាចដំណើរការបញ្ហានេះ។ (the linter/formatter) បានប្រើជាអាកាសធាតុដែលមានភាពងាយស្រួលបំផុត: បៃតង JavaScript API → N-API binding (.node file) → Rust core library គំនិតសំខាន់នេះគឺ — Node.js ដែលជា ABI ដែលមានស្ថេរភាពសម្រាប់ addons native ។ មិនមែនជាការកាត់បន្ថយដំណើរការកុមារ, Rust code compiles ទៅ a សៀវភៅដែលត្រូវបានទាញយកដោយផ្ទាល់ទៅក្នុងដំណើរការ Node.js ។ ការទាញយកគោលបំណងពី JavaScript ទៅ Rust នឹងក្លាយជាការទាញយកគោលបំណងដោយផ្ទាល់។ គ្មាន serialization, គ្មាន IPC, គ្មានការបញ្ចូលគោលបំណង។ N-API .node គោលបំណងនៃការវេចខ្ចប់គឺជាការសំខាន់ណាស់។ គោលបំណងប្លាស្ទិចដែលមានលក្ខណៈពិសេសសម្រាប់ប្លាស្ទិចត្រូវបានបោះពុម្ពជាកញ្ចប់ npm មួយដោយគ្មាន និង សត្វ : os cpu { "name": "@blazediff/bin-darwin-arm64", "os": ["darwin"], "cpu": ["arm64"], "files": ["blazediff", "blazediff.node"] } សៀវភៅទាំងនេះបានសរសេរជា : optionalDependencies { "name": "@blazediff/bin", "optionalDependencies": { "@blazediff/bin-darwin-arm64": "3.5.0", "@blazediff/bin-darwin-x64": "3.5.0", "@blazediff/bin-linux-arm64": "3.5.0", "@blazediff/bin-linux-x64": "3.5.0", "@blazediff/bin-win32-arm64": "3.5.0", "@blazediff/bin-win32-x64": "3.5.0" } } npm/pnpm/bun អនុញ្ញាតឱ្យអ្នកដំឡើងប្រព័ន្ធប្រតិបត្តិការរបស់អ្នកតែប៉ុណ្ណោះ។ មិនមានការដំឡើងបន្ទាប់ពីការដំឡើងប្រព័ន្ធប្រតិបត្តិការ។ មិនមានការដំឡើងប្រព័ន្ធប្រតិបត្តិការប៉ុណ្ណោះ។ គ្រាន់តែជាប្រព័ន្ធប្រតិបត្តិការ binary prebuilt ។ ប្រព័ន្ធ ប្រតិបត្តិការ Rust + N-API BlazeDiff បានបង្កើតគម្រោងបច្ចេកវិទ្យានៃ BlazeDiff ។ ការបណ្តុះបណ្តាល N-API គឺជាផ្លូវល្បឿនលឿន ។ ការបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តាល។ JavaScript API ↓ Try N-API binding (in-process, ~0 overhead) ↓ (if unavailable) Fall back to execFile (spawn binary) ↓ Rust diff engine ↓ SIMD + parallel I/O ការភ្ជាប់ N-API ត្រូវបានកំណត់ដោយ napi-rs: #[napi] pub fn compare( base_path: String, compare_path: String, diff_output: Option , options: Option , ) -> Result { // Load images in parallel using rayon let (img1, img2) = load_images(&base_path, &compare_path)?; // Run the diff let result = diff(&img1, &img2, output_image.as_mut(), &diff_options)?; Ok(NapiDiffResult { match_result: result.identical, reason: if result.identical { None } else { Some("pixel-diff".into()) }, diff_count: Some(result.diff_count), diff_percentage: Some(result.diff_percentage), }) } នៅលើទំព័រ JavaScript, ការបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តាល let nativeBinding: NativeBinding | null = null; let nativeBindingAttempted = false; function tryLoadNativeBinding(): NativeBinding | null { if (nativeBindingAttempted) return nativeBinding; nativeBindingAttempted = true; const key = `${os.platform()}-${os.arch()}`; const platformInfo = PLATFORM_PACKAGES[key]; if (!platformInfo) return null; try { const require = createRequire(import.meta.url); const binding = require(platformInfo.packageName) as NativeBinding; if (typeof binding?.compare === "function") { nativeBinding = binding; return binding; } } catch { // Native binding not available, will use execFile fallback } return null; } ការកំណត់រចនាសម្ព័ន្ធ Cargo បានកំណត់រចនាសម្ព័ន្ធដូចគ្នាដូចជា binary standalone និង cdylib (សៀវភៅរួមបញ្ចូលសម្រាប់ N-API) ។ [lib] name = "blazediff" crate-type = ["lib", "cdylib"] [features] default = [] napi = ["dep:napi", "dep:napi-derive"] មូលដ្ឋានកូដមួយ, មូលដ្ឋានផ្គត់ផ្គង់ពីរ: មូលដ្ឋាន CLI binary និងមូលដ្ឋាន Node.js ដែលមានមូលដ្ឋាន។ លក្ខខណ្ឌអតិបរមា SIMD ដែលដូចគ្នា, មូលដ្ឋានប្លុកដែលមានមូលដ្ឋានដូចគ្នា, អ្វីគ្រប់យ៉ាងដូចគ្នា, គ្រាន់តែជាតម្រូវការផ្សេងទៀត។ ការសិក្សា លក្ខណៈពិសេស: Algorithms Before Languages ការរចនាសម្ព័ន្ធប្លុកដែលមានមូលដ្ឋានបានបង្កើតការកើនឡើង 72-88% នៃការកើនឡើងល្បឿននៅក្នុង JavaScript ស្អាតមុនពេលដែល Rust ដែលបានសរសេរ។ ការជ្រើសរើសអាល្លាស្ទាមត្រឹមត្រូវគឺជាការសំខាន់ច្រើនជាងការជ្រើសរើសភាសាត្រឹមត្រូវ។ ប្រសិនបើខ្ញុំបានចូលទៅ Rust ដោយផ្ទាល់ដោយមានវិធីសាស្រ្តកែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រ JavaScript មានកម្រិតខ្ពស់សម្រាប់ការធ្វើការទូទាត់។ បន្ទាប់ពីអេឡិចត្រូនិកត្រូវបានប្រសើរឡើង, ពេលវេលាដំណើរការរបស់ JavaScript - ការបញ្ចប់ GC, ការកំដៅ JIT, ការគិតថ្លៃនៃ SIMD, កញ្ចក់ស្វែងរកសមត្ថភាព - បានក្លាយជាតម្លៃសំខាន់។ សម្រាប់ការបង្វិលទំហំទូលំទូលាយជាងការបង្វិលធំ, មិនមែនជាទំហំនៃ micro-optimization អាចបង្វិលទំហំ V8 ។ នេះមិនមែនជាការគិតថ្លៃរបស់ JavaScript ។ វាគឺជាការទទួលស្គាល់ថាឧបករណ៍ផ្សេងគ្នានេះបម្រើគោលបំណងផ្សេងគ្នានេះ។ ប្រព័ន្ធ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ប្រតិបត្តិការ ការហោះហើរពី N-API គឺជាការល្អប្រសើរជាងការផ្លាស់ប្តូរអេឡិចត្រូនិកមួយចំនួន។ ការផ្លាស់ប្តូរអេឡិចត្រូនិក - តើធ្វើដូចម្តេចដើម្បីផ្លាស់ប្តូរកូដ, តើធ្វើដូចម្តេចដើម្បីផ្លាស់ប្តូរទិន្នន័យ, តើធ្វើដូចម្តេចដើម្បីគ្រប់គ្រងជីវិតដំណើរការ - បានកើនឡើងជាមួយនឹងការសរសេរ។ នៅពេលដែលអ្នកផ្លាស់ប្តូរ 500 រូបភាពការផ្លាស់ប្តូររវាងការសរសេរកម្មវិធីនិងការផ្លាស់ប្តូរដំណើរការគឺជាការផ្លាស់ប្តូររយៈពេល ២ វិនាទីនិង នាទី។ spawn(binary) N-API គឺជាកញ្ចក់ដែលមិនមានតម្លៃ។ N-API ផ្តល់នូវការ ABI ដែលមានស្ថេរភាពនៅលើប្រព័ន្ធប្រតិបត្តិការ Node.js, ការវេចខ្ចប់ប្លាស្ទិចស្អាតតាមរយៈ វាគឺជាដំណោះស្រាយដូចគ្នាដែលត្រូវបានប្រើដោយឧបករណ៍ JavaScript ដែលមានប្រសិទ្ធិភាពខ្ពស់ដូចជា Biome, SWC និងឧបករណ៍ JavaScript ដែលមានប្រសិទ្ធិភាពខ្ពស់ផ្សេងទៀត។ ប្រសិនបើអ្នកកំពុងបង្កើតសៀវភៅ JavaScript ដែលមានប្រសិទ្ធិភាពក្នុងការអនុវត្តនិង JavaScript របស់ខ្លួនគឺជាដំណោះស្រាយ, N-API + Rust គឺជាដំណោះស្រាយដែលបានសាកល្បង។ optionalDependencies កុំព្យូទ័រ: កុំព្យូទ័រ: Benchmark Everything, Trust Nothing ការធ្វើឱ្យប្រសើរឡើងទាំងអស់ត្រូវបានត្រួតពិនិត្យដោយប្រើប្រសិទ្ធិភាពប្រសើរឡើងនៅលើឧបករណ៍គ្រប់គ្រង។ ការដំណើរការ WASM ត្រូវបានស្រាវជ្រាវនិងបាត់បន្ថយ (ខ្ញុំបានធ្វើការទាំង Rust WASM និង AssemblyScript — ទាំងពីរនេះគឺជាការរឹងមាំជាងប្រសើរឡើងសម្រាប់ផ្ទុកការងារនេះ) ។ គំរូទំហំប្លុកត្រូវបានត្រួតពិនិត្យដោយប្រវត្តិសាស្រ្តនៅលើទំហំរូបភាពពី 100 × 100 ទៅ 5600 × 3200 ។ ការធ្វើឱ្យប្រសើរឡើងគឺជាធម្មតា។ ការត្រួតពិនិត្យ។ JavaScript គឺជាប្រព័ន្ធផ្សព្វផ្សាយដ៏ល្អបំផុតសម្រាប់ឧបករណ៍អភិវឌ្ឍន៍: ប្រវត្តិសាស្រ្តនៃការគ្រប់គ្រងកញ្ចប់, ការបណ្តុះបណ្តាលការធ្វើតេស្តនិងទំហំទូលំទូលាយនៃសហគមន៍។ ប៉ុន្តែមានពេលវេលាដំណើរការយ៉ាងឆាប់រហ័សបំផុតគឺដើម្បីអនុញ្ញាតឱ្យកូដដើមធ្វើការកាត់បន្ថយទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូល។ ម៉ាស៊ីន BlazeDiff ជាតែមួយ នៅក្រោមកញ្ចក់នេះមាន 2,000 ដំណាក់កាលនៃកញ្ចក់ដំណើរការ Rust ដែលមានអត្ថប្រយោជន៍ដោយ SIMD ដោយរយៈប្រហែលកញ្ចក់ពីរដង។ ពីគំនិតនៃអ្នកអភិវឌ្ឍន៍វាគឺ . npm install compare(a, b) នេះគឺជាគោលបំណង: ការអនុវត្តដែលមិនអាចមើលឃើញ។ អ្នកប្រើប្រាស់មិនគួរតែដឹងឬអារម្មណ៍ថា Rust មាន។