【Linux:线程池】

news2025/1/19 7:53:37

文章目录

  • 1 线程池概念
  • 2 第一个版本的线程池
  • 3 第二个版本的线程池
  • 4 第三个版本的线程池
  • 5 STL中的容器以及智能指针的线程安全问题
  • 6 其他常见的各种锁
  • 7 读者写者问题(了解)

1 线程池概念

一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。

线程池的应用场景：

  • 1️⃣需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。 但对于长时间的任务，比如一个Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。
  • 2️⃣对性能要求苛刻的应用，比如要求服务器迅速响应客户请求。
  • 3️⃣接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池情况下，将产生大量线程，虽然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限，出现错误。

线程池示例：

    1. 创建固定数量线程池，循环从任务队列中获取任务对象，
    1. 获取到任务对象后，执行任务对象中的任务接口。

2 第一个版本的线程池

在创建线程池之前我们想想线程池的成员变量应该有哪些？首先我们需要一个容器来存放线程，所以不妨使用vector；还要使用一个整形变量来记录线程池中线程的个数；为了保证线程安全问题我们还得需要一把锁，同时为了维护同步关系我们还得需要一个条件变量(这里的同步关系是指当没有任务时线程库中的线程就休眠，当有任务时就执行任务)；另外我们还得需要一个任务队列。这里我们再封装一个任务类让等会儿验证时效果更加明显。

Task.hpp:

#pragma once
#include <iostream>
using namespace std;

class Task
{
public:
    Task(int x=0, int y=0, char op='+')
        : _x(x), _y(y), _op(op)
    {
    }
    void run()
    {
        switch (_op)
        {
        case '+':
            _res = _x + _y;
            break;
        case '-':
            _res = _x - _y;
            break;
        case '*':
            _res = _x * _y;
            break;
        case '/': 
            if(_y==0)
            {
                _exitCode=1;
                return;
            }
            _res = _x / _y;
            break;
            case '%':
            _res = _x % _y;
            break;
        }
    }

    void formatMsk()
    {
        cout<<"mask:"<<_x<<_op<<_y<<"==?"<<endl;
    }

    void formatRes()
    {
        cout<<"res:"<<_x<<_op<<_y<<"=="<<_res<<endl;
    }

private:
    int _x;
    int _y;
    char _op;
    int _res = 0;
    int _exitCode = 0;
};

现在我们来实现第一个版本：

#pragma once 
#include<iostream>
#include<vector>
#include<queue>
using namespace std;

const int N=5;
template<class T>
class threadPool
{
public:
    threadPool(int sz=N)
    :_sz(sz)
    ,_threads(sz)
    {
        pthread_mutex_init(&_mutex,nullptr);
        pthread_cond_init(&_cond,nullptr);
    }


    static void* Routine(void* args)//用内存池的多线程执行任务
    {
        pthread_detach(pthread_self());//先让自己与主线程分离
        threadPool<T> *ptp=static_cast<threadPool<T> *>(args);

        while(true)
        {
            pthread_mutex_lock(&(ptp->_mutex));

            while((ptp->_masks).empty())
            {
                pthread_cond_wait(&(ptp->_cond),&(ptp->_mutex));
            }

            T task=(ptp->_masks).front();
            (ptp->_masks).pop();
            pthread_mutex_unlock(&(ptp->_mutex));

            task.run();//在临界区外执行任务
            task.formatRes();
        }

        return nullptr;
    }

    void Start()
    {
        for(int i=0;i<_sz;++i)
        {
            pthread_create(&_threads[i],nullptr,Routine,this);
        }
    }

    void PushTask(const T& task)
    {
        pthread_mutex_lock(&_mutex);
        _masks.push(task);
        pthread_mutex_unlock(&_mutex);
        pthread_cond_signal(&_cond);//记得唤醒休眠的线程去执行任务
    }

    ~threadPool()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond);
    }

    vector<pthread_t> _threads;
    queue<T> _masks;
    int _sz;//线程池中线程的个数
    pthread_mutex_t _mutex;
    pthread_cond_t _cond;
};

