gem5 RubyPort： mem_request_port作用与连接 simple-MI_example.py

简介

回答这个问题：RubyPort的口下，一共定义了六个口，分别是mem_request_port，mem_response_port，pio_request_port，pio_response_port，in_ports, interrupt_out_ports，他们分别有什么用，应该怎么接

overview是下面这个图。
在这里插入图片描述

以一个简单的l1 cache为例子

https://www.gem5.org/documentation/learning_gem5/part3/simple-MI_example/

首先是l1cache对子函数的连接

class L1Cache(L1Cache_Controller):
	。。。
	def connectQueues(self, ruby_system):
		。。。
		self.mandatoryQueue = MessageBuffer()
        self.requestFromCache = MessageBuffer(ordered = True)
        self.requestFromCache.master = ruby_system.network.slave
        self.responseFromCache = MessageBuffer(ordered = True)
        self.responseFromCache.master = ruby_system.network.slave
        self.forwardToCache = MessageBuffer(ordered = True)
        self.forwardToCache.slave = ruby_system.network.master
        self.responseToCache = MessageBuffer(ordered = True)
        self.responseToCache.slave = ruby_system.network.master

然后是system对子函数的连接操作

step 1对一个RubySystem延伸的类，他的controller是python自己定义的。
step 2 这里它简化了一下，只有一个dir controller,也就是只有一个memory ctrl,但是 l1cache还是每个cpu都有一个的。
step3 创建了self.controller之后，并没有互联！ 这个rubysystem调用了自己的子类的子函数连接了网络和controllers。
step4 显式的连接cpu 与ruby system的 sequencer。

#step 1
class MyCacheSystem(RubySystem):
	#step 2 
	self.controllers = [L1Cache(system, self, cpu) for cpu in cpus] + [ DirController(self, system.mem_ranges, mem_ctrls) ]
	#step 3
	self.network.connectControllers(self.controllers)
	#step 4
	# Connect the cpu's cache, interrupt, and TLB ports to Ruby
        for i,cpu in enumerate(cpus):
            cpu.icache_port = self.sequencers[i].slave
            cpu.dcache_port = self.sequencers[i].slave
            isa = buildEnv['TARGET_ISA']
            if isa == 'x86':
                cpu.interrupts[0].pio = self.sequencers[i].master
                cpu.interrupts[0].int_master = self.sequencers[i].slave
                cpu.interrupts[0].int_slave = self.sequencers[i].master
            if isa == 'x86' or isa == 'arm':
                cpu.itb.walker.port = self.sequencers[i].slave
                cpu.dtb.walker.port = self.sequencers[i].slave

然后我们看看每一步怎么连接的细节：

step3 network.connectControllers(self.controllers)

先看看前置的一些条件

这里的self.controllers 创建了64个L1缓存控制器，每个控制器对应一个CPU，加上一个目录控制器。因此，controllers 列表总共包含65个控制器。
这里有一个不是很常规的情况：每个router连接了一个controller,也就是有65个router。正常应该是64个router对应64个cpu的，这里为了简便，直接每个controller分配一个router。同时，router间的互连也简化为crossbar,每个router连接了剩下所有的64个 router

 # Create one router/switch per controller in the system
        self.routers = [Switch(router_id = i) for i in range(len(controllers))]
        #outer间的互连也简化为crossbar,每个router连接了剩下所有的router，例如64个router
        for ri in self.routers:
            for rj in self.routers:
                if ri == rj: continue # Don't connect a router to itself!
                link_count += 1
                self.int_links.append(SimpleIntLink(link_id = link_count,
                                                    src_node = ri,
                                                    dst_node = rj))

这些前置条件过后，看怎么连接controller和router的：

def connectControllers(self, controllers):
        """Connect all of the controllers to routers and connect the routers
           together in a point-to-point network.
        """
        # Create one router/switch per controller in the system
        self.routers = [Switch(router_id = i) for i in range(len(controllers))]

        # Make a link from each controller to the router. The link goes
        # externally to the network.
        self.ext_links = [SimpleExtLink(link_id=i, ext_node=c,
                                        int_node=self.routers[i])
                          for i, c in enumerate(controllers)]

        # Make an "internal" link (internal to the network) between every pair
        # of routers.
        link_count = 0
        self.int_links = []
        for ri in self.routers:
            for rj in self.routers:
                if ri == rj: continue # Don't connect a router to itself!
                link_count += 1
                self.int_links.append(SimpleIntLink(link_id = link_count,
                                                    src_node = ri,
                                                    dst_node = rj))

