Linux 并发与竞争实验学习

news2024/11/25 18:54:58

Linux 并发与竞争实验学习

原子操作实验

这里原子操作就是采用原子变量来保护一个程序运行的完整过程，使用atomic 来实现一次只能允许一个应用访问 LED，创建atomic.c文件，其实改动内容就是添加原子变量，
要在设备结构体数据添加原子变量，具体代码如下：

struct gpioled_dev
{
    dev_t devid;            /* 设备号 */
    struct cdev cdev;       /* cdev */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    struct device_node *nd; /* 设备节点 */
    int led_gpio;           /* led 所使用的 GPIO 编号 */
    atomic_t lock;          /* 原子变量 */
};

首先是这个函数led_init：
这个函数要先初始化原子变量，以便于首次运行APP检查原子变量不出错。这里是初始化为1.

atomic_set(&gpioled.lock, 1); /* 原子变量初始值为 1 */

然后open函数检查原子变量的值，具体代码如下：

if (!atomic_dec_and_test(&gpioled.lock))
{
    atomic_inc(&gpioled.lock); /* 小于 0 的话就加 1,使其原子变量等于 0 */
    return -EBUSY;             /* LED 被使用，返回忙 */
}

每次打开驱动设备的时候先使用 atomic_dec_and_test 函数将 lock 减 1，如果 atomic_dec_and_test函数返回值为真就表示 lock 当前值为 0，说明设备可以使用。如果 atomic_dec_and_test 函数返回值为假，就表示 lock 当前值为负数(lock 值默认是 1)， lock 值为负数的可能性只有一个，那就是其他设备正在使用 LED。其他设备正在使用 LED 灯，那么就只能退出了，在退出之前调用函数 atomic_inc 将 lock 加 1，因为此时 lock 的值被减成了负数，必须要对其加 1，将 lock 的值变为 0。

static int led_release(struct inode *inode, struct file *filp)
{
    struct gpioled_dev *dev = filp->private_data;
    /* 关闭驱动文件的时候释放原子变量 */
    atomic_inc(&dev->lock);
    return 0;
}

然后还要模拟占用LED25秒，atomicApp.c程序具体如下：

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"

#define LEDOFF 0
#define LEDON 1
int main(int argc, char *argv[])
{
    int fd, retvalue;
    char *filename;
    unsigned char cnt = 0;
    unsigned char databuf[1];
    if (argc != 3)
    {
        printf("Error Usage!\r\n");
        return -1;
    }
    filename = argv[1];
    fd = open(filename, O_RDWR);
    if (fd < 0)
    {
        printf("file %s open failed!\r\n", argv[1]);
        return -1;
    }
    databuf[0] = atoi(argv[2]); /* 要执行的操作：打开或关闭 */
    /* 向/dev/gpioled 文件写入数据 */
    retvalue = write(fd, databuf, sizeof(databuf));
    if (retvalue < 0)
    {
        printf("LED Control Failed!\r\n");
        close(fd);
        return -1;
    }
    while (1)
    {
        sleep(5);
        cnt++;
        printf("App running times:%d\r\n", cnt);
        if (cnt >= 5)
            break;
    }
    printf("App running finished!");
    retvalue = close(fd); /* 关闭文件 */
    if (retvalue < 0)
    {
        printf("file %s close failed!\r\n", argv[1]);
        return -1;
    }
    return 0;
}

测试 APP 在获取到 LED 灯驱动的使用权以后会使用 25S。编译程序，通过网络挂载，测试原子操作。
在这里插入图片描述
出现如图则证明成功。

自旋锁实验

①、自旋锁保护的临界区要尽可能的短，因此在 open 函数中申请自旋锁，然后在 release 函
数中释放自旋锁的方法就不可取。我们可以使用一个变量来表示设备的使用情况，如果设备被
使用了那么变量就加一，设备被释放以后变量就减 1，我们只需要使用自旋锁保护这个变量即
可。
②、考虑驱动的兼容性，合理的选择 API 函数。
具体驱动程序为：

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#define GPIOLED_CNT 1          /* 设备号个数 */
#define GPIOLED_NAME "gpioled" /* 名字 */
#define LEDOFF 0               /* 关灯 */
#define LEDON 1                /* 开灯 */
                               /* gpioled 设备结构体 */
