from dataclasses import dataclass

@dataclass
class ModelConfig:
    name: str
    num_layers: int
    hidden_size: int
    num_attention_heads: int
    vocab_size: int
    intermediate_size: int
    
    @property
    def total_params(self) -> int:
        embedding = self.vocab_size * self.hidden_size
        qkv = 3 * self.hidden_size * self.hidden_size
        attn_out = self.hidden_size * self.hidden_size
        ffn = 3 * self.hidden_size * self.intermediate_size
        per_layer = qkv + attn_out + ffn
        return embedding + self.num_layers * per_layer + self.hidden_size

@dataclass
class InferenceMetrics:
    model: ModelConfig
    batch_size: int
    prompt_tokens: int
    generate_tokens: int
    
    def prefill_compute(self) -> float:
        return 2.0 * self.model.total_params * self.prompt_tokens * self.batch_size
    
    def decode_compute_per_token(self) -> float:
        return 2.0 * self.model.total_params * self.batch_size

def analyze_bottleneck():
    model = ModelConfig("LLaMA-70B", 80, 8192, 64, 32000, 28672)
    metrics = InferenceMetrics(model, 1, 2048, 256)
    
    print(f"Model: {model.name}")
    print(f"Total params: {model.total_params/1e9:.1f}B")
    print(f"Prefill compute: {metrics.prefill_compute()/1e12:.2f} TFLOPs")
    print(f"Decode compute/token: {metrics.decode_compute_per_token()/1e12:.2f} TFLOPs")
    
    # GPU cluster inter-chip latency
    gpu_latency = 50  # μs, NVLink
    wse_latency = 0.5  # μs, on-chip
    print(f"\nGPU inter-chip latency: {gpu_latency} μs")
    print(f"WSE on-chip latency: {wse_latency} μs")
    print(f"Latency reduction: {gpu_latency/wse_latency:.0f}x")

if __name__ == "__main__":
    analyze_bottleneck()

package main

import "fmt"

type WSEConfig struct {
	Cores        int
	MemoryBW     float64 // TB/s
	OnChipLatency float64 // ns
}

type GPUClusterConfig struct {
	NumGPUs          int
	InterconnectBW   float64 // GB/s
	InterconnectLatency float64 // μs
}

type InferenceLatencyModel struct {
	ModelParams    int64
	GenerateLength int
}

func (m *InferenceLatencyModel) DecodeTimeOnGPU(gpu GPUClusterConfig) float64 {
	memAccess := float64(m.ModelParams) * 2
	// Simulate GPU memory bandwidth bottleneck
	commOverhead := gpu.InterconnectLatency * 1e-6
	return memAccess / 3.35e12 + commOverhead
}

func (m *InferenceLatencyModel) DecodeTimeOnWSE(wse WSEConfig) float64 {
	memAccess := float64(m.ModelParams) * 2
	return memAccess / (wse.MemoryBW * 1e12) + wse.OnChipLatency * 1e-9
}

func main() {
	model := &InferenceLatencyModel{ModelParams: 70e9, GenerateLength: 256}
	
	gpu := GPUClusterConfig{NumGPUs: 8, InterconnectBW: 900, InterconnectLatency: 50}
	wse := WSEConfig{Cores: 900000, MemoryBW: 20, OnChipLatency: 0.5}
	
	decodeGPU := model.DecodeTimeOnGPU(gpu)
	decodeWSE := model.DecodeTimeOnWSE(wse)
	
	fmt.Printf("Per-token decode latency:\n")
	fmt.Printf("  GPU cluster: %.2f ms\n", decodeGPU*1000)
	fmt.Printf("  WSE-3: %.2f ms\n", decodeWSE*1000)
	fmt.Printf("  Latency improvement: %.1fx\n", decodeGPU/decodeWSE)
	
	// Agent scenario (50 tool calls)
	agentCalls := 50
	fmt.Printf("\nAgent scenario (%d calls):\n", agentCalls)
	fmt.Printf("  GPU cluster: %.2f s\n", decodeGPU*float64(agentCalls)*float64(model.GenerateLength))
	fmt.Printf("  Split arch: %.2f s\n", decodeWSE*float64(agentCalls)*float64(model.GenerateLength))
}

from dataclasses import dataclass

@dataclass
class AIScenario:
    name: str
    max_latency_ms: float
    market_size: str

scenarios = [
    AIScenario("Autonomous Driving", 5, ">$50B"),
    AIScenario("Humanoid Robot Control", 10, ">$30B"),
    AIScenario("AI Coding Assistant", 50, ">$20B"),
    AIScenario("Real-Time AI Agent", 100, ">$15B"),
    AIScenario("Cybersecurity Analysis", 10, ">$10B"),
    AIScenario("High-Frequency Trading", 1, ">$5B"),
]

gpu_compatible = sum(1 for s in scenarios if s.max_latency_ms >= 100)
wse_compatible = sum(1 for s in scenarios if s.max_latency_ms >= 1)
wse_exclusive = sum(1 for s in scenarios if s.max_latency_ms < 100)

print(f"GPU compatible: {gpu_compatible}/{len(scenarios)}")
print(f"WSE compatible: {wse_compatible}/{len(scenarios)}")
print(f"WSE exclusive: {wse_exclusive}/{len(scenarios)}")