หน้าแรก>ซอร์สโค้ด CGI>หมวดหมู่อื่นๆ
ดาวน์โหลด

บทนำ

การซื้อคืนนี้ใช้คอลเลกชันของส่วนประกอบที่เกี่ยวข้องกับอีเทอร์เน็ตใน Bluespec SystemVerilog(BSV) สำหรับการประมวลผลแพ็กเก็ตประสิทธิภาพสูงบน FPGA โดยเฉพาะอย่างยิ่ง repo นี้จัดเตรียมโมดูลสำหรับการสร้างและแยกวิเคราะห์แพ็กเก็ต UDP/IP/Ethernet นอกจากนี้ยังมีหน่วยประมวลผล ARP ที่มีข้อมูลที่อยู่จัดเก็บแคชแบบไม่ปิดกั้นเพื่อจัดการการแก้ไขที่อยู่ MAC โดยอัตโนมัติ นอกจากการสร้างสแต็ก UDP/IP/Ethernet มาตรฐานแล้ว blue-ethernet ยังเพิ่มการรองรับ RoCE (RDMA บน Converged Ethernet): 1) รวมการสร้างและการตรวจสอบ ICRC (Invariant Cyclic Redundancy) ในการประมวลผลแพ็คเก็ต UDP/IP; 2) จัดเตรียมโมดูลสำหรับจัดการ PFC (Priority Flow Control) เพื่อให้การรับส่งข้อมูลเครือข่ายแบบไม่สูญเสียข้อมูล และสุดท้ายยังมีโมดูลการแปลงอินเทอร์เฟซสำหรับตัวสร้างแพ็กเก็ตและตัวแยกวิเคราะห์เพื่อโต้ตอบกับระบบย่อยอีเธอร์เน็ต Xilinx 100G (CMAC)

ภาพรวมไดเรกทอรี

ไดเร็กทอรีหลักบางรายการของ repo นี้แสดงอยู่ด้านล่าง: 

├── lib               # external libraries/repos
│   ├── blue-crc      # high-performance CRC hardware implementation
│   └── blue-wrapper  # BSV wrappers for generating ready-to-use Verilog interface
├── scripts           # scripts used to build project
├── src               # design source files
│   └── includes      # files containing some commonly-used BSV types and modules
├── syn               # scripts for vivado synthesis and implementation
└── test              # source files for verification
    ├── bluesim       # testbenches based on bluesim
    ├── cocotb        # python testbenches based on cocotb
    └── vivado        # co-simulation with cmac using vivado

นี่คือรายการไฟล์ต้นฉบับที่สำคัญบางไฟล์: 

./src
├── ArpCache.bsv               # Cache implementation storing MAC addresses got from ARP
├── ArpProcessor.bsv           # processing unit handling ARP requests and responses
├── includes                   
│   ├── CompletionBuf.bsv      
│   ├── ContentAddressMem.bsv  
│   ├── EthernetTypes.bsv      # numeric and struct types about protocol definition
│   ├── PortConversion.bsv     # interface conversion modules used to generate ready-to-use Verilog
│   ├── Ports.bsv              # numeric and struct types about in/output ports of modules
│   ├── RFile.bsv
│   ├── StreamHandler.bsv      # modules implemented for manipulating data stream
│   └── EthUtils.bsv           # utility functions and modules
├── MacLayer.bsv               # generator and parser for Ethernet packet
├── PfcUdpIpArpEthRxTx.bsv     # generator and parser for UDP/IP/Ethernet packet with PFC
├── PriorityFlowControl.bsv    # modules handling PFC
├── UdpIpArpEthRxTx.bsv        # generator and parser for UDP/IP/Ethernet packet 
├── UdpIpEthRx.bsv             # parser for UDP/IP/Ethernet packet
├── UdpIpEthTx.bsv             # generator for UDP/IP/Ethernet packet
├── UdpIpLayer.bsv             # parser and generator for UDP/IP packet
├── UdpIpLayerForRdma.bsv      # parser and generator for UDP/IP packet with support for RoCE
└── XilinxCmacRxTxWrapper.bsv  # bridge modules between parser/generator and Xilinx CMAC

ส่วนประกอบ

ส่วนนี้ให้คำอธิบายโดยละเอียดเกี่ยวกับส่วนประกอบสำคัญบางอย่างที่ใช้งานในบลูอีเทอร์เน็ต รวมถึงฟังก์ชันการทำงาน อินเทอร์เฟซ และสถาปัตยกรรมฮาร์ดแวร์

ตัวจัดการสตรีม

สิ่งที่ส่วนประกอบฮาร์ดแวร์ที่เกี่ยวข้องกับอีเทอร์เน็ตทำคือชุดของการปรับแต่งสตรีม เครื่องกำเนิดแพ็กเก็ตมีหน้าที่แทรกสตรีมส่วนหัวลงในส่วนหัวของสตรีมเพย์โหลดเพื่อสร้างสตรีมแพ็กเก็ตที่สมบูรณ์ ในทางตรงกันข้าม สิ่งที่ parser ทำคือการแยกสตรีมส่วนหัวและสตรีมเพย์โหลดออกจากสตรีมแพ็กเก็ต สำหรับการเพิ่มเช็คซัมสำหรับแพ็กเก็ต สตรีมแพ็กเก็ตจะถูกส่งผ่านไปยังเครื่องคิดเลข CRC จากนั้นค่า CRC เอาต์พุตจะถูกต่อท้ายส่วนท้ายของสตรีมแพ็กเก็ต

เอนทิตีฮาร์ดแวร์ที่สอดคล้องกับสตรีมที่เรากล่าวถึงในที่นี้จริงๆ แล้วคือกลุ่มของสัญญาณข้อมูลที่ได้รับการปกป้องโดยคู่สัญญาณควบคุมที่พร้อมใช้งาน สัญญาณที่ถูกต้องบ่งชี้ว่าองค์ประกอบต้นทางต้องการถ่ายโอนข้อมูล และความพร้อมแสดงว่าอ่างล้างจานพร้อมรับข้อมูลจากแหล่งที่มา การถ่ายโอนระหว่างต้นทางและซิงก์จะเกิดขึ้นได้สำเร็จเมื่อทั้งความถูกต้องและพร้อมใช้งานอยู่ในระดับสูงเท่านั้น หากขนาดของข้อมูลที่จะส่งมีขนาดใหญ่กว่าขนาดของการถ่ายโอนหนึ่งครั้ง ข้อมูลจะต้องมีการแยกส่วนและถ่ายโอนเป็นชุดของการถ่ายโอน

