测试点点延迟和带宽的脚本总结

从队列中获取节点名

我们有时候需要从任务队列中取出完整的节点名称，比如cn[8044-8046,8358-8360,8926-8928,9002-9004]，可以给定参数input_str也可以在脚本中直接写死。

请添加图片描述

import re
import subprocess
import sys

input_str = "cn[7512-7519,7545-7552,7777,8290-8297,8888]"
input_str = "cn[7512-7519]"
# 使用正则表达式提取数字范围

input_str = sys.argv[1]
ranges = re.findall(r"\d+-\d+|\d+", input_str)

node_names = []
for item in ranges:
    if '-' in item:
        start, end = map(int, item.split('-'))
        for i in range(start, end + 1):
            node_names.append(f"cn{i}")
    else:
        node_names.append(f"cn{item}")

print(node_names)
print(len(node_names))

在这里插入图片描述

from util import *

一个技巧：写python脚本尽量使用函数方便进行调用，比如上面的脚本，虽然实现了功能，但是不方便其他脚本来调用，可以使用函数改写成：

import re
import subprocess
import sys


def get_cn_name(input_str):
    # 使用正则表达式提取数字范围
    ranges = re.findall(r"\d+-\d+|\d+", input_str)

    node_names = []
    for item in ranges:
        if '-' in item:
            start, end = map(int, item.split('-'))
            for i in range(start, end + 1):
                node_names.append(f"cn{i}")
        else:
            node_names.append(f"cn{item}")

    return node_names


if __name__ == "__main__":
    #input_str = "cn[7512-7519,7545-7552,7777,8290-8297,8888]"
    #input_str = "cn[7512-7519]"
    input_str = sys.argv[1]
    node_names = get_cn_name(input_str)
    print(node_names)
    print(len(node_names))

这样在其他脚本中使用这个函数，只需要import一下：

import get_cn_name
node_names = get_cn_name.get_cn_name("cn[7512-7519,7545-7552,7777,8290-8297,8888]")
print(node_names)
print(len(node_names))

from get_cn_name import *

node_names = get_cn_name("cn[7512-7519,7545-7552,7777,8290-8297,8888]")
print(node_names)
print(len(node_names))

import 关键字：

  • 使用 import 关键字可以导入整个模块。例如：import random 将整个 random 模块导入到当前的命名空间中。
  • 导入整个模块后，你可以使用模块中定义的函数、类和变量。但是，你需要使用模块名作为前缀来访问这些定义。例如：random.randint(1, 10)。
  • 这种方式可能会导致命名空间的冲突，特别是当你导入多个模块时，可能会出现同名的函数或变量。

from import 关键字：

  • 使用 from import 关键字可以从模块中导入特定的内容。例如：from random import randint 只导入 random 模块中的 randint 函数。
  • 导入特定内容后，你可以直接使用函数、类或变量的名称，而无需使用模块名作为前缀。例如：randint(1, 10)。
  • 这种方式可以减少代码中的冗余，并提供更直接的访问方式。但是，如果导入的内容与当前命名空间中的其他内容发生冲突，可能会导致命名冲突的问题。

随机数

在Python中，你可以使用random模块来生成随机数。random模块提供了各种生成随机数的函数。

生成一个0到1之间的随机浮点数：

import random

random_number = random.random()
print(random_number)

生成一个指定范围内的随机整数：

import random

random_integer = random.randint(1, 10)  # 生成1到10之间的随机整数
print(random_integer)

从列表或序列中随机选择一个元素：

import random

my_list = [1, 2, 3, 4, 5]
random_element = random.choice(my_list)
print(random_element)

生成一个指定范围内的随机浮点数：

import random

random_float = random.uniform(0.0, 1.0)  # 生成0到1之间的随机浮点数
print(random_float)

保留两位小数：

import random

random_float = round(random.uniform(0.0, 1.0), 2)  # 生成0到1之间的随机浮点数并保留两位小数
print(random_float)

采样

random.sample()函数是Python中用于从给定的序列中选择指定数量的唯一随机元素的函数。它可以用于生成不重复的随机数样本。下面这个程序是采样不重复numa和节点对。