struct gpioled_dev
{
    dev_t devid;            /* 设备号 */
    struct cdev cdev;       /* cdev */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    struct device_node *nd; /* 设备节点 */
    int led_gpio;           /* led 所使用的 GPIO 编号 */
    int dev_stats;          /* 设备状态， 0，设备未使用;>0,设备已经被使用 */
    spinlock_t lock;        /* 自旋锁变量 */
};
struct gpioled_dev gpioled; /* led 设备 */
static int led_open(struct inode *inode, struct file *filp)
{
    unsigned long flags;
    filp->private_data = &gpioled;           /* 设置私有数据 */
    spin_lock_irqsave(&gpioled.lock, flags); /* 上锁 */
    if (gpioled.dev_stats)
    {                                                 /* 如果设备被使用了 */
        spin_unlock_irqrestore(&gpioled.lock, flags); /* 解锁 */
        return -EBUSY;
    }
    gpioled.dev_stats++;                          /* 如果设备没有打开，那么就标记已经打开了 */
    spin_unlock_irqrestore(&gpioled.lock, flags); /*解锁*/
    return 0;
}
/*
 * @description : 从设备读取数据
 * @param – filp : 要打开的设备文件(文件描述符)
 * @param - buf : 返回给用户空间的数据缓冲区
 * @param - cnt : 要读取的数据长度
 * @param – offt : 相对于文件首地址的偏移
 * @return : 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    return 0;
}
/*
73 * @description : 向设备写数据
74 * @param - filp : 设备文件，表示打开的文件描述符
75 * @param - buf : 要写给设备写入的数据
76 * @param - cnt : 要写入的数据长度
77 * @param – offt : 相对于文件首地址的偏移
78 * @return : 写入的字节数，如果为负值，表示写入失败
79 */
static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
    int retvalue;
    unsigned char databuf[1];
    unsigned char ledstat;
    struct gpioled_dev *dev = filp->private_data;
    retvalue = copy_from_user(databuf, buf, cnt);
    if (retvalue < 0)
    {
        printk("kernel write failed!\r\n");
        return -EFAULT;
    }
    ledstat = databuf[0]; /* 获取状态值 */

    if (ledstat == LEDON)
    {
        gpio_set_value(dev->led_gpio, 0); /* 打开 LED 灯 */
    }
    else if (ledstat == LEDOFF)
    {
        gpio_set_value(dev->led_gpio, 1); /* 关闭 LED 灯 */
    }
    return 0;
}
/*
104 * @description : 关闭/释放设备
105 * @param – filp : 要关闭的设备文件(文件描述符)
106 * @return : 0 成功;其他 失败
*/
static int led_release(struct inode *inode, struct file *filp)
{
    unsigned long flags;
    struct gpioled_dev *dev = filp->private_data;
    /* 关闭驱动文件的时候将 dev_stats 减 1 */
    spin_lock_irqsave(&dev->lock, flags); /* 上锁 */
    if (dev->dev_stats)
    {
        dev->dev_stats--;
    }
    spin_unlock_irqrestore(&dev->lock, flags); /* 解锁 */
    return 0;
}
/* 设备操作函数 */
static struct file_operations gpioled_fops = {
    .owner = THIS_MODULE,
    .open = led_open,
    .read = led_read,
    .write = led_write,
    .release = led_release,
};
static int __init led_init(void)
{
    int ret = 0;
    spin_lock_init(&gpioled.lock);
    /* 设置 LED 所使用的 GPIO */
    /* 1、获取设备节点： gpioled */
    gpioled.nd = of_find_node_by_path("/gpioled");
    if (gpioled.nd == NULL)
    {
        printk("gpioled node cant not found!\r\n");
        return -EINVAL;
    }
    else
    {
        printk("gpioled node has been found!\r\n");
    }

    /* 2、 获取设备树中的 gpio 属性，得到 LED 所使用的 LED 编号 */
    gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);
    if (gpioled.led_gpio < 0)
    {
        printk("can't get led-gpio");
        return -EINVAL;
    }
    printk("led-gpio num = %d\r\n", gpioled.led_gpio);
    ret = gpio_direction_output(gpioled.led_gpio, 1);
    if (ret < 0)
    {
        printk("can't set gpio!\r\n");
    }
    /*1、创建设备号*/
    if (gpioled.major)
    {
        gpioled.devid = MKDEV(gpioled.major, 0);
        register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);
    }
    else
    {
        alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME);
        gpioled.major = MAJOR(gpioled.devid);
        gpioled.minor = MINOR(gpioled.devid);
    }
    printk("newcheled major: %d minor: %d", gpioled.major, gpioled.minor);
    gpioled.cdev.owner = THIS_MODULE;
    cdev_init(&gpioled.cdev, &gpioled_fops);
    cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);
    gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);
    if (IS_ERR(gpioled.class))
    {
        return PTR_ERR(gpioled.class);
    }
    gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME);
    if (IS_ERR(gpioled.device))
    {
        return PTR_ERR(gpioled.device);
    }
    return 0;
}
static void __exit led_exit(void)
{

    /* 注销字符设备驱动 */

    cdev_del(&gpioled.cdev); /* 删除 cdev */
    unregister_chrdev_region(gpioled.devid, GPIOLED_CNT);

    device_destroy(gpioled.class, gpioled.devid);
    class_destroy(gpioled.class);
}
module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("wyw");