ส่วนที่ยุ่งยากและเกิดข้อผิดพลาดได้ง่ายที่สุดในการประมวลผลสตรีมคือวิธีจัดการกับสัญญาณควบคุมที่พร้อมใช้งานของสตรีมต่างๆ ใน BSV การจัดการสัญญาณควบคุมจะดำเนินการโดยคอมไพเลอร์และมองไม่เห็นในระดับไวยากรณ์ ซึ่งช่วยให้นักออกแบบมุ่งเน้นไปที่ตรรกะของการประมวลผลสตรีม

โมดูลการประมวลผลสตรีมที่มีให้ใน blue-ethernet ประกอบด้วย:

สัญญาณข้อมูลที่ใช้ในการถ่ายโอนแพ็กเก็ตสตรีมระหว่างส่วนประกอบต่างๆ จะถูกห่อหุ้มไว้ในโครงสร้าง DataStream ซึ่งรวมถึงสัญญาณข้อมูล 256 บิต สัญญาณที่เปิดใช้งานไบต์ 32 บิต สัญญาณบูลีนสองสัญญาณแสดงว่าการถ่ายโอนนี้เป็นครั้งสุดท้ายหรือครั้งแรกของสตรีมแพ็กเก็ต 

 typedef 256 DATA_BUS_WIDTH ;
typedef TDiv # ( DATA_BUS_WIDTH , 8 ) DATA_BUS_BYTE_WIDTH ;
typedef Bit # ( DATA_BUS_WIDTH ) Data ;
typedef Bit # ( DATA_BUS_BYTE_WIDTH ) ByteEn ;
typedef struct {
    Data data ;
    ByteEn byteEn ;
    Bool isFirst ;
    Bool isLast ;
} DataStream deriving ( Bits , Bounded , Eq , FShow ) ;
  • mkAppendDataStreamHead ผนวกการถ่ายโอนหนึ่งครั้งในสตรีม appendDataIn ไปที่ส่วนหัวของหนึ่งแพ็กเก็ตในสตรีม dataStreamIn จุดสิ้นสุดของข้อมูลจากสตรีมทั้งสองนี้สามารถสลับได้โดยการตั้งค่าพารามิเตอร์ swapDataStream และ swapAppendData โมดูลนี้ใช้เพื่อรวมสตรีมส่วนหัวและสตรีมเพย์โหลดเพื่อสร้างแพ็กเก็ต UDP/IP/Ethernet ที่สมบูรณ์ 
 module mkAppendDataStreamHead # (
    IsSwapEndian swapDataStream ,
    IsSwapEndian swapAppendData ,
    FifoOut # ( DataStream ) dataStreamIn ,
    FifoOut # ( dType ) appendDataIn
)( FifoOut # ( DataStream )) ;
  • mkAppendDataStreamTail ทำงานในลักษณะเดียวกันกับ mkAppendDataStreamHead โดยผนวกการถ่ายโอนหนึ่งครั้งในสตรีม appendDataIn ต่อท้ายของหนึ่งแพ็กเก็ตในสตรีม dataStreamIn เพื่อให้การใช้งานฮาร์ดแวร์ภายในง่ายขึ้น ยังจำเป็นต้องใช้สตรีม streamLengthIn อีกหนึ่งสตรีม ซึ่งมีความยาวของแต่ละแพ็กเก็ตในไฟล์ . 
 module mkAppendDataStreamTail # (
    IsSwapEndian swapDataStream ,
    IsSwapEndian swapAppendData ,
    FifoOut # ( DataStream ) dataStreamIn ,
    FifoOut # ( dType ) appendDataIn ,
    FifoOut # ( Bit # ( streamLenWidth )) streamLengthIn
)( FifoOut # ( DataStream )) ;
  • mkExtractDataStreamHead แยกส่วนหัวของหนึ่งแพ็กเก็ตในสตรีม dataStreamIn เพื่อ แยก สตรีม DataOut และส่งสตรีมแพ็กเก็ตที่เหลือไปยังสตรีม dataStreamOut 
 interface ExtractDataStream # ( type dType ) ;
    interface FifoOut # ( dType ) extractDataOut ;
    interface FifoOut # ( DataStream ) dataStreamOut ;
endinterface
module mkExtractDataStreamHead # (
    FifoOut # ( DataStream ) dataStreamIn
)( ExtractDataStream # ( dType )) ;
  • mkAxiStream512ToDataStream แปลงอินเทอร์เฟซ AXI-Stream 512 บิตที่ Xilinx CMAC IP ต้องการเป็น DataStream 256 บิตที่ใช้ในอีเทอร์เน็ตสีน้ำเงิน
  • mkDataStreamToAxiStream512 แปลง DataStream 256 บิตที่ใช้ในอีเทอร์เน็ตสีน้ำเงิน **** เป็น AXI-Stream 512 บิตที่ Xilinx CMAC IP ต้องการ

UdpIpLayer

โมดูลในแพ็คเกจ UdpIpLayer ถูกนำมาใช้เพื่อสร้างและแยกวิเคราะห์แพ็กเก็ต UDP/IP

คำอธิบายแพ็คเกจโดยละเอียด:

เครื่องกำเนิดแพ็กเก็ตรับ UdpIpMetaData ที่มีข้อมูลส่วนหัว UDP/IP และสตรีมของเพย์โหลด และส่งออกสตรีมแพ็กเก็ต UDP/IP ที่สมบูรณ์ ตัวแยกวิเคราะห์แพ็คเก็ตทำงานในลักษณะตรงกันข้ามโดยการแยก UdpIpMetaData และเพย์โหลดสตรีมจากสตรีมแพ็กเก็ต UDP/IP 

 typedef struct {
    UdpLength  dataLen ;   # The Length of payload data
    IpAddr     ipAddr ;    # Desitnation IP address
    IpDscp     ipDscp ;    # DSCP field used for PFC
    IpEcn      ipEcn ;     # ECN field
    UdpPort    dstPort ;   # Destination port number
    UdpPort    srcPort ;   # Source port number
} UdpIpMetaData ;

สัญญาณที่ห่อหุ้มในโครงสร้าง UdpIpMetaData ไม่ครอบคลุมฟิลด์ทั้งหมดที่กำหนดไว้ในส่วนหัว UDP/IP ฟิลด์บางส่วนของส่วนหัวได้รับการแก้ไขสำหรับอุปกรณ์เครือข่ายเฉพาะ ซึ่งห่อหุ้มไว้ในโครงสร้าง UdpConfig และจำเป็นต้องกำหนดค่าก่อนที่จะส่งหรือรับแพ็กเก็ตใดๆ และฟิลด์อื่นๆ บางฟิลด์จะมีค่าคงที่และฮาร์ดโค้ดในส่วนประกอบฮาร์ดแวร์ 

 typedef struct {
    EthMacAddr macAddr ;  # Source MAC address
    IpAddr     ipAddr ;   # Source IP address
    IpNetMask  netMask ;  # IP netmask
    IpGateWay  gateWay ;  # IP gateway
} UdpConfig ;
  • mkUdpIpStream สร้างสตรีมแพ็กเก็ต UDP/IP โดยการรวมข้อมูลส่วนหัวของ udpIpMetaDataIn และ dataStreamIn ที่บรรทุกสตรีมเพย์โหลด โมดูลนี้ยังใช้ฟังก์ชันส่งคืนส่วนหัว UDP/IP ที่สมบูรณ์ โดยมีการระบุค่าของฟิลด์คงที่ของส่วนหัว การสร้างแพ็คเก็ตประกอบด้วยขั้นตอนต่อไปนี้: 1) สร้างส่วนหัว UDP/IP; 2) คำนวณและตั้งค่าฟิลด์ตรวจสอบผลรวมของส่วนหัว IP (ไม่ได้ใช้การตรวจสอบผลรวมของส่วนหัว UDP ใน blue-ethernet) 3) ใส่ส่วนหัวที่ส่วนหัวของสตรีมเพย์โหลด 
 module mkUdpIpStream # (
    UdpConfig udpConfig ,
    FifoOut # ( DataStream ) dataStreamIn ,
    FifoOut # ( UdpIpMetaData ) udpIpMetaDataIn ,
    function UdpIpHeader genHeader ( UdpIpMetaData meta , UdpConfig udpConfig , IpID ipId )
)( FifoOut # ( DataStream )) ;
  • mkUdpIpMetaDataAndDataStream แยกข้อมูลส่วนหัวที่มีข้อมูล udpIpMetaDataOut และ dataStreamOut ที่มีสตรีมเพย์โหลดจากอินพุตสตรีมแพ็กเก็ต UDP/IP udpIpStreamIn ก่อนที่จะส่งส่วนหัวและเพย์โหลดที่แยกออกมา โมดูลจำเป็นต้องตรวจสอบความสมบูรณ์ของส่วนหัว IP ที่ได้รับโดยฟิลด์ตรวจสอบผลรวม และโยนทิ้งหากส่วนหัวเสียหายระหว่างการส่งสัญญาณ 
 interface UdpIpMetaDataAndDataStream ;
    interface FifoOut # ( UdpIpMetaData ) udpIpMetaDataOut ;
    interface FifoOut # ( DataStream ) dataStreamOut ;
endinterface
module mkUdpIpMetaDataAndDataStream # (
    UdpConfig udpConfig ,
    FifoOut # ( DataStream ) udpIpStreamIn ,
    function UdpIpMetaData extractMetaData ( UdpIpHeader hdr )
)( UdpIpMetaDataAndDataStream ) ;

