golang UDP發送實在太慢了 系統調用，上下文切換消耗可觀。

原創 wyg_031113 2020-06-03 10:44

golang UDP WriteToUDP太慢了

由於發送大量的小包，導致系統調用過於頻繁，Packet Per Second: PPS=152300

golang目前沒有提供C中的API: sendmmsg, 這是個批量發送數據包的接口，一次系統調用可以發多個包。

udp_test.go

package main

import (
	"fmt"
	"net"
	"sync"
	"testing"
	"time"
)

func ListenUDP(addrStr string) (*net.UDPAddr, *net.UDPConn, error) {
	fmt.Println("Try to listen:", addrStr)
	addr, err := net.ResolveUDPAddr("udp", addrStr)
	if err != nil {
		fmt.Println("resolve udp addr failed:", err)
		return nil, nil, err
	}

	conn, err := net.ListenUDP("udp", addr)
	if err != nil {
		fmt.Println("listen udp svr failed:", err)
		return nil, nil, err
	}

	return addr, conn, nil
}
func TestUDPSendSpeed(t *testing.T) {
	_, svrConn, err := ListenUDP("127.0.0.1:21117")
	if err != nil {
		t.Fatal(err)
	}
	svrConn.SetWriteBuffer(300000000) //300MB
	cliAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:29875")
	data := []byte("Hello, test small packet")
	N := 100000
	M := 4
	begin := time.Now().UnixNano()
	var wg sync.WaitGroup
	for j := 0; j < M; j++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for i := 0; i < N; i++ {
				n, err := svrConn.WriteToUDP(data, cliAddr)
				if err != nil || n != len(data) {
					t.Fatal(err, n, len(data))
				}
			}
		}()
	}
	wg.Wait()
	end := time.Now().UnixNano()
	usedTimeMS := float64(end-begin) / 1e6
	usedTimeS := float64(end-begin) / 1e9
	fmt.Printf("Send %d packets, use %.2fms, PPS:%.0f\n", N*M, usedTimeMS, float64(N*M)/usedTimeS)

}

 

 

go test -v -cpuprofile=cpu.prof udp_test.go 
=== RUN   TestUDPSendSpeed
Try to listen: 127.0.0.1:21117
Send 1000000 packets, use 6565.98ms, PPS:152300
--- PASS: TestUDPSendSpeed (6.57s)
PASS
ok      command-line-arguments  6.713s

#性能分析
go tool pprof -http=:7897 cpu.prof 
Serving web UI on http://localhost:7897

 

如果使用C++呢 直接調用sendto呢？

經過多次運行，發線單線程效率最好，可達到25W PPS。 這也是單線程的極限了。

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <netdb.h>
#include <time.h>
//#include <gperftools/profiler.h>

#include <iostream>
#include <chrono>
#include <thread>
using namespace std;

#define BUF_SIZE 64
char data[BUF_SIZE];
sockaddr_in BuildAddr(const char *ip, int port)
{
    sockaddr_in svrAddr;
    memset(&svrAddr, 0, sizeof(svrAddr));
    svrAddr.sin_family = AF_INET;
    svrAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    svrAddr.sin_port = htons(port);
    return svrAddr;
}
int ListenUDP(const char *ip, int port)
{
    sockaddr_in svrAddr = BuildAddr(ip, port);
    int sockFd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockFd < 0)
    {
        perror("create socket failed!");
        return sockFd;
    }
    if (bind(sockFd, (sockaddr *)&svrAddr, sizeof(svrAddr)) < 0)
    {
        perror("bind svr addr failed");
        return -1;
    }
    return sockFd;
}

