{{< /rawhtml >}}
-This immediately sparked our interest and we wanted to give it some test run against
+This immediately sparked our interest and we wanted to give it some test run against
a containerized browser in our [Green Metrics Tool](https://github.com/green-coding-berlin/green-metrics-tool).
According to the information from Mozilla this works only for M1 Macs or on Windows 11.
-Since our Green Metrics Tool runs on Linux only we could not really make comparisons
-on one machine, but we could give it a first look none the less and look into some
+Since our Green Metrics Tool runs on Linux only we could not really make comparisons
+on one machine, but we could give it a first look none the less and look into some
details where the values are coming from.
## Research Questions
@@ -51,7 +51,7 @@ Tab where you can inspect the whole performance analysis.
Only the ones labeled *Process Power* are relevant for the Power output total.
-Firefox actually splits the power per process, which is quite unusual for the RAPL readings we
+Firefox actually splits the power per process, which is quite unusual for the RAPL readings we
have come accross so far, but more on that later, when we look at the source code.
The spikes for visiting the Umweltbundesamt.de homepage where at the typical spots
@@ -62,16 +62,16 @@ and did not exceed **4 W** in our case.
{{< /rawhtml >}}
-In order to get an energy value we somehow have to sum up these values though with their
+In order to get an energy value we somehow have to sum up these values though with their
respective time measurement interval.
Sampling time we defined was **10 ms**.
-The profiler is able to export a **JSON Dump** if you click on *Upload local profile* in the
+The profiler is able to export a **JSON Dump** if you click on *Upload local profile* in the
top right corner and then *Download* it.
A script to convert this we have attached in our Github repository.
-~~Apparently we had to convert all readings in the JSON by the weird value of **277000000** and
+~~Apparently we had to convert all readings in the JSON by the weird value of **277000000** and
are unsure where this value is coming from .... but at least it makes the raw values from
the JSON to be identical with the values we see in the profiler UI.~~
@@ -92,7 +92,7 @@ and then waiting 2 seconds did incur an energy cost of around **2mWh**.
Although we also had two very unusal measurements of **~40 mWh** that we were not able to
reproduce later the measurements seemed generally very stable.
-We repeated 10 measurements in total. Since it was just a first look and measurements
+We repeated 10 measurements in total. Since it was just a first look and measurements
where started and stopped manually we opted for not reporting Std.Dev. etc, as the manual
handling has probably more influence here anyway ...
@@ -142,7 +142,7 @@ with open(args.filename) as a:
## Comparison on MacBook Pro 2015
-On our **MacBook Pro Mid-2015 with an Intel Core i7-5557U @ 3.1 GHz** running Ubuntu 22.04 we executed a
+On our **MacBook Pro Mid-2015 with an Intel Core i7-5557U @ 3.1 GHz** running Ubuntu 22.04 we executed a
measurement with our container based setup with the Green Metrics Tool.
You can find [one sample measurement here](https://metrics.green-coding.io/stats.html?id=1102d24e-da8e-444e-ae60-a0c7b1694d90)
@@ -152,13 +152,13 @@ The component energy of CPU and DRAM, which is probably the most comparable, her
It is important to note that this is not the energy per process, but the energy for the whole system.
-Measurements between machines are anyway not comparable that easily, as they will have
+Measurements between machines are anyway not comparable that easily, as they will have
non linear load curves that you would have to account for.
### Takeaway
-So the takeaway and also what we wanted to find out as a research question from the start
+So the takeaway and also what we wanted to find out as a research question from the start
is that the M1 power measurements in Firefox seem to produce a value that looks very
interesting and deserves further inspection.
@@ -170,12 +170,12 @@ increase the reproducability greatly
## Further plans
-We were very suprised that the XNU kernel in macOS supplies a feature that can really
+We were very suprised that the XNU kernel in macOS supplies a feature that can really
deliver the energy per task.
This is what was the most interesting for us.
-If you look into the current source tree of Firefox stable it is visiibe that the
+If you look into the current source tree of Firefox stable it is visiibe that the
[code to instrument the measurement on macOS](https://hg.mozilla.org/integration/autoland/diff/f33bef1f7d560e494bab0599e2022a3ea53902f9/tools/profiler/core/PowerCounters-mac.cpp) is not too complex.
However finding relevant documentation posed a problem at the time of writing this article.
diff --git a/content/blog/nop-linux.md b/content/blog/nop-linux.md
index 9a272cb..7c487d7 100644
--- a/content/blog/nop-linux.md
+++ b/content/blog/nop-linux.md
@@ -6,13 +6,13 @@ author: "Didi Hoffmann"
authorlink: "https://www.linkedin.com/in/dietgerhoffmann/"
---
-At Green Coding Berlin (GCB), one goal is to enable reproducible runs on our cluster. An important step towards accurate measurements was the creation of NOP Linux, our custom Linux distro that disables as many background processes as possible to avoid interruptions during measurements. Another crucial step was ensuring the reliable operation of the [PowerSpy2](https://docs.green-coding.io/docs/measuring/metric-providers/psu-energy-ac-powerspy2/), so we could measure the entire power consumption.
+At Green Coding Solutions (GCS), one goal is to enable reproducible runs on our cluster. An important step towards accurate measurements was the creation of NOP Linux, our custom Linux distro that disables as many background processes as possible to avoid interruptions during measurements. Another crucial step was ensuring the reliable operation of the [PowerSpy2](https://docs.green-coding.io/docs/measuring/metric-providers/psu-energy-ac-powerspy2/), so we could measure the entire power consumption.
We wanted to create a cluster that allowed users to select the server on which they'd like to run the benchmark. Initially, we aimed for full automation and looked at the excellent tool from Canonical, [MAAS](https://maas.io/). As we use Ubuntu as our reference system, this seemed to be the logical choice. Although the tool was impressive, it required a daemon running on the machine, which created multiple interruptions during our measurements. This led us to reevaluate our tooling, and we decided to try a simpler approach using PXE. While there is a great description [1], and the general flow worked very well, we invested a significant amount of time and effort in configuring the machines correctly. Getting the entire installation flow working with reboots, different configurations like PowerSpy, and the multitude of different servers we wanted to use presented a considerable overhead. Additionally, we have our machines distributed across various data centers, and we needed to set up a complex networking layer for the DHCP discovery to work. While this was a scalable solution, it required substantial overhead that had to be maintained. Moreover, our tool develops quite rapidly, so we would have to keep updating the installation process. As a small company, this was not feasible in our scenario. Consequently, we decided to sacrifice scalability in favor of simplicity. In the meantime, we had built a complex test setup with various servers and a complicated setup that we could now disassemble. The main lesson learned for the future is to start with the simplest solution that solves the problem and continually reevaluate your assumptions and needs.
We are aware that there are a multitude of configuration systems out there that don't require a client running on the machine to be configured and that automate some of the tasks we will now do manually. But we decided to keep it very simple for now and not invest more time into another solution.
-At Green Coding Berlin, we are committed to not only creating efficient and reproducible programming solutions but also sharing our findings and tools with the wider community. We firmly believe in the principles of open-source, the power of shared knowledge, and the benefits of collaborative development. Our aim is to create tools and systems that can be utilized by anyone, without the restrictions of proprietary licenses. We don't just want to make our solutions better - we want to make programming better, for everyone. One of the exciting initiatives that align with our philosophy is the Blue Angel for Software. We support this cause and believe that our tools and systems should be made available for such uses. By making our developments publicly available, we hope to contribute to the broader objective of creating software that is efficient, effective, and transparent.
+At Green Coding Solutions, we are committed to not only creating efficient and reproducible programming solutions but also sharing our findings and tools with the wider community. We firmly believe in the principles of open-source, the power of shared knowledge, and the benefits of collaborative development. Our aim is to create tools and systems that can be utilized by anyone, without the restrictions of proprietary licenses. We don't just want to make our solutions better - we want to make programming better, for everyone. One of the exciting initiatives that align with our philosophy is the Blue Angel for Software. We support this cause and believe that our tools and systems should be made available for such uses. By making our developments publicly available, we hope to contribute to the broader objective of creating software that is efficient, effective, and transparent.
**The system we are using now**
@@ -23,7 +23,7 @@ As previously mentioned, the current system will not scale to accommodate thousa
We have now opted for quite a simple solution. You will need a server that exposes the database externally and all results will be written to this server. We then have a `client.py` script that runs on every server that periodically queries the server for jobs and if so executes the measurement undisturbed. After a job is finished the client does some cleanup tasks and checks if there is an update for the GMT and also for the operating system. It then retries to get a job till there are no more jobs left on which the client sleeps for 5 minutes and retries. On every wake up we send a message to the server that the client is up and functional. So we can check server side that all clients are up and working.
-To create your own GCB cluster, you can follow these steps:
+To create your own GCS cluster, you can follow these steps:
## 1) Install Ubuntu
diff --git a/content/blog/power-measurement-on-macos.md b/content/blog/power-measurement-on-macos.md
index dce86aa..287b021 100644
--- a/content/blog/power-measurement-on-macos.md
+++ b/content/blog/power-measurement-on-macos.md
@@ -9,20 +9,20 @@ authorlink: "https://www.linkedin.com/in/arne-tarara"
Last week we have been on the [SDIA event for sustainble software](https://sdialliance.org/landing/softawere-hackathon/) and held
a workshop on measuring the energy digital products.
-We presented approchaes where you measure the energy either with tool like [Scaphandre](https://github.com/hubblo-org/scaphandre) or
+We presented approchaes where you measure the energy either with tool like [Scaphandre](https://github.com/hubblo-org/scaphandre) or
the [Green Metrics Tool](https://github.com/green-coding-berlin/green-metrics-tool) as well as approaches for restricted environments like the cloud.
Here the [SDIA DEF Model](https://knowledge.sdialliance.org/digital-environmental-footprint) and our [SPECPower linear model](https://github.com/green-coding-berlin/spec-power-model) where presented.
-What the two former tools have in common though is that they are designed to work
+What the two former tools have in common though is that they are designed to work
exclusively on Linux.
Reason for that being is that the RAPL interfaces are nicely integrated into the
linux kernel and readily readable from a virtual file endpoint.
The downside of it is, that it requires root to read this data on Linux.
-This is also why the [Firefox 104 energy measurement](http://localhost:1313/blog/firefox-104-energy-measurements/) only works either on
+This is also why the [Firefox 104 energy measurement](http://localhost:1313/blog/firefox-104-energy-measurements/) only works either on
Windows or on a Mac M1, because here these interfaces are available in userland.
-In the workshop we saw many participants with exclusively MacBooks either running
+In the workshop we saw many participants with exclusively MacBooks either running
M1 chips or Intel chips and thus we wanted to make a blog post with some info
on how to get measurement data on these setups.
@@ -44,7 +44,7 @@ This is usually your first stop when trying to get some metrics out of your syst
The values to look at are **Energy Impact* and **12 hr Power**. Both are unfortunately
some custom and relative values that are not even comparable between two machines.
-The just tell how much much energy the app is using compared to the device history
+The just tell how much much energy the app is using compared to the device history
of energy usage and other apps on the system.
We are unsure if you could even derive an absolute value from that with just this
@@ -69,12 +69,12 @@ Output is:
- Temperature
- Utilization
-The command line tool can even execute a program and run collect all these metrics
+The command line tool can even execute a program and run collect all these metrics
during its execution.
As well as RAPL on Linux it has the issue that RAPL metrics are system wide.
-So even if you execute a `sleep` program, which would incur an insignificant energy
-draw, you might get high energy readings if some CPU intensive program is running
+So even if you execute a `sleep` program, which would incur an insignificant energy
+draw, you might get high energy readings if some CPU intensive program is running
in the background.
@@ -85,7 +85,7 @@ in the background.
It serves as a very nice introspection tool for your system energy draw though.
What we really liked is the functionality to run certain *tests*.
-For instance turning off Intel SpeedStep and letting the core always run at max
+For instance turning off Intel SpeedStep and letting the core always run at max
frequency, or testing for AVX-512 instructions in particular etc.
See details in the screenshot on the right.
@@ -110,10 +110,10 @@ and have to be converted to Watts to be comparable with Intel Power Gadget.
`powermetrics` comes pre-installed on macOS and can handle M1 and also Intel machines.
-The output is mostly unified, but shows some differences on the M1 machines mainly due
+The output is mostly unified, but shows some differences on the M1 machines mainly due
to the summary given at the end and also because the M1 has different types of cores.
-`powermetrics` sadly also needs root access although the underlying APIs are technically
+`powermetrics` sadly also needs root access although the underlying APIs are technically
readable from userland.
It can provide a lot of diagnostic output and is the only tool we know if you wanna
@@ -127,7 +127,7 @@ Reading these is done through the `rdmsr` instruction of the CPU.
Sadly this cannot be sent to the processor from userland, as it is a ring-0 instruction.
-However if you ever where to write a kernel extension that does so, this code would
+However if you ever where to write a kernel extension that does so, this code would
issue the `rdmsr` instruction. You just have to read the energy register `0x611` with it:
```C
@@ -135,10 +135,10 @@ asm volatile("rdmsr":"=a"(lo),"=d"(hi):"c"(0x10));
```
In the linux world the kernel extension `modprobe msr` forwards this functionality
-to a virtual file in the `/dev` directory. However we could not find a similar
+to a virtual file in the `/dev` directory. However we could not find a similar
macOS kext that would do the same.
-There is one installed alongside with Intel Power Gadget, but we could not find
+There is one installed alongside with Intel Power Gadget, but we could not find
any documentation how to leverage that. It might be easily traceable though ...
If you know of any well documented 3rd partykext or even one that comes
diff --git a/content/blog/releasing-code-bench.md b/content/blog/releasing-code-bench.md
index cadf988..b21151a 100644
--- a/content/blog/releasing-code-bench.md
+++ b/content/blog/releasing-code-bench.md
@@ -10,7 +10,7 @@ Standard benchmarks play a pivotal role in the field of software engineering, se
However, it is important to acknowledge that not all code is created equal. In reality, a significant portion of software is far from being optimally written. There are numerous reasons for this. Often, developers are constrained by tight deadlines, lack of interest or passion for the project, or simply the pressure to make things work within a limited timeframe. As a result, a lot of the software available today is not finely tuned or optimized. To mitigate this issue, considerable efforts have been made to enhance compilers and the internal mechanics of CPUs, aiming to compensate for less-than-optimal coding practices.
-At Green Coding Berlin we have developed a great measurement infrastructure that enables us to measure software reproducible and really see how changes reflect on the impact software has. Now that we can measure code we want to start applying green coding techniques and see how these affect the resource usage. Also a lot of work is currently going on in this space [[0]](https://www.enviroinfo2023.eu/programme/schedule-overview/friday-schedule/)[[1]](https://www.meetup.com/green-software-development-karlsruhe/events/296796570/) but one big problem is that there is no real benchmark of code that can be optimised and that can be measured before and after the changes are applied. I strongly believe that this is a big problem as currently everyone selects their own little piece of code and such there is a) no way to compare results and b) wrong results or conclusions might happen as there is no sound fundament.
+At Green Coding Solutions we have developed a great measurement infrastructure that enables us to measure software reproducible and really see how changes reflect on the impact software has. Now that we can measure code we want to start applying green coding techniques and see how these affect the resource usage. Also a lot of work is currently going on in this space [[0]](https://www.enviroinfo2023.eu/programme/schedule-overview/friday-schedule/)[[1]](https://www.meetup.com/green-software-development-karlsruhe/events/296796570/) but one big problem is that there is no real benchmark of code that can be optimised and that can be measured before and after the changes are applied. I strongly believe that this is a big problem as currently everyone selects their own little piece of code and such there is a) no way to compare results and b) wrong results or conclusions might happen as there is no sound fundament.
So we set out to create a repository with such code. The main aims are:
diff --git a/content/blog/software-life-cycle-assessment.md b/content/blog/software-life-cycle-assessment.md
index 6709a3c..38b1553 100644
--- a/content/blog/software-life-cycle-assessment.md
+++ b/content/blog/software-life-cycle-assessment.md
@@ -6,7 +6,7 @@ author: "Didi Hoffmann"
authorlink: "https://www.linkedin.com/in/dietgerhoffmann/"
---
-In this article I want to propose a simple way to do a Software Life Cycle Assessment for a piece of code. While explaining important concepts and tradeoffs that seem sensible for a little project. Of course things could be done differently and I am happy to discuss them in more detail as this is just a first draft of how things could be done. Please head to [https://github.com/green-coding-berlin/SLCA-Code](https://github.com/green-coding-berlin/SLCA-Code) for all source code and discussions. Please also feel free to contribute to the code through pull requests. As Green Coding Berlin we have been working on this topic for some time and a more academic discussion can be found in our chapter in the [Transparency for Software Climate Impact](https://publication2023.bits-und-baeume.org/#book/38) publication (Part of the Shaping Digital Transformation for a Sustainable Society publication).
+In this article I want to propose a simple way to do a Software Life Cycle Assessment for a piece of code. While explaining important concepts and tradeoffs that seem sensible for a little project. Of course things could be done differently and I am happy to discuss them in more detail as this is just a first draft of how things could be done. Please head to [https://github.com/green-coding-berlin/SLCA-Code](https://github.com/green-coding-berlin/SLCA-Code) for all source code and discussions. Please also feel free to contribute to the code through pull requests. As Green Coding Solutions we have been working on this topic for some time and a more academic discussion can be found in our chapter in the [Transparency for Software Climate Impact](https://publication2023.bits-und-baeume.org/#book/38) publication (Part of the Shaping Digital Transformation for a Sustainable Society publication).
Software Life Cycle Assessment (SLCA) is a topic that is talked about more and more. While Life Cycle Assessment (LCA) is fairly established in the realm of physical things. There are still various discussions in the software space though. In [ISO 14040](https://en.wikipedia.org/wiki/Life-cycle_assessment) and 14044 LCA is defined as the following:
@@ -74,10 +74,10 @@ This is probably the phase the least information is available about when doing r
Page 6.6
>
-Personally I have to disagree. I am quite aware that my development activity produces a lot of environmental impact. Just considering the tower PC with the two screens attached and the various online services I use that I sometimes don’t power down when I go to lunch, which I use for my Linux related development.
+Personally I have to disagree. I am quite aware that my development activity produces a lot of environmental impact. Just considering the tower PC with the two screens attached and the various online services I use that I sometimes don’t power down when I go to lunch, which I use for my Linux related development.
Or thinking about intensive DevOps or re-optimizations of AI models, which seem to be the norm in modern software products rather than the exception. Also if you think about all the software products that never reach a relevant audience or are prototypes and never reach production this cost would be totally neglected ... the list goes on and on ...
-So I wanted to measure this.
+So I wanted to measure this.
Starting with the most obvious: My development machine. I was quite astonished to realise there is no out of the box solution that I can just install and get a nice summary of the energy used for various tasks over time with nice drilldown etc. So I decided to keep it simple and just assume when my work computer is on I am doing work things and that everything the computer does is related to the project I am currently working on. It is debatable that if Spotify, which is one of the biggest [energy consumers](https://github.com/jpochyla/psst), should really be counted to the development of a web project. But I am listing to music while developing so I would argue that it should count. The same goes for Slack, Mail etc. it is currently unrealistic that I can account the energy usage of each email to the various projects I am working on. So to make things simple: If the computer is on everything is counted towards the main project I am working on. We are currently specking out how this could be solved more finer grain. Unfortunately Linux doesn’t really offer any tools that support energy measurements on a per process level. There are some implementations that use cpu utilisation to split the power, but as discussed in the “[CPU UTILIZATION - A USEFUL METRIC](https://www.green-coding.io/case-studies/cpu-utilization-usefulness/)” article this is sometimes misleading. As also part of this work was done while travelling I developed the code on my M1 Macbook Pro. Because of this I can use the `powermetrics` tool we use when benchmarking software on [MacOS](https://www.green-coding.io/blog/green-coding-on-mac/) which gives me a sort of power measurement through the energy impact value. This is a closed source implementation by Apple but some details are known and exposed in [this article by Mozilla](https://blog.mozilla.org/nnethercote/2015/08/26/what-does-the-os-x-activity-monitors-energy-impact-actually-measure/) for instance. While being far from perfect this value gives you a first impact estimate for each process.
@@ -102,7 +102,7 @@ from queue import Queue
from pathlib import Path
from AppKit import NSScreen
-APP_NAME = "gcb_power_logger"
+APP_NAME = "gcs_power_logger"
app_support_path = Path.home() / 'Library' / 'Application Support' / APP_NAME
app_support_path.mkdir(parents=True, exist_ok=True)
diff --git a/content/blog/specpower-model-with-xgboost-open-sourced.md b/content/blog/specpower-model-with-xgboost-open-sourced.md
index f4271e1..d6150ea 100644
--- a/content/blog/specpower-model-with-xgboost-open-sourced.md
+++ b/content/blog/specpower-model-with-xgboost-open-sourced.md
@@ -6,13 +6,13 @@ author: "Arne Tarara"
authorlink: "https://www.linkedin.com/in/arne-tarara"
---
-A detailed blog article is yet to come, but for everyone who follows our
+A detailed blog article is yet to come, but for everyone who follows our
blog only and not our repositories we wanted to highlight that we open sourced
the new XGBoost variant of the [SPECPower estimation model for cloud workloads on github](https://github.com/green-coding-berlin/spec-power-model).
-I guess the most interesting parts are the charts, where you can see the
-SPECPower data in comparsion to the a model by the [SDIA](https://www.sdialliance.org) formula and also our
-old linear model as well as the XGBoost model.
+I guess the most interesting parts are the charts, where you can see the
+SPECPower data in comparsion to the a model by the [SDIA](https://www.sdialliance.org) formula and also our
+old linear model as well as the XGBoost model.
## Summary excerpt
@@ -22,11 +22,11 @@ old linear model as well as the XGBoost model.
- The linear model is good for parameter exploration, but delivers badly fitted results
- The XGBoost model is able to estimate a real world 1-chip machine and an out of sample 2-chip machine from SPECPower very nicely.
+ However it tends to under-estimate
-- We see suprisingly no efficiency gain from applying the SPECPower BIOS settings but rather a smoothing of the curve.
+- We see suprisingly no efficiency gain from applying the SPECPower BIOS settings but rather a smoothing of the curve.
+ The reason to that is currently unknown.
## Detailed Talk & Slides
-Here are the slides to our talk, where we present the works on and performance of the model
+Here are the slides to our talk, where we present the works on and performance of the model
at the PyData Nov'22 Meetup in Berlin.
[Download Slides](/slides/PyData-Talk.pdf)
\ No newline at end of file
diff --git a/content/blog/tdp-and-acp.md b/content/blog/tdp-and-acp.md
index 83bb0f4..9141ebd 100644
--- a/content/blog/tdp-and-acp.md
+++ b/content/blog/tdp-and-acp.md
@@ -6,7 +6,7 @@ author: "Arne Tarara"
authorlink: "https://www.linkedin.com/in/arne-tarara"
---
-In the green software community we see very often that people use the [TDP of the processor](https://www.intel.com/content/www/us/en/support/articles/000055611/processors.html)
+In the green software community we see very often that people use the [TDP of the processor](https://www.intel.com/content/www/us/en/support/articles/000055611/processors.html)
as a metric to estimate how much energy the CPU will consume for a specific workload.
For instance the [SDIA use-phase estimation model](https://docs.google.com/spreadsheets/d/1uCQVs8mVgfu6fcQLEttDgfqPzhCm1yuf19_9RUDuU6w/edit#gid=1126994188) in it's current form uses this metric.
@@ -14,12 +14,12 @@ For instance the [SDIA use-phase estimation model](https://docs.google.com/sprea
We have been using this metric in our machine learning model, where it serves as a very
good indicator of how much the total energy consumption of the system will be.
-However lately I have stumbled over a [white paper from Intel](https://www.intel.com/content/dam/doc/white-paper/resources-xeon-measuring-processor-power-paper.pdf) where they discuss
+However lately I have stumbled over a [white paper from Intel](https://www.intel.com/content/dam/doc/white-paper/resources-xeon-measuring-processor-power-paper.pdf) where they discuss
the TDP in quite some detail and even compare it to a metric from AMD that I was not aware
of: The ACP.
Notes summary:
-- ACP is a measure by AMD for Opteron processors that gives the average power draw
+- ACP is a measure by AMD for Opteron processors that gives the average power draw
for the CPU while running a defined set of benchmarks (TPC Benchmark*-C, SPECcpu*2006, SPECjbb*2005, and STREAM).
- ACP value for Opteron processors is always lower than TDP
- TDP definitions from AMD and Intel are actually different!
@@ -46,18 +46,18 @@ This comparison is a bit tricky, as when we look deeper into how the system is a
- Adjacent Sector Prefetch - Disabled
- ...
-So the comparisons are not really on equal terrain. However it has to be clearly noted
-that Intel nevertheless has the better performance per watt which is probably due
+So the comparisons are not really on equal terrain. However it has to be clearly noted
+that Intel nevertheless has the better performance per watt which is probably due
to the more single workload focused architecture and higher base frequency.
-It shows though that the TDP alone might be a confusing indicator if energy is your
+It shows though that the TDP alone might be a confusing indicator if energy is your
concern, as it heavily depends on how the processor architecture really is, how the workload
is and also how the CPU / system is configured.
**Important note:** The White Paper is from 2011 and when looking at the current site from
Intel regarding TDP their definition reads a bit differently: [Intel TDP landing page](https://www.intel.com/content/www/us/en/support/articles/000055611/processors.html)
-It is unclear if the definition really changed or just the wording is a bit different due
+It is unclear if the definition really changed or just the wording is a bit different due
to a different author / department.
## Comparing TDPs and summary
diff --git a/content/blog/updating-dc-measurement.md b/content/blog/updating-dc-measurement.md
index 662d71e..5a2877c 100644
--- a/content/blog/updating-dc-measurement.md
+++ b/content/blog/updating-dc-measurement.md
@@ -9,7 +9,7 @@ authorlink: "https://www.linkedin.com/in/arne-tarara"
In my last blog post I have written about how we finally completed the DC measurement
reporter for our [Green Metrics Tool](https://github.com/green-coding-berlin/green-metrics-tool).
-In the last days we have looked at reducing the variance of the ATX powerlanes
+In the last days we have looked at reducing the variance of the ATX powerlanes
and finding out if swapping out the resistors for more stable current measurement
resistors can improve the measurement.
@@ -20,13 +20,13 @@ Here are the results!
- We are now using [**Isabellenhütte PBV 0,005 Ohm**](https://www.conrad.de/de/p/isabellenhuette-pbv-0-005-messwiderstand-0-005-10-w-l-x-b-x-h-22-x-4-x-17-mm-1-st-447366.html?searchType=SearchRedirect) current measurement resistors
- We have swapped out all the wiring and replaced it with new wiring that has matching resistances for every connection.
+ The lines connecting the two inner terminals of the current resistors are with **0.9 Ohm wires**
- + The lines connectiong the two outer terminals are connected with **1.7 Ohm wires**.
+ + The lines connectiong the two outer terminals are connected with **1.7 Ohm wires**.
+ Accuracy on the measurement is **+/- 0.1 Ohms**
-
+
## Adding the remaining lines on the ATX connector
In the PoC of our last blog post we have concentrated on the six 12 V power lines of the ATX connector.
-The connector however features 4 more slots, where one slot however is not connected with the
+The connector however features 4 more slots, where one slot however is not connected with the
PSU.
{{< rawhtml >}}
@@ -45,19 +45,19 @@ drop at least one of these lines.
We measured the **PS_ON pin** and got a minimal reading of **~ 20 mV** out of it. This pin is only
really needed to be connected on boot and seems to be irrelevant for the measurments.
-As well in functionality as also in the power that it consumes.
+As well in functionality as also in the power that it consumes.
So we could included the **11Vsb** and the **PWR_OK** in our measurements.
However when looking at the screenshots of the readouts you see that they do not really contribute
to the total power. This was expected for PWR_OK (apart from an error case maybe),
-but may not be the case for the 11Vsb.
+but may not be the case for the 11Vsb.
Depending on what device you have attached and how the mainboard wiring is done there could be a power draw on this line.
-However in our internal measurements we have not seen any power draw over that line and since
-it is kept on a stable voltage it clashes with the behaviour of our input channel.
-The input channel was constantly giving out a stable reading of a negative voltage over the
+However in our internal measurements we have not seen any power draw over that line and since
+it is kept on a stable voltage it clashes with the behaviour of our input channel.
+The input channel was constantly giving out a stable reading of a negative voltage over the
current resistor although no current was flowing.
To quickly falsify our assumption we checked with our AC power readings on a simple wall socket power meter
@@ -88,7 +88,7 @@ You can compare the measurements here:
{{< /rawhtml >}}
-As suggested in our previous post the 12 V lines are internally not all wired to the same
+As suggested in our previous post the 12 V lines are internally not all wired to the same
channel, but are split in two rails.
This is also seen in modern sytems, where the [P4 connector](https://en.wikipedia.org/wiki/ATX) can provide a second
@@ -99,7 +99,7 @@ Why Fujitsu made the decision to split every 12 V rail in three cables we might
By making a short stress test with `stress -c 10` and `stress -m 10` we see that the one rail gets
more loaded on a CPU intensive load and the other rail more on a memory intensive load.
-They are so distinguishable that by just looking at rail #1 one can tell if the DRAM is accessed. However
+They are so distinguishable that by just looking at rail #1 one can tell if the DRAM is accessed. However
the direction the other way round does not hold. Rail #2 is also loaded, cause obvioulsy the CPU has to feed the DRAM.
Nevertheless this insight might pose an interesting starting point for an algorithmic or ML detection of what kind of load is happening.
@@ -108,7 +108,7 @@ Nevertheless this insight might pose an interesting starting point for an algori
The total energy consumed with the new setup is very close to the old measurement with the old resistors.
-Compare the readings on:
+Compare the readings on:
- [Old Resitors Measurement](https://metrics.green-coding.io/stats.html?id=f99e563d-2c5c-453d-99fe-5ac9f6f307ac)
- [New Resitors Measurement](https://metrics.green-coding.io/stats.html?id=7f4e2725-d84b-4992-aeb7-5f42f797aa73)
diff --git a/content/blog/usability-study-of-the-green-metrics-tool.md b/content/blog/usability-study-of-the-green-metrics-tool.md
index 8678813..410289b 100644
--- a/content/blog/usability-study-of-the-green-metrics-tool.md
+++ b/content/blog/usability-study-of-the-green-metrics-tool.md
@@ -7,7 +7,7 @@ authorlink: "https://www.linkedin.com/in/arne-tarara"
---
-We recently had a team of aspiring UX researches at Green Coding Berlin that
+We recently had a team of aspiring UX researches at Green Coding Solutions that
made a research project on how the Green Metrics Tool can be used.
This is a guest article with their results
@@ -117,10 +117,10 @@ We try to reduce the cognitive load of choices, show the info I need to know fir
## 10 DEFINING THE USER
We defined our user persona, as a 32 years guy that is starting his career as a web developer named *Joao*. *Joao* wants to be able to *reduce the damage that he does to the environment by working in tech* but feels *frustrated about not knowing which tools or methods are inside his range of action*. He heard about **Green Coding** and would like to get to know about them and *How it works* so he can be able to use the *Green Metrics Tool* and support the cause.
-From here, *Joao* will approach the website by the following flow:
-1. Starting at the Homepage to get to know Green Coding and its Community and get interested in knowing about their *Green List*.
-2. Once at the *Green List* page, *Joao* will check the *Dashboard* of the *Github Links* that have been already provided by other users and measured by **Green Coding**. This will increase his interest in getting to know about other measurements such as *Energy* and *CPU*.
-3. He decides to get deeper and check on two different links to enable the *Comparison* page, where he can see the two links and individual measurements being compared.
+From here, *Joao* will approach the website by the following flow:
+1. Starting at the Homepage to get to know Green Coding and its Community and get interested in knowing about their *Green List*.
+2. Once at the *Green List* page, *Joao* will check the *Dashboard* of the *Github Links* that have been already provided by other users and measured by **Green Coding**. This will increase his interest in getting to know about other measurements such as *Energy* and *CPU*.
+3. He decides to get deeper and check on two different links to enable the *Comparison* page, where he can see the two links and individual measurements being compared.
4. That's when he decided to check on *How it works*, to be able to participate and provide a link by himself, read some information about the functionality of the Tool, and see a global picture of the issue that is being taken on.
{{< rawhtml >}}
diff --git a/content/blog/version-0.1-beta.md b/content/blog/version-0.1-beta.md
index a7b65c9..8fb1d08 100644
--- a/content/blog/version-0.1-beta.md
+++ b/content/blog/version-0.1-beta.md
@@ -20,10 +20,10 @@ Today we have have released the `0.1-beta` version of our [Green Metrics Tool](h
Version `0.1-beta` is considered a non-production version.
-We are currently working on the falsification of our energy measurements with public
+We are currently working on the falsification of our energy measurements with public
energy measurement databases.
-Also we will add functionality to compare measurements directly in the frontend as
+Also we will add functionality to compare measurements directly in the frontend as
well as a better install script to quickstart the tool.
The biggest part of work currently for us is the documentation which we are working
@@ -41,14 +41,14 @@ If you want to query the Open Data of our tool go to the [self-documenting API](
## Measurements of the tool
-On our [Metrics Dashboard](https://metrics.green-coding.io/) you can find already some measurements we did on
+On our [Metrics Dashboard](https://metrics.green-coding.io/) you can find already some measurements we did on
a copy of the [The Green Web Foundation](https://www.thegreenwebfoundation.org/) website.
Here we compare the energy consumption of a Wordpress version against a static version.
- Static: https://metrics.green-coding.io/stats.html?id=a57a7f97-be18-4a77-b7fe-ae0d76b5e4dd
- Wordpress: https://metrics.green-coding.io/stats.html?id=619e720e-f2fc-42fa-9786-c13cb4d9fb72
-An example on how to recreate these dashboards and also dive into the raw data to
+An example on how to recreate these dashboards and also dive into the raw data to
answer more detailed questions we provide [Example Jupyter Notebooks](https://metrics.green-coding.io/data-analysis.html)
diff --git a/content/blog/we-are-hiring.md b/content/blog/we-are-hiring.md
index 1766ff1..6ab1e68 100644
--- a/content/blog/we-are-hiring.md
+++ b/content/blog/we-are-hiring.md
@@ -9,7 +9,7 @@ authorlink: "https://www.linkedin.com/in/arne-tarara"
Today we have big news which shine a light on what we have planned for the coming months.
-Green Coding Berlin is becoming a legal entity in form of a non-profit [Green Coding Berlin gGmbH].
+Green Coding Solutions is becoming a legal entity in form of a non-profit [Green Coding Solutions gGmbH].
We recently joined the Green Software Foundation (https://greensoftware.foundation/) as a General Member and, apart from our meetups and the planned workshop, will be developing a metrics and certification toolchain for Green Software.
diff --git a/content/blog/youtube-extension.md b/content/blog/youtube-extension.md
index 5d87546..fa271a8 100644
--- a/content/blog/youtube-extension.md
+++ b/content/blog/youtube-extension.md
@@ -12,7 +12,7 @@ authorlink: "https://www.linkedin.com/in/alexandre-oliv"
How many times do we use Youtube only to listen to songs, or to watch videos without the necessity of going for that fancy 4k/HD resolution? Also: do we really want to automatically watch other (algorithmically-chosen) videos after the current video is finished? In other words, how can we have a carbon-friendly approach while still getting the content we wanted?
-During the onboarding process at Green Coding Berlin, I was given the task of creating a simple Chrome extension that would turn off the Autoplay feature of Youtube, and would also scale down the videos to the lowest available quality.
+During the onboarding process at Green Coding Solutions, I was given the task of creating a simple Chrome extension that would turn off the Autoplay feature of Youtube, and would also scale down the videos to the lowest available quality.
diff --git a/content/case-studies/DRAFT-turbo-boost-and-energy.md b/content/case-studies/DRAFT-turbo-boost-and-energy.md
new file mode 100644
index 0000000..c614eea
--- /dev/null
+++ b/content/case-studies/DRAFT-turbo-boost-and-energy.md
@@ -0,0 +1,186 @@
+---
+title: "Turbo Boost and energy - Processor energy configuration series - Part 2"
+draft: false
+date: 2023-03-02
+author: "Arne Tarara"
+authorlink: "https://www.linkedin.com/in/arne-tarara"
+---
+
+- Turning ON deep c-states. This might increase startup-latency of some workloads, but since Cores can not only go into one fixed Turbo Boost frequency, but actually if only SOME cores go into a stronger Turbo Boost, then they can reach even higher frequencies! So if you have a workload that is single or low-threaded you can profit from extraordinary high frequencies that you might never see when all cores are always running on higher frequencies.
+ - Source: https://www.vmware.com/explore/video-library/video-landing.html?sessionid=1686331461690001FeTn&videoId=6340661293112
+
+{{< infobox >}}
+ This arcticle is part of a multi-part series. Be sure to check out / stay tuned for the other parts!
+ In this series we look at processor configuration options either from the OS side or directly
+ in MSRs of the CPU and their effect on the power draw of the CPU.
+{{< /infobox >}}
+
+[Turbo Boost](https://en.wikipedia.org/wiki/Intel_Turbo_Boost) is the branded name from Intel for a technology called Dynamic Frequency and Voltage Scaling (DVFS).
+
+DVFS is available in every modern Intel or AMD CPU. the name in AMD CPUs is [Turbo Core](https://en.wikipedia.org/wiki/AMD_Turbo_Core)
+
+Turbo Boost can be checked through the linux subsystem, but also by querying the CPU registers directly.
+
+You can find a script to check if Turbo Boost is on or off on your system in our [Github Tools](https://github.com/green-coding-berlin/tools/blob/main/turbo_boost.sh) repository.
+
+Turbo Boost as a feature enables the processor to overshoot it's base frequency for a certain amount of time. This enables snappy responsiveness when instantaneous load happens.
+
+The downside of the feature is that it uses often exponentially more energy and can be detremential to energy cost of the system as a whole.
+
+The question that arises for someone who is doing research in software energy consumption is:
+- How much energy / power does Turbo Boost / SMT need to provide it's functionality?
+- What are the drawbacks of Turbo Boost?
+- What speed achievements can I achieve?
+- Should I turn Turbo Boost off when when energy is my primary concern?
+- Does it help "running" to the completion of my calculation and then turn off? (Race to sleep)
+
+## Energy test
+
+Our test machine is a MacBook Pro 13" 2015 model with a Intel Core i7-5557U CPU @ 3.1 GHz.
+
+According to `/proc/cpuinfo` this chip has 2 physical cores (found by looking at max. **core id** number) and 4 threads
+(found by looking at max. **processor** number).
+
+Looking at **flags** we see that **ht** is a feature, which corresponds to Hyper-Threading.
+
+In order to have a first glimpse at the energy characterisitcs of this feature we are using
+`sysbench`, which you can just install through **aptitude** on **Ubuntu 22.04**.
+
+The command we ran in `sysbench` is:
+
+```bash
+./turbo_boost.sh disable
+sleep 180
+perf stat -a -e power/energy-pkg/ sysbench --cpu-max-prime=10000 --threads=48 --test=cpu --events=300000 --time=0 run
+./turbo_boost.sh enable
+sleep 180
+perf stat -a -e power/energy-pkg/ sysbench --cpu-max-prime=10000 --threads=48 --test=cpu --events=300000 --time=0 run
+```
+
+The command always runs for **10 s** fixed. What we modified during the runs is the **--threads** argument
+as seen in the following table.
+
+This is the result:
+
+{{< table class="ui table" >}}
+| Turbo Boost On/Off | Blockheating (Time) | Blockheating (Energy) | MacBook Pro 13" (Time) | MacBook Pro 13" (Energy) | Fujitsu TX1330 (Time) | Fujitsu TX1330 (Energy) |
+|:-----------:|:----------:|:----------:|:---------:|:---------:|:---------:|:---------:|
+| On | 10,13 s | 1635,11 J | 93,477 s | 1482,08 J | 68,1 s | 958,66 J |
+| On | 10,13 s | 1636,11 J | 93,87 s | 1476,85 J | 68,34 s | 964,73 J |
+| On | 10,14 s | 1640,56 J | 93,48 s | 1484,34 J | 68,36 s | 967,26 J |
+| **AVG** | **10,13 s** | **1637,26 J** | **93,609 s** | **1481,09 J** | **68,26 s** | **963,55 J** |
+| **STDDEV** | **0,0058** | **2,9013** | **0,226** | **3,8419** | **0,1447** | **4,4198** |
+| **STDDEV %** | **0,057** | **0,1772** | **0,2415** | **0,2594** | **0,2119** | **0,4587** |
+| | | | | | | |
+| | | | | | | |
+| On | 8,76 s | 1744,58 J | 86,84 s | 1781,17 J | 49,122 s | 1315,72 J |
+| On | 8,76 s | 1742,85 J | 87,26 s | 1782,25 J | 49,12 s | 1315,33 J |
+| On | 8,77 s | 1747,99 J | 85,95 s | 1782,09 J | 49,09 s | 1313,75 J |
+| **AVG** | **8,76 s** | **1745,14 J** | **86,68 s** | **1781,84 J** | **49,11 s** | **1314,93 J** |
+| **STDDEV** | **0,0058** | **2,6154** | **0,6689** | **0,5829** | **0,0179** | **1,0432** |
+| **STDDEV %** | **0,0659** | **0,1499** | **0,7717** | **0,0327** | **0,0365** | **0,0793** |
+| | | | | | | |
+| | | | | | | |
+| **Increase / Decrease** | **86,48 %** | **106,59 %** | **92,6 %** | **120,31 %** | **71,94 %** | **136,47 %** |
+
+
+
+
+{{}}
+
+
+An important question is however also: How does this compare in a real-world use-case? Will results be the same?
+
+We picked the Unit-Tests of the Django project (https://github.com/green-coding-berlin/example-applications/tree/main/django_tests)
+and run the tests with Turbo-boost off and on.
+
+Important: If you have Turbo-Boost off and you have high loads on Hard-Disks the cut-off point when it makes sense to
+turn on / off Turbo Boost will occur earlier.
+
+In a [Django Unit-Test run with Turbo Boost On](https://metrics.green-coding.io/stats.html?id=48bec2ad-7bb6-4278-bed9-4b4f9afa606e) we see that the CPU-Package power is at **21.3 W** and equates over
+the runtime of **171 s** to an energy budget of **3645.30 J**.
+
+For the [Django Unit-Test run with Turbo Boost Off](https://metrics.green-coding.io/stats.html?id=b93ad091-4c70-447b-a828-598672c96d6e) we see that the CPU-Package power is at **12.87 W** and equates over
+the runtime of **218 s** to an energy budget of **2805.90 J**.
+
+So even in this real-world scenarios we see here that Turbo-Boost is a detremential feature when looking at the CPU
+Energy cost.
+However, this is not the whole story.
+
+When looking at energy costs you always have to expand the picture as much as you can:
+- How much auxilliary devices are running that also consume power?
+ + HDDs
+ + SDDs
+ + RAM
+ + etc.
+
+We see that the the CPU Package power dropped from 21.3 W -> 12.87 W (39.5 % reduction), but looking at the whole machine (*psu_power_ac_powerspy2_system*)
+we see that the drop is not that significant 42.17 W -> 32.62 W (22.64 % reduction).
+This makes perfect sense, as the CPU is only a part of the whole machine and the other components still run and are
+not affected by Turbo Boost.
+
+We see in this particular case, that the gain is still beneficial. The total energy (*psu_energy_ac_powerspy2_system*) for
+the Turbo Boost Off case is still lower (7113.10 J vs. 7215.67 J)
+
+If you are however in a datacenter, where the system is maybe externally cooled AND the cooling could be turned off if the
+machine can also be turned off, then you would have a case where it would make sense to have Turbo Boost turned on
+for this particular hardware setup.
+
+So you always have to make the scope as wide as you reasonably can and include all parts you use energy for.
+
+A
+
+
+As seen in the charts and the table Hyper-Threading on our Intel CPU on the test bench
+is always able to deliver more operations per 10 seconds.
+
+The energy with Hyper-Threading turned on exceeds the total amount of the non-Hyper-Threading configuration
+of the chip when using 3 cores or more.
+This was not necessarily expected ... it could also have been that the chip somehow throttles the performance
+but uses a constant energy budget..
+
+The other interesting metric is the mJ / Ops metric. Here we can see that Hyper-Threading
+actually is more energy efficient per operation than running the system
+only with physical cores.
+
+
+## Discussion
+The results are quite suprising as Hyper-Threading used to have a bit of a bad rep.
+
+For instance [this article from Percona](https://www.percona.com/blog/2015/01/15/hyper-threading-double-cpu-throughput/) comes to the conclusion that Hyper-Threading has rather
+throttling features and typically is more suitable for low utilization workloads.
+
+Also [Hyper-Threading has potential security issues](https://www.theregister.com/2019/10/29/intel_disable_hyper_threading_linux_kernel_maintainer/) although the current state
+and if it relevant in real world setups is not quite clear to us.
+
+Another factor to keep into consideration is that Hyper-Threading by theory reduced the
+latency of your system when a task is picked up.\
+This makes perfect sense, as you introduce another scheduling layer.\
+However since a normal Linux installation is anyway not real-time workload optimized
+this factor might not weigh very high.
+
+All in all we are very suprised about how energy friendly the feature is and especially
+for the typical server workloads that are rather multi-threaded and mostly idling.
+Since Hyper-Threading seems to have no effect on idle CPUs this seems like a perfect fit.
+
+Since Hyper-Threading is by default turned on, and also every server in the SPECPower database
+has it turned on we see no reason to run benchmarks that should reflect CPU capabilities with
+Hyper-Threading turned off.
+
+
+
+
+So what is the conclusion? Machines should be setup like this in on-premise environments.
+Then, if it is time to buy a new machine, because the current amount of machines cannot handle the amount of tasks anymore
+it should first be checked what the uptake of buying this machine is
+
+If you can somehow quantify the time that you are loosing in energy, than make a trade-off calculation.
+
+If you would be buing new machines, then trade-off.
+
+If you typically have long idle or even shutdown periods in between and there is no good reason why
+the calculation should be faster (which is often the case for many tasks in a system) -> off
+
+
+
+Did we miss something? Please shoot us an email to [info@green-coding.io](mailto:info@green-coding.io)
\ No newline at end of file
diff --git a/content/case-studies/cpu-power-capping.md b/content/case-studies/cpu-power-capping.md
index 817f9c1..e927fed 100644
--- a/content/case-studies/cpu-power-capping.md
+++ b/content/case-studies/cpu-power-capping.md
@@ -16,7 +16,7 @@ socialmedia_preview: "img/social-media-previews/cpu-power-capping.webp"
Power Capping is feature that will artifically limit the electrically supplied power of a hardware component with the intention of making it less warm and / or using less electrical power draw.
-This feature has been featured in some recent publications that focus on AI trainings on GPUs with the intention of getting the
+This feature has been featured in some recent publications that focus on AI trainings on GPUs with the intention of getting the
energy consumption for their training down. [[1]](#sources) [[2]](#sources) [[3]](#sources)
Since most compute workloads for transactional and operational work is still done on CPUs they make up a significant
@@ -110,7 +110,7 @@ sudo apt install sysbench # we need this for a testing workload
Once everything is installed you can check if the data can be read by issueing:
```console
$ ls /sys/class/powercap/intel-rapl/
-enabled intel-rapl:0 power subsystem uevent
+enabled intel-rapl:0 power subsystem uevent
# There should be a directory named intel-rapl:0 which represents your one installed CPU chip
$ cat /sys/class/powercap/intel-rapl/intel-rapl:0/name
@@ -145,10 +145,10 @@ Now we can modify the power capping of the system live by just writing to these
If, for example, we want to limit the power draw to **10 W** we issue:
```console
-$ echo "10000000" | sudo tee /sys/class/powercap/intel-rapl/intel-rapl:0/constraint_0_power_limit_uw
+$ echo "10000000" | sudo tee /sys/class/powercap/intel-rapl/intel-rapl:0/constraint_0_power_limit_uw
# Set 10 W long_term
-$ echo "10000000" | sudo tee /sys/class/powercap/intel-rapl/intel-rapl:0/constraint_1_power_limit_uw
+$ echo "10000000" | sudo tee /sys/class/powercap/intel-rapl/intel-rapl:0/constraint_1_power_limit_uw
# Set 10 W short_term
```
@@ -212,7 +212,7 @@ Threads fairness:
events (avg/stddev): 2214.6250/1.32
execution time (avg/stddev): 10.0011/0.00
-...
+...
```
@@ -220,7 +220,7 @@ We are now trying the benchmark with factory default (long_term is capped to **3
{{< table class="ui table" >}}
-| Power Cap | Time (s) | Events | Energy CPU Package (J) |
+| Power Cap | Time (s) | Events | Energy CPU Package (J) |
|:---------------:|:------------------:|:------:|:----------------------:|
| Factory default | 8.478750 +- 0.01% | 15000 | 190.67 +- 0.19% |
| 100% | 8.478520 +- 0.02% | 15000 | 190.75 +- 0.02% |
@@ -241,7 +241,7 @@ Here we see that around **80%** there seems to be a sweet spot where the power s
An important question is now: How does this compare in a real-world use-case? And how are the results to be interpreted when we do look at the whole machine and not only the CPU? What happens if we factor in embodied carbon? Will results be the same?
For this we are using our [Green Metrics Tool](/projects/green-metrics-tool/) and are measuring the unit test of the [Django](https://github.com/green-coding-berlin/django
-) project. This is by design a **event-fixed** workload also.
+) project. This is by design a **event-fixed** workload also.
We have put all measurements online on the [Green Metrics Tool Dashboard](https://metrics.green-coding.io/timeline.html?uri=https://github.com/green-coding-berlin/django&filename=usage_scenario.yml&branch=main&machine_id=6&start_date=2023-12-01&end_date=2023-12-02)
{{< rawhtml >}}
@@ -273,7 +273,7 @@ We have put all measurements online on the [Green Metrics Tool Dashboard](https:
{{< /rawhtml >}}
-The different coloring in the charts show the different power cappings.
+The different coloring in the charts show the different power cappings.
- *Green* is **100%**
- *Red* is **80%**
- *Violet* is **60%**
diff --git a/content/case-studies/cpu-utilization-usefulness.md b/content/case-studies/cpu-utilization-usefulness.md
index 0f6f4e5..ee5488e 100644
--- a/content/case-studies/cpu-utilization-usefulness.md
+++ b/content/case-studies/cpu-utilization-usefulness.md
@@ -190,7 +190,7 @@ So taking a normal **Ubuntu 22.04** system on a **Fujitsu Esprimo 956** **4-Core
{{< /rawhtml >}}
-In this case study we will look the carbon benefit of a static site.
+In this case study we will look the carbon benefit of a static site.
-Site generators like [HUGO](https://www.gohugo.io) are currently all the hype. The idea is to write your website in simple markdown but still benefit from nice styling and templating.
+Site generators like [HUGO](https://www.gohugo.io) are currently all the hype. The idea is to write your website in simple markdown but still benefit from nice styling and templating.
The result will be a one-time generated page which saves server compute resources, is faster to deliver and, hopefully, also save carbon emissions.
@@ -33,7 +33,7 @@ Also we will talk about hosting, as we will see that just moving your site to Wo
+ We will spin up the basic wordpress with the same template and just make a request to the root page
-- CURL vs. Firefox
+- CURL vs. Firefox
- Exclude functionality for containers in measurement!
@@ -184,13 +184,13 @@ Also we will talk about hosting, as we will see that just moving your site to Wo
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+
+
+
+
+
+
-
-
-
-
-
-
-
- 
-
-
-
- Arne Tarara
-
-
-
- 
-
-
-
- Dan Mateas
-
-
-
- 
-
-
-
- Didi Hoffmann
- 
- 
- 
- 
- 
- 