UdpIpLayerForRdma

โมดูลในแพ็คเกจ UdpIpLayerForRdma ได้รับการปรับใช้ตาม UdpIpLayer พร้อมรองรับ RoCE (RDMA บน Converged Ethernet) ฟังก์ชันเพิ่มเติมที่เพิ่มเพื่อรองรับ RoCE คือการสร้างและการตรวจสอบ ICRC (Invariant CRC) ที่จำเป็นสำหรับแพ็กเก็ต RoCE รูปแบบของแพ็กเก็ต RoCE มีการกำหนดไว้ด้านล่าง:

คำอธิบายแพ็คเกจโดยละเอียด:
  • mkUdpIpStreamForRdma เปิดเผยอินเทอร์เฟซและฟังก์ชันการทำงานเดียวกันกับ mkUdpIpStream ข้อแตกต่างที่สำคัญคือจะเพิ่มการตรวจสอบเพิ่มเติมที่ส่วนท้ายของกระแสแพ็กเก็ตเอาต์พุตเพื่อสร้างแพ็กเก็ต UDP/IP ที่สอดคล้องกับ RoCE เพื่อให้ทราบถึงฟังก์ชันการทำงานนี้ องค์ประกอบอีกสามองค์ประกอบจึงถูกรวมเข้ากับโฟลว์ข้อมูลการประมวลผลสตรีม: (1) mkUdpIpStreamForICrcGen สร้างสตรีมแพ็กเก็ต UDP/IP สำหรับการคำนวณ CRC โดยการตั้งค่าบางฟิลด์ของส่วนหัว IP/UDP และ IB BTH ให้เป็นศูนย์ ซึ่งจำเป็นตามคำจำกัดความ ของไอซีอาร์ซี; (2) mkCrcStream มีให้ใน blue-crc repo และใช้ในการคำนวณผลรวมตรวจสอบ CRC ของแพ็กเก็ตสตรีม (3) mkAppendDataStreamTail ผนวกการตรวจสอบ CRC เข้ากับส่วนท้ายของสตรีมแพ็กเก็ต UDP/IP ดั้งเดิม
  • mkUdpIpMetaDataAndDataStreamForRdma ได้รับการปรับใช้โดยอิงจาก mkUdpIpMetaDataAndDataStream พร้อมการสนับสนุนเพิ่มเติมสำหรับการตรวจสอบ ICRC เพื่อให้ทราบถึงฟังก์ชันเพิ่มเติมนี้ สตรีมแพ็กเก็ต UDP/IP อินพุตจะถูกส่งไปยัง mkUdpIpStreamForICrcChk จากนั้นส่งต่อไปยัง mkCrcStream เพื่อรับผลการตรวจสอบ ICRC หากการตรวจสอบล้มเหลว ข้อมูลเพย์โหลดและส่วนหัวที่แยกออกมาจะหายไป และก่อนที่จะส่งออกเพย์โหลดสตรีมที่แยกออกมา จะต้องผ่านคอมโพเนนต์ mkRemoveICrcFromDataStream เพื่อลบเช็คซัม ICRC ส่วนท้ายออก

แมคเลเยอร์

