:wrench: remove codecarbon install, add slightly modified codecarbon pkg to repo

codecarbon/__init__.py

@@ -0,0 +1,13 @@
+"""
+The Carbon Tracker module. The following objects/decorators belong to the Public API
+"""
+
+from ._version import __version__  # noqa
+from .emissions_tracker import (
+    EmissionsTracker,
+    OfflineEmissionsTracker,
+    track_emissions,
+)
+
+__all__ = ["EmissionsTracker", "OfflineEmissionsTracker", "track_emissions"]
+__app_name__ = "codecarbon"

codecarbon/_version.py

@@ -0,0 +1 @@
+__version__ = "3.0.2"

codecarbon/cli/cli_utils.py

@@ -0,0 +1,110 @@
+import configparser
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.prompt import Confirm
+
+
+def get_config(path: Optional[Path] = None):
+    p = path or Path.cwd().resolve() / ".codecarbon.config"
+
+    if p.exists():
+        config = configparser.ConfigParser()
+        config.read(str(p))
+        if "codecarbon" in config.sections():
+            d = dict(config["codecarbon"])
+            return d
+
+    else:
+        raise FileNotFoundError(
+            "No .codecarbon.config file found in the current directory."
+        )
+
+
+def get_api_endpoint(path: Optional[Path] = None):
+    p = path or Path.cwd().resolve() / ".codecarbon.config"
+    if p.exists():
+        config = configparser.ConfigParser()
+        config.read(str(p))
+        if "codecarbon" in config.sections():
+            d = dict(config["codecarbon"])
+            if "api_endpoint" in d:
+                return d["api_endpoint"]
+            else:
+                with p.open("a") as f:
+                    f.write("api_endpoint=https://api.codecarbon.io\n")
+    return "https://api.codecarbon.io"
+
+
+def get_existing_local_exp_id(path: Optional[Path] = None):
+    p = path or Path.cwd().resolve() / ".codecarbon.config"
+    if p.exists():
+        existing_path = p
+    else:
+        existing_path = Path("~/.codecarbon.config").expanduser()
+    return _get_local_exp_id(existing_path)
+
+
+def _get_local_exp_id(p: Optional[Path] = None):
+    config = configparser.ConfigParser()
+    config.read(str(p))
+    if "codecarbon" in config.sections():
+        d = dict(config["codecarbon"])
+        if "experiment_id" in d:
+            return d["experiment_id"]
+
+
+def write_local_exp_id(exp_id, path: Optional[Path] = None):
+    p = path or Path.cwd().resolve() / ".codecarbon.config"
+
+    config = configparser.ConfigParser()
+    if p.exists():
+        config.read(str(p))
+    if "codecarbon" not in config.sections():
+        config.add_section("codecarbon")
+
+    config["codecarbon"]["experiment_id"] = exp_id
+
+    with p.open("w") as f:
+        config.write(f)
+
+
+def overwrite_local_config(config_name, value, path: Optional[Path] = None):
+    p = path or Path.cwd().resolve() / ".codecarbon.config"
+
+    config = configparser.ConfigParser()
+    if p.exists():
+        config.read(str(p))
+    if "codecarbon" not in config.sections():
+        config.add_section("codecarbon")
+
+    config["codecarbon"][config_name] = value
+    with p.open("w") as f:
+        config.write(f)
+
+
+def create_new_config_file():
+    typer.echo("Creating new config file")
+    file_path = typer.prompt(
+        "Where do you want to put your config file ?",
+        type=str,
+        default="~/.codecarbon.config",
+    )
+    if file_path[0] == "~":
+        file_path = Path.home() / file_path[2:]
+    else:
+        file_path = Path(file_path)
+
+    if not file_path.parent.exists():
+        create = Confirm.ask(
+            "Parent folder does not exist do you want to create it (and parents) ?"
+        )
+        if create:
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+
+    file_path.touch()
+    with open(file_path, "w") as f:
+        f.write("[codecarbon]\n")
+    typer.echo(f"Config file created at {file_path}")
+    return file_path

codecarbon/cli/main.py

@@ -0,0 +1,381 @@
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+import questionary
+import requests
+import typer
+from fief_client import Fief
+from fief_client.integrations.cli import FiefAuth
+from rich import print
+from rich.prompt import Confirm
+from typing_extensions import Annotated
+
+from codecarbon import __app_name__, __version__
+from codecarbon.cli.cli_utils import (
+    create_new_config_file,
+    get_api_endpoint,
+    get_config,
+    get_existing_local_exp_id,
+    overwrite_local_config,
+)
+from codecarbon.core.api_client import ApiClient, get_datetime_with_timezone
+from codecarbon.core.schemas import ExperimentCreate, OrganizationCreate, ProjectCreate
+from codecarbon.emissions_tracker import EmissionsTracker
+
+AUTH_CLIENT_ID = os.environ.get(
+    "AUTH_CLIENT_ID",
+    "jsUPWIcUECQFE_ouanUuVhXx52TTjEVcVNNtNGeyAtU",
+)
+AUTH_SERVER_URL = os.environ.get(
+    "AUTH_SERVER_URL", "https://auth.codecarbon.io/codecarbon"
+)
+API_URL = os.environ.get("API_URL", "https://dashboard.codecarbon.io/api")
+
+DEFAULT_PROJECT_ID = "e60afa92-17b7-4720-91a0-1ae91e409ba1"
+DEFAULT_ORGANIzATION_ID = "e60afa92-17b7-4720-91a0-1ae91e409ba1"
+
+codecarbon = typer.Typer(no_args_is_help=True)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        print(f"{__app_name__} v{__version__}")
+        raise typer.Exit()
+
+
+@codecarbon.callback()
+def main(
+    version: Optional[bool] = typer.Option(
+        None,
+        "--version",
+        "-v",
+        help="Show the application's version and exit.",
+        callback=_version_callback,
+        is_eager=True,
+    ),
+) -> None:
+    return
+
+
+def show_config(path: Path = Path("./.codecarbon.config")) -> None:
+    d = get_config(path)
+    api_endpoint = get_api_endpoint(path)
+    api = ApiClient(endpoint_url=api_endpoint)
+    api.set_access_token(_get_access_token())
+    print("Current configuration : \n")
+    print("Config file content : ")
+    print(d)
+    try:
+        if "organization_id" not in d:
+            print(
+                "No organization_id in config, follow setup instruction to complete your configuration file!",
+            )
+        else:
+            org = api.get_organization(d["organization_id"])
+
+            if "project_id" not in d:
+                print(
+                    "No project_id in config, follow setup instruction to complete your configuration file!",
+                )
+            else:
+                project = api.get_project(d["project_id"])
+                if "experiment_id" not in d:
+                    print(
+                        "No experiment_id in config, follow setup instruction to complete your configuration file!",
+                    )
+                else:
+                    experiment = api.get_experiment(d["experiment_id"])
+                    print("\nExperiment :")
+                    print(experiment)
+                    print("\nProject :")
+                    print(project)
+                    print("\nOrganization :")
+                    print(org)
+    except Exception as e:
+        raise ValueError(
+            f"Your configuration is invalid, please verify your configuration file at {path}. To start from scratch, run `codecarbon config` and overwrite your configuration file. (error: {e})"
+        )
+
+
+def get_fief_auth():
+    fief = Fief(AUTH_SERVER_URL, AUTH_CLIENT_ID)
+    fief_auth = FiefAuth(fief, "./credentials.json")
+    return fief_auth
+
+
+def _get_access_token():
+    try:
+        access_token_info = get_fief_auth().access_token_info()
+        access_token = access_token_info["access_token"]
+        return access_token
+    except Exception as e:
+        raise ValueError(
+            f"Not able to retrieve the access token, please run `codecarbon login` first! (error: {e})"
+        )
+
+
+def _get_id_token():
+    id_token = get_fief_auth()._tokens["id_token"]
+    return id_token
+
+
+@codecarbon.command(
+    "test-api", short_help="Make an authenticated GET request to an API endpoint"
+)
+def api_get():
+    """
+    ex: test-api
+    """
+    api = ApiClient(endpoint_url=API_URL)  # TODO: get endpoint from config
+    api.set_access_token(_get_access_token())
+    organizations = api.get_list_organizations()
+    print(organizations)
+
+
+@codecarbon.command("login", short_help="Login to CodeCarbon")
+def login():
+    get_fief_auth().authorize()
+    api = ApiClient(endpoint_url=API_URL)  # TODO: get endpoint from config
+    id_token = _get_id_token()
+    api.set_access_token(id_token)
+    api.check_auth()
+
+
+def get_api_key(project_id: str):
+    req = requests.post(
+        f"{API_URL}/projects/{project_id}/api-tokens",
+        json={
+            "project_id": project_id,
+            "name": "api token",
+            "x_token": "???",
+        },
+        headers={"Authorization": f"Bearer {_get_access_token()}"},
+    )
+    api_key = req.json()["token"]
+    return api_key
+
+
+@codecarbon.command("get-token", short_help="Get project token")
+def get_token(project_id: str):
+    # api = ApiClient(endpoint_url=API_URL) # TODO: get endpoint from config
+    # api.set_access_token(_get_access_token())
+    token = get_api_key(project_id)
+    print("Your token: " + token)
+    print("Add it to the api_key field in your configuration file")
+
+
+@codecarbon.command("config", short_help="Generate or show config")
+def config():
+    """
+    Initialize CodeCarbon, this will prompt you for configuration of Organisation/Team/Project/Experiment.
+    """
+
+    print("Welcome to CodeCarbon configuration wizard")
+    home = Path.home()
+    global_path = (home / ".codecarbon.config").expanduser().resolve()
+
+    if global_path.exists():
+        print("Existing global config file found :")
+        show_config(global_path)
+
+        use_config = questionary_prompt(
+            "Use existing global ~/.codecarbon.config to configure or create a new file somewhere else ?",
+            ["~/.codecarbon.config", "Create New Config"],
+            default="~/.codecarbon.config",
+        )
+
+        if use_config == "~/.codecarbon.config":
+            modify = Confirm.ask("Do you want to modify the existing config file ?")
+            if modify:
+                print(f"Modifying existing config file {global_path}:")
+                file_path = global_path
+            else:
+                print(f"Using already existing global config file {global_path}")
+
+                return
+        else:
+            file_path = create_new_config_file()
+    else:
+        file_path = create_new_config_file()
+
+    api_endpoint = get_api_endpoint(file_path)
+    api_endpoint = typer.prompt(
+        f"Current API endpoint is {api_endpoint}. Press enter to continue or input other url",
+        type=str,
+        default=api_endpoint,
+    )
+    overwrite_local_config("api_endpoint", api_endpoint, path=file_path)
+    api = ApiClient(endpoint_url=api_endpoint)
+    api.set_access_token(_get_access_token())
+    organizations = api.get_list_organizations()
+    org = questionary_prompt(
+        "Pick existing organization from list or Create new organization ?",
+        [org["name"] for org in organizations] + ["Create New Organization"],
+        default="Create New Organization",
+    )
+
+    if org == "Create New Organization":
+        org_name = typer.prompt("Organization name", default="Code Carbon user test")
+        org_description = typer.prompt(
+            "Organization description", default="Code Carbon user test"
+        )
+
+        organization_create = OrganizationCreate(
+            name=org_name,
+            description=org_description,
+        )
+        organization = api.create_organization(organization=organization_create)
+        if organization is None:
+            print("Error creating organization")
+            return
+        print(f"Created organization : {organization}")
+    else:
+        organization = [orga for orga in organizations if orga["name"] == org][0]
+    org_id = organization["id"]
+    overwrite_local_config("organization_id", org_id, path=file_path)
+
+    projects = api.list_projects_from_organization(org_id)
+    project_names = [project["name"] for project in projects] if projects else []
+    project = questionary_prompt(
+        "Pick existing project from list or Create new project ?",
+        project_names + ["Create New Project"],
+        default="Create New Project",
+    )
+    if project == "Create New Project":
+        project_name = typer.prompt("Project name", default="Code Carbon user test")
+        project_description = typer.prompt(
+            "Project description", default="Code Carbon user test"
+        )
+        project_create = ProjectCreate(
+            name=project_name,
+            description=project_description,
+            organization_id=org_id,
+        )
+        project = api.create_project(project=project_create)
+        print(f"Created project : {project}")
+    else:
+        project = [p for p in projects if p["name"] == project][0]
+    project_id = project["id"]
+    overwrite_local_config("project_id", project_id, path=file_path)
+
+    experiments = api.list_experiments_from_project(project_id)
+    experiments_names = (
+        [experiment["name"] for experiment in experiments] if experiments else []
+    )
+
+    experiment = questionary_prompt(
+        "Pick existing experiment from list or Create new experiment ?",
+        experiments_names + ["Create New Experiment"],
+        default="Create New Experiment",
+    )
+    if experiment == "Create New Experiment":
+        print("Creating new experiment")
+        exp_name = typer.prompt("Experiment name :", default="Code Carbon user test")
+        exp_description = typer.prompt(
+            "Experiment description :",
+            default="Code Carbon user test ",
+        )
+
+        exp_on_cloud = Confirm.ask("Is this experiment running on the cloud ?")
+        if exp_on_cloud is True:
+            cloud_provider = typer.prompt(
+                "Cloud provider (AWS, GCP, Azure, ...)", default="AWS"
+            )
+            cloud_region = typer.prompt(
+                "Cloud region (eu-west-1, us-east-1, ...)", default="eu-west-1"
+            )
+        else:
+            cloud_provider = None
+            cloud_region = None
+        country_name = typer.prompt("Country name :", default="Auto")
+        country_iso_code = typer.prompt("Country ISO code :", default="Auto")
+        region = typer.prompt("Region :", default="Auto")
+        if country_name == "Auto":
+            country_name = None
+        if country_iso_code == "Auto":
+            country_iso_code = None
+        if region == "Auto":
+            region = None
+        experiment_create = ExperimentCreate(
+            timestamp=get_datetime_with_timezone(),
+            name=exp_name,
+            description=exp_description,
+            on_cloud=exp_on_cloud,
+            project_id=project["id"],
+            country_name=country_name,
+            country_iso_code=country_iso_code,
+            region=region,
+            cloud_provider=cloud_provider,
+            cloud_region=cloud_region,
+        )
+        experiment = api.add_experiment(experiment=experiment_create)
+
+    else:
+        experiment = [e for e in experiments if e["name"] == experiment][0]
+
+    overwrite_local_config("experiment_id", experiment["id"], path=file_path)
+    api_key = get_api_key(project_id)
+    overwrite_local_config("api_key", api_key, path=file_path)
+    show_config(file_path)
+    print(
+        "Consult [link=https://mlco2.github.io/codecarbon/usage.html#configuration]configuration documentation[/link] for more configuration options"
+    )
+
+
+@codecarbon.command("monitor", short_help="Monitor your machine's carbon emissions.")
+def monitor(
+    measure_power_secs: Annotated[
+        int, typer.Argument(help="Interval between two measures.")
+    ] = 10,
+    api_call_interval: Annotated[
+        int, typer.Argument(help="Number of measures between API calls.")
+    ] = 30,
+    api: Annotated[
+        bool, typer.Option(help="Choose to call Code Carbon API or not")
+    ] = True,
+):
+    """Monitor your machine's carbon emissions.
+
+    Args:
+        measure_power_secs (Annotated[int, typer.Argument, optional): Interval between two measures. Defaults to 10.
+        api_call_interval (Annotated[int, typer.Argument, optional): Number of measures before calling API. Defaults to 30.
+        api (Annotated[bool, typer.Option, optional): Choose to call Code Carbon API or not. Defaults to True.
+    """
+    experiment_id = get_existing_local_exp_id()
+    if api:
+        if experiment_id is None:
+            print(
+                "ERROR: No experiment id, call 'codecarbon config' first.",
+                file=sys.stderr,
+            )
+    print("CodeCarbon is going in an infinite loop to monitor this machine.")
+    with EmissionsTracker(
+        measure_power_secs=measure_power_secs,
+        api_call_interval=api_call_interval,
+        save_to_api=api,
+    ) as tracker:
+        # Infinite loop
+        while True:
+            if (
+                hasattr(tracker, "_another_instance_already_running")
+                and tracker._another_instance_already_running
+            ):
+                print("Another instance of CodeCarbon is already running. Exiting.")
+                break
+            time.sleep(300)
+
+
+def questionary_prompt(prompt, list_options, default):
+    value = questionary.select(
+        prompt,
+        list_options,
+        default,
+    ).ask()
+    return value
+
+
+if __name__ == "__main__":
+    codecarbon()

codecarbon/core/api_client.py

@@ -0,0 +1,362 @@
+"""
+
+Based on https://kernelpanic.io/the-modern-way-to-call-apis-in-python
+
+TODO : use async call to API
+"""
+
+# from httpx import AsyncClient
+import dataclasses
+import json
+from datetime import timedelta, tzinfo
+
+import arrow
+import requests
+
+from codecarbon.core.schemas import (
+    EmissionCreate,
+    ExperimentCreate,
+    OrganizationCreate,
+    ProjectCreate,
+    RunCreate,
+)
+from codecarbon.external.logger import logger
+
+# from codecarbon.output import EmissionsData
+
+
+def get_datetime_with_timezone():
+    timestamp = str(arrow.now().isoformat())
+    return timestamp
+
+
+class ApiClient:  # (AsyncClient)
+    """
+    This class call the Code Carbon API
+    """
+
+    run_id = None
+
+    def __init__(
+        self,
+        endpoint_url="https://api.codecarbon.io",
+        experiment_id=None,
+        api_key=None,
+        access_token=None,
+        conf=None,
+        create_run_automatically=True,
+    ):
+        """
+        :endpoint_url: URL of the API endpoint
+        :experiment_id: ID of the experiment
+        :api_key: Code Carbon API_KEY
+        :access_token: Code Carbon API access token
+        :conf: Metadata of the experiment
+        :create_run_automatically: If False, do not create a run. To use API in read only mode.
+        """
+        # super().__init__(base_url=endpoint_url) # (AsyncClient)
+        self.url = endpoint_url
+        self.experiment_id = experiment_id
+        self.api_key = api_key
+        self.conf = conf
+        self.access_token = access_token
+        if self.experiment_id is not None and create_run_automatically:
+            self._create_run(self.experiment_id)
+
+    def _get_headers(self):
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            # set the x-api-token header
+            headers["x-api-token"] = self.api_key
+        elif self.access_token:
+            headers["Authorization"] = f"Bearer {self.access_token}"
+        return headers
+
+    def set_access_token(self, token: str):
+        """This method sets the access token to be used for the API.
+        Args:
+            token (str): access token to be used for the API
+        """
+        self.access_token = token
+
+    def check_auth(self):
+        """
+        Check API access to user account
+        """
+        url = self.url + "/auth/check"
+        headers = self._get_headers()
+        r = requests.get(url=url, timeout=2, headers=headers)
+        if r.status_code != 200:
+            self._log_error(url, {}, r)
+            return None
+        return r.json()
+
+    def get_list_organizations(self):
+        """
+        List all organizations
+        """
+        url = self.url + "/organizations"
+        headers = self._get_headers()
+        r = requests.get(url=url, timeout=2, headers=headers)
+        if r.status_code != 200:
+            self._log_error(url, {}, r)
+            return None
+        return r.json()
+
+    def check_organization_exists(self, organization_name: str):
+        """
+        Check if an organization exists
+        """
+        organizations = self.get_list_organizations()
+        if organizations is None:
+            return False
+        for organization in organizations:
+            if organization["name"] == organization_name:
+                return organization
+        return False
+
+    def create_organization(self, organization: OrganizationCreate):
+        """
+        Create an organization
+        """
+        payload = dataclasses.asdict(organization)
+        url = self.url + "/organizations"
+        if organization := self.check_organization_exists(organization.name):
+            logger.warning(
+                f"Organization {organization['name']} already exists. Skipping creation."
+            )
+            return organization
+        else:
+            headers = self._get_headers()
+            r = requests.post(url=url, json=payload, timeout=2, headers=headers)
+            if r.status_code != 201:
+                self._log_error(url, payload, r)
+                return None
+            return r.json()
+
+    def get_organization(self, organization_id):
+        """
+        Get an organization
+        """
+        headers = self._get_headers()
+        url = self.url + "/organizations/" + organization_id
+        r = requests.get(url=url, timeout=2, headers=headers)
+        if r.status_code != 200:
+            self._log_error(url, {}, r)
+            return None
+        return r.json()
+
+    def update_organization(self, organization: OrganizationCreate):
+        """
+        Update an organization
+        """
+        payload = dataclasses.asdict(organization)
+        headers = self._get_headers()
+        url = self.url + "/organizations/" + organization.id
+        r = requests.patch(url=url, json=payload, timeout=2, headers=headers)
+        if r.status_code != 200:
+            self._log_error(url, payload, r)
+            return None
+        return r.json()
+
+    def list_projects_from_organization(self, organization_id):
+        """
+        List all projects
+        """
+        url = self.url + "/organizations/" + organization_id + "/projects"
+        headers = self._get_headers()
+        r = requests.get(url=url, timeout=2, headers=headers)
+        if r.status_code != 200:
+            self._log_error(url, {}, r)
+            return None
+        return r.json()
+
+    def create_project(self, project: ProjectCreate):
+        """
+        Create a project
+        """
+        payload = dataclasses.asdict(project)
+        url = self.url + "/projects"
+        headers = self._get_headers()
+        r = requests.post(url=url, json=payload, timeout=2, headers=headers)
+        if r.status_code != 201:
+            self._log_error(url, payload, r)
+            return None
+        return r.json()
+
+    def get_project(self, project_id):
+        """
+        Get a project
+        """
+        url = self.url + "/projects/" + project_id
+        headers = self._get_headers()
+        r = requests.get(url=url, timeout=2, headers=headers)
+        if r.status_code != 200:
+            self._log_error(url, {}, r)
+            return None
+        return r.json()
+
+    def add_emission(self, carbon_emission: dict):
+        assert self.experiment_id is not None
+        if self.run_id is None:
+            logger.warning(
+                "ApiClient.add_emission() need a run_id : the initial call may "
+                + "have failed. Retrying..."
+            )
+            self._create_run(self.experiment_id)
+            if self.run_id is None:
+                logger.error(
+                    "ApiClient.add_emission still no run_id, aborting for this time !"
+                )
+            return False
+        if carbon_emission["duration"] < 1:
+            logger.warning(
+                "ApiClient : emissions not sent because of a duration smaller than 1."
+            )
+            return False
+        emission = EmissionCreate(
+            timestamp=get_datetime_with_timezone(),
+            run_id=self.run_id,
+            duration=int(carbon_emission["duration"]),
+            emissions_sum=carbon_emission["emissions"],
+            emissions_rate=carbon_emission["emissions_rate"],
+            cpu_power=carbon_emission["cpu_power"],
+            gpu_power=carbon_emission["gpu_power"],
+            ram_power=carbon_emission["ram_power"],
+            cpu_energy=carbon_emission["cpu_energy"],
+            gpu_energy=carbon_emission["gpu_energy"],
+            ram_energy=carbon_emission["ram_energy"],
+            energy_consumed=carbon_emission["energy_consumed"],
+        )
+        try:
+            payload = dataclasses.asdict(emission)
+            url = self.url + "/emissions"
+            headers = self._get_headers()
+            r = requests.post(url=url, json=payload, timeout=2, headers=headers)
+            if r.status_code != 201:
+                self._log_error(url, payload, r)
+                return False
+            logger.debug(f"ApiClient - Successful upload emission {payload} to {url}")
+        except Exception as e:
+            logger.error(e, exc_info=True)
+            return False
+        return True
+
+    def _create_run(self, experiment_id: str):
+        """
+        Create the experiment for project_id
+        """
+        if self.experiment_id is None:
+            # TODO : raise an Exception ?
+            logger.error(
+                "ApiClient FATAL The ApiClient._create_run() needs an experiment_id !"
+            )
+            return None
+        try:
+            run = RunCreate(
+                timestamp=get_datetime_with_timezone(),
+                experiment_id=experiment_id,
+                os=self.conf.get("os"),
+                python_version=self.conf.get("python_version"),
+                codecarbon_version=self.conf.get("codecarbon_version"),
+                cpu_count=self.conf.get("cpu_count"),
+                cpu_model=self.conf.get("cpu_model"),
+                gpu_count=self.conf.get("gpu_count"),
+                gpu_model=self.conf.get("gpu_model"),
+                # Reduce precision for Privacy
+                longitude=round(self.conf.get("longitude", 0), 1),
+                latitude=round(self.conf.get("latitude", 0), 1),
+                region=self.conf.get("region"),
+                provider=self.conf.get("provider"),
+                ram_total_size=self.conf.get("ram_total_size"),
+                tracking_mode=self.conf.get("tracking_mode"),
+            )
+            payload = dataclasses.asdict(run)
+            url = self.url + "/runs"
+            headers = self._get_headers()
+            r = requests.post(url=url, json=payload, timeout=2, headers=headers)
+            if r.status_code != 201:
+                self._log_error(url, payload, r)
+                return None
+            self.run_id = r.json()["id"]
+            logger.info(
+                "ApiClient Successfully registered your run on the API.\n\n"
+                + f"Run ID: {self.run_id}\n"
+                + f"Experiment ID: {self.experiment_id}\n"
+            )
+            return self.run_id
+        except requests.exceptions.ConnectionError as e:
+            logger.error(
+                f"Failed to connect to API, please check the configuration. {e}",
+                exc_info=False,
+            )
+        except Exception as e:
+            logger.error(e, exc_info=True)
+
+    def list_experiments_from_project(self, project_id: str):
+        """
+        List all experiments for a project
+        """
+        url = self.url + "/projects/" + project_id + "/experiments"
+        headers = self._get_headers()
+        r = requests.get(url=url, timeout=2, headers=headers)
+        if r.status_code != 200:
+            self._log_error(url, {}, r)
+            return []
+        return r.json()
+
+    def set_experiment(self, experiment_id: str):
+        """
+        Set the experiment id
+        """
+        self.experiment_id = experiment_id
+
+    def add_experiment(self, experiment: ExperimentCreate):
+        """
+        Create an experiment, used by the CLI, not the package.
+        ::experiment:: The experiment to create.
+        """
+        payload = dataclasses.asdict(experiment)
+        url = self.url + "/experiments"
+        headers = self._get_headers()
+        r = requests.post(url=url, json=payload, timeout=2, headers=headers)
+        if r.status_code != 201:
+            self._log_error(url, payload, r)
+            return None
+        return r.json()
+
+    def get_experiment(self, experiment_id):
+        """
+        Get an experiment by id
+        """
+        url = self.url + "/experiments/" + experiment_id
+        headers = self._get_headers()
+        r = requests.get(url=url, timeout=2, headers=headers)
+        if r.status_code != 200:
+            self._log_error(url, {}, r)
+            return None
+        return r.json()
+
+    def _log_error(self, url, payload, response):
+        if len(payload) > 0:
+            logger.error(
+                f"ApiClient Error when calling the API on {url} with : {json.dumps(payload)}"
+            )
+        else:
+            logger.error(f"ApiClient Error when calling the API on {url}")
+        logger.error(
+            f"ApiClient API return http code {response.status_code} and answer : {response.text}"
+        )
+
+    def close_experiment(self):
+        """
+        Tell the API that the experiment has ended.
+        """
+
+
+class simple_utc(tzinfo):
+    def tzname(self, **kwargs):
+        return "UTC"
+
+    def utcoffset(self, dt):
+        return timedelta(0)

codecarbon/core/cloud.py

@@ -0,0 +1,71 @@
+from typing import Any, Dict, Optional
+
+import requests
+
+from codecarbon.external.logger import logger
+
+
+def postprocess_gcp_cloud_metadata(cloud_metadata: Dict[str, Any]) -> Dict[str, Any]:
+    # Attributes contains custom metadata and also contains Kubernetes config,
+    # startup script and secrets, filter it out
+    if "attributes" in cloud_metadata:
+        del cloud_metadata["attributes"]
+
+    return cloud_metadata
+
+
+CLOUD_METADATA_MAPPING: Dict[str, Dict[str, Any]] = {
+    "AWS": {
+        "url": "http://169.254.169.254/latest/dynamic/instance-identity/document",
+        "headers": {},
+    },
+    "Azure": {
+        "url": "http://169.254.169.254/metadata/instance?api-version=2019-08-15",
+        "headers": {"Metadata": "true"},
+    },
+    "GCP": {
+        "url": "http://169.254.169.254/computeMetadata/v1/instance/?recursive=true&alt=json",  # noqa: E501
+        "headers": {"Metadata-Flavor": "Google"},
+        "postprocess_function": postprocess_gcp_cloud_metadata,
+    },
+}
+
+
+def get_env_cloud_details(timeout: int = 1) -> Optional[Any]:
+    """
+    >>> get_env_cloud_details()
+    {'provider': 'AWS',
+     'metadata': {'accountId': '26550917306',
+        'architecture': 'x86_64',
+        'availabilityZone': 'us-east-1b',
+        'billingProducts': None,
+        'devpayProductCodes': None,
+        'marketplaceProductCodes': None,
+        'imageId': 'ami-025ed45832b817a35',
+        'instanceId': 'i-7c3e81fed58d8f7f7',
+        'instanceType': 'g4dn.2xlarge',
+        'kernelId': None,
+        'pendingTime': '2020-01-23T20:44:53Z',
+        'privateIp': '172.156.72.143',
+        'ramdiskId': None,
+        'region': 'us-east-1',
+        'version': '2017-09-30'}}
+    """
+    for provider in CLOUD_METADATA_MAPPING.keys():
+        try:
+            params = CLOUD_METADATA_MAPPING[provider]
+            response = requests.get(
+                params["url"], headers=params["headers"], timeout=timeout
+            )
+            response.raise_for_status()
+            response_data = response.json()
+
+            postprocess_function = params.get("postprocess_function")
+            if postprocess_function is not None:
+                response_data = postprocess_function(response_data)
+
+            return {"provider": provider, "metadata": response_data}
+        except requests.exceptions.RequestException:
+            logger.debug("Not running on %s", provider)
+
+    return None

codecarbon/core/co2_signal.py

@@ -0,0 +1,62 @@
+from typing import Any, Dict
+
+import requests
+
+from codecarbon.core.units import EmissionsPerKWh, Energy
+from codecarbon.external.geography import GeoMetadata
+
+URL: str = "https://api.co2signal.com/v1/latest"
+CO2_SIGNAL_API_TIMEOUT: int = 30
+
+
+def get_emissions(
+    energy: Energy, geo: GeoMetadata, co2_signal_api_token: str = ""
+) -> float:
+    """
+    Calculate the CO2 emissions based on energy consumption and geographic location.
+
+    This function retrieves the carbon intensity (in grams of CO2 per kWh) from the CO2
+    Signal API based on the geographic location provided. It then calculates the total
+    CO2 emissions for a given amount of energy consumption.
+
+    Args:
+        energy (Energy):
+            An object representing the energy consumption in kilowatt-hours (kWh).
+        geo (GeoMetadata):
+            Geographic metadata, including either latitude/longitude
+            or a country code.
+        co2_signal_api_token (str, optional):
+            The API token for authenticating with the CO2 Signal API (default is an empty string).
+
+    Returns:
+        float:
+            The total CO2 emissions in kilograms based on the provided energy consumption and
+            carbon intensity of the specified geographic location.
+
+    Raises:
+        CO2SignalAPIError:
+            If the CO2 Signal API request fails or returns an error.
+    """
+    params: Dict[str, Any]
+    if geo.latitude:
+        params = {"lat": geo.latitude, "lon": geo.longitude}
+    else:
+        params = {"countryCode": geo.country_2letter_iso_code}
+    resp = requests.get(
+        URL,
+        params=params,
+        headers={"auth-token": co2_signal_api_token},
+        timeout=CO2_SIGNAL_API_TIMEOUT,
+    )
+    if resp.status_code != 200:
+        message = resp.json().get("error") or resp.json().get("message")
+        raise CO2SignalAPIError(message)
+    carbon_intensity_g_per_kWh = resp.json()["data"]["carbonIntensity"]
+    emissions_per_kWh: EmissionsPerKWh = EmissionsPerKWh.from_g_per_kWh(
+        carbon_intensity_g_per_kWh
+    )
+    return emissions_per_kWh.kgs_per_kWh * energy.kWh
+
+
+class CO2SignalAPIError(Exception):
+    pass

codecarbon/core/config.py

@@ -0,0 +1,115 @@
+import configparser
+import os
+from pathlib import Path
+from typing import List
+
+from codecarbon.external.logger import logger
+
+
+def clean_env_key(k: str) -> str:
+    """
+    Clean up an environment variable key: remove starting
+    CODECARBON_ and to lower case.
+
+    eg: "CODECARBON_PROJECT_NAME" -> "project_name"
+
+    Args:
+        k (str): Environment variable key
+
+    Returns:
+        str: Cleaned str
+    """
+    assert isinstance(k, str)
+    return k.lower().replace("codecarbon_", "", 1)
+
+
+def parse_env_config() -> dict:
+    """
+    Get all environment variables starting with "CODECARBON_" (also in lower caps)
+    mapped to their values in a dict
+
+    eg:
+        * "CODECARBON_PROJECT_NAME=DeepLearning" -> {"project_name": "DeepLearning"}
+        * "codecarbon_project_name=DeepLearning" -> {"project_name": "DeepLearning"}
+
+    Returns:
+        dict: existing relevant environment variables mapped into a dict
+    """
+    return {
+        "codecarbon": {
+            clean_env_key(k): v
+            for k, v in os.environ.items()
+            if k.lower().startswith("codecarbon_")
+        }
+    }
+
+
+def parse_gpu_ids(gpu_ids_str: str) -> List[int]:
+    """
+    Transforms the potential gpu_ids string into a list of int values
+
+    Args:
+        gpu_ids_str (str): The config file or environment variable value for `gpu_ids`
+        which is read as a string and should be parsed into a list of ints
+
+    Returns:
+        list[int]: The list of GPU ids available declared by the user.
+            Potentially empty.
+    """
+    if not isinstance(gpu_ids_str, str):
+        return gpu_ids_str
+
+    gpu_ids_str = "".join(c for c in gpu_ids_str if (c.isalnum() or c == ","))
+    str_ids = [gpu_id for gpu_id in gpu_ids_str.split(",") if gpu_id]
+    return list(map(int, str_ids))
+
+
+def get_hierarchical_config():
+    """
+    Get the user-defined codecarbon configuration ConfigParser dictionnary
+    (actually a configparser.SectionProxy instance).
+
+    ```
+    >>> from codecarbon.core.config import get_hierarchical_config
+    >>> conf = get_hierarchical_config()
+    >>> print(conf)
+    ```
+
+    `conf` works like a regular dict + methods getint(key) getfloat(key)
+    and getboolean(key) to automatically parse strings into those types.
+
+    All values (outputs of get(key)) are strings.
+
+    It looks for, and reads, a config file .codecarbon.config in the user's $HOME.
+    It then looks for, reads, and updates the previous configuration from a config
+    file .codecarbon.config in the current working directory (Path.cwd()).
+    Finally it updates the resulting config from any environment variable starting
+    with `CODECARBON_` (for instance if `CODECARBON_PROJECT_NAME` is `your-project`
+    then the resulting configuration key `project_name` will have value `your-project`)
+
+    Returns:
+        dict: The final configuration dict parsed from global,
+        local and environment configurations. **All values are strings**.
+    """
+
+    config = configparser.ConfigParser()
+
+    cwd = Path.cwd()
+    home = Path.home()
+    global_path = str((home / ".codecarbon.config").expanduser().resolve())
+    local_path = str((cwd / ".codecarbon.config").expanduser().resolve())
+    if Path(global_path).exists():
+        logger.info(
+            f"Codecarbon is taking the configuration from global file: {global_path}"
+        )
+        if Path(local_path).exists():
+            logger.info(f"Some variables are overriden by the local file: {local_path}")
+    elif Path(local_path).exists():
+        logger.info(
+            f"Codecarbon is taking the configuration from the local file {local_path}"
+        )
+
+    config.read([global_path, local_path])
+    config.read_dict(parse_env_config())
+
+    return dict(config["codecarbon"])