这里面有几个特别需要注意的点：
在这里插入图片描述

  1. Routine我们实现的是static版本的，因为创建线程所要求的函数指针与类内成员函数不吻合，类内成员函数有this指针。
  2. 创建了线程后让该线程与主线程分离，也就是主线程不管新线程的资源回收了。
  3. 执行任务时要在临界区外执行，这样并发执行的效率才会更加高效。
  4. 为了方便使用将类中成员变量都搞成了公有，建议不要这样搞，可以自己写一个get。

至于其他的方面都很简单，相信大家能够很容易理解。
测试程序：

const char *ops = "+-*/%";

int main()
{
    threadPool<Task> *threads = new threadPool<Task>(30);
    threads->Start();
    srand((size_t)time(nullptr));
    while (true)
    {
        int x = rand() % 30 + 1;
        int y = rand() % 30 + 1;
        char op = ops[rand() % strlen(ops)];

        Task t(x, y, op);
        threads->PushTask(t);
        t.formatMsk();
        sleep(1);
    }

    return 0;
}

我们来运行下结果：
在这里插入图片描述

3 第二个版本的线程池

其实第二个版本的线程池与第一个的核心思路基本一致，主要是第二个版本使用的是我们自己模拟实现的创建线程的类，比如我们之前自己模拟实现(本质是封装了库中的线程库接口)的一份Thread.hpp:

#pragma once
#include <iostream>
#include <functional>
using namespace std;

class threadProcess
{
public:
    enum stu
    {
        NEW,
        RUNNING,
        EXIT
    };

    template<class T>
    threadProcess(int num, T exe, void *args)
        : _tid(0)
        , _status(NEW)
        ,_exe(exe)
        , _args(args)
    {
        char name[26];
        snprintf(name, 26, "thread%d", num);
        _name = name;
    }

    static void* runHelper(void *args)
    {
        threadProcess *ts = (threadProcess *)args; 
        
        (*ts)();
        return nullptr;
    }

    void operator()() // 仿函数
    {
        if (_exe != nullptr)
            _exe(_args);
    }

    void Run()
    {
        int n = pthread_create(&_tid, nullptr, runHelper, this);
        if (n != 0)
            exit(-1);
        _status = RUNNING;
    }

    void Join()
    {
        int n = pthread_join(_tid, nullptr);
        if (n != 0)
            exit(-1);
        _status = EXIT;
    }


    string _name;
    pthread_t _tid;
    stu _status;
    function<void*(void*)> _exe;
    void *_args;
};

这样我们自己就能够用自己的线程库来完成了：

#pragma once 
#include"Thread.hpp"
#include<iostream>
#include<vector>
#include<queue>
using namespace std;

const int N=5;
template<class T>
class threadPool
{
public:
    threadPool(int sz=N)
        :_sz(sz)
    {
        pthread_mutex_init(&_mutex,nullptr);
        pthread_cond_init(&_cond,nullptr);
    }


    static void* Routine(void* args)//用内存池的多线程执行任务
    {
        //pthread_detach(pthread_self());调用自己写的线程接口不用在分离了，析构时在join掉就好了
        threadPool<T> *ptp=static_cast<threadPool<T> *>(args);

        while(true)
        {
            pthread_mutex_lock(&(ptp->_mutex));

            while((ptp->_masks).empty())
            {
                pthread_cond_wait(&(ptp->_cond),&(ptp->_mutex));
            }

            T task=(ptp->_masks).front();
            (ptp->_masks).pop();
            pthread_mutex_unlock(&(ptp->_mutex));

            task.run();//在临界区外执行任务
            task.formatRes();

        }

        return nullptr;

    }

    void Init()
    {
        for(int i=0;i<_sz;++i)
        {
           _threads.push_back(threadProcess(i+1,Routine,this));
        }
    }

    void Start()
    {
        for(auto& e:_threads)
        {
            e.Run();
        }
    }

    void PushTask(const T& task)
    {
        
        pthread_mutex_lock(&_mutex);
        _masks.push(task);
        pthread_mutex_unlock(&_mutex);
        pthread_cond_signal(&_cond);//记得唤醒休眠的线程去执行任务
    }

