GEM5入门学习2-添加模块和调试

于 2024-03-22 14:15:49 发布
阅读量1.1k 收藏 21
点赞数 9
分类专栏： GEM5 文章标签： 学习 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014756627/article/details/136938111
版权

上篇文章《GEM5入门学习1》介绍了如何使用GEM5来仿真，本文讲介绍如何在GEM5中添加一个自己的模块，并且调试GEM5。

1 添加一个简单模块

添加一个简单的模块需要添加如下几个文件（新添加的demo位于src/learning_gem5/part2目录下）：

  • HelloObject.py：Python的模块接口文件，用于导出接口给仿真脚本使用。

  • hello_object.hh：自己实现的hello_object模块的头文件。

  • hello_object.cc：自己实现的hello_object模块的函数定义。

  • SConscript：编译脚本，在gem5编译系统中添加进去自己的模块。

先添加一个Python的文件，用于将C++模块导出，在python文件中指明新添加对象的名称以及对象的文件位置：

# file: src/learning_gem5/part2/HelloObject.py

from m5.params import *
from m5.SimObject import SimObject

class HelloObject(SimObject):
    type = 'HelloObject'
    cxx_header = "learning_gem5/part2/hello_object.hh"
    cxx_class = "gem5::HelloObject"

其次要实现hello_object.hh文件：

// file: src/learning_gem5/part2/hello_object.hh

#ifndef __LEARNING_GEM5_HELLO_OBJECT_HH__
#define __LEARNING_GEM5_HELLO_OBJECT_HH__
#include "params/HelloObject.hh"
#include "sim/sim_object.hh"

namespace gem5
{
    class HelloObject : public SimObject
    {
    public:
        HelloObject(const HelloObjectParams &p);
    };
} // namespace gem5

#endif // __LEARNING_GEM5_HELLO_OBJECT_HH__

以及模块的实现hello_object.cc文件：

// file src/learning_gem5/part2/hello_object.cc

#include "learning_gem5/part2/hello_object.hh"
#include <iostream>
namespace gem5
{
    HelloObject::HelloObject(const HelloObjectParams &params) : SimObject(params)
    {
        std::cout << "Hello World! From a SimObject!" << std::endl;
    }
} // namespace gem5

添加构建脚本：

# file: src/learning_gem5/part2/SConscript

Import('*')

SimObject('HelloObject.py', sim_objects=['HelloObject'])
Source('hello_object.cc')

上面四个文件时添加一个模块必要的文件，完成之后就可以重新构建gem5，新添加的文件就会被编译到gem的二进制文件中去

scons build/X86/gem5.opt

重新编译之后就可以写仿真脚本来运行我们自己写的模块了：

# file: configs/tutorial/part2/run_hello.py

import m5
from m5.objects import *

# 由于我们写了一个简单的验证模块，所以系统配置时不用指定CPU、内存、Cache等其他模块，单独的helloObject模块就可运行
root = Root(full_system = False)
root.hello = HelloObject()

m5.instantiate()
print("Beginning simulation!")
exit_event = m5.simulate()
print('Exiting @ tick {} because {}'.format(m5.curTick(), exit_event.getCause()))

运行：

./build/X86/gem5.opt configs/tutorial/part2/run_hello.py​

运行结果显示为：

qihangkong@ubuntu:~/git/gem5$ ./build/X86/gem5.opt ./configs/tutorial/part2/run_hello.py​ 
gem5 Simulator System.  https://www.gem5.org
gem5 is copyrighted software; use the --copyright option for details.

gem5 version 22.1.0.0
gem5 compiled Mar  6 2023 14:24:51
gem5 started Mar  6 2023 14:35:10
gem5 executing on ubuntu, pid 48426
command line: ./build/X86/gem5.opt './configs/tutorial/part2/run_hello.py​'

Global frequency set at 1000000000000 ticks per second
Hello World! From a SimObject!
Beginning simulation!
build/X86/sim/simulate.cc:192: info: Entering event queue @ 0.  Starting simulation...
Exiting @ tick 18446744073709551615 because simulate() limit reached

2 添加调试接口