codecarbon/core/cpu.py

@@ -0,0 +1,521 @@
+"""
+Implements tracking Intel CPU Power Consumption on Mac and Windows
+using Intel Power Gadget
+https://software.intel.com/content/www/us/en/develop/articles/intel-power-gadget.html
+"""
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+from typing import Dict, Optional, Tuple
+
+import pandas as pd
+import psutil
+from rapidfuzz import fuzz, process, utils
+
+from codecarbon.core.rapl import RAPLFile
+from codecarbon.core.units import Time
+from codecarbon.core.util import detect_cpu_model
+from codecarbon.external.logger import logger
+from codecarbon.input import DataSource
+
+# default W value per core for a CPU if no model is found in the ref csv
+DEFAULT_POWER_PER_CORE = 4
+
+
+def is_powergadget_available() -> bool:
+    """
+    Checks if Intel Power Gadget is available on the system.
+
+    Returns:
+        bool: `True` if Intel Power Gadget is available, `False` otherwise.
+    """
+    try:
+        IntelPowerGadget()
+        return True
+    except Exception as e:
+        logger.debug(
+            "Not using PowerGadget, an exception occurred while instantiating "
+            + "IntelPowerGadget : %s",
+            e,
+        )
+        return False
+
+
+def is_rapl_available() -> bool:
+    """
+    Checks if Intel RAPL is available on the system.
+
+    Returns:
+        bool: `True` if Intel RAPL is available, `False` otherwise.
+    """
+    try:
+        IntelRAPL()
+        return True
+    except Exception as e:
+        logger.debug(
+            "Not using the RAPL interface, an exception occurred while instantiating "
+            + "IntelRAPL : %s",
+            e,
+        )
+        return False
+
+
+def is_psutil_available():
+    try:
+        nice = psutil.cpu_times().nice
+        if nice > 0.0001:
+            return True
+        else:
+            logger.debug(
+                f"is_psutil_available() : psutil.cpu_times().nice is too small : {nice} !"
+            )
+            return False
+    except Exception as e:
+        logger.debug(
+            "Not using the psutil interface, an exception occurred while instantiating "
+            + f"psutil.cpu_times : {e}",
+        )
+        return False
+
+
+class IntelPowerGadget:
+    """
+    A class to interface with Intel Power Gadget for monitoring CPU power consumption on Windows and (non-Apple Silicon) macOS.
+
+    This class provides methods to set up and execute Intel Power Gadget's command-line interface (CLI) to
+    log power consumption data over a specified duration and resolution. It also includes functionality to
+    read and process the logged data to extract CPU power details.
+
+    Methods:
+        start():
+            Placeholder method for starting the Intel Power Gadget monitoring.
+
+        get_cpu_details() -> Dict:
+            Fetches the CPU power details by reading the values from the logged CSV file.
+
+    """
+
+    _osx_exec = "PowerLog"
+    _osx_exec_backup = "/Applications/Intel Power Gadget/PowerLog"
+    _windows_exec = "PowerLog3.0.exe"
+
+    def __init__(
+        self,
+        output_dir: str = ".",
+        duration=1,
+        resolution=100,
+        log_file_name="intel_power_gadget_log.csv",
+    ):
+        self._log_file_path = os.path.join(output_dir, log_file_name)
+        self._system = sys.platform.lower()
+        self._duration = duration
+        self._resolution = resolution
+        self._windows_exec_backup = None
+        self._setup_cli()
+
+    def _setup_cli(self) -> None:
+        """
+        Setup cli command to run Intel Power Gadget
+        """
+        if self._system.startswith("win"):
+            self._get_windows_exec_backup()
+            if shutil.which(self._windows_exec):
+                self._cli = shutil.which(
+                    self._windows_exec
+                )  # Windows exec is a relative path
+            elif shutil.which(self._windows_exec_backup):
+                self._cli = self._windows_exec_backup
+            else:
+                raise FileNotFoundError(
+                    f"Intel Power Gadget executable not found on {self._system}"
+                )
+        elif self._system.startswith("darwin"):
+            if shutil.which(self._osx_exec):
+                self._cli = self._osx_exec
+            elif shutil.which(self._osx_exec_backup):
+                self._cli = self._osx_exec_backup
+            else:
+                raise FileNotFoundError(
+                    f"Intel Power Gadget executable not found on {self._system}"
+                )
+        else:
+            raise SystemError("Platform not supported by Intel Power Gadget")
+
+    def _get_windows_exec_backup(self) -> None:
+        """
+        Find the windows executable for the current version of intel power gadget.
+        Example: "C:\\Program Files\\Intel\\Power Gadget 3.5\\PowerLog3.0.exe"
+        """
+        parent_folder = "C:\\Program Files\\Intel\\"
+
+        # Get a list of all subdirectories in the parent folder
+        subfolders = [f.name for f in os.scandir(parent_folder) if f.is_dir()]
+
+        # Look for a folder that contains "Power Gadget" in its name
+        desired_folder = next(
+            (folder for folder in subfolders if "Power Gadget" in folder), None
+        )
+        if desired_folder:
+            self._windows_exec_backup = os.path.join(
+                parent_folder, desired_folder, self._windows_exec
+            )
+        else:
+            self._windows_exec_backup = None
+
+    def _log_values(self) -> None:
+        """
+        Logs output from Intel Power Gadget command line to a file
+        """
+        returncode = None
+        if self._system.startswith("win"):
+            returncode = subprocess.call(
+                [
+                    self._cli,
+                    "-duration",
+                    str(self._duration),
+                    "-resolution",
+                    str(self._resolution),
+                    "-file",
+                    self._log_file_path,
+                ],
+                shell=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+        elif self._system.startswith("darwin"):
+            returncode = subprocess.call(
+                f"'{self._cli}' -duration {self._duration} -resolution {self._resolution} -file {self._log_file_path} > /dev/null",  # noqa: E501
+                shell=True,
+            )
+        else:
+            return None
+
+        if returncode != 0:
+            logger.warning(
+                "Returncode while logging power values using "
+                + "Intel Power Gadget: %s",
+                returncode,
+            )
+
+    def get_cpu_details(self) -> Dict:
+        """
+        Fetches the CPU Power Details by fetching values from a logged csv file
+        in _log_values function
+        """
+        self._log_values()
+        cpu_details = {}
+        try:
+            cpu_data = pd.read_csv(self._log_file_path).dropna()
+            for col_name in cpu_data.columns:
+                if col_name in ["System Time", "Elapsed Time (sec)", "RDTSC"]:
+                    continue
+                if "Cumulative" in col_name:
+                    cpu_details[col_name] = cpu_data[col_name].iloc[-1]
+                else:
+                    cpu_details[col_name] = cpu_data[col_name].mean()
+        except Exception as e:
+            logger.info(
+                f"Unable to read Intel Power Gadget logged file at {self._log_file_path}\n \
+                Exception occurred %s",
+                e,
+                exc_info=True,
+            )
+        return cpu_details
+
+    def start(self) -> None:
+        """
+        Placeholder method for starting the Intel Power Gadget monitoring.
+        """
+        # TODO: Read energy
+
+
+class IntelRAPL:
+    """
+    A class to interface Intel's Running Average Power Limit (RAPL) for monitoring CPU power consumption.
+
+    This class provides methods to set up and read energy consumption data from Intel RAPL files,
+    which are available on Linux systems.
+    It enables the measurement of CPU energy usage over time and provides methods to fetch
+    both dynamic and static CPU energy details.
+
+    Attributes:
+        _lin_rapl_dir (str): The directory path where Intel RAPL files are located.
+        _system (str): The platform of the running system, typically used to ensure compatibility.
+        _rapl_files (List[RAPLFile]): A list of RAPLFile objects representing the files to read energy data from.
+        _cpu_details (Dict): A dictionary storing the latest CPU energy details.
+        _last_mesure (int): Placeholder for storing the last measurement time.
+
+    Methods:
+        start():
+            Starts monitoring CPU energy consumption.
+
+        get_cpu_details(duration: Time) -> Dict:
+            Fetches the CPU energy deltas over a specified duration by reading values from RAPL files.
+
+        get_static_cpu_details() -> Dict:
+            Returns the CPU details without recalculating them.
+
+    """
+
+    def __init__(self, rapl_dir="/sys/class/powercap/intel-rapl/subsystem"):
+        self._lin_rapl_dir = rapl_dir
+        self._system = sys.platform.lower()
+        self._rapl_files = []
+        self._setup_rapl()
+        self._cpu_details: Dict = {}
+
+        self._last_mesure = 0
+
+    def _is_platform_supported(self) -> bool:
+        return self._system.startswith("lin")
+
+    def _setup_rapl(self) -> None:
+        if self._is_platform_supported():
+            if os.path.exists(self._lin_rapl_dir):
+                self._fetch_rapl_files()
+            else:
+                raise FileNotFoundError(
+                    f"Intel RAPL files not found at {self._lin_rapl_dir} "
+                    + f"on {self._system}"
+                )
+        else:
+            raise SystemError("Platform not supported by Intel RAPL Interface")
+
+    def _fetch_rapl_files(self) -> None:
+        """
+        Fetches RAPL files from the RAPL directory
+        """
+
+        # consider files like `intel-rapl:$i`
+        files = list(filter(lambda x: ":" in x, os.listdir(self._lin_rapl_dir)))
+
+        i = 0
+        for file in files:
+            path = os.path.join(self._lin_rapl_dir, file, "name")
+            with open(path) as f:
+                name = f.read().strip()
+                # Fake the name used by Power Gadget
+                # We ignore "core" in name as it seems to be included in "package" for Intel CPU.
+                # TODO: Use "dram" for memory power
+                if "package" in name:
+                    name = f"Processor Energy Delta_{i}(kWh)"
+                    i += 1
+                # RAPL file to take measurement from
+                rapl_file = os.path.join(self._lin_rapl_dir, file, "energy_uj")
+                # RAPL file containing maximum possible value of energy_uj above which it wraps
+                rapl_file_max = os.path.join(
+                    self._lin_rapl_dir, file, "max_energy_range_uj"
+                )
+                try:
+                    # Try to read the file to be sure we can
+                    with open(rapl_file, "r") as f:
+                        _ = float(f.read())
+                    self._rapl_files.append(
+                        RAPLFile(name=name, path=rapl_file, max_path=rapl_file_max)
+                    )
+                    logger.debug("We will read Intel RAPL files at %s", rapl_file)
+                except PermissionError as e:
+                    raise PermissionError(
+                        "PermissionError : Unable to read Intel RAPL files for CPU power, we will use a constant for your CPU power."
+                        + " Please view https://github.com/mlco2/codecarbon/issues/244"
+                        + " for workarounds : %s",
+                        e,
+                    ) from e
+
+    def get_cpu_details(self, duration: Time) -> Dict:
+        """
+        Fetches the CPU Energy Deltas by fetching values from RAPL files
+        """
+        cpu_details = {}
+        try:
+            list(map(lambda rapl_file: rapl_file.delta(duration), self._rapl_files))
+
+            for rapl_file in self._rapl_files:
+                logger.debug(rapl_file)
+                cpu_details[rapl_file.name] = rapl_file.energy_delta.kWh
+                # We fake the name used by Power Gadget when using RAPL
+                if "Energy" in rapl_file.name:
+                    cpu_details[rapl_file.name.replace("Energy", "Power")] = (
+                        rapl_file.power.W
+                    )
+        except Exception as e:
+            logger.info(
+                "Unable to read Intel RAPL files at %s\n \
+                Exception occurred %s",
+                self._rapl_files,
+                e,
+                exc_info=True,
+            )
+        self._cpu_details = cpu_details
+        logger.debug("get_cpu_details %s", self._cpu_details)
+        return cpu_details
+
+    def get_static_cpu_details(self) -> Dict:
+        """
+        Return CPU details without computing them.
+        """
+        return self._cpu_details
+
+    def start(self) -> None:
+        """
+        Starts monitoring CPU energy consumption.
+        """
+        for rapl_file in self._rapl_files:
+            rapl_file.start()
+
+
+class TDP:
+    """
+    Represents Thermal Design Power (TDP) for detecting and estimating
+    the power consumption of the CPU on a machine.
+
+    The class provides methods to identify the CPU model, match it with known TDP
+    values from a dataset, and return the corresponding power consumption in watts.
+
+    Attributes:
+        model (str): The detected CPU model name.
+        tdp (int): The TDP value of the detected CPU in watts.
+
+    Methods:
+        start():
+            Placeholder method to initiate TDP analysis.
+
+    """
+
+    def __init__(self):
+        self.model, self.tdp = self._main()
+
+    @staticmethod
+    def _get_cpu_constant_power(match: str, cpu_power_df: pd.DataFrame) -> int:
+        """Extract constant power from matched CPU"""
+        return float(cpu_power_df[cpu_power_df["Name"] == match]["TDP"].values[0])
+
+    def _get_cpu_power_from_registry(self, cpu_model_raw: str) -> Optional[int]:
+        cpu_power_df = DataSource().get_cpu_power_data()
+        cpu_matching = self._get_matching_cpu(cpu_model_raw, cpu_power_df)
+        if cpu_matching:
+            power = self._get_cpu_constant_power(cpu_matching, cpu_power_df)
+            return power
+        return None
+
+    def _get_matching_cpu(
+        self, model_raw: str, cpu_df: pd.DataFrame, greedy=False
+    ) -> str:
+        """
+        Get matching cpu name
+
+        :args:
+            model_raw (str): raw name of the cpu model detected on the machine
+
+            cpu_df (DataFrame): table containing cpu models along their tdp
+
+            greedy (default False): if multiple cpu models match with an equal
+            ratio of similarity, greedy (True) selects the first model,
+            following the order of the cpu list provided, while non-greedy
+            returns None.
+
+        :return: name of the matching cpu model
+
+        :notes:
+            Thanks to the greedy mode, even though the match could be a model
+            with a tdp very different from the actual tdp of current cpu, it
+            still enables the relative comparison of models emissions running
+            on the same machine.
+
+            THRESHOLD_DIRECT defines the similarity ratio value to consider
+            almost-exact matches.
+
+            THRESHOLD_TOKEN_SET defines the similarity ratio value to consider
+            token_set matches (for more detail see fuzz.token_set_ratio).
+        """
+        THRESHOLD_DIRECT: int = 100
+        THRESHOLD_TOKEN_SET: int = 100
+
+        direct_match = process.extractOne(
+            model_raw,
+            cpu_df["Name"],
+            processor=lambda s: s.lower(),
+            scorer=fuzz.ratio,
+            score_cutoff=THRESHOLD_DIRECT,
+        )
+
+        if direct_match:
+            return direct_match[0]
+
+        model_raw = model_raw.replace("(R)", "")
+        start_cpu = model_raw.find(" CPU @ ")
+        if start_cpu > 0:
+            model_raw = model_raw[0:start_cpu]
+        model_raw = model_raw.replace(" CPU", "")
+        model_raw = re.sub(r" @\s*\d+\.\d+GHz", "", model_raw)
+        direct_match = process.extractOne(
+            model_raw,
+            cpu_df["Name"],
+            processor=lambda s: s.lower(),
+            scorer=fuzz.ratio,
+            score_cutoff=THRESHOLD_DIRECT,
+        )
+
+        if direct_match:
+            return direct_match[0]
+        indirect_matches = process.extract(
+            model_raw,
+            cpu_df["Name"],
+            processor=utils.default_process,
+            scorer=fuzz.token_set_ratio,
+            score_cutoff=THRESHOLD_TOKEN_SET,
+        )
+
+        if indirect_matches:
+            if (
+                greedy
+                or len(indirect_matches) == 1
+                or indirect_matches[0][1] != indirect_matches[1][1]
+            ):
+                return indirect_matches[0][0]
+
+        return None
+
+    def _main(self) -> Tuple[str, int]:
+        """
+        Get CPU power from constant mode
+
+        :return: model name (str), power in Watt (int)
+        """
+        cpu_model_detected = detect_cpu_model()
+
+        if cpu_model_detected:
+            power = self._get_cpu_power_from_registry(cpu_model_detected)
+
+            if power:
+                logger.debug(
+                    "CPU : We detect a %s with a TDP of %s W",
+                    cpu_model_detected,
+                    power,
+                )
+                return cpu_model_detected, power
+            logger.warning(
+                "We saw that you have a %s but we don't know it."
+                + " Please contact us.",
+                cpu_model_detected,
+            )
+            if is_psutil_available():
+                # Count thread of the CPU
+                threads = psutil.cpu_count(logical=True)
+                estimated_tdp = threads * DEFAULT_POWER_PER_CORE
+                logger.warning(
+                    f"We will use the default power consumption of {DEFAULT_POWER_PER_CORE} W per thread for your {threads} CPU, so {estimated_tdp}W."
+                )
+                return cpu_model_detected, estimated_tdp
+            return cpu_model_detected, None
+        logger.warning(
+            "We were unable to detect your CPU using the `cpuinfo` package."
+            + " Resorting to a default power consumption."
+        )
+        return "Unknown", None
+
+    def start(self):
+        pass

codecarbon/core/emissions.py

@@ -0,0 +1,308 @@
+"""
+Provides functionality to compute emissions for cloud & private infra
+based on impact & energy Usage package
+
+https://github.com/mlco2/impact
+https://github.com/responsibleproblemsolving/energy-usage
+"""
+
+from typing import Dict, Optional
+
+import pandas as pd
+
+from codecarbon.core import co2_signal
+from codecarbon.core.units import EmissionsPerKWh, Energy
+from codecarbon.external.geography import CloudMetadata, GeoMetadata
+from codecarbon.external.logger import logger
+from codecarbon.input import DataSource, DataSourceException
+
+
+class Emissions:
+    def __init__(
+        self, data_source: DataSource, co2_signal_api_token: Optional[str] = None
+    ):
+        self._data_source = data_source
+        self._co2_signal_api_token = co2_signal_api_token
+
+    def get_cloud_emissions(
+        self, energy: Energy, cloud: CloudMetadata, geo: GeoMetadata = None
+    ) -> float:
+        """
+        Computes emissions for cloud infra
+        :param energy: Mean power consumption of the process (kWh)
+        :param cloud: Region of compute
+        :param geo: Instance of GeoMetadata to fallback if we don't find cloud carbon intensity
+        :return: CO2 emissions in kg
+        """
+
+        df: pd.DataFrame = self._data_source.get_cloud_emissions_data()
+        try:
+            emissions_per_kWh: EmissionsPerKWh = EmissionsPerKWh.from_g_per_kWh(
+                df.loc[
+                    (df["provider"] == cloud.provider) & (df["region"] == cloud.region)
+                ]["impact"].item()
+            )
+            emissions = emissions_per_kWh.kgs_per_kWh * energy.kWh  # kgs
+        except Exception as e:
+            logger.warning(
+                f"Cloud electricity carbon intensity for provider '{cloud.provider}' and region '{cloud.region}' not found, using country value instead. Error : {e}"
+            )
+            logger.warning(
+                "AWS and Azure do not provide any carbon intensity data. Only GCP does it."
+            )
+            if geo:
+                emissions = self.get_private_infra_emissions(
+                    energy, geo
+                )  # float: kg co2_eq
+            else:
+                carbon_intensity_per_source = (
+                    DataSource().get_carbon_intensity_per_source_data()
+                )
+                emissions = (
+                    EmissionsPerKWh.from_g_per_kWh(
+                        carbon_intensity_per_source.get("world_average")
+                    ).kgs_per_kWh
+                    * energy.kWh
+                )  # kgs
+        return emissions
+
+    def get_cloud_country_name(self, cloud: CloudMetadata) -> str:
+        """
+        Returns the Country Name where the cloud region is located
+        """
+        df: pd.DataFrame = self._data_source.get_cloud_emissions_data()
+        flags = (df["provider"] == cloud.provider) & (df["region"] == cloud.region)
+        selected = df.loc[flags]
+        if not len(selected):
+            raise ValueError(
+                "Unable to find country name for "
+                f"cloud_provider={cloud.provider}, "
+                f"cloud_region={cloud.region}"
+            )
+        return selected["country_name"].item()
+
+    def get_cloud_country_iso_code(self, cloud: CloudMetadata) -> str:
+        """
+        Returns the Country ISO Code where the cloud region is located
+        """
+        df: pd.DataFrame = self._data_source.get_cloud_emissions_data()
+        flags = (df["provider"] == cloud.provider) & (df["region"] == cloud.region)
+        selected = df.loc[flags]
+        if not len(selected):
+            raise ValueError(
+                "Unable to find country ISO Code for "
+                f"cloud_provider={cloud.provider}, "
+                f"cloud_region={cloud.region}"
+            )
+        return selected["countryIsoCode"].item()
+
+    def get_cloud_geo_region(self, cloud: CloudMetadata) -> str:
+        """
+        Returns the State/City where the cloud region is located
+        """
+        df: pd.DataFrame = self._data_source.get_cloud_emissions_data()
+        flags = (df["provider"] == cloud.provider) & (df["region"] == cloud.region)
+        selected = df.loc[flags]
+        if not len(selected):
+            raise ValueError(
+                "Unable to find State/City name for "
+                f"cloud_provider={cloud.provider}, "
+                f"cloud_region={cloud.region}"
+            )
+
+        state = selected["state"].item()
+        if state is not None:
+            return state
+        city = selected["city"].item()
+        return city
+
+    def get_private_infra_emissions(self, energy: Energy, geo: GeoMetadata) -> float:
+        """
+        Computes emissions for private infra
+        :param energy: Mean power consumption of the process (kWh)
+        :param geo: Country and region metadata
+        :return: CO2 emissions in kg
+        """
+        if self._co2_signal_api_token:
+            try:
+                return co2_signal.get_emissions(energy, geo, self._co2_signal_api_token)
+            except Exception as e:
+                logger.error(
+                    "co2_signal.get_emissions: "
+                    + str(e)
+                    + " >>> Using CodeCarbon's data."
+                )
+
+        compute_with_regional_data: bool = (geo.region is not None) and (
+            geo.country_iso_code.upper() in ["USA", "CAN"]
+        )
+
+        if compute_with_regional_data:
+            try:
+                return self.get_region_emissions(energy, geo)
+            except Exception as e:
+                logger.error(e, exc_info=True)
+                logger.warning(
+                    "Regional emissions retrieval failed."
+                    + " Falling back on country emissions."
+                )
+        return self.get_country_emissions(energy, geo)
+
+    def get_region_emissions(self, energy: Energy, geo: GeoMetadata) -> float:
+        """
+        Computes emissions for a region on private infra.
+        Given an quantity of power consumed, use regional data
+         on emissions per unit power consumed or the mix of energy sources.
+        https://github.com/responsibleproblemsolving/energy-usage#calculating-co2-emissions
+        :param energy: Mean power consumption of the process (kWh)
+        :param geo: Country and region metadata.
+        :return: CO2 emissions in kg
+        """
+        try:
+            country_emissions_data = self._data_source.get_country_emissions_data(
+                geo.country_iso_code.lower()
+            )
+
+            if geo.region not in country_emissions_data:
+                # TODO: Deal with missing data, default to something
+                raise ValueError(
+                    f"Region: {geo.region} not found for Country"
+                    + f" with ISO CODE : {geo.country_iso_code}"
+                )
+
+            emissions_per_kWh: EmissionsPerKWh = EmissionsPerKWh.from_lbs_per_mWh(
+                country_emissions_data[geo.region]["emissions"]
+            )
+        except DataSourceException:
+            # This country has regional data at the energy mix level,
+            # not the emissions level
+            country_energy_mix_data = self._data_source.get_country_energy_mix_data(
+                geo.country_iso_code.lower()
+            )
+            region_energy_mix_data = country_energy_mix_data[geo.region]
+            emissions_per_kWh = self._region_energy_mix_to_emissions_rate(
+                region_energy_mix_data
+            )
+
+        return emissions_per_kWh.kgs_per_kWh * energy.kWh  # kgs
+
+    def get_country_emissions(self, energy: Energy, geo: GeoMetadata) -> float:
+        """
+        Computes emissions for a country on private infra,
+        given a quantity of power consumed by
+        using data for the mix of energy sources of that country.
+        :param energy: Mean power consumption of the process (kWh)
+        :param geo: Country and region metadata
+        :return: CO2 emissions in kg
+        """
+        energy_mix = self._data_source.get_global_energy_mix_data()
+
+        if geo.country_iso_code not in energy_mix:
+            logger.warning(
+                f"We do not have data for {geo.country_iso_code}, using world average."
+            )
+            carbon_intensity_per_source = (
+                DataSource().get_carbon_intensity_per_source_data()
+            )
+            return (
+                EmissionsPerKWh.from_g_per_kWh(
+                    carbon_intensity_per_source.get("world_average")
+                ).kgs_per_kWh
+                * energy.kWh
+            )  # kgs
+
+        country_energy_mix: Dict = energy_mix[geo.country_iso_code]
+        emissions_per_kWh = self._global_energy_mix_to_emissions_rate(
+            country_energy_mix
+        )
+        logger.debug(
+            f"We apply an energy mix of {emissions_per_kWh.kgs_per_kWh * 1000:.0f}"
+            + f" g.CO2eq/kWh for {geo.country_name}"
+        )
+
+        return emissions_per_kWh.kgs_per_kWh * energy.kWh  # kgs
+
+    @staticmethod
+    def _global_energy_mix_to_emissions_rate(energy_mix: Dict) -> EmissionsPerKWh:
+        """
+        Convert a mix of electricity sources into emissions per kWh.
+        :param energy_mix: A dictionary that breaks down the electricity produced into
+            energy sources, with a total value. Format will vary, but must have keys for "total_TWh"
+        :return: an EmissionsPerKwh object representing the average emissions rate
+            in Kgs.CO2 / kWh
+        """
+        # If we have the chance to have the carbon intensity for this country
+        if energy_mix.get("carbon_intensity"):
+            return EmissionsPerKWh.from_g_per_kWh(energy_mix.get("carbon_intensity"))
+
+        # Else we compute it from the energy mix.
+        # Read carbon_intensity from the json data file.
+        carbon_intensity_per_source = (
+            DataSource().get_carbon_intensity_per_source_data()
+        )
+        carbon_intensity = 0
+        energy_sum = energy_mix["total_TWh"]
+        energy_sum_computed = 0
+        # Iterate through each source of energy in the country
+        for energy_type, energy_per_year in energy_mix.items():
+            if "_TWh" in energy_type:
+                # Compute the carbon intensity ratio of this source for this country
+                carbon_intensity_for_type = carbon_intensity_per_source.get(
+                    energy_type[: -len("_TWh")]
+                )
+                if carbon_intensity_for_type:  # to ignore "total_TWh"
+                    carbon_intensity += (
+                        energy_per_year / energy_sum
+                    ) * carbon_intensity_for_type
+                    energy_sum_computed += energy_per_year
+
+        # Sanity check
+        if energy_sum_computed != energy_sum:
+            logger.error(
+                f"We find {energy_sum_computed} TWh instead of {energy_sum} TWh for {energy_mix.get('country_name')}, using world average."
+            )
+            return EmissionsPerKWh.from_g_per_kWh(
+                carbon_intensity_per_source.get("world_average")
+            )
+
+        return EmissionsPerKWh.from_g_per_kWh(carbon_intensity)
+
+    @staticmethod
+    def _region_energy_mix_to_emissions_rate(energy_mix: Dict) -> EmissionsPerKWh:
+        """
+        Convert a mix of energy sources into emissions per kWh
+        https://github.com/responsibleproblemsolving/energy-usage#calculating-co2-emissions
+        :param energy_mix: A dictionary that breaks down the energy produced into
+            sources, with a total value. Format will vary, but must have keys for "coal"
+            "petroleum" and "naturalGas" and "total"
+        :return: an EmissionsPerKwh object representing the average emissions rate
+        """
+        # source:
+        # https://github.com/responsibleproblemsolving/energy-usage#conversion-to-co2
+        emissions_by_source: Dict[str, EmissionsPerKWh] = {
+            "coal": EmissionsPerKWh.from_kgs_per_kWh(0.995725971),
+            "petroleum": EmissionsPerKWh.from_kgs_per_kWh(0.8166885263),
+            "naturalGas": EmissionsPerKWh.from_kgs_per_kWh(0.7438415916),
+        }
+        emissions_percentage: Dict[str, float] = {}
+        for energy_type in energy_mix.keys():
+            if energy_type not in ["total", "isoCode", "country_name"]:
+                emissions_percentage[energy_type] = (
+                    energy_mix[energy_type] / energy_mix["total"]
+                )
+        #  Weighted sum of emissions by % of contributions
+        # `emissions_percentage`: coal: 0.5, petroleum: 0.25, naturalGas: 0.25
+        # `emission_value`: coal: 0.995725971, petroleum: 0.8166885263, naturalGas: 0.7438415916 # noqa: E501
+        # `emissions_per_kWh`: (0.5 * 0.995725971) + (0.25 * 0.8166885263) * (0.25 * 0.7438415916) # noqa: E501
+        #  >> 0.5358309 kg/kWh
+        emissions_per_kWh = EmissionsPerKWh.from_kgs_per_kWh(
+            sum(
+                [
+                    emissions_percentage[source]
+                    * value.kgs_per_kWh  # % (0.x)  # kgs / kWh
+                    for source, value in emissions_by_source.items()
+                ]
+            )
+        )
+
+        return emissions_per_kWh

codecarbon/core/gpu.py

@@ -0,0 +1,305 @@
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Union
+
+import pynvml
+
+from codecarbon.core.units import Energy, Power, Time
+from codecarbon.external.logger import logger
+
+
+@dataclass
+class GPUDevice:
+    """
+    Represents a GPU device with associated energy and power metrics.
+
+    Attributes:
+        handle (any): An identifier for the GPU device.
+        gpu_index (int): The index of the GPU device in the system.
+        energy_delta (Energy): The amount of energy consumed by the GPU device
+            since the last measurement, expressed in kilowatt-hours (kWh).
+            Defaults to an initial value of 0 kWh.
+        power (Power): The current power consumption of the GPU device,
+            measured in watts (W). Defaults to an initial value of 0 W.
+        last_energy (Energy): The last recorded energy reading for the GPU
+            device, expressed in kilowatt-hours (kWh). This is used to
+            calculate `energy_delta`. Defaults to an initial value of 0 kWh.
+    """
+
+    handle: any
+    gpu_index: int
+    # Energy consumed in kWh
+    energy_delta: Energy = field(default_factory=lambda: Energy(0))
+    # Power based on reading
+    power: Power = field(default_factory=lambda: Power(0))
+    # Last energy reading in kWh
+    last_energy: Energy = field(default_factory=lambda: Energy(0))
+
+    def start(self) -> None:
+        self.last_energy = self._get_energy_kwh()
+
+    def __post_init__(self) -> None:
+        self.last_energy = self._get_energy_kwh()
+        self._init_static_details()
+
+    def _get_energy_kwh(self) -> Energy:
+        total_energy_consumption = self._get_total_energy_consumption()
+        if total_energy_consumption is None:
+            return self.last_energy
+        return Energy.from_millijoules(total_energy_consumption)
+
+    def delta(self, duration: Time) -> dict:
+        """
+        Compute the energy/power used since last call.
+        """
+        new_last_energy = energy = self._get_energy_kwh()
+        self.power = self.power.from_energies_and_delay(
+            energy, self.last_energy, duration
+        )
+        self.energy_delta = energy - self.last_energy
+        self.last_energy = new_last_energy
+        return {
+            "name": self._gpu_name,
+            "uuid": self._uuid,
+            "delta_energy_consumption": self.energy_delta,
+            "power_usage": self.power,
+        }
+
+    def get_static_details(self) -> Dict[str, Any]:
+        return {
+            "name": self._gpu_name,
+            "uuid": self._uuid,
+            "total_memory": self._total_memory,
+            "power_limit": self._power_limit,
+            "gpu_index": self.gpu_index,
+        }
+
+    def _init_static_details(self) -> None:
+        self._gpu_name = self._get_gpu_name()
+        self._uuid = self._get_uuid()
+        self._power_limit = self._get_power_limit()
+        # Get the memory
+        memory = self._get_memory_info()
+        self._total_memory = memory.total
+
+    def get_gpu_details(self) -> Dict[str, Any]:
+        # Memory
+        memory = self._get_memory_info()
+
+        device_details = {
+            "name": self._gpu_name,
+            "uuid": self._uuid,
+            "free_memory": memory.free,
+            "total_memory": memory.total,
+            "used_memory": memory.used,
+            "temperature": self._get_temperature(),
+            "power_usage": self._get_power_usage(),
+            "power_limit": self._power_limit,
+            "total_energy_consumption": self._get_total_energy_consumption(),
+            "gpu_utilization": self._get_gpu_utilization(),
+            "compute_mode": self._get_compute_mode(),
+            "compute_processes": self._get_compute_processes(),
+            "graphics_processes": self._get_graphics_processes(),
+        }
+        return device_details
+
+    def _to_utf8(self, str_or_bytes) -> Any:
+        if hasattr(str_or_bytes, "decode"):
+            return str_or_bytes.decode("utf-8", errors="replace")
+
+        return str_or_bytes
+
+    def _get_total_energy_consumption(self) -> int:
+        """Returns total energy consumption for this GPU in millijoules (mJ) since the driver was last reloaded
+        https://docs.nvidia.com/deploy/nvml-api/group__nvmlDeviceQueries.html#group__nvmlDeviceQueries_1g732ab899b5bd18ac4bfb93c02de4900a
+        """
+        try:
+            return pynvml.nvmlDeviceGetTotalEnergyConsumption(self.handle)
+        except pynvml.NVMLError:
+            logger.warning(
+                "Failed to retrieve gpu total energy consumption", exc_info=True
+            )
+            return None
+
+    def _get_gpu_name(self) -> Any:
+        """Returns the name of the GPU device
+        https://docs.nvidia.com/deploy/nvml-api/group__nvmlDeviceQueries.html#group__nvmlDeviceQueries_1ga5361803e044c6fdf3b08523fb6d1481
+        """
+        try:
+            name = pynvml.nvmlDeviceGetName(self.handle)
+            return self._to_utf8(name)
+        except UnicodeDecodeError:
+            return "Unknown GPU"
+
+    def _get_uuid(self) -> Any:
+        """Returns the globally unique GPU device UUID
+        https://docs.nvidia.com/deploy/nvml-api/group__nvmlDeviceQueries.html#group__nvmlDeviceQueries_1g72710fb20f30f0c2725ce31579832654
+        """
+        uuid = pynvml.nvmlDeviceGetUUID(self.handle)
+        return self._to_utf8(uuid)
+
+    def _get_memory_info(self):
+        """Returns memory info in bytes
+        https://docs.nvidia.com/deploy/nvml-api/group__nvmlDeviceQueries.html#group__nvmlDeviceQueries_1g2dfeb1db82aa1de91aa6edf941c85ca8
+        """
+        return pynvml.nvmlDeviceGetMemoryInfo(self.handle)
+
+    def _get_temperature(self) -> int:
+        """Returns degrees in the Celsius scale
+        https://docs.nvidia.com/deploy/nvml-api/group__nvmlDeviceQueries.html#group__nvmlDeviceQueries_1g92d1c5182a14dd4be7090e3c1480b121
+        """
+        return pynvml.nvmlDeviceGetTemperature(self.handle, pynvml.NVML_TEMPERATURE_GPU)
+
+    def _get_power_usage(self) -> int:
+        """Returns power usage in milliwatts
+        https://docs.nvidia.com/deploy/nvml-api/group__nvmlDeviceQueries.html#group__nvmlDeviceQueries_1g7ef7dff0ff14238d08a19ad7fb23fc87
+        """
+        return pynvml.nvmlDeviceGetPowerUsage(self.handle)
+
+    def _get_power_limit(self) -> Union[int, None]:
+        """Returns max power usage in milliwatts
+        https://docs.nvidia.com/deploy/nvml-api/group__nvmlDeviceQueries.html#group__nvmlDeviceQueries_1g263b5bf552d5ec7fcd29a088264d10ad
+        """
+        try:
+            return pynvml.nvmlDeviceGetEnforcedPowerLimit(self.handle)
+        except Exception:
+            return None
+
+    def _get_gpu_utilization(self):
+        """Returns the % of utilization of the kernels during the last sample
+        https://docs.nvidia.com/deploy/nvml-api/structnvmlUtilization__t.html#structnvmlUtilization__t
+        """
+        return pynvml.nvmlDeviceGetUtilizationRates(self.handle).gpu
+
+    def _get_compute_mode(self) -> int:
+        """Returns the compute mode of the GPU
+        https://docs.nvidia.com/deploy/nvml-api/group__nvmlDeviceEnumvs.html#group__nvmlDeviceEnumvs_1gbed1b88f2e3ba39070d31d1db4340233
+        """
+        return pynvml.nvmlDeviceGetComputeMode(self.handle)
+
+    def _get_compute_processes(self) -> List:
+        """Returns the list of processes ids having a compute context on the
+        device with the memory used
+        https://docs.nvidia.com/deploy/nvml-api/group__nvmlDeviceQueries.html#group__nvmlDeviceQueries_1g46ceaea624d5c96e098e03c453419d68
+        """
+        try:
+            processes = pynvml.nvmlDeviceGetComputeRunningProcesses(self.handle)
+
+            return [{"pid": p.pid, "used_memory": p.usedGpuMemory} for p in processes]
+        except pynvml.NVMLError:
+            return []
+
+    def _get_graphics_processes(self) -> List:
+        """Returns the list of processes ids having a graphics context on the
+        device with the memory used
+        https://docs.nvidia.com/deploy/nvml-api/group__nvmlDeviceQueries.html#group__nvmlDeviceQueries_1g7eacf7fa7ba4f4485d166736bf31195e
+        """
+        try:
+            processes = pynvml.nvmlDeviceGetGraphicsRunningProcesses(self.handle)
+
+            return [{"pid": p.pid, "used_memory": p.usedGpuMemory} for p in processes]
+        except pynvml.NVMLError:
+            return []
+
+
+class AllGPUDevices:
+    def __init__(self) -> None:
+        if is_gpu_details_available():
+            logger.debug("GPU available. Starting setup")
+            self.device_count = pynvml.nvmlDeviceGetCount()
+        else:
+            logger.error("There is no GPU available")
+            self.device_count = 0
+        self.devices = []
+        for i in range(self.device_count):
+            handle = pynvml.nvmlDeviceGetHandleByIndex(i)
+            gpu_device = GPUDevice(handle=handle, gpu_index=i)
+            self.devices.append(gpu_device)
+
+    def get_gpu_static_info(self) -> List:
+        """Get all GPUs static information.
+        >>> get_gpu_static_info()
+        [
+            {
+                "name": "Tesla V100-SXM2-16GB",
+                "uuid": "GPU-4e817856-1fb8-192a-7ab7-0e0e4476c184",
+                "total_memory": 16945512448,
+                "power_limit": 300000,
+                "gpu_index": 0,
+            }
+        ]
+        """
+        try:
+            devices_static_info = []
+            for i in range(self.device_count):
+                gpu_device = self.devices[i]
+                devices_static_info.append(gpu_device.get_static_details())
+            return devices_static_info
+
+        except pynvml.NVMLError:
+            logger.warning("Failed to retrieve gpu static info", exc_info=True)
+            return []
+
+    def get_gpu_details(self) -> List:
+        """Get all GPUs instantaneous metrics
+        >>> get_gpu_details()
+        [
+            {
+                "name": "Tesla V100-SXM2-16GB",
+                "uuid": "GPU-4e817856-1fb8-192a-7ab7-0e0e4476c184",
+                "free_memory": 16945381376,
+                "total_memory": 16945512448,
+                "used_memory": 131072,
+                "temperature": 28,
+                "total_energy_consumption":2000,
+                "power_usage": 42159,
+                "power_limit": 300000,
+                "gpu_utilization": 0,
+                "compute_mode": 0,
+                "compute_processes": [],
+                "graphics_processes": [],
+            }
+        ]
+        """
+        try:
+            devices_info = []
+            for i in range(self.device_count):
+                gpu_device: GPUDevice = self.devices[i]
+                devices_info.append(gpu_device.get_gpu_details())
+            return devices_info
+
+        except pynvml.NVMLError:
+            logger.warning("Failed to retrieve gpu information", exc_info=True)
+            return []
+
+    def get_delta(self, last_duration: Time) -> List:
+        """Get difference since last time this function was called
+        >>> get_delta()
+        [
+            {
+                "name": "Tesla V100-SXM2-16GB",
+                "uuid": "GPU-4e817856-1fb8-192a-7ab7-0e0e4476c184",
+                "delta_energy_consumption":2000,
+                "power_usage": 42159,
+            }
+        ]
+        """
+        try:
+            devices_info = []
+            for i in range(self.device_count):
+                gpu_device: GPUDevice = self.devices[i]
+                devices_info.append(gpu_device.delta(last_duration))
+            return devices_info
+
+        except pynvml.NVMLError:
+            logger.warning("Failed to retrieve gpu information", exc_info=True)
+            return []
+
+
+def is_gpu_details_available() -> bool:
+    """Returns True if the GPU details are available."""
+    try:
+        pynvml.nvmlInit()
+        return True
+
+    except pynvml.NVMLError:
+        return False

codecarbon/core/measure.py

@@ -0,0 +1,97 @@
+from time import perf_counter
+
+from codecarbon.external.hardware import CPU, GPU, RAM, AppleSiliconChip
+from codecarbon.external.logger import logger
+
+
+class MeasurePowerEnergy:
+    """
+    Measure power and energy consumption of a hardware component.
+    """
+
+    _last_measured_time: int = 0
+    _hardware: list
+    _pue: float
+    _total_cpu_energy: float
+    _total_gpu_energy: float
+    _total_ram_energy: float
+    _total_energy: float
+    _cpu_power: float
+    _gpu_power: float
+    _ram_power: float
+
+    def __init__(self, hardware, pue):
+        """
+        :param hardware: list of hardware components to measure
+        :param pue: Power Usage Effectiveness of the datacenter
+        """
+        self._last_measured_time = perf_counter()
+        self._hardware = hardware
+        self._pue = pue
+        # TODO: Read initial energy values from hardware
+        self._total_cpu_energy = 0
+        self._total_gpu_energy = 0
+        self._total_ram_energy = 0
+        self._total_energy = 0
+        # Power cant't be read at init because we need time, so we set it to 0
+        self._cpu_power = 0
+        self._gpu_power = 0
+        self._ram_power = 0
+
+    def do_measure(self) -> None:
+        for hardware in self._hardware:
+            h_time = perf_counter()
+            # Compute last_duration again for more accuracy
+            last_duration = perf_counter() - self._last_measured_time
+            power, energy = hardware.measure_power_and_energy(
+                last_duration=last_duration
+            )
+            # Apply the PUE of the datacenter to the consumed energy
+            energy *= self._pue
+            self._total_energy += energy
+            if isinstance(hardware, CPU):
+                self._total_cpu_energy += energy
+                self._cpu_power = power
+                logger.info(
+                    f"Energy consumed for all CPUs : {self._total_cpu_energy.kWh:.6f} kWh"
+                    + f". Total CPU Power : {self._cpu_power.W} W"
+                )
+            elif isinstance(hardware, GPU):
+                self._total_gpu_energy += energy
+                self._gpu_power = power
+                logger.info(
+                    f"Energy consumed for all GPUs : {self._total_gpu_energy.kWh:.6f} kWh"
+                    + f". Total GPU Power : {self._gpu_power.W} W"
+                )
+            elif isinstance(hardware, RAM):
+                self._total_ram_energy += energy
+                self._ram_power = power
+                logger.info(
+                    f"Energy consumed for RAM : {self._total_ram_energy.kWh:.6f} kWh."
+                    + f"RAM Power : {self._ram_power.W} W"
+                )
+            elif isinstance(hardware, AppleSiliconChip):
+                if hardware.chip_part == "CPU":
+                    self._total_cpu_energy += energy
+                    self._cpu_power = power
+                    logger.info(
+                        f"Energy consumed for AppleSilicon CPU : {self._total_cpu_energy.kWh:.6f} kWh"
+                        + f".Apple Silicon CPU Power : {self._cpu_power.W} W"
+                    )
+                elif hardware.chip_part == "GPU":
+                    self._total_gpu_energy += energy
+                    self._gpu_power = power
+                    logger.info(
+                        f"Energy consumed for AppleSilicon GPU : {self._total_gpu_energy.kWh:.6f} kWh"
+                        + f".Apple Silicon GPU Power : {self._gpu_power.W} W"
+                    )
+            else:
+                logger.error(f"Unknown hardware type: {hardware} ({type(hardware)})")
+            h_time = perf_counter() - h_time
+            logger.debug(
+                f"{hardware.__class__.__name__} : {hardware.total_power().W:,.2f} "
+                + f"W during {last_duration:,.2f} s [measurement time: {h_time:,.4f}]"
+            )
+        logger.info(
+            f"{self._total_energy.kWh:.6f} kWh of electricity used since the beginning."
+        )

codecarbon/core/powermetrics.py

@@ -0,0 +1,200 @@
+import os
+import re
+import shutil
+import subprocess
+import sys
+from typing import Dict
+
+import numpy as np
+
+from codecarbon.core.util import detect_cpu_model
+from codecarbon.external.logger import logger
+
+
+def is_powermetrics_available() -> bool:
+    try:
+        ApplePowermetrics()
+        response = _has_powermetrics_sudo()
+        return response
+    except Exception as e:
+        logger.debug(
+            "Not using PowerMetrics, an exception occurred while instantiating"
+            + f" Powermetrics : {e}",
+        )
+        return False
+
+
+def _has_powermetrics_sudo() -> bool:
+    if shutil.which("sudo") is None:
+        logger.debug("sudo not available, we won't use Apple PowerMetrics.")
+        return False
+    if shutil.which("powermetrics") is None:
+        logger.info(
+            "Apple PowerMetrics not available. Please install it if you are using an Apple product."
+        )
+        return False
+
+    with subprocess.Popen(
+        [
+            "sudo",
+            "powermetrics",
+            "--samplers",
+            "cpu_power",
+            "-n",
+            "1",
+            "-i",
+            "1",
+            "-o",
+            "/dev/null",
+        ],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    ) as process:
+        _, stderr = process.communicate()
+
+        if re.search(r"[sudo].*password", stderr):
+            logger.debug(
+                """Not using PowerMetrics, sudo password prompt detected.
+                    If you want to enable Powermetrics please modify your sudoers file
+                    as described in :
+                    https://mlco2.github.io/codecarbon/methodology.html#power-usage
+                """
+            )
+            return False
+        if process.returncode != 0:
+            raise Exception("Return code != 0")
+
+        return True
+
+
+class ApplePowermetrics:
+    """
+    A class to interact with and retrieve power metrics on Apple Silicon devices using
+    the `powermetrics` command-line tool.
+
+    Methods:
+    --------
+    __init__(output_dir: str = ".", n_points=10, interval=100, log_file_name="powermetrics_log.txt"):
+        Initializes the ApplePowermetrics instance, setting up the log file path, system info,
+        and other configurations.
+
+    get_details() -> Dict:
+        Parses the log file generated by `powermetrics` and returns a dictionary containing
+        the average CPU and GPU power consumption and energy deltas. If parsing fails, logs
+        the exception and returns an empty dictionary.
+
+    start() -> None:
+        Placeholder method for starting the energy reading process (to be implemented).
+    """
+
+    _osx_silicon_exec = "powermetrics"
+
+    def __init__(
+        self,
+        output_dir: str = ".",
+        n_points=10,
+        interval=100,
+        log_file_name="powermetrics_log.txt",
+    ):
+        self._log_file_path = os.path.join(output_dir, log_file_name)
+        self._system = sys.platform.lower()
+        self._n_points = n_points
+        self._interval = interval
+        self._setup_cli()
+
+    def _setup_cli(self) -> None:
+        """
+        Setup cli command to run Powermetrics
+        """
+        if self._system.startswith("darwin"):
+            cpu_model = detect_cpu_model()
+            if cpu_model.startswith("Apple"):
+                if shutil.which(self._osx_silicon_exec):
+                    self._cli = self._osx_silicon_exec
+                else:
+                    raise FileNotFoundError(
+                        f"Powermetrics executable not found on {self._system}"
+                    )
+        else:
+            raise SystemError("Platform not supported by Powermetrics")
+
+    def _log_values(self) -> None:
+        """
+        Logs output from Powermetrics to a file
+        """
+        returncode = None
+
+        if self._system.startswith("darwin"):
+            # Run the powermetrics command with sudo and capture its output
+            cmd = [
+                "sudo",
+                "powermetrics",
+                "-n",
+                str(self._n_points),
+                "",
+                "--samplers",
+                "cpu_power",
+                "--format",
+                "csv",
+                "-i",
+                str(self._interval),
+                "-o",
+                self._log_file_path,
+            ]
+            returncode = subprocess.call(cmd, universal_newlines=True)
+
+        else:
+            return None
+
+        if returncode != 0:
+            logger.warning(
+                "Returncode while logging power values using "
+                + f"Powermetrics: {returncode}"
+            )
+        return
+
+    def get_details(self) -> Dict:
+        """
+        Fetches the CPU Power Details by fetching values from a logged csv file
+        in _log_values function
+        """
+        self._log_values()
+        details = dict()
+        try:
+            with open(self._log_file_path) as f:
+                logfile = f.read()
+            cpu_pattern = r"CPU Power: (\d+) mW"
+            cpu_power_list = re.findall(cpu_pattern, logfile)
+
+            details["CPU Power"] = np.mean(
+                [float(power) / 1000 for power in cpu_power_list]
+            )
+            details["CPU Energy Delta"] = np.sum(
+                [
+                    (self._interval / 1000) * (float(power) / 1000)
+                    for power in cpu_power_list
+                ]
+            )
+            gpu_pattern = r"GPU Power: (\d+) mW"
+            gpu_power_list = re.findall(gpu_pattern, logfile)
+            details["GPU Power"] = np.mean(
+                [float(power) / 1000 for power in gpu_power_list]
+            )
+            details["GPU Energy Delta"] = np.sum(
+                [
+                    (self._interval / 1000) * (float(power) / 1000)
+                    for power in gpu_power_list
+                ]
+            )
+        except Exception as e:
+            logger.info(
+                f"Unable to read Powermetrics logged file at {self._log_file_path}\n \
+                Exception occurred {e}",
+                exc_info=True,
+            )
+        return details
+
+    def start(self) -> None:
+        # TODO: Read energy
+        pass

codecarbon/core/rapl.py

@@ -0,0 +1,58 @@
+from dataclasses import dataclass, field
+
+from codecarbon.core.units import Energy, Power, Time
+from codecarbon.external.logger import logger
+
+
+@dataclass
+class RAPLFile:
+    # RAPL device being measured
+    name: str
+    # Path to file containing RAPL reading
+    path: str
+    # Path to corresponding file containing maximum possible RAPL reading
+    max_path: str
+    # Energy consumed in kWh
+    energy_delta: Energy = field(default_factory=lambda: Energy(0))
+    # Power based on reading
+    power: Power = field(default_factory=lambda: Power(0))
+    # Last energy reading in kWh
+    last_energy: Energy = field(default_factory=lambda: Energy(0))
+    # Max value energy can hold before it wraps
+    max_energy_reading: Energy = field(default_factory=lambda: Energy(0))
+
+    def __post_init__(self):
+        self.last_energy = self._get_value()
+        with open(self.max_path, "r") as f:
+            max_micro_joules = float(f.read())
+
+            self.max_energy_reading = Energy.from_ujoules(max_micro_joules)
+
+    def _get_value(self) -> Energy:
+        """
+        Reads the value in the file at the path
+        """
+        with open(self.path, "r") as f:
+            micro_joules = float(f.read())
+
+            e = Energy.from_ujoules(micro_joules)
+            return e
+
+    def start(self) -> None:
+        self.last_energy = self._get_value()
+
+    def delta(self, duration: Time) -> None:
+        """
+        Compute the energy used since last call.
+        """
+        new_last_energy = energy = self._get_value()
+        if self.last_energy > energy:
+            logger.debug(
+                f"In RAPLFile : Current energy value ({energy}) is lower than previous value ({self.last_energy}). Assuming wrap-around! Source file : {self.path}"
+            )
+            energy = energy + self.max_energy_reading
+        self.power = self.power.from_energies_and_delay(
+            energy, self.last_energy, duration
+        )
+        self.energy_delta = energy - self.last_energy
+        self.last_energy = new_last_energy

codecarbon/core/resource_tracker.py

@@ -0,0 +1,230 @@
+from collections import Counter
+from typing import List, Union
+
+from codecarbon.core import cpu, gpu, powermetrics
+from codecarbon.core.config import parse_gpu_ids
+from codecarbon.core.util import detect_cpu_model, is_linux_os, is_mac_os, is_windows_os
+from codecarbon.external.hardware import CPU, GPU, MODE_CPU_LOAD, AppleSiliconChip
+from codecarbon.external.logger import logger
+from codecarbon.external.ram import RAM
+
+
+class ResourceTracker:
+    cpu_tracker = gpu_tracker = ram_tracker = "Unspecified"
+
+    def __init__(self, tracker):
+        self.tracker = tracker
+
+    def set_RAM_tracking(self):
+        logger.info("[setup] RAM Tracking...")
+        if self.tracker._force_ram_power is not None:
+            self.ram_tracker = (
+                f"User specified constant: {self.tracker._force_ram_power} Watts"
+            )
+            logger.info(
+                f"Using user-provided RAM power: {self.tracker._force_ram_power} Watts"
+            )
+        else:
+            self.ram_tracker = "RAM power estimation model"
+        ram = RAM(
+            tracking_mode=self.tracker._tracking_mode,
+            force_ram_power=self.tracker._force_ram_power,
+        )
+        self.tracker._conf["ram_total_size"] = ram.machine_memory_GB
+        self.tracker._hardware: List[Union[RAM, CPU, GPU, AppleSiliconChip]] = [ram]
+
+    def set_CPU_tracking(self):
+        logger.info("[setup] CPU Tracking...")
+        cpu_number = self.tracker._conf.get("cpu_physical_count")
+        tdp = cpu.TDP()
+        if self.tracker._force_cpu_power is not None:
+            logger.info(
+                f"Using user-provided CPU power: {self.tracker._force_cpu_power} Watts"
+            )
+            self.cpu_tracker = "User Input TDP constant"
+            max_power = self.tracker._force_cpu_power
+        else:
+            max_power = tdp.tdp * cpu_number if tdp.tdp is not None else None
+        if self.tracker._conf.get("force_mode_cpu_load", False) and (
+            tdp.tdp is not None or self.tracker._force_cpu_power is not None
+        ):
+            if cpu.is_psutil_available():
+                # Register a CPU with MODE_CPU_LOAD
+                model = tdp.model
+                hardware_cpu = CPU.from_utils(
+                    self.tracker._output_dir,
+                    MODE_CPU_LOAD,
+                    model,
+                    max_power,
+                    tracking_mode=self.tracker._tracking_mode,
+                )
+                self.cpu_tracker = MODE_CPU_LOAD
+                self.tracker._conf["cpu_model"] = hardware_cpu.get_model()
+                self.tracker._hardware.append(hardware_cpu)
+                return
+            else:
+                logger.warning(
+                    "Force CPU load mode requested but psutil is not available."
+                )
+        if cpu.is_powergadget_available() and self.tracker._force_cpu_power is None:
+            logger.info("Tracking Intel CPU via Power Gadget")
+            self.cpu_tracker = "Power Gadget"
+            hardware_cpu = CPU.from_utils(
+                self.tracker._output_dir, "intel_power_gadget"
+            )
+            self.tracker._hardware.append(hardware_cpu)
+            self.tracker._conf["cpu_model"] = hardware_cpu.get_model()
+        elif cpu.is_rapl_available():
+            logger.info("Tracking Intel CPU via RAPL interface")
+            self.cpu_tracker = "RAPL"
+            hardware_cpu = CPU.from_utils(
+                output_dir=self.tracker._output_dir, mode="intel_rapl"
+            )
+            self.tracker._hardware.append(hardware_cpu)
+            self.tracker._conf["cpu_model"] = hardware_cpu.get_model()
+            if "AMD Ryzen Threadripper" in self.tracker._conf["cpu_model"]:
+                logger.warning(
+                    "The RAPL energy and power reported is divided by 2 for all 'AMD Ryzen Threadripper' as it seems to give better results."
+                )
+        # change code to check if powermetrics needs to be installed or just sudo setup
+        elif (
+            powermetrics.is_powermetrics_available()
+            and self.tracker._force_cpu_power is None
+        ):
+            logger.info("Tracking Apple CPU and GPU via PowerMetrics")
+            self.gpu_tracker = "PowerMetrics"
+            self.cpu_tracker = "PowerMetrics"
+            hardware_cpu = AppleSiliconChip.from_utils(
+                self.tracker._output_dir, chip_part="CPU"
+            )
+            self.tracker._hardware.append(hardware_cpu)
+            self.tracker._conf["cpu_model"] = hardware_cpu.get_model()
+
+            hardware_gpu = AppleSiliconChip.from_utils(
+                self.tracker._output_dir, chip_part="GPU"
+            )
+            self.tracker._hardware.append(hardware_gpu)
+
+            self.tracker._conf["gpu_model"] = hardware_gpu.get_model()
+            self.tracker._conf["gpu_count"] = 1
+        else:
+            # Explain what to install to increase accuracy
+            cpu_tracking_install_instructions = ""
+            if is_mac_os():
+                if (
+                    "M1" in detect_cpu_model()
+                    or "M2" in detect_cpu_model()
+                    or "M3" in detect_cpu_model()
+                ):
+                    cpu_tracking_install_instructions = ""
+                    cpu_tracking_install_instructions = "Mac OS and ARM processor detected: Please enable PowerMetrics sudo to measure CPU"
+                else:
+                    cpu_tracking_install_instructions = "Mac OS detected: Please install Intel Power Gadget or enable PowerMetrics sudo to measure CPU"
+            elif is_windows_os():
+                cpu_tracking_install_instructions = "Windows OS detected: Please install Intel Power Gadget to measure CPU"
+            elif is_linux_os():
+                cpu_tracking_install_instructions = "Linux OS detected: Please ensure RAPL files exist at /sys/class/powercap/intel-rapl/subsystem to measure CPU"
+            logger.warning(
+                f"No CPU tracking mode found. Falling back on estimation based on TDP for CPU. \n {cpu_tracking_install_instructions}\n"
+            )
+            self.cpu_tracker = "TDP constant"
+            model = tdp.model
+            if (max_power is None) and self.tracker._force_cpu_power:
+                # We haven't been able to calculate CPU power but user has input a default one. We use it
+                user_input_power = self.tracker._force_cpu_power
+                logger.debug(f"Using user input TDP: {user_input_power} W")
+                self.cpu_tracker = "User Input TDP constant"
+                max_power = user_input_power
+            logger.info(f"CPU Model on constant consumption mode: {model}")
+            self.tracker._conf["cpu_model"] = model
+            if tdp:
+                if cpu.is_psutil_available():
+                    logger.warning(
+                        "No CPU tracking mode found. Falling back on CPU load mode."
+                    )
+                    hardware_cpu = CPU.from_utils(
+                        self.tracker._output_dir,
+                        MODE_CPU_LOAD,
+                        model,
+                        max_power,
+                        tracking_mode=self.tracker._tracking_mode,
+                    )
+                    self.cpu_tracker = MODE_CPU_LOAD
+                else:
+                    logger.warning(
+                        "No CPU tracking mode found. Falling back on CPU constant mode."
+                    )
+                    hardware_cpu = CPU.from_utils(
+                        self.tracker._output_dir, "constant", model, max_power
+                    )
+                    self.cpu_tracker = "global constant"
+                self.tracker._hardware.append(hardware_cpu)
+            else:
+                if cpu.is_psutil_available():
+                    logger.warning(
+                        "Failed to match CPU TDP constant. Falling back on CPU load mode."
+                    )
+                    hardware_cpu = CPU.from_utils(
+                        self.tracker._output_dir,
+                        MODE_CPU_LOAD,
+                        model,
+                        max_power,
+                        tracking_mode=self.tracker._tracking_mode,
+                    )
+                    self.cpu_tracker = MODE_CPU_LOAD
+                else:
+                    logger.warning(
+                        "Failed to match CPU TDP constant. Falling back on a global constant."
+                    )
+                    self.cpu_tracker = "global constant"
+                    hardware_cpu = CPU.from_utils(self.tracker._output_dir, "constant")
+                self.tracker._hardware.append(hardware_cpu)
+
+    def set_GPU_tracking(self):
+        logger.info("[setup] GPU Tracking...")
+        if self.tracker._gpu_ids:
+            # If _gpu_ids is a string or a list of int, parse it to a list of ints
+            if isinstance(self.tracker._gpu_ids, str) or (
+                isinstance(self.tracker._gpu_ids, list)
+                and all(isinstance(gpu_id, int) for gpu_id in self.tracker._gpu_ids)
+            ):
+                self.tracker._gpu_ids: List = parse_gpu_ids(self.tracker._gpu_ids)
+                self.tracker._conf["gpu_ids"] = self.tracker._gpu_ids
+                self.tracker._conf["gpu_count"] = len(self.tracker._gpu_ids)
+            else:
+                logger.warning(
+                    "Invalid gpu_ids format. Expected a string or a list of ints."
+                )
+        if gpu.is_gpu_details_available():
+            logger.info("Tracking Nvidia GPU via pynvml")
+            gpu_devices = GPU.from_utils(self.tracker._gpu_ids)
+            self.tracker._hardware.append(gpu_devices)
+            gpu_names = [n["name"] for n in gpu_devices.devices.get_gpu_static_info()]
+            gpu_names_dict = Counter(gpu_names)
+            self.tracker._conf["gpu_model"] = "".join(
+                [f"{i} x {name}" for name, i in gpu_names_dict.items()]
+            )
+            if self.tracker._conf.get("gpu_count") is None:
+                self.tracker._conf["gpu_count"] = len(
+                    gpu_devices.devices.get_gpu_static_info()
+                )
+            self.gpu_tracker = "pynvml"
+        else:
+            logger.info("No GPU found.")
+
+    def set_CPU_GPU_ram_tracking(self):
+        """
+        Set up CPU, GPU and RAM tracking based on the user's configuration.
+        param tracker: BaseEmissionsTracker object
+        """
+        self.set_RAM_tracking()
+        self.set_CPU_tracking()
+        self.set_GPU_tracking()
+
+        logger.info(
+            f"""The below tracking methods have been set up:
+                RAM Tracking Method: {self.ram_tracker}
+                CPU Tracking Method: {self.cpu_tracker}
+                GPU Tracking Method: {self.gpu_tracker}
+            """
+        )

codecarbon/core/schemas.py

@@ -0,0 +1,110 @@
+"""
+Here is the schemas used to communicate with the API.
+"""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+from uuid import UUID
+
+
+@dataclass
+class EmissionBase:
+    timestamp: str
+    run_id: str
+    duration: int
+    emissions_sum: float
+    emissions_rate: float
+    cpu_power: float
+    gpu_power: float
+    ram_power: float
+    cpu_energy: float
+    gpu_energy: float
+    ram_energy: float
+    energy_consumed: float
+
+
+class EmissionCreate(EmissionBase):
+    pass
+
+
+class Emission(EmissionBase):
+    id: str
+
+
+@dataclass
+class RunBase:
+    timestamp: str
+    experiment_id: str
+    os: Optional[str]
+    python_version: Optional[str]
+    codecarbon_version: Optional[str]
+    cpu_count: Optional[int]
+    cpu_model: Optional[str]
+    gpu_count: Optional[int]
+    gpu_model: Optional[str]
+    longitude: Optional[float]
+    latitude: Optional[float]
+    region: Optional[str]
+    provider: Optional[str]
+    ram_total_size: Optional[float]
+    tracking_mode: Optional[str]
+
+
+class RunCreate(RunBase):
+    pass
+
+
+class Run(RunBase):
+    id: str
+
+
+@dataclass
+class ExperimentBase:
+    timestamp: datetime
+    name: str
+    description: str
+    on_cloud: bool
+    project_id: UUID
+    country_name: Optional[str] = None
+    country_iso_code: Optional[str] = None
+    region: Optional[str] = None
+    cloud_provider: Optional[str] = None
+    cloud_region: Optional[str] = None
+
+
+class ExperimentCreate(ExperimentBase):
+    pass
+
+
+class Experiment(ExperimentBase):
+    id: str
+
+
+@dataclass
+class OrganizationBase:
+    name: str
+    description: str
+
+
+class OrganizationCreate(OrganizationBase):
+    pass
+
+
+class Organization(OrganizationBase):
+    id: str
+
+
+@dataclass
+class ProjectBase:
+    name: str
+    description: str
+    organization_id: str
+
+
+class ProjectCreate(ProjectBase):
+    pass
+
+
+class Project(ProjectBase):
+    id: str

codecarbon/core/units.py

@@ -0,0 +1,164 @@
+"""
+Provides functionality for unit conversions
+"""
+
+from dataclasses import dataclass, field
+
+# from pydantic.dataclasses import dataclass, field
+
+
+@dataclass
+class Time:
+    """
+    Measured in seconds
+    """
+
+    seconds: float
+    SECONDS_TO_HOURS = 1 / 3600
+
+    @property
+    def hours(self) -> float:
+        return self.seconds * Time.SECONDS_TO_HOURS
+
+    @classmethod
+    def from_seconds(cls, seconds: float) -> "Time":
+        return cls(seconds=seconds)
+
+
+@dataclass
+class EmissionsPerKWh:
+    """
+    Measured in kg/kWh
+    """
+
+    LBS_MWH_TO_KG_KWH = 0.00045359237
+    G_KWH_TO_KG_KWH = 0.001
+
+    kgs_per_kWh: float
+
+    @classmethod
+    def from_lbs_per_mWh(cls, lbs_per_mWh: float) -> "EmissionsPerKWh":
+        return cls(kgs_per_kWh=lbs_per_mWh * EmissionsPerKWh.LBS_MWH_TO_KG_KWH)
+
+    @classmethod
+    def from_g_per_kWh(cls, g_per_kWh: float) -> "EmissionsPerKWh":
+        return cls(kgs_per_kWh=g_per_kWh * EmissionsPerKWh.G_KWH_TO_KG_KWH)
+
+    @classmethod
+    def from_kgs_per_kWh(cls, kgs_per_kWh: float) -> "EmissionsPerKWh":
+        return cls(kgs_per_kWh=kgs_per_kWh)
+
+
+@dataclass(order=True)
+class Energy:
+    """
+    Measured in kWh
+    """
+
+    UJOULES_TO_JOULES = 10 ** (-6)
+    MILLIJOULES_TO_JOULES = 10 ** (-3)
+    JOULES_TO_KWH = 2.77778e-7
+
+    kWh: float = field(compare=True)
+
+    def __post_init__(self):
+        self.kWh = float(self.kWh)
+
+    @classmethod
+    def from_power_and_time(cls, *, power: "Power", time: "Time") -> "Energy":
+        assert isinstance(power.kW, float)
+        assert isinstance(time.hours, float)
+        energy = power.kW * time.hours
+        return cls(kWh=energy)
+
+    @classmethod
+    def from_ujoules(cls, energy: float) -> "Energy":
+        return cls(kWh=energy * Energy.UJOULES_TO_JOULES * Energy.JOULES_TO_KWH)
+
+    @classmethod
+    def from_millijoules(cls, energy: float) -> "Energy":
+        return cls(kWh=energy * Energy.MILLIJOULES_TO_JOULES * Energy.JOULES_TO_KWH)
+
+    @classmethod
+    def from_energy(cls, kWh: float) -> "Energy":
+        return cls(kWh=kWh)
+
+    def __sub__(self, other: "Energy") -> "Energy":
+        return Energy(self.kWh - other.kWh)
+
+    def __add__(self, other: "Energy") -> "Energy":
+        return Energy(self.kWh + other.kWh)
+
+    def __mul__(self, factor: float) -> "Energy":
+        assert isinstance(factor, float)
+        assert isinstance(self.kWh, float)
+        result = Energy(self.kWh * factor)
+        return result
+
+    def __float__(self) -> float:
+        return float(self.kWh)
+
+    def __truediv__(self, divisor: float) -> "Energy":
+        return Energy(self.kWh / divisor)
+
+
+@dataclass
+class Power:
+    """
+    Measured in kW
+    """
+
+    MILLI_WATTS_TO_WATTS = 0.001
+    WATTS_TO_KILO_WATTS = 0.001
+
+    kW: float
+
+    @classmethod
+    def from_milli_watts(cls, milli_watts: float) -> "Power":
+        return cls(
+            kW=milli_watts * Power.MILLI_WATTS_TO_WATTS * Power.WATTS_TO_KILO_WATTS
+        )
+
+    @classmethod
+    def from_watts(cls, watts: float) -> "Power":
+        return cls(kW=watts * Power.WATTS_TO_KILO_WATTS)
+
+    @classmethod
+    def from_energies_and_delay(cls, e1: "Energy", e2: "Energy", delay: "Time"):
+        """
+        P = (E_{t1} - E_{t2}) / delay (=t2-t1)
+        kW      kWh       kWh     h
+
+        Args:
+            e1 (Energy): First measurement
+            e2 (Energy): Second measurement
+            delay (Time): Time between measurements
+
+        Returns:
+            Power: Resulting Power estimation
+        """
+        delta_energy = float(abs(e2.kWh - e1.kWh))
+        kW = delta_energy / delay.hours if delay.hours != 0.0 else 0.0
+        return cls(kW=kW)
+
+    @classmethod
+    def from_energy_delta_and_delay(cls, e: "Energy", delay: "Time"):
+        return cls.from_energies_and_delay(e, Energy(0), delay)
+
+    @property
+    def W(self):
+        if not isinstance(self.kW, float):
+            return self.kW
+        return self.kW * 1000
+
+    def __add__(self, other: "Power") -> "Power":
+        return Power(self.kW + other.kW)
+
+    def __mul__(self, factor: float) -> "Power":
+        return Power(self.kW * factor)
+
+    def __truediv__(self, divisor: float) -> "Power":
+        return Power(self.kW / divisor)
+
+    def __floordiv__(self, divisor: float) -> "Power":
+        return Power(self.kW // divisor)

codecarbon/core/util.py

@@ -0,0 +1,157 @@
+import os
+import re
+import subprocess
+import sys
+from contextlib import contextmanager
+from os.path import expandvars
+from pathlib import Path
+from typing import Optional, Union
+
+import cpuinfo
+import psutil
+
+from codecarbon.external.logger import logger
+
+SLURM_JOB_ID = os.environ.get(
+    "SLURM_JOB_ID",  # default
+    os.environ.get("SLURM_JOBID"),  # deprecated but may still be used
+)
+
+
+@contextmanager
+def suppress(*exceptions):
+    try:
+        yield
+    except exceptions:
+        logger.warning("graceful shutdown. Exceptions:")
+        logger.warning(
+            exceptions if len(exceptions) != 1 else exceptions[0], exc_info=True
+        )
+        logger.warning("stopping.")
+
+
+def resolve_path(path: Union[str, Path]) -> Path:
+    """
+    Fully resolve a path:
+    resolve env vars ($HOME etc.) -> expand user (~) -> make absolute
+
+    Args:
+        path (Union[str, Path]): Path to a file or repository to resolve as
+            string or pathlib.Path
+
+    Returns:
+        pathlib.Path: resolved absolute path
+    """
+    return Path(expandvars(str(path))).expanduser().resolve()
+
+
+def backup(file_path: Union[str, Path], ext: Optional[str] = ".bak") -> None:
+    """
+    Resolves the path to a path then backs it up, adding the extension provided.
+    Warning : this function will rename the file in place, it's the calling function that will write a new file at the original path.
+    This function will not overwrite existing backups but add a number.
+
+    Args:
+        file_path (Union[str, Path]): Path to a file to backup.
+        ext (Optional[str], optional): extension to append to the filename when
+            backing it up. Defaults to ".bak".
+    """
+    file_path = resolve_path(file_path)
+    if not file_path.exists():
+        return
+    assert file_path.is_file()
+    idx = 0
+    parent = file_path.parent
+    file_name = f"{file_path.name}{ext}"
+    backup_path = parent / file_name
+
+    while backup_path.exists():
+        file_name = f"{file_path.name}_{idx}{ext}"
+        backup_path = parent / file_name
+        idx += 1
+
+    file_path.rename(backup_path)
+
+
+def detect_cpu_model() -> str:
+    cpu_info = cpuinfo.get_cpu_info()
+    if cpu_info:
+        cpu_model_detected = cpu_info.get("brand_raw", "")
+        return cpu_model_detected
+    return None
+
+
+def is_mac_os() -> str:
+    system = sys.platform.lower()
+    return system.startswith("dar")
+
+
+def is_windows_os() -> str:
+    system = sys.platform.lower()
+    return system.startswith("win")
+
+
+def is_linux_os() -> str:
+    system = sys.platform.lower()
+    return system.startswith("lin")
+
+
+def count_physical_cpus():
+    import platform
+    import subprocess
+
+    if platform.system() == "Windows":
+        return int(os.environ.get("NUMBER_OF_PROCESSORS", 1))
+    else:
+        try:
+            output = subprocess.check_output(["lscpu"], text=True)
+            for line in output.split("\n"):
+                if "Socket(s):" in line:
+                    return int(line.split(":")[1].strip())
+            else:
+                return 1
+        except Exception as e:
+            logger.warning(
+                f"Error while trying to count physical CPUs: {e}. Defaulting to 1."
+            )
+            return 1
+
+
+def count_cpus() -> int:
+    if SLURM_JOB_ID is None:
+        return psutil.cpu_count()
+
+    try:
+        logger.debug(
+            "SLURM environment detected for job {SLURM_JOB_ID}, running"
+            + " `scontrol show job $SLURM_JOB_ID` to count SLURM-available cpus."
+        )
+        scontrol = subprocess.check_output(
+            [f"scontrol show job {SLURM_JOB_ID}"], shell=True
+        ).decode()
+    except subprocess.CalledProcessError:
+        logger.warning(
+            "Error running `scontrol show job $SLURM_JOB_ID` "
+            + "to count SLURM-available cpus. Using the machine's cpu count."
+        )
+        return psutil.cpu_count(logical=True)
+
+    num_cpus_matches = re.findall(r"NumCPUs=\d+", scontrol)
+
+    if len(num_cpus_matches) == 0:
+        logger.warning(
+            "Could not find NumCPUs= after running `scontrol show job $SLURM_JOB_ID` "
+            + "to count SLURM-available cpus. Using the machine's cpu count."
+        )
+        return psutil.cpu_count(logical=True)
+
+    if len(num_cpus_matches) > 1:
+        logger.warning(
+            "Unexpected output after running `scontrol show job $SLURM_JOB_ID` "
+            + "to count SLURM-available cpus. Using the machine's cpu count."
+        )
+        return psutil.cpu_count(logical=True)
+
+    num_cpus = num_cpus_matches[0].replace("NumCPUs=", "")
+    logger.debug(f"Detected {num_cpus} cpus available on SLURM.")
+    return int(num_cpus)

codecarbon/data/cloud/impact.csv

@@ -0,0 +1,41 @@
+provider,providerName,offsetRatio,region,regionName,country_name,countryIsoCode,state,city,impact,source,comment
+gcp,Google Cloud Platform,100,africa-south1,,South Africa,ZAF,,Johannesburg,646,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,asia-east1,,Taiwan,TWN,,Changhua County,451,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,asia-east2,,China,CHN,,Hong Kong,360,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,asia-northeast1,,Japan,JPN,,Tokyo,459,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,asia-northeast2,,Japan,JPN,,Osaka,385,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,asia-northeast3,,Korea,KOR,South Korea,Seoul,378,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,asia-south1,,India,IND,,Mumbai,648,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,asia-south2,,India,IND,,Delhi,529,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,asia-southeast1,,Singapore,SGP,,Jurong West,369,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,asia-southeast2,,Indonesia,IDN,,Jakarta,580,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,australia-southeast1,,Australia,AUS,,Sydney,501,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,australia-southeast2,,Australia,AUS,,Melbourne,456,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,europe-central2,,Poland,POL,,Warsaw,723,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,europe-north1,,Finland,FIN,,Hamina,46,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,europe-southwest1,,Spain,ESP,,Madrid,131,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,europe-west1,,Belgium,BEL,,St. Ghislain,122,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,europe-west2,,United Kingdom,GBR,England,London,136,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,europe-west3,,Germany,DEU,,Frankfurt,345,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,europe-west4,,Netherlands,NLD,,Eemshaven,236,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,europe-west6,,Switzerland,CHE,,Zurich,59,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,europe-west8,,Italy,ITA,,Milan,249,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,europe-west9,,France,FRA,,Paris,34,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,europe-west10,,Germany,DEU,,Berlin,345,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,europe-west12,,Italy,ITA,,Turin,249,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,me-cenrtal1,,Qatar,QAT,,Doha,575,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,me-central2,,Saudi Arabia,SAU,,Dammam,569,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,me-west1,,Israel,ISR,,Tel Aviv,463,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,northamerica-northeast1,,Canada,CAN,Quebec,Montreal,2,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,northamerica-northeast2,,Canada,CAN,,Toronto,47,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,southamerica-east1,,Brazil,BRA,,Sao Paulo,56,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,southamerica-west1,,Chile,CHL,,Santiago,138,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,us-central1,,USA,USA,Iowa,Council Bluffs,430,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,us-east1,,USA,USA,South Carolina,Moncks Corner,560,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,us-east4,,USA,USA,Northern Virginia,Ashburn,322,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,us-east5,,USA,USA,,Columbus,322,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,us-south1,,USA,USA,,Dallas,321,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,us-west1,,USA,USA,Oregon,The Dalles,94,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,us-west2,,USA,USA,California,Los Angeles,198,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,us-west3,,USA,USA,Utah,Salt Lake City,588,https://cloud.google.com/sustainability/region-carbon#data,
+gcp,Google Cloud Platform,100,us-west4,,USA,USA,Nevada,Las Vegas,373,https://cloud.google.com/sustainability/region-carbon#data,

codecarbon/data/hardware/cpu_dataset_builder/CPU_Create_Dataset.ipynb

@@ -0,0 +1,1671 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We want to build a CPU dataset.\n",
+    "There is pointer on https://github.com/felixsteinke/cpu-spec-dataset\n",
+    "\n",
+    "## AMD Dataset\n",
+    "\n",
+    "Manually Export Data as CSV/Excel from https://www.amd.com/en/products/specifications/processors\n",
+    "Website Screenshot\n",
+    "\n",
+    "blob:https://www.amd.com/fc70f2d3-27d4-4bf1-a466-9912927167de\n",
+    "\n",
+    "## Ampere Dataset\n",
+    "\n",
+    "Extracted from https://amperecomputing.com/briefs/ampere-altra-family-product-brief with the responsible Web Scraper.\n",
+    "\n",
+    "cd ampere-web-scraper\n",
+    "java -jar ./target/exectuable.jar\n",
+    "\n",
+    "## Intel Dataset\n",
+    "\n",
+    "Extracted from https://ark.intel.com/content/www/us/en/ark.html with the responsible Web Scraper.\n",
+    "\n",
+    "cd intel-web-scraper\n",
+    "java -jar ./target/exectuable.jar\n",
+    "\n",
+    "## CPU Benchmark Dataset\n",
+    "\n",
+    "Extracted from https://www.cpubenchmark.net/cpu_list.php with the responsible Web Scraper.\n",
+    "\n",
+    "cd benchmark-web-scraper\n",
+    "java -jar ./target/exectuable.jar\n",
+    "\n",
+    "## CPU World Dataset\n",
+    "\n",
+    "Extracted from https://www.cpu-world.com/CPUs/CPU.html with the responsible Web Scraper.\n",
+    "\n",
+    "cd cpuworld-web-scraper\n",
+    "mvn -jar ./target/exectuable.jar"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "test"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Extraction from https://www.intel.com/content/www/us/en/ark/products/series/236644/5th-gen-intel-xeon-scalable-processors.html\n",
+    "```html\n",
+    "<table id=\"product-table\" class=\"table table-sorter sorting tablesorter tablesorter-default\">\n",
+    "                                <thead>\n",
+    "                                    <tr class=\"tablesorter-headerRow\">\n",
+    "                                        <th class=\"product-table-sortable-col product-name-col ark-product-name xlarge-column component header tablesorter-header\" data-component=\"wa_skip_track\" data-component-id=\"1\" data-col=\"productName\" data-sort-field=\"productName\" role=\"columnheader\" aria-sort=\"\" aria-rowindex=\"1\" data-column=\"0\"><div class=\"tablesorter-header-inner\">\n",
+    "                                            <div class=\"header-additional-padding\">\n",
+    "                                                <div class=\"header-text-space\">\n",
+    "                                                    Product Name\n",
+    "                                                </div>\n",
+    "                                            </div>\n",
+    "                                        </div></th>\n",
+    "                                        \n",
+    "                                            \n",
+    "                                                \n",
+    "                                                    <th class=\"product-table-sortable-col component medium-column descending tablesorter-header\" data-component=\"wa_skip_track\" data-component-id=\"1\" data-col=\"BornOnDate\" role=\"columnheader\" aria-sort=\"\" aria-rowindex=\"1\" data-column=\"1\"><div class=\"tablesorter-header-inner\">\n",
+    "                                                        <div class=\"header-additional-padding\">\n",
+    "                                                            <div class=\"header-text-space\">\n",
+    "                                                                Launch Date\n",
+    "                                                            </div>\n",
+    "                                                        </div>\n",
+    "                                                    </div></th>\n",
+    "                                                \n",
+    "                                            \n",
+    "                                                \n",
+    "                                                    <th class=\"product-table-sortable-col component medium-column tablesorter-header\" data-component=\"wa_skip_track\" data-component-id=\"1\" data-col=\"CoreCount\" role=\"columnheader\" aria-sort=\"\" aria-rowindex=\"1\" data-column=\"2\"><div class=\"tablesorter-header-inner\">\n",
+    "                                                        <div class=\"header-additional-padding\">\n",
+    "                                                            <div class=\"header-text-space\">\n",
+    "                                                                Total Cores\n",
+    "                                                            </div>\n",
+    "                                                        </div>\n",
+    "                                                    </div></th>\n",
+    "                                                \n",
+    "                                            \n",
+    "                                                \n",
+    "                                                    <th class=\"product-table-sortable-col component medium-column tablesorter-header\" data-component=\"wa_skip_track\" data-component-id=\"1\" data-col=\"ClockSpeedMax\" role=\"columnheader\" aria-sort=\"\" aria-rowindex=\"1\" data-column=\"3\"><div class=\"tablesorter-header-inner\">\n",
+    "                                                        <div class=\"header-additional-padding\">\n",
+    "                                                            <div class=\"header-text-space\">\n",
+    "                                                                Max Turbo Frequency\n",
+    "                                                            </div>\n",
+    "                                                        </div>\n",
+    "                                                    </div></th>\n",
+    "                                                \n",
+    "                                            \n",
+    "                                                \n",
+    "                                                    <th class=\"product-table-sortable-col component medium-column tablesorter-header\" data-component=\"wa_skip_track\" data-component-id=\"1\" data-col=\"ClockSpeed\" role=\"columnheader\" aria-sort=\"\" aria-rowindex=\"1\" data-column=\"4\"><div class=\"tablesorter-header-inner\">\n",
+    "                                                        <div class=\"header-additional-padding\">\n",
+    "                                                            <div class=\"header-text-space\">\n",
+    "                                                                Processor Base Frequency\n",
+    "                                                            </div>\n",
+    "                                                        </div>\n",
+    "                                                    </div></th>\n",
+    "                                                \n",
+    "                                            \n",
+    "                                                \n",
+    "                                                    <th class=\"product-table-sortable-col component medium-column tablesorter-header\" data-component=\"wa_skip_track\" data-component-id=\"1\" data-col=\"Cache\" role=\"columnheader\" aria-sort=\"\" aria-rowindex=\"1\" data-column=\"5\"><div class=\"tablesorter-header-inner\">\n",
+    "                                                        <div class=\"header-additional-padding\">\n",
+    "                                                            <div class=\"header-text-space\">\n",
+    "                                                                Cache\n",
+    "                                                            </div>\n",
+    "                                                        </div>\n",
+    "                                                    </div></th>\n",
+    "                                                \n",
+    "                                            \n",
+    "                                                \n",
+    "                                                    <th class=\"product-table-sortable-col component medium-column tablesorter-header\" data-component=\"wa_skip_track\" data-component-id=\"1\" data-col=\"MaxTDP\" role=\"columnheader\" aria-sort=\"\" aria-rowindex=\"1\" data-column=\"6\"><div class=\"tablesorter-header-inner\">\n",
+    "                                                        <div class=\"header-additional-padding\">\n",
+    "                                                            <div class=\"header-text-space\">\n",
+    "                                                                TDP\n",
+    "                                                            </div>\n",
+    "                                                        </div>\n",
+    "                                                    </div></th>\n",
+    "                                                \n",
+    "                                            \n",
+    "                                        \n",
+    "                                    </tr>\n",
+    "                                </thead>\n",
+    "                                <tbody>\n",
+    "                                    \n",
+    "                                        <tr class=\"blank-table-row   seg-server  seg-embedded  seg-retailsku\" data-codename=\"Sapphire Rapids\" data-filter=\"Server\" data-product-id=\"236639\">\n",
+    "\n",
+    "                                            \n",
+    "                                            \n",
+    "\n",
+    "                                            <td class=\"ark-product-name ark-accessible-color component\" data-value=\"1\" data-component=\"arkproductlink\" data-component-id=\"1\">\n",
+    "                                                <div class=\"add-compare-wrap\">\n",
+    "                                                    <label class=\"containerCB component\" data-component=\"wa_skip_track\" data-component-id=\"1\">\n",
+    "                                                        <input class=\"compare-checkbox compare-toggle\" data-component=\"ark-component\" data-product-id=\"236639\" type=\"checkbox\">\n",
+    "                                                        <span class=\"checkmark\"></span>\n",
+    "                                                    </label>\n",
+    "                                                    <a href=\"/content/www/us/en/products/sku/236639/intel-xeon-bronze-3508u-processor-22-5m-cache-2-10-ghz/specifications.html\">Intel® Xeon® Bronze 3508U Processor</a>\n",
+    "                                                </div>\n",
+    "                                            </td>\n",
+    "\n",
+    "                                            \n",
+    "                                                \n",
+    "                                                    <td class=\"\" data-value=\"\">\n",
+    "                                                        \n",
+    "                                                            \n",
+    "                                                                \n",
+    "                                                                \n",
+    "                                                                \n",
+    "                                                                    Q4'23\n",
+    "                                                                \n",
+    "                                                            \n",
+    "                                                        \n",
+    "                                                    </td>\n",
+    "                                                \n",
+    "                                            \n",
+    "                                                \n",
+    "                                                    <td class=\"\" data-value=\"8\">\n",
+    "                                                        \n",
+    "                                                            \n",
+    "                                                                \n",
+    "                                                                \n",
+    "                                                                \n",
+    "                                                                    8\n",
+    "                                                                \n",
+    "                                                            \n",
+    "                                                        \n",
+    "                                                    </td>\n",
+    "                                                \n",
+    "                                            \n",
+    "                                                \n",
+    "                                                    <td class=\"\" data-value=\"2200\">\n",
+    "                                                        \n",
+    "                                                            \n",
+    "                                                                \n",
+    "                                                                \n",
+    "                                                                \n",
+    "                                                                    2.2 GHz\n",
+    "                                                                \n",
+    "                                                            \n",
+    "                                                        \n",
+    "                                                    </td>\n",
+    "                                                \n",
+    "                                            \n",
+    "                                                \n",
+    "                                                    <td class=\"\" data-value=\"2100\">\n",
+    "                                                        \n",
+    "                                                            \n",
+    "                                                                \n",
+    "                                                                \n",
+    "                                                                \n",
+    "                                                                    2.10 GHz\n",
+    "                                                                \n",
+    "                                                            \n",
+    "                                                        \n",
+    "                                                    </td>\n",
+    "                                                \n",
+    "                                            \n",
+    "                                                \n",
+    "                                                    <td class=\"\" data-value=\"23040\">\n",
+    "                                                        \n",
+    "                                                            \n",
+    "                                                                \n",
+    "                                                                \n",
+    "                                                                \n",
+    "                                                                    22.5 MB\n",
+    "                                                                \n",
+    "                                                            \n",
+    "                                                        \n",
+    "                                                    </td>\n",
+    "                                                \n",
+    "                                            \n",
+    "                                                \n",
+    "                                                    <td class=\"\" data-value=\"125\">\n",
+    "                                                        \n",
+    "                                                            \n",
+    "                                                                \n",
+    "                                                                \n",
+    "                                                                \n",
+    "                                                                    125 W\n",
+    "                                                                \n",
+    "                                                            \n",
+    "                                                        \n",
+    "                                                    </td>\n",
+    "                                                \n",
+    "                                            \n",
+    "                                        </tr>\n",
+    "                                    \n",
+    "                                   ```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**AI Prompt**\n",
+    "\n",
+    "How to automate extraction ?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**AI Response**\n",
+    "\n",
+    "I see you're looking to extract CPU data from Intel's website. Before diving into the automation, I'd like to understand a few things:\n",
+    "\n",
+    "1. Are you comfortable with Python programming? \n",
+    "2. Have you tried web scraping before?\n",
+    "3. Would you prefer using a specific library (like BeautifulSoup, Scrapy, or Selenium)?\n",
+    "\n",
+    "This looks like a dynamic table with sortable columns, so we'll need to consider the best approach based on your experience level and requirements. Let me know your preferences, and I'll help guide you through the process."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**AI Prompt**\n",
+    "\n",
+    "BeautifulSoup"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**AI Response**\n",
+    "\n",
+    "Great choice! BeautifulSoup is perfect for this. Looking at the HTML you shared, we can extract the table data. Would you like me to:\n",
+    "\n",
+    "1. Help you write the code step by step, or\n",
+    "2. Provide a complete solution?\n",
+    "\n",
+    "Also, do you need to:\n",
+    "- Extract just this one page, or\n",
+    "- Navigate through multiple pages?\n",
+    "\n",
+    "Let me know your preference and I'll help accordingly."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**AI Prompt**\n",
+    "\n",
+    "Extract just this one page"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**AI Response**\n",
+    "\n",
+    "I'll help you extract data from this page. Let's break it down into steps:\n",
+    "\n",
+    "1. First, we'll need to set up BeautifulSoup and make the request. Would you like to start by writing the code to import the required libraries and fetch the page?\n",
+    "\n",
+    "The libraries we'll need are:\n",
+    "- `beautifulsoup4`\n",
+    "- `requests`\n",
+    "\n",
+    "Would you like to try writing this first part, or would you like me to show you how?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**AI Prompt**\n",
+    "\n",
+    "give me the code"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**AI Response**\n",
+    "\n",
+    "Here's the code to get started:\n",
+    "\n",
+    "```python\n",
+    "import requests\n",
+    "from bs4 import BeautifulSoup\n",
+    "\n",
+    "url = \"https://www.intel.com/content/www/us/en/ark/products/series/236644/5th-gen-intel-xeon-scalable-processors.html\"\n",
+    "response = requests.get(url)\n",
+    "soup = BeautifulSoup(response.text, 'html.parser')\n",
+    "```\n",
+    "\n",
+    "Try running this code. Let me know if it works, and then we'll move on to extracting the table data. \n",
+    "\n",
+    "(Note: If you get any errors about missing libraries, you'll need to install them first using `pip install requests beautifulsoup4`)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import requests\n",
+    "from bs4 import BeautifulSoup\n",
+    "\n",
+    "url = \"https://www.intel.com/content/www/us/en/ark/products/series/236644/5th-gen-intel-xeon-scalable-processors.html\"\n",
+    "response = requests.get(url)\n",
+    "soup = BeautifulSoup(response.text, \"html.parser\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**AI Prompt**\n",
+    "\n",
+    "fine, give me the code to extract the data ?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**AI Response**\n",
+    "\n",
+    "Here's the code to extract the table data:\n",
+    "\n",
+    "```python\n",
+    "# Find the table\n",
+    "table = soup.find('table', id='product-table')\n",
+    "\n",
+    "# Extract headers\n",
+    "headers = []\n",
+    "for th in table.find_all('th'):\n",
+    "    header_text = th.find('div', class_='header-text-space').text.strip()\n",
+    "    headers.append(header_text)\n",
+    "\n",
+    "# Extract rows\n",
+    "data = []\n",
+    "for row in table.find('tbody').find_all('tr'):\n",
+    "    row_data = {}\n",
+    "    cells = row.find_all('td')\n",
+    "    for i, cell in enumerate(cells):\n",
+    "        row_data[headers[i]] = cell.text.strip()\n",
+    "    data.append(row_data)\n",
+    "\n",
+    "# Convert to pandas DataFrame for easy viewing/export\n",
+    "import pandas as pd\n",
+    "df = pd.DataFrame(data)\n",
+    "print(df)\n",
+    "```\n",
+    "\n",
+    "Would you like me to explain how this code works, or would you prefer to see how to modify it for specific needs?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                              Product Name Launch Date  ...    Cache    TDP\n",
+      "0      Intel® Xeon® Bronze 3508U Processor       Q4'23  ...  22.5 MB  125 W\n",
+      "1        Intel® Xeon® Gold 5512U Processor       Q4'23  ...  52.5 MB  185 W\n",
+      "2        Intel® Xeon® Gold 5515+ Processor       Q4'23  ...  22.5 MB  165 W\n",
+      "3        Intel® Xeon® Gold 5520+ Processor       Q4'23  ...  52.5 MB  205 W\n",
+      "4        Intel® Xeon® Gold 6526Y Processor       Q4'23  ...  37.5 MB  195 W\n",
+      "5         Intel® Xeon® Gold 6530 Processor       Q4'23  ...   160 MB  270 W\n",
+      "6         Intel® Xeon® Gold 6534 Processor       Q4'23  ...  22.5 MB  195 W\n",
+      "7        Intel® Xeon® Gold 6538N Processor       Q4'23  ...    60 MB  205 W\n",
+      "8       Intel® Xeon® Gold 6538Y+ Processor       Q4'23  ...    60 MB  225 W\n",
+      "9        Intel® Xeon® Gold 6542Y Processor       Q4'23  ...    60 MB  250 W\n",
+      "10       Intel® Xeon® Gold 6544Y Processor       Q4'23  ...    45 MB  270 W\n",
+      "11       Intel® Xeon® Gold 6548N Processor       Q4'23  ...    60 MB  250 W\n",
+      "12      Intel® Xeon® Gold 6548Y+ Processor       Q4'23  ...    60 MB  250 W\n",
+      "13       Intel® Xeon® Gold 6554S Processor       Q4'23  ...   180 MB  270 W\n",
+      "14       Intel® Xeon® Gold 6558Q Processor       Q4'23  ...    60 MB  350 W\n",
+      "15    Intel® Xeon® Platinum 8558 Processor       Q4'23  ...   260 MB  330 W\n",
+      "16   Intel® Xeon® Platinum 8558P Processor       Q4'23  ...   260 MB  350 W\n",
+      "17   Intel® Xeon® Platinum 8558U Processor       Q4'23  ...   260 MB  300 W\n",
+      "18  Intel® Xeon® Platinum 8562Y+ Processor       Q4'23  ...    60 MB  300 W\n",
+      "19  Intel® Xeon® Platinum 8568Y+ Processor       Q4'23  ...   300 MB  350 W\n",
+      "20    Intel® Xeon® Platinum 8570 Processor       Q4'23  ...   300 MB  350 W\n",
+      "21   Intel® Xeon® Platinum 8571N Processor       Q4'23  ...   300 MB  300 W\n",
+      "22    Intel® Xeon® Platinum 8580 Processor       Q4'23  ...   300 MB  350 W\n",
+      "23   Intel® Xeon® Platinum 8581V Processor       Q4'23  ...   300 MB  270 W\n",
+      "24   Intel® Xeon® Platinum 8592+ Processor       Q4'23  ...   320 MB  350 W\n",
+      "25   Intel® Xeon® Platinum 8592V Processor       Q4'23  ...   320 MB  330 W\n",
+      "26   Intel® Xeon® Platinum 8593Q Processor       Q4'23  ...   320 MB  385 W\n",
+      "27     Intel® Xeon® Silver 4509Y Processor       Q4'23  ...  22.5 MB  125 W\n",
+      "28      Intel® Xeon® Silver 4510 Processor       Q4'23  ...    30 MB  150 W\n",
+      "29     Intel® Xeon® Silver 4510T Processor       Q4'23  ...    30 MB  115 W\n",
+      "30     Intel® Xeon® Silver 4514Y Processor       Q4'23  ...    30 MB  150 W\n",
+      "31    Intel® Xeon® Silver 4516Y+ Processor       Q4'23  ...    45 MB  185 W\n",
+      "\n",
+      "[32 rows x 7 columns]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Find the table\n",
+    "table = soup.find(\"table\", id=\"product-table\")\n",
+    "\n",
+    "# Extract headers\n",
+    "headers = []\n",
+    "for th in table.find_all(\"th\"):\n",
+    "    header_text = th.find(\"div\", class_=\"header-text-space\").text.strip()\n",
+    "    headers.append(header_text)\n",
+    "\n",
+    "# Extract rows\n",
+    "data = []\n",
+    "for row in table.find(\"tbody\").find_all(\"tr\"):\n",
+    "    row_data = {}\n",
+    "    cells = row.find_all(\"td\")\n",
+    "    for i, cell in enumerate(cells):\n",
+    "        row_data[headers[i]] = cell.text.strip()\n",
+    "    data.append(row_data)\n",
+    "\n",
+    "# Convert to pandas DataFrame for easy viewing/export\n",
+    "import pandas as pd\n",
+    "\n",
+    "df = pd.DataFrame(data)\n",
+    "print(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0     125 W\n",
+       "1     185 W\n",
+       "2     165 W\n",
+       "3     205 W\n",
+       "4     195 W\n",
+       "5     270 W\n",
+       "6     195 W\n",
+       "7     205 W\n",
+       "8     225 W\n",
+       "9     250 W\n",
+       "10    270 W\n",
+       "11    250 W\n",
+       "12    250 W\n",
+       "13    270 W\n",
+       "14    350 W\n",
+       "15    330 W\n",
+       "16    350 W\n",
+       "17    300 W\n",
+       "18    300 W\n",
+       "19    350 W\n",
+       "20    350 W\n",
+       "21    300 W\n",
+       "22    350 W\n",
+       "23    270 W\n",
+       "24    350 W\n",
+       "25    330 W\n",
+       "26    385 W\n",
+       "27    125 W\n",
+       "28    150 W\n",
+       "29    115 W\n",
+       "30    150 W\n",
+       "31    185 W\n",
+       "Name: TDP, dtype: object"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df[\"TDP\"].replace(\"W\", \"\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## AMD"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Average TDP per core from AMD dataset: 4.73 W\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "# Path to your manually exported AMD CPU dataset.\n",
+    "# (Adjust the file path as needed.)\n",
+    "amd_csv_path = \"./AMD_CPU_desktop_laptop.csv\"\n",
+    "\n",
+    "try:\n",
+    "    amd_df = pd.read_csv(amd_csv_path)\n",
+    "    amd_df = amd_df[amd_df[\"Launch Date\"].str.contains(\"2024|2025\", na=False)]\n",
+    "    amd_df = amd_df[amd_df[\"Form Factor\"].str.contains(\"Desktops\", na=False)]\n",
+    "\n",
+    "    # Convert columns to numeric, forcing errors to NaN\n",
+    "    # amd_df['Default TDP'] = amd_df['Default TDP'].str.replace('W', '').astype(float)\n",
+    "    amd_df[\"TDP\"] = pd.to_numeric(\n",
+    "        amd_df[\"Default TDP\"].str.replace(\"W\", \"\"), errors=\"coerce\"\n",
+    "    )\n",
+    "    amd_df[\"# of Threads\"] = pd.to_numeric(amd_df[\"# of Threads\"], errors=\"coerce\")\n",
+    "\n",
+    "    # It is assumed the CSV contains columns named 'TDP' (in Watts) and 'Total Cores'\n",
+    "    # Adjust the column names if they differ.\n",
+    "    amd_df[\"TDP_per_core\"] = amd_df[\"TDP\"] / amd_df[\"# of Threads\"]\n",
+    "\n",
+    "    average_tdp_per_core = amd_df[\"TDP_per_core\"].mean()\n",
+    "    print(\n",
+    "        \"Average TDP per core from AMD dataset: {:.2f} W\".format(average_tdp_per_core)\n",
+    "    )\n",
+    "except Exception as e:\n",
+    "    print(\"Error loading or processing AMD dataset:\", e)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Average TDP per core from AMD dataset: 3.61 W\n"
+     ]
+    }
+   ],
+   "source": [
+    "# https://www.amd.com/en/products/specifications/server-processor.html\n",
+    "import pandas as pd\n",
+    "\n",
+    "# Path to your manually exported AMD CPU dataset.\n",
+    "# (Adjust the file path as needed.)\n",
+    "amd_csv_path = \"./AMD_Server_Processor_Specifications.csv\"\n",
+    "\n",
+    "try:\n",
+    "    amd_df = pd.read_csv(amd_csv_path)\n",
+    "    amd_df = amd_df[amd_df[\"Launch Date\"].str.contains(\"2024|2025\", na=False)]\n",
+    "\n",
+    "    # Convert columns to numeric, forcing errors to NaN\n",
+    "    # amd_df['Default TDP'] = amd_df['Default TDP'].str.replace('W', '').astype(float)\n",
+    "    amd_df[\"TDP\"] = pd.to_numeric(\n",
+    "        amd_df[\"Default TDP\"].str.replace(\"W\", \"\"), errors=\"coerce\"\n",
+    "    )\n",
+    "    amd_df[\"# of Threads\"] = pd.to_numeric(amd_df[\"# of Threads\"], errors=\"coerce\")\n",
+    "\n",
+    "    # It is assumed the CSV contains columns named 'TDP' (in Watts) and 'Total Cores'\n",
+    "    # Adjust the column names if they differ.\n",
+    "    amd_df[\"TDP_per_core\"] = amd_df[\"TDP\"] / amd_df[\"# of Threads\"]\n",
+    "\n",
+    "    average_tdp_per_core = amd_df[\"TDP_per_core\"].mean()\n",
+    "    print(\n",
+    "        \"Average TDP per core from AMD dataset: {:.2f} W\".format(average_tdp_per_core)\n",
+    "    )\n",
+    "except Exception as e:\n",
+    "    print(\"Error loading or processing AMD dataset:\", e)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Index(['Name', 'Family', 'Series', 'Form Factor', '# of CPU Cores',\n",
+       "       '# of Threads', 'Max. Boost Clock', 'Base Clock', 'L2 Cache',\n",
+       "       'L3 Cache', 'Default TDP', 'L1 Cache', 'AMD Configurable TDP (cTDP)',\n",
+       "       'Processor Technology for CPU Cores', 'Unlocked for Overclocking',\n",
+       "       'CPU Socket', 'Thermal Solution (PIB)', 'Recommended Cooler',\n",
+       "       'Thermal Solution (MPK)', 'Max. Operating Temperature (Tjmax)',\n",
+       "       'Launch Date', '*OS Support', 'PCI Express® Version',\n",
+       "       'System Memory Type', 'Memory Channels', 'System Memory Specification',\n",
+       "       'Graphics Model', 'Graphics Core Count', 'Graphics Frequency',\n",
+       "       'AMD Ryzen™ AI', 'Product ID Boxed', 'Product ID Tray',\n",
+       "       'Product ID MPK', 'Supported Technologies', 'TDP_per_core'],\n",
+       "      dtype='object')"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "amd_df.columns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Name</th>\n",
+       "      <th>TDP</th>\n",
+       "      <th># of Threads</th>\n",
+       "      <th>TDP_per_core</th>\n",
+       "      <th>Launch Date</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>34</th>\n",
+       "      <td>AMD Ryzen™ 9 9950X</td>\n",
+       "      <td>170</td>\n",
+       "      <td>32.0</td>\n",
+       "      <td>5.312500</td>\n",
+       "      <td>08/15/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>36</th>\n",
+       "      <td>AMD Ryzen™ 9 9900X</td>\n",
+       "      <td>120</td>\n",
+       "      <td>24.0</td>\n",
+       "      <td>5.000000</td>\n",
+       "      <td>08/15/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>38</th>\n",
+       "      <td>AMD Ryzen™ 7 9800X3D</td>\n",
+       "      <td>120</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>7.500000</td>\n",
+       "      <td>11/07/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>39</th>\n",
+       "      <td>AMD Ryzen™ 7 9700X</td>\n",
+       "      <td>65</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>4.062500</td>\n",
+       "      <td>08/08/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>40</th>\n",
+       "      <td>AMD Ryzen™ 5 9600X</td>\n",
+       "      <td>65</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>5.416667</td>\n",
+       "      <td>08/08/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>44</th>\n",
+       "      <td>AMD Ryzen™ 7 PRO 8845HS</td>\n",
+       "      <td>45</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>2.812500</td>\n",
+       "      <td>04/16/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>46</th>\n",
+       "      <td>AMD Ryzen™ 7 PRO 8700GE</td>\n",
+       "      <td>35</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>2.187500</td>\n",
+       "      <td>4/16/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>47</th>\n",
+       "      <td>AMD Ryzen™ 7 PRO 8700G</td>\n",
+       "      <td>65</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>4.062500</td>\n",
+       "      <td>4/16/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>51</th>\n",
+       "      <td>AMD Ryzen™ 5 PRO 8600GE</td>\n",
+       "      <td>35</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>2.916667</td>\n",
+       "      <td>4/16/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>52</th>\n",
+       "      <td>AMD Ryzen™ 5 PRO 8600G</td>\n",
+       "      <td>65</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>5.416667</td>\n",
+       "      <td>4/16/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>54</th>\n",
+       "      <td>AMD Ryzen™ 5 PRO 8500GE</td>\n",
+       "      <td>35</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>2.916667</td>\n",
+       "      <td>4/16/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>55</th>\n",
+       "      <td>AMD Ryzen™ 5 PRO 8500G</td>\n",
+       "      <td>65</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>5.416667</td>\n",
+       "      <td>4/16/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>57</th>\n",
+       "      <td>AMD Ryzen™ 3 PRO 8300GE</td>\n",
+       "      <td>35</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>4.375000</td>\n",
+       "      <td>4/16/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>58</th>\n",
+       "      <td>AMD Ryzen™ 3 PRO 8300G</td>\n",
+       "      <td>65</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>8.125000</td>\n",
+       "      <td>4/16/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>62</th>\n",
+       "      <td>AMD Ryzen™ 7 8700G</td>\n",
+       "      <td>65</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>4.062500</td>\n",
+       "      <td>1/31/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>63</th>\n",
+       "      <td>AMD Ryzen™ 7 8700F</td>\n",
+       "      <td>65</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>4.062500</td>\n",
+       "      <td>04/01/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>67</th>\n",
+       "      <td>AMD Ryzen™ 5 8600G</td>\n",
+       "      <td>65</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>5.416667</td>\n",
+       "      <td>1/31/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>69</th>\n",
+       "      <td>AMD Ryzen™ 5 8500GE</td>\n",
+       "      <td>35</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>2.916667</td>\n",
+       "      <td>4/16/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>70</th>\n",
+       "      <td>AMD Ryzen™ 5 8500G</td>\n",
+       "      <td>65</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>5.416667</td>\n",
+       "      <td>1/31/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>72</th>\n",
+       "      <td>AMD Ryzen™ 3 8300GE</td>\n",
+       "      <td>35</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>4.375000</td>\n",
+       "      <td>4/16/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>73</th>\n",
+       "      <td>AMD Ryzen™ 5 8400F</td>\n",
+       "      <td>65</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>5.416667</td>\n",
+       "      <td>04/01/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>74</th>\n",
+       "      <td>AMD Ryzen™ 3 8300G</td>\n",
+       "      <td>65</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>8.125000</td>\n",
+       "      <td>1/31/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>105</th>\n",
+       "      <td>AMD Ryzen™ 9 7940HX</td>\n",
+       "      <td>55</td>\n",
+       "      <td>32.0</td>\n",
+       "      <td>1.718750</td>\n",
+       "      <td>1/17/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>111</th>\n",
+       "      <td>AMD Ryzen™ 7 7840HX</td>\n",
+       "      <td>55</td>\n",
+       "      <td>24.0</td>\n",
+       "      <td>2.291667</td>\n",
+       "      <td>1/17/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>124</th>\n",
+       "      <td>AMD Ryzen™ 5 7600X3D</td>\n",
+       "      <td>65</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>5.416667</td>\n",
+       "      <td>9/5/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>138</th>\n",
+       "      <td>AMD Ryzen™ 5 7400F</td>\n",
+       "      <td>65</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>5.416667</td>\n",
+       "      <td>1/9/2025</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>178</th>\n",
+       "      <td>AMD Ryzen™ 7 PRO 5755GE</td>\n",
+       "      <td>35</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>2.187500</td>\n",
+       "      <td>9/5/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>179</th>\n",
+       "      <td>AMD Ryzen™ 7 PRO 5755G</td>\n",
+       "      <td>65</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>4.062500</td>\n",
+       "      <td>9/5/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>183</th>\n",
+       "      <td>AMD Ryzen™ 5 PRO 5655GE</td>\n",
+       "      <td>35</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>2.916667</td>\n",
+       "      <td>5/7/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>184</th>\n",
+       "      <td>AMD Ryzen™ 5 PRO 5655G</td>\n",
+       "      <td>65</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>5.416667</td>\n",
+       "      <td>5/7/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>191</th>\n",
+       "      <td>AMD Ryzen™ 3 PRO 5355GE</td>\n",
+       "      <td>35</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>4.375000</td>\n",
+       "      <td>9/5/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>192</th>\n",
+       "      <td>AMD Ryzen™ 3 PRO 5355G</td>\n",
+       "      <td>65</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>8.125000</td>\n",
+       "      <td>9/5/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>198</th>\n",
+       "      <td>AMD Ryzen™ 9 5900XT</td>\n",
+       "      <td>105</td>\n",
+       "      <td>32.0</td>\n",
+       "      <td>3.281250</td>\n",
+       "      <td>07/31/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>206</th>\n",
+       "      <td>AMD Ryzen™ 7 5800XT</td>\n",
+       "      <td>105</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>6.562500</td>\n",
+       "      <td>07/31/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>214</th>\n",
+       "      <td>AMD Ryzen™ 7 5700X3D</td>\n",
+       "      <td>105</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>6.562500</td>\n",
+       "      <td>01/08/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>219</th>\n",
+       "      <td>AMD Ryzen™ 7 5700</td>\n",
+       "      <td>65</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>4.062500</td>\n",
+       "      <td>01/31/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>229</th>\n",
+       "      <td>AMD Ryzen™ 5 5600XT</td>\n",
+       "      <td>65</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>5.416667</td>\n",
+       "      <td>10/31/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>230</th>\n",
+       "      <td>AMD Ryzen™ 5 5600T</td>\n",
+       "      <td>65</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>5.416667</td>\n",
+       "      <td>10/31/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>231</th>\n",
+       "      <td>AMD Ryzen™ 5 5600GT</td>\n",
+       "      <td>65</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>5.416667</td>\n",
+       "      <td>01/08/2024</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>238</th>\n",
+       "      <td>AMD Ryzen™ 5 5500GT</td>\n",
+       "      <td>65</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>5.416667</td>\n",
+       "      <td>01/08/2024</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                        Name  TDP  # of Threads  TDP_per_core Launch Date\n",
+       "34        AMD Ryzen™ 9 9950X  170          32.0      5.312500  08/15/2024\n",
+       "36        AMD Ryzen™ 9 9900X  120          24.0      5.000000  08/15/2024\n",
+       "38      AMD Ryzen™ 7 9800X3D  120          16.0      7.500000  11/07/2024\n",
+       "39        AMD Ryzen™ 7 9700X   65          16.0      4.062500  08/08/2024\n",
+       "40        AMD Ryzen™ 5 9600X   65          12.0      5.416667  08/08/2024\n",
+       "44   AMD Ryzen™ 7 PRO 8845HS   45          16.0      2.812500  04/16/2024\n",
+       "46   AMD Ryzen™ 7 PRO 8700GE   35          16.0      2.187500   4/16/2024\n",
+       "47    AMD Ryzen™ 7 PRO 8700G   65          16.0      4.062500   4/16/2024\n",
+       "51   AMD Ryzen™ 5 PRO 8600GE   35          12.0      2.916667   4/16/2024\n",
+       "52    AMD Ryzen™ 5 PRO 8600G   65          12.0      5.416667   4/16/2024\n",
+       "54   AMD Ryzen™ 5 PRO 8500GE   35          12.0      2.916667   4/16/2024\n",
+       "55    AMD Ryzen™ 5 PRO 8500G   65          12.0      5.416667   4/16/2024\n",
+       "57   AMD Ryzen™ 3 PRO 8300GE   35           8.0      4.375000   4/16/2024\n",
+       "58    AMD Ryzen™ 3 PRO 8300G   65           8.0      8.125000   4/16/2024\n",
+       "62        AMD Ryzen™ 7 8700G   65          16.0      4.062500   1/31/2024\n",
+       "63        AMD Ryzen™ 7 8700F   65          16.0      4.062500  04/01/2024\n",
+       "67        AMD Ryzen™ 5 8600G   65          12.0      5.416667   1/31/2024\n",
+       "69       AMD Ryzen™ 5 8500GE   35          12.0      2.916667   4/16/2024\n",
+       "70        AMD Ryzen™ 5 8500G   65          12.0      5.416667   1/31/2024\n",
+       "72       AMD Ryzen™ 3 8300GE   35           8.0      4.375000   4/16/2024\n",
+       "73        AMD Ryzen™ 5 8400F   65          12.0      5.416667  04/01/2024\n",
+       "74        AMD Ryzen™ 3 8300G   65           8.0      8.125000   1/31/2024\n",
+       "105      AMD Ryzen™ 9 7940HX   55          32.0      1.718750   1/17/2024\n",
+       "111      AMD Ryzen™ 7 7840HX   55          24.0      2.291667   1/17/2024\n",
+       "124     AMD Ryzen™ 5 7600X3D   65          12.0      5.416667    9/5/2024\n",
+       "138       AMD Ryzen™ 5 7400F   65          12.0      5.416667    1/9/2025\n",
+       "178  AMD Ryzen™ 7 PRO 5755GE   35          16.0      2.187500    9/5/2024\n",
+       "179   AMD Ryzen™ 7 PRO 5755G   65          16.0      4.062500    9/5/2024\n",
+       "183  AMD Ryzen™ 5 PRO 5655GE   35          12.0      2.916667    5/7/2024\n",
+       "184   AMD Ryzen™ 5 PRO 5655G   65          12.0      5.416667    5/7/2024\n",
+       "191  AMD Ryzen™ 3 PRO 5355GE   35           8.0      4.375000    9/5/2024\n",
+       "192   AMD Ryzen™ 3 PRO 5355G   65           8.0      8.125000    9/5/2024\n",
+       "198      AMD Ryzen™ 9 5900XT  105          32.0      3.281250  07/31/2024\n",
+       "206      AMD Ryzen™ 7 5800XT  105          16.0      6.562500  07/31/2024\n",
+       "214     AMD Ryzen™ 7 5700X3D  105          16.0      6.562500  01/08/2024\n",
+       "219        AMD Ryzen™ 7 5700   65          16.0      4.062500  01/31/2024\n",
+       "229      AMD Ryzen™ 5 5600XT   65          12.0      5.416667  10/31/2024\n",
+       "230       AMD Ryzen™ 5 5600T   65          12.0      5.416667  10/31/2024\n",
+       "231      AMD Ryzen™ 5 5600GT   65          12.0      5.416667  01/08/2024\n",
+       "238      AMD Ryzen™ 5 5500GT   65          12.0      5.416667  01/08/2024"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "amd_df[[\"Name\", \"TDP\", \"# of Threads\", \"TDP_per_core\", \"Launch Date\"]]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Update the static CodeCarbon database"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Name</th>\n",
+       "      <th>TDP</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1075T</td>\n",
+       "      <td>95</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>255e</td>\n",
+       "      <td>45</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3260 HE</td>\n",
+       "      <td>45</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>3280</td>\n",
+       "      <td>65</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>3320 EE</td>\n",
+       "      <td>25</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3923</th>\n",
+       "      <td>TL-52</td>\n",
+       "      <td>31</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3924</th>\n",
+       "      <td>TL-60</td>\n",
+       "      <td>31</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3925</th>\n",
+       "      <td>TL-64</td>\n",
+       "      <td>35</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3926</th>\n",
+       "      <td>X1150</td>\n",
+       "      <td>17</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3927</th>\n",
+       "      <td>X940</td>\n",
+       "      <td>45</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>3928 rows × 2 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "         Name TDP\n",
+       "0       1075T  95\n",
+       "1        255e  45\n",
+       "2     3260 HE  45\n",
+       "3        3280  65\n",
+       "4     3320 EE  25\n",
+       "...       ...  ..\n",
+       "3923    TL-52  31\n",
+       "3924    TL-60  31\n",
+       "3925    TL-64  35\n",
+       "3926    X1150  17\n",
+       "3927     X940  45\n",
+       "\n",
+       "[3928 rows x 2 columns]"
+      ]
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df = pd.read_csv(\"cpu_power.csv\")\n",
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Name</th>\n",
+       "      <th>TDP</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>AMD EPYC 9965</td>\n",
+       "      <td>500.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>AMD EPYC 9845</td>\n",
+       "      <td>390.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>AMD EPYC 9825</td>\n",
+       "      <td>390.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "            Name    TDP\n",
+       "0  AMD EPYC 9965  500.0\n",
+       "1  AMD EPYC 9845  390.0\n",
+       "2  AMD EPYC 9825  390.0"
+      ]
+     },
+     "execution_count": 65,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "amd_csv_path = \"./AMD_Server_Processor_Specifications.csv\"\n",
+    "amd_df = pd.read_csv(amd_csv_path)\n",
+    "amd_df[\"TDP\"] = pd.to_numeric(\n",
+    "    amd_df[\"Default TDP\"].str.replace(\"W\", \"\"), errors=\"coerce\"\n",
+    ")\n",
+    "amd_df[\"Name\"] = amd_df[\"Name\"].str.replace(\"™\", \"\")\n",
+    "amd_server = amd_df[[\"Name\", \"TDP\"]]\n",
+    "amd_server = amd_server.dropna(subset=[\"TDP\"])\n",
+    "amd_server.head(3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_52381/4222190993.py:6: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  new_cpus['TDP'] = new_cpus['TDP_AMD']\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Name</th>\n",
+       "      <th>TDP</th>\n",
+       "      <th>TDP_AMD</th>\n",
+       "      <th>_merge</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>505</th>\n",
+       "      <td>AMD EPYC 4124P</td>\n",
+       "      <td>65</td>\n",
+       "      <td>65</td>\n",
+       "      <td>right_only</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>506</th>\n",
+       "      <td>AMD EPYC 4244P</td>\n",
+       "      <td>65</td>\n",
+       "      <td>65</td>\n",
+       "      <td>right_only</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>507</th>\n",
+       "      <td>AMD EPYC 4344P</td>\n",
+       "      <td>65</td>\n",
+       "      <td>65</td>\n",
+       "      <td>right_only</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>508</th>\n",
+       "      <td>AMD EPYC 4364P</td>\n",
+       "      <td>105</td>\n",
+       "      <td>105</td>\n",
+       "      <td>right_only</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>509</th>\n",
+       "      <td>AMD EPYC 4464P</td>\n",
+       "      <td>65</td>\n",
+       "      <td>65</td>\n",
+       "      <td>right_only</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>752</th>\n",
+       "      <td>AMD Opteron 6328</td>\n",
+       "      <td>115</td>\n",
+       "      <td>115</td>\n",
+       "      <td>right_only</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>753</th>\n",
+       "      <td>AMD Opteron 6338P</td>\n",
+       "      <td>99</td>\n",
+       "      <td>99</td>\n",
+       "      <td>right_only</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>754</th>\n",
+       "      <td>AMD Opteron 6344</td>\n",
+       "      <td>115</td>\n",
+       "      <td>115</td>\n",
+       "      <td>right_only</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>757</th>\n",
+       "      <td>AMD Opteron 6370P</td>\n",
+       "      <td>99</td>\n",
+       "      <td>99</td>\n",
+       "      <td>right_only</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>807</th>\n",
+       "      <td>AMD Opteron X2170 APU</td>\n",
+       "      <td>25</td>\n",
+       "      <td>25</td>\n",
+       "      <td>right_only</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>113 rows × 4 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Name  TDP TDP_AMD      _merge\n",
+       "505         AMD EPYC 4124P   65      65  right_only\n",
+       "506         AMD EPYC 4244P   65      65  right_only\n",
+       "507         AMD EPYC 4344P   65      65  right_only\n",
+       "508         AMD EPYC 4364P  105     105  right_only\n",
+       "509         AMD EPYC 4464P   65      65  right_only\n",
+       "..                     ...  ...     ...         ...\n",
+       "752       AMD Opteron 6328  115     115  right_only\n",
+       "753      AMD Opteron 6338P   99      99  right_only\n",
+       "754       AMD Opteron 6344  115     115  right_only\n",
+       "757      AMD Opteron 6370P   99      99  right_only\n",
+       "807  AMD Opteron X2170 APU   25      25  right_only\n",
+       "\n",
+       "[113 rows x 4 columns]"
+      ]
+     },
+     "execution_count": 66,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Merge df with amd_server, avoiding duplicates\n",
+    "amd_server[\"TDP\"] = amd_server[\"TDP\"].astype(int).astype(str)\n",
+    "merged_df = df.merge(\n",
+    "    amd_server, on=\"Name\", how=\"outer\", suffixes=(\"\", \"_AMD\"), indicator=True\n",
+    ")\n",
+    "# Filter for new entries that are only in amd_server\n",
+    "new_cpus = merged_df[merged_df[\"_merge\"] == \"right_only\"]\n",
+    "new_cpus[\"TDP\"] = new_cpus[\"TDP_AMD\"]\n",
+    "new_cpus"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Name</th>\n",
+       "      <th>TDP</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>505</th>\n",
+       "      <td>AMD EPYC 4124P</td>\n",
+       "      <td>65</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>506</th>\n",
+       "      <td>AMD EPYC 4244P</td>\n",
+       "      <td>65</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>507</th>\n",
+       "      <td>AMD EPYC 4344P</td>\n",
+       "      <td>65</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>508</th>\n",
+       "      <td>AMD EPYC 4364P</td>\n",
+       "      <td>105</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>509</th>\n",
+       "      <td>AMD EPYC 4464P</td>\n",
+       "      <td>65</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>752</th>\n",
+       "      <td>AMD Opteron 6328</td>\n",
+       "      <td>115</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>753</th>\n",
+       "      <td>AMD Opteron 6338P</td>\n",
+       "      <td>99</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>754</th>\n",
+       "      <td>AMD Opteron 6344</td>\n",
+       "      <td>115</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>757</th>\n",
+       "      <td>AMD Opteron 6370P</td>\n",
+       "      <td>99</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>807</th>\n",
+       "      <td>AMD Opteron X2170 APU</td>\n",
+       "      <td>25</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>113 rows × 2 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Name  TDP\n",
+       "505         AMD EPYC 4124P   65\n",
+       "506         AMD EPYC 4244P   65\n",
+       "507         AMD EPYC 4344P   65\n",
+       "508         AMD EPYC 4364P  105\n",
+       "509         AMD EPYC 4464P   65\n",
+       "..                     ...  ...\n",
+       "752       AMD Opteron 6328  115\n",
+       "753      AMD Opteron 6338P   99\n",
+       "754       AMD Opteron 6344  115\n",
+       "757      AMD Opteron 6370P   99\n",
+       "807  AMD Opteron X2170 APU   25\n",
+       "\n",
+       "[113 rows x 2 columns]"
+      ]
+     },
+     "execution_count": 67,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# merged_df.query('Name.str.contains(\"EPYC\")')\n",
+    "new_cpus_to_add = new_cpus.drop(columns=[\"_merge\"]).loc[:, df.columns]\n",
+    "new_cpus_to_add"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Name</th>\n",
+       "      <th>TDP</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>3928</th>\n",
+       "      <td>AMD EPYC 4124P</td>\n",
+       "      <td>65</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                Name TDP\n",
+       "3928  AMD EPYC 4124P  65"
+      ]
+     },
+     "execution_count": 68,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Option 2: Append the new CPUs to the original df\n",
+    "df = pd.concat([df, new_cpus_to_add], ignore_index=True)\n",
+    "df.sort_values(\"Name\", ascending=True, inplace=True)\n",
+    "df.query('Name.str.contains(\"AMD EPYC 4124P\")')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df.to_csv(\"cpu_power.csv\", index=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Remove with..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "# Load the existing dataset\n",
+    "df = pd.read_csv(\"../cpu_power.csv\")\n",
+    "# Replace with re.sub(r\" with.*\", \"\", name)\n",
+    "def clean_cpu_name(name):\n",
+    "    import re\n",
+    "    # Remove \"with\" and everything after it\n",
+    "    name = re.sub(r\" with.*\", \"\", name)\n",
+    "    # Remove \"™\" symbol\n",
+    "    name = name.replace(\"™\", \"\")\n",
+    "    return name.strip()\n",
+    "df[\"Name\"] = df[\"Name\"].apply(clean_cpu_name)\n",
+    "# Save the cleaned dataset\n",
+    "df.to_csv(\"../cpu_power.csv\", index=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "3.10.5",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