    ~threadPool()
    {
        for(auto& e:_threads)
        {
            e.Join();
        }
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond);
    }

    void Check()
    {
        for(auto& e:_threads)
        {
            cout<<"name:"<<e._name<<" id"<<e._tid<<endl;
        }
    }

    vector<threadProcess> _threads;
    queue<T> _masks;
    int _sz;//线程池中线程的个数
    pthread_mutex_t _mutex;
    pthread_cond_t _cond;
};

测试代码：

int main()
{
    threadPool<Task> *threads = new threadPool<Task>(8);
    threads->Init();
    threads->Start();
    srand((size_t)time(nullptr));
    while (true)
    {
        int x = rand() % 30 + 1;
        int y = rand() % 30 + 1;
        char op = ops[rand() % strlen(ops)];

        Task t(x, y, op);
        threads->PushTask(t);
        t.formatMsk();
        sleep(1);
    }
    return 0;
}

运行结果：
在这里插入图片描述

4 第三个版本的线程池

这个版本的线程池在前面版本的基础上加了一个单例模式。因为我们发现其实线程池只需要一个就可以了，我们使用懒汉模式来创建单例。

代码实现：

#pragma once
#include "Thread.hpp"
#include <iostream>
#include <vector>
#include <queue>
using namespace std;

const int N = 5;
template <class T>
class threadPool
{
public:

    static threadPool<T>* GetInstance(int sz=N)
    {
        if(_sta_obj==nullptr)
        {
            pthread_mutex_lock(&_mutex);
            if(_sta_obj==nullptr)
            {
                _sta_obj=new threadPool<T>(sz);
            }
            pthread_mutex_unlock(&_mutex);
        }
    }

    static void *Routine(void *args) // 用内存池的多线程执行任务
    {
        // pthread_detach(pthread_self());调用自己写的线程接口不用在分离了，析构时在join掉就好了
        threadPool<T> *ptp = static_cast<threadPool<T> *>(args);

        while (true)
        {
            pthread_mutex_lock(&(ptp->_mutex));

            while ((ptp->_masks).empty())
            {
                pthread_cond_wait(&(ptp->_cond), &(ptp->_mutex));
            }

            T task = (ptp->_masks).front();
            (ptp->_masks).pop();
            pthread_mutex_unlock(&(ptp->_mutex));

            task.run(); // 在临界区外执行任务
            task.formatRes();
        }

        return nullptr;
    }

    void Init()
    {
        for (int i = 0; i < _sz; ++i)
        {
            _threads.push_back(threadProcess(i + 1, Routine, this));
        }
    }

    void Start()
    {
        for (auto &e : _threads)
        {
            e.Run();
        }
    }

    void PushTask(const T &task)
    {

        pthread_mutex_lock(&_mutex);
        _masks.push(task);
        pthread_mutex_unlock(&_mutex);
        pthread_cond_signal(&_cond); // 记得唤醒休眠的线程去执行任务
    }

    ~threadPool()
    {
        for (auto &e : _threads)
        {
            e.Join();
        }
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond);
    }

    void Check()
    {
        for (auto &e : _threads)
        {
            cout << "name:" << e._name << " id" << e._tid << endl;
        }
    }

    vector<threadProcess> _threads;
    queue<T> _masks;
    int _sz; // 线程池中线程的个数
    pthread_mutex_t _mutex;
    pthread_cond_t _cond;

private:
    threadPool(int sz = N)
        : _sz(sz)
    {
        pthread_mutex_init(&_mutex, nullptr);
        pthread_cond_init(&_cond, nullptr);
    }

    threadPool(const threadPool<T>& th)=delete;
    threadPool<T>& operator=(const threadPool<T>& th)=delete;

    static threadPool<T>* _sta_obj;
};
template<class T>
threadPool<T>* threadPool<T>::_sta_obj=nullptr;

其中注意点：
在这里插入图片描述
在加锁时为了高效我们是用了双重if条件判断。

在这里插入图片描述
注意将构造函数搞成了私有，拷贝构造和拷贝赋值都删掉了。

5 STL中的容器以及智能指针的线程安全问题

STL中的容器是否是线程安全的?