GEM5中包含一套调试信息的实现接口，其支持自定义的log信息打印，可以在运行时指定 --debug-flags=XXX 来指定输出log的信息：

如输出DRAM的日志信息可以使用：

build/X86/gem5.opt --debug-flags=DRAM configs/learning_gem5/part1/simple.py | head -n 50

输出执行过程的日志信息可以使用：

build/X86/gem5.opt --debug-flags=Exec configs/learning_gem5/part1/simple.py | head -n 50

可以通过 --debug-help 来获取所有的debug信息：

build/X86/gem5.opt --debug-help

接下来我们在新添加的模块里面添加一个新的调试标签，就可以替换print输出。

实现需要先在前面创建的SConstruct文件添加申明一个Debug标签：

# file: src/learning_gem5/part2/SConstruct

Import("*")

DebugFlag("HelloExample")   # 这个声明必须在Import("*")后面

在SConstruct中声明了标签之后，构建系统将会自动生成一个 debug/HelloExample.hh 的头文件，在使用的时候直接包含这个头文件，就可以使用DPRINT宏来打印日志：

// file: src/learning_gem5/part2/hello_object.cc

#include "base/trace.hh"
#include "debug/HelloExample.hh"

#include "learning_gem5/part2/hello_object.hh"
#include <iostream>
namespace gem5
{
    HelloObject::HelloObject(const HelloObjectParams &params) : SimObject(params)
    {
        DPRINTF(HelloExample, "Created the hello object\n");
    }
} // namespace gem5

编译后运行命令：

./build/X86/gem5.opt --debug-flags=HelloExample configs/tutorial/part2/run_hello.py​

就会打印出来上面的日志：

gem5 Simulator System.  https://www.gem5.org
gem5 is copyrighted software; use the --copyright option for details.

gem5 version 22.1.0.0
gem5 compiled Mar  7 2023 11:27:08
gem5 started Mar  7 2023 11:41:32
gem5 executing on ubuntu, pid 66785
command line: ./build/X86/gem5.opt --debug-flags=HelloExample 'configs/tutorial/part2/run_hello.py​'

Global frequency set at 1000000000000 ticks per second
      0: hello: Create the hello object
Beginning simulation!
build/X86/sim/simulate.cc:192: info: Entering event queue @ 0.  Starting simulation...
Exiting @ tick 18446744073709551615 because simulate() limit reached

如果不加 --debug-flags就没有打印信息的输出。

3 事件驱动编程

GEM5是一个事件驱动的模型，在本节中将在上一节的demo基础上扩展为事件处理模型。

对于事件模型，每个事件将会触发钩子函数的执行，Gem5中提供一个简单的接口来创建事件模型。

首先要定义事件的钩子函数：

  • processEvent()函数：用来执行在每次事件发生的响应函数

  • EventFunctionWrapper event：执行任意事件函数的接口

  • startup()函数：用来使SimObjects调度内部事件。

// file: src/learning_gem5/part2/hello_object.hh

#ifndef __LEARNING_GEM5_HELLO_OBJECT_HH__
#define __LEARNING_GEM5_HELLO_OBJECT_HH__

#include "params/HelloObject.hh"
#include "sim/sim_object.hh"

namespace gem5
{
    class HelloObject : public SimObject
    {
    public:
        HelloObject(const HelloObjectParams &p);

        void startup();

    private:
        void processEvent();

        EventFunctionWrapper event;
    };
} // namespace gem5

#endif // __LEARNING_GEM5_HELLO_OBJECT_HH__

hello_object.cc文件中实现如下：

// file: src/learning_gem5/part2/hello_object.cc

#include "base/trace.hh"
#include "debug/HelloExample.hh"

#include "learning_gem5/part2/hello_object.hh"
#include <iostream>
namespace gem5
{
    HelloObject::HelloObject(const HelloObjectParams &params) :
        SimObject(params), 
        event([this]{processEvent();}, name())
    {
        DPRINTF(HelloExample, "this is function HelloObject\n");
    }

    void HelloObject::processEvent() {
        DPRINTF(HelloExample, "this is function processEvent()\n");
    }