import random

numa = [(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7),
        (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7),
        (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7),
        (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7),
        (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7),
        (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7),
        (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7),
        (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7),
        ]

random_four = random.sample(numa, 4)
print(random_four)
print(random_four[1])
print(random_four[1][0])
print(random_four[1][1])

cns = ["cn1", "cn2", "cn3", "cn4", "cn5", "cn6", "cn7", "cn8", "cn9", "cn10", "cn11", "cn12", "cn13", "cn14", "cn15", "cn16",
       "cn17", "cn18", "cn19", "cn10"]

random_pairs = random.sample(cns, k=20)
random_pairs = [(random_pairs[i], random_pairs[i + 1]) for i in range(0, len(random_pairs), 2)]

print(random_pairs)

for i in range(0,len(random_pairs)):
    print(random_pairs[i][0],random_pairs[i][1])

在这里插入图片描述

程序运行时间计时

import os

import time

start_time = time.time()
time.sleep(10)
end_time = time.time()
# 计算执行时间
execution_time = end_time - start_time
print("程序执行时间：", execution_time, "秒")

使用oobw计算点点延迟和带宽

get_oobw是单纯的进行点点延迟和带宽的计算，get_oobw_mpi使用了多线程计算，节省大量时间。sam_get_min_oobw_mpi相比get_oobw_mpi进行了采样，在全局环境下不需要穷尽所有节点的点点延迟和带宽计算，进一步节省了时间。

#!/usr/bin/env python3 
# -*- coding: utf-8 -*- 
#----------------------------------------------------------------------------
# Created By  : Wanxin Wang
# Created Date: 03.8.2024
import random
import re
import os
#import matplotlib.pyplot as plt
import numpy as np
import os
import subprocess
from subprocess import PIPE, run
from contextlib import contextmanager
import sys
import time
import multiprocessing



def get_available_vp(info):
    info = info.split("\n")[1:]
    #print(info)
    used_vps = []
    for line in info:
        tmp = line.split()
        if len(tmp) > 1:
            tmp = line.split()[0]
            if "*" in tmp:
                tmp = tmp[1:]

            #print(tmp)
            used_vps.append(int(tmp))
    for vp in range(9, 56):
        if vp not in used_vps:
            return vp