把这些代码画成图如下：

                +----------------+
                |     CPU 0      |
                | icache_port    |
                | dcache_port    |
                +----------------+
                        |
                        v
                +----------------+
                | RubySequencer  |
                +----------------+
                        |
                        v
                 +---------------+
                 |   L1 Cache   |			 |   L1 Cache.sub   |	
		         |viaSimpleExtLin|          |responseFromCache.master|   |forwardToCache.slave|                |responseToCache.slave|

                 +---------------+         	  +---------------+          +---------------+                           +---------------+  
                        | 							 |                          |                                            |
                        v  							 v                          v                                            v
                +----------------+          +----------------+  
        |rubysystem.network.Router 0|       |rubysystem.network.slave|   |rubysystem.network.slave|           |ruby_system.network.master       |                            
                +----------------+		    +----------------+
 

                ... (多个类似的组件重复上述连接关系) ...

                +----------------+
                |     CPU 63     |
                | icache_port    |
                | dcache_port    |
                +----------------+
                        |
                        v
                +----------------+
                | RubySequencer  |
                +----------------+
                        |
                        v
                 +---------------+
                 |   L1 Cache   |
                 +---------------+
                        |
                        v
                +----------------+
                |   Router 63    |
                +----------------+
 			
				第65个router比较特殊，在这个简化的实例里没有连接l1而是连接了dircontroller.
				同时每个router之间都是连接的。
                +----------------+
                |   Router 64    |
                +----------------+
                 ^            |
                 |            v
                +----------------+
                |   DirController|
                +----------------+

代码和图联合 分析

按照https://www.gem5.org/documentation/learning_gem5/part3/simple-MI_example/ 的顺序，

连接l1 cache与router

rubysystem 创建了一堆controller，随后创建了sequencer但是还没连，然后调用network。connectController连接了controlle和router,

 # Create the network and connect the controllers.
        # NOTE: This is quite different if using Garnet!
        self.network.connectControllers(self.controllers)
        self.network.setup_buffers()

也就是在这里插入图片描述 l1cache和network.router通过simpleextlink相连的。

连接cpu 与sequencer

随后，rybysystem 显式的连接了之前创建的sequence和 cpu的interrupt 和itb.walker.port.

 # Connect the cpu's cache, interrupt, and TLB ports to Ruby
        for i,cpu in enumerate(cpus):
            cpu.icache_port = self.sequencers[i].slave
            cpu.dcache_port = self.sequencers[i].slave
            isa = buildEnv['TARGET_ISA']
            if isa == 'x86':
                cpu.interrupts[0].pio = self.sequencers[i].master
                cpu.interrupts[0].int_master = self.sequencers[i].slave
                cpu.interrupts[0].int_slave = self.sequencers[i].master
            if isa == 'x86' or isa == 'arm':
                cpu.itb.walker.port = self.sequencers[i].slave
                cpu.dtb.walker.port = self.sequencers[i].slave

图里也就是连接这一部分：
在这里插入图片描述

连接l1cache 和rubysystem.networ

这里是隐藏在l1初始化的时候，创建l1cache需要初始化，（对这个python文件）初始化的时候l1cache就传递进来了rubysystem这个对象。

self.connectQueues(ruby_system)