    void HelloObject::startup() {
        DPRINTF(HelloExample, "this is function startup()\n");
        schedule(event, 100);
    }
} // namespace gem5

运行命令：

./build/X86/gem5.opt --debug-flags=HelloExample configs/tutorial/part2/run_hello.py

执行结果如下：

gem5 Simulator System.  https://www.gem5.org
gem5 is copyrighted software; use the --copyright option for details.

gem5 version 22.1.0.0
gem5 compiled Mar  7 2023 11:59:40
gem5 started Mar  7 2023 12:01:39
gem5 executing on ubuntu, pid 67893
command line: ./build/X86/gem5.opt --debug-flags=HelloExample 'configs/tutorial/part2/run_hello.py​'

Global frequency set at 1000000000000 ticks per second
      0: hello: this is function HelloObject
Beginning simulation!
      0: hello: this is function startup()
build/X86/sim/simulate.cc:192: info: Entering event queue @ 0.  Starting simulation...
    100: hello: this is function processEvent()
Exiting @ tick 18446744073709551615 because simulate() limit reached

现在可以添加一些变量来控制程序的Tick时延，在hello_object.hh文件中：

// file: src/learning_gem5/part2/hello_object.hh

#ifndef __LEARNING_GEM5_HELLO_OBJECT_HH__
#define __LEARNING_GEM5_HELLO_OBJECT_HH__
#include "params/HelloObject.hh"
#include "sim/sim_object.hh"

namespace gem5
{
    class HelloObject : public SimObject
    {
    public:
        HelloObject(const HelloObjectParams &p);

        void startup();
    private:
        void processEvent();

        EventFunctionWrapper event;

        const Tick latency;
        int timeLeft;
    };
} // namespace gem5


#endif // __LEARNING_GEM5_HELLO_OBJECT_HH__

hello_object.cc：

// file src/learning_gem5/part2/hello_object.cc

#include "base/trace.hh"
#include "debug/HelloExample.hh"

#include "learning_gem5/part2/hello_object.hh"
#include <iostream>
namespace gem5
{
    HelloObject::HelloObject(const HelloObjectParams &params) :
        SimObject(params), event([this]{processEvent();}, name()), latency(100), timeLeft(10)
    {
        DPRINTF(HelloExample, "this is function HelloObject\n");
    }

    void HelloObject::processEvent() {
        DPRINTF(HelloExample, "this is function processEvent()\n");

        timeLeft --;
        if (timeLeft <= 0) {
            DPRINTF(HelloExample, "Done\n");
        } else {
            schedule(event, curTick() + latency);
        }
    }

    void HelloObject::startup() {
        DPRINTF(HelloExample, "this is function startup()\n");
        schedule(event, latency);
    }
} // namespace gem5

运行输出如下：

qihangkong@ubuntu:~/git/gem5$ ./build/X86/gem5.opt --debug-flags=HelloExample configs/tutorial/part2/run_hello.py​ 
gem5 Simulator System.  https://www.gem5.org
gem5 is copyrighted software; use the --copyright option for details.

gem5 version 22.1.0.0
gem5 compiled Mar  7 2023 15:02:47
gem5 started Mar  7 2023 15:22:11
gem5 executing on ubuntu, pid 73107
command line: ./build/X86/gem5.opt --debug-flags=HelloExample 'configs/tutorial/part2/run_hello.py​'

Global frequency set at 1000000000000 ticks per second
      0: hello: this is function HelloObject
Beginning simulation!
      0: hello: this is function startup()
build/X86/sim/simulate.cc:192: info: Entering event queue @ 0.  Starting simulation...
    100: hello: this is function processEvent()
    200: hello: this is function processEvent()
    300: hello: this is function processEvent()
    400: hello: this is function processEvent()
    500: hello: this is function processEvent()
    600: hello: this is function processEvent()
    700: hello: this is function processEvent()
    800: hello: this is function processEvent()
    900: hello: this is function processEvent()
   1000: hello: this is function processEvent()
   1000: hello: Done
Exiting @ tick 18446744073709551615 because simulate() limit reached

4 从Python传参数

上面的例子中，参数是定义在程序中的，本节介绍如何通过python脚本传递参数。