void SendPacket(int n, int size, int svrFd, const char *targetIP, int targetPort)
{
    sockaddr_in targetAddr = BuildAddr(targetIP, targetPort);
    char *data = new char[size];

    for (int i = 0; i < n; i++)
    {
        int ret = sendto(svrFd, data, size, 0, (sockaddr *)&targetAddr, sizeof(targetAddr));
        if (ret < 0)
        {
            perror("sendto failed");
        }
        //printf("send packet:%d\n", ret);
    }

    delete[] data;
}
void SendMsgPacket(int n, int m, int size, int svrFd, const char *targetIP, int targetPort)
{
    sockaddr_in targetAddr = BuildAddr(targetIP, targetPort);
    char *data = new char[size];
    struct iovec msg1;
    msg1.iov_base = data;
    msg1.iov_len = 1;
    mmsghdr *msg = new mmsghdr[m];
    for (int i = 0; i < m; i++)
    {
        msg[i].msg_len = 1;
        msg[i].msg_hdr.msg_name = &targetAddr;
        msg[i].msg_hdr.msg_namelen = sizeof(targetAddr);
        msg[i].msg_hdr.msg_iov = &msg1;
        msg[i].msg_hdr.msg_iovlen = 1;
    }
    for (int i = 0; i < n; i++)
    {
        int t = m;
        while (t > 0)
        {
            int ret = sendmmsg(svrFd, msg, m, 0);
            if (ret < 0)
            {
                perror("sendto failed");
            }
            //printf("send %d\n", t);
            t -= ret;
        }
    }
    delete[] msg;
    delete[] data;
}
void TestSendThread(int n, int svrFd)
{
    SendPacket(n, 32, svrFd, "127.0.0.1", 55667);
}
void TestSendMsgThread(int n, int m, int svrFd)
{
    SendMsgPacket(n, m, 32, svrFd, "127.0.0.1", 55667);
}
int main(int argc, char *argv[])
{
    int svrFd = ListenUDP("127.0.0.1", 65432);
    if (svrFd < 0)
    {
        perror("listen upd failed");
    }
    else
    {
        printf("UDP Server at 127.0.0.1:65432\n");
    }
    //ProfilerStart("udpsend.prof");
    auto begin = chrono::steady_clock::now();
    int n = 100000;
    int m = 100;
    TestSendThread(n, svrFd);
    //TestSendMsgThread(n, m, svrFd);
    auto end = chrono::steady_clock::now();
    //ProfilerStop();
    double dr_ms = std::chrono::duration<double, std::milli>(end - begin).count();
    printf("Use time:%.2fms, PPS:%.0f\n", dr_ms, n / (dr_ms / 1000));
    close(svrFd);
}
//g++ -O3 -o send_speed send_speed.cpp -lpthread

//g++  -g -pg -o send_speed send_speed.cpp -lpthread

/*
g++ -O3 -o send_speed send_speed.cpp 
valgrind --tool=callgrind ./send_speed
python ../../gprof2dot/gprof2dot.py -f callgrind -n 10 -s callgrind.out.2938509 > val.dot
dot -Tpng val.dot -o val.png
python -m http.server 7897
*/
./send_speed 
UDP Server at 127.0.0.1:65432
Use time:383.56ms, PPS:260712

./send_speed 
UDP Server at 127.0.0.1:65432
Use time:382.87ms, PPS:261182

 ./send_speed 
UDP Server at 127.0.0.1:65432
Use time:381.96ms, PPS:261810

經過分析發現，sendto系統調用佔用了34%

 

C++多線程 sento

120WQPS

本機是8核，所以用8線程。發送速度幾乎提升了8倍。CPU終於到了755%但是golang使用多現成確不能提升。golang的writeToUDP自帶鎖。所以只能達到單核心的25W PPS。

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <netdb.h>
#include <time.h>
//#include <gperftools/profiler.h>

#include <iostream>
#include <chrono>
#include <thread>
using namespace std;

#define BUF_SIZE 64
char data[BUF_SIZE];
sockaddr_in BuildAddr(const char *ip, int port)
{
    sockaddr_in svrAddr;
    memset(&svrAddr, 0, sizeof(svrAddr));
    svrAddr.sin_family = AF_INET;
    svrAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    svrAddr.sin_port = htons(port);
    return svrAddr;
}
int ListenUDP(const char *ip, int port)
{
    sockaddr_in svrAddr = BuildAddr(ip, port);
    int sockFd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockFd < 0)
    {
        perror("create socket failed!");
        return sockFd;
    }
    if (bind(sockFd, (sockaddr *)&svrAddr, sizeof(svrAddr)) < 0)
    {
        perror("bind svr addr failed");
        return -1;
    }
    return sockFd;
}

