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

news2024/10/5 16:30:23

从队列中获取节点名

我们有时候需要从任务队列中取出完整的节点名称，比如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

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

音视频数字化（视频线缆与接口）

音视频数字化（视频线缆与接口）

目录 1、DVI接口 2、DP接口 之前的文章【音视频数字化（线缆与接口）】提到了部分视频线缆，今天再补充几个。 视频模拟信号连接从莲花头的“复合”线开始，经历了S端子、色差分量接口，通过亮度、色度尽量分离的办法提高画面质量，到VGA已经到了模拟的顶峰，实现了RGB的独立…
阅读更多...
面试问答之MySQL数据库进阶

面试问答之MySQL数据库进阶

文章目录 &#x1f412;个人主页&#xff1a;信计2102罗铠威&#x1f3c5;JavaEE系列专栏&#x1f4d6;前言&#xff1a;&#x1f380; MySQL架构&#x1f415;数据库引擎&#x1f415; InnoDB存储存储引擎&#x1f415;MYISAM &#x1f3e8;索引&#x1f415;哪些情况需要创建…
阅读更多...
学习c语言：预处理详解（宏定义）

学习c语言：预处理详解（宏定义）

1.预定义符号 C语⾔设置了⼀些预定义符号&#xff0c;可以直接使⽤&#xff0c;预定义符号也是在预处理期间处理的。 __FILE__ //进⾏编译的源⽂件 __LINE__ //⽂件当前的⾏号 __DATE__ //⽂件被编译的⽇期 __TIME__ //⽂件被编译的时间 __STDC__ //如果编译器遵循ANSI C&…
阅读更多...
Docker镜像及Dockerfile详解

Docker镜像及Dockerfile详解

1 Docker镜像用途 统一应用发布的标准格式支撑一个Docker容器的运行 2 Docker镜像的创建方法 基于已有镜像创建基于本地模板创建基于Dockerfile创建 &#xff08;实际环境中用的最多&#xff09; 2.1 基于已有镜像的创建 将容器里面运行的程序及运行环境打包生成新的镜像 …
阅读更多...
盘点美貌与个性兼备的国漫女神，她们绝不是花瓶！

盘点美貌与个性兼备的国漫女神，她们绝不是花瓶！

在近年来的影视作品里&#xff0c;女性角色不再只是简单的陪衬或是花瓶&#xff0c;她们以各具特色的形象&#xff0c;展现了独立、坚韧和多元的女性力量。而在二次元的世界里&#xff0c;众多女角色同样散发着耀眼的光芒。正值国际妇女节&#xff0c;一起来看看国漫中那些兼具…
阅读更多...
新能源车高压线束更换VR虚拟互动教学保障了培训安全可控

新能源车高压线束更换VR虚拟互动教学保障了培训安全可控

随着新能源汽车市场的快速发展&#xff0c;对于新能源汽车检修人才的需求也日益增长。然而&#xff0c;传统的培训模式往往存在一些限制&#xff0c;如培训周期长、成本高、实践机会少等。为了解决这些问题&#xff0c;新能源车检修VR互动培训应运而生&#xff0c;成为一种创新…
阅读更多...
分享MDN前端结构化技能、实践指南、学习资源

分享MDN前端结构化技能、实践指南、学习资源

前言 MDN课程为成为一名成功的前端开发人员提供了一个结构化的基本技能和实践指南&#xff0c;以及推荐的学习资源。 先看下让人不得不服的书《宝宝的网页设计》&#xff08;套装共3册&#xff09; 宝宝的HTML、宝宝的CSS、宝宝的JavaScript 全球首套中英文宝宝编程启蒙书&a…
阅读更多...
文献学习-14-一种用于高精度微创手术的纤维机器人

文献学习-14-一种用于高精度微创手术的纤维机器人

Authors: Mohamed E. M. K. Abdelaziz1,2 †, Jinshi Zhao1,3 †, Bruno Gil Rosa1,2 , Hyun-Taek Lee4 , Daniel Simon3,5 , Khushi Vyas1,2 , Bing Li6,7 , Hanifa Koguna3 , Yue Li1 , Ali Anil Demircali3 , Huseyin Uvet8 , Gulsum Gencoglan9,10, Arzu Akcay11,12, Moham…
阅读更多...
WinCE USB驱动架构及术语明析

WinCE USB驱动架构及术语明析

一、层式驱动的概念。 WinCE驱动多为层式驱动&#xff0c;分为MDD和PDD两层。 MDD包含通用的驱动代码&#xff0c;向操作系统提供了驱动接口&#xff0c;该层代码调用PDD功能访问硬件。 PDD部分包含与硬件平台相关的特殊代码&#xff0c;不具有通用性。 之所以要分层&#xff0…
阅读更多...
050-WEB攻防-PHP应用文件包含LFIRFI伪协议编码算法无文件利用黑白盒

050-WEB攻防-PHP应用文件包含LFIRFI伪协议编码算法无文件利用黑白盒