首先要修改src/learning_gem5/part2/HelloObject.py添加参数：

# file: src/learning_gem5/part2/HelloObject.py

from m5.params import *
from m5.SimObject import SimObject

class HelloObject(SimObject):
    type = 'HelloObject'
    cxx_header = "learning_gem5/part2/hello_object.hh"
    cxx_class = "gem5::HelloObject"

    time_to_wait = Param.Latency("time before firing the event")
    number_of_fires = Param.Int(1, "Number of times to fire the event before goodbye")

修改hello_object.cc文件中的变量初始化方式，从params.time_to_wait和params.number_of_fires中初始化：

// file src/learning_gem5/part2/hello_object.cc

#include "base/trace.hh"
#include "debug/HelloExample.hh"

#include "learning_gem5/part2/hello_object.hh"
#include <iostream>
namespace gem5
{
    HelloObject::HelloObject(const HelloObjectParams &params) :
        SimObject(params), event([this]{processEvent();}, name()), latency(params.time_to_wait), timeLeft(params.number_of_fires)
    {
        DPRINTF(HelloExample, "this is function HelloObject\n");
    }

    void HelloObject::processEvent() {
        DPRINTF(HelloExample, "this is function processEvent()\n");

        timeLeft --;
        if (timeLeft <= 0) {
            DPRINTF(HelloExample, "Done\n");
        } else {
            schedule(event, curTick() + latency);
        }
    }

    void HelloObject::startup() {
        DPRINTF(HelloExample, "this is function startup()\n");
        schedule(event, latency);
    }
} // namespace gem5

因为是从python脚本中传的参数进来，所以要修改python脚本：

# file: configs/tutorial/part2/run_hello.py

import m5
from m5.objects import *

# 由于我们写了一个间的验证模块，所以系统配置时不用指定CPU、内存、Cache等其他模块，helloObject就可运行
root = Root(full_system = False)
root.hello = HelloObject()
root.hello.time_to_wait = '1ns'

m5.instantiate()
print("Beginning simulation!")
exit_event = m5.simulate()
print('Exiting @ tick {} because {}'.format(m5.curTick(), exit_event.getCause()))

运行结果如下：

qihangkong@ubuntu:~/git/gem5$ ./build/X86/gem5.opt --debug-flags=HelloExample configs/tutorial/part2/run_hello.py​ 
gem5 Simulator System.  https://www.gem5.org
gem5 is copyrighted software; use the --copyright option for details.

gem5 version 22.1.0.0
gem5 compiled Mar  7 2023 15:57:18
gem5 started Mar  7 2023 15:59:05
gem5 executing on ubuntu, pid 77889
command line: ./build/X86/gem5.opt --debug-flags=HelloExample 'configs/tutorial/part2/run_hello.py​'

Global frequency set at 1000000000000 ticks per second
      0: hello: this is function HelloObject
Beginning simulation!
      0: hello: this is function startup()
build/X86/sim/simulate.cc:192: info: Entering event queue @ 0.  Starting simulation...
   1000: hello: this is function processEvent()
   1000: hello: Done
Exiting @ tick 18446744073709551615 because simulate() limit reached

5 传更多的参数

还可以传递其他的SimObject作为参数，在这个例子中设置了一个HelloObject，HelloObject中包含一个GoodbyeObject的对象，其中GoodbyeObject通过参数传递给HelloObject。

实现HelloObject执行倒计时之后给GoodbyeObject发送消息，直到消息填满GoodbyeObject的缓冲区为止。

实现包含文件：

  • src/learning_gem5/part2/SConscript：构建工程，包含两个对象HelloObject和GoodbyeObject

  • src/learning_gem5/part2/goodbye_object：新增加一个goodbye_object对象的实现

  • src/learning_gem5/part2/hello_object：更新hello_object，给goodbye发送消息

  • src/learning_gem5/part2/HelloObject.py：导出GoodbyeObject

首先创建一个新的GoodbyeObject的实现goodbye_object.hh：

// file: src/learning_gem5/part2/goodbye_object.hh