然后l1cache连接了rubyssytem的master和slaveport.现在叫out_port 和in_port 。

 def connectQueues(self, ruby_system):
        """Connect all of the queues for this controller.
        """
        self.mandatoryQueue = MessageBuffer()
        self.requestFromCache = MessageBuffer(ordered = True)
        self.requestFromCache.master = ruby_system.network.slave
        self.responseFromCache = MessageBuffer(ordered = True)
        self.responseFromCache.master = ruby_system.network.slave
        self.forwardToCache = MessageBuffer(ordered = True)
        self.forwardToCache.slave = ruby_system.network.master
        self.responseToCache = MessageBuffer(ordered = True)
        self.responseToCache.slave = ruby_system.network.master
        #小插曲： master和slave的说法已经被弃用了 by src/mem/ruby/network/Network.py
	        #in_port = VectorResponsePort("CPU input port")
	   		#slave = DeprecatedParam(in_port, "`slave` is now called `in_port`")
	    	#out_port = VectorRequestPort("CPU output port")
	    	#master = DeprecatedParam(out_port, "`master` is now called `out_port`")

图里是这一部分，描述的l1的cache的子成员直接和network相连。
在这里插入图片描述

关键问题：这些port结构连上了，但是属于哪些类型的rubyport？

rubyport。hh里有六种类型，这些结构上相连的port各自属于哪些类型？ 我们一个个搜索从结构上看过来

RubySequencer