โมดูลในแพ็คเกจ MacLayer ถูกนำมาใช้เพื่อสร้างและแยกวิเคราะห์แพ็กเก็ตอีเธอร์เน็ต เครื่องกำเนิดไฟฟ้าจะแทรกส่วนหัวอีเธอร์เน็ตเข้ากับส่วนหัวของสตรีมแพ็กเก็ต UDP/IP เพื่อสร้างสตรีมแพ็กเก็ตอีเทอร์เน็ต parser จะแยกส่วนหัวของอีเทอร์เน็ตและสตรีมแพ็กเก็ต UDP/IP จากสตรีมแพ็กเก็ตอีเทอร์เน็ต

คำอธิบายแพ็คเกจโดยละเอียด:

ข้อมูลส่วนหัวที่ใช้ในการสร้างแพ็กเก็ตอีเธอร์เน็ตถูกกำหนดไว้ในโครงสร้าง MacMetaData 

 typedef struct {
    EthMacAddr macAddr ; # Destination MAC address
    EthType    ethType ; # Type of Ethernet frame
} MacMetaData deriving ( Bits , Eq , FShow ) ;

โปรดทราบว่าแพ็กเก็ตอีเธอร์เน็ตที่จัดการใน MacLayer จะครอบคลุมเฉพาะฟิลด์ที่ระบุไว้ในสี่เหลี่ยมสีแดงในรูปด้านล่าง ฟิลด์อื่นๆ จะถูกประมวลผลโดย Xilinx CMAC IP

  • mkMacStream สร้างกระแสแพ็กเก็ตอีเธอร์เน็ตโดยการรวม udpIpStreamIn ที่บรรทุกสตรีมแพ็กเก็ต UDP/IP และ macMetaDataIn ที่บรรทุกข้อมูลส่วนหัวของอีเทอร์เน็ต 
 module mkMacStream # (
    FifoOut # ( DataStream )  udpIpStreamIn ,
    FifoOut # ( MacMetaData ) macMetaDataIn ,
    UdpConfig udpConfig
)( FifoOut # ( DataStream )) ;
  • mkMacMetaDataAndUdpIpStream แยก macMetaDataOut ที่มีข้อมูลส่วนหัวของ Ethernet และ udpIpStreamOut ที่มีกระแสแพ็กเก็ต UDP/IP จากกระแสแพ็กเก็ต Ethernet macStreamIn 
 interface MacMetaDataAndUdpIpStream ;
    interface FifoOut # ( MacMetaData ) macMetaDataOut ;
    interface FifoOut # ( DataStream )  udpIpStreamOut ;
endinterface

module mkMacMetaDataAndUdpIpStream # (
    FifoOut # ( DataStream ) macStreamIn ,
    UdpConfig udpConfig
)( MacMetaDataAndUdpIpStream ) ;

โปรเซสเซอร์ ARP

Address Resolution Protocol (ARP) ใช้สำหรับค้นหาที่อยู่ MAC ที่เชื่อมโยงกับที่อยู่ IP ที่กำหนด ใน blue-ethernet โมดูล mkArpProcessor ถูกนำมาใช้สำหรับการประมวลผล ARP ซึ่งรวมตัวสร้างแพ็กเก็ต ARP, parser และโมดูล mkArpCache ที่จัดเก็บที่อยู่ MAC

คำอธิบายโดยละเอียดของ mkArpCache และ mkArpProcessor:

mkArpCache

สำหรับแคชที่ใช้ในการประมวลผล ARP ที่อยู่ IP 32 บิตจะสอดคล้องกับที่อยู่แคช และที่อยู่ MAC 48 บิตจะสอดคล้องกับข้อมูลแคช การจัดเรียงเริ่มต้นของอาร์เรย์หน่วยความจำสำหรับแคช ARP แสดงอยู่ด้านล่าง ซึ่งเป็นโครงสร้างการเชื่อมโยงชุด 4 ทาง แต่ละวิธีประกอบด้วย 64 บรรทัด และแต่ละบรรทัดประกอบด้วยแท็กที่ถูกต้อง 1 บิต แท็ก 26 บิต และข้อมูล 48 บิต ขนาดรวมของการกำหนดค่าอาร์เรย์เริ่มต้นนี้คือประมาณ 1.2KB รองรับการเปลี่ยนขนาดของอาร์เรย์หน่วยความจำโดยการตั้งค่าจำนวนบรรทัดและวิธีการ ตามอาร์เรย์หน่วยความจำนี้ แคชได้รับการออกแบบมาให้ไม่ปิดกั้น รองรับคำขอที่ค้างอยู่ (คำขอหลายรายการบนเครื่อง) และใช้อัลกอริธึมหลอก-LRU สำหรับการแทนที่บรรทัดแคช

คำจำกัดความของอินเทอร์เฟซและแผนภาพโครงสร้างที่เรียบง่ายของโมดูล mkArpCache แสดงอยู่ด้านล่าง ArpCache มีอินเทอร์เฟซย่อยสองแบบ: cacheServer จัดการการโต้ตอบกับส่วนประกอบที่บริการแก้ไขที่อยู่ MAC; และ arpClient จัดการการโต้ตอบด้วย mkArpProcessor เพื่อเริ่มต้นคำขอ ARP และรับที่อยู่ MAC จากการตอบสนองของ ARP ขั้นตอนการทำงานพื้นฐานของโมดูล mkArpCache มีดังนี้:

เมื่อแคชได้รับคำขออ่าน แคชจะค้นหาอาร์เรย์หน่วยความจำก่อนเพื่อรับแท็กและข้อมูลทั้งหมดที่สอดคล้องกับที่อยู่ IP ที่กำหนด จากนั้นจะตรวจสอบแท็กเพื่อดูว่าข้อมูลที่เราต้องการนั้นจัดเก็บไว้ในแคชหรือไม่ หากแคชเข้าถึง ข้อมูลที่ดึงมาจะถูกส่งไปยัง hitBuf หรือที่อยู่ IP ถูกส่งไปยัง arpReqBuf เพื่อเริ่มต้นคำขอ ARP และเมื่อการตอบสนองของ ARP กลับมา ข้อมูลและที่อยู่ที่มีนั้นจะถูกเขียนไปยัง cacheWrBuf และ missHitBuf เพื่ออัปเดตอาร์เรย์หน่วยความจำและส่งคืนการตอบสนองการอ่านแคช 

 interface ArpCache ;
    interface Server # ( CacheAddr , CacheData ) cacheServer ;
    interface Client # ( CacheAddr ,   ArpResp ) arpClient ;
endinterface