codecarbon/data/hardware/cpu_dataset_builder/README.md

@@ -0,0 +1,15 @@
+# How to update the CPU database
+
+To update the CPU database, you have to run:
+
+```bash
+cd codecarbon/data/hardware/cpu_dataset_builder
+hatch run pip install playwright beautifulsoup4
+hatch run python intel_cpu_scrapper.py
+hatch run python amd_cpu_scrapper.py
+hatch run python merge_scrapped_cpu_power.py
+```
+
+Then commit the changes to the CSV files.
+
+CodeCarbon only use the `cpu_power.csv` file, but we keep the other files for reference and to allow someone else to use them if needed.

codecarbon/data/hardware/cpu_dataset_builder/amd_cpu_scrapper.py

@@ -0,0 +1,120 @@
+"""
+This script uses Playwright to scrape AMD CPU data from their website and save it as a CSV file.
+
+hatch run pip install playwright
+hatch run python amd_cpu_scrapper.py
+"""
+
+import asyncio
+
+from playwright.async_api import Page, async_playwright
+
+
+async def handle_cookie_banner(page: Page):
+    """Attempts to find and click a 'Reject All' button for cookie consent."""
+    try:
+        reject_button_selectors = [
+            "button:has-text('Reject All')",
+            "button:has-text('Decline All')",
+            "button[id*='reject']",
+            "button[class*='reject']",
+            "//button[contains(translate(text(), 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), 'reject all')]",
+            "//button[contains(translate(text(), 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), 'decline all')]",
+        ]
+
+        reject_button = None
+        for selector in reject_button_selectors:
+            try:
+                button = page.locator(selector).first
+                if await button.is_visible(
+                    timeout=2000
+                ):  # Short timeout for visibility check
+                    reject_button = button
+                    print(f"Found cookie consent button with selector: {selector}")
+                    break
+            except Exception:
+                pass  # Selector not found or button not visible, try next
+
+        if reject_button:
+            await reject_button.click()
+            print("Clicked 'Reject All' on cookie banner.")
+            await page.wait_for_timeout(1000)  # Wait a bit for the banner to disappear
+        else:
+            print(
+                "Cookie banner 'Reject All' button not found or not visible after trying common selectors."
+            )
+
+    except Exception as cookie_error:
+        print(f"Could not handle cookie banner: {cookie_error}")
+
+
+async def download_csv_from_url(page: Page, url: str, output_filename: str):
+    """Navigates to a URL, handles cookie banner, and downloads a CSV file."""
+    print(f"Attempting to download from: {url}")
+    retries = 2
+    for attempt in range(retries):
+        try:
+            await page.goto(url, timeout=30000)  # Increased timeout for page load
+            await handle_cookie_banner(page)
+            break  # If goto is successful, break the loop
+        except Exception as e:
+            print(f"Attempt {attempt + 1} to navigate to {url} failed: {e}")
+            if attempt < retries - 1:
+                await asyncio.sleep(5)  # Wait for 5 seconds before retrying
+            else:
+                print(f"All retries failed for {url}.")
+                return  # Exit if all retries fail
+
+    try:
+        # Wait for the download to start after clicking the button
+        async with page.expect_download(
+            timeout=30000
+        ) as download_info:  # Increased timeout for download
+            # Click the button with the class "buttons-csv"
+            await page.locator(".buttons-csv").click()
+            print(f"Clicked download button for {url}")
+
+        download = await download_info.value
+
+        # Save the downloaded file
+        file_path = f"{output_filename}"
+        await download.save_as(file_path)
+        print(f"File downloaded from {url} and saved as {file_path}")
+
+    except Exception as e:
+        print(f"An error occurred while downloading from {url}: {e}")
+
+
+async def main():
+    async with async_playwright() as p:
+        browser = await p.chromium.launch(
+            headless=False,  # Set to True for production
+            args=[
+                "--no-sandbox",
+                "--disable-setuid-sandbox",
+                "--disable-dev-shm-usage",
+                "--disable-gpu",
+            ],
+        )
+        page = await browser.new_page()
+
+        urls_to_download = [
+            {
+                "url": "https://www.amd.com/en/products/specifications/server-processor.html",
+                "filename": "amd_cpu_server_dataset.csv",
+            },
+            {
+                "url": "https://www.amd.com/en/products/specifications/processors.html",
+                "filename": "amd_cpu_desktop_dataset.csv",
+            },
+        ]
+
+        for item in urls_to_download:
+            await download_csv_from_url(page, item["url"], item["filename"])
+            await asyncio.sleep(2)  # Small delay between downloads
+
+        await browser.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