def get_oobw(sender,reciver,reciver_numa,sender_numa):
    latency = 0
    bandwidth = 0

    # get inputs
    os.system("rm ./receiver.lock ./result.txt >/dev/null 2>&1")

    #print("sys.arg[0] sender reciver reciver_numa sender_numa")
    #sender = sys.argv[1]
    #reciver = sys.argv[2]
    #reciver_numa = sys.argv[3]
    #sender_numa = sys.argv[4]
    errorlog = open("/tmp/stderr.log", "wb")
    outlog = open("/tmp/out.log", "wb")

    get_nic_id_cmd = "~/auto_oobw-master/get_nic_id"
    out, err = subprocess.Popen(
        "/usr/bin/nss_yhpc_ssh root@{} ".format(sender) + get_nic_id_cmd,
        shell=True,
        stdout=subprocess.PIPE,
        stderr=errorlog,
    ).communicate()
    out = out.decode("ascii")
    sender_nic_id = out.split("\n")[0]
    get_vp_cmd = "cat /proc/glex/nic0/endpoints"

    out, err = subprocess.Popen(
        "/usr/bin/nss_yhpc_ssh root@{} ".format(reciver) + get_nic_id_cmd,
        shell=True,
        stdout=subprocess.PIPE,
        stderr=errorlog,
    ).communicate()

    out = out.decode("ascii")
    reciver_nic_id = out.split("\n")[0]

    out, err = subprocess.Popen(
        "/usr/bin/nss_yhpc_ssh root@{} ".format(sender) + get_vp_cmd,
        shell=True,
        stdout=subprocess.PIPE,
        stderr=errorlog,
    ).communicate()
    sender_available_vp = get_available_vp(out.decode("ascii"))

    out, err = subprocess.Popen(
        "/usr/bin/nss_yhpc_ssh root@{} ".format(reciver) + get_vp_cmd,
        shell=True,
        stdout=subprocess.PIPE,
        stderr=errorlog,
    ).communicate()
    reciver_available_vp = get_available_vp(out.decode("ascii"))

    print("starting reciver")
    #result_file = '{}.to.{}/txt/{}_send_{}_recv_send_numa_{}_recv_numa_{}.txt'.format(sender, reciver, sender, reciver, sender_numa, reciver_numa)
    #if os.access(result_file, os.F_OK):
    #    exit(1)

    reciver_test_cmd = "/usr/bin/nss_yhpc_ssh root@{} numactl --cpunodebind={} --localalloc /usr/local/glex/examples/oo_bw_r {} {} {} 0x100000".format(
        reciver, reciver_numa, reciver_available_vp, sender_nic_id, sender_available_vp
    )
    sender_test_cmd = "/usr/bin/nss_yhpc_ssh root@{} numactl --cpunodebind={} --localalloc /usr/local/glex/examples/oo_bw_s {} {} {} 0x100000".format(
        sender, sender_numa, sender_available_vp, reciver_nic_id, reciver_available_vp
    )

    #print(reciver_test_cmd)
    #print(sender_test_cmd)
    pid = os.fork()
    if pid == 0:
        # os.system(reciver_test_cmd)
        result = subprocess.run(reciver_test_cmd, shell=True, capture_output=True, text=True)
        exit(0)
        # print(result.stdout)
    else:
        time.sleep(1)
        result = subprocess.run(sender_test_cmd, shell=True, capture_output=True, text=True)
        #print(result.stdout)
        lines = result.stdout.split('\n')

        pattern = re.compile(r'\s+')
        #print(type(lines[21:]))
        values = re.split(pattern, lines[21:][0])
        #print(values)
        if len(values) >= 3:
            latency = float(values[1])
            bandwidth = float(values[2])
            # print(latency, bandwidth)
            # os.system(sender_test_cmd)
    
    return latency, bandwidth


def get_oobw_mpi(sender,reciver,reciver_numa,sender_numa,result_queue):
    latency = 0
    bandwidth = 0

    # get inputs
    os.system("rm ./receiver.lock ./result.txt >/dev/null 2>&1")

    #print("sys.arg[0] sender reciver reciver_numa sender_numa")
    #sender = sys.argv[1]
    #reciver = sys.argv[2]
    #reciver_numa = sys.argv[3]
    #sender_numa = sys.argv[4]
    errorlog = open("/tmp/stderr.log", "wb")
    outlog = open("/tmp/out.log", "wb")

    get_nic_id_cmd = "~/auto_oobw-master/get_nic_id"
    out, err = subprocess.Popen(
        "/usr/bin/nss_yhpc_ssh root@{} ".format(sender) + get_nic_id_cmd,
        shell=True,
        stdout=subprocess.PIPE,
        stderr=errorlog,
    ).communicate()
    out = out.decode("ascii")
    sender_nic_id = out.split("\n")[0]
    get_vp_cmd = "cat /proc/glex/nic0/endpoints"

    out, err = subprocess.Popen(
        "/usr/bin/nss_yhpc_ssh root@{} ".format(reciver) + get_nic_id_cmd,
        shell=True,
        stdout=subprocess.PIPE,
        stderr=errorlog,
    ).communicate()

    out = out.decode("ascii")
    reciver_nic_id = out.split("\n")[0]

    out, err = subprocess.Popen(
        "/usr/bin/nss_yhpc_ssh root@{} ".format(sender) + get_vp_cmd,
        shell=True,
        stdout=subprocess.PIPE,
        stderr=errorlog,
    ).communicate()
    sender_available_vp = get_available_vp(out.decode("ascii"))

    out, err = subprocess.Popen(
        "/usr/bin/nss_yhpc_ssh root@{} ".format(reciver) + get_vp_cmd,
        shell=True,
        stdout=subprocess.PIPE,
        stderr=errorlog,
    ).communicate()
    reciver_available_vp = get_available_vp(out.decode("ascii"))

    print("starting reciver")
    #result_file = '{}.to.{}/txt/{}_send_{}_recv_send_numa_{}_recv_numa_{}.txt'.format(sender, reciver, sender, reciver, sender_numa, reciver_numa)
    #if os.access(result_file, os.F_OK):
    #    exit(1)

    reciver_test_cmd = "/usr/bin/nss_yhpc_ssh root@{} numactl --cpunodebind={} --localalloc /usr/local/glex/examples/oo_bw_r {} {} {} 0x100000".format(
        reciver, reciver_numa, reciver_available_vp, sender_nic_id, sender_available_vp
    )
    sender_test_cmd = "/usr/bin/nss_yhpc_ssh root@{} numactl --cpunodebind={} --localalloc /usr/local/glex/examples/oo_bw_s {} {} {} 0x100000".format(
        sender, sender_numa, sender_available_vp, reciver_nic_id, reciver_available_vp
    )

    #print(reciver_test_cmd)
    #print(sender_test_cmd)
    pid = os.fork()
    if pid == 0:
        # os.system(reciver_test_cmd)
        result = subprocess.run(reciver_test_cmd, shell=True, capture_output=True, text=True)
        exit(0)
        # print(result.stdout)
    else:
        time.sleep(1)
        result = subprocess.run(sender_test_cmd, shell=True, capture_output=True, text=True)
        #print(result.stdout)
        try:
            lines = result.stdout.split('\n')

            pattern = re.compile(r'\s+')
            #print(type(lines[21:]))
            values = re.split(pattern, lines[21:][0])
            #print(values)
            if len(values) >= 3:
                latency = float(values[1])
                bandwidth = float(values[2])
                # print(latency, bandwidth)
                # os.system(sender_test_cmd)
        except Exception as e:
            pass
    result = (sender,reciver,reciver_numa,sender_numa,latency, bandwidth)
    result_queue.put(result)
    #return latency, bandwidth


