สถาปัตยกรรมความหน่วงต่ำสำหรับ Solana HFT

ข้อมูลกำลังเข้ามา แต่ราคาที่แอปพลิเคชันใช้ตัดสินใจยังเป็นข้อมูลเก่า ในแอปพลิเคชัน Solana HFT คุณต้องพิจารณาทั้งเวลาที่ใช้คำนวณ และเวลาที่ข้อมูลซึ่งรับมาแล้วต้องรอก่อนนำไปใช้ตัดสินใจ การอัปเดตก่อนหน้าอาจยังรอประมวลผล การเขียนล็อกอาจยังไม่เสร็จ หรือการอัปเดตของอีกตลาดอาจกำลังถือครองล็อกอยู่ วิธีจัดโครงสร้างโค้ดส่งผลต่อการรอเหล่านี้
บทความนี้ใช้รูปแบบการออกแบบห้ารูปแบบเพื่อติดตามว่าข้อมูลขาเข้ารออยู่ตรงไหน และงานใดจะเดินหน้าต่อได้เมื่อเปลี่ยนการออกแบบ คุณสามารถเริ่มจากอาการที่ตรงกับแอปพลิเคชันของคุณ แล้วอ่านหัวข้อนั้นโดยตรงได้เช่นกัน
| สิ่งที่เกิดขึ้นในแอปพลิเคชัน | การออกแบบที่ควรตรวจสอบ |
|---|---|
| ข้อมูลที่ยังไม่ประมวลผลเพิ่มขึ้นเรื่อย ๆ เมื่อแอปพลิเคชันทำงานนานขึ้น | 1. อัตราข้อมูลเข้า อัตราประมวลผล และขีดจำกัดการรอ |
| ประมวลผลราคาถัดไปไม่ได้ระหว่างบันทึกข้อมูล | 2. แยกงานที่จำเป็นต่อการตัดสินใจออกจากล็อกเพื่อการวิเคราะห์ |
| การอัปเดตตลาด A ทำให้การอัปเดตตลาด B ต้องรอ | 3. แยกล็อกที่ปกป้องสถานะอิสระจากกัน |
| เตรียมงานเดิมซ้ำทุกครั้งที่ข้อมูลมาถึง | 4. เตรียมส่วนที่ไม่เปลี่ยนล่วงหน้าและนำกลับมาใช้ |
| ยังใช้ค่าเก่าตัดสินใจแม้เชื่อมต่อกลับมาแล้ว | 5. แยกการกู้คืนการเชื่อมต่อออกจากการกู้คืนสถานะสำหรับตัดสินใจ |
ท้ายแต่ละส่วนมีคำสั่งที่คัดลอกได้สำหรับนำการปรับปรุงนั้นไปใช้กับแอปพลิเคชันของคุณ ส่งคำสั่งให้เอเจนต์ AI ที่สามารถอ่านโค้ดของโครงการได้
จำนวนข้อมูล ราคา จำนวนครั้งของการทำงาน และระยะเวลาในแผนภาพเป็นแบบจำลองเพื่ออธิบาย ไม่ใช่ผลวัดประสิทธิภาพหรือผลลัพธ์การซื้อขายจริง
แตะหรือคลิกแผนภาพเพื่อเปิดภาพขนาดเต็ม
1. เปรียบเทียบข้อมูลขาเข้ากับกำลังประมวลผล และกำหนดขีดจำกัดการรอ
สมมติว่าในแต่ละช่วงเวลาที่มีความยาวเท่ากัน แอปพลิเคชันรับหกเหตุการณ์และประมวลผลได้สองเหตุการณ์ เมื่อจบช่วงแรกจะเหลือสี่เหตุการณ์ที่ยังไม่ประมวลผล คิวคือที่ที่ข้อมูลรอรับการประมวลผล
งานประมวลผลกำลังเดินหน้า แต่ยังมีสี่เหตุการณ์ที่ไม่ได้นำไปใช้ตัดสินใจ
ทีนี้ขยายสัดส่วนเดิมเป็นข้อมูลขาเข้า 60,000 เหตุการณ์ เมื่อประมวลผล 20,000 เหตุการณ์ จะเหลือ 40,000 เหตุการณ์ที่รออยู่ ด้านขวาของแผนภาพใช้จุดหนึ่งจุดแทน 100 เหตุการณ์ และกลุ่มหนึ่งที่มี 100 จุดแทน 10,000 เหตุการณ์ ประมวลผลแล้วสองกลุ่ม และยังรออีกสี่กลุ่ม
กลุ่มทางด้านขวาเป็นวิธีแสดงปริมาณ ไม่ได้หมายถึงแบตช์ที่แอปพลิเคชันใช้ประมวลผล
ช่วงถัดไปเริ่มต้นโดยมี 40,000 เหตุการณ์รออยู่ก่อนแล้ว อีก 60,000 เหตุการณ์เข้ามาและประมวลผลไป 20,000 เหตุการณ์ จึงเหลือ 80,000 เหตุการณ์ เมื่อจบช่วงถัดจากนั้นจะเหลือ 120,000 เหตุการณ์ ราคาที่เพิ่งเข้ามาต้องรอต่อจากงานที่อยู่ในคิวแล้ว
หากข้อมูลขาเข้ามากกว่ากำลังประมวลผลอย่างต่อเนื่อง งานค้างก็จะเพิ่มขึ้นต่อไป
คิวช่วยรองรับข้อมูลที่เข้ามากระจุกตัวในช่วงเวลาสั้น ๆ ได้ แต่การเพิ่มความจุคิวไม่แก้ปัญหากำลังประมวลผลไม่เพียงพออย่างต่อเนื่องเช่นในตัวอย่างนี้ นอกจากจำนวนรายการและไบต์ที่เก็บไว้ ให้สังเกตด้วยว่ารายการเก่าที่สุดรอมานานเท่าใด และกำหนดขีดจำกัดที่ยอมรับได้ หากข้อมูลไม่สดใหม่ตามข้อกำหนดแล้ว ให้หยุดการตัดสินใจซื้อขายใหม่ที่อาศัยค่าเหล่านั้นชั่วคราว แม้จะไม่มีการอัปเดตสูญหายเลยก็ตาม
เมื่อถึงขีดจำกัดควรเกิดอะไรขึ้น? ในแผนภาพถัดไป ช่องว่างทั้งแปดช่องเต็มแล้วเมื่อมีการอัปเดตเพิ่มเข้ามาอีกสองรายการ หากเก็บสองรายการนี้ไว้ไม่ได้และจำเป็นต้องใช้ในการตัดสินใจ แอปพลิเคชันก็ไม่สามารถปรับค่าที่เก็บอยู่ให้ถูกต้องได้ ควรหยุดการตัดสินใจซื้อขายใหม่ที่อาศัยค่าเหล่านั้น และกลับมาทำงานหลังจากกู้คืนการอัปเดตที่จำเป็นแล้ว
การออกแบบคิวต้องระบุด้วยว่าจะทำอย่างไรหลังถึงขีดจำกัด
ตรวจสอบว่าสามารถลดงานหรือเพิ่มกำลังประมวลผลได้หรือไม่ หากผู้ใช้ข้อมูลต้องการเพียงสถานะสมบูรณ์ล่าสุดของสิ่งเดียวกัน อาจรวมค่าระหว่างทางให้เหลือค่าล่าสุดได้ แต่สำหรับกระบวนการที่สะสมส่วนเปลี่ยนแปลงหรือจำเป็นต้องใช้เหตุการณ์ระหว่างทาง การข้ามการอัปเดตจะเปลี่ยนผลลัพธ์
การหยุดรับข้อมูลอาจเพียงย้ายการรอไปยังต้นทางด้วย ให้พิจารณา flow control ของ gRPC ซึ่งควบคุมจังหวะการส่งและรับ ร่วมกับตัวกรองฝั่งเซิร์ฟเวอร์ที่ลดขอบเขตข้อมูลที่สมัครรับ และกำลังประมวลผลจริงของแอปพลิเคชัน[3][4]
หากต้องการปรับปรุงความจุคิวรับข้อมูลและความสดใหม่ของข้อมูลในแอปพลิเคชัน ให้คัดลอกคำสั่งต่อไปนี้
text
ปรับปรุงการจัดการข้อมูลขาเข้าของแอปพลิเคชันนี้เมื่อประมวลผลไม่ทันและข้อมูลที่ใช้ตัดสินใจล้าสมัย
อ่าน README คำแนะนำการพัฒนา dependencies และโค้ดรับข้อมูล → คิว → อัปเดตสถานะ → ตัดสินใจ ใช้ภาษา runtime และ SDK ที่มีอยู่ ตรวจสอบว่าการอัปเดตเป็นสถานะสมบูรณ์หรือ delta ต้องนำไปใช้ตามลำดับใด และต้องการความสดใหม่ของข้อมูลระดับใด
1. เก็บอินพุตที่ทำซ้ำได้โดยไม่มีข้อมูลลับ และบันทึกค่าก่อนเปลี่ยนแปลง ตรวจสอบการรอก่อนเข้าคิวด้วย วัดจำนวนรายการและไบต์ขาเข้าและขาออกในช่วงเวลาเดียวกัน งานที่อยู่ในคิว อายุของรายการที่รอนานที่สุด และงานที่กำลังดำเนินการ
2. กำหนดและนำขีดจำกัดจำนวนรายการ ไบต์ เวลารอ และจำนวนงานพร้อมกันไปใช้ พร้อมเหตุผลของแต่ละค่า ระบุสมมติฐานเมื่อยังไม่ทราบข้อกำหนด ตรวจสอบว่าลดการรับหรือประมวลผลที่ไม่จำเป็นได้หรือไม่ และกำลังประมวลผลเพียงพอหรือไม่ อย่าถือว่าการขยายคิวเพียงอย่างเดียวแก้ปัญหากำลังประมวลผลไม่พออย่างต่อเนื่องได้
3. กำหนดพฤติกรรมเมื่อคิวเต็ม หากเก็บการอัปเดตที่จำเป็นไม่ได้ หรือข้อมูลไม่สดใหม่ตามข้อกำหนดแม้ไม่มีการอัปเดตสูญหาย ให้พักการตัดสินใจซื้อขายใหม่ที่อาศัยค่าเหล่านั้น ดำเนินการอัปเดตและกู้คืนสถานะต่อ แล้วตรวจสอบเงื่อนไขการกลับมาตัดสินใจ
4. หากรวมค่าระหว่างทาง ต้องยืนยันว่าสถานะสมบูรณ์ล่าสุดของสิ่งเดียวกันเพียงพอที่จะรักษาผลลัพธ์ อย่าทิ้ง delta หรือเหตุการณ์ที่จำเป็นโดยไม่แจ้ง หากหยุดรับข้อมูลชั่วคราว ให้ตรวจสอบ flow control ของผู้ให้บริการและตำแหน่งที่การรอย้ายไป
5. เล่นซ้ำอินพุตปกติ ข้อมูลที่มาเป็นช่วงกระชาก ภาวะโหลดเกินต่อเนื่อง และการกลับมาจากคิวเต็มภายใต้เงื่อนไขเดียวกัน เปรียบเทียบอัตราข้อมูลเข้าและประมวลผล อายุรายการที่เก่าที่สุด p50/p95/p99 ตั้งแต่รับข้อมูลจนตัดสินใจเสร็จ CPU และหน่วยความจำ รวมถึงการอัปเดตที่สูญหายหรือถูกทิ้ง ตรวจสอบสถานะที่นำไปใช้และการตัดสินใจกับผลลัพธ์ที่คาดหวัง ใช้นาฬิกา monotonic วัดระยะเวลาภายในโฮสต์เดียวกัน และระบุจุดเริ่มต้นกับจุดสิ้นสุดของการวัด
รักษาการอนุมัติ สิทธิ์ และขั้นตอนพัฒนาที่มีอยู่ คำสั่งนี้เพียงอย่างเดียวไม่ได้เพิ่มสิทธิ์ให้เปลี่ยนระบบ production ทำสัญญาที่มีค่าใช้จ่าย หรือซื้อขายจริง อย่าแสดง private key ข้อมูลรับรอง หรือข้อมูลลูกค้า
รายงานสิ่งที่เปลี่ยน เงื่อนไขเปรียบเทียบ ค่าที่วัดก่อนและหลัง การตรวจสอบความถูกต้อง และข้อจำกัดที่เหลือ ค่าที่วัดไม่ได้ให้ระบุว่ายังไม่ได้วัดปรับปรุงการจัดการข้อมูลขาเข้าของแอปพลิเคชันนี้เมื่อประมวลผลไม่ทันและข้อมูลที่ใช้ตัดสินใจล้าสมัย
อ่าน README คำแนะนำการพัฒนา dependencies และโค้ดรับข้อมูล → คิว → อัปเดตสถานะ → ตัดสินใจ ใช้ภาษา runtime และ SDK ที่มีอยู่ ตรวจสอบว่าการอัปเดตเป็นสถานะสมบูรณ์หรือ delta ต้องนำไปใช้ตามลำดับใด และต้องการความสดใหม่ของข้อมูลระดับใด
1. เก็บอินพุตที่ทำซ้ำได้โดยไม่มีข้อมูลลับ และบันทึกค่าก่อนเปลี่ยนแปลง ตรวจสอบการรอก่อนเข้าคิวด้วย วัดจำนวนรายการและไบต์ขาเข้าและขาออกในช่วงเวลาเดียวกัน งานที่อยู่ในคิว อายุของรายการที่รอนานที่สุด และงานที่กำลังดำเนินการ
2. กำหนดและนำขีดจำกัดจำนวนรายการ ไบต์ เวลารอ และจำนวนงานพร้อมกันไปใช้ พร้อมเหตุผลของแต่ละค่า ระบุสมมติฐานเมื่อยังไม่ทราบข้อกำหนด ตรวจสอบว่าลดการรับหรือประมวลผลที่ไม่จำเป็นได้หรือไม่ และกำลังประมวลผลเพียงพอหรือไม่ อย่าถือว่าการขยายคิวเพียงอย่างเดียวแก้ปัญหากำลังประมวลผลไม่พออย่างต่อเนื่องได้
3. กำหนดพฤติกรรมเมื่อคิวเต็ม หากเก็บการอัปเดตที่จำเป็นไม่ได้ หรือข้อมูลไม่สดใหม่ตามข้อกำหนดแม้ไม่มีการอัปเดตสูญหาย ให้พักการตัดสินใจซื้อขายใหม่ที่อาศัยค่าเหล่านั้น ดำเนินการอัปเดตและกู้คืนสถานะต่อ แล้วตรวจสอบเงื่อนไขการกลับมาตัดสินใจ
4. หากรวมค่าระหว่างทาง ต้องยืนยันว่าสถานะสมบูรณ์ล่าสุดของสิ่งเดียวกันเพียงพอที่จะรักษาผลลัพธ์ อย่าทิ้ง delta หรือเหตุการณ์ที่จำเป็นโดยไม่แจ้ง หากหยุดรับข้อมูลชั่วคราว ให้ตรวจสอบ flow control ของผู้ให้บริการและตำแหน่งที่การรอย้ายไป
5. เล่นซ้ำอินพุตปกติ ข้อมูลที่มาเป็นช่วงกระชาก ภาวะโหลดเกินต่อเนื่อง และการกลับมาจากคิวเต็มภายใต้เงื่อนไขเดียวกัน เปรียบเทียบอัตราข้อมูลเข้าและประมวลผล อายุรายการที่เก่าที่สุด p50/p95/p99 ตั้งแต่รับข้อมูลจนตัดสินใจเสร็จ CPU และหน่วยความจำ รวมถึงการอัปเดตที่สูญหายหรือถูกทิ้ง ตรวจสอบสถานะที่นำไปใช้และการตัดสินใจกับผลลัพธ์ที่คาดหวัง ใช้นาฬิกา monotonic วัดระยะเวลาภายในโฮสต์เดียวกัน และระบุจุดเริ่มต้นกับจุดสิ้นสุดของการวัด
รักษาการอนุมัติ สิทธิ์ และขั้นตอนพัฒนาที่มีอยู่ คำสั่งนี้เพียงอย่างเดียวไม่ได้เพิ่มสิทธิ์ให้เปลี่ยนระบบ production ทำสัญญาที่มีค่าใช้จ่าย หรือซื้อขายจริง อย่าแสดง private key ข้อมูลรับรอง หรือข้อมูลลูกค้า
รายงานสิ่งที่เปลี่ยน เงื่อนไขเปรียบเทียบ ค่าที่วัดก่อนและหลัง การตรวจสอบความถูกต้อง และข้อจำกัดที่เหลือ ค่าที่วัดไม่ได้ให้ระบุว่ายังไม่ได้วัด2. ประมวลผลราคาถัดไปโดยไม่รอให้บันทึกข้อมูลเสร็จ
พิจารณาราคาตลาดที่เปลี่ยนจาก 100 เป็น 101 แอปพลิเคชันนำค่า 100 ไปใช้ ตัดสินใจเสร็จแล้ว และกำลังบันทึกข้อมูลเพื่อการวิเคราะห์ หากลูปที่จัดการข้อมูลขาเข้ารอให้การบันทึกเสร็จ ก็จะนำค่า 101 ไปใช้ไม่ได้แม้การอัปเดตจะมาถึงแล้ว ราคาที่เก็บอยู่ในแอปพลิเคชันยังคงเป็น 100
สาเหตุที่ยังเริ่มประมวลผล 101 ไม่ได้ คือการรอบันทึกข้อมูลของ 100
ทีนี้ส่งข้อมูลวิเคราะห์ไปยังคิวเสริมที่ยังมีความจุ แล้วให้การทำงานอีกส่วนบันทึกข้อมูลแทน เมื่อส่งต่องานเสร็จ ลูปรับข้อมูลก็กลับไปรับอินพุตถัดไปได้ จึงนำ 101 ไปใช้และดำเนินการตัดสินใจได้ขณะที่ยังบันทึกข้อมูลของ 100 อยู่
การเปรียบเทียบต่อไปนี้คงเวลาบันทึกของ 100 เวลาที่ 101 มาถึง และเวลาที่ใช้ประมวลผล 101 ให้เท่ากัน สิ่งที่เปลี่ยนคือการไปยังอินพุตถัดไปต้องรอให้บันทึกเสร็จหรือไม่
แม้ไม่ได้ลดเวลาทำงานของ 101 เอง คุณก็ลดการรอก่อนเริ่มงานได้
เส้นทางประมวลผลที่จำเป็นตั้งแต่รับข้อมูล ผ่านการตัดสินใจ ไปจนถึงส่งธุรกรรม เรียกว่า hot path ในตัวอย่างนี้ การบันทึกล็อกเพื่อการวิเคราะห์ที่ไม่จำเป็นต้องทำให้การตัดสินใจรอ ถูกย้ายออกจากเส้นทางดังกล่าว ส่วนการตรวจสอบยอดคงเหลือ การตรวจสอบขีดจำกัดความเสี่ยง และการบันทึกที่ต้องเสร็จเพื่อรักษาความถูกต้อง ยังคงอยู่ในตำแหน่งที่ข้อกำหนดบังคับ
งานบันทึกยังคงมีอยู่ คิวเสริมจึงต้องมีขีดจำกัดความจุและเวลารอเช่นกัน งานที่แยกออกมาไม่ได้แปลว่าจะทำงานบน CPU แยกเสมอไป งานที่ใช้ CPU นานหรืองานแบบ blocking ใน Tokio รวมถึงงาน synchronous ที่ใช้เวลานานบน event loop ของ Node.js อาจขัดขวางงานอื่นได้ เมื่อย้ายงานต้องตรวจสอบว่าจะนำไปประมวลผลที่ใดจริง[1][2]
หากต้องการแยกการเขียนบันทึกเพื่อการวิเคราะห์ออกจากเส้นทางตัดสินใจ ให้คัดลอกคำสั่งต่อไปนี้
text
ปรับปรุงแอปพลิเคชันนี้ในจุดที่การรอให้บันทึกข้อมูลเพื่อการวิเคราะห์เสร็จขัดขวางการนำการอัปเดตถัดไปไปใช้หรือใช้ตัดสินใจ
อ่าน README คำแนะนำการพัฒนา dependencies และลูปรับข้อมูล ใช้ภาษา runtime และไลบรารีจัดเก็บที่มีอยู่ หาจุดที่รอการบันทึกเสร็จ และระบุ thread, task หรือ event loop ที่งานทำงานจริง
1. เตรียมอินพุตที่ทำซ้ำได้โดยไม่มีข้อมูลลับ บันทึกเวลารับข้อมูล การนำสถานะไปใช้ จุดเริ่มและจบการตัดสินใจ จุดเริ่มและจบการบันทึก และผลลัพธ์ปัจจุบัน
2. ตรวจจากข้อกำหนดว่าการบันทึกเสร็จเป็นเงื่อนไขก่อนตัดสินใจหรือกู้คืนหรือไม่ คงการตรวจยอดคงเหลือ ความเสี่ยง และการจัดเก็บถาวรที่จำเป็นต่อความถูกต้องไว้ในตำแหน่งที่ต้องใช้ แยกบันทึกเพื่อการวิเคราะห์ที่สามารถบันทึกให้เสร็จภายหลังได้
3. กำหนดวิธีส่งต่อบันทึกเพื่อไม่ให้การเปลี่ยนสถานะภายหลังเปลี่ยนค่าที่กำลังบันทึก สร้างคิวเสริมที่มีขีดจำกัดและผู้รับงานบันทึก ระบุขีดจำกัดจำนวนรายการ ไบต์ และเวลารอ พฤติกรรมเมื่อคิวเต็ม บันทึกล้มเหลว ลองใหม่ และปิดระบบ รวมทั้งข้อกำหนดการเก็บรักษา อย่าทิ้งบันทึกขณะที่ยังไม่ทราบข้อกำหนดการเก็บรักษา
4. อย่าสมมติว่าแยก task แล้วจะทำงานบน CPU อื่น ตรวจสอบว่า I/O แบบ synchronous และงาน CPU ที่ใช้เวลานานทำงานที่ไหน หากใช้ worker หรือกลไกคล้ายกัน ให้จำกัดจำนวนงานพร้อมกันและรวมต้นทุนแปลงข้อมูล คัดลอก และรอส่งต่อในการประเมิน
5. ใช้อินพุตและจังหวะการมาถึงเดียวกันเพื่อจำลองการบันทึกปกติ การบันทึกช้า ความล้มเหลว คิวเสริมเต็ม และการปิดระบบ เปรียบเทียบ p50/p95/p99 ตั้งแต่รับข้อมูลจนตัดสินใจเสร็จ การรอและงานค้างฝั่งบันทึก CPU และหน่วยความจำ รวมถึงบันทึกที่หายหรือซ้ำ ตรวจสอบความถูกต้องของสถานะและการตัดสินใจ และข้อกำหนดการเก็บรักษาบันทึก ใช้นาฬิกา monotonic วัดระยะเวลาภายในโฮสต์เดียวกัน และระบุจุดเริ่มต้นกับจุดสิ้นสุดของการวัด
รักษาการอนุมัติ สิทธิ์ และขั้นตอนพัฒนาที่มีอยู่ คำสั่งนี้เพียงอย่างเดียวไม่ได้เพิ่มสิทธิ์ให้เปลี่ยนระบบ production ทำสัญญาที่มีค่าใช้จ่าย หรือซื้อขายจริง อย่าแสดง private key ข้อมูลรับรอง หรือข้อมูลลูกค้า
รายงานสิ่งที่เปลี่ยน เงื่อนไขเปรียบเทียบ ค่าที่วัดก่อนและหลัง การตรวจสอบความถูกต้อง และข้อจำกัดที่เหลือ ค่าที่วัดไม่ได้ให้ระบุว่ายังไม่ได้วัดปรับปรุงแอปพลิเคชันนี้ในจุดที่การรอให้บันทึกข้อมูลเพื่อการวิเคราะห์เสร็จขัดขวางการนำการอัปเดตถัดไปไปใช้หรือใช้ตัดสินใจ
อ่าน README คำแนะนำการพัฒนา dependencies และลูปรับข้อมูล ใช้ภาษา runtime และไลบรารีจัดเก็บที่มีอยู่ หาจุดที่รอการบันทึกเสร็จ และระบุ thread, task หรือ event loop ที่งานทำงานจริง
1. เตรียมอินพุตที่ทำซ้ำได้โดยไม่มีข้อมูลลับ บันทึกเวลารับข้อมูล การนำสถานะไปใช้ จุดเริ่มและจบการตัดสินใจ จุดเริ่มและจบการบันทึก และผลลัพธ์ปัจจุบัน
2. ตรวจจากข้อกำหนดว่าการบันทึกเสร็จเป็นเงื่อนไขก่อนตัดสินใจหรือกู้คืนหรือไม่ คงการตรวจยอดคงเหลือ ความเสี่ยง และการจัดเก็บถาวรที่จำเป็นต่อความถูกต้องไว้ในตำแหน่งที่ต้องใช้ แยกบันทึกเพื่อการวิเคราะห์ที่สามารถบันทึกให้เสร็จภายหลังได้
3. กำหนดวิธีส่งต่อบันทึกเพื่อไม่ให้การเปลี่ยนสถานะภายหลังเปลี่ยนค่าที่กำลังบันทึก สร้างคิวเสริมที่มีขีดจำกัดและผู้รับงานบันทึก ระบุขีดจำกัดจำนวนรายการ ไบต์ และเวลารอ พฤติกรรมเมื่อคิวเต็ม บันทึกล้มเหลว ลองใหม่ และปิดระบบ รวมทั้งข้อกำหนดการเก็บรักษา อย่าทิ้งบันทึกขณะที่ยังไม่ทราบข้อกำหนดการเก็บรักษา
4. อย่าสมมติว่าแยก task แล้วจะทำงานบน CPU อื่น ตรวจสอบว่า I/O แบบ synchronous และงาน CPU ที่ใช้เวลานานทำงานที่ไหน หากใช้ worker หรือกลไกคล้ายกัน ให้จำกัดจำนวนงานพร้อมกันและรวมต้นทุนแปลงข้อมูล คัดลอก และรอส่งต่อในการประเมิน
5. ใช้อินพุตและจังหวะการมาถึงเดียวกันเพื่อจำลองการบันทึกปกติ การบันทึกช้า ความล้มเหลว คิวเสริมเต็ม และการปิดระบบ เปรียบเทียบ p50/p95/p99 ตั้งแต่รับข้อมูลจนตัดสินใจเสร็จ การรอและงานค้างฝั่งบันทึก CPU และหน่วยความจำ รวมถึงบันทึกที่หายหรือซ้ำ ตรวจสอบความถูกต้องของสถานะและการตัดสินใจ และข้อกำหนดการเก็บรักษาบันทึก ใช้นาฬิกา monotonic วัดระยะเวลาภายในโฮสต์เดียวกัน และระบุจุดเริ่มต้นกับจุดสิ้นสุดของการวัด
รักษาการอนุมัติ สิทธิ์ และขั้นตอนพัฒนาที่มีอยู่ คำสั่งนี้เพียงอย่างเดียวไม่ได้เพิ่มสิทธิ์ให้เปลี่ยนระบบ production ทำสัญญาที่มีค่าใช้จ่าย หรือซื้อขายจริง อย่าแสดง private key ข้อมูลรับรอง หรือข้อมูลลูกค้า
รายงานสิ่งที่เปลี่ยน เงื่อนไขเปรียบเทียบ ค่าที่วัดก่อนและหลัง การตรวจสอบความถูกต้อง และข้อจำกัดที่เหลือ ค่าที่วัดไม่ได้ให้ระบุว่ายังไม่ได้วัด3. อย่าให้การอัปเดตที่เป็นอิสระรอล็อกเดียวกัน
สมมติว่าแอปพลิเคชันอัปเดตราคาตลาด A และ B ได้อย่างเป็นอิสระ การอัปเดต B มาถึงหลังการอัปเดต A เริ่มแล้ว หาก mutex เดียวปกป้องทั้ง A และ B, B ต้องรอจน A ปล่อยล็อก
mutex ให้สิทธิ์เข้าถึงข้อมูลที่ปกป้องอยู่แก่การทำงานครั้งละหนึ่งงาน หากงานอื่นใช้อยู่ งานที่พยายามขอล็อกเดียวกันต้องรอ[17]
ข้อมูลของ B มาถึงแล้ว แต่กำลังรอล็อกที่ A ถืออยู่
หาก A และ B ต่างแก้ไขค่าคนละส่วน ทางเลือกหนึ่งคือปกป้องด้วยล็อกแยกกัน ครึ่งบนของแผนภาพถัดไปใช้ล็อกร่วม ครึ่งล่างใช้ล็อกแยก ตำแหน่งการมาถึงและระยะเวลาถือครองล็อกของ A และ B เท่ากันทั้งสองส่วน ตัวอย่างนี้สมมติว่าล็อกของ B ว่าง และมีทรัพยากรสำหรับประมวลผล B บทเรียนทางการของ Tokio ยังอธิบายการแบ่ง mutex สำหรับข้อมูลที่มีคีย์เป็นอิสระจากกันด้วย[18]
แถบสีน้ำเงินของ B ยาวเท่าเดิม ส่วนที่หายไปคือช่วงรอสีชมพูด้านหน้า
แถบสีน้ำเงินครอบคลุมเวลาตั้งแต่ได้ล็อกจนปล่อยล็อก ในตัวอย่างนี้ B เสร็จขณะที่ A ยังอัปเดตอยู่ การแยกล็อกไม่ได้กำจัดการรอที่เกิดจากล็อกของ B เองถูกใช้งาน หรือจากงานอื่นครอบครองทรัพยากรประมวลผลที่มีอยู่
ก่อนแยกล็อก ต้องระบุว่าการอัปเดตใดเป็นอิสระ แม้ราคา A และ B จะอัปเดตแยกกันได้ การตัดสินใจที่ใช้ทั้งสองราคาหรือยอดคงเหลือร่วมกันก็ยังต้องมีวิธีอ่านค่าที่จำเป็นอย่างสอดคล้องกัน ค่าอาจเปลี่ยนขณะงานหยุดรอที่ await แม้จะอยู่บนเธรดเดียวกันก็ตาม ต้องกำหนดว่าการตัดสินใจอ่านเวอร์ชันใด อ่านอย่างไร และนำการอัปเดตไปใช้ตามลำดับใด
ตัวอย่างเช่น หาก A และ B อ่านยอดคงเหลือเดียวกันแล้วต่างฝ่ายสร้างคำสั่งซื้อขาย ทั้งสองอาจคาดว่าจะใช้เงินก้อนเดียวกัน ค่าที่ใช้ร่วมกันยังต้องมีการปกป้องของตนเอง เช่น ให้ตัวจัดการเพียงตัวเดียวตรวจสอบยอดคงเหลือและกันเงินสำหรับแต่ละคำสั่งตามลำดับ
อีกทางเลือกคือให้แต่ละสถานะมีผู้รับผิดชอบการอัปเดตเพียงรายเดียว แล้วส่งข้อความอัปเดตให้รายนั้น นี่คือหลักการ Single Writer การแยกล็อกและการเลือกผู้เขียนข้อมูลเพียงรายเดียวเป็นการตัดสินใจออกแบบคนละเรื่อง LMAX Disruptor อธิบาย Single Writer และการพึ่งพาระหว่างขั้นตอนประมวลผล ส่วน Tokio อธิบายการจัดการสถานะผ่านข้อความที่ส่งไปยังงานเฉพาะ[5][18]
หากต้องการลดการรอล็อกระหว่างการอัปเดตสถานะที่เป็นอิสระ ให้คัดลอกคำสั่งต่อไปนี้
text
ปรับปรุงแอปพลิเคชันนี้ในกรณีที่การอัปเดตตลาดหรือคีย์หนึ่งทำให้การอัปเดตอื่นที่เป็นอิสระต้องรอล็อกร่วมตัวเดียวกัน
อ่าน README คำแนะนำการพัฒนา dependencies และโค้ดอ่านหรือเขียนสถานะ การขอล็อก หรือการรอด้วย await ใช้ภาษาและ runtime ที่มีอยู่ ระบุว่าใครอัปเดตแต่ละค่า และการตัดสินใจแต่ละครั้งอ่านค่าชุดใด
1. เก็บอินพุตที่ทำซ้ำได้โดยไม่มีข้อมูลลับ และบันทึกค่าก่อนเปลี่ยนแปลง สำหรับล็อกที่มีการแย่งใช้งาน ให้บันทึกการมาถึงแยกตามคีย์ เวลารอได้ล็อก ระยะเวลาถือล็อก ลำดับการอัปเดต และเวอร์ชันสถานะที่ใช้ตัดสินใจ
2. แยกค่าที่อัปเดตอย่างเป็นอิสระได้ออกจากค่าที่ต้องรักษาความสอดคล้องร่วมกัน แบ่งล็อกตามสถานะที่เป็นอิสระ และระบุลำดับการนำการอัปเดตไปใช้กับความรับผิดชอบการเขียนของแต่ละคีย์ให้ชัดเจน ควบคุมจำนวนล็อกหรือผู้รับผิดชอบประมวลผลไม่ให้เพิ่มโดยไร้ขีดจำกัด
3. ปกป้องการตัดสินใจที่ครอบคลุมหลายตลาดและยอดคงเหลือหรือการกันเงินที่ใช้ร่วมกัน ทำให้การตรวจยอดคงเหลือและการกันเงินเป็นการดำเนินการเดียวที่ประสานกัน เพื่อไม่ให้หลายคำสั่งซื้อขายต่างถือว่าเงินก้อนเดียวกันพร้อมใช้งาน หากต้องใช้หลายล็อก ให้กำหนดลำดับการขอล็อก
4. ตรวจสอบการเปลี่ยนสถานะข้ามจุด await และลำดับเสร็จสิ้นเมื่อถอดรหัสแบบขนาน กำหนดว่าการตัดสินใจอ่านเวอร์ชันใดและอ่านอย่างไร อย่าให้ลำดับถอดรหัสเสร็จมาแทนลำดับการนำข้อมูลไปใช้ที่จำเป็น หลังแบ่งล็อก ให้ตรวจสอบว่ายังมีการรอจากข้อจำกัดทรัพยากรประมวลผลหรือการแย่งคีย์เดียวกันหรือไม่
5. เล่นซ้ำอินพุตและลำดับการมาถึงเดิม โดยครอบคลุมคีย์อิสระ การอัปเดตที่กระจุกตัวบนคีย์เดียว การแย่งกันกันเงินจากยอดร่วม และงานที่พักแล้วกลับมาทำต่อ เปรียบเทียบเวลารอล็อก p50/p95/p99 ตั้งแต่รับข้อมูลจนตัดสินใจเสร็จ CPU และหน่วยความจำ ตรวจสอบลำดับอัปเดตที่จำเป็น ความสอดคล้องของสถานะที่ใช้ตัดสินใจ และการไม่กันเงินซ้ำ ใช้นาฬิกา monotonic วัดระยะเวลาภายในโฮสต์เดียวกัน และระบุจุดเริ่มต้นกับจุดสิ้นสุดของการวัด
รักษาการอนุมัติ สิทธิ์ และขั้นตอนพัฒนาที่มีอยู่ คำสั่งนี้เพียงอย่างเดียวไม่ได้เพิ่มสิทธิ์ให้เปลี่ยนระบบ production ทำสัญญาที่มีค่าใช้จ่าย หรือซื้อขายจริง อย่าแสดง private key ข้อมูลรับรอง หรือข้อมูลลูกค้า
รายงานสิ่งที่เปลี่ยน เงื่อนไขเปรียบเทียบ ค่าที่วัดก่อนและหลัง การตรวจสอบความถูกต้อง และข้อจำกัดที่เหลือ ค่าที่วัดไม่ได้ให้ระบุว่ายังไม่ได้วัดปรับปรุงแอปพลิเคชันนี้ในกรณีที่การอัปเดตตลาดหรือคีย์หนึ่งทำให้การอัปเดตอื่นที่เป็นอิสระต้องรอล็อกร่วมตัวเดียวกัน
อ่าน README คำแนะนำการพัฒนา dependencies และโค้ดอ่านหรือเขียนสถานะ การขอล็อก หรือการรอด้วย await ใช้ภาษาและ runtime ที่มีอยู่ ระบุว่าใครอัปเดตแต่ละค่า และการตัดสินใจแต่ละครั้งอ่านค่าชุดใด
1. เก็บอินพุตที่ทำซ้ำได้โดยไม่มีข้อมูลลับ และบันทึกค่าก่อนเปลี่ยนแปลง สำหรับล็อกที่มีการแย่งใช้งาน ให้บันทึกการมาถึงแยกตามคีย์ เวลารอได้ล็อก ระยะเวลาถือล็อก ลำดับการอัปเดต และเวอร์ชันสถานะที่ใช้ตัดสินใจ
2. แยกค่าที่อัปเดตอย่างเป็นอิสระได้ออกจากค่าที่ต้องรักษาความสอดคล้องร่วมกัน แบ่งล็อกตามสถานะที่เป็นอิสระ และระบุลำดับการนำการอัปเดตไปใช้กับความรับผิดชอบการเขียนของแต่ละคีย์ให้ชัดเจน ควบคุมจำนวนล็อกหรือผู้รับผิดชอบประมวลผลไม่ให้เพิ่มโดยไร้ขีดจำกัด
3. ปกป้องการตัดสินใจที่ครอบคลุมหลายตลาดและยอดคงเหลือหรือการกันเงินที่ใช้ร่วมกัน ทำให้การตรวจยอดคงเหลือและการกันเงินเป็นการดำเนินการเดียวที่ประสานกัน เพื่อไม่ให้หลายคำสั่งซื้อขายต่างถือว่าเงินก้อนเดียวกันพร้อมใช้งาน หากต้องใช้หลายล็อก ให้กำหนดลำดับการขอล็อก
4. ตรวจสอบการเปลี่ยนสถานะข้ามจุด await และลำดับเสร็จสิ้นเมื่อถอดรหัสแบบขนาน กำหนดว่าการตัดสินใจอ่านเวอร์ชันใดและอ่านอย่างไร อย่าให้ลำดับถอดรหัสเสร็จมาแทนลำดับการนำข้อมูลไปใช้ที่จำเป็น หลังแบ่งล็อก ให้ตรวจสอบว่ายังมีการรอจากข้อจำกัดทรัพยากรประมวลผลหรือการแย่งคีย์เดียวกันหรือไม่
5. เล่นซ้ำอินพุตและลำดับการมาถึงเดิม โดยครอบคลุมคีย์อิสระ การอัปเดตที่กระจุกตัวบนคีย์เดียว การแย่งกันกันเงินจากยอดร่วม และงานที่พักแล้วกลับมาทำต่อ เปรียบเทียบเวลารอล็อก p50/p95/p99 ตั้งแต่รับข้อมูลจนตัดสินใจเสร็จ CPU และหน่วยความจำ ตรวจสอบลำดับอัปเดตที่จำเป็น ความสอดคล้องของสถานะที่ใช้ตัดสินใจ และการไม่กันเงินซ้ำ ใช้นาฬิกา monotonic วัดระยะเวลาภายในโฮสต์เดียวกัน และระบุจุดเริ่มต้นกับจุดสิ้นสุดของการวัด
รักษาการอนุมัติ สิทธิ์ และขั้นตอนพัฒนาที่มีอยู่ คำสั่งนี้เพียงอย่างเดียวไม่ได้เพิ่มสิทธิ์ให้เปลี่ยนระบบ production ทำสัญญาที่มีค่าใช้จ่าย หรือซื้อขายจริง อย่าแสดง private key ข้อมูลรับรอง หรือข้อมูลลูกค้า
รายงานสิ่งที่เปลี่ยน เงื่อนไขเปรียบเทียบ ค่าที่วัดก่อนและหลัง การตรวจสอบความถูกต้อง และข้อจำกัดที่เหลือ ค่าที่วัดไม่ได้ให้ระบุว่ายังไม่ได้วัด4. เตรียมส่วนที่ไม่เปลี่ยนล่วงหน้า เพื่อลดงานหลังข้อมูลมาถึง
สมมติว่าทุกครั้งที่ราคาอัปเดต แอปพลิเคชันต้องแยกวิเคราะห์ ID คงที่เดิม คำนวณแอดเดรสคงที่จากอินพุตเดิม และจัดสรรหน่วยความจำทำงาน หน่วยความจำนี้เรียกอีกอย่างว่าบัฟเฟอร์ การทำสามขั้นตอนนี้ซ้ำทำให้เวลาที่ใช้เตรียมข้อมูลซึ่งไม่เปลี่ยนอยู่บนเส้นทางของทุกการตัดสินใจ
การเตรียมที่อินพุตไม่เปลี่ยนสามารถทำให้เสร็จก่อนข้อมูลมาถึงและนำกลับมาใช้ได้ หลังรับข้อมูล แอปพลิเคชันตรวจสอบข้อมูลที่เปลี่ยนสำหรับเหตุการณ์นี้ สร้างข้อความสุดท้ายที่จะส่ง และลงลายมือชื่อให้เนื้อหานั้น
ย้ายการเตรียมส่วนที่ไม่เปลี่ยนไปไว้ก่อน แต่ยังตรวจสอบเนื้อหาปัจจุบันและลงลายมือชื่อหลังข้อมูลมาถึง
ลองนับสิ่งที่เปลี่ยนสำหรับการอัปเดตสามรายการ การเตรียมสามประเภทสำหรับทุกเหตุการณ์ต้องเตรียมเก้าครั้ง หากเตรียมสามประเภทนั้นเพียงครั้งเดียวแล้วนำมาใช้ซ้ำตามลำดับ จะเหลือสามครั้ง ทั้งสองแบบยังรับสามเหตุการณ์ ประมวลผลทีละเหตุการณ์ และสร้างผลลัพธ์สามรายการ
ในตัวอย่างนี้ จำนวนเหตุการณ์ยังเป็นสาม แต่การเตรียมส่วนคงที่ลดจากเก้าครั้งเหลือสามครั้ง
การเปรียบเทียบนี้สมมติว่าเงื่อนไขคงที่ไม่เปลี่ยน และสามารถนำหน่วยความจำทำงานมาใช้ซ้ำอย่างปลอดภัยตามลำดับได้ เนื้อหาภายในยังต้องอัปเดตให้ตรงกับเหตุการณ์ปัจจุบันทุกครั้ง หากหลายงานทำงานพร้อมกัน ต้องใช้พื้นที่แยกสำหรับแต่ละงานหรือใช้พูลที่จัดการสิทธิ์เข้าถึง เพื่อไม่ให้เขียนทับหน่วยความจำเดียวกัน
ขยายตัวอย่างเดิมเป็น 1,000 เหตุการณ์ การเตรียมสามประเภทสำหรับทุกเหตุการณ์ต้องทำ 3,000 ครั้ง แต่การเตรียมร่วมเพียงครั้งเดียวต้องทำสามครั้ง ทั้งสองแบบรับ 1,000 เหตุการณ์ ประมวลผลทีละเหตุการณ์ และสร้างผลลัพธ์ 1,000 รายการ ต้องแยกจำนวนครั้งของการเตรียมออกจากจำนวนเหตุการณ์ที่ประมวลผล
สิ่งที่ลดลงคือการเตรียมส่วนคงที่ซ้ำ ๆ การตรวจสอบ การตัดสินใจ การลงลายมือชื่อ และงานอื่นยังคงอยู่ ดังนั้นอัตราส่วนของจำนวนครั้งนี้จึงไม่ใช่อัตราเร่งของทั้งแอปพลิเคชัน
กำหนดเงื่อนไขที่ทำให้การใช้ซ้ำยังถูกต้อง หากอินพุตสำหรับคำนวณแอดเดรสคงที่เปลี่ยน ต้องคำนวณแอดเดรสใหม่ ราคา ปริมาณ ยอดคงเหลือ สถานะบัญชีที่อ้างอิง ขีดจำกัดความเสี่ยง และ blockhash ต้องใช้ได้ ณ เวลาตัดสินใจ หากแอปพลิเคชันเก็บสถานะภายในที่อัปเดตต่อเนื่อง ต้องตรวจเวอร์ชัน ความสดใหม่ และความถูกต้อง การทำเช่นนี้ไม่ได้หมายความว่าต้องดึงข้อมูลทั้งหมดผ่าน RPC ใหม่ทุกครั้งที่ตัดสินใจ
getLatestBlockhash ของ Solana คืนค่า blockhash พร้อม lastValidBlockHeight เมื่อตรวจการหมดอายุ ต้องแยกความสูงบล็อกออกจาก slot[7] กำหนดข้อความให้เสร็จก่อนลงลายมือชื่อ หากแก้ข้อความหลังลงลายมือชื่อ ต้องสร้างลายมือชื่อสำหรับเนื้อหาที่อัปเดตแล้วใหม่[19]
หากต้องการใช้การเตรียมส่วนคงที่ซ้ำและลดงานหลังรับข้อมูล ให้คัดลอกคำสั่งต่อไปนี้
text
ตรวจสอบงานที่แยกวิเคราะห์ข้อมูล คำนวณที่อยู่ หรือจัดสรรหน่วยความจำแบบเดิมซ้ำสำหรับทุกอินพุต แล้วนำการเตรียมที่ใช้ซ้ำได้ไปทำก่อนรับข้อมูล
อ่าน README คำแนะนำการพัฒนา dependencies และโค้ดรับข้อมูล → เตรียม → ตัดสินใจ → สร้างข้อความ → ลงลายเซ็น ใช้ภาษา runtime และ SDK ที่มีอยู่ ระบุอินพุต เอาต์พุต ผู้เป็นเจ้าของ และช่วงเวลาที่ผลการเตรียมแต่ละอย่างใช้ได้
1. เก็บอินพุตที่ทำซ้ำได้โดยไม่มีข้อมูลลับ บันทึกจำนวนเหตุการณ์และเอาต์พุต จำนวนครั้งและระยะเวลาของการเตรียมแต่ละอย่าง หน่วยความจำที่จัดสรร และระยะเวลาตั้งแต่รับข้อมูลจนตัดสินใจเสร็จ
2. ระบุการเตรียมที่อินพุตไม่เปลี่ยน ทำงานนั้นระหว่างเริ่มต้นระบบหรือขั้นตอนก่อนหน้าที่เหมาะสม แล้วนำผลมาใช้ซ้ำ สร้างคีย์สำหรับใช้ซ้ำ กลไกยกเลิกความใช้ได้และคำนวณใหม่เมื่ออินพุตหรือการตั้งค่าเปลี่ยน และขีดจำกัดของแคชกับ buffer pool
3. อัปเดตเนื้อหาในหน่วยความจำทำงานที่ใช้ซ้ำให้เป็นอินพุตปัจจุบัน หากมีงานพร้อมกัน ให้ใช้พื้นที่แยกหรือระบบยืมคืนที่จัดการได้ เพื่อไม่ให้เขียนทับหรือคืนพื้นที่ระหว่างที่ยังใช้งาน
4. ตรวจสอบราคา ปริมาณ ยอดคงเหลือ สถานะบัญชี เงื่อนไขความเสี่ยง และ blockhash ตามข้อกำหนดของการตัดสินใจ หากใช้สถานะภายในที่อัปเดตต่อเนื่อง ให้ตรวจเวอร์ชันและความสดใหม่ สำหรับ Solana ต้องแยก block height ออกจาก slot เมื่อใช้ lastValidBlockHeight ตรวจการหมดอายุของ blockhash กำหนดข้อความสุดท้ายให้เสร็จก่อนลงลายเซ็น และลงลายเซ็นข้อความที่แก้ไขใหม่หากเนื้อหาเปลี่ยนหลังลงลายเซ็น
5. ใช้อินพุตเดียวกันเปรียบเทียบจำนวนครั้งและเวลาของการเตรียม p50/p95/p99 ตั้งแต่รับข้อมูลจนตัดสินใจเสร็จ CPU และหน่วยความจำ และเอาต์พุต จำลองการเปลี่ยนอินพุตหรือการตั้งค่า การหมดอายุ และการทำงานพร้อมกันด้วย เพื่อตรวจการใช้ผลเก่าผิดพลาดและความขัดแย้งของหน่วยความจำ อย่าถือว่าอัตราส่วนจำนวนการเตรียมคืออัตราเร่งของทั้งระบบ ใช้นาฬิกา monotonic วัดระยะเวลาภายในโฮสต์เดียวกัน และระบุจุดเริ่มต้นกับจุดสิ้นสุดของการวัด
รักษาการอนุมัติ สิทธิ์ และขั้นตอนพัฒนาที่มีอยู่ คำสั่งนี้เพียงอย่างเดียวไม่ได้เพิ่มสิทธิ์ให้เปลี่ยนระบบ production ทำสัญญาที่มีค่าใช้จ่าย หรือซื้อขายจริง อย่าแสดง private key ข้อมูลรับรอง หรือข้อมูลลูกค้า
รายงานสิ่งที่เปลี่ยน เงื่อนไขเปรียบเทียบ ค่าที่วัดก่อนและหลัง การตรวจสอบความถูกต้อง และข้อจำกัดที่เหลือ ค่าที่วัดไม่ได้ให้ระบุว่ายังไม่ได้วัดตรวจสอบงานที่แยกวิเคราะห์ข้อมูล คำนวณที่อยู่ หรือจัดสรรหน่วยความจำแบบเดิมซ้ำสำหรับทุกอินพุต แล้วนำการเตรียมที่ใช้ซ้ำได้ไปทำก่อนรับข้อมูล
อ่าน README คำแนะนำการพัฒนา dependencies และโค้ดรับข้อมูล → เตรียม → ตัดสินใจ → สร้างข้อความ → ลงลายเซ็น ใช้ภาษา runtime และ SDK ที่มีอยู่ ระบุอินพุต เอาต์พุต ผู้เป็นเจ้าของ และช่วงเวลาที่ผลการเตรียมแต่ละอย่างใช้ได้
1. เก็บอินพุตที่ทำซ้ำได้โดยไม่มีข้อมูลลับ บันทึกจำนวนเหตุการณ์และเอาต์พุต จำนวนครั้งและระยะเวลาของการเตรียมแต่ละอย่าง หน่วยความจำที่จัดสรร และระยะเวลาตั้งแต่รับข้อมูลจนตัดสินใจเสร็จ
2. ระบุการเตรียมที่อินพุตไม่เปลี่ยน ทำงานนั้นระหว่างเริ่มต้นระบบหรือขั้นตอนก่อนหน้าที่เหมาะสม แล้วนำผลมาใช้ซ้ำ สร้างคีย์สำหรับใช้ซ้ำ กลไกยกเลิกความใช้ได้และคำนวณใหม่เมื่ออินพุตหรือการตั้งค่าเปลี่ยน และขีดจำกัดของแคชกับ buffer pool
3. อัปเดตเนื้อหาในหน่วยความจำทำงานที่ใช้ซ้ำให้เป็นอินพุตปัจจุบัน หากมีงานพร้อมกัน ให้ใช้พื้นที่แยกหรือระบบยืมคืนที่จัดการได้ เพื่อไม่ให้เขียนทับหรือคืนพื้นที่ระหว่างที่ยังใช้งาน
4. ตรวจสอบราคา ปริมาณ ยอดคงเหลือ สถานะบัญชี เงื่อนไขความเสี่ยง และ blockhash ตามข้อกำหนดของการตัดสินใจ หากใช้สถานะภายในที่อัปเดตต่อเนื่อง ให้ตรวจเวอร์ชันและความสดใหม่ สำหรับ Solana ต้องแยก block height ออกจาก slot เมื่อใช้ lastValidBlockHeight ตรวจการหมดอายุของ blockhash กำหนดข้อความสุดท้ายให้เสร็จก่อนลงลายเซ็น และลงลายเซ็นข้อความที่แก้ไขใหม่หากเนื้อหาเปลี่ยนหลังลงลายเซ็น
5. ใช้อินพุตเดียวกันเปรียบเทียบจำนวนครั้งและเวลาของการเตรียม p50/p95/p99 ตั้งแต่รับข้อมูลจนตัดสินใจเสร็จ CPU และหน่วยความจำ และเอาต์พุต จำลองการเปลี่ยนอินพุตหรือการตั้งค่า การหมดอายุ และการทำงานพร้อมกันด้วย เพื่อตรวจการใช้ผลเก่าผิดพลาดและความขัดแย้งของหน่วยความจำ อย่าถือว่าอัตราส่วนจำนวนการเตรียมคืออัตราเร่งของทั้งระบบ ใช้นาฬิกา monotonic วัดระยะเวลาภายในโฮสต์เดียวกัน และระบุจุดเริ่มต้นกับจุดสิ้นสุดของการวัด
รักษาการอนุมัติ สิทธิ์ และขั้นตอนพัฒนาที่มีอยู่ คำสั่งนี้เพียงอย่างเดียวไม่ได้เพิ่มสิทธิ์ให้เปลี่ยนระบบ production ทำสัญญาที่มีค่าใช้จ่าย หรือซื้อขายจริง อย่าแสดง private key ข้อมูลรับรอง หรือข้อมูลลูกค้า
รายงานสิ่งที่เปลี่ยน เงื่อนไขเปรียบเทียบ ค่าที่วัดก่อนและหลัง การตรวจสอบความถูกต้อง และข้อจำกัดที่เหลือ ค่าที่วัดไม่ได้ให้ระบุว่ายังไม่ได้วัด5. อย่าตัดสินใจต่อเมื่อขาดการอัปเดตที่จำเป็น
สมมติว่ามีสองตลาดสำหรับสินทรัพย์เดียวกัน และแอปพลิเคชันคำนวณส่วนต่างราคา B−A ระหว่างการเชื่อมต่อขาด ตลาด A เปลี่ยนจาก 100 เป็น 105 แต่แอปพลิเคชันพลาดการอัปเดตนั้น หากหลังเชื่อมต่อใหม่ได้รับเพียงราคา B ที่ 104 จะคำนวณ 104−100 ได้ +4 แต่ถ้าใช้ค่า A ที่อัปเดตแล้วจะได้ 104−105 หรือ -1 แม้แต่เครื่องหมายของผลลัพธ์ก็เปลี่ยน
การคำนวณแบบเดียวกันให้ผลต่างกันตามว่าจะใช้ค่าเก่า 100 หรือค่าใหม่ 105 ของ A
แบบจำลองนี้แสดงเพียงส่วนต่างราคา ไม่รวมค่าธรรมเนียม เงื่อนไขการจับคู่คำสั่ง และปัจจัยอื่น อีกทั้งไม่ใช่กำไรจากการซื้อขาย ประเด็นคือการเชื่อมต่อกลับมาไม่ได้แปลว่าการอัปเดตทั้งหมดที่จำเป็นต่อการตัดสินใจกลับมาครบแล้ว
ในตัวอย่างนี้ ให้หยุดการตัดสินใจซื้อขายใหม่ที่ใช้ราคา A และ B แล้วแทนค่าเก่า 100 ของ A ด้วยค่าที่กู้คืนได้คือ 105 จากนั้นยืนยันว่าอัปเดตที่จำเป็นต่อการตัดสินใจถูกนำไปใช้กับ A และ B ครบ และเป็นไปตามเงื่อนไขด้านลำดับและความสดใหม่ กลับมาทำงานเมื่อการตรวจสอบที่จำเป็นครบถ้วนแล้ว หากตรวจสอบไม่สำเร็จให้หยุดต่อไป
แยกขั้นตอนอัปเดตค่าออกจากขั้นตอนยืนยันว่าค่าเหล่านั้นใช้ตัดสินใจได้
กลไกกู้คืนที่พบได้บ่อยคือ snapshot ซึ่งเป็นชุดสถานะ ณ จุดเวลาหนึ่ง เมื่อเชื่อม snapshot กับสตรีมอัปเดตต่อเนื่อง ต้องระบุว่าการอัปเดตใดอยู่ใน snapshot แล้ว และการอัปเดตใดหลังจากนั้นต้องนำมาใช้ เพื่อไม่ให้นำส่วนเปลี่ยนแปลงที่รวมไว้แล้วมาใช้ซ้ำหรือพลาดการอัปเดตตรงรอยต่อ วิธีที่แน่นอนต้องเป็นไปตามการรับประกันของ API ที่เลือกเกี่ยวกับการเริ่มสมัครรับ การระบุข้อมูล การดึงซ้ำ และการเล่นข้อมูลย้อนหลัง
ข้อความ Yellowstone มีฟิลด์ เช่น slot และ write_version[16] การมีฟิลด์เหล่านี้เพียงอย่างเดียวไม่ได้รับประกันลำดับที่ใช้ร่วมกันระหว่างผู้ให้บริการ หรือการตรวจพบช่องว่างของข้อมูลได้ครบถ้วน อย่าแปลงส่วนต่าง slot เป็นจำนวนอัปเดตที่หายหรือจำนวนวินาทีของความหน่วงโดยตรง ต้องตรวจสอบว่าสถานะถูกเชื่อมต่อกลับอย่างถูกต้องตามการรับประกันของผู้ให้บริการที่เลือก
ต้องพิจารณาการคำนวณที่เริ่มก่อนกู้คืนด้วย งานที่เริ่มด้วยสถานะเก่าแต่เสร็จหลังการกู้คืนอาจนำผลของมันมาเขียนทับสถานะใหม่ วิธีหนึ่งคือให้หมายเลขรุ่นของสถานะเปลี่ยนเมื่อมีการกู้คืน และปฏิเสธผลจากรุ่นก่อน หากใช้สถานะ processed ให้รวม rollback ซึ่งหมายถึงสถานะนั้นไม่ถูกยอมรับอีกต่อไป เป็นเงื่อนไขที่ต้องตรวจทานสถานะด้วย[6]
หากต้องการกู้คืนสถานะที่ถูกต้องก่อนกลับมาตัดสินใจหลังเชื่อมต่อใหม่ ให้คัดลอกคำสั่งต่อไปนี้
text
ป้องกันไม่ให้แอปพลิเคชันนี้กลับมาตัดสินใจซื้อขายบนสถานะเก่าเพียงเพราะการเชื่อมต่อกลับมาแล้ว สร้างการกู้คืนสถานะที่จำเป็นก่อนกลับมาตัดสินใจ
อ่าน README คำแนะนำการพัฒนา dependencies และโค้ดสมัครรับข้อมูล ดึงข้อมูลเริ่มต้น นำการอัปเดตไปใช้ เชื่อมต่อใหม่ และตัดสินใจ ใช้ภาษา runtime และ SDK ที่มีอยู่ ตรวจสอบผู้ให้บริการ commitment ความหมายของการอัปเดต และการรับประกันจริงเรื่องลำดับ การระบุรายการ การดึงซ้ำ และการเล่นข้อมูลซ้ำ
1. แยกสถานะการเชื่อมต่อ ความใช้ได้ของข้อมูล และสิทธิ์ในการกลับมาตัดสินใจ หากยืนยันว่าขาดการอัปเดตที่จำเป็นหรือข้อมูลสดใหม่ไม่พอ ให้พักการตัดสินใจซื้อขายใหม่ที่ขึ้นกับสถานะนั้น ขณะเดียวกันให้ดำเนินการรับข้อมูล อัปเดต และกู้คืนที่จำเป็นต่อไป
2. หากใช้ snapshot ให้ตรวจจากการรับประกันของผู้ให้บริการว่าครอบคลุมการอัปเดตใด และมีรอยต่อกับ stream ถัดไปตรงไหน ป้องกันการนำ delta ไปใช้ซ้ำ ช่องว่างที่รอยต่อ และลำดับนำข้อมูลไปใช้ที่ผิด อย่าเติมส่วนที่ไม่มีการรับประกันด้วยสมมติฐาน อย่าถือว่า slot หรือ write_version เป็นลำดับที่ใช้ตรวจการอัปเดตสูญหายได้โดยไม่มีเงื่อนไข
3. อย่ากลับมาตัดสินใจเพียงเพราะดึงค่าได้แล้ว สร้างการตรวจการอัปเดต ลำดับ ความสดใหม่ และความสอดคล้องที่จำเป็นต่อการตัดสินใจที่ได้รับผลกระทบ และพักการตัดสินใจเหล่านั้นต่อหากยังตรวจไม่ครบ ใช้ generation หรือกลไกเทียบเท่าเพื่อป้องกันการนำผลคำนวณหรือข้อเสนอคำสั่งซื้อขายเก่าไปใช้หรือส่งออก หากงานที่เริ่มก่อนกู้คืนมาจบภายหลัง เมื่อกลับมาทำงาน ให้ตัดสินใจใหม่จากสถานะที่ตรวจสอบแล้ว หากใช้สถานะ processed ให้จัดการการยกเลิกความใช้ได้และกู้คืนหลัง rollback
4. ใช้อินพุตที่ทำซ้ำได้และไม่มีข้อมูลลับ จำลองการอัปเดตที่พลาดระหว่างตัดการเชื่อมต่อ รายการซ้ำ การอัปเดตผิดลำดับ ข้อมูลเก่า การเชื่อมต่อใหม่ซ้ำ ๆ และงานของ generation เก่าที่มาจบทีหลัง ตรวจสอบว่าการตัดสินใจยังพักอยู่ตั้งแต่เชื่อมต่อกลับมาจนตรวจสอบเสร็จ และสถานะที่ตรวจแล้วตรงกับผลที่คาดหวัง
5. บันทึกเวลากู้คืน จำนวนครั้งที่พยายามตัดสินใจแต่ถูกระงับเพราะสถานะไม่ถูกต้องและระยะเวลาที่พัก การอัปเดตที่นำไปใช้ซ้ำหรือคัดออก ระยะเวลาปกติตั้งแต่รับข้อมูลจนตัดสินใจเสร็จ CPU และหน่วยความจำ อย่าตัดช่วงพักหรือการอัปเดตที่หายออกจากการวัดโดยไม่แจ้ง ระบุขอบเขตการวัดและสิ่งที่ตรวจพบได้กับไม่ได้ ใช้นาฬิกา monotonic วัดระยะเวลาภายในโฮสต์เดียวกัน
รักษาการอนุมัติ สิทธิ์ และขั้นตอนพัฒนาที่มีอยู่ คำสั่งนี้เพียงอย่างเดียวไม่ได้เพิ่มสิทธิ์ให้เปลี่ยนระบบ production ทำสัญญาที่มีค่าใช้จ่าย หรือซื้อขายจริง อย่าแสดง private key ข้อมูลรับรอง หรือข้อมูลลูกค้า
รายงานสิ่งที่เปลี่ยน เงื่อนไขเปรียบเทียบ ค่าที่วัดก่อนและหลัง การตรวจสอบความถูกต้อง และข้อจำกัดที่เหลือ ค่าที่วัดไม่ได้ให้ระบุว่ายังไม่ได้วัดป้องกันไม่ให้แอปพลิเคชันนี้กลับมาตัดสินใจซื้อขายบนสถานะเก่าเพียงเพราะการเชื่อมต่อกลับมาแล้ว สร้างการกู้คืนสถานะที่จำเป็นก่อนกลับมาตัดสินใจ
อ่าน README คำแนะนำการพัฒนา dependencies และโค้ดสมัครรับข้อมูล ดึงข้อมูลเริ่มต้น นำการอัปเดตไปใช้ เชื่อมต่อใหม่ และตัดสินใจ ใช้ภาษา runtime และ SDK ที่มีอยู่ ตรวจสอบผู้ให้บริการ commitment ความหมายของการอัปเดต และการรับประกันจริงเรื่องลำดับ การระบุรายการ การดึงซ้ำ และการเล่นข้อมูลซ้ำ
1. แยกสถานะการเชื่อมต่อ ความใช้ได้ของข้อมูล และสิทธิ์ในการกลับมาตัดสินใจ หากยืนยันว่าขาดการอัปเดตที่จำเป็นหรือข้อมูลสดใหม่ไม่พอ ให้พักการตัดสินใจซื้อขายใหม่ที่ขึ้นกับสถานะนั้น ขณะเดียวกันให้ดำเนินการรับข้อมูล อัปเดต และกู้คืนที่จำเป็นต่อไป
2. หากใช้ snapshot ให้ตรวจจากการรับประกันของผู้ให้บริการว่าครอบคลุมการอัปเดตใด และมีรอยต่อกับ stream ถัดไปตรงไหน ป้องกันการนำ delta ไปใช้ซ้ำ ช่องว่างที่รอยต่อ และลำดับนำข้อมูลไปใช้ที่ผิด อย่าเติมส่วนที่ไม่มีการรับประกันด้วยสมมติฐาน อย่าถือว่า slot หรือ write_version เป็นลำดับที่ใช้ตรวจการอัปเดตสูญหายได้โดยไม่มีเงื่อนไข
3. อย่ากลับมาตัดสินใจเพียงเพราะดึงค่าได้แล้ว สร้างการตรวจการอัปเดต ลำดับ ความสดใหม่ และความสอดคล้องที่จำเป็นต่อการตัดสินใจที่ได้รับผลกระทบ และพักการตัดสินใจเหล่านั้นต่อหากยังตรวจไม่ครบ ใช้ generation หรือกลไกเทียบเท่าเพื่อป้องกันการนำผลคำนวณหรือข้อเสนอคำสั่งซื้อขายเก่าไปใช้หรือส่งออก หากงานที่เริ่มก่อนกู้คืนมาจบภายหลัง เมื่อกลับมาทำงาน ให้ตัดสินใจใหม่จากสถานะที่ตรวจสอบแล้ว หากใช้สถานะ processed ให้จัดการการยกเลิกความใช้ได้และกู้คืนหลัง rollback
4. ใช้อินพุตที่ทำซ้ำได้และไม่มีข้อมูลลับ จำลองการอัปเดตที่พลาดระหว่างตัดการเชื่อมต่อ รายการซ้ำ การอัปเดตผิดลำดับ ข้อมูลเก่า การเชื่อมต่อใหม่ซ้ำ ๆ และงานของ generation เก่าที่มาจบทีหลัง ตรวจสอบว่าการตัดสินใจยังพักอยู่ตั้งแต่เชื่อมต่อกลับมาจนตรวจสอบเสร็จ และสถานะที่ตรวจแล้วตรงกับผลที่คาดหวัง
5. บันทึกเวลากู้คืน จำนวนครั้งที่พยายามตัดสินใจแต่ถูกระงับเพราะสถานะไม่ถูกต้องและระยะเวลาที่พัก การอัปเดตที่นำไปใช้ซ้ำหรือคัดออก ระยะเวลาปกติตั้งแต่รับข้อมูลจนตัดสินใจเสร็จ CPU และหน่วยความจำ อย่าตัดช่วงพักหรือการอัปเดตที่หายออกจากการวัดโดยไม่แจ้ง ระบุขอบเขตการวัดและสิ่งที่ตรวจพบได้กับไม่ได้ ใช้นาฬิกา monotonic วัดระยะเวลาภายในโฮสต์เดียวกัน
รักษาการอนุมัติ สิทธิ์ และขั้นตอนพัฒนาที่มีอยู่ คำสั่งนี้เพียงอย่างเดียวไม่ได้เพิ่มสิทธิ์ให้เปลี่ยนระบบ production ทำสัญญาที่มีค่าใช้จ่าย หรือซื้อขายจริง อย่าแสดง private key ข้อมูลรับรอง หรือข้อมูลลูกค้า
รายงานสิ่งที่เปลี่ยน เงื่อนไขเปรียบเทียบ ค่าที่วัดก่อนและหลัง การตรวจสอบความถูกต้อง และข้อจำกัดที่เหลือ ค่าที่วัดไม่ได้ให้ระบุว่ายังไม่ได้วัดเปรียบเทียบจุดแข็งของภาษาในหกด้าน
การนำการออกแบบทั้งห้านี้ไปใช้ต้องตัดสินใจว่าใครอัปเดตข้อมูล จัดสรรหน่วยความจำที่ไหน คัดลอกอะไร และงานใดต้องรอ การคำนวณที่เร็ว การควบคุมความล่าช้าฉับพลัน และการทำต้นแบบได้เร็วเป็นจุดแข็งคนละด้าน เปรียบเทียบภาษาตามส่วนที่ต้องการปรับปรุง
เปรียบเทียบเวลาทำงานจากเบนช์มาร์กที่เผยแพร่
ผลวัดที่เผยแพร่ลงวันที่ 1 สิงหาคม 2025 นี้คำนวณวัตถุห้าชิ้นเป็นจำนวน 500,000 ขั้นตอน เวลาทำงานเฉลี่ยคือค่าเฉลี่ยของเวลาตั้งแต่เริ่มโปรแกรมจนประมวลผลเสร็จ โดยรวมการเริ่มต้นและการปรับประสิทธิภาพโค้ดระหว่างทำงาน แต่ไม่รวมขั้นตอนบิลด์ล่วงหน้า 1,000 ms เท่ากับหนึ่งวินาที[27][29]
| ภาษา / runtime | เวลาทำงานเฉลี่ย | อัตราสัมพัทธ์ (Python = 1) |
|---|---|---|
| Rust / rustc 1.88.0 | 25.1 ms | ≈118 |
| C++ / g++ 11.4.0 | 33.2 ms | ≈90 |
| Zig / Zig 0.14.1 | 33.3 ms | ≈89 |
| Go / Go 1.24.5 | 38.4 ms | ≈77 |
| TypeScript / Deno 2.4.3 | 77.6 ms | ≈38 |
| JavaScript / Node.js 24.4.1 | 79.1 ms | ≈38 |
| Python / CPython 3.13.5 | 2970.8 ms | 1 |
อัตราสัมพัทธ์คำนวณจากเวลาเฉลี่ยก่อนปัดเศษ โดยกำหนดให้ Python = 1 สำหรับแต่ละกลุ่มภาษาและ runtime เราเลือกค่าเฉลี่ยที่เผยแพร่ต่ำสุดจากรุ่นเสถียรซึ่งส่วนคำนวณตัวเลขใช้เธรดเดียว โดยไม่มีคำสั่ง SIMD แบบชัดเจน ชนิดเวกเตอร์ หรือไลบรารีคำนวณตัวเลขภายนอก โค้ดและการปรับประสิทธิภาพแตกต่างกัน โดย Zig ใช้ ReleaseFast ส่วน TypeScript ทำงานเป็นไฟล์เรียกใช้ที่มี Deno/V8 รวมอยู่ และ JavaScript ทำงานบน Node.js[28]
ให้อ่านค่าที่ใกล้กันว่าเป็นผลที่ใกล้เคียงกัน โดยไม่ใช้โจทย์เดียวนี้จัดอันดับภาษาโดยรวม ผลนี้ไม่ได้วัดเวลาประมวลผลของบอตที่ทำงานต่อเนื่องหลังเริ่มต้น หรือความหน่วงจนคำสั่งซื้อขายไปถึงปลายทางโดยตรง
สภาพแวดล้อมที่บันทึกไว้คือ Linux บน AMD EPYC 7763 ที่มีคอร์ให้ใช้สี่คอร์ โค้ดวัดที่เผยแพร่ตั้งค่าให้ทำซ้ำสามครั้งต่อเงื่อนไข โดยเริ่มกระบวนการใหม่ทุกครั้ง ไม่สามารถยืนยันคอมมิตที่ใช้ในการรันครั้งนั้นหรือข้อมูลดิบของการวัดแต่ละครั้งได้ จึงนำเสนอเป็นค่าเฉลี่ยที่เผยแพร่[28][29]
เปรียบเทียบจุดแข็งด้านการออกแบบในหกมิติ
แผนภาพต่อไปนี้เป็นแนวทางเลือกสามระดับตามการประเมินของผู้เขียน สำหรับไคลเอนต์ Solana ที่ทำงานนอกเชน ด้านความเร็วในการคำนวณพิจารณาทางเลือกในการเร่งการอ่านข้อมูลปริมาณมากและการคำนวณที่เขียนโดยตรงในภาษาและ implementation ที่เปรียบเทียบ ไม่ได้จัดอันดับทั้งแอปพลิเคชันที่ใช้เวลาส่วนใหญ่รอเครือข่าย หรืองานคำนวณที่ส่งให้ไลบรารีภายนอกแบบเร่งความเร็ว
Rust, Go, C++ และ Zig เป็นตัวเลือกที่เหมาะกับการทำงานแบบ native ที่ปรับให้มีประสิทธิภาพ ไม่ได้หมายความว่าเร็วเท่ากัน การเรียงลำดับละเอียดต้องวัดจากภาระงานจริง V8 ก็แปลงฟังก์ชันที่ทำงานบ่อยเป็นภาษาเครื่องเช่นกัน การบอกว่า JavaScript ช้าเพียงเพราะเป็นภาษาแบบ interpreted จึงไม่ถูกต้อง.[20][21]
สามด้าน ได้แก่ ความเร็วในการคำนวณ การควบคุมความหน่วง และการควบคุมหน่วยความจำ อธิบายจุดแข็งด้านการคำนวณและการควบคุม ส่วนการช่วยรักษาความปลอดภัย ความง่ายในการทำต้นแบบ และ Solana SDK อธิบายสิ่งที่ช่วยในการพัฒนา แกนทั้งหกไม่ได้แสดงความเร็วในการประมวลผลทั้งหมด
รูปหกเหลี่ยมทุกภาพใช้แกนและมาตราส่วนเดียวกัน ตำแหน่งที่ไกลออกไปหมายถึงจุดแข็งเชิงคุณภาพที่มากกว่าในด้านนั้น ไม่ใช่ความเร็วหรืออัตราส่วนที่วัดจริง ระดับ 3 ไม่ได้หมายถึงสามเท่าของระดับ 1 ให้เปรียบเทียบทีละด้านที่ต้องการปรับปรุง แทนที่จะใช้พื้นที่รูปหลายเหลี่ยมเป็นคะแนนรวม
| ด้าน | สิ่งที่เปรียบเทียบ |
|---|---|
| ความเร็วในการคำนวณ | ทางเลือกในการเร่งการอ่านข้อมูลปริมาณมากและการคำนวณที่เขียนเอง ภายใน implementation ที่เปรียบเทียบ |
| การควบคุมความหน่วง | ความสามารถในการแยกงาน เช่น การจัดสรรและคืนหน่วยความจำ หรือการปรับโค้ดระหว่างรัน ออกจากการประมวลผลสำคัญโดยตรง เพื่อจำกัดความล่าช้าฉับพลัน |
| การควบคุมหน่วยความจำ | ความสามารถในการออกแบบโดยตรงเกี่ยวกับการจัดวางข้อมูล ownership และอายุข้อมูล การจัดสรร การใช้ซ้ำ และการคืนหน่วยความจำ |
| การช่วยรักษาความปลอดภัย | ความช่วยเหลือจากคุณสมบัติภาษา runtime และเครื่องมือมาตรฐาน เพื่อป้องกันความผิดพลาดด้านอายุหน่วยความจำและหน่วยความจำร่วม |
| ความง่ายในการทำต้นแบบ | ความง่ายในการรันแอปพลิเคชันขนาดเล็กและทดลองเปลี่ยนแปลง เป็นการประเมินของผู้เขียนซึ่งเปลี่ยนตามประสบการณ์และโค้ดเดิม |
| Solana SDK | ความง่ายในการค้นหา SDK ไคลเอนต์และตัวอย่างที่เหมาะกับการใช้งานจากเอกสารทางการของ Solana |
แกนการควบคุมประเมินทางเลือกในการออกแบบโดยตรง แกนความปลอดภัยประเมินความช่วยเหลือที่มี และแกน SDK ประเมินเส้นทางจากเอกสารทางการ ระดับเดียวกันอาจหมายถึงกลไกและการรับประกันที่ต่างกัน.[8][13][20][21][26]
ภาพรวมนี้เปรียบเทียบหกภาษาในสามคอลัมน์และสองแถว ได้แก่ Rust, Go, TypeScript, Python, C++ และ Zig ให้เปรียบเทียบด้านที่สำคัญกับคุณ แล้วตรวจสอบสมมติฐานเกี่ยวกับ runtime และการใช้งานที่เหมาะสมจากภาพรายภาษาและคำอธิบายด้านล่าง
Rust รวมการควบคุมรูปแบบหน่วยความจำ การจัดสรร และการใช้ซ้ำบนเส้นทางสำคัญ เข้ากับการตรวจ ownership และ borrowing การจัดการหน่วยความจำตามปกติไม่จำเป็นต้องใช้ tracing GC.[8] การรับประกันของ safe Rust เรื่อง data race ไม่ได้รับประกันว่าจะไม่มี race condition ทั่วไป deadlock หรือตรรกะตัดสินใจที่ผิด โค้ด unsafe และการเชื่อมต่อภาษาอื่นต้องตรวจแยกต่างหาก.[22] การคัดลอก จัดสรร คืนหน่วยความจำ ล็อก และการรอระบบปฏิบัติการยังเกิดขึ้นได้ จึงต้องทดสอบกับอินพุตและโหลดจริง
Go เป็นตัวเลือกสำหรับการคอมไพล์ไปทำงานแบบ native เช่นกัน ช่วยประกอบบริการและการประมวลผลที่ทำงานพร้อมกัน โดย runtime ดูแลการจัดการหน่วยความจำและงานอื่น ๆ.[20] งาน GC ส่วนใหญ่ดำเนินควบคู่กับงานอื่น แต่ยังต้องวัดการจัดสรรและต้นทุนการเก็บขยะด้าน CPU หน่วยความจำ และความหน่วง ศักยภาพด้านการประมวลผล CPU เป็นคนละประเด็นกับการควบคุมเวลาคืนหน่วยความจำโดยตรง.[13]
TypeScript เป็นภาษา ส่วน Node.js และ Deno เป็น runtime ภาพนี้พิจารณา JavaScript ที่ V8 รัน type annotation ถูกลบเมื่อทำงาน ดังนั้นการเพิ่มชนิดข้อมูลไม่ได้ทำให้งาน CPU เร็วขึ้นด้วยตัวมันเอง ข้อมูลจากภายนอกยังต้องตรวจสอบระหว่างรัน.[9][10][21] ตัวเลือกเหล่านี้ใช้เชื่อม API จัดการการตั้งค่า ตรวจติดตาม สร้าง Web UI และประมวลผล stream ที่ทำสมรรถนะได้ตามต้องการได้
Node.js worker_threads และ Deno Web Workers สามารถย้ายงาน CPU ไปยังบริบทการทำงานอื่น เอกสาร Node.js แนะนำให้ใช้ worker pool แทนสร้าง worker ใหม่ทุกงาน ต้องรวมการแปลงข้อมูล คัดลอก และเวลารอส่งงาน พร้อมกับเวลาคำนวณที่ปลายทางในการประเมิน.[11][12]
Python เป็นตัวเลือกสำหรับการวิจัย วิเคราะห์ ตรวจสอบ และงานที่ใช้ไลบรารีเดิม การประเมิน CPU ในที่นี้หมายถึงลูปที่เขียนด้วย Python และทำงานใน CPython ปกติ งานคำนวณที่ส่งให้โค้ดคอมไพล์ เช่น การทำงานของ NumPy เป็นอีกกรณีหนึ่ง.[23] ตรวจสอบการตั้งค่าจริง รวมถึง build แบบ free-threaded แทนการตัดสินจากชื่อภาษาอย่างเดียว.[14] หากย้ายบางส่วนไป Rust หรือ implementation อื่น ให้วัดการแปลงและคัดลอกที่รอยต่อ และตรวจว่าทั้งแอปพลิเคชันได้ประโยชน์
C++ รวมการควบคุมระดับล่างเข้ากับ abstraction และไลบรารีที่มีอยู่ RAII และ smart pointer ช่วยจัดการอายุทรัพยากร แต่การใช้สิ่งเหล่านี้ไม่ได้รับประกันความปลอดภัยทั้งหมดของอายุหน่วยความจำหรือหน่วยความจำร่วม.[24] ระดับความปลอดภัยกลางไม่ได้หมายถึงการรับประกันแบบเดียวกับหน่วยความจำที่ runtime จัดการให้ เช่น ใน Go
Zig รองรับการออกแบบการจัดสรรและการเลือก allocator อย่างชัดเจน โปรไฟล์นี้ตั้งอยู่บนการตรวจของ ReleaseSafe ส่วน ReleaseFast และ ReleaseSmall มีการตรวจเริ่มต้นต่างกัน และ ReleaseSafe ไม่ได้ตรวจพบพฤติกรรมที่ไม่ถูกต้องทุกแบบ.[25] รูปหลายเหลี่ยมที่เหมือน C++ ไม่ได้หมายความว่ากลไกเหมือนกัน
ด้าน Solana SDK ใช้เส้นทางเอกสารทางการของ TypeScript และ Rust และไคลเอนต์ Go กับ Python ที่ระบุอยู่ในนั้น ไม่ได้จัดอันดับจำนวนหรือคุณภาพไลบรารีทั่วไป และไม่ได้อ้างว่า C++ หรือ Zig ไม่มีไลบรารี สำหรับ SDK ที่จะใช้จริง ให้ตรวจ API ที่ต้องการ การตามทันการเปลี่ยนแปลงของโครงการ และความเข้ากันได้กับ runtime ที่เลือก รวมถึง Deno.[26]
วัดว่าแอปพลิเคชันใช้เวลาไปที่ใด แล้วเลือกจุดแข็งที่ส่วนนั้นต้องการ เริ่มลดการรอและงานซ้ำด้วยภาษาเดิมก่อน หากต้องการควบคุมละเอียดขึ้น การย้ายเฉพาะส่วนที่เกี่ยวข้องไปอีกภาษายังเป็นทางเลือกได้
เปรียบเทียบการเปลี่ยนแปลงภายใต้เงื่อนไขเดียวกัน
คำสั่งในแต่ละส่วนครอบคลุมการนำการปรับปรุงนั้นไปใช้และตรวจสอบ หากปรับปรุงหลายอย่าง ให้เก็บความสัมพันธ์ระหว่างการเปลี่ยนแปลงแต่ละอย่างกับผลการวัดไว้ การเปลี่ยนหลายอย่างพร้อมกันทำให้แยกได้ยากว่าการเปลี่ยนแปลงใดส่งผลต่อผลลัพธ์ใด
เปรียบเทียบก่อนและหลังด้วยอินพุต เงื่อนไขการสมัครรับ โหลด และข้อกำหนดผลลัพธ์เดียวกัน สำหรับเวลาตั้งแต่รับจนตัดสินใจเสร็จ ให้ดูค่ามัธยฐาน p50 พร้อม p95 และ p99 ค่า p99 คือเกณฑ์เวลาที่ 99% ของเหตุการณ์ที่วัดเสร็จภายในนั้น ช่วยให้เห็นด้านที่ช้าของการกระจายควบคู่กับเวลาประมวลผลโดยทั่วไป
การบวก p99 ของแต่ละขั้นตอนไม่ได้ให้ p99 ตลอดเส้นทาง ต้องวัดเวลารวมตั้งแต่รับจนตัดสินใจเสร็จของแต่ละเหตุการณ์โดยตรง พร้อมดูเวลารอคิว การใช้ CPU และหน่วยความจำ การอัปเดตที่ขาดหรือถูกทิ้ง และความตรงกันของผลการตัดสินใจ
เมื่อวัดเวลาที่ผ่านไปภายในโฮสต์เดียว ให้ใช้นาฬิกา monotonic ที่ไม่ย้อนกลับเมื่อปรับเวลานาฬิการะบบ หาก SDK เรียก callback หลังถอดรหัสเท่านั้น แปลว่ามีการประมวลผลเกิดขึ้นก่อนเริ่ม callback ด้วย ระบุจุดเริ่มและจุดจบของทุกการวัดให้ชัด เพื่อแยกพิจารณาความหน่วงในการส่งข้อมูลกับความหน่วงของแอปพลิเคชันได้
ตรวจสิ่งที่เกิดหลังส่งด้วย การตอบกลับ sendTransaction ว่าสำเร็จไม่ได้รับประกันว่าคลัสเตอร์ประมวลผลหรือยืนยันธุรกรรมแล้ว[15] การเชื่อมโยงการรับข้อมูล การตัดสินใจ การรับคำขอส่ง และผลบนเชนที่สังเกตได้ ช่วยหาจุดปรับปรุงถัดไป
เปลี่ยนการส่งข้อมูลที่รวดเร็วให้เป็นการตัดสินใจที่ทันเวลา
ทั้งการส่งข้อมูลที่รวดเร็วและแอปพลิเคชันที่ตัดสินใจตามความจำเป็นได้ทันเวลาล้วนสำคัญ ERPC จะปรับปรุงโครงสร้างพื้นฐานการส่งข้อมูลต่อไป และพัฒนาข้อมูลความรู้ที่ช่วยปรับปรุงซอฟต์แวร์ที่ทำงานอยู่บนนั้น
ตรวจผลของการเปลี่ยนแอปพลิเคชันในสภาพแวดล้อมเดียวกันก่อน จากนั้นหากจำเป็นจึงเปรียบเทียบโค้ดเดียวกันบนตำแหน่งติดตั้งหรือทรัพยากรต่างกันเพื่อแยกผลกระทบ เมื่อใช้การคิดค่าบริการรายชั่วโมงของ ERPC ให้กำหนดสมมติฐาน เงื่อนไขเปรียบเทียบ และระยะเวลาใช้งานล่วงหน้า พร้อมตรวจราคาและความพร้อมใน Dashboard ปัจจุบัน
แหล่งอ้างอิงและลิงก์ที่เกี่ยวข้อง
- [1] Tokio / งาน CPU-bound และ blocking
- [2] Node.js / อย่าบล็อก Event Loop
- [3] gRPC / Flow Control
- [4] Yellowstone gRPC / ข้อความและข้อกำหนดการสมัครรับ
- [5] LMAX Disruptor / การออกแบบและใช้งาน
- [6] Solana / Commitment
- [7] Solana / getLatestBlockhash
- [8] Rust / Ownership
- [9] TypeScript / พฤติกรรมขณะรันและการลบชนิดข้อมูล
- [10] Deno / TypeScript
- [11] Node.js / Worker threads
- [12] Deno / Web Workers
- [13] Go / Garbage Collector
- [14] Python / Free threading
- [15] Solana / sendTransaction
- [16] Yellowstone gRPC / นิยามข้อความ
- [17] Rust / std::sync::Mutex
- [18] Tokio / สถานะร่วมและการแบ่ง mutex
- [19] Solana / โครงสร้างธุรกรรมและลายมือชื่อ
- [20] Go / คำถามที่พบบ่อย
- [21] V8 / ภาพรวมระดับสูง
- [22] Rust / Data Race และ Race Condition
- [23] NumPy / NumPy คืออะไร
- [24] C++ / แนวทางหลัก
- [25] Zig / เอกสารอ้างอิงภาษา
- [26] Solana / SDK ไคลเอนต์
- [27] Programming-Language-Benchmarks / nbody
- [28] Programming-Language-Benchmarks / Measurement code (2025-07-31): execution, defaults, aggregation, Zig build, Deno configuration.
- [29] Programming-Language-Benchmarks / Published measurement data (2025-08-01)
- โลโก้และแหล่งที่มา: Rust © Rust Foundation (CC BY 4.0, ไม่เปลี่ยนรูปทรงและสี); Zig © Zig project (CC BY-SA 4.0, ไม่เปลี่ยนรูปทรงและสี).
- โลโก้อื่น ๆ: Go © The Go Authors; TypeScript © Microsoft; Python © Python Software Foundation; C++ by Jeremy Kratz / Standard C++ Foundation; Node.js / OpenJS Foundation and Node.js contributors; Deno / Deno Land Inc..
- ERPC
- ERPC Web Dashboard