#ifndef __LEARNING_GEM5_GOODBYE_OBJECT_HH__
#define __LEARNING_GEM5_GOODBYE_OBJECT_HH__

#include <string>
#include "params/GoodbyeObject.hh"
#include "sim/sim_object.hh"
namespace gem5
{
    class GoodbyeObject : public SimObject
    {
    private:
        void processEvent();

        // 在每一次迭代填充缓冲区，如果缓冲区未满，此函数将调用其他的事件，继续填充
        void fillBuffer();
        EventWrapper<GoodbyeObject, &GoodbyeObject::processEvent> event;

        float bandwidth;
        int bufferSize;
        char *buffer;
        std::string message;
        int bufferUsed;

    public:
        GoodbyeObject(const GoodbyeObjectParams &params);
        ~GoodbyeObject();

        void sayGoodBye(std::string name);
    };
}

#endif

goodbye_object.cc：

// file: src/learning_gem5/part2/goodbye_object.cc

#include "learning_gem5/part2/goodbye_object.hh"

#include "base/trace.hh"
#include "debug/Hello.hh"
#include "sim/sim_exit.hh"

namespace gem5 {

GoodbyeObject::GoodbyeObject(const GoodbyeObjectParams &params) :
    SimObject(params),
    event(*this),
    bandwidth(params.write_bandwidth),
    bufferSize(params.buffer_size),
    buffer(nullptr),
    bufferUsed(0)
{
    buffer = new char[bufferSize];
    DPRINTF(Hello, "Create the goodbye object\n");
}

GoodbyeObject::~GoodbyeObject()
{
    delete[] buffer;
}

void GoodbyeObject::processEvent()
{
    DPRINTF(Hello, "Processing the event\n");
    fillBuffer();
}

void GoodbyeObject::sayGoodBye(std::string other_name)
{
    DPRINTF(Hello, "Saying Goodbye to %s\n", other_name);
    message = "Goodbye " + other_name + "!!";

    fillBuffer();
}

void GoodbyeObject::fillBuffer()
{
    assert(message.length() > 0);

    int bytes_copied = 0;
    for (auto it = message.begin(); it<message.end() && bufferUsed < bufferSize - 1; it++, bufferUsed++, bytes_copied++) {
        buffer[bufferUsed] = *it;
    }

    if (bufferUsed < bufferSize -1) {
        // buffer 未填充满
        DPRINTF(Hello, "Scheduing another fillbuffer in %d ticks\n", bandwidth * bytes_copied);
        schedule(event, curTick() + bandwidth * bytes_copied);
    } else {
        DPRINTF(Hello, "Goodbye done copying~\n");
        exitSimLoop(buffer, 0, curTick() + bandwidth * bytes_copied);
    }
}

} // namespace gem5

修改HelloObject.py，声明GoodbyeObject，并在HelloObject中通过参数传递：

# file: src/learning_gem5/part2/HelloObject.py

from m5.params import *
from m5.SimObject import SimObject

class GoodbyeObject(SimObject):
    type = "GoodbyeObject"
    cxx_header = "learning_gem5/part2/goodbye_object.hh"
    cxx_class = "gem5::GoodbyeObject"

    buffer_size = Param.MemorySize('1kB', "size of buffer to fill with goodbye")
    write_bandwidth = Param.MemoryBandwidth('100MB/s', "Bandwidth to fill the buffer")

class HelloObject(SimObject):
    type = "HelloObject"
    cxx_header = "learning_gem5/part2/hello_object.hh"
    cxx_class = "gem5::HelloObject"

    time_to_wait = Param.Latency("2us", "Time before firing the event")
    number_of_fires = Param.Int(
        10, "Number of times to fire the event before googbye"
    )
    goodbye_object = Param.GoodbyeObject("A goodbye object")

对应的hello_object.hh也需要修改：

// file: src/learning_gem5/part2/hello_object.hh

#ifndef __LEARNING_GEM5_HELLO_OBJECT_HH__
#define __LEARNING_GEM5_HELLO_OBJECT_HH__

#include "learning_gem5/part2/goodbye_object.hh"
#include "params/HelloObject.hh"
#include "sim/sim_object.hh"