测试App和上面的保持一致即可。

信号量实验：

#include <linux/semaphore.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#define GPIOLED_CNT 1          /* 设备号个数 */
#define GPIOLED_NAME "gpioled" /* 名字 */
#define LEDOFF 0               /* 关灯 */
#define LEDON 1                /* 开灯 */
                               /* gpioled 设备结构体 */
struct gpioled_dev
{
    dev_t devid;            /* 设备号 */
    struct cdev cdev;       /* cdev */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    struct device_node *nd; /* 设备节点 */
    int led_gpio;           /* led 所使用的 GPIO 编号 */
    struct semaphore sem;   /* 信号量 */
};
struct gpioled_dev gpioled; /* led 设备 */
static int led_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &gpioled; /* 设置私有数据 */
                                   /* 获取信号量,进入休眠状态的进程可以被信号打断 */
    if (down_interruptible(&gpioled.sem))
    {
        return -ERESTARTSYS;
    }
#if 0
 down(&gpioled.sem); /* 不能被信号打断 */
#endif
    return 0;
}
/*
 * @description : 从设备读取数据
 * @param – filp : 要打开的设备文件(文件描述符)
 * @param - buf : 返回给用户空间的数据缓冲区
 * @param - cnt : 要读取的数据长度
 * @param – offt : 相对于文件首地址的偏移
 * @return : 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    return 0;
}
/*
73 * @description : 向设备写数据
74 * @param - filp : 设备文件，表示打开的文件描述符
75 * @param - buf : 要写给设备写入的数据
76 * @param - cnt : 要写入的数据长度
77 * @param – offt : 相对于文件首地址的偏移
78 * @return : 写入的字节数，如果为负值，表示写入失败
79 */
static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
    int retvalue;
    unsigned char databuf[1];
    unsigned char ledstat;
    struct gpioled_dev *dev = filp->private_data;
    retvalue = copy_from_user(databuf, buf, cnt);
    if (retvalue < 0)
    {
        printk("kernel write failed!\r\n");
        return -EFAULT;
    }
    ledstat = databuf[0]; /* 获取状态值 */

    if (ledstat == LEDON)
    {
        gpio_set_value(dev->led_gpio, 0); /* 打开 LED 灯 */
    }
    else if (ledstat == LEDOFF)
    {
        gpio_set_value(dev->led_gpio, 1); /* 关闭 LED 灯 */
    }
    return 0;
}
/*
104 * @description : 关闭/释放设备
105 * @param – filp : 要关闭的设备文件(文件描述符)
106 * @return : 0 成功;其他 失败
*/
static int led_release(struct inode *inode, struct file *filp)
{
    struct gpioled_dev *dev = filp->private_data;
    /* 关闭驱动文件的时候释放原子变量 */
    up(&dev->sem); /* 释放信号量，信号量值加 1 */
    return 0;
}
/* 设备操作函数 */
static struct file_operations gpioled_fops = {
    .owner = THIS_MODULE,
    .open = led_open,
    .read = led_read,
    .write = led_write,
    .release = led_release,
};
static int __init led_init(void)
{
    int ret = 0;
    sema_init(&gpioled.sem, 1);
    /* 设置 LED 所使用的 GPIO */
    /* 1、获取设备节点： gpioled */
    gpioled.nd = of_find_node_by_path("/gpioled");
    if (gpioled.nd == NULL)
    {
        printk("gpioled node cant not found!\r\n");
        return -EINVAL;
    }
    else
    {
        printk("gpioled node has been found!\r\n");
    }

    /* 2、 获取设备树中的 gpio 属性，得到 LED 所使用的 LED 编号 */
    gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);
    if (gpioled.led_gpio < 0)
    {
        printk("can't get led-gpio");
        return -EINVAL;
    }
    printk("led-gpio num = %d\r\n", gpioled.led_gpio);
    ret = gpio_direction_output(gpioled.led_gpio, 1);
    if (ret < 0)
    {
        printk("can't set gpio!\r\n");
    }
    /*1、创建设备号*/
    if (gpioled.major)
    {
        gpioled.devid = MKDEV(gpioled.major, 0);
        register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);
    }
    else
    {
        alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME);
        gpioled.major = MAJOR(gpioled.devid);
        gpioled.minor = MINOR(gpioled.devid);
    }
    printk("newcheled major: %d minor: %d", gpioled.major, gpioled.minor);
    gpioled.cdev.owner = THIS_MODULE;
    cdev_init(&gpioled.cdev, &gpioled_fops);
    cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);
    gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);
    if (IS_ERR(gpioled.class))
    {
        return PTR_ERR(gpioled.class);
    }
    gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME);
    if (IS_ERR(gpioled.device))
    {
        return PTR_ERR(gpioled.device);
    }
    return 0;
}
static void __exit led_exit(void)
{

    /* 注销字符设备驱动 */

    cdev_del(&gpioled.cdev); /* 删除 cdev */
    unregister_chrdev_region(gpioled.devid, GPIOLED_CNT);

    device_destroy(gpioled.class, gpioled.devid);
    class_destroy(gpioled.class);
}
module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("wyw");