ส่วนที่ยากที่สุดของการใช้แคชคือการสนับสนุนคุณลักษณะที่โดดเด่น ซึ่งสนับสนุนคำขออ่านหลายรายการบนเที่ยวบิน ปัญหาที่เกิดจากความโดดเด่นคือเวลาตอบสนองแตกต่างกันไปสำหรับคำขอ ARP บนเที่ยวบินแต่ละรายการ ซึ่งหมายความว่าคำขอล่าช้าอาจได้รับการตอบกลับก่อน ดังนั้นจึงจำเป็นต้องมีกลไกการเรียงลำดับใหม่เพื่อรับประกันความสอดคล้องระหว่างที่อยู่คำขอและข้อมูลการตอบสนองเมื่อแคชพลาดเกิดขึ้น เพื่อให้ทราบถึงการตอบสนองตามลำดับ บัฟเฟอร์ respCBuf ที่เสร็จสมบูรณ์และหน่วยความจำที่สามารถระบุตำแหน่งเนื้อหาได้ missReqTab จะถูกรวมไว้ในโฟลว์ข้อมูล บัฟเฟอร์การเสร็จสิ้นทำงานเหมือนกับ FIFO พร้อมการสนับสนุนเพิ่มเติมสำหรับฟังก์ชันการจอง ก่อนการดำเนินการจัดคิวตามจริง เราสามารถจองคำสั่งซื้อไว้ในบัฟเฟอร์ที่เสร็จสมบูรณ์ได้ก่อน และการดำเนินการถอนคิวเป็นไปตามลำดับที่สงวนไว้ไม่ว่าลำดับการดำเนินการตามลำดับจริงจะเป็นอย่างไร สำหรับแต่ละคำขออ่าน ลำดับ dequeue จะกลับรายการเป็น respCBuf เมื่อได้รับแล้ว และเนื่องจากคำขอ ARP ไม่สามารถส่งข้อมูลคำสั่งซื้อได้ จึงมีการใช้ missReqTab เพื่อจัดเก็บข้อมูลดังกล่าว

mkArpProcessor

โมดูลสามารถทำงานได้ทั้งไคลเอนต์ ARP และเซิร์ฟเวอร์ ในฐานะเซิร์ฟเวอร์ โปรเซสเซอร์จำเป็นต้องสร้างคำขอ ARP หากไม่ทราบที่อยู่ MAC ของ IP เป้าหมาย จากนั้นรอการตอบสนอง ARP จากอุปกรณ์เป้าหมาย ในฐานะไคลเอนต์ โปรเซสเซอร์ ARP ได้รับคำขอ ARP จากอุปกรณ์อื่น และส่งการตอบสนอง ARP กลับมาโดยมีที่อยู่ MAC ของตัวเอง 

 interface ArpProcessor ;
    interface FifoOut # ( DataStream ) arpStreamOut ;
    interface FifoOut # ( MacMetaData ) macMetaDataOut ;
    interface Put # ( UdpConfig ) udpConfig ;
endinterface

module mkArpProcessor # (
    FifoOut # ( DataStream ) arpStreamIn ,
    FifoOut # ( UdpIpMetaData ) udpIpMetaDataIn
)( ArpProcessor ) ;

UdpIpEthRx

โมดูลในแพ็คเกจ UdpIpEthRx ถูกนำมาใช้เพื่อรับและแยกวิเคราะห์แพ็กเก็ต UDP/IP/Ethernet

คำอธิบายแพ็คเกจโดยละเอียด:
  • mkGenericUdpIpEthRx แยกสตรีมส่วนหัวของอีเทอร์เน็ต ( macMetaDataOut ), สตรีมส่วนหัว UDP/IP ( udpIpMetaDataOut ) และสตรีมเพย์โหลด ( dataStreamOut ) จาก axiStreamIn ที่มีสตรีมแพ็กเก็ตอีเทอร์เน็ต จำเป็นต้องกำหนดค่าส่วนประกอบผ่านอินเทอร์เฟซ udpConfig ก่อนที่จะรับและแยกวิเคราะห์แพ็กเก็ต และพารามิเตอร์โมดูล isSupportRdma ระบุว่ารองรับการประมวลผลแพ็คเก็ต RoCE หรือไม่ รูปด้านล่างแสดงแผนผังโครงสร้างของโมดูลนี้ที่รองรับการเปิดใช้งาน RoCE หากปิดใช้งานการสนับสนุน RoCE โมดูล mkUdpIpMetaDataAndDataStreamForRdma ทั้งหมดจะถูกแทนที่ด้วย mkUdpIpMetaDataAndDataStream 
 interface UdpIpEthRx ;
    interface Put # ( UdpConfig ) udpConfig ;
    
    interface Put # ( AxiStream512 ) axiStreamIn ;
    
    interface FifoOut # ( MacMetaData ) macMetaDataOut ;
    interface FifoOut # ( UdpIpMetaData ) udpIpMetaDataOut ;
    interface FifoOut # ( DataStream )  dataStreamOut ;
endinterface

module mkGenericUdpIpEthRx # ( Bool isSupportRdma )( UdpIpEthRx )
  • mkGenericRawUdpIpEthRx ล้อม mkGenericUdpIpEthRx โดยใช้โมดูลที่มีให้ใน blue-wrapper เพื่อสร้างอินเทอร์เฟซ Verilog ที่พร้อมใช้งาน

UdpIpEthTx

โมดูลในแพ็คเกจ UdpIpEthTx ถูกนำมาใช้เพื่อสร้างและส่งแพ็กเก็ต UDP/IP/Ethernet

คำอธิบายแพ็คเกจโดยละเอียด:
  • mkGenericUdpIpEthTx รับสตรีมส่วนหัวของ Ethernet ( macMetaDataOut ), สตรีมส่วนหัว UDP/IP ( udpIpMetaDataOut ) และสตรีมข้อมูลเพย์โหลด ( dataStreamOut ) สร้างสตรีมแพ็กเก็ตอีเธอร์เน็ต จากนั้นส่งออกผ่าน axiStreamOut และพารามิเตอร์โมดูล isSupportRdma ระบุว่ารองรับการประมวลผลแพ็คเก็ต RoCE หรือไม่ รูปด้านล่างแสดงโครงสร้างของโมดูลนี้ที่รองรับการเปิดใช้งาน RoCE 
 interface UdpIpEthTx ;
    interface Put # ( UdpConfig ) udpConfig ;
    interface Put # ( UdpIpMetaData ) udpIpMetaDataIn ;
    interface Put # ( MacMetaData ) macMetaDataIn ;
    interface Put # ( DataStream ) dataStreamIn ;
    interface AxiStream512FifoOut axiStreamOut ;