namespace gem5
{
    class HelloObject : public SimObject
    {
        public:
            HelloObject(const HelloObjectParams &p);

            void startup() override;

        private:
            void processEvent();

            EventFunctionWrapper event;
            GoodbyeObject *goodbye;
            const std::string myName;
            const Tick latency;
            int timesLeft;

    };
} // namespace gem5

#endif // __LEARNING_GEM5_HELLO_OBJECT_HH__

hello_object.cc：

// file: src/learning_gem5/part2/hello_object.cc

#include "base/trace.hh"
#include "debug/Hello.hh"

#include "learning_gem5/part2/hello_object.hh"
#include <iostream>

namespace gem5
{
    HelloObject::HelloObject(const HelloObjectParams &params) :
        SimObject(params),
        event([this]{processEvent();}, name()),
        goodbye(params.goodbye_object),
        myName(params.name),
        latency(params.time_to_wait),
        timesLeft(params.number_of_fires)
    {
        DPRINTF(Hello, "this is function HelloObject()\n");
    }

    void HelloObject::processEvent() {
        timesLeft --;
        DPRINTF(Hello, "Hello world! Processing the event! %d left\n",
                timesLeft);
        if (timesLeft <= 0) {
            DPRINTF(Hello, "Done Firing!\n");
            goodbye->sayGoodBye(myName);
        } else {
            schedule(event, curTick() + latency);
        }
    }

    void HelloObject::startup() {
        DPRINTF(Hello, "this is function startup()\n");
        schedule(event, latency);
    }

} // namespace gem5

SConscript构建脚本修改如下：

# file: src/learning_gem5/part2/SConstruct

Import('*')

DebugFlag('Hello')

SimObject('HelloObject.py', sim_objects=['HelloObject', 'GoodbyeObject'])
Source('hello_object.cc')
Source('goodbye_object.cc')

最后还需要修改 configs/tutorial/part2/run_hello.py 文件：

# file: configs/tutorial/part2/run_hello.py

import m5
from m5.objects import *

# 由于我们写了一个简单的验证模块，所以系统配置时不用指定CPU、内存、Cache等其他模块，单独的helloObject模块就可运行
root = Root(full_system=False)

root.hello = HelloObject(time_to_wait = '2ns', number_of_fires = 5)
root.hello.goodbye_object = GoodbyeObject(buffer_size='100B')

m5.instantiate()
print("Beginning simulation!")
exit_event = m5.simulate()
print(f"Exiting @ tick {m5.curTick()} because {exit_event.getCause()}")

添加完成之后编译运行：

scons build/X86/gem5.opt -j 32
./build/X86/gem5.opt --debug-flags=Hello configs/tutorial/part2/run_hello.py

打印信息如下：

zac@zac-us:~/rworkdir/gem5/gem5$ ./build/X86/gem5.opt --debug-flags=Hello configs/tutorial/part2/run_hello.py
gem5 Simulator System.  https://www.gem5.org
gem5 is copyrighted software; use the --copyright option for details.

gem5 version 23.1.0.0
gem5 compiled Mar 22 2024 11:32:46
gem5 started Mar 22 2024 12:04:09
gem5 executing on zac-us, pid 60993
command line: ./build/X86/gem5.opt --debug-flags=Hello configs/tutorial/part2/run_hello.py

Global frequency set at 1000000000000 ticks per second
warn: No dot file generated. Please install pydot to generate the dot file and pdf.
      0: hello.goodbye_object: Create the goodbye object
      0: hello: this is function HelloObject()
Beginning simulation!
      0: hello: this is function startup()