codecarbon/data/hardware/cpu_dataset_builder/amd_cpu_server_dataset.csv

@@ -0,0 +1,203 @@
+"Name","Series","# of CPU Cores","# of Threads","Max. Boost Clock","All Core Boost Speed","Base Clock","L3 Cache","1kU Pricing","Default TDP","AMD Configurable TDP (cTDP)","CPU Socket","Socket Count","Launch Date","PCI Express® Version","System Memory Type","Memory Channels","System Memory Specification","Per Socket Mem BW","Product ID Boxed","Product ID Tray","AMD Infinity Guard","Supported Technologies","Workload Affinity"
+"AMD EPYC™ 9965","EPYC 9005 Series","192","384","Up to 3.7 GHz","3.35 GHz","2.25 GHz","384 MB","14813 USD","500W","450-500W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000000976","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , Content mgmt , HPC , Media streaming , Networking|NFV , Security , VDI , VM Density , Web Serving , CDC"
+"AMD EPYC™ 9845","EPYC 9005 Series","160","320","Up to 3.7 GHz","3.25 GHz","2.1 GHz","320 MB","13564 USD","390W","320-400W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001458","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CDC , Content mgmt , HPC , Media streaming , Networking|NFV , Security , VDI , VM Density , Web Serving"
+"AMD EPYC™ 9825","EPYC 9005 Series","144","288","Up to 3.7 GHz","3.3 GHz","2.2 GHz","384 MB","13006 USD","390W","320-400W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000000837","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CDC , Content mgmt , HPC , Media streaming , Networking|NFV , Security , VDI , VM Density , Web Serving"
+"AMD EPYC™ 9755","EPYC 9005 Series","128","256","Up to 4.1 GHz","4.1 GHz","2.7 GHz","512 MB","12984 USD","500W","450-500W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001443","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , Content mgmt , HPC , Media streaming , Networking|NFV , Security , VDI , VM Density , Web Serving , CDC"
+"AMD EPYC™ 9745","EPYC 9005 Series","128","256","Up to 3.7 GHz","3.45 GHz","2.4 GHz","256 MB","12141 USD","400W","320-400W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001460","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , Content mgmt , HPC , Media streaming , Networking|NFV , Security , VDI , VM Density , Web Serving , CDC"
+"AMD EPYC™ 9655P","EPYC 9005 Series","96","192","Up to 4.5 GHz","4.1 GHz","2.6 GHz","384 MB","10811 USD","400W","320-400W","SP5","1P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001522","","AMD Infinity Guard , AMD Infinity Architecture","CAE|CFD|FEA , High capacity data mgmt (NR|RDBMS) , HPC"
+"AMD EPYC™ 9655","EPYC 9005 Series","96","192","Up to 4.5 GHz","4.1 GHz","2.6 GHz","384 MB","11852 USD","400W","320-400W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000000674","","AMD Infinity Guard , AMD Infinity Architecture","CAE|CFD|FEA , High capacity data mgmt (NR|RDBMS) , HPC"
+"AMD EPYC™ 9645","EPYC 9005 Series","96","192","Up to 3.7 GHz","3.3 GHz","2.3 GHz","256 MB","11048 USD","320W","320-400W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001461","","AMD Infinity Guard , AMD Infinity Architecture","App dev|test , Consumer-Oriented Digital Services , Content mgmt , ERM|SCM|CRM apps"
+"AMD EPYC™ 9575F","EPYC 9005 Series","64","128","Up to 5 GHz","4.5 GHz","3.3 GHz","256 MB","11791 USD","400W","320-400W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001554","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9565","EPYC 9005 Series","72","144","Up to 4.3 GHz","4.2 GHz","3.15 GHz","384 MB","10486 USD","400W","320-400W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001447","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , HPC , VM Density"
+"AMD EPYC™ 9555P","EPYC 9005 Series","64","128","Up to 4.4 GHz","4.2 GHz","3.2 GHz","256 MB","7983 USD","360W","320-400W","SP5","1P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001523","","AMD Infinity Guard , 4th Gen AMD Infinity Architecture","App dev|test , ERM|SCM|CRM apps , Value data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9555","EPYC 9005 Series","64","128","Up to 4.4 GHz","4.2 GHz","3.2 GHz","256 MB","9826 USD","360W","320-400W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001142","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , HPC , VM Density"
+"AMD EPYC™ 9535","EPYC 9005 Series","64","128","Up to 4.3 GHz","3.5 GHz","2.4 GHz","256 MB","8992 USD","300W","240-300W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001147","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CAE , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9475F","EPYC 9005 Series","48","96","Up to 4.8 GHz","4.4 GHz","3.65 GHz","256 MB","7592 USD","400W","320-400W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001143","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9455P","EPYC 9005 Series","48","96","Up to 4.4 GHz","4.1 GHz","3.15 GHz","256 MB","4819 USD","300W","240-300W","SP5","1P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001563","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9455","EPYC 9005 Series","48","96","Up to 4.4 GHz","4.1 GHz","3.15 GHz","256 MB","5412 USD","300W","240-300W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001542","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9375F","EPYC 9005 Series","32","64","Up to 4.8 GHz","4.4 GHz","3.8 GHz","256 MB","5306 USD","320W","320-400W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001197","","AMD Infinity Guard , AMD Infinity Architecture","EDA , HCI , High performance VM Density , Per core CAE|CFD|FEA , VDI"
+"AMD EPYC™ 9365","EPYC 9005 Series","36","72","Up to 4.3 GHz","4.15 GHz","3.4 GHz","192 MB","4341 USD","300W","240-300W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001448","","AMD Infinity Guard , AMD Infinity Architecture","Content mgmt , ERM|SCM|CRM apps , General Purpose , CDN"
+"AMD EPYC™ 9355P","EPYC 9005 Series","32","64","Up to 4.4 GHz","4.2 GHz","3.55 GHz","256 MB","2998 USD","280W","240-300W","SP5","1P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001521","","AMD Infinity Guard , AMD Infinity Architecture","ERM|SCM|CRM apps , Value data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9355","EPYC 9005 Series","32","64","Up to 4.4 GHz","4.2 GHz","3.55 GHz","256 MB","3694 USD","280W","240-300W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001148","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , CAE|CFD|FEA , ERM|SCM|CRM apps , Media streaming , Medium capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9335","EPYC 9005 Series","32","64","Up to 4.4 GHz","4 GHz","3 GHz","128 MB","3178 USD","210W","200-240W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001149","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , CAE|CFD|FEA , ERM|SCM|CRM apps , Media streaming , Medium capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9275F","EPYC 9005 Series","24","48","Up to 4.8 GHz","4.5 GHz","4.1 GHz","256 MB","3439 USD","320W","320-400W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001144","","AMD Infinity Architecture , AMD Infinity Guard","General Purpose , GPU|FPGA Accelerated , Per core CAE|CFD|FEA , SW-defined storage"
+"AMD EPYC™ 9255","EPYC 9005 Series","24","48","Up to 4.3 GHz","4 GHz","3.2 GHz","128 MB","2495 USD","200W","200-240W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000000694","","AMD Infinity Architecture , AMD Infinity Guard","ERM|SCM|CRM apps , General Purpose , Networking|NFV , Web Serving"
+"AMD EPYC™ 9175F","EPYC 9005 Series","16","32","Up to 5 GHz","4.55 GHz","4.2 GHz","512 MB","4256 USD","320W","320-400W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001145","","AMD Infinity Architecture , AMD Infinity Guard","CAE|CFD|FEA , EDA , HPC"
+"AMD EPYC™ 9135","EPYC 9005 Series","16","32","Up to 4.3 GHz","4.25 GHz","3.65 GHz","64 MB","1214 USD","200W","200-240W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001150","","AMD Infinity Architecture , AMD Infinity Guard","EDA , High-speed data mgmt (NR|RDBMS) , Per core CAE|CFD|FEA"
+"AMD EPYC™ 9115","EPYC 9005 Series","16","32","Up to 4.1 GHz","3.3 GHz","2.6 GHz","64 MB","726 USD","125W","120-155W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001552","","AMD Infinity Architecture , AMD Infinity Guard","Media streaming , Per core CAE|CFD|FEA , Value"
+"AMD EPYC™ 9015","EPYC 9005 Series","8","16","Up to 4.1 GHz","3.95 GHz","3.6 GHz","64 MB","527 USD","125W","120-155W","SP5","1P / 2P","10/10/2024","PCIe® 5.0 x128","DDR5","12","Up to 6400 MT/s","614 GB/s","","100-000001553","","AMD Infinity Architecture , AMD Infinity Guard","Collaborative , ERM|SCM|CRM apps , General Purpose"
+"AMD EPYC™ 9754S","EPYC 9004 Series","128","128","Up to 3.1 GHz","3.1 GHz","2.25 GHz","256 MB","10200 USD","360W","320-400W","SP5","1P / 2P","06/13/2023","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000001371","","AMD Infinity Guard , AMD Infinity Architecture","App dev|test , Collaborative , Consumer-Oriented Digital Services , Content mgmt , General Purpose , HPC , Media streaming , VDI , VM Density , Web Serving"
+"AMD EPYC™ 9754","EPYC 9004 Series","128","256","Up to 3.1 GHz","3.1 GHz","2.25 GHz","256 MB","11900 USD","360W","320-400W","SP5","1P / 2P","06/13/2023","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000001234","","AMD Infinity Guard , AMD Infinity Architecture","App dev|test , Collaborative , Consumer-Oriented Digital Services , Content mgmt , General Purpose , HPC , Media streaming , VDI , VM Density , Web Serving"
+"AMD EPYC™ 9734","EPYC 9004 Series","112","224","Up to 3 GHz","3 GHz","2.2 GHz","256 MB","9600 USD","340W","320-400W","SP5","1P / 2P","06/13/2023","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000001235","","AMD Infinity Guard , AMD Infinity Architecture","App dev|test , Collaborative , Consumer-Oriented Digital Services , Content mgmt , General Purpose , HPC , Media streaming , VDI , VM Density , Web Serving"
+"AMD EPYC™ 9684X","EPYC 9004 Series","96","192","Up to 3.7 GHz","3.42 GHz","2.55 GHz","1152 MB","14756 USD","400W","320-400W","SP5","1P / 2P","06/13/2023","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000001254","","AMD 3D V-Cache™ Technology , AMD Infinity Guard , AMD Infinity Architecture","CAE|CFD|FEA , High capacity data mgmt (NR|RDBMS) , HPC"
+"AMD EPYC™ 9654P","EPYC 9004 Series","96","192","Up to 3.7 GHz","3.55 GHz","2.4 GHz","384 MB","10625 USD","360W","320-400W","SP5","1P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000803","","AMD Infinity Guard , AMD Infinity Architecture","App dev|test , Consumer-Oriented Digital Services , Content mgmt , ERM|SCM|CRM apps"
+"AMD EPYC™ 9654","EPYC 9004 Series","96","192","Up to 3.7 GHz","3.55 GHz","2.4 GHz","384 MB","11805 USD","360W","320-400W","SP5","1P / 2P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000789","","AMD Infinity Guard , AMD Infinity Architecture","App dev|test , Consumer-Oriented Digital Services , Content mgmt , ERM|SCM|CRM apps"
+"AMD EPYC™ 9634","EPYC 9004 Series","84","168","Up to 3.7 GHz","3.1 GHz","2.25 GHz","384 MB","10304 USD","290W","240-300W","SP5","1P / 2P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000797","","AMD Infinity Guard , AMD Infinity Architecture","App dev|test , Consumer-Oriented Digital Services , Content mgmt , ERM|SCM|CRM apps"
+"AMD EPYC™ 9554P","EPYC 9004 Series","64","128","Up to 3.75 GHz","3.75 GHz","3.1 GHz","256 MB","7104 USD","360W","320-400W","SP5","1P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000804","","AMD Infinity Guard , AMD Infinity Architecture","App dev|test , ERM|SCM|CRM apps , Value data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9554","EPYC 9004 Series","64","128","Up to 3.75 GHz","3.75 GHz","3.1 GHz","256 MB","9087 USD","360W","320-400W","SP5","1P / 2P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000790","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , HPC , VM Density"
+"AMD EPYC™ 9534","EPYC 9004 Series","64","128","Up to 3.7 GHz","3.55 GHz","2.45 GHz","256 MB","8803 USD","280W","240-300W","SP5","1P / 2P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000799","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CAE , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9474F","EPYC 9004 Series","48","96","Up to 4.1 GHz","3.95 GHz","3.6 GHz","256 MB","6780 USD","360W","320-400W","SP5","1P / 2P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000788","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9454P","EPYC 9004 Series","48","96","Up to 3.8 GHz","3.65 GHz","2.75 GHz","256 MB","4598 USD","290W","240-300W","SP5","1P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000873","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9454","EPYC 9004 Series","48","96","Up to 3.8 GHz","3.65 GHz","2.75 GHz","256 MB","5225 USD","290W","240-300W","SP5","1P / 2P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000478","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9384X","EPYC 9004 Series","32","64","Up to 3.9 GHz","3.5 GHz","3.1 GHz","768 MB","5529 USD","320W","320-400W","SP5","1P / 2P","06/13/2023","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000001256","","AMD 3D V-Cache™ Technology , AMD Infinity Guard , AMD Infinity Architecture","CAE|CFD|FEA , EDA , HPC"
+"AMD EPYC™ 9374F","EPYC 9004 Series","32","64","Up to 4.3 GHz","4.1 GHz","3.85 GHz","256 MB","4850 USD","320W","320-400W","SP5","1P / 2P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000792","","AMD Infinity Guard , AMD Infinity Architecture","EDA , HCI , High performance VM Density , Per core CAE|CFD|FEA , VDI"
+"AMD EPYC™ 9354P","EPYC 9004 Series","32","64","Up to 3.8 GHz","3.75 GHz","3.25 GHz","256 MB","2730 USD","280W","240-300W","SP5","1P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000805","","AMD Infinity Guard , AMD Infinity Architecture","ERM|SCM|CRM apps , Value data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9354","EPYC 9004 Series","32","64","Up to 3.8 GHz","3.75 GHz","3.25 GHz","256 MB","3420 USD","280W","240-300W","SP5","1P / 2P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000798","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , CAE|CFD|FEA , ERM|SCM|CRM apps , Media streaming , Medium capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9334","EPYC 9004 Series","32","64","Up to 3.9 GHz","3.85 GHz","2.7 GHz","128 MB","2990 USD","210W","200-240W","SP5","1P / 2P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000800","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , CAE|CFD|FEA , ERM|SCM|CRM apps , Media streaming , Medium capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 9274F","EPYC 9004 Series","24","48","Up to 4.3 GHz","4.1 GHz","4.05 GHz","256 MB","3060 USD","320W","320-400W","SP5","1P / 2P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000794","","AMD Infinity Guard , AMD Infinity Architecture","EDA , HCI , High performance VM Density , Per core CAE|CFD|FEA , VDI"
+"AMD EPYC™ 9254","EPYC 9004 Series","24","48","Up to 4.15 GHz","3.9 GHz","2.9 GHz","128 MB","2299 USD","200W","200-240W","SP5","1P / 2P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000480","","AMD Infinity Guard , AMD Infinity Architecture","General Purpose , GPU|FPGA Accelerated , Per core CAE|CFD|FEA , SW-defined storage"
+"AMD EPYC™ 9224","EPYC 9004 Series","24","48","Up to 3.7 GHz","3.65 GHz","2.5 GHz","64 MB","1825 USD","200W","200-240W","SP5","1P / 2P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000939","","AMD Infinity Guard , AMD Infinity Architecture","ERM|SCM|CRM apps , General Purpose , Networking|NFV , Web Serving"
+"AMD EPYC™ 9184X","EPYC 9004 Series","16","32","Up to 4.2 GHz","3.85 GHz","3.55 GHz","768 MB","4928 USD","320W","320-400W","SP5","1P / 2P","06/13/2023","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000001255","","AMD 3D V-Cache™ Technology , AMD Infinity Guard , AMD Infinity Architecture","CAE|CFD|FEA , EDA , HPC"
+"AMD EPYC™ 9174F","EPYC 9004 Series","16","32","Up to 4.4 GHz","4.15 GHz","4.1 GHz","256 MB","3850 USD","320W","320-400W","SP5","1P / 2P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000796","","AMD Infinity Guard , AMD Infinity Architecture","EDA , High-speed data mgmt (NR|RDBMS) , Per core CAE|CFD|FEA"
+"AMD EPYC™ 9124","EPYC 9004 Series","16","32","Up to 3.7 GHz","3.6 GHz","3 GHz","64 MB","1083 USD","200W","200-240W","SP5","1P / 2P","11/10/2022","PCIe® 5.0 x128","DDR5","12","Up to 4800 MT/s","460.8 GB/s","","100-000000802","","AMD Infinity Guard , AMD Infinity Architecture","Media streaming , Per core CAE|CFD|FEA , Value"
+"AMD EPYC™ 8534PN","EPYC 8004 Series","64","128","Up to 3.1 GHz","3.05 GHz","2 GHz","128 MB","5450 USD","175W","","SP6","1P","09/18/2023","PCIe® 5.0 x96","DDR5","6","Up to 4800 MT/s","230.4 GB/s","","100-000001172","","AMD Infinity Guard , AMD Infinity Architecture","Client-Middleware Computing , HCI , Media streaming , Networking|NFV , SW-defined storage , Telco"
+"AMD EPYC™ 8534P","EPYC 8004 Series","64","128","Up to 3.1 GHz","3.1 GHz","2.3 GHz","128 MB","4950 USD","200W","155-225W","SP6","1P","09/18/2023","PCIe® 5.0 x96","DDR5","6","Up to 4800 MT/s","230.4 GB/s","","100-000000875","","AMD Infinity Guard , AMD Infinity Architecture","Client-Middleware Computing , HCI , Media streaming , Networking|NFV , SW-defined storage"
+"AMD EPYC™ 8434PN","EPYC 8004 Series","48","96","Up to 3 GHz","3 GHz","2 GHz","128 MB","3150 USD","155W","","SP6","1P","09/18/2023","PCIe® 5.0 x96","DDR5","6","Up to 4800 MT/s","230.4 GB/s","","100-000001174","","AMD Infinity Guard , AMD Infinity Architecture","Client-Middleware Computing , HCI , Media streaming , Networking|NFV , SW-defined storage , Telco"
+"AMD EPYC™ 8434P","EPYC 8004 Series","48","96","Up to 3.1 GHz","3.1 GHz","2.5 GHz","128 MB","2700 USD","200W","155-225W","SP6","1P","09/18/2023","PCIe® 5.0 x96","DDR5","6","Up to 4800 MT/s","230.4 GB/s","","100-000000877","","AMD Infinity Guard , AMD Infinity Architecture","Client-Middleware Computing , HCI , Media streaming , Networking|NFV , SW-defined storage"
+"AMD EPYC™ 8324PN","EPYC 8004 Series","32","64","Up to 3 GHz","3 GHz","2.05 GHz","128 MB","2125 USD","130W","","SP6","1P","09/18/2023","PCIe® 5.0 x96","DDR5","6","Up to 4800 MT/s","230.4 GB/s","","100-000001162","","AMD Infinity Guard , AMD Infinity Architecture","Client-Middleware Computing , HCI , Media streaming , SW-defined storage , Telco"
+"AMD EPYC™ 8324P","EPYC 8004 Series","32","64","Up to 3 GHz","3 GHz","2.65 GHz","128 MB","1895 USD","180W","155-225W","SP6","1P","09/18/2023","PCIe® 5.0 x96","DDR5","6","Up to 4800 MT/s","230.4 GB/s","","100-000001133","","AMD Infinity Guard , AMD Infinity Architecture","Client-Middleware Computing , HCI , Media streaming , Networking|NFV , SW-defined storage"
+"AMD EPYC™ 8224PN","EPYC 8004 Series","24","48","Up to 3 GHz","2.9 GHz","2 GHz","64 MB","1015 USD","120W","","SP6","1P","09/18/2023","PCIe® 5.0 x96","DDR5","6","Up to 4800 MT/s","230.4 GB/s","","100-000001164","","AMD Infinity Guard , AMD Infinity Architecture","Client-Middleware Computing , HCI , Media streaming , Networking|NFV , SW-defined storage , Telco"
+"AMD EPYC™ 8224P","EPYC 8004 Series","24","48","Up to 3 GHz","3 GHz","2.55 GHz","64 MB","855 USD","160W","155-225W","SP6","1P","09/18/2023","PCIe® 5.0 x96","DDR5","6","Up to 4800 MT/s","230.4 GB/s","","100-000001134","","AMD Infinity Guard , AMD Infinity Architecture","Client-Middleware Computing , HCI , Media streaming , Networking|NFV , SW-defined storage"
+"AMD EPYC™ 8124PN","EPYC 8004 Series","16","32","Up to 3 GHz","2.9 GHz","2 GHz","64 MB","790 USD","100W","","SP6","1P","09/18/2023","PCIe® 5.0 x96","DDR5","6","Up to 4800 MT/s","230.4 GB/s","","100-000001166","","AMD Infinity Guard , AMD Infinity Architecture","Client-Middleware Computing , HCI , Media streaming , Networking|NFV , SW-defined storage , Telco"
+"AMD EPYC™ 8124P","EPYC 8004 Series","16","32","Up to 3 GHz","2.95 GHz","2.45 GHz","64 MB","639 USD","125W","120-150W","SP6","1P","09/18/2023","PCIe® 5.0 x96","DDR5","6","Up to 4800 MT/s","230.4 GB/s","","100-000001135","","AMD Infinity Guard , AMD Infinity Architecture","Client-Middleware Computing , HCI , Media streaming , Networking|NFV , SW-defined storage"
+"AMD EPYC™ 8024PN","EPYC 8004 Series","8","16","Up to 3 GHz","2.95 GHz","2.05 GHz","32 MB","525 USD","80W","","SP6","1P","09/18/2023","PCIe® 5.0 x96","DDR5","6","Up to 4800 MT/s","230.4 GB/s","","100-000001170","","AMD Infinity Guard , AMD Infinity Architecture","Client-Middleware Computing , HCI , Media streaming , Networking|NFV , SW-defined storage , Telco"
+"AMD EPYC™ 8024P","EPYC 8004 Series","8","16","Up to 3 GHz","2.95 GHz","2.4 GHz","32 MB","409 USD","90W","70-100W","SP6","1P","09/18/2023","PCIe® 5.0 x96","DDR5","6","Up to 4800 MT/s","230.4 GB/s","","100-000001136","","AMD Infinity Guard , AMD Infinity Architecture","Client-Middleware Computing , HCI , Media streaming , Networking|NFV , SW-defined storage"
+"AMD EPYC™ 7203P","EPYC 7003 Series","8","16","Up to 3.4 GHz","","2.8 GHz","64 MB","338 USD","120W","120-150W","SP3","1P","09/05/2023","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-000001287WOF","100-000001287","","AMD Infinity Guard , AMD Infinity Architecture","General Purpose"
+"AMD EPYC™ 7203","EPYC 7003 Series","8","16","Up to 3.4 GHz","","2.8 GHz","64 MB","348 USD","120W","120-150W","SP3","1P / 2P","09/05/2023","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-000001286WOF","100-000001286","","AMD Infinity Guard , AMD Infinity Architecture","General Purpose"
+"AMD EPYC™ 7303P","EPYC 7003 Series","16","32","Up to 3.4 GHz","","2.4 GHz","64 MB","594 USD","130W","120-150W","SP3","1P","09/05/2023","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-000001289WOF","100-000001289","","AMD Infinity Guard , AMD Infinity Architecture","Cost-optimized , General Purpose"
+"AMD EPYC™ 7303","EPYC 7003 Series","16","32","Up to 3.4 GHz","","2.4 GHz","64 MB","604 USD","130W","120-150W","SP3","1P / 2P","09/05/2023","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-000001288WOF","100-000001288","","AMD Infinity Guard , AMD Infinity Architecture","Cost-optimized , General Purpose"
+"AMD EPYC™ 7643P","EPYC 7003 Series","48","96","Up to 3.6 GHz","","2.3 GHz","256 MB","2722 USD","225W","225-240W","SP3","1P","09/05/2023","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","","100-000001285","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7773X","EPYC 7003 Series","64","128","Up to 3.5 GHz","","2.2 GHz","768 MB","8800 USD","280W","225-280W","SP3","1P / 2P","03/22/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","","100-000000504​","","AMD 3D V-Cache™ Technology , AMD Infinity Guard , AMD Infinity Architecture","Cache-sensitive scale-up|out , CFD , FEA Solvers"
+"AMD EPYC™ 7763","EPYC 7003 Series","64","128","Up to 3.5 GHz","","2.45 GHz","256 MB","7890 USD","280W","225-280W","SP3","1P / 2P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000312WOF","100-000000312","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , Cache-sensitive scale-up|out , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VM Density"
+"AMD EPYC™ 7713P","EPYC 7003 Series","64","128","Up to 3.67 GHz","","2 GHz","256 MB","5010 USD","225W","225-240W","SP3","1P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","","100-000000337","","AMD Infinity Guard , AMD Infinity Architecture","App dev|test , ERM|SCM|CRM apps , Value data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7713","EPYC 7003 Series","64","128","Up to 3.67 GHz","","2 GHz","256 MB","7060 USD","225W","225-240W","SP3","1P / 2P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000344WOF","100-000000344","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7663","EPYC 7003 Series","56","112","Up to 3.5 GHz","","2 GHz","256 MB","6366 USD","240W","225-240W","SP3","1P / 2P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","","100-000000318","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7643","EPYC 7003 Series","48","96","Up to 3.6 GHz","","2.3 GHz","256 MB","4995 USD","225W","225-240W","SP3","1P / 2P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","","100-000000326","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7663P","EPYC 7003 Series","56","112","Up to 3.5 GHz","","2 GHz","256 MB","3139 USD","240W","225-280W","SP3","1P","09/05/2023","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","","100-000001284","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 75F3","EPYC 7003 Series","32","64","Up to 4 GHz","","2.95 GHz","256 MB","4860 USD","280W","225-280W","SP3","1P / 2P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","","100-000000313","","AMD Infinity Guard , AMD Infinity Architecture","EDA , HCI , High performance VM Density , Per core CAE|CFD|FEA , VDI"
+"AMD EPYC™ 7573X","EPYC 7003 Series","32","64","Up to 3.6 GHz","","2.8 GHz","768 MB","5590 USD","280W","225-280W","SP3","1P / 2P","03/22/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","","100-000000506​","","AMD 3D V-Cache™ Technology , AMD Infinity Guard , AMD Infinity Architecture","CFD , FEA Solvers"
+"AMD EPYC™ 7543P","EPYC 7003 Series","32","64","Up to 3.7 GHz","","2.8 GHz","256 MB","2730 USD","225W","225-240W","SP3","1P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000341WOF","100-000000341","","AMD Infinity Guard , AMD Infinity Architecture","ERM|SCM|CRM apps , Value data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7543","EPYC 7003 Series","32","64","Up to 3.7 GHz","","2.8 GHz","256 MB","3761 USD","225W","225-240W","SP3","1P / 2P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000345WOF","100-000000345","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , CAE|CFD|FEA , ERM|SCM|CRM apps , Media streaming , Medium capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7513","EPYC 7003 Series","32","64","Up to 3.65 GHz","","2.6 GHz","128 MB","2840 USD","200W","165-200W","SP3","1P / 2P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000334WOF","100-000000334","","AMD Infinity Guard , AMD Infinity Architecture","App dev|test , Content mgmt , General Purpose"
+"AMD EPYC™ 74F3","EPYC 7003 Series","24","48","Up to 4 GHz","","3.2 GHz","256 MB","2900 USD","240W","225-240W","SP3","1P / 2P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","","100-000000317","","AMD Infinity Guard , AMD Infinity Architecture","EDA , HCI , High performance VM Density , Per core CAE|CFD|FEA , VDI"
+"AMD EPYC™ 7473X","EPYC 7003 Series","24","48","Up to 3.7 GHz","","2.8 GHz","768 MB","3900 USD","240W","225-280W","SP3","1P / 2P","03/22/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","","100-000000507​","","AMD 3D V-Cache™ Technology , AMD Infinity Guard , AMD Infinity Architecture","CFD , EDA , FEA Solvers"
+"AMD EPYC™ 7453","EPYC 7003 Series","28","56","Up to 3.45 GHz","","2.75 GHz","64 MB","1570 USD","225W","225-240W","SP3","1P / 2P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","","100-000000319","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , Content mgmt , General Purpose , Value , Value data mgmt (NR|RDBMS)"
+"AMD EPYC™ 7443P","EPYC 7003 Series","24","48","Up to 4 GHz","","2.85 GHz","128 MB","1337 USD","200W","165-200W","SP3","1P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000342WOF","100-000000342","","AMD Infinity Guard , AMD Infinity Architecture","General Purpose , SW-defined storage , Value"
+"AMD EPYC™ 7443","EPYC 7003 Series","24","48","Up to 4 GHz","","2.85 GHz","128 MB","2010 USD","200W","165-200W","SP3","1P / 2P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","","100-000000340","","AMD Infinity Guard , AMD Infinity Architecture","General Purpose , GPU|FPGA Accelerated , Per core CAE|CFD|FEA , SW-defined storage"
+"AMD EPYC™ 7413","EPYC 7003 Series","24","48","Up to 3.6 GHz","","2.65 GHz","128 MB","1825 USD","180W","165-200W","SP3","1P / 2P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000323WOF","100-000000323","","AMD Infinity Guard , AMD Infinity Architecture","ERM|SCM|CRM apps , General Purpose , Networking|NFV , Web Serving"
+"AMD EPYC™ 73F3","EPYC 7003 Series","16","32","Up to 4 GHz","","3.5 GHz","256 MB","3521 USD","240W","225-240W","SP3","1P / 2P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","","100-000000321","","AMD Infinity Guard , AMD Infinity Architecture","EDA , High-speed data mgmt (NR|RDBMS) , Per core CAE|CFD|FEA"
+"AMD EPYC™ 7373X","EPYC 7003 Series","16","32","Up to 3.8 GHz","","3.05 GHz","768 MB","4185 USD","240W","225-280W","SP3","1P / 2P","03/22/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","","100-000000508​","","AMD 3D V-Cache™ Technology , AMD Infinity Guard , AMD Infinity Architecture","CFD , EDA , FEA Solvers"
+"AMD EPYC™ 7343","EPYC 7003 Series","16","32","Up to 3.9 GHz","","3.2 GHz","128 MB","1565 USD","190W","165-200W","SP3","1P / 2P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","","100-000000338","","AMD Infinity Guard , AMD Infinity Architecture","EDA , General Purpose , Media streaming , Per core CAE|CFD|FEA , Value"
+"AMD EPYC™ 7313P","EPYC 7003 Series","16","32","Up to 3.7 GHz","","3 GHz","128 MB","913 USD","155W","155-180W","SP3","1P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000339WOF","100-000000339","","AMD Infinity Guard , AMD Infinity Architecture","EDA , Media streaming , Value per core CAE|CFD|FEA"
+"AMD EPYC™ 7313","EPYC 7003 Series","16","32","Up to 3.7 GHz","","3 GHz","128 MB","1083 USD","155W","155-180W","SP3","1P / 2P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000329WOF","100-000000329","","AMD Infinity Guard , AMD Infinity Architecture","EDA , Media streaming , Per core CAE|CFD|FEA"
+"AMD EPYC™ 72F3","EPYC 7003 Series","8","16","Up to 4.1 GHz","","3.7 GHz","256 MB","2468 USD","180W","165-200W","SP3","1P / 2P","03/15/2021","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","","100-000000327","","AMD Infinity Guard , AMD Infinity Architecture","Departmental CAE|CFD|FEA , EDA , FSI risk analysis , Licensed per core data mgmt (RDBMS)"
+"AMD EPYC™ 7H12","EPYC 7002 Series","64","128","Up to 3.3 GHz","","2.6 GHz","256 MB","7250 USD","280W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000055WOF","100-000000055","","AMD Infinity Guard , AMD Infinity Architecture","Specialized CAE|CFD|FEA"
+"AMD EPYC™ 7F72","EPYC 7002 Series","24","48","Up to 3.7 GHz","","3.2 GHz","192 MB","2450 USD","240W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-000000141WOF","100-000000141","","AMD Infinity Guard , AMD Infinity Architecture","EDA , HCI , High performance VM Density , Per core CAE|CFD|FEA , VDI"
+"AMD EPYC™ 7F52","EPYC 7002 Series","16","32","Up to 3.9 GHz","","3.5 GHz","256 MB","3100 USD","240W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-000000140WOF","100-000000140","","AMD Infinity Guard , AMD Infinity Architecture","EDA , High-speed data mgmt (NR|RDBMS) , Per core CAE|CFD|FEA"
+"AMD EPYC™ 7F32","EPYC 7002 Series","8","16","Up to 3.9 GHz","","3.7 GHz","128 MB","2100 USD","180W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-000000139WOF","100-000000139","","AMD Infinity Guard , AMD Infinity Architecture","Departmental CAE|CFD|FEA , EDA , FSI risk analysis , Licensed per core data mgmt (RDBMS)"
+"AMD EPYC™ 4585PX","EPYC 4005 Series","16","32","Up to 5.7 GHz","","4.3 GHz","128 MB","699 USD","170W","","AM5","1P","5/13/2025","PCIe® 5.0 x28","DDR5","2","Up to 5600 MT/s","89.6 GB/s","100-100001561WOF","100-000001561","","AMD Infinity Guard , AMD Infinity Architecture",""
+"AMD EPYC™ 7742","EPYC 7002 Series","64","128","Up to 3.4 GHz","","2.25 GHz","256 MB","6950 USD","225W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000053WOF","100-000000053","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , Cache-sensitive scale-up|out , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VM Density"
+"AMD EPYC™ 4565P","EPYC 4005 Series","16","32","Up to 5.7 GHz","","4.3 GHz","64 MB","589 USD","170W","","AM5","1P","5/13/2025","PCIe® 5.0 x28","DDR5","2","Up to 5600 MT/s","89.6 GB/s","100-100001559WOF","100-000001559","","AMD Infinity Architecture , AMD Infinity Guard",""
+"AMD EPYC™ 4545P","EPYC 4005 Series","16","32","Up to 5.4 GHz","","3 GHz","64 MB","549 USD","65W","","AM5","1P","5/13/2025","PCIe® 5.0 x28","DDR5","2","Up to 5600 MT/s","89.6 GB/s","100-100001764WOF","100-000001764","","AMD Infinity Guard , AMD Infinity Architecture",""
+"AMD EPYC™ 7702P","EPYC 7002 Series","64","128","Up to 3.35 GHz","","2 GHz","256 MB","4425 USD","200W","","SP3","1P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000047WOF","100-000000047","","AMD Infinity Guard , AMD Infinity Architecture","ERM|SCM|CRM apps , Security , Value data mgmt (NR|RDBMS) , VM Density"
+"AMD EPYC™ 4465P","EPYC 4005 Series","12","24","Up to 5.4 GHz","","3.4 GHz","64 MB","399 USD","65W","","AM5","1P","5/13/2025","PCIe® 5.0 x28","DDR5","2","Up to 5600 MT/s","89.6 GB/s","100-100001558WOF","100-000001558","","AMD Infinity Guard , AMD Infinity Architecture",""
+"AMD EPYC™ 4345P","EPYC 4005 Series","8","16","Up to 5.5 GHz","","3.8 GHz","32 MB","329 USD","65W","","AM5","1P","5/13/2025","PCIe® 5.0 x28","DDR5","2","Up to 5600 MT/s","89.6 GB/s","100-100001556WOF","100-000001556","","AMD Infinity Guard , AMD Infinity Architecture",""
+"AMD EPYC™ 7702","EPYC 7002 Series","64","128","Up to 3.35 GHz","","2 GHz","256 MB","6450 USD","200W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000038WOF","100-000000038","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , Cache-sensitive scale-up|out , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VM Density"
+"AMD EPYC™ 4245P","EPYC 4005 Series","6","12","Up to 5.4 GHz","","3.9 GHz","32 MB","239 USD","65W","","AM5","1P","5/13/2025","PCIe® 5.0 x28","DDR5","2","Up to 5600 MT/s","89.6 GB/s","100-100001555WOF","100-000001555","","AMD Infinity Guard , AMD Infinity Architecture",""
+"AMD EPYC™ 7662","EPYC 7002 Series","64","128","Up to 3.3 GHz","","2 GHz","256 MB","6150 USD","225W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-000000137WOF","100-000000137","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7642","EPYC 7002 Series","48","96","Up to 3.3 GHz","","2.3 GHz","256 MB","4775 USD","225W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000074WOF","100-000000074","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7552","EPYC 7002 Series","48","96","Up to 3.3 GHz","","2.2 GHz","192 MB","4025 USD","200W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000076WOF","100-000000076","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7542","EPYC 7002 Series","32","64","Up to 3.4 GHz","","2.9 GHz","128 MB","3400 USD","225W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000075WOF","100-000000075","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , CAE|CFD|FEA , ERM|SCM|CRM apps , Media streaming , Medium capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7532","EPYC 7002 Series","32","64","Up to 3.3 GHz","","2.4 GHz","256 MB","2380 USD","200W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-000000136WOF","100-000000136","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , CAE|CFD|FEA , ERM|SCM|CRM apps , Media streaming , Medium capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7502P","EPYC 7002 Series","32","64","Up to 3.35 GHz","","2.5 GHz","128 MB","2300 USD","180W","","SP3","1P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000045WOF","100-000000045","","AMD Infinity Guard , AMD Infinity Architecture","ERM|SCM|CRM apps , Value data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7502","EPYC 7002 Series","32","64","Up to 3.35 GHz","","2.5 GHz","128 MB","2600 USD","180W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000054WOF","100-000000054","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , CAE|CFD|FEA , ERM|SCM|CRM apps , Media streaming , Medium capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7452","EPYC 7002 Series","32","64","Up to 3.35 GHz","","2.35 GHz","128 MB","2025 USD","155W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000057WOF","100-000000057","","AMD Infinity Guard , AMD Infinity Architecture","App dev|test , Content mgmt , General Purpose"
+"AMD EPYC™ 7402P","EPYC 7002 Series","24","48","Up to 3.35 GHz","","2.8 GHz","128 MB","1250 USD","180W","","SP3","1P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000048WOF","100-000000048","","AMD Infinity Guard , AMD Infinity Architecture","General Purpose , SW-defined storage , Value"
+"AMD EPYC™ 7402","EPYC 7002 Series","24","48","Up to 3.35 GHz","","2.8 GHz","128 MB","1783 USD","180W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000046WOF","100-000000046","","AMD Infinity Guard , AMD Infinity Architecture","General Purpose , GPU|FPGA Accelerated , Per core CAE|CFD|FEA , SW-defined storage"
+"AMD EPYC™ 7352","EPYC 7002 Series","24","48","Up to 3.2 GHz","","2.3 GHz","128 MB","1080 USD","155W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000077WOF","100-000000077","","AMD Infinity Guard , AMD Infinity Architecture","ERM|SCM|CRM apps , Networking|NFV , Web Serving"
+"AMD EPYC™ 7302P","EPYC 7002 Series","16","32","Up to 3.3 GHz","","3 GHz","128 MB","825 USD","155W","","SP3","1P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000049WOF","100-000000049","","AMD Infinity Guard , AMD Infinity Architecture","EDA , Media streaming , Value per core CAE|CFD|FEA"
+"AMD EPYC™ 7302","EPYC 7002 Series","16","32","Up to 3.3 GHz","","3 GHz","128 MB","978 USD","155W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000043WOF","100-000000043","","AMD Infinity Guard , AMD Infinity Architecture","EDA , Media streaming , Per core CAE|CFD|FEA"
+"AMD EPYC™ 7282","EPYC 7002 Series","16","32","Up to 3.2 GHz","","2.8 GHz","64 MB","604 USD","120W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","85.3 GB/s","100-100000078WOF","100-000000078","","AMD Infinity Guard , AMD Infinity Architecture","Cost-optimized , General Purpose , SW-defined storage"
+"AMD EPYC™ 7272","EPYC 7002 Series","12","24","Up to 3.2 GHz","","2.9 GHz","64 MB","549 USD","120W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","85.3 GB/s","100-100000079WOF","100-000000079","","AMD Infinity Guard , AMD Infinity Architecture","Content mgmt , Cost-optimized , General Purpose"
+"AMD EPYC™ 7262","EPYC 7002 Series","8","16","Up to 3.4 GHz","","3.2 GHz","128 MB","505 USD","155W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","204.8 GB/s","100-100000041WOF","100-000000041","","AMD Infinity Guard , AMD Infinity Architecture","Collaborative , Cost-optimized , Departmental CAE|CFD|FEA , EDA , Licensed per core data mgmt (RDBMS)"
+"AMD EPYC™ 7252","EPYC 7002 Series","8","16","Up to 3.2 GHz","","3.1 GHz","64 MB","348 USD","120W","","SP3","1P / 2P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","85.3 GB/s","100-100000080WOF","100-000000080","","AMD Infinity Guard , AMD Infinity Architecture","Collaborative , Cost-optimized , Departmental CAE|CFD|FEA , EDA , Licensed per core data mgmt (RDBMS)"
+"AMD EPYC™ 7232P","EPYC 7002 Series","8","16","Up to 3.2 GHz","","3.1 GHz","32 MB","338 USD","120W","","SP3","1P","","PCIe® 4.0 x128","DDR4","8","Up to 3200 MT/s","85.3 GB/s","100-100000081WOF","100-000000081","","AMD Infinity Guard , AMD Infinity Architecture","Cost-optimized , Per core license , Value"
+"AMD EPYC™ 7601","EPYC 7001 Series","32","64","Up to 3.2 GHz","","2.2 GHz","64 MB","3270 USD","180W","","SP3","1P / 2P","","PCIe® 3.0 x128","DDR4","8","Up to 2666 MT/s","170.6 GB/s","PS7601BDAFWOF","PS7601BDVIHAF","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , Cache-sensitive scale-up|out , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS)"
+"AMD EPYC™ 7551P","EPYC 7001 Series","32","64","Up to 3 GHz","","2 GHz","64 MB","1830 USD","180W","","SP3","1P","","PCIe® 3.0 x128","DDR4","8","Up to 2666 MT/s","170.6 GB/s","PS755PBDAFWOF","PS755PBDVIHAF","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , Cache-sensitive scale-up|out , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7551","EPYC 7001 Series","32","64","Up to 3 GHz","","2 GHz","64 MB","2660 USD","180W","","SP3","1P / 2P","","PCIe® 3.0 x128","DDR4","8","Up to 2666 MT/s","170.6 GB/s","PS7551BDAFWOF","PS7551BDVIHAF","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , App dev|test , Cache-sensitive scale-up|out , CAE|CFD|FEA , ERM|SCM|CRM apps , High capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7501","EPYC 7001 Series","32","64","Up to 3 GHz","","2 GHz","64 MB","2870 USD","155W / 170W","","SP3","1P / 2P","","PCIe® 3.0 x128","DDR4","8","2400 MT/s / 2666 MT/s","153.6 GB/s / 170.6 GB/s","PS7501BEAFWOF","PS7501BEVIHAF","","AMD Infinity Guard , AMD Infinity Architecture","Analytics , CAE|CFD|FEA , ERM|SCM|CRM apps , Media streaming , Medium capacity data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7451","EPYC 7001 Series","24","48","Up to 3.2 GHz","","2.3 GHz","64 MB","1880 USD","180W","","SP3","1P / 2P","","PCIe® 3.0 x128","DDR4","8","Up to 2666 MT/s","170.6 GB/s","PS7451BDAFWOF","PS7451BDVHCAF","","AMD Infinity Guard , AMD Infinity Architecture","App dev|test , Content mgmt , General Purpose"
+"AMD EPYC™ 7401P","EPYC 7001 Series","24","48","Up to 3 GHz","","2 GHz","64 MB","920 USD","155W / 170W","","SP3","1P","","PCIe® 3.0 x128","DDR4","8","2400 MT/s / 2666 MT/s","153.6 GB/s / 170.6 GB/s","PS740PBEAFWOF","PS740PBEVHCAF","","AMD Infinity Guard , AMD Infinity Architecture","ERM|SCM|CRM apps , Value data mgmt (NR|RDBMS) , VDI , VM Density"
+"AMD EPYC™ 7401","EPYC 7001 Series","24","48","Up to 3 GHz","","2 GHz","64 MB","1620 USD","155W / 170W","","SP3","1P / 2P","","PCIe® 3.0 x128","DDR4","8","2400 MT/s / 2666 MT/s","153.6 GB/s / 170.6 GB/s","PS7401BEAFWOF","PS7401BEVHCAF","","AMD Infinity Guard , AMD Infinity Architecture","General Purpose , GPU|FPGA Accelerated , SW-defined storage"
+"AMD EPYC™ 7371","EPYC 7001 Series","16","32","Up to 3.8 GHz","","3.1 GHz","64 MB","1550 USD","200W","","SP3","1P / 2P","","PCIe® 3.0 x128","DDR4","8","Up to 2666 MT/s","170.6 GB/s","","","","AMD Infinity Guard , AMD Infinity Architecture","EDA , ERM|SCM|CRM apps , Media streaming , Networking|NFV , Per core CAE|CFD|FEA , Web Serving"
+"AMD EPYC™ 7351P","EPYC 7001 Series","16","32","Up to 2.9 GHz","","2.4 GHz","64 MB","660 USD","155W / 170W","","SP3","1P","","PCIe® 3.0 x128","DDR4","8","2400 MT/s / 2666 MT/s","153.6 GB/s / 170.6 GB/s","PS735PBEAFWOF","PS735PBEVGPAF","","AMD Infinity Guard , AMD Infinity Architecture","Cost-optimized , EDA , General Purpose , Media streaming , Value per core CAE|CFD|FEA"
+"AMD EPYC™ 7351","EPYC 7001 Series","16","32","Up to 2.9 GHz","","2.4 GHz","64 MB","890 USD","155W / 170W","","SP3","1P / 2P","","PCIe® 3.0 x128","DDR4","8","2400 MT/s / 2666 MT/s","153.6 GB/s / 170.6 GB/s","PS7351BEAFWOF","PS7351BEVGPAF","","AMD Infinity Guard , AMD Infinity Architecture","General Purpose , Media streaming , Per core CAE|CFD|FEA , Web Serving"
+"AMD EPYC™ 7301","EPYC 7001 Series","16","32","Up to 2.7 GHz","","2.2 GHz","64 MB","740 USD","155W / 170W","","SP3","1P / 2P","","PCIe® 3.0 x128","DDR4","8","2400 MT/s / 2666 MT/s","153.6 GB/s / 170.6 GB/s","PS7301BEAFWOF","PS7301BEVGPAF","","AMD Infinity Guard , AMD Infinity Architecture","EDA , General Purpose , Media streaming , Per core CAE|CFD|FEA"
+"AMD EPYC™ 7281","EPYC 7001 Series","16","32","Up to 2.7 GHz","","2.1 GHz","32 MB","580 USD","155W / 170W","","SP3","1P / 2P","","PCIe® 3.0 x128","DDR4","8","2400 MT/s / 2666 MT/s","153.6 GB/s / 170.6 GB/s","PS7281BEAFWOF","PS7281BEVGAAF","","AMD Infinity Guard , AMD Infinity Architecture","Cost-optimized , General Purpose , SW-defined storage"
+"AMD EPYC™ 7261","EPYC 7001 Series","8","16","Up to 2.9 GHz","","2.5 GHz","64 MB","570 USD","155W / 170W","","SP3","1P / 2P","","","DDR4","8","2400 MT/s / 2666 MT/s","153.6 GB/s / 170.6 GB/s","","PS7261BEV8RAF","","AMD Infinity Guard , AMD Infinity Architecture","Collaborative , Cost-optimized , Departmental CAE|CFD|FEA , EDA , Per core license , Value data mgmt (NR|RDBMS)"
+"AMD EPYC™ 7251","EPYC 7001 Series","8","16","Up to 2.9 GHz","","2.1 GHz","32 MB","400 USD","120W","","SP3","1P / 2P","","PCIe® 3.0 x128","DDR4","8","Up to 2400 MT/s","153.6 GB/s","PS7251BFAFWOF","PS7251BFV8SAF","","AMD Infinity Guard , AMD Infinity Architecture","Collaborative , Cost-optimized , Per core license , Value data mgmt (NR|RDBMS)"
+"AMD EPYC™ 4584PX","EPYC 4004 Series","16","32","Up to 5.7 GHz","5.7 GHz","4.2 GHz","128 MB","699 USD","120W","","AM5","1P","","PCIe® 5.0 x28","DDR5","2","Up to 5200 MT/s","","100-100001481WOF","100-000001481","Yes","AMD Infinity Architecture",""
+"AMD EPYC™ 4564P","EPYC 4004 Series","16","32","Up to 5.7 GHz","","4.5 GHz","64 MB","699 USD","170W","","AM5","1P","","PCIe® 5.0 x28","DDR5","2","Up to 5200 MT/s","","100-100001476WOF","100-000001476","Yes","AMD Infinity Architecture",""
+"AMD EPYC™ 4484PX","EPYC 4004 Series","12","24","Up to 5.6 GHz","","4.4 GHz","128 MB","599 USD","120W","","AM5","1P","","PCIe® 5.0 x28","DDR5","2","Up to 5200 MT/s","","100-100001482WOF","100-000001482","Yes","AMD Infinity Architecture",""
+"AMD EPYC™ 4464P","EPYC 4004 Series","12","24","Up to 5.4 GHz","","3.7 GHz","64 MB","429 USD","65W","","AM5","1P","","PCIe® 5.0 x28","DDR5","2","Up to 5200 MT/s","","100-100001478WOF","100-000001478","Yes","AMD Infinity Architecture",""
+"AMD EPYC™ 4364P","EPYC 4004 Series","8","16","Up to 5.4 GHz","","4.5 GHz","32 MB","399 USD","105W","","AM5","1P","","PCIe® 5.0 x28","DDR5","2","Up to 5200 MT/s","","100-100001477WOF","100-000001477","Yes","AMD Infinity Architecture",""
+"AMD EPYC™ 4344P","EPYC 4004 Series","8","16","Up to 5.3 GHz","","3.8 GHz","32 MB","329 USD","65W","","AM5","1P","","PCIe® 5.0 x28","DDR5","2","Up to 5200 MT/s","","100-100001479WOF","100-000001479","Yes","AMD Infinity Architecture",""
+"AMD EPYC™ 4244P","EPYC 4004 Series","6","12","Up to 5.1 GHz","","3.8 GHz","32 MB","229 USD","65W","","AM5","1P","","PCIe® 5.0 x28","DDR5","2","Up to 5200 MT/s","","100-100001480WOF","100-000001480","Yes","AMD Infinity Architecture",""
+"AMD EPYC™ 4124P","EPYC 4004 Series","4","8","Up to 5.1 GHz","","3.8 GHz","16 MB","149 USD","65W","","AM5","1P","","PCIe® 5.0 x28","DDR5","2","Up to 5200 MT/s","","100-100001570WOF","100-000001570","Yes","AMD Infinity Architecture",""
+"AMD Opteron™ X2170 APU","Opteron X2100 Series APU","4","4","","","2.4 GHz","","","25W","","FT3","","","","DDR3","","Up to 1866 MT/s","","","","","Graphics Core Next Architecture , AMD X86 SoC Technology",""
+"AMD Opteron™ X2150 APU","Opteron X2100 Series APU","4","4","","","1.9 GHz","","","22W","","FT3","","","","DDR3","","","","n/a","OX2150IAJ44HM","","Catalyst Software , AMD HD3D Technology",""
+"AMD Opteron™ X1150","Opteron X1100 Series","4","4","","","2 GHz","","","17W","","FT3","","","","DDR3","","Up to 800 MT/s","","n/a","OX1150IPJ44HM","","",""
+"AMD Opteron™ 6386 SE","Opteron 6300 Series","16","16","Up to 3.5 GHz","","2.8 GHz","16 MB","","140W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6386YETGGHK","","",""
+"AMD Opteron™ 6370P","Opteron 6300 Series","16","16","Up to 2.5 GHz","","2 GHz","16 MB","","99W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6370WQTGGHK","","",""
+"AMD Opteron™ 6366 HE","Opteron 6300 Series","16","16","Up to 3.1 GHz","","1.8 GHz","16 MB","","85W","","G34","","","","DDR3","","Up to 1800 MT/s","","n/a","OS6366VATGGHK","","",""
+"AMD Opteron™ 6338P","Opteron 6300 Series","12","12","Up to 2.8 GHz","","2.3 GHz","16 MB","","99W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6338WQTCGHK","","",""
+"AMD Opteron™ 6380","Opteron 6300 Series","16","16","Up to 3.4 GHz","","2.5 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6380WKTGGHK","","",""
+"AMD Opteron™ 6378","Opteron 6300 Series","16","16","Up to 3.3 GHz","","2.4 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6378WKTGGHK","","",""
+"AMD Opteron™ 6376","Opteron 6300 Series","16","16","Up to 2 GHz","","2.3 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6376WKTGGHK","","",""
+"AMD Opteron™ 6348","Opteron 6300 Series","12","12","Up to 3.4 GHz","","2.8 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6348WKTCGHK","","",""
+"AMD Opteron™ 6344","Opteron 6300 Series","12","12","Up to 2 GHz","","2.6 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6344WKTCGHK","","",""
+"AMD Opteron™ 6328","Opteron 6300 Series","8","8","Up to 3.8 GHz","","3.2 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6328WKT8GHK","","",""
+"AMD Opteron™ 6320","Opteron 6300 Series","8","8","Up to 3.3 GHz","","2.8 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6320WKT8GHK","","",""
+"AMD Opteron™ 6308","Opteron 6300 Series","4","4","","","3.5 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6308WKT4GHK","","",""
+"AMD Opteron™ 4376 HE","Opteron 4300 Series","8","8","Up to 3.6 GHz","","2.6 GHz","8 MB","","65W","","C32","","","","DDR3","","Up to 2000 MT/s","","n/a","OS4376OFU8KHK","","",""
+"AMD Opteron™ 4332 HE","Opteron 4300 Series","6","6","Up to 3.7 GHz","","3 GHz","8 MB","","65W","","C32","","","","DDR3","","Up to 2000 MT/s","","n/a","OS4332OFU6KHK","","",""
+"AMD Opteron™ 4310 EE","Opteron 4300 Series","6","6","Up to 3 GHz","","2.2 GHz","8 MB","","35W","","C32","","","","DDR3","","Up to 1600 MT/s","","n/a","OS4310HPU4KHK","","",""
+"AMD Opteron™ 4386","Opteron 4300 Series","8","8","Up to 3.8 GHz","","3.1 GHz","8 MB","","95W","","C32","","","","DDR3","","Up to 2200 MT/s","","n/a","OS4386WLU8KHK","","",""
+"AMD Opteron™ 4365","Opteron 4300 Series","8","8","Up to 2.8 GHz","","2 GHz","8 MB","","40W","","C32","","","","DDR3","","Up to 1600 MT/s","","n/a","n/a","","",""
+"AMD Opteron™ 4340","Opteron 4300 Series","6","6","Up to 3.8 GHz","","3.5 GHz","8 MB","","95W","","C32","","","","DDR3","","Up to 2200 MT/s","","n/a","OS4340WLU6KHK","","",""
+"AMD Opteron™ 4334","Opteron 4300 Series","6","6","Up to 3.5 GHz","","3.1 GHz","8 MB","","95W","","C32","","","","DDR3","","Up to 2000 MT/s","","n/a","OS4334WLU6KHK","","",""
+"AMD Opteron™ 3350 HE","Opteron 3300 Series","4","4","Up to 3.8 GHz","","2.8 GHz","8 MB","","45W","","AM3+","","","","DDR3","","Up to 2000 MT/s","","n/a","OS3350HOW4KHK","","",""
+"AMD Opteron™ 3320 EE","Opteron 3300 Series","4","4","Up to 2.5 GHz","","1.9 GHz","8 MB","","25W","","AM3+","","","","DDR3","","Up to 1400 MT/s","","n/a","OS3320SJW4KHK","","",""
+"AMD Opteron™ 3380","Opteron 3300 Series","8","8","Up to 3.6 GHz","","2.6 GHz","8 MB","","65W","","AM3+","","","","DDR3","","Up to 2000 MT/s","","n/a","OS3380OLW8KHK","","",""
+"AMD Opteron™ 3365","Opteron 3300 Series","8","8","Up to 3.3 GHz","","2.3 GHz","8 MB","","65W","","AM3+","","","","DDR3","","Up to 2000 MT/s","","n/a","OS3365OLW8KHK","","",""
+"AMD Opteron™ 6284 SE","Opteron 6200 Series","16","16","Up to 3.4 GHz","","2.7 GHz","16 MB","","140W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6284YETGGGU","","",""
+"AMD Opteron™ 6282 SE","Opteron 6200 Series","16","16","Up to 3.3 GHz","","2.6 GHz","16 MB","","140W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6282YETGGGU","","",""
+"AMD Opteron™ 6262 HE","Opteron 6200 Series","16","16","Up to 2.9 GHz","","1.6 GHz","16 MB","","85W","","G34","","","","DDR3","","Up to 1800 MT/s","","n/a","OS6262VATGGGU","","",""
+"AMD Opteron™ 6278","Opteron 6200 Series","16","16","Up to 3.3 GHz","","2.4 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6278WKTGGGU","","",""
+"AMD Opteron™ 6276","Opteron 6200 Series","16","16","Up to 3.2 GHz","","2.3 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6276WKTGGGU","","",""
+"AMD Opteron™ 6274","Opteron 6200 Series","16","16","Up to 3.1 GHz","","2.2 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6274WKTGGGU","","",""
+"AMD Opteron™ 6272","Opteron 6200 Series","16","16","Up to 3 GHz","","2.1 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6272WKTGGGU","","",""
+"AMD Opteron™ 6238","Opteron 6200 Series","12","12","Up to 3.2 GHz","","2.6 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6238WKTCGGU","","",""
+"AMD Opteron™ 6234","Opteron 6200 Series","12","12","Up to 3 GHz","","2.4 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6234WKTCGGU","","",""
+"AMD Opteron™ 6220","Opteron 6200 Series","8","8","Up to 3.6 GHz","","3 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6220WKT8GGU","","",""
+"AMD Opteron™ 6212","Opteron 6200 Series","8","8","Up to 3.2 GHz","","2.6 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6212WKT8GGU","","",""
+"AMD Opteron™ 6204","Opteron 6200 Series","4","4","","","3.3 GHz","16 MB","","115W","","G34","","","","DDR3","","Up to 2000 MT/s","","n/a","OS6204WKT4GGU","","",""
+"AMD Opteron™ 4276 HE","Opteron 4200 Series","8","8","Up to 3.6 GHz","","2.6 GHz","8 MB","","65W","","C32","","","","DDR3","","Up to 2000 MT/s","","n/a","OS4276OFU8KGU","","",""
+"AMD Opteron™ 4274 HE","Opteron 4200 Series","8","8","Up to 3.5 GHz","","2.5 GHz","8 MB","","65W","","C32","","","","DDR3","","Up to 2000 MT/s","","n/a","OS4274OFU8KGU","","",""
+"AMD Opteron™ 4256 EE","Opteron 4200 Series","8","8","Up to 2.8 GHz","","1.6 GHz","8 MB","","35W","","C32","","","","DDR3","","Up to 1600 MT/s","","n/a","OS4256HJU8KGU","","",""
+"AMD Opteron™ 4230 HE","Opteron 4200 Series","6","6","Up to 3.7 GHz","","2.9 GHz","8 MB","","65W","","C32","","","","DDR3","","Up to 2000 MT/s","","n/a","OS4230OFU6KGU","","",""
+"AMD Opteron™ 4228 HE","Opteron 4200 Series","6","6","Up to 3.6 GHz","","2.8 GHz","8 MB","","65W","","C32","","","","DDR3","","Up to 2000 MT/s","","n/a","OS4228OFU6KGU","","",""
+"AMD Opteron™ 4284","Opteron 4200 Series","8","8","Up to 3.7 GHz","","3 GHz","8 MB","","95W","","C32","","","","DDR3","","Up to 2200 MT/s","","n/a","OS4284WLU8KGU","","",""
+"AMD Opteron™ 4280","Opteron 4200 Series","8","8","Up to 2.2 GHz","","2.8 GHz","8 MB","","95W","","C32","","","","DDR3","","Up to 2200 MT/s","","n/a","OS4280WLU8KGU","","",""
+"AMD Opteron™ 4240","Opteron 4200 Series","6","6","Up to 3.8 GHz","","3.4 GHz","8 MB","","95W","","C32","","","","DDR3","","","","n/a","OS4240WLU6KGU","","",""
+"AMD Opteron™ 4238","Opteron 4200 Series","6","6","Up to 3.7 GHz","","3.3 GHz","8 MB","","95W","","C32","","","","DDR3","","Up to 2200 MT/s","","n/a","OS4238WLU6KGU","","",""
+"AMD Opteron™ 4234","Opteron 4200 Series","6","6","Up to 3.5 GHz","","3.1 GHz","8 MB","","95W","","C32","","","","DDR3","","Up to 2200 MT/s","","n/a","OS4234WLU6KGU","","",""
+"AMD Opteron™ 4226","Opteron 4200 Series","6","6","Up to 3.1 GHz","","2.7 GHz","8 MB","","95W","","C32","","","","DDR3","","Up to 2000 MT/s","","n/a","OS4226WLU6KGU","","",""
+"AMD Opteron™ 3260 HE","Opteron 3200 Series","4","4","Up to 3.7 GHz","","2.7 GHz","4 MB","","45W","","AM3+","","","","DDR3","","Up to 2000 MT/s","","OS3260HOW4MGUBOX","OS3260HOW4MGU","","",""
+"AMD Opteron™ 3250 HE","Opteron 3200 Series","","","Up to 3.5 GHz","","2.5 GHz","4 MB","","45W","","AM3+","","","","DDR3","","Up to 2000 MT/s","","OS3250HOW4MGUBOX","OS3250HOW4MGU","","",""
+"AMD Opteron™ 3280","Opteron 3200 Series","8","8","Up to 3.4 GHz","","2.4 GHz","8 MB","","65W","","AM3+","","","","DDR3","","Up to 2000 MT/s","","OS3280OLW8KGUBOX","OS3280OLW8KGU","","",""
+"AMD Opteron™ 6180 SE","Opteron 6100 Series","12","12","","","2.5 GHz","12 MB","","140W","","G34","","","","DDR3","","Up to 1800 MT/s","","n/a","OS6180YETCEGO","","",""
+"AMD Opteron™ 6166 HE","Opteron 6100 Series","12","12","","","1.8 GHz","12 MB","","85W","","G34","","","","DDR3","","Up to 1800 MT/s","","n/a","OS6166VATCEGO","","",""
+"AMD Opteron™ 6132 HE","Opteron 6100 Series","8","8","","","2.2 GHz","12 MB","","85W","","G34","","","","DDR3","","Up to 1800 MT/s","","n/a","OS6132VAT8EGO","","",""
+"AMD Opteron™ 6176","Opteron 6100 Series","12","12","","","2.3 GHz","12 MB","","115W","","G34","","","","DDR3","","Up to 1800 MT/s","","OS6176WKTCEGOWOF","OS6176WKTCEGO","","",""
+"AMD Opteron™ 6140","Opteron 6100 Series","8","8","","","2.6 GHz","12 MB","","115W","","G34","","","","DDR3","","Up to 1800 MT/s","","OS6140WKT8EGOWOF","OS6140WKT8EGO","","",""