不是。原因是, STL 的设计初衷是将性能挖掘到极致, 而一旦涉及到加锁保证线程安全, 会对性能造成巨大的影响.而且对于不同的容器, 加锁方式的不同, 性能可能也不同(例如hash表的锁表和锁桶).因此 STL 默认不是线程安全. 如果需要在多线程环境下使用, 往往需要调用者自行保证线程安全。

智能指针是否是线程安全的?

对于 unique_ptr, 由于只是在当前代码块范围内生效, 因此不涉及线程安全问题。
对于 shared_ptr, 多个对象需要共用一个引用计数变量, 所以会存在线程安全问题. 但是标准库实现的时候考虑到了这个问题, 基于原子操作(CAS)的方式保证 shared_ptr 能够高效, 原子的操作引用计数。

6 其他常见的各种锁

  • 悲观锁：在每次取数据时，总是担心数据会被其他线程修改，所以会在取数据前先加锁（读锁，写锁，行锁等），当其他线程想要访问数据时，被阻塞挂起。
  • 乐观锁：每次取数据时候，总是乐观的认为数据不会被其他线程修改，因此不上锁。但是在更新数据前，会判断其他数据在更新前有没有对数据进行修改。主要采用两种方式：版本号机制和CAS操作。CAS操作：当需要更新数据时，判断当前内存值和之前取得的值是否相等。如果相等则用新值更新。若不等则失败，失败则重试，一般是一个自旋的过程，即不断重试。
  • 自旋锁，公平锁，非公平锁。

7 读者写者问题(了解)

读写锁:
在编写多线程的时候，有一种情况是十分常见的。那就是，有些公共数据修改的机会比较少。相比较改写，它们读的机会反而高的多。通常而言，在读的过程中，往往伴随着查找的操作，中间耗时很长。给这种代码段加锁，会极大地降低我们程序的效率。那么有没有一种方法，可以专门处理这种多读少写的情况呢？ 有，那就是读写锁。

读写锁的行为：

当前锁的状态读锁请求写锁请求
无锁可以可以
读锁可以阻塞
写锁阻塞阻塞
  • 注意：写独占，读共享，读锁优先级高

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

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

相关文章

16-2_Qt 5.9 C++开发指南_使用样式表Qss自定义界面

16-2_Qt 5.9 C++开发指南_使用样式表Qss自定义界面

进行本篇介绍学习前&#xff0c;请先参考链接01_1_Qt工程实践_Qt样式表Qss&#xff0c;后再结合本篇进行融合学习如何使用样式表定义界面。 文章目录 1. Qt样式表2. Qt样式表句法2.1 一般句法格式2.2 选择器 (selector)2.3 子控件&#xff08;sub-controls&#xff09;2.4 伪状…
阅读更多...
neo4j的CQL命令实例演示

neo4j的CQL命令实例演示

天行健&#xff0c;君子以自强不息&#xff1b;地势坤&#xff0c;君子以厚德载物。 每个人都有惰性&#xff0c;但不断学习是好好生活的根本&#xff0c;共勉&#xff01; 文章均为学习整理笔记&#xff0c;分享记录为主&#xff0c;如有错误请指正&#xff0c;共同学习进步。…
阅读更多...
vim学习笔记(致敬vim作者)

vim学习笔记(致敬vim作者)

vim cheat sheet 30. vim 删除大法 vim 删除某个字符之后改行的其他的字符&#xff1f;删除某行之后的其他行&#xff1f;删除某个字符之后的其他字符&#xff1f;【1】删除单个字符&#xff1f; 跳到要删除的字符位置 按下d键然后按下shift 4键 【2】删除某行之后的其他行…
阅读更多...
List list=new ArrayList()抛出的ArrayIndexOutOfBoundsException异常

List list=new ArrayList()抛出的ArrayIndexOutOfBoundsException异常

1.应用场景&#xff0c;今天生产日志监控到一下ArrayList 进行add 异常&#xff0c;具体日志如下&#xff1a; eptionHandler.handler(178): TXXYBUSSINESS|执行异常 java.util.concurrent.CompletionException: java.lang.ArrayIndexOutOfBoundsException: Index 1 out of bo…
阅读更多...
激活函数总结（一）：ReLU及其变体

激活函数总结（一）：ReLU及其变体

