DC
Derek Christ
Wed, Jun 14, 2023 6:32 AM
Hello,
maybe I have missed something in the official docs, but I'm not sure how
to run multiple simulations with different parameters concurrently to
speed up the process.
What I have done is I created a Python script that sets environment
variables and then kicks-off gem5 which in turn runs another Python
script that reads those environment variables to configure the simulation.
But I'm sure there has to be a better way?
I think it might be easier if it would be possible to run gem5 purely
with Python (without the gem5 executable) because then it would be easy
to pass custom parameters to the gem5 configuration.
Is there something that I missed?
Thanks
Best
Derek
Hello,
maybe I have missed something in the official docs, but I'm not sure how
to run multiple simulations with different parameters concurrently to
speed up the process.
What I have done is I created a Python script that sets environment
variables and then kicks-off gem5 which in turn runs another Python
script that reads those environment variables to configure the simulation.
But I'm sure there has to be a better way?
I think it might be easier if it would be possible to run gem5 purely
with Python (without the gem5 executable) because then it would be easy
to pass custom parameters to the gem5 configuration.
Is there something that I missed?
Thanks
Best
Derek
AA
Ayaz Akram
Wed, Jun 14, 2023 7:21 AM
Hi Derek,
I am not sure if I have understood your question correctly, but the gem5
interface is basically a Python run script in which you can add parameters
as well (that can be set from the command line or in shell scripts). For
example, you can look at the following link to see how argparse is used
for this purpose:
https://www.gem5.org/documentation/learning_gem5/part1/cache_config/
-Ayaz
On Tue, Jun 13, 2023 at 11:32 PM Derek Christ via gem5-users <
gem5-users@gem5.org> wrote:
Hello,
maybe I have missed something in the official docs, but I'm not sure how
to run multiple simulations with different parameters concurrently to
speed up the process.
What I have done is I created a Python script that sets environment
variables and then kicks-off gem5 which in turn runs another Python
script that reads those environment variables to configure the simulation.
But I'm sure there has to be a better way?
I think it might be easier if it would be possible to run gem5 purely
with Python (without the gem5 executable) because then it would be easy
to pass custom parameters to the gem5 configuration.
Is there something that I missed?
Thanks
Best
Derek
gem5-users mailing list -- gem5-users@gem5.org
To unsubscribe send an email to gem5-users-leave@gem5.org
Hi Derek,
I am not sure if I have understood your question correctly, but the gem5
interface is basically a Python run script in which you can add parameters
as well (that can be set from the command line or in shell scripts). For
example, you can look at the following link to see how `argparse` is used
for this purpose:
https://www.gem5.org/documentation/learning_gem5/part1/cache_config/
-Ayaz
On Tue, Jun 13, 2023 at 11:32 PM Derek Christ via gem5-users <
gem5-users@gem5.org> wrote:
> Hello,
>
> maybe I have missed something in the official docs, but I'm not sure how
> to run multiple simulations with different parameters concurrently to
> speed up the process.
>
> What I have done is I created a Python script that sets environment
> variables and then kicks-off gem5 which in turn runs another Python
> script that reads those environment variables to configure the simulation.
> But I'm sure there has to be a better way?
>
> I think it might be easier if it would be possible to run gem5 purely
> with Python (without the gem5 executable) because then it would be easy
> to pass custom parameters to the gem5 configuration.
>
> Is there something that I missed?
>
> Thanks
>
> Best
> Derek
> _______________________________________________
> gem5-users mailing list -- gem5-users@gem5.org
> To unsubscribe send an email to gem5-users-leave@gem5.org
>
DC
Derek Christ
Wed, Jun 14, 2023 11:40 AM
Hi Ayaz,
thanks for your quick response.
Yeah, argparse is one possibility. But it is cumbersome and bugprone to
implement a new option for every single configuration parameter I want
to vary. Also, I would need a way not only to parse the options, but
also to generate the gem5 command with the parameters on-the-fly. As far
as I know, argparse does not provide this functionality.
So another option that I thought of is to serialize my custom
configuration class, pass it to gem5, and deserialize it again in the
gem5 configuration script.
Best
Derek
Am 14.06.23 um 09:21 schrieb Ayaz Akram via gem5-users:
Hi Derek,
I am not sure if I have understood your question correctly, but the
gem5 interface is basically a Python run script in which you can add
parameters as well (that can be set from the command line or in shell
scripts). For example, you can look at the following link to see how
argparse is used for this purpose:
https://www.gem5.org/documentation/learning_gem5/part1/cache_config/
-Ayaz
On Tue, Jun 13, 2023 at 11:32 PM Derek Christ via gem5-users
gem5-users@gem5.org wrote:
Hello,
maybe I have missed something in the official docs, but I'm not
sure how
to run multiple simulations with different parameters concurrently to
speed up the process.
What I have done is I created a Python script that sets environment
variables and then kicks-off gem5 which in turn runs another Python
script that reads those environment variables to configure the
simulation.
But I'm sure there has to be a better way?
I think it might be easier if it would be possible to run gem5 purely
with Python (without the gem5 executable) because then it would be
easy
to pass custom parameters to the gem5 configuration.
Is there something that I missed?
Thanks
Best
Derek
_______________________________________________
gem5-users mailing list -- gem5-users@gem5.org
To unsubscribe send an email to gem5-users-leave@gem5.org
gem5-users mailing list --gem5-users@gem5.org
To unsubscribe send an email togem5-users-leave@gem5.org
Hi Ayaz,
thanks for your quick response.
Yeah, argparse is one possibility. But it is cumbersome and bugprone to
implement a new option for every single configuration parameter I want
to vary. Also, I would need a way not only to parse the options, but
also to generate the gem5 command with the parameters on-the-fly. As far
as I know, argparse does not provide this functionality.
So another option that I thought of is to serialize my custom
configuration class, pass it to gem5, and deserialize it again in the
gem5 configuration script.
Best
Derek
Am 14.06.23 um 09:21 schrieb Ayaz Akram via gem5-users:
> Hi Derek,
>
> I am not sure if I have understood your question correctly, but the
> gem5 interface is basically a Python run script in which you can add
> parameters as well (that can be set from the command line or in shell
> scripts). For example, you can look at the following link to see how
> `argparse` is used for this purpose:
>
> https://www.gem5.org/documentation/learning_gem5/part1/cache_config/
>
> -Ayaz
>
> On Tue, Jun 13, 2023 at 11:32 PM Derek Christ via gem5-users
> <gem5-users@gem5.org> wrote:
>
> Hello,
>
> maybe I have missed something in the official docs, but I'm not
> sure how
> to run multiple simulations with different parameters concurrently to
> speed up the process.
>
> What I have done is I created a Python script that sets environment
> variables and then kicks-off gem5 which in turn runs another Python
> script that reads those environment variables to configure the
> simulation.
> But I'm sure there has to be a better way?
>
> I think it might be easier if it would be possible to run gem5 purely
> with Python (without the gem5 executable) because then it would be
> easy
> to pass custom parameters to the gem5 configuration.
>
> Is there something that I missed?
>
> Thanks
>
> Best
> Derek
> _______________________________________________
> gem5-users mailing list -- gem5-users@gem5.org
> To unsubscribe send an email to gem5-users-leave@gem5.org
>
>
> _______________________________________________
> gem5-users mailing list --gem5-users@gem5.org
> To unsubscribe send an email togem5-users-leave@gem5.org
EM
Eliot Moss
Wed, Jun 14, 2023 12:38 PM
On 6/14/2023 2:32 AM, Derek Christ via gem5-users wrote:
Hello,
maybe I have missed something in the official docs, but I'm not sure how to run multiple simulations
with different parameters concurrently to speed up the process.
What I have done is I created a Python script that sets environment variables and then kicks-off
gem5 which in turn runs another Python script that reads those environment variables to configure
the simulation.
But I'm sure there has to be a better way?
I think it might be easier if it would be possible to run gem5 purely with Python (without the gem5
executable) because then it would be easy to pass custom parameters to the gem5 configuration.
Is there something that I missed?
Thanks
Best
Derek
I use scripts that setup environment variables, command line parameters, and a python
file with python parameter settings. The latter is placed in a directory unique to
the run.
It happens that my scripts are shell scripts, but with varying degrees of pain, other
scripting languages, or even hard coding in C or something, would work. I just use
what I am skilled with.
You must have the gem4 executable, however. The bulk of the simulation is run with
that (optimizing compiled) C++ code. It implements the actual modules as well as the
event driven simulation part. Python is used mostly for configuring the simulation
before the event loop is kicked off. If the simulator were written entirely in python
it would be much slower.
HTH - Eliot Moss
On 6/14/2023 2:32 AM, Derek Christ via gem5-users wrote:
> Hello,
>
> maybe I have missed something in the official docs, but I'm not sure how to run multiple simulations
> with different parameters concurrently to speed up the process.
>
> What I have done is I created a Python script that sets environment variables and then kicks-off
> gem5 which in turn runs another Python script that reads those environment variables to configure
> the simulation.
> But I'm sure there has to be a better way?
>
> I think it might be easier if it would be possible to run gem5 purely with Python (without the gem5
> executable) because then it would be easy to pass custom parameters to the gem5 configuration.
>
> Is there something that I missed?
>
> Thanks
>
> Best
> Derek
I use scripts that setup environment variables, command line parameters, and a python
file with python parameter settings. The latter is placed in a directory unique to
the run.
It happens that my scripts are shell scripts, but with varying degrees of pain, other
scripting languages, or even hard coding in C or something, would work. I just use
what I am skilled with.
You *must* have the gem4 executable, however. The bulk of the simulation is run with
that (optimizing compiled) C++ code. It implements the actual modules as well as the
event driven simulation part. Python is used mostly for configuring the simulation
before the event loop is kicked off. If the simulator were written entirely in python
it would be much slower.
HTH - Eliot Moss
DC
Derek Christ
Wed, Jun 14, 2023 3:30 PM
Hello Elliot Moss,
a shared Python file with parameter settings sounds useful.
What I meant with running gem5 without the gem5 executable was to use
the compiled library directly from the Python configuration script.
From what I have seen, the gem5 executable sets up some internal state
and then directly calls the embedded Python interpreter to launch the
user-provided script.
But as I see it there is no technical reason why it shouldn't be
possible to call this setup routine directly from Python. This would
reduce the complexity to only one single Python script.
Best
Derek
Am 14.06.23 um 14:38 schrieb Eliot Moss via gem5-users:
On 6/14/2023 2:32 AM, Derek Christ via gem5-users wrote:
Hello,
maybe I have missed something in the official docs, but I'm not sure
how to run multiple simulations with different parameters
concurrently to speed up the process.
What I have done is I created a Python script that sets environment
variables and then kicks-off gem5 which in turn runs another Python
script that reads those environment variables to configure the
simulation.
But I'm sure there has to be a better way?
I think it might be easier if it would be possible to run gem5 purely
with Python (without the gem5 executable) because then it would be
easy to pass custom parameters to the gem5 configuration.
Is there something that I missed?
Thanks
Best
Derek
I use scripts that setup environment variables, command line
parameters, and a python
file with python parameter settings. The latter is placed in a
directory unique to
the run.
It happens that my scripts are shell scripts, but with varying degrees
of pain, other
scripting languages, or even hard coding in C or something, would
work. I just use
what I am skilled with.
You must have the gem4 executable, however. The bulk of the
simulation is run with
that (optimizing compiled) C++ code. It implements the actual modules
as well as the
event driven simulation part. Python is used mostly for configuring
the simulation
before the event loop is kicked off. If the simulator were written
entirely in python
it would be much slower.
HTH - Eliot Moss
gem5-users mailing list -- gem5-users@gem5.org
To unsubscribe send an email to gem5-users-leave@gem5.org
Hello Elliot Moss,
a shared Python file with parameter settings sounds useful.
What I meant with running gem5 without the gem5 executable was to use
the compiled library directly from the Python configuration script.
From what I have seen, the gem5 executable sets up some internal state
and then directly calls the embedded Python interpreter to launch the
user-provided script.
But as I see it there is no technical reason why it shouldn't be
possible to call this setup routine directly from Python. This would
reduce the complexity to only one single Python script.
Best
Derek
Am 14.06.23 um 14:38 schrieb Eliot Moss via gem5-users:
> On 6/14/2023 2:32 AM, Derek Christ via gem5-users wrote:
>> Hello,
>>
>> maybe I have missed something in the official docs, but I'm not sure
>> how to run multiple simulations with different parameters
>> concurrently to speed up the process.
>>
>> What I have done is I created a Python script that sets environment
>> variables and then kicks-off gem5 which in turn runs another Python
>> script that reads those environment variables to configure the
>> simulation.
>> But I'm sure there has to be a better way?
>>
>> I think it might be easier if it would be possible to run gem5 purely
>> with Python (without the gem5 executable) because then it would be
>> easy to pass custom parameters to the gem5 configuration.
>>
>> Is there something that I missed?
>>
>> Thanks
>>
>> Best
>> Derek
>
> I use scripts that setup environment variables, command line
> parameters, and a python
> file with python parameter settings. The latter is placed in a
> directory unique to
> the run.
>
> It happens that my scripts are shell scripts, but with varying degrees
> of pain, other
> scripting languages, or even hard coding in C or something, would
> work. I just use
> what I am skilled with.
>
> You *must* have the gem4 executable, however. The bulk of the
> simulation is run with
> that (optimizing compiled) C++ code. It implements the actual modules
> as well as the
> event driven simulation part. Python is used mostly for configuring
> the simulation
> before the event loop is kicked off. If the simulator were written
> entirely in python
> it would be much slower.
>
> HTH - Eliot Moss
> _______________________________________________
> gem5-users mailing list -- gem5-users@gem5.org
> To unsubscribe send an email to gem5-users-leave@gem5.org
EM
Eliot Moss
Wed, Jun 14, 2023 5:58 PM
On 6/14/2023 11:30 AM, Derek Christ wrote:
Hello Eliot Moss, [one ell please]
a shared Python file with parameter settings sounds useful.
What I meant with running gem5 without the gem5 executable was to use the
compiled library directly from the Python configuration script.
From what I have seen, the gem5 executable sets up some internal state and
then directly calls the embedded Python interpreter to launch the
user-provided script.
But as I see it there is no technical reason why it shouldn't be possible to
call this setup routine directly from Python. This would reduce the
complexity to only one single Python script.
Well, there may remain value to having a standard setup/run script that
invokes a user supplied script. It helps keep gem5 per se separate from the
user's setup / configuration - a principle of modularity.
A quick look at main.cc suggests you may be right that this could be done,
though I have no idea what those various setup functions do and whether any of
that would be hard to do from python. What I suppose I am missing is the
motivation - why such a change would be substantially better. My applications
tend to be quite complex and I find I need the layers of script, for various
reasons. Maybe this has more to do with preference to write in python vs bash
scripts vs C++ code.
gem5 is not currently packaged as a library, I don't think, though I suppose
it could be. Given the amount of existing projects and infrastructure, one
would need to continue to support the current way of doing things as well.
This might further complicate the system and its maintenance - one hopes by
not very much.
HTH - EM
On 6/14/2023 11:30 AM, Derek Christ wrote:
> Hello Eliot Moss, [one ell please]
> a shared Python file with parameter settings sounds useful.
> What I meant with running gem5 without the gem5 executable was to use the
> compiled library directly from the Python configuration script.
> From what I have seen, the gem5 executable sets up some internal state and
> then directly calls the embedded Python interpreter to launch the
> user-provided script.
> But as I see it there is no technical reason why it shouldn't be possible to
> call this setup routine directly from Python. This would reduce the
> complexity to only one single Python script.
Well, there may remain value to having a standard setup/run script that
invokes a user supplied script. It helps keep gem5 per se separate from the
user's setup / configuration - a principle of modularity.
A quick look at main.cc suggests you may be right that this *could* be done,
though I have no idea what those various setup functions do and whether any of
that would be hard to do from python. What I suppose I am missing is the
motivation - why such a change would be substantially better. My applications
tend to be quite complex and I find I need the layers of script, for various
reasons. Maybe this has more to do with preference to write in python vs bash
scripts vs C++ code.
gem5 is not currently packaged as a library, I don't think, though I suppose
it could be. Given the amount of existing projects and infrastructure, one
would need to continue to support the current way of doing things as well.
This might further complicate the system and its maintenance - one hopes by
not very much.
HTH - EM
JL
Jason Lowe-Power
Wed, Jun 14, 2023 6:05 PM
Hi all,
You can use python multiprocessing with gem5. See
https://github.com/gem5/gem5/tree/develop/src/python/gem5/utils/multiprocessing
for details.
So, in theory, you can create scripts such that you can run ./gem5 run.py
which will run a set of different experiments. You could potentially even
send a subset of stats back to the main run.py script for
post-processing, though I haven't tested that, yet.
We are planning to add extensions to the simulator module to make this more
user friendly in gem5 23.1 (the release after gem5 23.0).
Cheers,
Jason
On Wed, Jun 14, 2023 at 11:01 AM Eliot Moss via gem5-users <
gem5-users@gem5.org> wrote:
On 6/14/2023 11:30 AM, Derek Christ wrote:
Hello Eliot Moss, [one ell please]
a shared Python file with parameter settings sounds useful.
What I meant with running gem5 without the gem5 executable was to use the
compiled library directly from the Python configuration script.
From what I have seen, the gem5 executable sets up some internal state
then directly calls the embedded Python interpreter to launch the
user-provided script.
But as I see it there is no technical reason why it shouldn't be
call this setup routine directly from Python. This would reduce the
complexity to only one single Python script.
Well, there may remain value to having a standard setup/run script that
invokes a user supplied script. It helps keep gem5 per se separate from
the
user's setup / configuration - a principle of modularity.
A quick look at main.cc suggests you may be right that this could be
done,
though I have no idea what those various setup functions do and whether
any of
that would be hard to do from python. What I suppose I am missing is the
motivation - why such a change would be substantially better. My
applications
tend to be quite complex and I find I need the layers of script, for
various
reasons. Maybe this has more to do with preference to write in python vs
bash
scripts vs C++ code.
gem5 is not currently packaged as a library, I don't think, though I
suppose
it could be. Given the amount of existing projects and infrastructure, one
would need to continue to support the current way of doing things as well.
This might further complicate the system and its maintenance - one hopes by
not very much.
HTH - EM
gem5-users mailing list -- gem5-users@gem5.org
To unsubscribe send an email to gem5-users-leave@gem5.org
Hi all,
You can use python multiprocessing with gem5. See
https://github.com/gem5/gem5/tree/develop/src/python/gem5/utils/multiprocessing
for details.
So, in theory, you can create scripts such that you can run `./gem5 run.py`
which will run a set of different experiments. You could potentially even
send a subset of stats back to the main `run.py` script for
post-processing, though I haven't tested that, yet.
We are planning to add extensions to the simulator module to make this more
user friendly in gem5 23.1 (the release after gem5 23.0).
Cheers,
Jason
On Wed, Jun 14, 2023 at 11:01 AM Eliot Moss via gem5-users <
gem5-users@gem5.org> wrote:
> On 6/14/2023 11:30 AM, Derek Christ wrote:
> > Hello Eliot Moss, [one ell please]
>
> > a shared Python file with parameter settings sounds useful.
>
> > What I meant with running gem5 without the gem5 executable was to use the
> > compiled library directly from the Python configuration script.
>
> > From what I have seen, the gem5 executable sets up some internal state
> and
> > then directly calls the embedded Python interpreter to launch the
> > user-provided script.
>
> > But as I see it there is no technical reason why it shouldn't be
> possible to
> > call this setup routine directly from Python. This would reduce the
> > complexity to only one single Python script.
>
> Well, there may remain value to having a standard setup/run script that
> invokes a user supplied script. It helps keep gem5 per se separate from
> the
> user's setup / configuration - a principle of modularity.
>
> A quick look at main.cc suggests you may be right that this *could* be
> done,
> though I have no idea what those various setup functions do and whether
> any of
> that would be hard to do from python. What I suppose I am missing is the
> motivation - why such a change would be substantially better. My
> applications
> tend to be quite complex and I find I need the layers of script, for
> various
> reasons. Maybe this has more to do with preference to write in python vs
> bash
> scripts vs C++ code.
>
> gem5 is not currently packaged as a library, I don't think, though I
> suppose
> it could be. Given the amount of existing projects and infrastructure, one
> would need to continue to support the current way of doing things as well.
> This might further complicate the system and its maintenance - one hopes by
> not very much.
>
> HTH - EM
> _______________________________________________
> gem5-users mailing list -- gem5-users@gem5.org
> To unsubscribe send an email to gem5-users-leave@gem5.org
>
DC
Derek Christ
Wed, Jun 14, 2023 6:21 PM
Hi Jason,
it seems like this is exactly what I was looking for.
Awesome to hear that things will get more user friendly in next versions.
Best
Derek
Am 14.06.23 um 20:05 schrieb Jason Lowe-Power via gem5-users:
Hi all,
You can use python multiprocessing with gem5. See
https://github.com/gem5/gem5/tree/develop/src/python/gem5/utils/multiprocessing
for details.
So, in theory, you can create scripts such that you can run ./gem5 run.py which will run a set of different experiments. You could
potentially even send a subset of stats back to the main run.py
script for post-processing, though I haven't tested that, yet.
We are planning to add extensions to the simulator module to make this
more user friendly in gem5 23.1 (the release after gem5 23.0).
Cheers,
Jason
On Wed, Jun 14, 2023 at 11:01 AM Eliot Moss via gem5-users
gem5-users@gem5.org wrote:
On 6/14/2023 11:30 AM, Derek Christ wrote:
Hello Eliot Moss, [one ell please]
a shared Python file with parameter settings sounds useful.
What I meant with running gem5 without the gem5 executable was
compiled library directly from the Python configuration script.
From what I have seen, the gem5 executable sets up some internal
then directly calls the embedded Python interpreter to launch the
user-provided script.
But as I see it there is no technical reason why it shouldn't be
call this setup routine directly from Python. This would reduce the
complexity to only one single Python script.
Well, there may remain value to having a standard setup/run script
that
invokes a user supplied script. It helps keep gem5 per se
separate from the
user's setup / configuration - a principle of modularity.
A quick look at main.cc suggests you may be right that this
*could* be done,
though I have no idea what those various setup functions do and
whether any of
that would be hard to do from python. What I suppose I am missing
is the
motivation - why such a change would be substantially better. My
applications
tend to be quite complex and I find I need the layers of script,
for various
reasons. Maybe this has more to do with preference to write in
python vs bash
scripts vs C++ code.
gem5 is not currently packaged as a library, I don't think, though
I suppose
it could be. Given the amount of existing projects and
infrastructure, one
would need to continue to support the current way of doing things
as well.
This might further complicate the system and its maintenance - one
hopes by
not very much.
HTH - EM
_______________________________________________
gem5-users mailing list -- gem5-users@gem5.org
To unsubscribe send an email to gem5-users-leave@gem5.org
gem5-users mailing list --gem5-users@gem5.org
To unsubscribe send an email togem5-users-leave@gem5.org
Hi Jason,
it seems like this is exactly what I was looking for.
Awesome to hear that things will get more user friendly in next versions.
Best
Derek
Am 14.06.23 um 20:05 schrieb Jason Lowe-Power via gem5-users:
> Hi all,
>
> You can use python multiprocessing with gem5. See
> https://github.com/gem5/gem5/tree/develop/src/python/gem5/utils/multiprocessing
> for details.
>
> So, in theory, you can create scripts such that you can run `./gem5
> run.py` which will run a set of different experiments. You could
> potentially even send a subset of stats back to the main `run.py`
> script for post-processing, though I haven't tested that, yet.
>
> We are planning to add extensions to the simulator module to make this
> more user friendly in gem5 23.1 (the release after gem5 23.0).
>
> Cheers,
> Jason
>
> On Wed, Jun 14, 2023 at 11:01 AM Eliot Moss via gem5-users
> <gem5-users@gem5.org> wrote:
>
> On 6/14/2023 11:30 AM, Derek Christ wrote:
> > Hello Eliot Moss, [one ell please]
>
> > a shared Python file with parameter settings sounds useful.
>
> > What I meant with running gem5 without the gem5 executable was
> to use the
> > compiled library directly from the Python configuration script.
>
> > From what I have seen, the gem5 executable sets up some internal
> state and
> > then directly calls the embedded Python interpreter to launch the
> > user-provided script.
>
> > But as I see it there is no technical reason why it shouldn't be
> possible to
> > call this setup routine directly from Python. This would reduce the
> > complexity to only one single Python script.
>
> Well, there may remain value to having a standard setup/run script
> that
> invokes a user supplied script. It helps keep gem5 per se
> separate from the
> user's setup / configuration - a principle of modularity.
>
> A quick look at main.cc suggests you may be right that this
> *could* be done,
> though I have no idea what those various setup functions do and
> whether any of
> that would be hard to do from python. What I suppose I am missing
> is the
> motivation - why such a change would be substantially better. My
> applications
> tend to be quite complex and I find I need the layers of script,
> for various
> reasons. Maybe this has more to do with preference to write in
> python vs bash
> scripts vs C++ code.
>
> gem5 is not currently packaged as a library, I don't think, though
> I suppose
> it could be. Given the amount of existing projects and
> infrastructure, one
> would need to continue to support the current way of doing things
> as well.
> This might further complicate the system and its maintenance - one
> hopes by
> not very much.
>
> HTH - EM
> _______________________________________________
> gem5-users mailing list -- gem5-users@gem5.org
> To unsubscribe send an email to gem5-users-leave@gem5.org
>
>
> _______________________________________________
> gem5-users mailing list --gem5-users@gem5.org
> To unsubscribe send an email togem5-users-leave@gem5.org