代码用的self.sequencers[i].master/slave,其中 self.sequencers = [RubySequencer(version = i,。。。
RubySequencer 从哪里来的呢？
在src/mem/ruby/system/Sequencer.py找到了 RubySequencer的定义：

class RubySequencer(RubyPort):
    type = "RubySequencer"
    cxx_class = "gem5::ruby::Sequencer"
    cxx_header = "mem/ruby/system/Sequencer.hh"

RubySequencer 不是Sequencer： python与c++的关系。

细看会发现，我们用的是 RubySequencer 不是Sequencer ，RubySequencer是python的class,他的type是cpp里的"gem5::ruby::Sequencer"。还告诉我们用的头文件是 “mem/ruby/system/Sequencer.hh”。

cpp Sequencer.hh 没有

先看src/mem/ruby/system/Sequencer.hh 中，

class Sequencer : public RubyPort

所以Sequencer 其实是继承自RubyPort的。而RubyPort继承自clockedobject.
这俩都没有.slave 子成员。 那我们的python代码调用的slave来自于哪里？

RubyPort的python定义

对rubyport最关键的代码出现了：src/mem/ruby/system/Sequencer.py
没错，竟然没有一个单独的python文件 RubyPort.py 而是在 Sequencer.py里。
step1 这个代码把c++和python联系起来了。
step2 这个代码创建了新的python里的名字

  1. in_port同时也是弃用的slave
  2. interrupt_out_port同时也是弃用的master
  3. pio_request_port同时也是弃用的 pio_master_port
  4. mem_request_port 同时也是弃用的mem_master_port
  5. pio_response_port 同时也是弃用的pio_slave_port
class RubyPort(ClockedObject):
    type = "RubyPort"
    abstract = True
    cxx_header = "mem/ruby/system/RubyPort.hh"
    cxx_class = "gem5::ruby::RubyPort"

    version = Param.Int(0, "")
    in_ports = VectorResponsePort(
        "CPU side of this RubyPort/Sequencer. "
        "The CPU request ports should be connected to this. If a CPU "
        "has multiple ports (e.g., I/D ports) all of the ports for a "
        "single CPU can connect to one RubyPort."
    )
    slave = DeprecatedParam(in_ports, "`slave` is now called `in_ports`")

    interrupt_out_port = VectorRequestPort(
        "Port to connect to x86 interrupt "
        "controller to send the CPU requests from outside."
    )
    master = DeprecatedParam(
        interrupt_out_port, "`master` is now called `interrupt_out_port`"
    )

    pio_request_port = RequestPort("Ruby pio request port")
    pio_master_port = DeprecatedParam(
        pio_request_port, "`pio_master_port` is now called `pio_request_port`"
    )

    mem_request_port = RequestPort("Ruby mem request port")
    mem_master_port = DeprecatedParam(
        mem_request_port, "`mem_master_port` is now called `mem_request_port`"
    )

    pio_response_port = ResponsePort("Ruby pio response port")
    pio_slave_port = DeprecatedParam(
        pio_response_port, "`pio_slave_port` is now called `pio_response_port`"
    )

这些python的port和 c++port的定义

是python提供字符串描述，然后调用python通过名字找port的函数，然后cpp响应这个函数，返回对应的cpp对象。由此，python定义的port和c++的port联系起来。
下面是细节，分别是根据名字字符串 找port 的函数， c++对port名字的回应， 和这些port的对应关系。

根据名字字符串 找port 的函数

在src/python/m5/params.py中

class RequestPort(Port):
    # RequestPort("description")
    def __init__(self, desc):
        super().__init__("GEM5 REQUESTOR", desc, is_source=True)

c++对port名字的回应

Port &
RubyPort::getPort(const std::string &if_name, PortID idx)
{
    if (if_name == "mem_request_port") {
        return memRequestPort;
    } else if (if_name == "pio_request_port") {
        return pioRequestPort;
    } else if (if_name == "mem_response_port") {
        return memResponsePort;
    } else if (if_name == "pio_response_port") {
        return pioResponsePort;
    } else if (if_name == "interrupt_out_port") {
        // used by the x86 CPUs to connect the interrupt PIO and interrupt
        // response port
        if (idx >= static_cast<PortID>(request_ports.size())) {
            panic("%s: unknown %s index (%d)\n", __func__, if_name, idx);
        }

        return *request_ports[idx];
    } else if (if_name == "in_ports") {
        // used by the CPUs to connect the caches to the interconnect, and
        // for the x86 case also the interrupt request port
        if (idx >= static_cast<PortID>(response_ports.size())) {
            panic("%s: unknown %s index (%d)\n", __func__, if_name, idx);
        }

        return *response_ports[idx];
    }

    // pass it along to our super class
    return ClockedObject::getPort(if_name, idx);
}

python port和 cpp port的对应关系：根据name返回

mem_request_port 和 memRequestPort

python 文件中，mem_request_port 是来自于 RequestPort(“Ruby mem request port”)
mem_request_port = RequestPort(“Ruby mem request port”)
查找返回的是 if (if_name == “mem_request_port”) { return memRequestPort;

pio_request_port和 pioRequestPort

python 文件中， pio_request_port = RequestPort(“Ruby pio request port”)
查找的cpp返回的是 else if (if_name == “pio_request_port”) { return pioRequestPort;

pio_response_port 和 pioResponsePort

python 文件中 pio_response_port = ResponsePort(“Ruby pio response port”)
查找的cpp返回的是 else if (if_name == “pio_response_port”) { return pioResponsePort;

interrupt_out_port 和*request_ports[idx]

python 文件中 pio_response_port = ResponsePort(“Ruby pio response port”)
查找的cpp返回的是 else if (if_name == “interrupt_out_port”) { // used by the x86 CPUs to connect the interrupt PIO and interrupt // response port if (idx >= static_cast(request_ports.size())) { panic(“%s: unknown %s index (%d)\n”, func, if_name, idx); }

in_ports 和 *response_ports[idx]

python 文件中 in_ports = VectorResponsePort( "CPU side of this RubyPort/Sequencer. " “The CPU request ports should be connected to this. If a CPU " “has multiple ports (e.g., I/D ports) all of the ports for a " “single CPU can connect to one RubyPort.” )
查找的cpp返回的是 else if (if_name == “in_ports”) { // used by the CPUs to connect the caches to the interconnect, and // for the x86 case also the interrupt request port if (idx >= static_cast(response_ports.size())) { panic(”%s: unknown %s index (%d)\n”, func, if_name, idx); } return *response_ports[idx];

这些python port（同时也代表c++port） 怎么连接的

核心是这些连接是由python文件定义，我们还是以 simple-MI_example.py为例子：

cpu和sequencer

# Connect the cpu's cache, interrupt, and TLB ports to Ruby
        for i,cpu in enumerate(cpus):
            cpu.icache_port = self.sequencers[i].slave
            cpu.dcache_port = self.sequencers[i].slave
            isa = buildEnv['TARGET_ISA']
            if isa == 'x86':
                cpu.interrupts[0].pio = self.sequencers[i].master
                cpu.interrupts[0].int_master = self.sequencers[i].slave
                cpu.interrupts[0].int_slave = self.sequencers[i].master
            if isa == 'x86' or isa == 'arm':
                cpu.itb.walker.port = self.sequencers[i].slave
                cpu.dtb.walker.port = self.sequencers[i].slave

cpu 与sequencer 的连接图

画成图就是
在这里插入图片描述

network 和 l1 dir

l1 连接l1的port和network

def connectQueues(self, ruby_system):
        """Connect all of the queues for this controller.
        """
        self.mandatoryQueue = MessageBuffer()
        self.requestFromCache = MessageBuffer(ordered = True)
        self.requestFromCache.master = ruby_system.network.slave
        self.responseFromCache = MessageBuffer(ordered = True)
        self.responseFromCache.master = ruby_system.network.slave
        self.forwardToCache = MessageBuffer(ordered = True)
        self.forwardToCache.slave = ruby_system.network.master
        self.responseToCache = MessageBuffer(ordered = True)
        self.responseToCache.slave = ruby_system.network.master

DirController 里，连接dir 的port和network

def connectQueues(self, ruby_system):
        self.requestToDir = MessageBuffer(ordered = True)
        self.requestToDir.slave = ruby_system.network.master
        self.dmaRequestToDir = MessageBuffer(ordered = True)
        self.dmaRequestToDir.slave = ruby_system.network.master

        self.responseFromDir = MessageBuffer()
        self.responseFromDir.master = ruby_system.network.slave
        self.dmaResponseFromDir = MessageBuffer(ordered = True)
        self.dmaResponseFromDir.master = ruby_system.network.slave
        self.forwardFromDir = MessageBuffer()
        self.forwardFromDir.master = ruby_system.network.slave
        self.responseFromMemory = MessageBuffer()
## network 里，连接router和 l1以及dir
```python
        self.ext_links = [SimpleExtLink(link_id=i, ext_node=c,
                                        int_node=self.routers[i])
                          for i, c in enumerate(controllers)]

network 里连接network.router 和conrollers

# Make a link from each controller to the router. The link goes
        # externally to the network.
        self.ext_links = [SimpleExtLink(link_id=i, ext_node=c,
                                        int_node=self.routers[i])
                          for i, c in enumerate(controllers)]

network with routers 与l1， dir 的连接图

画成图就是
在这里插入图片描述
#小结
再把sequencer中的cacher和l1相连起来就全部串起来了
最后的总结图：
在这里插入图片描述

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

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

相关文章

YOLOv8改进 | 主干篇 | 利用MobileNetV2替换Backbone（轻量化网络结构）

YOLOv8改进 | 主干篇 | 利用MobileNetV2替换Backbone（轻量化网络结构）

一、本文介绍 本文给大家带来的改进机制是MobileNetV2&#xff0c;其是专为移动和嵌入式视觉应用设计的轻量化网络结构。其在MobilNetV1的基础上采用反转残差结构和线性瓶颈层。这种结构通过轻量级的深度卷积和线性卷积过滤特征&#xff0c;同时去除狭窄层中的非线性&#xff…
阅读更多...
Circulation:室性早搏会增加不良心血管事件|UK Biobank周报（12.14）

Circulation:室性早搏会增加不良心血管事件|UK Biobank周报（12.14）

欢迎报名2023年郑老师团队课程&#xff01; 郑老师科研统计培训&#xff0c;包括临床数据、公共数据分析课程等&#xff0c;欢迎报名 英国生物银行&#xff08;UK Biobank&#xff0c;UKB&#xff09;是英国迄今以来规模最大的有关致病或预防疾病的基因和环境因子的信息资源库。…
阅读更多...
【案例】图片预览

【案例】图片预览

效果图 如何让图片放大&#xff0c;大多数的UI组件都带有这种功能&#xff0c;今天给大家介绍的这个插件除了放大之外&#xff0c;还可以旋转、移动、翻转、旋转、二次放大&#xff08;全屏&#xff09; 实现 npm i v-viewer -Smain.js 中引入 import viewerjs/dist/viewer.c…
阅读更多...
java并发编程六 共享模型之内存

java并发编程六 共享模型之内存

文章目录 Java 内存模型可见性解决方法 有序性解决方法 Java 内存模型 JMM 即 Java Memory Model&#xff0c;它定义了主存、工作内存抽象概念&#xff0c;底层对应着 CPU 寄存器、缓存、硬件内存、CPU 指令优化等。 JMM 体现在以下几个方面 原子性 - 保证指令不会受到线程上…
阅读更多...
前端ICON库

前端ICON库

前端ICON库 1.mingcute mingcute 2.lordicon lordicon 3.字节iconpark&#xff08;推荐&#xff09; 字节iconpark 4.iconbuddy iconbuddy.app/ 5.商标寻找youicons 免费下载数百万个徽标以获得设计灵感 | YouIcons.com 还有一堆工具
阅读更多...
黑盒测试中的完整性测试：确保系统的功能完整性

黑盒测试中的完整性测试：确保系统的功能完整性

在软件开发过程中&#xff0c;为了保证系统的质量和可靠性&#xff0c;测试是一个不可或缺的环节。而黑盒测试作为常用的测试方法之一&#xff0c;以用户的角度出发&#xff0c;测试系统在不知道内部工作原理的情况下&#xff0c;对输入数据的处理和输出结果的正确性进行验证。…
阅读更多...
如何直接使用别人的Python项目的虚拟环境

如何直接使用别人的Python项目的虚拟环境

Cannot set up a python SDK at Python 3.10 (flaskTest) (2) (H:\WorkPlace\PyWorkPlace\flaskTest\flaskTest\venv\Scripts\python.exe). The SDK seems invalid 如何复制别人的虚拟环境 修改步骤 1. 修改pyvenv.cfg文件里的home和version 2. Scripts\activate以及Scripts\a…
阅读更多...
助力工业产品质检，基于YOLOv8开发构建智能PCB电路板质检分析系统

助力工业产品质检，基于YOLOv8开发构建智能PCB电路板质检分析系统

AI助力工业质检智能生产制造已经有很多成功的实践应用了&#xff0c;在我们前面的系列博文中也有很多对应的实践&#xff0c;感兴趣的话可以自行移步阅读前面的博文即可&#xff1a; 《助力质量生产&#xff0c;基于目标检测模型MobileNetV2-YOLOv3-Lite实现PCB电路板缺陷检测…
阅读更多...
【算法】算法题-20231221

【算法】算法题-20231221

这里写目录标题 一、830. 较大分组的位置二、657. 机器人能否返回原点三、771. 宝石与石头 一、830. 较大分组的位置 在一个由小写字母构成的字符串 s 中&#xff0c;包含由一些连续的相同字符所构成的分组。 例如&#xff0c;在字符串 s "abbxxxxzyy"中&#xff0…
阅读更多...
九、W5100S/W5500+RP2040之MicroPython开发＜HTTPOneNET示例＞

九、W5100S/W5500+RP2040之MicroPython开发＜HTTPOneNET示例＞

文章目录 1. 前言2. 平台操作流程2.1 创建设备2.2 创建数据流模板 3. WIZnet以太网芯片4. 示例讲解以及使用4.1 程序流程图4.2 测试准备4.3 连接方式4.4 相关代码4.5 烧录验证 5. 注意事项6. 相关链接 1. 前言 在这个智能硬件和物联网时代&#xff0c;MicroPython和树莓派PICO正…
阅读更多...
依托亚马逊云科技构建韧性应用

依托亚马逊云科技构建韧性应用

背景 现代业务系统受到越来越多的韧性相关的挑战&#xff0c;特别是客户要求他们的业务系统 724 不间断的运行。因此&#xff0c;韧性对于云的基础设施和应用系统有着至关重要的作用。 亚马逊云科技把韧性视为一项最基本的工作&#xff0c;为了让我们的业务系统能持续优雅地提供…
阅读更多...
LLM之RAG实战（七）| 使用llama_index实现多模态RAG

LLM之RAG实战（七）| 使用llama_index实现多模态RAG

一、多模态RAG OpenAI开发日上最令人兴奋的发布之一是GPT-4V API&#xff08;https://platform.openai.com/docs/guides/vision&#xff09;的发布。GPT-4V是一个多模态模型&#xff0c;可以接收文本/图像&#xff0c;并可以输出文本响应。最近还有一些其他的多模态模型&#x…
阅读更多...
【大数据存储与处理】实验二 HBase 过滤器操作

【大数据存储与处理】实验二 HBase 过滤器操作

实验二 HBase 过滤器操作 【实验目的】&#xff1a; 1.掌握使用 HBase 过滤器进行全表扫描。 【实验内容与要求】&#xff1a; 在 HBase 中&#xff0c;Get 和 Scan 操作都可以使用过滤器来设置输出的范围&#xff0c;类似于 SQL 里面 的 Where 查询条件。使用 show_filte…
阅读更多...
中国自动驾驶行业：迈向无限可能

中国自动驾驶行业：迈向无限可能

中国自动驾驶行业正在经历蓬勃发展&#xff0c;取得了令人瞩目的成果。这一行业在技术创新、政策支持和市场需求等方面展现出巨大潜力。本文将从技术创新、产业生态和前景发展等角度&#xff0c;探讨中国自动驾驶行业的现状和未来前景。 中国自动驾驶行业正处于一个令人瞩目的快…
阅读更多...
Codeforces Round 638 (Div. 2)B. Phoenix and Beauty(思维构造)

Codeforces Round 638 (Div. 2)B. Phoenix and Beauty(思维构造)

B. Phoenix and Beauty 这道题目学到的东西&#xff1a; 从给出的数据范围观察&#xff0c;得到一些有用信息&#xff08;峰哥教的&#xff09;考虑无解的情况‘ 其实这题考虑怎么操作是比较难的&#xff0c;如果能想出来满足条件的结果就比较好了&#xff08;我在说什么我自…
阅读更多...
ASP.NET Core基础之定时任务(二)-Quartz.NET入门

ASP.NET Core基础之定时任务(二)-Quartz.NET入门

阅读本文你的收获 了解任务调度框架QuartZ.NET的核心构成学会在ASP.NET Core 中使用QuartZ.NET 在项目的开发过程中&#xff0c;难免会遇见需要后台处理的任务&#xff0c;例如定时发送邮件通知、后台处理耗时的数据处理等&#xff0c;上次分享了ASP.NET Core中实现定时任务的…
阅读更多...
vitepress项目使用github的action自动部署到github-pages中，理论上可以通用所有

vitepress项目使用github的action自动部署到github-pages中，理论上可以通用所有

使用github的action自动部署到github-pages中 创建部署的deploy.yml文件&#xff0c;在项目的根目录下面 .github\workflows\deploy.yml 完整的代码&#xff1a;使用的是pnpm进行依赖安装。 name: 部署VitePresson:push:branches:- docs # 这段是在推送到 docs 分支时触发该…
阅读更多...
EfficientDet:Scalable and Efficient Object Detection中文版 (BiFPN)

EfficientDet:Scalable and Efficient Object Detection中文版 (BiFPN)

EfficientDet: Scalable and Efficient Object Detection EfficientDet&#xff1a;可扩展和高效的目标检测 摘要 模型效率在计算机视觉中变得越来越重要。本文系统地研究了用于目标检测的神经网络架构设计选择&#xff0c;并提出了几个关键的优化方法来提高效率。首先&…
阅读更多...
[node]Node.js 中REPL简单介绍

[node]Node.js 中REPL简单介绍

[node]Node.js 中REPL简单介绍 什么是REPL为什么使用REPL如何使用REPL 命令REPL模式node的全局内容展示node全局所有模块查看全局模块具体内容其它命令 实践 什么是REPL Node.js REPL(Read Eval Print Loop:交互式解释器) 表示电脑的环境&#xff0c;类似 Windows 系统的终端或…
阅读更多...
【大数据存储与处理】第一次作业

【大数据存储与处理】第一次作业

hbase 启动步骤 1、启动 hadoop&#xff0c;master 虚拟机&#xff0c;切换 root 用户&#xff0c;输入终端命令&#xff1a;start-all.sh 2、启动 zookeeper&#xff0c;分别在 master、slave1、slave2 虚拟机终端命令执行&#xff1a;zkServer.sh start 3、启动 hbase&#x…
阅读更多...
最新文章

Copyright @ 2022~2023