void SendPacket(int n, int size, int svrFd, const char *targetIP, int targetPort)
{
    sockaddr_in targetAddr = BuildAddr(targetIP, targetPort);
    char *data = new char[size];

    for (int i = 0; i < n; i++)
    {
        int ret = sendto(svrFd, data, size, 0, (sockaddr *)&targetAddr, sizeof(targetAddr));
        if (ret < 0)
        {
            perror("sendto failed");
        }
        //printf("send packet:%d\n", ret);
    }

    delete[] data;
}
void SendMsgPacket(int n, int m, int size, int svrFd, const char *targetIP, int targetPort)
{
    sockaddr_in targetAddr = BuildAddr(targetIP, targetPort);
    char data[] = "{\"cmd\":\"echo\"}";
    int iov_len = strlen(data);
    struct iovec msg2[2];
    msg2[0].iov_base = data;
    msg2[0].iov_len = iov_len;
    msg2[1] = msg2[0];
    mmsghdr *msg = new mmsghdr[m];
    for (int i = 0; i < m; i++)
    {
        msg[i].msg_len = 1;
        msg[i].msg_hdr.msg_name = &targetAddr;
        msg[i].msg_hdr.msg_namelen = sizeof(targetAddr);
        msg[i].msg_hdr.msg_iov = msg2;
        msg[i].msg_hdr.msg_iovlen = 1;
    }
    for (int i = 0; i < n; i++)
    {
        int t = m;
        while (t > 0)
        {
            int ret = sendmmsg(svrFd, msg, m, 0);
            if (ret < 0)
            {
                perror("sendto failed");
            }
            //printf("send %d\n", t);
            t -= ret;
        }
    }
    delete[] msg;
}
void TestSendThread(int n, int svrFd)
{
    SendPacket(n, 32, svrFd, "127.0.0.1", 16666);
}
void TestSendMsgThread(int n, int m, int svrFd)
{
    SendMsgPacket(n, m, 32, svrFd, "127.0.0.1", 16666);
}
int main(int argc, char *argv[])
{
    int svrFd = ListenUDP("127.0.0.1", 65432);
    if (svrFd < 0)
    {
        perror("listen upd failed");
    }
    else
    {
        printf("UDP Server at 127.0.0.1:65432\n");
    }
    int value = 200000000;
    ::setsockopt(svrFd, SOL_SOCKET, SO_RCVBUF, (char *)&value, sizeof(value));
    ::setsockopt(svrFd, SOL_SOCKET, SO_SNDBUF, (char *)&value, sizeof(value));
    //ProfilerStart("udpsend.prof");
    auto begin = chrono::steady_clock::now();
    int n = 1000000;
    int m = 1;
    //TestSendThread(n, svrFd);
    int t = 8;
    thread *threads[20];
    for (int i = 0; i < t; i++)
    {
        //threads[i] = new thread(TestSendMsgThread, n, m, svrFd);
        threads[i] = new thread(TestSendThread, n, svrFd);
    }
    for (int i = 0; i < t; i++)
    {
        threads[i]->join();
        delete threads[i];
    }

    auto end = chrono::steady_clock::now();
    //ProfilerStop();
    double dr_ms = std::chrono::duration<double, std::milli>(end - begin).count();
    printf("Use time:%.2fms, PPS:%.0f\n", dr_ms, n * m * t / (dr_ms / 1000));
    close(svrFd);
}


g++ -O3 -o send_speed send_speed.cpp -lpthread
./send_speed 
UDP Server at 127.0.0.1:65432
Use time:6903.19ms, PPS:1158884

 ./send_speed 
UDP Server at 127.0.0.1:65432
Use time:6737.55ms, PPS:1187375

 ./send_speed 
UDP Server at 127.0.0.1:65432
Use time:6742.78ms, PPS:1186455

 

C++多線程 sendmmsg

也就130W PPS,但是可以看出sendmmsg系統調用不是瓶頸。

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <netdb.h>
#include <time.h>
//#include <gperftools/profiler.h>

#include <iostream>
#include <chrono>
#include <thread>
using namespace std;