def sam_get_min_oobw_mpi(input_str):
    start_time = time.time()
    ranges = re.findall(r"\d+-\d+|\d+", input_str)

    node_names = []
    for item in ranges:
        if '-' in item:
            start, end = map(int, item.split('-'))
            for i in range(start, end + 1):
                node_names.append(f"cn{i}")
        else:
            node_names.append(f"cn{item}")

    # print(node_names)
    # print(len(node_names))
    random_pairs = random.sample(node_names, k=len(node_names))
    random_pairs = [(random_pairs[i], random_pairs[i + 1]) for i in range(0, len(random_pairs), 2)]

    print(random_pairs)

    # for i in range(0,len(random_pairs)):
    #    print(random_pairs[i][0],random_pairs[i][1])

    numa = [(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7),
            (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7),
            (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7),
            (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7),
            (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7),
            (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7),
            (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7),
            (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7),
            ]

    random_four = random.sample(numa, 5)

    mb = 2000000
    ml = 2000000

    results = []
    processes = []
    result_queue = multiprocessing.Queue()
    for i in range(0, len(random_pairs)):
        process = multiprocessing.Process(target=get_oobw_mpi, args=(
        random_pairs[i][0], random_pairs[i][1], random_four[0][0], random_four[0][1], result_queue))
        process.start()
        processes.append(process)

    for process in processes:
        process.join()

    while not result_queue.empty():
        result = result_queue.get()
        results.append(result)

    for result in results:
        node_name1, node_name2, numa1, numa2, latency, bandwidth = result
        print(node_name1, node_name2, numa1, numa2, latency, bandwidth)
        if bandwidth < mb:
            mb = bandwidth
            ml = latency

    results = []
    processes = []
    result_queue = multiprocessing.Queue()
    for i in range(0, len(random_pairs)):
        process = multiprocessing.Process(target=get_oobw_mpi, args=(
        random_pairs[i][0], random_pairs[i][1], random_four[1][0], random_four[1][1], result_queue))
        process.start()
        processes.append(process)

    for process in processes:
        process.join()

    while not result_queue.empty():
        result = result_queue.get()
        results.append(result)

    for result in results:
        node_name1, node_name2, numa1, numa2, latency, bandwidth = result
        print(node_name1, node_name2, numa1, numa2, latency, bandwidth)
        if bandwidth < mb:
            mb = bandwidth
            ml = latency

    results = []
    processes = []
    result_queue = multiprocessing.Queue()
    for i in range(0, len(random_pairs)):
        process = multiprocessing.Process(target=get_oobw_mpi, args=(
        random_pairs[i][0], random_pairs[i][1], random_four[2][0], random_four[2][1], result_queue))
        process.start()
        processes.append(process)

    for process in processes:
        process.join()

    while not result_queue.empty():
        result = result_queue.get()
        results.append(result)

    for result in results:
        node_name1, node_name2, numa1, numa2, latency, bandwidth = result
        print(node_name1, node_name2, numa1, numa2, latency, bandwidth)
        if bandwidth < mb:
            mb = bandwidth
            ml = latency

    results = []
    processes = []
    result_queue = multiprocessing.Queue()
    for i in range(0, len(random_pairs)):
        process = multiprocessing.Process(target=get_oobw_mpi, args=(
        random_pairs[i][0], random_pairs[i][1], random_four[3][0], random_four[3][1], result_queue))
        process.start()
        processes.append(process)

    for process in processes:
        process.join()

    while not result_queue.empty():
        result = result_queue.get()
        results.append(result)

    for result in results:
        node_name1, node_name2, numa1, numa2, latency, bandwidth = result
        print(node_name1, node_name2, numa1, numa2, latency, bandwidth)
        if bandwidth < mb:
            mb = bandwidth
            ml = latency

    results = []
    processes = []
    result_queue = multiprocessing.Queue()
    for i in range(0, len(random_pairs)):
        process = multiprocessing.Process(target=get_oobw_mpi, args=(
        random_pairs[i][0], random_pairs[i][1], random_four[4][0], random_four[4][1], result_queue))
        process.start()
        processes.append(process)

    for process in processes:
        process.join()

    while not result_queue.empty():
        result = result_queue.get()
        results.append(result)

    for result in results:
        node_name1, node_name2, numa1, numa2, latency, bandwidth = result
        print(node_name1, node_name2, numa1, numa2, latency, bandwidth)
        if bandwidth < mb:
            mb = bandwidth
            ml = latency

    print(ml, mb)
    end_time = time.time()
    # 计算执行时间
    execution_time = end_time - start_time
    print("程序执行时间：", execution_time, "秒")
    return ml, mb

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/439437.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