src/sim/simulate.cc:199: info: Entering event queue @ 0.  Starting simulation...
   2000: hello: Hello world! Processing the event! 4 left
   4000: hello: Hello world! Processing the event! 3 left
   6000: hello: Hello world! Processing the event! 2 left
   8000: hello: Hello world! Processing the event! 1 left
  10000: hello: Hello world! Processing the event! 0 left
  10000: hello: Done Firing!
  10000: hello.goodbye_object: Saying Goodbye to hello
  10000: hello.goodbye_object: Scheduing another fillbuffer in 143055 ticks
 153055: hello.goodbye_object: Processing the event
 153055: hello.goodbye_object: Scheduing another fillbuffer in 143055 ticks
 296110: hello.goodbye_object: Processing the event
 296110: hello.goodbye_object: Scheduing another fillbuffer in 143055 ticks
 439165: hello.goodbye_object: Processing the event
 439165: hello.goodbye_object: Scheduing another fillbuffer in 143055 ticks
 582220: hello.goodbye_object: Processing the event
 582220: hello.goodbye_object: Scheduing another fillbuffer in 143055 ticks
 725275: hello.goodbye_object: Processing the event
 725275: hello.goodbye_object: Scheduing another fillbuffer in 143055 ticks
 868330: hello.goodbye_object: Processing the event
 868330: hello.goodbye_object: Goodbye done copying~
Exiting @ tick 954163 because Goodbye hello!!Goodbye hello!!Goodbye hello!!Goodbye hello!!Goodbye hello!!Goodbye hello!!Goodbye h

马师傅哈哈哈
关注
专栏目录
Gem5的安装
傻红就是不爱跑步的博客
03-22 2521
一、简介gem5由C++和python共同完成。可以在FS（full system）模式下模拟完整的系统，或是在SE(syscall emulation)模式下由模拟器提供系统调用模拟用户空间程序。二、Gem5的安装1、预装软件（1）安装python 因为scons是用python写的，所以在使用scons之前，我们需要安装python。一般情况在你安装的系统中都已经有python，可以使用:
如何调试gem5
zgl07的专栏
12-09 6911
1. tracing printf（）是很好的工具，同时gem5在自己代码里面就有很多已经做好的输出信息，可以通过flag制定来选择。 输出flags: Fetch, Decode, Ethernet, Exec, TLB, DMA, Bus, Cache, Loader, O3CPUAll, 要想知道所有的flags，运行的时候加上--debug-help选项就可以。 调
Gem5 Debug
http://www.icfgblog.com/
08-19 1482
Gem5的源码在src文件夹，涉及很多内容，如果希望修改某些模块，或增加某些功能，总感觉无从下手：一方面对Gem5的代码组织不清楚，另一方面对硬件结构不熟悉。经过一番探索，逐渐有些感觉，特来记录一波。
Gem5 (1) Building Gem5
IvanCanull的博客
03-20 250
编辑于2020/3/17 Get Started Preliminaries Referring to building gem5 apt-get install build-essential git m4 scons zlib1g zlib1g-dev apt-get install libprotobuf-dev protobuf-compiler libprotoc-dev li...
体系结构模拟器——gem5
qq_36817827的博客
11-25 2303
Gem5 模拟器
ruby入门简单demo，学习练习编程语言
最新发布
03-05
5. Pry：一个交互式的Ruby控制台，提供了更好的调试和学习环境。 在“ruby-master”这个文件夹中，很可能是包含了一个Ruby的学习项目或教程。通过这个项目，你可以实践Ruby的基本语法，例如变量、控制流、函数、类...
Ruby编程快速入门：看图学习指南
7. 调试和测试工具：Ruby有内置的调试器和测试框架，如irb（交互式Ruby shell）和RSpec，便于开发者进行测试驱动开发。 在《Ruby Visual QuickStart Guide》中，读者可以期待学习到以下内容： - Ruby的基础知识：...
ruby 入门练习上手项目
02-18
12. **Gem管理**：Ruby的包管理系统是Gem，你将学会如何安装、使用和管理第三方库。 通过这个"Ruby入门练习上手项目"，你不仅可以学习到基础的Ruby编程，还能了解Web开发的基础，为未来的项目开发打下坚实基础。...
Ruby相关入门教程网址
04-16
同时，熟悉并掌握一些常见的Ruby开发工具，如 pry 调试工具，rake 构建工具，gem 包管理器，以及bundle来管理项目依赖，都是提高开发效率的关键。 总的来说，这份Ruby入门教程应该能帮助初学者建立起对Ruby语言的...
Ruby语言入门教程：从基础到实践
教程后续章节会进一步深入到类和模块、方法、模块导入、块和 Proc 对象、闭包和匿名函数、继承和多态性、宝石（Gem）管理和包管理，以及如何调试和测试Ruby程序等内容。此外，还可能包含一些实战项目，帮助读者将所...
Gem5安装包
10-02
Gem5主要用于进行系统级建模和CPU建模仿真工具，能快速进行微架构的调整，仿真
gem5--Getting started with gem5
DuskWatcher的博客
05-15 646
gem5--创建一个简单的配置脚本搭建的结构模型 注：关于如何搭建gem5环境，不再进行过多的介绍。直接参照gem5的官方文档即可。http://www.m5sim.org/Main_Page 今天有了一点时间，来搞一下如何进行gem5的配置。 搭建的结构模型 在这里，我想搭建的是一个如下图的结构模型，这个结构模型中暂时没有考虑cache等复杂结构。 首先要做的是在 gem5/configs中新...
gem5中添加调试信息DPRINTF
计算机系统、存储
11-15 2719
参考：http://article.gmane.org/gmane.comp.emulators.m5.users/16869/match=debug+dprintf 问题来源：gem5中想查看缓存运行过程中的访问情况时，需要查看调试信息，DPRINTF会将有用的信息输出到trace.out中，这样可以方便查看其中的信息。那么如何添加自己的调试信息呢？ 解决方法： 1. 定义
GEM5 Tutorial
u010170039的博客
09-08 5419
GEM5 Tutorial主要完成创建一个简单系统的配置脚本，并写一个C语言程序在gem5上运行仿真。 第二步，完成一个2级cache系统； 最后，观察改变一些系统参数比如memory types, 处理器频率，程序的性能复杂性。  模拟脚本控制了gem5模拟的配置和运行。gem5模拟器本身是被动的，gem5的调用就是执行用户的模拟脚本，只有当脚本调用它时才执行指定操作。   模拟脚本用Py
Gem5简介
kim_mechane的博客
03-22 7983
        GEM5是一款模块化的离散事件驱动全系统模拟器，它结合了M5和GEMS中最优秀的部分，是一款高度可配置、集成多种ISA和多种CPU模型的体系结构模拟器。M5是由Michigan大学开发的一款开源的多处理机模拟器，受到了业内的...