#define BUF_SIZE 64
char data[BUF_SIZE];
sockaddr_in BuildAddr(const char *ip, int port)
{
    sockaddr_in svrAddr;
    memset(&svrAddr, 0, sizeof(svrAddr));
    svrAddr.sin_family = AF_INET;
    svrAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    svrAddr.sin_port = htons(port);
    return svrAddr;
}
int ListenUDP(const char *ip, int port)
{
    sockaddr_in svrAddr = BuildAddr(ip, port);
    int sockFd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockFd < 0)
    {
        perror("create socket failed!");
        return sockFd;
    }
    if (bind(sockFd, (sockaddr *)&svrAddr, sizeof(svrAddr)) < 0)
    {
        perror("bind svr addr failed");
        return -1;
    }
    return sockFd;
}

void SendPacket(int n, int size, int svrFd, const char *targetIP, int targetPort)
{
    sockaddr_in targetAddr = BuildAddr(targetIP, targetPort);
    char *data = new char[size];

    for (int i = 0; i < n; i++)
    {
        int ret = sendto(svrFd, data, size, 0, (sockaddr *)&targetAddr, sizeof(targetAddr));
        if (ret < 0)
        {
            perror("sendto failed");
        }
        //printf("send packet:%d\n", ret);
    }

    delete[] data;
}
void SendMsgPacket(int n, int m, int size, int svrFd, const char *targetIP, int targetPort)
{
    sockaddr_in targetAddr = BuildAddr(targetIP, targetPort);
    char data[] = "{\"cmd\":\"echo\"}";
    int iov_len = strlen(data);
    struct iovec msg2[2];
    msg2[0].iov_base = data;
    msg2[0].iov_len = iov_len;
    msg2[1] = msg2[0];
    mmsghdr *msg = new mmsghdr[m];
    for (int i = 0; i < m; i++)
    {
        msg[i].msg_len = 1;
        msg[i].msg_hdr.msg_name = &targetAddr;
        msg[i].msg_hdr.msg_namelen = sizeof(targetAddr);
        msg[i].msg_hdr.msg_iov = msg2;
        msg[i].msg_hdr.msg_iovlen = 1;
    }
    for (int i = 0; i < n; i++)
    {
        int t = m;
        while (t > 0)
        {
            int ret = sendmmsg(svrFd, msg, m, 0);
            if (ret < 0)
            {
                perror("sendto failed");
            }
            //printf("send %d\n", t);
            t -= ret;
        }
    }
    delete[] msg;
}
void TestSendThread(int n, int svrFd)
{
    SendPacket(n, 32, svrFd, "127.0.0.1", 16666);
}
void TestSendMsgThread(int n, int m, int svrFd)
{
    SendMsgPacket(n, m, 32, svrFd, "127.0.0.1", 16666);
}
int main(int argc, char *argv[])
{
    int svrFd = ListenUDP("127.0.0.1", 65432);
    if (svrFd < 0)
    {
        perror("listen upd failed");
    }
    else
    {
        printf("UDP Server at 127.0.0.1:65432\n");
    }
    int value = 200000000;
    ::setsockopt(svrFd, SOL_SOCKET, SO_RCVBUF, (char *)&value, sizeof(value));
    ::setsockopt(svrFd, SOL_SOCKET, SO_SNDBUF, (char *)&value, sizeof(value));
    //ProfilerStart("udpsend.prof");
    auto begin = chrono::steady_clock::now();
    int n = 1000;
    int m = 1000;
    //TestSendThread(n, svrFd);
    int t = 8;
    thread *threads[20];
    for (int i = 0; i < t; i++)
    {
        threads[i] = new thread(TestSendMsgThread, n, m, svrFd);
        //threads[i] = new thread(TestSendThread, n, svrFd);
    }
    for (int i = 0; i < t; i++)
    {
        threads[i]->join();
        delete threads[i];
    }

    auto end = chrono::steady_clock::now();
    //ProfilerStop();
    double dr_ms = std::chrono::duration<double, std::milli>(end - begin).count();
    printf("Use time:%.2fms, PPS:%.0f\n", dr_ms, n * m * t / (dr_ms / 1000));
    close(svrFd);
}

//g++ -O3 -o send_speed send_speed.cpp -lpthread
//g++ -O3 -o send_speed send_speed.cpp -lpthread

//g++  -g -pg -o send_speed send_speed.cpp -lpthread