尚硅谷SpringBoot3笔记

尚硅谷SpringBoot3笔记

推荐课程&#xff1a;03.快速入门-示例Demo_哔哩哔哩_bilibili 目录 01--示例demo 01--示例demo 1、在新建项目创建一个Maven 模块 2、引入 spring-boot-starter-parent 和 spring-boot-starter-web 依赖 spring-boot-starter-parent 是 Spring Boot 提供的一个用于构建 Spr…
阅读更多...
爬虫实战——巴黎圣母院新闻【内附超详细教程，你上你也行】

爬虫实战——巴黎圣母院新闻【内附超详细教程，你上你也行】

文章目录 发现宝藏一、 目标二、简单分析网页1. 寻找所有新闻2. 分析模块、版面和文章 三、爬取新闻1. 爬取模块2. 爬取版面3. 爬取文章 四、完整代码五、效果展示 发现宝藏 前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不…
阅读更多...
四川宏博蓬达法律咨询：专业领航，法治路上的坚实后盾

四川宏博蓬达法律咨询：专业领航，法治路上的坚实后盾

在法治社会中&#xff0c;法律咨询服务扮演着举足轻重的角色。四川宏博蓬达法律咨询&#xff0c;作为业界的佼佼者&#xff0c;以其正规可靠的服务赢得了广大客户的信赖和好评。今天&#xff0c;我们就来一起了解一下这家在法律服务领域备受赞誉的企业。 一、正规资质&#xff…
阅读更多...
数据结构之单链表详解（C语言手撕）

数据结构之单链表详解（C语言手撕）

