My idea for this seems a bit different, but maybe the difference is only superficial. Let me present what you stated here, but in the form I imagined, so we can see if our views match.
First, we have some set of components. These represent hardware blocks, and we can think of this set as a database of known processors, accelerators, etc. Let’s say we have
// I don't know specific names, but "NVIDIA_GPU_type1" could stand for "RTX3080"
// or something like that.
Component NVIDIA_GPU_type1;
Component NVIDIA_GPU_type2;
Component AMDGPU_type1;
Component X86_64_type1;
Then, for describing a specific system, we’d create an “architecture”:
Architecture = {
Components = [X86_64_type1, NVIDIA_GPU_type1, NVIDIA_GPU_type1];
// Abbreviate C[x] = Components[x]
Connections = [(C[0], C[1], "uni-directional"),
(C[0], C[2], "uni-directional")]
}
This would represent an X86 with two GPUs, where the X86 can actively communicate with each GPU, but GPUs cannot actively communicate with anything.
We could then say
class DeviceWithHostArch : public Architecture {
public:
int host; // Components[host] is the host.
};
Making architecture a member of DeviceWithHostArch would probably be better, but the idea is the same.
Seems like the main difference is that you put Target in the derived classes, whereas in my idea, targets (components) would be listed in Architecture. The components list in the architecture could have additional properties, like OS:
Components = [
(X86_CPU_type1, Linux),
(NVIDIA_GPU_type1, baremetal),
(NVIDIA_GPU_type1, baremetal),
]
The idea is to have a set of building blocks, and a way to represent structures that we can build from them in a way that we can add more blocks without having to modify anything else (to enable their use).