/*
g++ -O3 -o send_speed send_speed.cpp 
valgrind --tool=callgrind ./send_speed

}
//g++ -O3 -o send_speed send_speed.cpp -lpthread

//g++  -g -pg -o send_speed send_speed.cpp -lpthread

/*
g++ -O3 -o send_speed send_speed.cpp 
valgrind --tool=callgrind ./send_speed
python ../../gprof2dot/gprof2dot.py -f callgrind -n 10 -s callgrind.out.2938509 > val.dot
dot -Tpng val.dot -o val.png
python -m http.server 7897
*/
 ./send_speed 
UDP Server at 127.0.0.1:65432
Use time:6025.68ms, PPS:1327650

 ./send_speed 
UDP Server at 127.0.0.1:65432
Use time:5970.89ms, PPS:1339833

 ./send_speed 
UDP Server at 127.0.0.1:65432
Use time:6180.63ms, PPS:1294366

 

C++ 多socket同時發送

由於本機不支持SO_REUSEPORT,所以使用多個socket模擬。 PPS可達 170W。

操作系統版本：uname -a

Linux n227-020-135 4.14.81.bm.15-amd64 #1 SMP Debian 4.14.81.bm.15 Sun Sep 8 05:02:31 UTC 2019 x86_64 GNU/Linux

發現TCP可以reuse port, UDP就不行。

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <netdb.h>
#include <time.h>
//#include <gperftools/profiler.h>

#include <iostream>
#include <chrono>
#include <thread>
using namespace std;

#define BUF_SIZE 64
char data[BUF_SIZE];
sockaddr_in BuildAddr(const char *ip, int port)
{
    sockaddr_in svrAddr;
    memset(&svrAddr, 0, sizeof(svrAddr));
    svrAddr.sin_family = AF_INET;
    svrAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    svrAddr.sin_port = htons(port);
    return svrAddr;
}
int ListenUDP(const char *ip, int port)
{
    sockaddr_in svrAddr = BuildAddr(ip, port);
    int sockFd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockFd < 0)
    {
        perror("create socket failed!");
        return sockFd;
    }
    if (bind(sockFd, (sockaddr *)&svrAddr, sizeof(svrAddr)) < 0)
    {
        perror("bind svr addr failed");
        return -1;
    }
    int val = 1;
    if (setsockopt(sockFd, SOL_SOCKET, SO_REUSEPORT | SO_REUSEADDR, &val, sizeof(val)) < 0)
    {
        perror("setsockopt()");
    }
    return sockFd;
}

void SendPacket(int n, int size, int svrFd, const char *targetIP, int targetPort)
{
    sockaddr_in targetAddr = BuildAddr(targetIP, targetPort);
    char *data = new char[size];

    for (int i = 0; i < n; i++)
    {
        int ret = sendto(svrFd, data, size, 0, (sockaddr *)&targetAddr, sizeof(targetAddr));
        if (ret < 0)
        {
            perror("sendto failed");
        }
        //printf("send packet:%d\n", ret);
    }

    delete[] data;
}
void SendMsgPacket(int n, int m, int size, int svrFd, const char *targetIP, int targetPort)
{
    sockaddr_in targetAddr = BuildAddr(targetIP, targetPort);
    char data[] = "{\"cmd\":\"echo\"}";
    int iov_len = strlen(data);
    struct iovec msg2[2];
    msg2[0].iov_base = data;
    msg2[0].iov_len = iov_len;
    msg2[1] = msg2[0];
    mmsghdr *msg = new mmsghdr[m];
    for (int i = 0; i < m; i++)
    {
        msg[i].msg_len = 1;
        msg[i].msg_hdr.msg_name = &targetAddr;
        msg[i].msg_hdr.msg_namelen = sizeof(targetAddr);
        msg[i].msg_hdr.msg_iov = msg2;
        msg[i].msg_hdr.msg_iovlen = 1;
    }
    for (int i = 0; i < n; i++)
    {
        int t = m;
        while (t > 0)
        {
            int ret = sendmmsg(svrFd, msg, m, 0);
            if (ret < 0)
            {
                perror("sendto failed");
            }
            //printf("send %d\n", t);
            t -= ret;
        }
    }
    delete[] msg;
}
void TestSendThread(int n, int svrFd)
{
    SendPacket(n, 32, svrFd, "127.0.0.1", 16666);
}