​ &#x1f389;个人名片&#xff1a;&#x1f43c;作者简介&#xff1a;一名乐于分享在学习道路上收获的大二在校生 &#x1f648;个人主页&#x1f389;&#xff1a;GOTXX &#x1f43c;个人WeChat&#xff1a;ILXOXVJE &#x1f43c;本文由GOTXX原创&#xff0c;首发CSDN…
阅读更多...
Python与Go代码转换库之grumpy使用详解

Python与Go代码转换库之grumpy使用详解

概要 在软件开发领域，Python 和 Go 是两种备受欢迎的编程语言，它们各自拥有独特的优势和特点。Python 以其简洁、易学和强大的生态系统而闻名，而 Go 则以其高效、并发和简洁的语法而受到广泛青睐。然而，在某些情况下，开发人员可能会希望将 Python 代码转换为 Go 代码，以…
阅读更多...
西门子S120故障报警F30003的解决办法总结

西门子S120故障报警F30003的解决办法总结

西门子S120故障报警F30003的解决办法总结 如下图所示&#xff0c;压机在回程时突然出现报警&#xff0c;故障代码为&#xff1a;30003&#xff0c; 如下图所示&#xff0c;查找手册可以看到F30003的报警分析为&#xff1a;直流母线欠压 如下图所示&#xff0c;本来想测量输入端…
阅读更多...
升工作效率，确保公文准确性——爱校对软件的职场革命

升工作效率，确保公文准确性——爱校对软件的职场革命

在当今快节奏的工作环境中&#xff0c;效率和准确性成为了每个职场人士的追求目标。尤其是在处理官方文件和公文材料时&#xff0c;一点小小的错误都可能造成沟通障碍甚至误解&#xff0c;给工作带来不必要的困扰。这时&#xff0c;一款高效、精准、易用的校对软件就显得尤为重…
阅读更多...
Nginx配置http访问转https

Nginx配置http访问转https

场景: 我们通常使用http://www.xxx.com访问自己后台或网站时,浏览器会提示不安全,这就让上层领导看着认为我们做的网站不安全,而通过https访问就没有不会出现这样的问题 配置https前提条件:我们去申请ssl证书, 看自己的域名是在哪个平台购买的 可去 阿里云 或 腾讯云申请免费的…
阅读更多...
rocketmq学习笔记（一）安装部署

rocketmq学习笔记（一）安装部署

初次使用rocketmq&#xff0c;记录一下全流程步骤。 1、下载安装包 首先在官网&#xff0c;下载安装包&#xff0c;可也根据官方文档进行部署&#xff0c;但有一些细节没说明&#xff0c;可能会有坑&#xff0c;本文会尽量详细的描述每个步骤&#xff0c;把我踩过的坑填补上。…
阅读更多...
P5149 会议座位 题解 归并排序 逆序对

P5149 会议座位 题解 归并排序 逆序对

会议座位 传送门 题目背景 话说校长最近很喜欢召开全校教职工大会&#xff0c;让老师们强行听他装逼 题目描述 现在校长在校园网上公布了一份座位表&#xff0c; n n n 位老师从左到右依次排成一行。老师们都对这个座位很满意。 然而到了开会时&#xff0c;校长不小心把座…
阅读更多...
开源的前端思维导图库介绍

开源的前端思维导图库介绍

在开源社区中&#xff0c;有许多优秀的思维导图库可供开发者使用。这些库通常具有丰富的功能和灵活的API&#xff0c;可以满足不同需求的前端开发。以下是一些流行的开源前端思维导图库&#xff0c;以及它们的特点和区别。 1. **MindMap** 特点&#xff1a; - 基于原生…
阅读更多...
c1-第三周

c1-第三周

文章目录 1月份2.定义一个整形数组arr2.定义整形栈s3.输入一个字符串包括大小写和数字&#xff0c;将其中的大写英文字母改为小写&#xff0c;并且输出数字个数4.根据下面数据&#xff0c;编程实现要求功能&#xff1a; 9月1.编写程序实现以下功能或问题3.完成以下功能4.对运算…
阅读更多...
义乌慧鼎思是做什么的？

义乌慧鼎思是做什么的？