codecarbon/data/hardware/cpu_dataset_builder/intel_cpu_scrapper.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+"""
+Intel CPU Scraper
+
+This script uses requests and BeautifulSoup to scrape CPU names and their associated TDP values
+from the Intel ARK website using the advanced filter search URL.
+
+hatch run pip install beautifulsoup4
+hatch run python intel_cpu_scrapper.py
+
+"""
+
+import csv
+import os
+import re
+import time
+
+import requests
+from bs4 import BeautifulSoup
+
+
+class IntelCpuScraper:
+    """Scraper for Intel CPU data from ARK website."""
+
+    def __init__(self):
+        """Initialize the scraper."""
+        self.base_url = "https://www.intel.com/libs/apps/intel/support/ark/advancedFilterSearch?productType=873&3_MaxTDP-Min=0.03&3_MaxTDP-Max=500&forwardPath=/content/www/us/en/ark/featurefilter.html&pageNo={page_num}&sort=&sortType="
+        self.results = []
+        self.headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+        }
+
+    def fetch_page(self, page_num):
+        """Fetch a single page of results."""
+        url = self.base_url.format(page_num=page_num)
+        print(f"Fetching URL: {url}")
+        try:
+            response = requests.get(url, headers=self.headers, timeout=30)
+            response.raise_for_status()  # Raise an exception for bad status codes
+            return response.text
+        except requests.exceptions.RequestException as e:
+            print(f"Error fetching page {page_num}: {e}")
+            return None
+
+    def parse_html(self, html_content):
+        """Parse HTML content to extract CPU data."""
+        soup = BeautifulSoup(html_content, "html.parser")
+        # Prioritize rows with 'data-product-id' as they are likely the CPU entries
+        rows = soup.find_all("tr", {"data-product-id": True})
+
+        if not rows:
+            no_results_message = soup.find("div", class_="no-results-message")
+            if (
+                no_results_message
+                and "no results found" in no_results_message.text.lower()
+            ):
+                print("No results found on this page (no-results-message).")
+                return []
+            if "No products matching your selection were found" in html_content:
+                print("No results found on this page (No products matching text).")
+                return []
+            print("No CPU data rows with 'data-product-id' found on the page.")
+            return None  # Indicate an issue or unexpected structure if no specific "no results" message
+
+        page_results = []
+        for row in rows:
+            try:
+                # Get all direct child <td> elements of the row
+                tds = row.find_all("td", recursive=False)
+
+                # Expected columns: Name, Launch, Cores, Max Turbo, Base Freq, Cache, TDP
+                if len(tds) < 7:
+                    # print(f"Skipping row, expected at least 7 columns, got {len(tds)}.")
+                    continue
+
+                # 1. Product Name
+                cpu_name_tag = tds[0].find("a")
+                if not cpu_name_tag:
+                    # print("Skipping row: CPU name tag not found in first cell.")
+                    continue
+                cpu_name = cpu_name_tag.text.strip()
+
+                # Helper to get text from a td cell
+                def get_cell_text(cell_index, tds):
+                    if cell_index < len(tds) and tds[cell_index]:
+                        return tds[cell_index].text.strip()
+                    return ""
+
+                # 2. Launch Date (e.g., "Q2'25")
+                launch_date = get_cell_text(1, tds)
+
+                # 3. Total Cores (e.g., "40")
+                total_cores = get_cell_text(2, tds)
+
+                # 4. Max Turbo Frequency (e.g., "3.5 GHz")
+                max_turbo_frequency = get_cell_text(3, tds)
+
+                # 5. Processor Base Frequency (e.g., "2.5 GHz")
+                processor_base_frequency = get_cell_text(4, tds)
+
+                # 6. Cache (e.g., "160 MB")
+                cache = get_cell_text(5, tds)
+
+                # 7. TDP (e.g., "235 W")
+                tdp_text_content = get_cell_text(6, tds)
+                tdp_data_value = (
+                    tds[6].get("data-value") if len(tds) > 6 and tds[6] else None
+                )
+
+                tdp_numeric = None
+                if tdp_data_value and tdp_data_value.replace(".", "", 1).isdigit():
+                    tdp_numeric = float(tdp_data_value)
+                elif "W" in tdp_text_content:
+                    tdp_match = re.search(r"([\\d.]+)\\s*W", tdp_text_content)
+                    if tdp_match:
+                        tdp_numeric = float(tdp_match.group(1))
+
+                if not cpu_name:  # Basic validation
+                    # print("Skipping row: CPU name is empty.")
+                    continue
+
+                result_item = {
+                    "cpu_name": cpu_name,
+                    "launch_date": launch_date,
+                    "total_cores": total_cores,
+                    "max_turbo_frequency": max_turbo_frequency,
+                    "processor_base_frequency": processor_base_frequency,
+                    "cache": cache,
+                    "tdp": (
+                        tdp_numeric if tdp_numeric is not None else ""
+                    ),  # Store numeric TDP in Watts
+                }
+                page_results.append(result_item)
+                # print(f"Processed: {cpu_name}, TDP: {tdp_numeric if tdp_numeric is not None else 'N/A'}")
+
+            except Exception as e:
+                print(f"Error parsing a row: {e}")
+                # print(f"Problematic row HTML snippet: {str(row)[:500]}")
+        return page_results
+
+    def scrape_all_cpus(self):
+        """Scrape all CPU data by iterating through pages."""
+        page_num = 1
+        consecutive_empty_pages = 0  # To detect end of results
+        max_consecutive_empty = (
+            2  # Stop after 2 consecutive pages with no new valid entries
+        )
+
+        while True:
+            print(f"Processing page {page_num}...")
+            html_content = self.fetch_page(page_num)
+
+            if html_content is None:
+                print(f"Failed to fetch page {page_num} after retries. Stopping.")
+                break
+
+            page_results = self.parse_html(html_content)
+
+            if page_results is None:  # Indicates an unexpected page structure or error
+                print(
+                    f"Could not parse data from page {page_num} or unexpected structure. Stopping."
+                )
+                break
+
+            if not page_results:
+                consecutive_empty_pages += 1
+                print(
+                    f"No results extracted from page {page_num}. Consecutive empty pages: {consecutive_empty_pages}"
+                )
+                if consecutive_empty_pages >= max_consecutive_empty:
+                    print("Reached max consecutive empty pages. Assuming end of data.")
+                    break
+            else:
+                consecutive_empty_pages = 0  # Reset counter if we found data
+                new_cpus_found_on_page = 0
+                for res in page_results:
+                    if (
+                        res not in self.results
+                    ):  # Avoid duplicates if any page re-processing happens
+                        self.results.append(res)
+                        new_cpus_found_on_page += 1
+                print(
+                    f"Added {new_cpus_found_on_page} new CPUs from page {page_num}. Total CPUs: {len(self.results)}"
+                )
+                if new_cpus_found_on_page == 0 and len(page_results) > 0:
+                    # This means all CPUs on this page were duplicates, could be an issue or end of new data
+                    print(
+                        f"All {len(page_results)} CPUs on page {page_num} are duplicates. Considering this as end of new data."
+                    )
+                    break
+
+            page_num += 1
+            time.sleep(1)  # Be respectful to the server
+
+        print(f"Scraping complete. Found {len(self.results)} CPUs.")
+
+    def save_to_csv(self, filename="intel_cpu_ark_dataset.csv"):
+        """Save the scraped data to a CSV file."""
+        filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), filename)
+        if not self.results:
+            print("No data to save to CSV.")
+            return
+
+        keys = self.results[0].keys()
+        with open(filepath, "w", newline="", encoding="utf-8") as f:
+            writer = csv.DictWriter(f, fieldnames=keys)
+            writer.writeheader()
+            writer.writerows(self.results)
+        print(f"Data saved to {filepath}")
+
+
+def main():
+    """Main function to run the scraper."""
+    scraper = IntelCpuScraper()
+    scraper.scrape_all_cpus()
+
+    if scraper.results:
+        scraper.save_to_csv()
+    else:
+        print("No data was scraped.")
+
+
+if __name__ == "__main__":
+    main()
+
+
+"""
+
+Sample content from the Intel ARK page:
+
+Product Name
+Launch Date
+Total Cores
+Max Turbo Frequency
+Processor Base Frequency
+Cache
+TDP
+
+                                    <tr class="blank-table-row   seg-server  seg-embedded  "
+                                        data-codename="Granite Rapids-D"
+                                        data-filter="Server"
+                                        data-product-id="242908">
+                                        <td class="ark-product-name ark-accessible-color component"
+                                            data-value="4" data-component="arkproductlink"
+                                            data-component-id="1">
+                                            <div class="add-compare-wrap">
+                                                <label class="containerCB component" data-component="wa_skip_track"
+                                                    data-component-id="1">
+                                                    <input class="compare-checkbox compare-toggle"
+                                                        data-component="ark-component"
+                                                        data-product-id="242908" type="checkbox">
+                                                    <span class="checkmark"></span>
+                                                </label>
+                                                <a href="/content/www/us/en/products/sku/242908/intel-xeon-6716pb-processor-160m-cache-2-50-ghz/specifications.html">Intel® Xeon® 6716P-B Processor</a>
+                                            </div>
+                                        </td>
+
+                                                <td class=""
+                                                    data-value="">
+                                                                Q2'25
+                                                </td>
+                                                <td class=""
+                                                    data-value="40">
+
+                                                                40
+                                                </td>
+                                                <td class=""
+                                                    data-value="3500">
+                                                                3.5 GHz
+                                                </td>
+                                                <td class=""
+                                                    data-value="2500">
+                                                                2.5 GHz
+                                                </td>
+                                                <td class=""
+                                                    data-value="163840">
+                                                                160 MB
+                                                </td>
+                                                <td class=""
+                                                    data-value="235">
+                                                                235 W
+                                                </td>
+                                    </tr>
+"""