int fds[128];
void TestSendMsgThread(int n, int m, int svrFd)
{
    if (svrFd <= 0)
    {
        int i = -svrFd;
        svrFd = ListenUDP("127.0.0.1", 65432 + svrFd);
        fds[i] = svrFd;
        printf("%d %d\n", i, svrFd);
        if (svrFd < 0)
        {
            perror("listen upd failed");
            exit(1);
        }
        else
        {
            printf("UDP Server at 127.0.0.1:%d\n", 65432 + svrFd);
        }
    }
    SendMsgPacket(n, m, 32, svrFd, "127.0.0.1", 16666);
}
int main(int argc, char *argv[])
{
    //int fds[20];

    //int value = 4000;
    //::setsockopt(svrFd, SOL_SOCKET, SO_RCVBUF, (char *)&value, sizeof(value));
    //::setsockopt(svrFd, SOL_SOCKET, SO_SNDBUF, (char *)&value, sizeof(value));
    //ProfilerStart("udpsend.prof");
    auto begin = chrono::steady_clock::now();
    int n = 1000;
    int m = 1000;
    //TestSendThread(n, svrFd);
    int t = 10;

    // int svrFd = ListenUDP("127.0.0.1", 65431);
    // //fork();
    // if (svrFd < 0)
    // {
    //     perror("listen upd failed");
    //     exit(1);
    // }
    // else
    // {
    //     printf("UDP Server at 127.0.0.1:65432\n");
    // }

    thread *threads[128];
    for (int i = 0; i < t; i++)
    {
        threads[i] = new thread(TestSendMsgThread, n, m, i >= 8 ? fds[i % 8] : -i);
        //threads[i] = new thread(TestSendThread, n, svrFd);
    }

    for (int i = 0; i < t; i++)
    {
        threads[i]->join();
        delete threads[i];
    }

    auto end = chrono::steady_clock::now();
    //ProfilerStop();
    double dr_ms = std::chrono::duration<double, std::milli>(end - begin).count();
    printf("Use time:%.2fms, PPS:%.0f\n", dr_ms, n * m * t / (dr_ms / 1000));
    // close(svrFd);
}

//g++ -O3 -o send_speed send_speed.cpp -lpthread
//g++ -O3 -o send_speed send_speed.cpp -lpthread

//g++  -g -pg -o send_speed send_speed.cpp -lpthread

/*
g++ -O3 -o send_speed send_speed.cpp 
valgrind --tool=callgrind ./send_speed

}
//g++ -O3 -o send_speed send_speed.cpp -lpthread

//g++  -g -pg -o send_speed send_speed.cpp -lpthread

/*
g++ -O3 -o send_speed send_speed.cpp 
valgrind --tool=callgrind ./send_speed
python ../../gprof2dot/gprof2dot.py -f callgrind -n 10 -s callgrind.out.2938509 > val.dot
dot -Tpng val.dot -o val.png
python -m http.server 7897
*/

 

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

流水線 YAML 高級用法來了！大幅降低重複代碼、靈活編排多任務

作者：木煙 在 YAML 化配置流水線時，你是否會遇到以下問題？ 單流水線中批量執行類似任務場景時，YAML 中需要定義多個類似邏輯的 Job，Job 越多，流水線 YAML 配置的越長，YAML 中的重複代碼越多，代碼複用性低，可讀性差

原創 2024-05-16 21:13:44

通義千問 2.5 “客串” ChatGPT4，你分的清嗎？

作者：張添翼、董藝荃 引子 OpenAI 發佈了最新的 GPT-4o 模型，通義千問也在前不久剛發佈通義千問 2.5，已經和 GPT-4-Turbo 不分伯仲： 既然目前還沒有和 GPT-4o 文本生成能力的對比數據，就讓我們來和大模型一

原創 2024-05-16 21:13:41

`iris.context`獲取參數的具體代碼是什麼？

