hardware_topology.h

Go to the documentation of this file.

/*
 * Copyright 2025 Stanford University, NVIDIA Corporation
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef REALM_TOPOLOGY_H
#define REALM_TOPOLOGY_H
 
#include "realm/realm_config.h"
#include <stddef.h>
#include <memory>
#include <set>
#include <map>
#include <vector>
 
namespace Realm {
 
  class HardwareTopology {
 
  public:
    typedef int ProcID;
 
    struct Proc {
      ProcID id;                        
      int domain;                       
      std::set<ProcID> kernel_proc_ids; 
      std::set<ProcID>
          shares_alu; 
      std::set<ProcID>
          shares_fpu; 
      std::set<ProcID>
          shares_ldst; 
    };
 
    struct MemoryInfo {
      size_t bytes; 
      int domain;   
    };
 
    static HardwareTopology create_topology(void);
 
    HardwareTopology(void);
 
    HardwareTopology(const std::vector<Proc> &logical_cores,
                     const std::vector<MemoryInfo> &memories, const size_t host_memory);
 
    ~HardwareTopology(void);
 
    HardwareTopology &operator=(const HardwareTopology &rhs) = default;
 
    void remove_hyperthreads(void);
 
    size_t system_memory(void) const;
 
    unsigned num_logical_cores(void) const;
 
    unsigned num_physical_cores(void) const;
 
    unsigned num_numa_domains(void) const;
 
    void get_logical_cores(std::set<ProcID> &cores) const;
 
    bool has_processor(ProcID proc_id) const;
 
    bool numa_domain_has_processors(int domain_id) const;
 
    const std::set<ProcID> &get_processors_by_domain(int domain_id) const;
 
    const std::set<ProcID> &get_processors_share_alu(ProcID proc_id) const;
 
    const std::set<ProcID> &get_processors_share_fpu(ProcID proc_id) const;
 
    const std::set<ProcID> &get_processors_share_ldst(ProcID proc_id) const;
 
    const std::set<ProcID> &get_kernel_processor_ids(ProcID proc_id) const;
 
    std::vector<ProcID> distribute_processors_across_domains(void) const;
 
    friend std::ostream &operator<<(std::ostream &os, const HardwareTopology &topo);
 
  private:
    size_t sys_memory_size{0};  
    unsigned physical_cores{0}; 
 
    typedef std::map<ProcID, Proc> ProcMap; 
 
    struct DomainInfo {
      size_t memory_size;             
      std::set<ProcID> logical_cores; 
    };
 
    typedef std::map<int, DomainInfo> DomainMap; 
 
    ProcMap all_procs;   
    DomainMap by_domain; 
  };
 
}; /* namespace Realm*/
 
#endif /* REALM_TOPOLOGY_H */