codecarbon/data/hardware/cpu_dataset_builder/merge_scrapped_cpu_power.py

@@ -0,0 +1,159 @@
+"""
+This script updates the CPU power data by reading from Intel and AMD CPU data file,
+cleaning the CPU names, and merging the data into an existing CPU power CSV file.
+It ensures that the TDP values are numeric and updates existing entries or adds new ones.
+
+cd codecarbon/data/hardware/cpu_dataset_builder
+hatch run python merge_scrapped_cpu_power.py
+
+"""
+
+import re
+
+import pandas as pd
+
+# Define file paths
+intel_cpu_file = "intel_cpu_ark_dataset.csv"
+amd_desktop_cpu_file = "amd_cpu_desktop_dataset.csv"
+amd_server_cpu_file = "amd_cpu_server_dataset.csv"
+cpu_power_file = "../cpu_power.csv"
+
+# Read Intel CPU data
+try:
+    intel_df = pd.read_csv(intel_cpu_file)
+    amd_desktop_df = pd.read_csv(amd_desktop_cpu_file)
+    amd_server_df = pd.read_csv(amd_server_cpu_file)
+except FileNotFoundError as e:
+    print(f"FATAL Error: Data file not found {e}")
+    exit(1)
+
+
+# Clean Intel CPU names and select relevant columns
+def clean_intel_cpu_name(name):
+    if pd.isna(name):
+        return None
+    name = re.sub(r"®", "", name)
+    name = name.replace(r"(R)", "")
+    name = name.replace(r"(TM)", "")
+    name = re.sub(r" Processor", "", name)
+    name = re.sub(r" Coprocessor", "", name)
+    name = re.sub(r"™", "", name)
+    name = re.sub(r" with.*", "", name)
+    name = name.strip()
+    if not name.startswith("Intel "):
+        name = "Intel " + name
+    return name
+
+
+if not intel_df.empty:
+    intel_df["Name"] = intel_df["cpu_name"].apply(clean_intel_cpu_name)
+    intel_df = intel_df[["Name", "tdp"]].copy()
+    intel_df.rename(columns={"tdp": "TDP"}, inplace=True)
+else:
+    intel_df = pd.DataFrame(columns=["Name", "TDP"])
+
+
+# Clean AMD CPU names
+def clean_amd_cpu_name(name):
+    if pd.isna(name):
+        return None
+    name = str(name)  # Ensure name is a string
+    name = re.sub(r"®", "", name)
+    name = name.replace(r"(R)", "")
+    name = name.replace(r"(TM)", "")
+    name = re.sub(r" Processor", "", name)
+    name = re.sub(r"™", "", name)
+    name = re.sub(r" with.*", "", name)
+    name = name.strip()
+    if not name.startswith("AMD "):
+        name = "AMD " + name
+    return name
+
+
+def extract_tdp_value(tdp_str):
+    if pd.isna(tdp_str):
+        return None
+    tdp_str = str(tdp_str).replace("W", "").strip()
+    # If it's a range like "15-54", take the upper value
+    if "-" in tdp_str:
+        try:
+            return float(tdp_str.split("-")[-1])
+        except ValueError:
+            return None
+    try:
+        return float(tdp_str)
+    except ValueError:
+        return None
+
+
+amd_desktop_df["Name"] = amd_desktop_df["Name"].apply(clean_amd_cpu_name)
+amd_desktop_df.rename(columns={"Default TDP": "TDP"}, inplace=True)
+amd_desktop_df = amd_desktop_df[["Name", "TDP"]].copy()
+amd_desktop_df["TDP"] = amd_desktop_df["TDP"].apply(extract_tdp_value)
+
+amd_server_df["Name"] = amd_server_df["Name"].apply(clean_amd_cpu_name)
+amd_server_df = amd_server_df[["Name", "Default TDP"]].copy()
+amd_server_df.rename(columns={"Default TDP": "TDP"}, inplace=True)
+amd_server_df["TDP"] = amd_server_df["TDP"].apply(extract_tdp_value)
+
+# Concatenate all CPU data
+all_cpus_df = pd.concat([intel_df, amd_desktop_df, amd_server_df], ignore_index=True)
+
+print(
+    f"Total CPUs found: {len(all_cpus_df)} using Intel {len(intel_df)}, AMD Desktop {len(amd_desktop_df)}, and AMD Server {len(amd_server_df)} datasets."
+)
+
+# Ensure TDP is numeric, coercing errors to NaN (which will be dropped)
+all_cpus_df["TDP"] = pd.to_numeric(all_cpus_df["TDP"], errors="coerce")
+all_cpus_df.dropna(subset=["Name", "TDP"], inplace=True)
+all_cpus_df["TDP"] = all_cpus_df["TDP"].astype(int)
+
+
+# Read existing CPU power data
+try:
+    cpu_power_df = pd.read_csv(cpu_power_file)
+except FileNotFoundError:
+    print(f"FATAL ERROR: cpu_power.csv not found at {cpu_power_file}. Exiting.")
+    exit(1)
+
+
+# Ensure 'Name' column is string type for merging
+cpu_power_df["Name"] = cpu_power_df["Name"].astype(str)
+all_cpus_df["Name"] = all_cpus_df["Name"].astype(str)
+
+# Remove duplicates from cpu_power_df before setting index
+cpu_power_df.drop_duplicates(subset=["Name"], keep="first", inplace=True)
+# Remove duplicates from all_cpus_df before setting index to avoid issues if source data also has dupes
+all_cpus_df.drop_duplicates(subset=["Name"], keep="first", inplace=True)
+
+# Set 'Name' as index for easier update/merge
+cpu_power_df.set_index("Name", inplace=True)
+all_cpus_df.set_index("Name", inplace=True)
+
+# Update existing entries and add new ones
+# For CPUs in all_cpus_df, their TDP will overwrite existing TDP in cpu_power_df
+# New CPUs from all_cpus_df will be added
+cpu_power_df.update(all_cpus_df)
+# Add CPUs from all_cpus_df that were not in cpu_power_df
+new_cpus = all_cpus_df[~all_cpus_df.index.isin(cpu_power_df.index)]
+combined_df = pd.concat([cpu_power_df, new_cpus])
+
+
+# Reset index and sort
+combined_df.reset_index(inplace=True)
+combined_df.sort_values(by="Name", inplace=True, kind="mergesort")
+
+# Drop duplicates, keeping the first occurrence (which would be the updated/new one if there were any issues)
+combined_df.drop_duplicates(subset=["Name"], keep="first", inplace=True)
+
+
+# Save the updated dataframe
+try:
+    combined_df.to_csv(cpu_power_file, index=False)
+    print(
+        f"Successfully updated {cpu_power_file} with data from Intel and AMD CPU datasets."
+    )
+except Exception as e:
+    print(f"Error writing to {cpu_power_file}: {e}")
+
+print(f"Script finished. {cpu_power_file} has been updated.")