激活函数介绍&#xff08;一&#xff09; 1 引言2 常用激活函数介绍2.1 Sigmoid激活函数2.2 Tanh激活函数2.3 ReLU激活函数2.4 Leaky ReLU激活函数2.5 Parametric ReLU&#xff08;PReLU&#xff09;激活函数2.6 Swish激活函数 3. 总结 介绍的激活函数都在目录中有所展示&#…
阅读更多...
VLE基于预训练文本和图像编码器的图像-文本多模态理解模型：支持视觉问答、图文匹配、图片分类、常识推理等

VLE基于预训练文本和图像编码器的图像-文本多模态理解模型：支持视觉问答、图文匹配、图片分类、常识推理等

项目设计集合&#xff08;人工智能方向&#xff09;&#xff1a;助力新人快速实战掌握技能、自主完成项目设计升级&#xff0c;提升自身的硬实力&#xff08;不仅限NLP、知识图谱、计算机视觉等领域&#xff09;&#xff1a;汇总有意义的项目设计集合&#xff0c;助力新人快速实…
阅读更多...
DROP USER c##xyt CASCADE ＞ ORA-01940: 无法删除当前连接的用户

DROP USER c##xyt CASCADE ＞ ORA-01940: 无法删除当前连接的用户

多创建了一个用户&#xff0c;想要给它删除掉 一 上执行过程&#xff0c;确实删除成功了 Oracle Database 12c Enterprise Edition Release 12.1.0.2.0 - 64bit Production With the Partitioning, OLAP, Advanced Analytics and Real Application Testing optionsSQL> DR…
阅读更多...
用excel格式书写的接口用例执行脚本

用excel格式书写的接口用例执行脚本

创建测试用例和测试结果集文件夹&#xff1a; excel编写的接口测试用例如下&#xff1a; 1 encoding 响应的编码格式。所测项目大部分是utf-8&#xff0c;有一个特殊项目是utf-8-sig 2 params 对应requests的params 3 data&#xff0c;对应requests的data 有些参数是动态的&a…
阅读更多...
C#，数值计算——查找等价类（Find equivalence classes）的计算方法及其源程序

C#，数值计算——查找等价类（Find equivalence classes）的计算方法及其源程序

1 等价类的定义 2 Examples 3 Partitions 4 C#源代码 using System; namespace Legalsoft.Truffer { /// <summary> /// Find equivalence classes /// </summary> public class EClass { public EClass() { } pub…
阅读更多...
有没有好用的在线画图工具推荐？

有没有好用的在线画图工具推荐？

绘画是设计师最常见的工作之一&#xff0c;设计师对在线绘画工具的要求越来越高&#xff0c;市场上也出现了各种在线绘画工具&#xff0c;让设计师不知道如何选择高质量的在线绘画工具&#xff0c;一个好的在线绘画工具不仅可以让你轻松绘画&#xff0c;而且可以让你的工作效率…
阅读更多...
android studio内存分析之Memory profiler的使用

android studio内存分析之Memory profiler的使用

目录 Android Studio中内存分析工具Memory profiler的使用1. 打开Memory Profiler2. 工具使用3. 内存选项说明4. 内存性能分析器概览5. 内存计算方式6. 查看内存分配7. 捕获java/kotlin方式查看内存分配8. 堆转储文件导入和导出 内存性能分析器中的泄漏检测 Android Studio中内…
阅读更多...
带你了解—使用Ubuntu系统，公网环境下SSH远程树莓派

带你了解—使用Ubuntu系统，公网环境下SSH远程树莓派

公网环境下Ubuntu系统SSH远程树莓派 文章目录 公网环境下Ubuntu系统SSH远程树莓派前言 1. 安装cpolar客户端2. 安装完成后输入指令3. ubuntu系统输入命令 前言 树莓派作为低功耗、小型化的硬件设备&#xff0c;其功能和运算能力并未过度缩水&#xff0c;在不少场景中&#xff…
阅读更多...
UEditorPlus v3.3.0 图片上传压缩重构，UI优化，升级基础组件

UEditorPlus v3.3.0 图片上传压缩重构，UI优化，升级基础组件