獲取URL路徑參數： go 複製 package main import ( "github.com/kataras/iris/v12" ) func main() {

原創 2024-05-16 01:55:00

OSS_PIPE：Rust編寫的大規模文件遷移工具

‍ 隨着業務的發展，文件數量和文件大小會急劇增加，文件遷移的數量和難度不斷攀升。oss_pipe 是rust編寫的文件遷移工具，旨在支撐大規模的文件遷移場景。 編寫 oss_pipe 的初衷 •同類產品面臨的問題 •rust 語

京東雲開發者 2024-05-15 23:59:27

數據結構筆記淺記（十四） 樹

二叉樹 「二叉樹 binary tree」是一種非線性數據結構，代表“祖先”與“後代”之間的派生關係，體現了“一分爲二” 的分治邏輯。與鏈表類似，二叉樹的基本單元是節點，每個節點包含值、左子節點引用和右子節點引用。   每個節點都有兩個引

原創 2024-05-14 00:28:41

Linux中的tty和pts

一、幾個基本概念 tty（Teletypewriter） 來源於“電傳打印機”，Linux系統中則是終端設備的統稱，同時也代指操作系統中支持終端設備的tty子系統。   console（控制檯）

原創 2024-05-18 00:45:13

個人開發者如何入門 Java 異步編程

標題：《從零開始：一份詳盡的Linux安裝教程》 引言： 在數字化的世界裏，Linux操作系統以其開源的特性、高度的安全性和穩定性，成爲了服務器和個人電腦的熱門選擇。無論是開發者、系統管理員還是技術愛好者，掌握Linux的安裝與配置都是一項

原創 2024-05-17 01:49:09

在Linux操作系統的安裝過程中，如何選擇合適的發行版

【關鍵詞】{{linux安裝}} 【提問】{{question}} 在Linux操作系統的安裝過程中，如何選擇合適的發行版，並確保安裝過程順利進行？此外，對於不同硬件配置的用戶，有哪些特定的安裝注意事項和優化策略？ 【文章】{{Linux操

原創 2024-05-17 01:49:06

高效調度新篇章：詳解DolphinScheduler 3.2.0生產級集羣搭建

轉載自tuoluzhe8521 導讀：通過簡化複雜的任務依賴關係， DolphinScheduler爲數據工程師提供了強大的工作流程管理和調度能力。在3.2.0版本中，DolphinScheduler帶來了一系列新功能和改進，使其在生產環

原創 2024-05-15 21:22:54

Spring 按條件裝配使用方法

條件註冊 Spring 4.0 引入條件註冊機制，暴露給用戶的API是@Conditional和Condition接口，把@Conditional聲明在一個 @Component類上，並接受一組條件（Condition實現），容器初始化期間

原創 2024-05-15 11:50:12

界面組件DevExpress Reporting v24.1預覽版 - 擁有原生Angular報表查看器

DevExpress Reporting是.NET Framework下功能完善的報表平臺，它附帶了易於使用的Visual Studio報表設計器和豐富的報表控件集，包括數據透視表、圖表，因此您可以構建無與倫比、信息清晰的報表。 下一個主要

原創 2024-05-14 12:21:34

利用pyinstaller打包Python程序爲一個可執行文件

有時，Python發佈的程序需要被打包爲一個文件夾、甚至一個文件發佈。 目前（2020）最佳的策略是使用pyinstaller。 pyinstaller不僅支持打包整個運行環境到一個可執行文件，而且還支持加密。 但唯一的問題是，必須依賴

osc_hwc3munb 2024-05-14 02:04:34

FA的linux基礎01

vim常用功能 set nu   :200  set nonu  G 最後一行   gg跳到第一行 dd 刪除光標所在行      5dd 從光標所在行開始，刪除5行 p粘貼 yy 複製光標所在行  p粘貼 5yy  u 撤銷之前的操

osc_hzf6peqc 2024-05-14 01:40:14

Android內存管理機制官方詳解文檔

很早之前寫過一篇《Android內存管理機制詳解》點擊量已7萬+，現把Google官方文檔整理輸出一下，供各位參考。 一、內存管理概覽 Android 運行時 (ART) 和 Dalvik 虛擬機使用分頁和內存映射來管理內存。這意味着應用

osc_51airx3z 2024-05-14 00:37:42

raid添加新的硬盤問題

linux平臺下: 在raid5已經做好的時候，不能添加新硬盤的raid5的陣列組裏，添加的只能變爲spare盤。 比如：用4塊磁盤做的raid5，再往這麼陣列組中添加硬盤變成5塊硬盤的陣列是錯誤的做法，原因是raid是橫向條帶化的。

osc_61miaq6u 2024-05-13 22:58:18