codecarbon/data/hardware/cpu_load_profiling/AMD_EPYC_8024P_8C/compare_cpu_load_and_RAPL-all_cores-AMD_EPYC_8024P_8-Core_Processor-2025-01-14-tasks.csv

@@ -0,0 +1 @@
+

codecarbon/data/hardware/cpu_load_profiling/AMD_EPYC_8024P_8C/compare_cpu_load_and_RAPL-all_cores-AMD_EPYC_8024P_8-Core_Processor-2025-01-14.csv

@@ -0,0 +1,12 @@
+task_name,load_type,cpu_name,timestamp,cores_used,cpu_load,temperature,cpu_freq,rapl_power,rapl_energy,estimated_power,estimated_energy,tapo_power,tapo_energy,tapo_time_delta,duration
+Load for 0 threads or % load on all_cores,all_cores,AMD EPYC 8024P 8-Core Processor,1736870539.3604305,16,0.6,0,1588.8038125,0.5890910446092622,0.0001549484709031223,0.5283870967741936,4.483109622193541e-06,0,0,0,30.545820467999988
+Load for 10 threads or % load on all_cores,all_cores,AMD EPYC 8024P 8-Core Processor,1736870570.4132967,16,10.0,0,1499.2493125,18.614618427174943,0.0002482180077409144,9.351290322580647,7.94934203722469e-05,0,0,0,30.604371506000007
+Load for 20 threads or % load on all_cores,all_cores,AMD EPYC 8024P 8-Core Processor,1736870601.5247905,16,20.0,0,1710.87575,29.50062862301284,0.0003278735881319947,18.08709677419355,0.00015376875545155633,0,0,0,30.60747165600003
+Load for 30 threads or % load on all_cores,all_cores,AMD EPYC 8024P 8-Core Processor,1736870632.6398633,16,30.0,0,2275.4458125,38.665937352398046,0.00035451283138781577,26.628387096774198,0.000226326359785935,0,0,0,30.59898082199993
+Load for 40 threads or % load on all_cores,all_cores,AMD EPYC 8024P 8-Core Processor,1736870663.7467482,16,40.3,0,2005.7899375,41.7532422053059,0.000365986424177794,35.12903225806452,0.0002984793734458876,0,0,0,30.587945687
+Load for 50 threads or % load on all_cores,all_cores,AMD EPYC 8024P 8-Core Processor,1736870694.8418806,16,50.0,0,2995.3906875,43.218847417139216,0.0004040316335028266,43.96064516129032,0.00037339789414168585,0,0,0,30.579274994000002
+Load for 60 threads or % load on all_cores,all_cores,AMD EPYC 8024P 8-Core Processor,1736870725.9287038,16,64.6,0,2995.0565625,47.60235461601638,0.0004135376972187821,52.64709677419356,0.0004470785513329841,0,0,0,30.572279641000023
+Load for 70 threads or % load on all_cores,all_cores,AMD EPYC 8024P 8-Core Processor,1736870757.008383,16,70.2,0,2995.4159375,48.71374809013383,0.00041818504176998825,61.33064516129033,0.0005208395157953634,0,0,0,30.573280777000036
+Load for 80 threads or % load on all_cores,all_cores,AMD EPYC 8024P 8-Core Processor,1736870788.0900218,16,80.0,0,2995.0515,49.29431270782221,0.00043202708951028436,69.78193548387098,0.0005926033291364812,0,0,0,30.572722531999943
+Load for 90 threads or % load on all_cores,all_cores,AMD EPYC 8024P 8-Core Processor,1736870819.169809,16,89.4,0,2995.3314375,50.71795701044753,0.00039116028792797984,78.46548387096773,0.0006661357492079613,0,0,0,30.563372235000088
+Load for 100 threads or % load on all_cores,all_cores,AMD EPYC 8024P 8-Core Processor,1736870850.241218,16,100.0,0,2960.06425,46.07999203334885,0.0003927146597270323,86.62645161290322,0.0007355714738463658,0,0,0,30.57010326000011