具体代码如上所示。open函数中申请信号量，可以使用down函数，也可以使用down_interruptible函数。如果信号量值大于等于 1 就表示可用，那么应用程序就会开始使用 LED 灯。如果信号量值为 0 就表示应用程序不能使用 LED 灯，此时应用程序就会进入到休眠状态。等到信号量值大于 1 的时候应用程序就会唤醒，申请信号量，获取 LED 灯使用权实验现象如下：
在这里插入图片描述

互斥体实验

互斥实验类似，将信号量对应的部分换为互斥体的部分即可，具体代码如下：

55 static int led_open(struct inode *inode, struct file *filp)
56 {
57 filp->private_data = &gpioled; /* 设置私有数据 */
58
59 /* 获取互斥体,可以被信号打断 */
60 if (mutex_lock_interruptible(&gpioled.lock)) {
61 return -ERESTARTSYS;
62 }
63 #if 0
64 mutex_lock(&gpioled.lock); /* 不能被信号打断 */
65 #endif
66	return 0；
67	}

119 static int led_release(struct inode *inode, struct file *filp)
120 {
121 struct gpioled_dev *dev = filp->private_data;
122
123 /* 释放互斥锁 */
124 mutex_unlock(&dev->lock);
125
126 return 0;
127 }
143 static int __init led_init(void)
144 {
145 int ret = 0;
146
147 /* 初始化互斥体 */
148 mutex_init(&gpioled.lock);
......
205 return 0;
206 }

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

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

相关文章

MEMS：Lecture 19 Wafer bonding package

MEMS：Lecture 19 Wafer bonding package

讲义 Current MEMS Packages Die Level (芯片级) 封装 图片描述&#xff1a;左侧的图显示了Cronos继电器的芯片级封装。这种封装方式是在晶圆切割后&#xff0c;将独立的MEMS芯片组装到单独的陶瓷封装中。特点&#xff1a; Die level release and ceramic package&#xff1a…
阅读更多...
数据库管理-第204期 数据库的IO掉速，也许是SSD的锅（20240615）

数据库管理-第204期 数据库的IO掉速，也许是SSD的锅（20240615）