endinterface

module mkGenericUdpIpEthTx # ( Bool isSupportRdma )( UdpIpEthTx ) ;
  • mkGenericRawUdpIpEthTx : โมดูลนี้จะล้อม mkGenericUdpIpEthTx โดยใช้โมดูลที่ให้มาใน blue-wrapper เพื่อสร้างอินเทอร์เฟซ Verilog ที่พร้อมใช้งาน

UdpIpArpEthRxTx

โมดูลที่มีให้ในแพ็คเกจ UdpIpArpEthRxTx ได้รับการออกแบบมาเพื่อรับและส่งแพ็กเก็ต UDP/IP/Ethernet และจัดการคำขอและการตอบกลับ ARP ในเวลาเดียวกัน

คำอธิบายแพ็คเกจโดยละเอียด:

mkGenericUdpIpArpEthRxTx

โมดูลสามารถแบ่งออกเป็นสองเส้นทางที่ตรงข้ามกันของสตรีม รวมถึงเส้นทางการส่งสัญญาณและเส้นทางการรับ:

สำหรับเส้นทางการส่งข้อมูล จะใช้ dataStreamInTx ที่บรรทุกสตรีมเพย์โหลด และ udpIpMetaDataIn ที่บรรทุกสตรีมข้อมูลส่วนหัว และสร้าง axiStreamOutTx ที่บรรทุกสตรีมแพ็กเก็ต UDP/IP/Ethernet ไม่จำเป็นต้องจัดเตรียม MacMetaData ที่มีข้อมูลส่วนหัวของ Ethernet เป็นโมดูล mkUdpIpEthTx เนื่องจาก mkArpProcessor มีหน้าที่ในการจัดการการแก้ไขที่อยู่ MAC และสร้างข้อมูลส่วนหัวของ Ethernet

สำหรับเส้นทางการรับ จะทำงานในทางตรงกันข้ามโดยการแยก dataStreamOutRx ที่บรรทุกสตรีมเพย์โหลด และ udpIpMetaDataOutRx ที่บรรทุกสตรีมข้อมูลส่วนหัวจาก axiStreamInRx ที่บรรทุกสตรีมแพ็กเก็ต UDP/IP/Ethernet

ตัวสร้างแพ็กเก็ตอีเธอร์เน็ตและตัวแยกวิเคราะห์ถูกใช้ร่วมกันโดยทั้งแพ็กเก็ต UDP/IP และแพ็กเก็ต ARP ดังนั้นจึงจำเป็นต้องมี Mux และ Demux เพิ่มเติมในพาธการส่งและการรับสำหรับการอนุญาโตตุลาการและการกระจายสตรีม พารามิเตอร์โมดูล isSupportRdma ระบุว่ารองรับการประมวลผลแพ็กเก็ต RoCE หรือไม่ หากปิดใช้งานการรองรับ RDMA เราต้องการเพียง mkUdpIpStream และ mkUdpIpMetaAndDataStream ในเส้นทางการส่งสัญญาณและการรับตามลำดับ 

 interface UdpIpArpEthRxTx ;
    interface Put # ( UdpConfig )  udpConfig ;
    // Tx
    interface Put # ( UdpIpMetaData ) udpIpMetaDataInTx ;
    interface Put # ( DataStream )    dataStreamInTx ;
    interface AxiStream512FifoOut axiStreamOutTx ;
    // Rx
    interface Put # ( AxiStream512 )   axiStreamInRx ;
    interface FifoOut # ( UdpIpMetaData ) udpIpMetaDataOutRx ;
    interface FifoOut # ( DataStream )    dataStreamOutRx ;
endinterface

module mkGenericUdpIpArpEthRxTx # ( Bool isSupportRdma )( UdpIpArpEthRxTx ) ;

mkGenericRawUdpIpArpEthRxTx

โมดูลจะล้อม mkGenericUdpIpArpEthRxTx โดยใช้โมดูลที่ให้มาใน blue-wrapper เพื่อสร้างอินเทอร์เฟซ Verilog ที่พร้อมใช้งาน

mkUdpIpArpEthCmacRxTx

โมดูลนี้รวมเอาทั้งโมดูล mkGenericUdpIpArpEthRxTx และโมดูล mkXilinxCmacTxWrapper ได้รับการออกแบบมาเพื่อโต้ตอบกับ Xilinx CMAC IP เพื่อส่งและรับแพ็กเก็ต UDP/IP/Ethernet ไปและกลับจากสื่อทางกายภาพ

ลำดับความสำคัญFlowControl

โมดูลในแพ็คเกจ PriorityFlowControl ได้รับการปรับใช้เพื่อให้ทราบถึงกลไกของการควบคุมโฟลว์ที่มีลำดับความสำคัญเพื่อให้แน่ใจว่าการส่งผ่านเครือข่ายจะไม่สูญเสียข้อมูล

คำอธิบายแพ็คเกจโดยละเอียด:
  • mkPriorityFlowControlTx รับ dataStreamInVec ซึ่งประกอบด้วยช่องเพย์โหลดสตรีมแปดช่อง และ udpIpMetaDataInVec รองรับข้อมูลส่วนหัวแปดช่อง จากนั้นดำเนินการอนุญาโตตุลาการผ่านแปดช่องสัญญาณและส่งออกผลลัพธ์การอนุญาโตตุลาการผ่าน udpIpMetaDataOut และ dataStreamOut กลยุทธ์การอนุญาโตตุลาการแบบพบกันหมดถูกนำมาใช้ในโมดูลนี้เพื่อให้ทุกช่องมีลำดับความสำคัญเท่ากัน โมดูลนี้ยังรับผิดชอบในการหยุดชั่วคราวหรือกลับมาทำงานต่อแต่ละช่องตามข้อมูลการควบคุมการไหลจาก flowControlReqVecIn 
 interface PriorityFlowControlTx ;
    interface Get # ( UdpIpMetaData ) udpIpMetaDataOut ;
    interface Get # ( DataStream ) dataStreamOut ;
endinterface