codecarbon/data/hardware/cpu_load_profiling/AMD_EPYC_8024P_8C/compare_cpu_load_and_RAPL-some_cores-AMD_EPYC_8024P_8-Core_Processor-2025-01-14-tasks.csv

@@ -0,0 +1 @@
+

codecarbon/data/hardware/cpu_load_profiling/AMD_EPYC_8024P_8C/compare_cpu_load_and_RAPL-some_cores-AMD_EPYC_8024P_8-Core_Processor-2025-01-14.csv

@@ -0,0 +1,12 @@
+task_name,load_type,cpu_name,timestamp,cores_used,cpu_load,temperature,cpu_freq,rapl_power,rapl_energy,estimated_power,estimated_energy,tapo_power,tapo_energy,tapo_time_delta,duration
+Load for 0 threads or % load on some_cores,some_cores,AMD EPYC 8024P 8-Core Processor,1736870885.4314823,0,0.0,0,1573.6895625,0.570341609175781,0.0001498387148708754,0.4006451612903227,3.3952651785241804e-06,0,0,0,30.509340853999902
+Load for 1 threads or % load on some_cores,some_cores,AMD EPYC 8024P 8-Core Processor,1736870916.4484718,1,6.8,0,1674.0149375,18.32137992981586,0.0003186004209912441,6.143225806451613,5.213020505654175e-05,0,0,0,30.548963089000154
+Load for 3 threads or % load on some_cores,some_cores,AMD EPYC 8024P 8-Core Processor,1736870947.5048661,3,18.6,0,1875.329125,37.67548313872943,0.00035289236703589175,16.79806451612903,0.00014253898582775382,0,0,0,30.54814376499985
+Load for 4 threads or % load on some_cores,some_cores,AMD EPYC 8024P 8-Core Processor,1736870978.5606444,4,24.8,0,1917.428375,41.64788408234253,0.0003687826669703416,22.357741935483872,0.00018972382129295778,0,0,0,30.549244971999997
+Load for 6 threads or % load on some_cores,some_cores,AMD EPYC 8024P 8-Core Processor,1736871009.6169264,6,37.3,0,2390.904875,43.577488003823284,0.00040014462511544363,33.12870967741936,0.0002811189356871732,0,0,0,30.54906796199998
+Load for 8 threads or % load on some_cores,some_cores,AMD EPYC 8024P 8-Core Processor,1736871040.6735368,8,50.3,0,2577.975125,47.22484688134498,0.0004186007634914522,43.899677419354845,0.00037251962926638875,0,0,0,30.54776646800019
+Load for 9 threads or % load on some_cores,some_cores,AMD EPYC 8024P 8-Core Processor,1736871071.7283158,9,56.2,0,2552.9630625,49.348595570337984,0.00042330994975879783,49.53193548387097,0.00042031326421113654,0,0,0,30.549575562999962
+Load for 11 threads or % load on some_cores,some_cores,AMD EPYC 8024P 8-Core Processor,1736871102.7853847,11,71.6,0,2786.4235,49.929496571226025,0.0004353003696289052,60.29419354838709,0.0005116486368893932,0,0,0,30.549821148999854
+Load for 12 threads or % load on some_cores,some_cores,AMD EPYC 8024P 8-Core Processor,1736871133.8423305,12,78.1,0,2864.8995625,51.11155331744621,0.0003866883171281862,65.8741935483871,0.0005590049861902901,0,0,0,30.550244901000042
+Load for 14 threads or % load on some_cores,some_cores,AMD EPYC 8024P 8-Core Processor,1736871164.901577,14,87.5,0,2994.7883125,45.597339246911396,0.00039462264042008227,76.74677419354839,0.0006513229867146689,0,0,0,30.552348375000065
+Load for 16 threads or % load on some_cores,some_cores,AMD EPYC 8024P 8-Core Processor,1736871195.9626908,16,100.0,0,2953.2051875,46.50666589353752,0.00039668247206794613,87.01548387096774,0.0007384650344527547,0,0,0,30.552532602999918

codecarbon/data/hardware/cpu_load_profiling/AMD_Threadripper/compare_cpu_load_and_RAPL-all_cores-AMD_Ryzen_Threadripper_1950X_16-Core_Processor-2025-01-14.csv

@@ -0,0 +1,12 @@
+task_name,load_type,cpu_name,timestamp,cores_used,cpu_load,temperature,cpu_freq,rapl_power,rapl_energy,estimated_power,estimated_energy,tapo_power,tapo_energy,tapo_time_delta,duration
+Load for 0 threads or % load on all_cores,all_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861292.1865184,32,2.8,34.0,2332.872375,1.376693725703893,0.00036348698592824497,2.685483870967742,2.287107937566501e-05,115,0,25.784160137176514,30.67482220400052
+Load for 10 threads or % load on all_cores,all_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861323.3733351,32,13.9,39.0,2398.1069375,43.30157205175239,0.0005287301286782094,18.41632258064516,0.00015699294566882027,147,2,31.239955186843872,30.690144125997904
+Load for 20 threads or % load on all_cores,all_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861354.606225,32,23.2,49.0,2525.59284375,62.548275592287716,0.000667400991698144,51.95264516129033,0.0004430374025184006,198,1,31.248691082000732,30.67295572799776
+Load for 30 threads or % load on all_cores,all_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861385.796707,32,36.4,46.0,2797.5584375,79.17104774627222,0.0009009795239774861,82.75797881016943,0.0007061364594770959,226,2,31.160773754119873,30.710970439999073
+Load for 40 threads or % load on all_cores,all_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861417.028149,32,44.8,51.0,2821.1256562500002,106.32788732711822,0.0010895405520484095,121.69003144108179,0.001039181644778305,257,2,31.274537086486816,30.744163438001124
+Load for 50 threads or % load on all_cores,all_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861448.2934384,32,53.1,52.0,2987.12765625,128.12680031791092,0.0012224324344729436,150.75142340191675,0.0012868445490575916,219,2,31.180025577545166,30.71990360300333
+Load for 60 threads or % load on all_cores,all_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861479.5261245,32,66.0,56.0,3690.57340625,144.1489018144105,0.0014702612339858234,160.82284379438934,0.0013702119021750114,285,2,31.250231504440308,30.68199840700254
+Load for 70 threads or % load on all_cores,all_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861510.718988,32,72.1,57.0,3576.53553125,172.4348439188416,0.0014511648695420768,166.20343002665635,0.001415799954084005,278,3,31.177345514297485,30.66615740099951
+Load for 80 threads or % load on all_cores,all_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861541.892845,32,83.1,56.0,3418.62696875,170.32448690508448,0.0014419653435713518,169.0462755144238,0.001440005981082607,279,2,31.25270128250122,30.67268269300257
+Load for 90 threads or % load on all_cores,all_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861573.0767784,32,91.7,56.0,3357.159875,169.17512402821018,0.001424203854084394,170.99110652598637,0.0014592032859312692,277,2,31.135616064071655,30.722248964000755
+Load for 100 threads or % load on all_cores,all_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861604.3297272,32,99.7,56.0,3323.42371875,166.8914474009169,0.0014241745394776087,172.01108915577154,0.0014670329755684629,278,3,31.260193586349487,30.684765958001663

codecarbon/data/hardware/cpu_load_profiling/AMD_Threadripper/compare_cpu_load_and_RAPL-some_cores-AMD_Ryzen_Threadripper_1950X_16-Core_Processor-2025-01-14.csv

@@ -0,0 +1,12 @@
+task_name,load_type,cpu_name,timestamp,cores_used,cpu_load,temperature,cpu_freq,rapl_power,rapl_energy,estimated_power,estimated_energy,tapo_power,tapo_energy,tapo_time_delta,duration
+Load for 0 threads or % load on some_cores,some_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861645.8957796,0,5.0,44.0,2404.504125,1.4314313929445108,0.00037612030867378377,2.5403225806451615,2.1533075069456695e-05,161,2,41.54746890068054,30.50736453400168
+Load for 3 threads or % load on some_cores,some_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861676.92222,3,12.2,53.0,2470.4883125,45.38482572705677,0.000643388347349155,15.636774193548389,0.00013281317053516283,159,1,31.027068614959717,30.60917342099856
+Load for 6 threads or % load on some_cores,some_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861708.0628958,6,22.9,57.0,2782.765875,76.2361648967495,0.0007852407877754612,45.20264516129032,0.00038409021052205965,178,2,31.136895179748535,30.582065591002902
+Load for 9 threads or % load on some_cores,some_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861739.1693892,9,32.2,53.0,2985.71678125,93.3325909425021,0.0010383771248677017,79.43787901061218,0.0006748331769033504,266,2,31.1038601398468,30.566226797000127
+Load for 12 threads or % load on some_cores,some_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861770.2447922,12,41.4,56.0,3206.83459375,123.02110940943629,0.0012440137061823899,106.22233175845183,0.000901886908494226,278,2,31.06801199913025,30.572869749998063
+Load for 16 threads or % load on some_cores,some_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861801.3405495,16,52.0,59.0,3497.22140625,147.40291619865533,0.0014847857724110004,151.95548639522778,0.0012909726593646263,278,2,31.09264326095581,30.595551153000997
+Load for 19 threads or % load on some_cores,some_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861832.4449117,19,64.0,61.0,3411.51403125,174.78376979270854,0.001472625799905254,161.29498553839264,0.0013694488571545866,279,3,31.248048543930054,30.567659471998923
+Load for 22 threads or % load on some_cores,some_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861863.553106,22,73.1,60.0,3552.37396875,173.30973054466918,0.0014398759664831836,165.96767419530283,0.0014106243805873664,324,2,31.02893352508545,30.57063357000152
+Load for 25 threads or % load on some_cores,some_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861894.641952,25,80.1,60.0,3314.47165625,169.42739506124113,0.0014223668401147846,169.16041577918944,0.0014371547304600357,326,3,31.0912823677063,30.577015545000904
+Load for 28 threads or % load on some_cores,some_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861925.7400923,28,92.5,59.0,3611.6851875,167.4199618733835,0.0014106022938975976,170.8023391866958,0.0014508931444192387,280,3,31.036678552627563,30.5716582189998
+Load for 32 threads or % load on some_cores,some_cores,AMD Ryzen Threadripper 1950X 16-Core Processor,1736861956.8230855,32,100.0,58.0,3399.25659375,166.03346252141944,0.0014042897956531592,172.11738734560865,0.0014619673561903947,290,2,31.138123273849487,30.579071764001128

codecarbon/data/hardware/cpu_load_profiling/E3-1240/compare_cpu_load_and_RAPL-all_cores-Intel(R)_Xeon(R)_CPU_E3-1240_V2_@_3.40GHz-2025-01-14-tasks.csv

@@ -0,0 +1 @@
+

codecarbon/data/hardware/cpu_load_profiling/E3-1240/compare_cpu_load_and_RAPL-all_cores-Intel(R)_Xeon(R)_CPU_E3-1240_V2_@_3.40GHz-2025-01-14.csv

@@ -0,0 +1,12 @@
+task_name,load_type,cpu_name,timestamp,cores_used,cpu_load,temperature,cpu_freq,rapl_power,rapl_energy,estimated_power,estimated_energy,tapo_power,tapo_energy,tapo_time_delta,duration
+Load for 0 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866099.9980605,8,2.5,49.0,1599.327875,0.1762793799621185,4.6355697362304715e-05,0.9059032258064517,7.684335073074023e-06,0,0,0,30.538775300999987
+Load for 10 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866131.0446987,8,12.5,49.8,1599.292875,5.5088107550388195,5.799798473168395e-05,7.701290322580645,6.536165501667947e-05,0,0,0,30.556003262000104
+Load for 20 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866162.1088045,8,21.8,49.8,1615.887,6.874427700098117,6.887324732077552e-05,14.45883870967742,0.00012281514661734017,0,0,0,30.5808577480002
+Load for 30 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866193.198372,8,32.5,51.2,1608.707625,8.150962966608036,8.008787768136114e-05,21.122903225806454,0.00017917736530554418,0,0,0,30.538505429999987
+Load for 40 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866224.2449238,8,41.2,52.6,1774.674,9.590357335248587,0.00011939784885153792,27.519870967741934,0.00023356720765311314,0,0,0,30.55596754599992
+Load for 50 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866255.3088953,8,51.3,67.0,3691.3945,14.386126401140913,0.0002032038075629114,34.119387096774204,0.0002894370308469203,0,0,0,30.540959523999845
+Load for 60 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866286.357926,8,60.8,67.8,3203.470375,24.131781439057242,0.0002502017190501027,40.80125806451613,0.00034607542561449563,0,0,0,30.536806867999985
+Load for 70 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866317.402762,8,71.3,82.6,3592.053,29.980918434149974,0.0003775369217515201,47.27390322580646,0.0004010445097183033,0,0,0,30.541943295000237
+Load for 80 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866348.452758,8,80.2,86.0,3594.7035,44.58692502781162,0.0004000440664238894,53.58183870967742,0.00045449143269400997,0,0,0,30.537735556999905
+Load for 90 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866379.4978347,8,88.9,84.6,3591.723,47.199718258502074,0.0004102256151246736,60.172451612903224,0.0005103165358412896,0,0,0,30.533969553000134
+Load for 100 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866410.5401917,8,100.0,85.2,3591.759875,48.40222176814008,0.00041915237032163,66.44032258064517,0.0005636082589397366,0,0,0,30.540446279000207

codecarbon/data/hardware/cpu_load_profiling/E3-1240/compare_cpu_load_and_RAPL-some_cores-Intel(R)_Xeon(R)_CPU_E3-1240_V2_@_3.40GHz-2025-01-14-tasks.csv

@@ -0,0 +1 @@
+

codecarbon/data/hardware/cpu_load_profiling/E3-1240/compare_cpu_load_and_RAPL-some_cores-Intel(R)_Xeon(R)_CPU_E3-1240_V2_@_3.40GHz-2025-01-14.csv

@@ -0,0 +1,10 @@
+task_name,load_type,cpu_name,timestamp,cores_used,cpu_load,temperature,cpu_freq,rapl_power,rapl_energy,estimated_power,estimated_energy,tapo_power,tapo_energy,tapo_time_delta,duration
+Load for 0 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866451.8262937,0,2.5,59.4,1622.370375,0.1829557095380892,4.8066226786283583e-05,1.175225806451613,9.959652394347182e-06,0,0,0,30.510028410999894
+Load for 1 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866482.8443036,1,13.7,66.8,2909.180125,6.1681087430444785,0.00017863574624181477,8.820870967741937,7.480994601777782e-05,0,0,0,30.532809745000122
+Load for 2 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866513.885087,2,25.3,74.4,3154.836875,21.330531392160513,0.0002490961023322788,17.167645161290324,0.00014560237809553166,0,0,0,30.533378567
+Load for 3 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866544.926259,3,38.8,82.4,3379.551,29.60393014529158,0.000310693952443852,25.54335483870968,0.00021663643725879813,0,0,0,30.533274188000178
+Load for 4 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866575.9672496,4,50.0,90.6,3093.732375,36.830415975414766,0.000362681275978122,33.9123870967742,0.00028761470732627394,0,0,0,30.533258208000007
+Load for 5 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866607.008547,5,60.8,93.8,3591.593,42.818970213978986,0.00037760179374785995,41.602548387096775,0.0003528519844455608,0,0,0,30.534384863000014
+Load for 6 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866638.0509386,6,76.2,90.0,3342.7835,44.592887191004166,0.0003967921685445921,50.56587096774194,0.00042885450421531923,0,0,0,30.533063157000015
+Load for 7 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866669.0927322,7,88.7,83.0,3591.758125,46.8127764264249,0.0004043059895556436,59.023935483870964,0.0005006315188387323,0,0,0,30.53561314799981
+Load for 8 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736866700.138663,8,100.0,84.2,3591.768875,47.73004219703574,0.0004210827754770616,66.56941935483871,0.0005645897030578939,0,0,0,30.5334539090004

codecarbon/data/hardware/cpu_load_profiling/E5-1240/compare_cpu_load_and_RAPL-all_cores-Intel(R)_Xeon(R)_CPU_E3-1240_V2_@_3.40GHz-2025-01-14-tasks.csv

@@ -0,0 +1 @@
+

codecarbon/data/hardware/cpu_load_profiling/E5-1240/compare_cpu_load_and_RAPL-all_cores-Intel(R)_Xeon(R)_CPU_E3-1240_V2_@_3.40GHz-2025-01-14.csv

@@ -0,0 +1,12 @@
+task_name,load_type,cpu_name,timestamp,cores_used,cpu_load,temperature,cpu_freq,rapl_power,rapl_energy,estimated_power,estimated_energy,tapo_power,tapo_energy,tapo_time_delta,duration
+Load for 0 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864264.566133,8,2.5,55.4,1597.2875,0.24045452886021762,6.321467779392322e-05,0.9437419354838712,8.00299163331743e-06,0,0,0,30.530655949999982
+Load for 10 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864295.6047955,8,10.3,56.0,1608.7538749999999,7.538504597340449,8.54672550404164e-05,7.728000000000001,6.558665694214691e-05,0,0,0,30.552170786000033
+Load for 20 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864326.6656816,8,21.3,56.6,1596.3545,10.155731937011202,0.00010787949074796827,14.314161290322582,0.00012158928507307066,0,0,0,30.58094489799987
+Load for 30 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864357.7544494,8,31.6,57.4,1597.23125,12.777656622991184,0.00012821319923714356,21.04277419354839,0.0001784956265845537,0,0,0,30.539114385999937
+Load for 40 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864388.8024442,8,41.3,58.6,2180.2647500000003,15.395214417842357,0.0002021824959125328,27.571064516129034,0.00023397646594410047,0,0,0,30.551980603000175
+Load for 50 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864419.8624222,8,51.9,61.8,1793.815125,24.21258198840792,0.0003044742055236128,34.221774193548384,0.00029040600192907343,0,0,0,30.55149350800002
+Load for 60 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864450.9216642,8,62.0,78.2,3588.65625,36.60190500045977,0.0004947912699993662,40.71445161290323,0.00034540601126875473,0,0,0,30.542951248999998
+Load for 70 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864481.9730074,8,70.0,87.6,3591.77275,59.21681786864419,0.0007304884855014321,47.18487096774194,0.0004002782981833257,0,0,0,30.540747797999984
+Load for 80 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864513.0216124,8,80.0,92.4,3591.752625,86.28703440247716,0.0007775349425830115,53.49503225806452,0.00045366902355707455,0,0,0,30.532312602000047
+Load for 90 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864544.062235,8,89.6,93.8,3591.755875,91.60016243312562,0.0007568507235356488,58.56987096774195,0.0004968053414603382,0,0,0,30.538087567000048
+Load for 100 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864575.1117647,8,84.6,93.4,3591.759375,89.35810683301246,0.0007923197952442191,63.940741935483864,0.0005423658388764648,0,0,0,30.537738765000086

codecarbon/data/hardware/cpu_load_profiling/E5-1240/compare_cpu_load_and_RAPL-some_cores-Intel(R)_Xeon(R)_CPU_E3-1240_V2_@_3.40GHz-2025-01-14-tasks.csv

@@ -0,0 +1 @@
+

codecarbon/data/hardware/cpu_load_profiling/E5-1240/compare_cpu_load_and_RAPL-some_cores-Intel(R)_Xeon(R)_CPU_E3-1240_V2_@_3.40GHz-2025-01-14.csv

@@ -0,0 +1,10 @@
+task_name,load_type,cpu_name,timestamp,cores_used,cpu_load,temperature,cpu_freq,rapl_power,rapl_energy,estimated_power,estimated_energy,tapo_power,tapo_energy,tapo_time_delta,duration
+Load for 0 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864616.3802829,0,1.3,64.4,1722.9547499999999,0.24348604948238767,6.396986895363006e-05,0.9637741935483872,8.167858581407357e-06,0,0,0,30.510393207000106
+Load for 1 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864647.3992167,1,13.8,71.8,2908.105125,8.546889319740076,0.00032664317798099946,8.972225806451613,7.609811727004668e-05,0,0,0,30.53422949700007
+Load for 2 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864678.4420338,2,25.0,77.6,2677.836875,39.05248608945464,0.00046885920175372686,17.312322580645162,0.00014683093029187213,0,0,0,30.53335141499997
+Load for 3 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864709.4832304,3,38.8,82.0,3093.805875,55.74034273843472,0.00058967813118657,25.610129032258065,0.0002172003980805138,0,0,0,30.53297458499992
+Load for 4 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864740.5242574,4,51.3,89.4,3592.125625,69.91521339597362,0.000691733977831184,34.019225806451615,0.0002885280151346684,0,0,0,30.534353922000037
+Load for 5 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864771.5664937,5,60.0,94.6,3591.77,81.68108269518869,0.0007244284862089941,41.13290322580646,0.0003488550486577481,0,0,0,30.533480329999975
+Load for 6 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864802.6076632,6,70.9,92.6,3591.811375,85.51117470400919,0.0007499405605075199,49.79129032258064,0.0004222963451957981,0,0,0,30.534298728000067
+Load for 7 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864833.6504998,7,88.9,90.6,3591.7715,88.5859467712891,0.000793641966024175,59.197548387096774,0.0005020658069015539,0,0,0,30.533413398999983
+Load for 8 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E3-1240 V2 @ 3.40GHz,1736864864.6926847,8,100.0,90.6,3591.7475,93.67184784435268,0.0008193529074262459,66.63396774193548,0.000565153702695967,0,0,0,30.53452582199975

codecarbon/data/hardware/cpu_load_profiling/E5-2620/compare_cpu_load_and_RAPL-all_cores-Intel(R)_Xeon(R)_CPU_E5-2620_v3_@_2.40GHz-2025-01-14-tasks.csv

@@ -0,0 +1 @@
+

codecarbon/data/hardware/cpu_load_profiling/E5-2620/compare_cpu_load_and_RAPL-all_cores-Intel(R)_Xeon(R)_CPU_E5-2620_v3_@_2.40GHz-2025-01-14.csv

@@ -0,0 +1,12 @@
+task_name,load_type,cpu_name,timestamp,cores_used,cpu_load,temperature,cpu_freq,rapl_power,rapl_energy,estimated_power,estimated_energy,tapo_power,tapo_energy,tapo_time_delta,duration
+Load for 0 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736851743.3478487,24,0.0,32.92857142857143,1666.6777916666667,0.5133866472185064,0.00013516682896670684,0.13709677419354838,1.1643220985035955e-06,0,0,0,30.57596656700025
+Load for 10 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736851774.4329672,24,10.0,34.0,1395.8670833333333,16.393231698147034,0.0002615093458739823,16.70387096774194,0.00014209152257347633,0,0,0,30.625665163999656
+Load for 20 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736851805.5679224,24,20.0,35.214285714285715,1200.067875,30.981249858901204,0.00032480096234055456,33.150000000000006,0.00028184237688695906,0,0,0,30.609375409999302
+Load for 30 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736851836.6865406,24,30.0,36.42857142857143,1200.0924166666666,38.4109895669274,0.0003803408392724292,49.54677419354839,0.00042138001590360423,0,0,0,30.619102634000228
+Load for 40 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736851867.8147955,24,40.5,39.0,1359.3699583333334,45.28221173134997,0.0005286525493105876,65.92709677419354,0.000560481283428218,0,0,0,30.607923018999827
+Load for 50 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736851898.9319813,24,50.2,40.07142857142857,1675.1815833333333,62.15733970891361,0.0005226188955947848,82.30741935483871,0.0006995284841773753,0,0,0,30.598696191000272
+Load for 60 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736851930.0399046,24,60.0,42.42857142857143,2081.6238333333336,61.94885605758223,0.0006439153740207745,98.64935483870968,0.0008383901874825152,0,0,0,30.59755781199965
+Load for 70 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736851961.1466608,24,69.9,47.42857142857143,2600.2822499999997,76.92334580239137,0.0009501084453639348,114.92,0.0009769654159054015,0,0,0,30.606379566000214
+Load for 80 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736851992.2622006,24,80.8,49.714285714285715,2606.1148333333335,111.88460818853675,0.0009838415673504054,131.25645161290325,0.0011155469922320095,0,0,0,30.59841364100066
+Load for 90 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736852023.370749,24,89.7,51.642857142857146,2566.944875,115.80752337627442,0.0009980875206916026,147.63129032258067,0.0012548379009832316,0,0,0,30.60126471300009
+Load for 100 threads or % load on all_cores,all_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736852054.4802783,24,99.6,51.214285714285715,2400.266,117.01747308959027,0.0008921996457035876,163.77032258064517,0.001391876641844674,0,0,0,30.598267295999904

codecarbon/data/hardware/cpu_load_profiling/E5-2620/compare_cpu_load_and_RAPL-some_cores-Intel(R)_Xeon(R)_CPU_E5-2620_v3_@_2.40GHz-2025-01-14-tasks.csv

@@ -0,0 +1 @@
+

codecarbon/data/hardware/cpu_load_profiling/E5-2620/compare_cpu_load_and_RAPL-some_cores-Intel(R)_Xeon(R)_CPU_E5-2620_v3_@_2.40GHz-2025-01-14.csv

@@ -0,0 +1,12 @@
+task_name,load_type,cpu_name,timestamp,cores_used,cpu_load,temperature,cpu_freq,rapl_power,rapl_energy,estimated_power,estimated_energy,tapo_power,tapo_energy,tapo_time_delta,duration
+Load for 0 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736852095.9750729,0,0.0,42.142857142857146,1479.1971666666668,0.5065285278727721,0.00013308117646485332,0.10419354838709678,8.830525274655887e-07,0,0,0,30.511303407000014
+Load for 2 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736852126.9954355,2,8.7,41.0,1316.7375833333333,16.312251102677653,0.00029392221235980537,13.852258064516132,0.00011764077408649119,0,0,0,30.57471732799968
+Load for 4 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736852158.079285,4,17.0,40.142857142857146,1212.5389583333333,34.76638021452525,0.00033555079427375484,27.671612903225803,0.00023500116479415815,0,0,0,30.57451805099936
+Load for 7 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736852189.1629093,7,29.0,41.214285714285715,1361.3113333333333,39.833438799011766,0.0004206977390579236,48.15387096774193,0.00040898022458755426,0,0,0,30.57759773700036
+Load for 9 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736852220.2496197,9,37.9,41.0,1200.0558333333333,49.54412283036035,0.00042417380406099825,61.92387096774194,0.0005259465888520012,0,0,0,30.577943293000317
+Load for 12 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736852251.3367052,12,50.0,42.214285714285715,1254.2069583333334,50.48931782182756,0.0005688961442832166,82.45548387096774,0.0007003238567262363,0,0,0,30.577464056999816
+Load for 14 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736852282.4232924,14,58.7,43.642857142857146,1400.1012083333335,67.12624394179127,0.0006075904494053028,96.15419354838708,0.0008166565664626951,0,0,0,30.5767449519999
+Load for 16 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736852313.508811,16,66.7,44.642857142857146,1458.4309166666665,71.54867753236186,0.0006107800055680582,109.87483870967742,0.0009332072212445437,0,0,0,30.57744154000011
+Load for 19 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736852344.5952287,19,79.2,45.92857142857143,1721.068375,72.0308325399428,0.0006425051590037145,130.43387096774194,0.0011079623452897123,0,0,0,30.58129966099932
+Load for 21 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736852375.6856108,21,87.5,46.214285714285715,1712.7019166666666,75.74636452660306,0.0006716593131603499,144.1051612903226,0.001224281732537364,0,0,0,30.589186831000006
+Load for 24 threads or % load on some_cores,some_cores,Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz,1736852406.785565,24,100.0,48.07142857142857,2250.244458333333,79.60567601760141,0.0008177076741656131,164.37354838709678,0.0013961793068869984,0,0,0,30.57898776299953

codecarbon/data/private_infra/2016/canada_energy_mix.json

@@ -0,0 +1,171 @@
+{
+    "british columbia": {
+        "naturalGas": 1.1,
+        "nuclear": 0.0,
+        "petroleum": 0.7,
+        "biomass": 6.4,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 0.0,
+        "tidal": 0.0,
+        "total": 100,
+        "wind": 1.3,
+        "hydro": 90.5
+    },
+    "newfoundland and labrador": {
+        "naturalGas": 0.7,
+        "nuclear": 0.0,
+        "petroleum": 4.8,
+        "biomass": 0.3,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 0.0,
+        "tidal": 0.0,
+        "total": 100,
+        "wind": 0.5,
+        "hydro": 93.7
+    },
+    "saskatchewan": {
+        "naturalGas": 35.7,
+        "nuclear": 0.0,
+        "petroleum": 0.0,
+        "biomass": 0.0,
+        "coal": 46.6,
+        "other": 0.0,
+        "solar": 0.1,
+        "tidal": 0.0,
+        "total": 99.9,
+        "wind": 3.8,
+        "hydro": 13.7
+    },
+    "prince edward island": {
+        "naturalGas": 0.0,
+        "nuclear": 0.0,
+        "petroleum": 1.1,
+        "biomass": 0.7,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 0.3,
+        "tidal": 0.0,
+        "total": 100,
+        "wind": 97.9,
+        "hydro": 0.0
+    },
+    "ontario": {
+        "naturalGas": 5.2,
+        "nuclear": 58.6,
+        "petroleum": 0.1,
+        "biomass": 1.3,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 2.2,
+        "tidal": 0.0,
+        "total": 100,
+        "wind": 6.7,
+        "hydro": 25.9
+    },
+    "nova scotia": {
+        "naturalGas": 14.3,
+        "nuclear": 0.0,
+        "petroleum": 12.2,
+        "biomass": 4.9,
+        "coal": 47.9,
+        "other": 0.0,
+        "solar": 0.03,
+        "tidal": 0.2,
+        "total": 100.13,
+        "wind": 11.8,
+        "hydro": 8.8
+    },
+    "quebec": {
+        "naturalGas": 0.1,
+        "nuclear": 0.0,
+        "petroleum": 0.2,
+        "biomass": 0.8,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 0.0,
+        "tidal": 0.0,
+        "total": 100,
+        "wind": 3.9,
+        "hydro": 95.0
+    },
+    "alberta": {
+        "naturalGas": 42.2,
+        "nuclear": 0.0,
+        "petroleum": 2.6,
+        "biomass": 2.2,
+        "coal": 44.9,
+        "other": 0.2,
+        "solar": 0.1,
+        "tidal": 0.0,
+        "total": 100.1,
+        "wind": 5.4,
+        "hydro": 2.5
+    },
+    "manitoba": {
+        "naturalGas": 0.0,
+        "nuclear": 0.0,
+        "petroleum": 0.2,
+        "biomass": 0.1,
+        "coal": 0.1,
+        "other": 0.0,
+        "solar": 0.0,
+        "tidal": 0.0,
+        "total": 99.9,
+        "wind": 2.7,
+        "hydro": 96.8
+    },
+    "northwest territories": {
+        "naturalGas": 4.0,
+        "nuclear": 0.0,
+        "petroleum": 55.3,
+        "biomass": 0.0,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 0.2,
+        "tidal": 0.0,
+        "total": 100,
+        "wind": 2.0,
+        "hydro": 38.5
+    },
+    "new brunswick": {
+        "naturalGas": 9.9,
+        "nuclear": 36.1,
+        "petroleum": 7.6,
+        "biomass": 4.2,
+        "coal": 15.8,
+        "other": 0.0,
+        "solar": 0.0,
+        "tidal": 0.0,
+        "total": 99.8,
+        "wind": 6.6,
+        "hydro": 19.6
+    },
+    "nunavut": {
+        "naturalGas": 0.0,
+        "nuclear": 0.0,
+        "petroleum": 100.0,
+        "biomass": 0.0,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 0.0,
+        "tidal": 0.0,
+        "total": 100,
+        "wind": 0.0,
+        "hydro": 0.0
+    },
+    "yukon": {
+        "naturalGas": 2.0,
+        "nuclear": 0.0,
+        "petroleum": 5.5,
+        "biomass": 0.0,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 0.3,
+        "tidal": 0.0,
+        "total": 100,
+        "wind": 0.0,
+        "hydro": 92.2
+    }
+}