根据天眼查的信息&#xff0c;我们可以对其进行一番探究。义乌慧鼎思(义乌市慧鼎思商务信息咨询有限公司)成立于2021年&#xff0c;注册地位于我国浙江省义乌市。从其名称来看&#xff0c;“慧鼎思”寓意着智慧、重量和思考&#xff0c;这三个词汇也许能为我们揭示企业的经营理…
阅读更多...
基于JAVA+ springboot实现的抗疫物质信息管理系统

基于JAVA+ springboot实现的抗疫物质信息管理系统

基于JAVA springboot实现的抗疫物质信息管理系统设计和实现 博主介绍&#xff1a;多年java开发经验&#xff0c;专注Java开发、定制、远程、文档编写指导等,csdn特邀作者、专注于Java技术领域 作者主页 央顺技术团队 Java毕设项目精品实战案例《1000套》 欢迎点赞 收藏 ⭐留言 …
阅读更多...
IR 召回测试数据集（中文测试集）——T2Ranking

IR 召回测试数据集（中文测试集）——T2Ranking

文章排名包括两个阶段&#xff1a;文章检索和文章重排序&#xff0c;这对信息检索&#xff08;IR&#xff09;领域的学术界和业界来说都是重要而具有挑战性的课题。然而&#xff0c;常用的文章排名数据集通常集中在英语语言上。对于非英语场景&#xff0c;如中文&#xff0c;现…
阅读更多...
简单实现微信机器人-接入ChatGPT3.5

简单实现微信机器人-接入ChatGPT3.5

前端基于开源项目&#xff1a;wechaty实现微信网页版功能&#xff0c;感兴趣的小伙伴可以自行研究。 前端代码已开源&#xff1a;https://github.com/labi-xiaoxin/wechat-bot-wechat4u.git 本项目搭建愿景&#xff1a; 1、在无法科学上网的情况下&#xff0c;实现ChatGPT对话…
阅读更多...
unicloud 云数据库概念及创建一个云数据库表并添加记录(数据)

unicloud 云数据库概念及创建一个云数据库表并添加记录(数据)

云数据库概念 uniCloud提供了一个 JSON 格式的文档型数据库。顾名思义&#xff0c;数据库中的每条记录都是一个 JSON 格式的文档。 它是 nosql 非关系型数据库&#xff0c;如果您之前熟悉 sql 关系型数据库&#xff0c;那么两者概念对应关系如下表&#xff1a; 关系型JSON 文…
阅读更多...
基于React的低代码开发：探索应用构建的新模式

基于React的低代码开发：探索应用构建的新模式

&#x1f308;个人主页: Aileen_0v0 &#x1f525;热门专栏: 华为鸿蒙系统学习|计算机网络|数据结构与算法|MySQL| ​&#x1f4ab;个人格言:“没有罗马,那就自己创造罗马~” #mermaid-svg-OywB1Epu30PrvOJQ {font-family:"trebuchet ms",verdana,arial,sans-serif;f…
阅读更多...
华为“仓颉”不是中文编程：中文编程早有所属，势如破竹

华为“仓颉”不是中文编程：中文编程早有所属，势如破竹

“何时能见证中国自主研发的编程语言崛起&#xff1f;”这是我们这些对IT生态心怀关切的人常常深思的问题。 语言&#xff0c;作为文化的灵魂&#xff0c;总是与特定的环境和人群紧密相连。无论是中文还是英语&#xff0c;它们都不仅仅是交流的工具&#xff0c;更是各自文化背…
阅读更多...
SL3038宽电压降压恒压 72V降12V，110V降压12V 开关型降压芯片

SL3038宽电压降压恒压 72V降12V，110V降压12V 开关型降压芯片

SL3038宽电压降压恒压开关型降压芯片是一款高效、稳定的电源管理芯片&#xff0c;广泛应用于各种电子设备中。它能够将高电压降至所需的低电压&#xff0c;并保持输出电压的稳定&#xff0c;从而确保设备的正常运行。本文将详细介绍SL3038的工作原理、特点、应用以及使用注意事…
阅读更多...
最新文章

Copyright @ 2022~2023