module mkPriorityFlowControlTx # (
    FifoOut # ( FlowControlReqVec ) flowControlReqVecIn ,
    Vector # ( VIRTUAL_CHANNEL_NUM , DataStreamFifoOut ) dataStreamInVec ,
    Vector # ( VIRTUAL_CHANNEL_NUM , UdpIpMetaDataFifoOut ) udpIpMetaDataInVec
)( PriorityFlowControlTx ) ;
  • mkPriorityFlowControlRx รับ udpIpMetaDataIn บรรทุกสตรีมข้อมูลส่วนหัวและ dataStreamIn บรรทุกสตรีม payload จากนั้นกำหนดเส้นทางสตรีมทั้งสองนี้ไปยังช่องสัญญาณเอาต์พุตที่สอดคล้องกันซึ่งระบุโดยดัชนีช่องสัญญาณที่รวมอยู่ในข้อมูลส่วนหัว นอกจากนี้ โมดูลนี้จำเป็นต้องตรวจสอบจำนวนองค์ประกอบที่จัดเก็บไว้ในบัฟเฟอร์กลางของแต่ละช่องสัญญาณ และเมื่อบัฟเฟอร์ของช่องถึงขีดจำกัด มันจะส่งคำขอควบคุมการไหลเพื่อหยุดการส่งแพ็กเก็ตของช่องนี้ชั่วคราว พารามิเตอร์ bufPacketNum ตั้งค่าจำนวนสูงสุดของแพ็กเก็ตที่จัดเก็บไว้ในบัฟเฟอร์ระหว่างกลาง และ maxPacketFrameNum ตั้งค่าจำนวนเฟรมสูงสุดในหนึ่งแพ็กเก็ต ความกว้างของแต่ละเฟรมคือ 256 บิต ซึ่งเท่ากับความกว้างของข้อมูลของบัฟเฟอร์ระดับกลาง pfcThreshold ตั้งค่าจำนวนขีดจำกัดของแพ็กเก็ตที่จัดเก็บไว้ในบัฟเฟอร์ที่ทริกเกอร์คำขอควบคุมการไหล 
 interface PriorityFlowControlRx # (
    numeric type bufPacketNum , 
    numeric type maxPacketFrameNum ,
    numeric type pfcThreshold
) ;
    interface FifoOut # ( FlowControlReqVec ) flowControlReqVecOut ;
    interface Vector # ( VIRTUAL_CHANNEL_NUM , Get # ( DataStream )) dataStreamOutVec ;
    interface Vector # ( VIRTUAL_CHANNEL_NUM , Get # ( UdpIpMetaData )) udpIpMetaDataOutVec ;
endinterface