050-WEB攻防-PHP应用&文件包含&LFI&RFI&伪协议编码算法&无文件利用&黑白盒 #知识点&#xff1a; 1、文件包含-原理&分类&危害-LFI&RFI 2、文件包含-利用-黑白盒&无文件&伪协议 演示案例&#xff1a; ➢文件包含-原理&分类&am…
阅读更多...
C语言从入门到精通 第十一章（文件操作）

C语言从入门到精通 第十一章（文件操作）

写在前面&#xff1a; 本系列专栏主要介绍C语言的相关知识&#xff0c;思路以下面的参考链接教程为主&#xff0c;大部分笔记也出自该教程。除了参考下面的链接教程以外&#xff0c;笔者还参考了其它的一些C语言教材&#xff0c;笔者认为重要的部分大多都会用粗体标注&#xf…
阅读更多...
C++ Qt开发：QFileSystemModel文件管理组件

C++ Qt开发：QFileSystemModel文件管理组件

Qt 是一个跨平台C图形界面开发库&#xff0c;利用Qt可以快速开发跨平台窗体应用程序&#xff0c;在Qt中我们可以通过拖拽的方式将不同组件放到指定的位置&#xff0c;实现图形化开发极大的方便了开发效率&#xff0c;本章将重点介绍如何运用QFileSystemModel组件实现文件管理器…
阅读更多...
HelpLook 和 confluence：创建知识库我选HelpLook

HelpLook 和 confluence：创建知识库我选HelpLook

企业要想快速创建知识库&#xff0c;最好的方法就是利用好工具。而市面上创建知识库的平台多而繁杂&#xff0c;无法在最快时间内判断哪一个是最适合企业解决问题的。HelpLook和confluence功能相似&#xff0c;多数人无法判断并做出最佳选择&#xff0c;今天就跟着LookLook同学…
阅读更多...
1688商品详情数据丨工厂详情数据丨店铺详情数据

1688商品详情数据丨工厂详情数据丨店铺详情数据

1688商品详情数据、工厂详情数据以及店铺详情数据是商家在阿里巴巴1688平台上进行运营和决策的重要参考。这些数据涵盖了商品的详细信息、工厂的生产能力和信誉情况&#xff0c;以及店铺的经营状况和口碑评价&#xff0c;为商家提供了全方位的市场洞察和竞争优势。 请求示例&a…
阅读更多...
Flutter学习9 - http 中 get/post 请求示例

Flutter学习9 - http 中 get/post 请求示例

1、配置 http pubspec.yaml dependencies:http: ^0.13.4flutter:sdk: flutterhttp 库最新插件版本查看&#xff1a;https://pub.dev/packages/http不一定要用最新版本 http&#xff0c;要使用项目所能支持的版本 .dart import package:http/http.dart as http;2、示例 &a…
阅读更多...
基于UDP实现直播间聊天的功能

基于UDP实现直播间聊天的功能

需求&#xff1a;软件划分为用户客户端和主播服务端两个软件client.c和server.c 用户客户端负责&#xff1a;1.接收用户的昵称2.接收用户输入的信息&#xff0c;能够将信息发送给服务端3.接收服务端回复的数据信息,并完成显示主播服务端负责&#xff1a;1.对所有加入直播间的用…
阅读更多...
基于uniapp cli项目开发的老项目，运行报错path.replace is not a function

基于uniapp cli项目开发的老项目，运行报错path.replace is not a function

项目&#xff1a;基于uniapp cli的微信小程序老项目 问题&#xff1a;git拉取代码&#xff0c;npm安装包时就报错&#xff1b; cnpm能安装成功包&#xff0c;运行报错 三种方法尝试解决&#xff1a; 更改代码&#xff0c;typeof pathstring的话&#xff0c;才走path.replace…
阅读更多...
mysql的语法总结2

mysql的语法总结2

命令&#xff1a; mysql -u 用户名 -p mysql登录 命令&#xff1a;create database u1 创建数据库u1 查询数据库 使用数据库u1 创建表department 查询表department ALTER TABLE 表名 操作类型&#xff1b; 操作类型可以有以下的操作&#xff1a; 添加列&#x…
阅读更多...
【算法 高级数据结构】树状数组：一种高效的数据结构（一）

【算法 高级数据结构】树状数组：一种高效的数据结构（一）

&#x1f680;个人主页&#xff1a;为梦而生~ 关注我一起学习吧&#xff01; &#x1f4a1;专栏&#xff1a;算法题、 基础算法~赶紧来学算法吧 &#x1f4a1;往期推荐&#xff1a; 【算法基础 & 数学】快速幂求逆元&#xff08;逆元、扩展欧几里得定理、小费马定理&#x…
阅读更多...
Baumer工业相机堡盟工业相机如何通过NEOAPI SDK实现双快门采集两张曝光时间非常短的图像（C#）

Baumer工业相机堡盟工业相机如何通过NEOAPI SDK实现双快门采集两张曝光时间非常短的图像（C#）

Baumer工业相机堡盟工业相机如何通过NEOAPI SDK实现双快门采集两张曝光时间非常短的图像&#xff08;C#&#xff09; Baumer工业相机Baumer工业相机定序器功能的技术背景Baumer工业相机通过NEOAPI SDK使用定序器功能预期的相机动作技术限制定序器的工作原理 Baumer工业相机通过…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023