数据库管理204期 2024-06-15 数据库管理-第204期 数据库的IO掉速&#xff0c;也许是SSD的锅&#xff08;20240615&#xff09;1 SSD物理结构2 SSD颗粒类型3 DRAM & SLC Cache3.1 DRAM3.2 SLC Cache3.3 其他方式 4 缓外降速总结 数据库管理-第204期 数据库的IO掉速&#xff…
阅读更多...
C++ Windows下Glog日志库安装使用教程

C++ Windows下Glog日志库安装使用教程

🙋 介绍：glog是google推出的一款轻量级c++开源日志框架。  环境配置：windows+VS2015+gflags 2.2.2+glog-0.3.5。为避免新版本（glog V0.7.1）踏坑，建议装低版本，这里我选用的是V0.3.5。 1. 下载 在gflags官方中下载gflags代码，官方地址 在Glog官方中下载，githut地址：…
阅读更多...
探索开源世界：2024年值得关注的热门开源项目推荐

探索开源世界：2024年值得关注的热门开源项目推荐

文章目录 每日一句正能量前言GitCode成立背景如何使用GitCode如何把你现有的项目迁移至 GitCode&#xff1f;热门开源项目推荐actions-poetry - 管理 Python 依赖项的 GitLab CI/CD 工具项目概述技术分析应用场景特点项目地址 Spider - 网络爬虫框架项目简介技术分析应用场景项…
阅读更多...
【Mac】Luminar Neo for mac（图像编辑软件）软件介绍及同类型软件比较

【Mac】Luminar Neo for mac（图像编辑软件）软件介绍及同类型软件比较

Luminar Neo软件介绍 Luminar Neo 是一款由 Skylum 开发的功能强大的照片编辑软件&#xff0c;专为摄影师和摄影爱好者设计。它适用于 Mac 和 Windows 平台&#xff0c;提供了一系列先进的编辑工具和功能&#xff0c;使用户能够轻松提升和优化他们的照片。以下是 Luminar Neo …
阅读更多...
C#开发-集合使用和技巧（四）集合中常用的查询方法

C#开发-集合使用和技巧（四）集合中常用的查询方法

集合中常用的查询方法 测试数据准备&#xff1a;查询方法详解**Where**条件查询定义和注释&#xff1a;功能详细说明&#xff1a;应用实例查找所有设备类型为“生产设备”的对象 结果测试&#xff1a;查询所有测试结果大于90的设备多条件查询&#xff1a;类型为生产设备同时测试…
阅读更多...
2023年的Top20 AI应用在近一年表现怎么样？

2023年的Top20 AI应用在近一年表现怎么样？

AI应用现在进入寒武纪大爆发时代&#xff0c;百花争艳。如果倒回到2023年初&#xff0c;那时候排名靠前的AI应用在一年多时间&#xff0c;发生了哪些变化&#xff1f;能带给我们什么启示&#xff1f; 在2023年1月&#xff0c;排名靠前20的AI应用是&#xff1a; DeepL&#xff…
阅读更多...
datax图形化界面datax-web安装及使用

datax图形化界面datax-web安装及使用

环境准备&#xff1a;需要先安装git和maven git安装可参考git的安装-CSDN博客 maven只需解压安装包&#xff0c;配置环境变量即可使用 1 源代码下载 直接从Git上面获得datax-web源代码 git clone https://gitee.com/WeiYe-Jing/datax-web.git 2 打包项目 进入项目源码根…
阅读更多...
Spring底层架构核心概念解析

Spring底层架构核心概念解析

BeanDefinition BeanDefinition表示Bean定义,BeanDefinition中存在很多属性用来描述一个Bean的特点.比如: beanClass:表示Bean类型scope:表示Bean作用域,单例/原型等lazyInit:表示Bean是否懒加载initMethodName:表示Bean初始化时要执行的方法destoryMethodName:表示Bean销毁时…
阅读更多...
用于每个平台的最佳WordPress LMS主题

用于每个平台的最佳WordPress LMS主题

你已选择在 WordPress 上构建学习管理系统 (LMS)了。恭喜&#xff01; 你甚至可能已经选择了要使用的 LMS 插件&#xff0c;这已经是成功的一半了。 现在是时候弄清楚哪个 WordPress LMS 主题要与你的插件配对。 我将解释 LMS 主题和插件之间的区别&#xff0c;以便你了解要…
阅读更多...
Unity中实现ScrollRect 滚动定位到视口内

Unity中实现ScrollRect 滚动定位到视口内