module mkPriorityFlowControlRx # (
    DataStreamFifoOut dataStreamIn ,
    UdpIpMetaDataFifoOut udpIpMetaDataIn
)( PriorityFlowControlRx # ( bufPacketNum , maxPacketFrameNum , pfcThreshold )) ;

PfcUdpIpArpEthRxTx

  • mkGenericPfcUdpIpArpEthRxTx ผสานรวม mkPriorityFlowControlRx/Tx และ mkGenericUdpIpArpEthRxTx เพื่อให้มีฟังก์ชันการสร้างและแยกวิเคราะห์แพ็กเก็ต UDP/IP/Ethernet ในขณะที่สนับสนุนการควบคุมโฟลว์ลำดับความสำคัญ สำหรับการส่งแพ็กเก็ต จะใช้แปดช่องทางของเพย์โหลดสตรีมและข้อมูลส่วนหัว UDP/IP และส่งออกสตรีมแพ็กเก็ต UDP/IP/Ethernet หนึ่งช่อง สำหรับการรับแพ็กเก็ต จะใช้สตรีมแพ็กเก็ต UDP/IP/Ethernet หนึ่งรายการ และกำหนดเส้นทางส่วนหัว UDP/IP ที่แยกออกมาและสตรีมเพย์โหลดไปยังหนึ่งในแปดช่องสัญญาณเอาท์พุต

  • mkPfcUdpIpArpEthCmacRxTx ผสานรวมทั้งโมดูล mkGenericPfcUdpIpArpEthRxTx และโมดูล mkXilinxCmacTxWrapper ได้รับการออกแบบมาเพื่อโต้ตอบกับ Xilinx CMAC IP เพื่อส่งและรับแพ็กเก็ต UDP/IP/Ethernet ไปและกลับจากสื่อทางกายภาพ

ประสิทธิภาพและพื้นที่

การสังเคราะห์และการใช้งานโมดูลหลัก mkGenericUdpIpArpEthRxTx ดำเนินการโดยใช้อุปกรณ์ Xilinx xcvu9p โดยใช้ Vivado และผลลัพธ์แสดงให้เห็นว่าวงจรสามารถเข้าถึงความถี่ในการทำงาน 500MHz และให้ทรูพุตสูงสุดที่ 128Gbps การใช้ทรัพยากรฮาร์ดแวร์มีดังต่อไปนี้: 

CLB Logic
+----------------------------+-------+-------+------------+-----------+-------+
|          Site Type         |  Used | Fixed | Prohibited | Available | Util % |
+----------------------------+-------+-------+------------+-----------+-------+
| CLB LUTs                   | 63886 |     0 |          0 |   1182240 |  5.40 |
|   LUT as Logic             | 41242 |     0 |          0 |   1182240 |  3.49 |
|   LUT as Memory            | 22644 |     0 |          0 |    591840 |  3.83 |
|     LUT as Distributed RAM | 22644 |     0 |            |           |       |
|     LUT as Shift Register  |     0 |     0 |            |           |       |
| CLB Registers              | 44099 |     0 |          0 |   2364480 |  1.87 |
|   Register as Flip Flop    | 44099 |     0 |          0 |   2364480 |  1.87 |
|   Register as Latch        |     0 |     0 |          0 |   2364480 |  0.00 |
| CARRY8                     |    73 |     0 |          0 |    147780 |  0.05 |
| F7 Muxes                   |   194 |     0 |          0 |    591120 |  0.03 |
| F8 Muxes                   |    28 |     0 |          0 |    295560 | < 0.01 |
| F9 Muxes                   |     0 |     0 |          0 |    147780 |  0.00 |
+----------------------------+-------+-------+------------+-----------+-------+

BLOCKRAM
+-------------------+------+-------+------------+-----------+-------+
|     Site Type     | Used | Fixed | Prohibited | Available | Util % |
+-------------------+------+-------+------------+-----------+-------+
| Block RAM Tile    |  4.5 |     0 |          0 |      2160 |  0.21 |
|   RAMB36 / FIFO *    |    4 |     0 |          0 |      2160 |  0.19 |
|     RAMB36E2 only |    4 |       |            |           |       |
|   RAMB18          |    1 |     0 |          0 |      4320 |  0.02 |
|     RAMB18E2 only |    1 |       |            |           |       |
| URAM              |    0 |     0 |          0 |       960 |  0.00 |
+-------------------+------+-------+------------+-----------+-------+

เริ่มต้นเลย

ส่วนนี้แนะนำวิธีเริ่มต้นกับโปรเจ็กต์นี้ ก่อนขั้นตอนอื่นๆ คุณต้องตั้งค่าสภาพแวดล้อมการพัฒนาโดยอ้างอิงถึงสคริปต์ setup.sh ก่อน นี่คือรายการการขึ้นต่อกัน:

  • คอมไพเลอร์ Bluespec
  • นักเทียบท่า
  • วิวาโด
  • แพ็คเกจ Python: cocotb, cocotb-test, netifaces, scapy, cocotbext-axi
  • ฮาร์ดแวร์จำลอง: iverilog/verilator

หลังจากตั้งค่าสภาพแวดล้อมแล้ว ให้โคลน repo นี้ไปยังไดเร็กทอรีเฉพาะ ที่นี่เราเรียกไดเรกทอรีนี้ว่า BLUE_ETH: 

git clone --recursive https://github.com/wengwz/blue-ethernet.git $( BLUE_ETH )

เรียกใช้การจำลอง

ม้านั่งทดสอบมีสามระดับที่แตกต่างกันใน blue-ethernet:

  • ระดับหน่วย: ม้านั่งทดสอบของระดับนี้จะอยู่ใน $(BLUE_ETH)/test/bluesim และให้การตรวจสอบการทำงานขององค์ประกอบย่อยที่สำคัญบางอย่าง เช่น ArpCache, CompletionBuf และ AppendDataStreamTail หากต้องการเริ่มการจำลอง คุณสามารถทำตามคำสั่งด้านล่าง: 
 # Specify TARGET to the name of target component
cd $( BLUE_ETH ) /test/bluesim
make TARGET=ArpCache
  • ระดับระบบ: ม้านั่งทดสอบของระดับนี้จะอยู่ใน $(BLUE_ETH)/test/cocotb และนำไปใช้ใน Python โดยใช้แพลตฟอร์มจำลอง cocotb การตรวจสอบการทำงานของโมดูล UdpIpEthRx และ UdpIpEthTx ใช้ scapy เพื่อสร้างโมเดลอ้างอิง และโมดูล UdpIpArpEthRxTx ได้รับการทดสอบผ่านเครือข่ายเสมือนที่สร้างจากนักเทียบท่า 
 # Run tests of UdpIpEthRx/Tx
# Enable/Disable support for RDMA by setting SUPPORT_RDAM to True/False
cd $( BLUE_ETH ) /test/cocotb
make cocotb TARGET=UdpIpEthTx SUPPORT_RDMA=TRUE

# Run simulation on virtual network
# Change NET_IFC in run_docker_net_test.sh to the name of your network card
cd $( BLUE_ETH ) /test/cocotb
docker build -f ./build_docker/Dockerfile -t ethernet-test ./build_docker
./run_docker_net_test.sh
  • การจำลองด้วย CMAC: ไฟล์ต้นฉบับและสคริปต์ที่ใช้ในการจำลองร่วมของการออกแบบที่นำไปใช้และ Xilinx CMAC IP มีอยู่ในไดเร็กทอรี $(BLUE_ETH)/test/vivado 
 # Available TARGET includes UdpIpArpEthCmacRxTx/PfcUdpIpArpEthCmacRxTx
# Enable/Disable support for RDMA by setting SUPPORT_RDAM to True/False
cd $( BLUE_ETH ) /test/vivado
make sim TARGET=UdpIpArpEthCmacRxTx SUPPORT_RDMA=False

เรียกใช้การสังเคราะห์และการใช้งาน

สคริปต์ที่ใช้ในการรันการสังเคราะห์และการนำการออกแบบไปใช้นั้นมีอยู่ในไดเร็กทอรี $(BLUE_ETH)/syn 

 # TARGET specifies the top module to be synthsized or implemented
# SUPPORT_RDMA specifies whether modules supports RoCE packet processing
# ONLYSYNTH decides whether or not run implemetation after synthesis 
cd $( BLUE_ETH ) /syn
make vivado TARGET=UdpIpArpEthRxTx SUPPORT_RDMA=False ONLYSYNTH=0

การใช้งาน

  • ผู้ใช้ Verilog: การออกแบบ BSV ที่ให้ไว้ใน repo นี้สามารถสร้างโค้ด Verilog เพื่อรวมเข้ากับโปรเจ็กต์อื่นได้ บางโมดูลได้รับการหุ้มด้วยโมดูลที่ให้มาใน blue-wrapper เพื่อสร้างอินเทอร์เฟซ Verilog ที่พร้อมใช้งาน รวมถึง mkRawUdpIpEthRx , mkRawUdpIpArpEthRxTx และ mkRawUdpIpEthRx สำหรับโมดูลอื่นๆ คุณสามารถพันโมดูลเหล่านั้นได้หากจำเป็น ในการสร้างรหัส Verilog คุณสามารถปฏิบัติตามคำสั่งด้านล่าง และรหัสที่สร้างขึ้นจะอยู่ใน $(BLUE_ETH)/test/cocotb/verilog 
 # TARGET specifies the name of top module to be generated
# Specify SUPPORT_RDMA if needed
cd $( BLUE_ETH ) /test/cocotb
make verilog TARGET=UdpIpEthTx SUPPORT_RDMA=TRUE
  • ผู้ใช้ BSV: สำหรับนักออกแบบที่ใช้ BSV จะสะดวกกว่าในการรวมโมดูลที่มีให้ใน repo นี้เข้ากับโปรเจ็กต์ของตนเอง เพียงนำเข้าแพ็คเกจที่ใช้ในรหัสของคุณและเพิ่มเส้นทางไฟล์ต้นฉบับของ repo นี้เพื่อรวบรวมตัวเลือก: 
bsc -p +: $( BLUE_ETH ) /src: $( BLUE_ETH ) /src/includes ...

ลิงค์ที่เกี่ยวข้อง

การใช้งาน blue-ethernet เกี่ยวข้องกับการใช้ไลบรารีภายนอกต่อไปนี้:

  • สีฟ้า-crc: https://github.com/datenlord/blue-crc.git
  • blue-wrapper: https://github.com/wengwz/blue-wrapper
ขยาย
ข้อมูลเพิ่มเติม
แอปที่เกี่ยวข้อง
แนะนำสำหรับคุณ
ข้อมูลที่เกี่ยวข้อง ทั้งหมด