UEditor是由百度开发的所见即所得的开源富文本编辑器&#xff0c;基于MIT开源协议&#xff0c;该富文本编辑器帮助不少网站开发者解决富文本编辑器的难点。 UEditorPlus 是有 ModStart 团队基于 UEditor 二次开发的富文本编辑器&#xff0c;主要做了样式的定制&#xff0c;更符…
阅读更多...
基于spring boot的餐饮管理系统java酒店饭店菜谱 jsp源代码mysql

基于spring boot的餐饮管理系统java酒店饭店菜谱 jsp源代码mysql

本项目为前几天收费帮学妹做的一个项目&#xff0c;Java EE JSP项目&#xff0c;在工作环境中基本使用不到&#xff0c;但是很多学校把这个当作编程入门的项目来做&#xff0c;故分享出本项目供初学者参考。 一、项目描述 基于spring boot的餐饮管理系统j 系统1权限&#xff…
阅读更多...
Python实现GA遗传算法优化LightGBM分类模型(LGBMClassifier算法)项目实战

Python实现GA遗传算法优化LightGBM分类模型(LGBMClassifier算法)项目实战

说明&#xff1a;这是一个机器学习实战项目&#xff08;附带数据代码文档视频讲解&#xff09;&#xff0c;如需数据代码文档视频讲解可以直接到文章最后获取。 1.项目背景 遗传算法&#xff08;Genetic Algorithm&#xff0c;GA&#xff09;最早是由美国的 John holland于20世…
阅读更多...
利用Jmeter做接口测试全流程分析

利用Jmeter做接口测试全流程分析

利用Jmeter做接口测试怎么做呢&#xff1f;过程真的是超级简单。 明白了原理以后&#xff0c;把零碎的知识点填充进去就可以了。这篇文章就来介绍一下如何利用Jmeter做接口测试的流程&#xff0c;主要针对的是功能测试。暂不涉及到自动化测试和性能测试的内容。 一把来说&…
阅读更多...
AIGC：【LLM（五）】——Faiss：高效的大规模相似度检索库

AIGC：【LLM（五）】——Faiss：高效的大规模相似度检索库

文章目录 一.简介1.1 什么是Faiss1.2 Faiss的安装 二.Faiss检索流程2.1 构建向量库2.2 构建索引2.3 top-k检索 三.Faiss构建索引的多种方式3.1 Flat &#xff1a;暴力检索3.2 IVFx Flat &#xff1a;倒排暴力检索3.3 IVFxPQy 倒排乘积量化3.4 LSH 局部敏感哈希3.5 HNSWx 一.简介…
阅读更多...
企业工程项目管理系统源码（三控：进度组织、质量安全、预算资金成本、二平台：招采、设计管理）em

企业工程项目管理系统源码（三控：进度组织、质量安全、预算资金成本、二平台：招采、设计管理）em

​ 工程项目管理软件&#xff08;工程项目管理系统&#xff09;对建设工程项目管理组织建设、项目策划决策、规划设计、施工建设到竣工交付、总结评估、运维运营&#xff0c;全过程、全方位的对项目进行综合管理 工程项目各模块及其功能点清单 一、系统管理 1、数据字典&#…
阅读更多...
【Megatron-DeepSpeed】张量并行工具代码mpu详解(三)：张量并行层的实现及测试

【Megatron-DeepSpeed】张量并行工具代码mpu详解(三)：张量并行层的实现及测试

相关博客 【Megatron-DeepSpeed】张量并行工具代码mpu详解(三)&#xff1a;张量并行层的实现及测试 【Megatron-DeepSpeed】张量并行工具代码mpu详解(一)&#xff1a;并行环境初始化 【Megatron-DeepSpeed】张量并行工具代码mpu详解(二)&#xff1a;Collective通信操作的封装ma…
阅读更多...
【FIFO IP系列】FIFO IP参数配置与使用示例

【FIFO IP系列】FIFO IP参数配置与使用示例

Vivado IP核提供了强大的FIFO生成器&#xff0c;可以通过图形化配置快速生成FIFO IP核。 本文将详细介绍如何在Vivado中配置一个FIFO IP核,以及如何调用这个FIFO IP核。 一、FIFO IP核的配置 1、新建FIFO IP 在Vivado的IP Catalog中找到FIFO Generator IP核&#xff0c;双击…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023