Demo链接: https://download.csdn.net/download/qq_41973169/89439428https://download.csdn.net/download/qq_41973169/89439428 一、前言 Unity版本:2020.1.x 如果需要资源请联系我我会分享给你 因为本人也要存储一下Demo所以上传到这里了但是又不能设置不需要积分 在Un…
阅读更多...
车载网络安全指南 软件层面开发阶段（八）

车载网络安全指南 软件层面开发阶段（八）

返回总目录->返回总目录<- 目录 前言 一、软件层面产品开发启动 二、确定网络安全需求 三、软件架构设计 四、软件层面漏洞分析 五、软件单元设计和实现 六、软件实现的分析与评估 七、软件单元测试 八、软件集成和测试 九、网络安全验证 十、细化网络安全评估…
阅读更多...
发布自己的c#包到nuget

发布自己的c#包到nuget

1)创建自己的nuget账号 NuGet Gallery | Home 2)在Rider中-->项目邮件-->properties 注意&#xff1a;必须勾选生成nuget包 3)编译后&#xff0c;将生成一个包 4)点击上传包 5)将之前的nuget包拖拽过来&#xff0c;点击上传即可&#xff0c;如果有不对的比如&#xf…
阅读更多...
C++ 43 之 自增运算符的重载

C++ 43 之 自增运算符的重载

#include <iostream> #include <string> using namespace std;class MyInt{friend ostream& operator<< (ostream& cout , MyInt& int1); public:MyInt(){this->m_num 0;}// 前置自增&#xff1a; 成员函数实现运算符的重载 返回的是 引用&a…
阅读更多...
Android 蓝牙配对Settings应用里面的简要流程记录

Android 蓝牙配对Settings应用里面的简要流程记录

Android 蓝牙配对Settings应用里面的简要流程记录 文章目录 Android 蓝牙配对Settings应用里面的简要流程记录一、前言二、Settings蓝牙配对的关键代码1、接收蓝牙请求的地方 AndroidManifest.xml2、BluetoothPairingRequest3、BluetoothPairingService4、BluetoothPairingDial…
阅读更多...
石头、剪子、布小游戏图形化

石头、剪子、布小游戏图形化

石头、剪子、布小游戏图形化 也是之前编写了一个石头、剪子、布的小游戏&#xff0c;总感觉界面不够友好&#xff0c;AI时代到来&#xff0c;一切都无所不能&#xff0c;而且编程效率大大提高了。所以用AI大模型进行程序代码重构&#xff0c;再稍加修改&#xff0c;效果还不错…
阅读更多...
LLM proj - 审稿大模型

LLM proj - 审稿大模型

常用数据处理 主要是四种方式&#xff1a;正则表达式、AC自动机、困惑度过滤低质文本、最小哈希算法实现文本去重 1. 正则表达式&#xff0c;去做一些模式匹配 ex&#xff1a; # 论文的评审内容有时会存在大量列举reference&#xff08;参考文献&#xff09;的情况 # 这些r…
阅读更多...
KKT基础知识

KKT基础知识

KKT条件定义 KKT条件(Karush–Kuhn–Tucker conditions)是最优化&#xff08;特别是非线性规划&#xff09;领域最重要的成果之一&#xff0c;是判断某点是极值点的必要条件。 最优化问题 要选择一组参数&#xff08;变量&#xff09;&#xff0c;在满足一定的限制条件&…
阅读更多...
Unity动态添加聊天文本

Unity动态添加聊天文本

1.创建一个滚动视图 2.调整滚动视图的位置并删掉这个 3.创建一个输入框和一个按钮 这里插一句一定要给content添加这个组件并设置单元格大小 4创建一个脚本并编写下面代码 using System.Collections; using System.Collections.Generic; using TMPro; using Unity.VisualScrip…
阅读更多...
⭐Unity 控制任意UI的渐隐渐显

⭐Unity 控制任意UI的渐隐渐显

使用脚本之前先给要控制的UI加上CanvasGroup组件 解释: 这个脚本使用协程来逐渐改变CanvasGroup的alpha值&#xff0c;从而实现渐隐和渐显的效果。 Mathf.Lerp函数用于在指定的时间内平滑地从当前透明度过渡到目标透明度。 通过调用FadeIn和FadeOut方法&#xff0c;你可以在任…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023