Gem5在全系统(FS)模式下运行自己的测试程序
开眼看世界
06-25 3091
上一篇文章讲了怎么用Gem5构建和启动FS模式,这一次想看看怎么在模拟的环境中测试自己的程序. 我这里还是用的上次提到的X86的环境,整体过程是以下几个步骤: 1.挂载镜像 ypf@ypf-PC:~/ws$ sudo mount -o,loop,offset=32256 full_system_images/disks/linux-x86.img /mnt 2.将可执行程序拷贝到挂载的镜像...
gem5学习——The gem5 Memory System
weixin_49908714的博客
03-15 1209
本文是对gem5官方教程gem5: gem5_memory_syste 的学习：描述了gem5中的内存子系统，重点关注CPU简单内存事务（读或写）期间的程序流。
Ubuntu安装gem5
xiao_huocai的博客
08-30 4830
GEM5是一个非常强大的模拟平台，服务于计算机系统架构相关研究，包括系统级架构和处理器微架构。最近在做GEM5相关的研究工作，顺便在blog上记下学习笔记。本文主要描述怎么正确地在Linux系统上安装和运行GEM5。 安装一些依赖软件 运行GEM5需要一些依赖软件，包括：g++ （4.7版本及以上）、Python （2.5版本及以上）、 SCons （0.98.1版本及以上）、 S...
gem5简介
09-16 8252
gem5模拟器提供了四个不同的CPU模型，两个不同的系统模型以及两个不同的内存系统模型，并且支持多种指令集（ARM、ALPHA、MIPS、Power、SPARC和x86），其中可以再ARM、ALPHA和x86三种架构上运行Linux。gem5的许可证是基于BSD的，这就为工业界和学术界的合作搭建了一个好的桥梁。虽然开发一个Full-system的模拟器是很复杂的，但gem5正在借助开源的强大合作力（如mailing lists，wiki，web-based patch reviews，a publicly
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

马师傅哈哈哈

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值