"""
taalas_mask_rom_sim.py
Simulates Taalas Mask-ROM recall fabric weight storage and inference
Demonstrates 4-bit weight, single-transistor multiplication core logic
"""

import numpy as np
from typing import List, Tuple
import time

class MaskROMSimulator:
    """
    Simulates Taalas Mask-ROM recall fabric.
    Core idea: Pre-compute all possible input×weight products,
    then route the correct result via selection logic.
    """
    
    def __init__(self, num_weights: int, bit_width: int = 4):
        """
        Initialize Mask-ROM simulator
        
        Args:
            num_weights: Number of weight parameters
            bit_width: Quantization bit width (Taalas HC1 uses 3/6-bit hybrid)
        """
        self.num_weights = num_weights
        self.bit_width = bit_width
        self.num_quant_levels = 2 ** bit_width  # 4-bit => 16 levels
        
        # Mask-ROM storage: weights permanently etched into silicon
        self.weights = np.random.randint(0, self.num_quant_levels, 
                                         size=num_weights, dtype=np.uint8)
        
        # Dequantization table: maps quantized index back to float
        self.dequant_table = self._build_dequant_table()
        
        # Statistics
        self.read_count = 0
        self.total_latency = 0.0
    
    def _build_dequant_table(self) -> np.ndarray:
        """Build symmetric 4-bit dequantization lookup table"""
        max_val = 1.0
        step = 2 * max_val / (self.num_quant_levels - 1)
        return np.linspace(-max_val, max_val, self.num_quant_levels)
    
    def precompute_all_products(self, input_val: float) -> np.ndarray:
        """
        Simulate Taalas shared multiplier bank:
        pre-compute input × all 16 possible values
        
        Args:
            input_val: Input activation value
            
        Returns:
            16 candidate product results
        """
        products = np.zeros(self.num_quant_levels, dtype=np.float32)
        for i in range(self.num_quant_levels):
            weight_val = self.dequant_table[i]
            products[i] = input_val * weight_val
        return products
    
    def masked_multiply(self, input_val: float, weight_idx: int) -> float:
        """
        Simulate single-transistor multiply: route-select from pre-computed products
        
        In Taalas's real implementation, each weight cell uses only one transistor
        to perform the "select correct pre-computed product" operation.
        
        Args:
            input_val: Input activation value
            weight_idx: Quantized weight index
            
        Returns:
            Product result
        """
        candidates = self.precompute_all_products(input_val)
        result = candidates[weight_idx]
        
        self.read_count += 1
        return result
    
    def matrix_vector_multiply(self, matrix_indices: np.ndarray, 
                                input_vector: np.ndarray) -> np.ndarray:
        """
        Matrix-vector multiply: Mask-ROM version of GEMV
        
        Args:
            matrix_indices: Quantized weight matrix indices, shape (M, N)
            input_vector: Input vector, shape (N,)
            
        Returns:
            Output vector, shape (M,)
        """
        M, N = matrix_indices.shape
        output = np.zeros(M, dtype=np.float32)
        
        for i in range(M):
            acc = 0.0
            for j in range(N):
                acc += self.masked_multiply(input_vector[j], matrix_indices[i, j])
            output[i] = acc
        
        return output


class SRAMRecallFabric:
    """
    Simulates Taalas SRAM recall fabric for KV Cache and LoRA adapters
    """
    
    def __init__(self, max_context_length: int, hidden_dim: int, 
                 num_layers: int, num_heads: int):
        self.max_context_length = max_context_length
        self.hidden_dim = hidden_dim
        self.num_layers = num_layers
        self.num_heads = num_heads
        self.head_dim = hidden_dim // num_heads
        
        # KV Cache storage (dynamically allocated in SRAM)
        self.k_cache = {}
        self.v_cache = {}
        self.current_length = 0
        
        # LoRA adapter storage
        self.lora_weights = {}
        self.lora_enabled = False
        
        self.cache_hits = 0
        self.cache_misses = 0
    
    def init_kv_cache(self, batch_size: int = 1):
        """Initialize KV Cache space"""
        for layer in range(self.num_layers):
            self.k_cache[layer] = np.zeros(
                (batch_size, self.num_heads, self.max_context_length, self.head_dim),
                dtype=np.float16
            )
            self.v_cache[layer] = np.zeros(
                (batch_size, self.num_heads, self.max_context_length, self.head_dim),
                dtype=np.float16
            )
    
    def append_kv(self, layer: int, key: np.ndarray, value: np.ndarray):
        """Append new token's Key and Value to KV Cache"""
        pos = self.current_length
        self.k_cache[layer][:, :, pos:pos+1, :] = key
        self.v_cache[layer][:, :, pos:pos+1, :] = value
        self.current_length += 1
    
    def get_kv(self, layer: int) -> Tuple[np.ndarray, np.ndarray]:
        """Get cached Key and Value for current layer"""
        if self.current_length > 0:
            self.cache_hits += 1
            return (self.k_cache[layer][:, :, :self.current_length, :],
                    self.v_cache[layer][:, :, :self.current_length, :])
        self.cache_misses += 1
        return None, None


def simulate_taalas_inference():
    """Simulate a complete Taalas HC1 inference pipeline"""
    print("=" * 70)
    print(" Taalas HC1 Inference Simulator")
    print("=" * 70)
    
    # Configuration (simplified Llama 3.1 8B)
    HIDDEN_DIM = 256      # Simplified: real value is 4096
    NUM_LAYERS = 4         # Simplified: real value is 32
    NUM_HEADS = 8
    HEAD_DIM = HIDDEN_DIM // NUM_HEADS
    SEQ_LEN = 128
    
    print(f"\n[Config] Hidden={HIDDEN_DIM}, Layers={NUM_LAYERS}, "
          f"Heads={NUM_HEADS}, SeqLen={SEQ_LEN}")
    
    # Phase 1: Initialize Mask-ROM
    print("\n[Phase 1] Initializing Mask-ROM weight storage...")
    rom = MaskROMSimulator(
        num_weights=HIDDEN_DIM * HIDDEN_DIM * NUM_LAYERS * 4,
        bit_width=4
    )
    stats = {
        "num_weights": rom.num_weights,
        "storage_mb": rom.num_weights * 4 / 8 / 1024 / 1024,
    }
    print(f"  - Weights: {stats['num_weights']:,}")
    print(f"  - Storage: {stats['storage_mb']:.2f} MB")
    
    # Phase 2: Initialize SRAM KV Cache
    print("\n[Phase 2] Initializing SRAM KV Cache...")
    sram = SRAMRecallFabric(
        max_context_length=4096,
        hidden_dim=HIDDEN_DIM,
        num_layers=NUM_LAYERS,
        num_heads=NUM_HEADS
    )
    sram.init_kv_cache(batch_size=1)
    kv_mb = sram.hidden_dim * sram.num_layers * 2 * 4096 * 2 / 1024 / 1024
    print(f"  - KV Cache capacity: {kv_mb:.1f} MB")
    
    # Phase 3: Prefill phase
    print("\n[Phase 3] Simulating autoregressive token generation...")
    print(f"  {'Token':>8s} | {'Latency(us)':>10s} | {'KV Cache Len':>12s} | {'Throughput':>12s}")
    print("-" * 50)
    
    start_time = time.time()
    for pos in range(SEQ_LEN):
        for layer in range(NUM_LAYERS):
            q_proj = rom.matrix_vector_multiply(
                np.random.randint(0, 16, (HIDDEN_DIM, HIDDEN_DIM)),
                np.random.randn(HIDDEN_DIM).astype(np.float32)
            )
            fake_key = np.random.randn(1, NUM_HEADS, 1, HEAD_DIM).astype(np.float16)
            fake_value = np.random.randn(1, NUM_HEADS, 1, HEAD_DIM).astype(np.float16)
            sram.append_kv(layer, fake_key, fake_value)
        
        if pos % 16 == 0 or pos == SEQ_LEN - 1:
            elapsed = (time.time() - start_time) * 1e6 / (pos + 1)
            throughput = (pos + 1) / (time.time() - start_time + 1e-10)
            print(f"  {pos+1:>8d} | {elapsed:>10.1f} | {sram.current_length:>12d} | {throughput:>12.1f}")
    
    # Phase 4: Decode phase
    print("\n[Phase 4] Decode phase (token-by-token generation)...")
    DECODE_TOKENS = 64
    start_time = time.time()
    
    for pos in range(DECODE_TOKENS):
        for layer in range(NUM_LAYERS):
            k, v = sram.get_kv(layer)
            q = rom.matrix_vector_multiply(
                np.random.randint(0, 16, (HIDDEN_DIM, HIDDEN_DIM)),
                np.random.randn(HIDDEN_DIM).astype(np.float32)
            )
            fake_key = np.random.randn(1, NUM_HEADS, 1, HEAD_DIM).astype(np.float16)
            fake_value = np.random.randn(1, NUM_HEADS, 1, HEAD_DIM).astype(np.float16)
            sram.append_kv(layer, fake_key, fake_value)
        
        if pos % 16 == 0 or pos == DECODE_TOKENS - 1:
            elapsed = (time.time() - start_time) * 1e6 / (pos + 1)
            throughput = (pos + 1) / (time.time() - start_time + 1e-10)
            print(f"  {pos+1:>8d} | {elapsed:>10.1f} | {sram.current_length:>12d} | {throughput:>12.1f}")
    
    print(f"\n[Result] Inference complete")
    print(f"  - Mask-ROM total reads: {rom.read_count:,}")


if __name__ == "__main__":
    simulate_taalas_inference()

// pipeline_scheduler.go
// Taalas HC2 multi-chip pipeline parallel scheduler simulation

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

// TaalasChip represents a single Taalas HC2 chip
type TaalasChip struct {
	ID          int
	ParamsStart int
	ParamsEnd   int
	ParamCount  int
	ProcessTime float64 // processing time per forward pass (microseconds)
	TotalTokens int64
	TotalLatency time.Duration
}

// PipelineStage represents a pipeline stage
type PipelineStage struct {
	Chip       *TaalasChip
	InputChan  chan *InferenceRequest
	OutputChan chan *InferenceRequest
}

// InferenceRequest represents a single inference request
type InferenceRequest struct {
	ID           int64
	PromptTokens int
	GenTokens    int
	StartTime    time.Time
	StageStart   []time.Time
	StageEnd     []time.Time
	CurrentStage int
}

// PipelineScheduler manages pipeline-parallel scheduling
type PipelineScheduler struct {
	Stages      []*PipelineStage
	NumChips    int
	TotalParams int64
	BatchSize   int
	Stats       SchedulerStats
}

// SchedulerStats tracks scheduling statistics
type SchedulerStats struct {
	TotalRequests     int64
	CompletedRequests int64
	TotalLatency      time.Duration
	mu                sync.Mutex
}

// NewPipelineScheduler creates a new pipeline scheduler
func NewPipelineScheduler(numChips int, totalParams int64, batchSize int) *PipelineScheduler {
	paramsPerChip := totalParams / int64(numChips)
	ps := &PipelineScheduler{
		Stages:      make([]*PipelineStage, numChips),
		NumChips:    numChips,
		TotalParams: totalParams,
		BatchSize:   batchSize,
	}

	for i := 0; i < numChips; i++ {
		chip := &TaalasChip{
			ID:          i,
			ParamsStart: int(paramsPerChip * int64(i)),
			ParamsEnd:   int(paramsPerChip * int64(i+1)),
			ParamCount:  int(paramsPerChip),
			ProcessTime: 5.0 + rand.Float64()*3.0,
		}

		ps.Stages[i] = &PipelineStage{
			Chip:      chip,
			InputChan: make(chan *InferenceRequest, 100),
    	}
    }

    return ps
}

// ProcessStage handles a single pipeline stage
func (ps *PipelineScheduler) ProcessStage(stageIdx int, wg *sync.WaitGroup) {
	defer wg.Done()
	stage := ps.Stages[stageIdx]
	chip := stage.Chip

	for req := range stage.InputChan {
		processStart := time.Now()

		processTime := chip.ProcessTime * float64(req.GenTokens)
		time.Sleep(time.Duration(processTime) * time.Microsecond)

		req.StageEnd[stageIdx] = time.Now()
		req.CurrentStage = stageIdx + 1

		chip.TotalTokens += int64(req.GenTokens)
		chip.TotalLatency += time.Since(processStart)

		if stageIdx < ps.NumChips-1 {
			ps.Stages[stageIdx+1].InputChan <- req
		} else {
			ps.Stats.mu.Lock()
			ps.Stats.CompletedRequests++
			ps.Stats.TotalLatency += time.Since(req.StartTime)
			ps.Stats.mu.Unlock()
		}
	}
}

// SubmitRequest submits an inference request
func (ps *PipelineScheduler) SubmitRequest(req *InferenceRequest) {
	req.StageStart = make([]time.Time, ps.NumChips)
	req.StageEnd = make([]time.Time, ps.NumChips)
	req.StartTime = time.Now()
	req.StageStart[0] = req.StartTime

	ps.Stats.mu.Lock()
	ps.Stats.TotalRequests++
	ps.Stats.mu.Unlock()

	ps.Stages[0].InputChan <- req
}

// Start launches all pipeline stages
func (ps *PipelineScheduler) Start() *sync.WaitGroup {
	var wg sync.WaitGroup
	for i := 0; i < ps.NumChips; i++ {
		wg.Add(1)
		go ps.ProcessStage(i, &wg)
	}
	return &wg
}

// PrintReport prints a performance report
func (ps *PipelineScheduler) PrintReport() {
	fmt.Println("\n========================================")
	fmt.Println(" Taalas HC2 Pipeline Parallel Report")
	fmt.Println("========================================")
	fmt.Printf(" Chips: %d\n", ps.NumChips)
	fmt.Printf(" Total Params: %d (%.1fT)\n", ps.TotalParams, float64(ps.TotalParams)/1e12)
	fmt.Printf(" Params/Chip: %d (%.1fB)\n", 
		ps.TotalParams/int64(ps.NumChips),
		float64(ps.TotalParams/int64(ps.NumChips))/1e9)
	fmt.Println("----------------------------------------")
	
	for i, stage := range ps.Stages {
		chip := stage.Chip
		avgLat := float64(chip.TotalLatency.Microseconds())
		if chip.TotalTokens > 0 {
			avgLat /= float64(chip.TotalTokens)
		}
		fmt.Printf(" HC2#%02d: Params[%d~%d), Tokens=%5d, Avg=%.1f us/tok\n",
			i, chip.ParamsStart, chip.ParamsEnd, chip.TotalTokens, avgLat)
	}

	ps.Stats.mu.Lock()
	defer ps.Stats.mu.Unlock()
	
	totalTokens := int64(0)
	for _, stage := range ps.Stages {
		totalTokens += stage.Chip.TotalTokens
	}
	fmt.Println("----------------------------------------")
	fmt.Printf(" Total Requests: %d\n", ps.Stats.TotalRequests)
	fmt.Printf(" Completed: %d\n", ps.Stats.CompletedRequests)
	fmt.Printf(" Total Tokens: %d\n", totalTokens)
	fmt.Printf(" Effective Throughput: %.0f tok/s\n",
		float64(totalTokens)/(float64(ps.Stats.TotalLatency.Seconds())+1))
	fmt.Println("========================================")
}

func main() {
	rand.Seed(time.Now().UnixNano())

	// Configuration: 50 HC2 chips for a trillion-parameter model
	numChips := 50
	totalParams := int64(1_000_000_000_000) // 1 trillion parameters

	fmt.Println("=" * 55)
	fmt.Println(" Taalas HC2 Trillion-Parameter Inference")
	fmt.Println("=" * 55)
	fmt.Printf(" Config: %d HC2 chips, 20B params each, %.1fT total\n",
		numChips, float64(totalParams)/1e12)

	scheduler := NewPipelineScheduler(numChips, totalParams, 1)
	wg := scheduler.Start()

	numRequests := 100
	fmt.Printf("\n Submitting %d inference requests...\n", numRequests)
	for i := 0; i < numRequests; i++ {
		req := &InferenceRequest{
			ID:           int64(i),
			PromptTokens: 1024,
			GenTokens:    rand.Intn(256) + 64,
		}
		scheduler.SubmitRequest(req)
		time.Sleep(time.Duration(rand.Intn(50)) * time.Microsecond)
	}

	time.Sleep(5 * time.Second)

	for _, stage := range scheduler.Stages {
		close(stage.InputChan)
	}
	wg.Wait()

	scheduler.PrintReport()
}

"""
taalas_quantization.py
Simulating Taalas HC1 custom 3-bit/6-bit mixed precision quantization
"""

import numpy as np
from dataclasses import dataclass
from typing import Dict, Tuple

@dataclass
class QuantConfig:
    """Quantization configuration"""
    name: str
    bit_width: int
    symmetric: bool = True
    block_size: int = 128

class MixedPrecisionQuantizer:
    """
    Taalas custom mixed-precision quantizer
    Simulates 3-bit/6-bit mixed precision quantization strategy
    """
    
    def __init__(self, configs: Dict[str, QuantConfig]):
        self.configs = configs
        self.quantized_weights = {}
        self.scales = {}
        self.quantized_stats = {}
    
    def _block_quantize(self, weights: np.ndarray, 
                        config: QuantConfig) -> Tuple[np.ndarray, np.ndarray]:
        """Block-wise quantization for better precision"""
        orig_shape = weights.shape
        flat_weights = weights.flatten()
        
        num_blocks = (len(flat_weights) + config.block_size - 1) // config.block_size
        padded_len = num_blocks * config.block_size
        padded = np.zeros(padded_len)
        padded[:len(flat_weights)] = flat_weights
        
        blocked = padded.reshape(num_blocks, config.block_size)
        n_levels = 2 ** (config.bit_width - 1)
        max_vals = np.max(np.abs(blocked), axis=1)
        max_vals = np.maximum(max_vals, 1e-10)
        
        scales = max_vals / n_levels
        quantized = np.clip(
            np.round(blocked / scales[:, np.newaxis]), 
            -n_levels, n_levels - 1
        ).astype(np.int8)
        
        quantized_flat = quantized.flatten()[:len(flat_weights)]
        return quantized_flat.reshape(orig_shape), scales
    
    def quantize_layer(self, layer_name: str, weights: np.ndarray, 
                       layer_type: str) -> Dict:
        """Quantize a single layer"""
        config = self.configs.get(layer_type)
        if config is None:
            raise ValueError(f"Unknown layer type: {layer_type}")
        
        quantized, scales = self._block_quantize(weights, config)
        self.quantized_weights[layer_name] = quantized
        self.scales[layer_name] = scales
        
        # Dequantize to evaluate error
        dequantized = self._dequantize(layer_name, weights.shape)
        mse = np.mean((weights - dequantized) ** 2)
        snr = 10 * np.log10(np.var(weights) / (mse + 1e-10))
        
        self.quantized_stats[layer_name] = {
            'bit_width': config.bit_width,
            'mse': mse,
            'snr_db': snr,
            'compression_ratio': 32 / config.bit_width,
            'storage_bits': weights.size * config.bit_width,
        }
        return self.quantized_stats[layer_name]
    
    def _dequantize(self, layer_name: str, shape: tuple) -> np.ndarray:
        """Dequantize back to float"""
        quantized = self.quantized_weights[layer_name].flatten()
        scales = self.scales[layer_name]
        
        num_blocks = len(scales)
        padded_len = num_blocks * 128
        padded = np.zeros(padded_len)
        padded[:len(quantized)] = quantized
        
        blocked = padded.reshape(num_blocks, 128)
        dequantized = (blocked * scales[:, np.newaxis]).flatten()[:len(quantized)]
        return dequantized.reshape(shape)
    
    def simulate_taalas_hc1(self):
        """Simulate full model quantization for Taalas HC1"""
        print("=" * 70)
        print(" Taalas HC1 Mixed-Precision Quantization Simulation")
        print("=" * 70)
        
        np.random.seed(42)
        hidden_dim = 4096
        num_layers = 32
        ffn_dim = 14336
        
        self.configs = {
            'attention': QuantConfig('attention', 6),
            'ffn': QuantConfig('ffn', 3),
            'embedding': QuantConfig('embedding', 6),
        }
        
        total_original_bits = 0
        total_quantized_bits = 0
        
        for layer_idx in range(num_layers):
            for proj in ['Q', 'K', 'V', 'O']:
                w = np.random.randn(hidden_dim, hidden_dim) * 0.02
                stats = self.quantize_layer(f"L{layer_idx}.attn.{proj}", w, 'attention')
                total_original_bits += w.size * 32
                total_quantized_bits += stats['storage_bits']
            
            for proj in ['gate', 'up', 'down']:
                w = np.random.randn(hidden_dim, ffn_dim) * 0.02
                stats = self.quantize_layer(f"L{layer_idx}.ffn.{proj}", w, 'ffn')
                total_original_bits += w.size * 32
                total_quantized_bits += stats['storage_bits']
        
        embed_w = np.random.randn(32000, hidden_dim) * 0.02
        self.quantize_layer('token_embedding', embed_w, 'embedding')
        total_original_bits += embed_w.size * 32
        total_quantized_bits += self.quantized_stats['token_embedding']['storage_bits']
        
        lm_w = np.random.randn(hidden_dim, 32000) * 0.02
        self.quantize_layer('lm_head', lm_w, 'embedding')
        total_original_bits += lm_w.size * 32
        total_quantized_bits += self.quantized_stats['lm_head']['storage_bits']
        
        avg_bit_width = total_quantized_bits / (total_original_bits / 32)
        compression_ratio = total_original_bits / total_quantized_bits
        
        print(f"\n[Model] Llama 3.1 8B (simplified)")
        print(f"  - Hidden dim: {hidden_dim}")
        print(f"  - Transformer layers: {num_layers}")
        print(f"  - FFN dim: {ffn_dim}")
        print(f"  - Vocabulary: 32000")
        
        print(f"\n[Quantization Config]")
        for name, config in self.configs.items():
            print(f"  - {name}: {config.bit_width}-bit, block={config.block_size}")
        
        print(f"\n[Storage]")
        print(f"  - FP32 original: {total_original_bits/8/1024/1024/1024:.2f} GB")
        print(f"  - Quantized: {total_quantized_bits/8/1024/1024/1024:.2f} GB")
        print(f"  - Compression: {compression_ratio:.1f}x")
        print(f"  - Avg bit width: {avg_bit_width:.2f} bit/param")
        
        print(f"\n[HC2 Upgrade] MXFP4 4-bit float format")
        print(f"  - HC1 avg bit width: {avg_bit_width:.2f} bit")
        print(f"  - HC2 target: 4.0 bit (uniform MXFP4)")
        print(f"  - HC2 expected SNR gain: ~3-6 dB")
        
        return {
            'compression_ratio': compression_ratio,
            'avg_bit_width': avg_bit_width,
        }


if __name__ == "__main__":
    quantizer = MixedPrecisionQuantizer({})
    results = quantizer.simulate_taalas_hc1()

"""
taalas_throughput_benchmark.py
Comparing Taalas HC1 vs NVIDIA GPU vs Cerebras inference throughput
"""

import numpy as np
from dataclasses import dataclass
from typing import List, Dict

@dataclass
class InferenceConfig:
    model_name: str
    model_params_b: float
    batch_size: int
    input_length: int
    output_length: int
    precision: str

@dataclass
class HardwareSpec:
    name: str
    peak_tflops: float
    memory_bandwidth_tbps: float
    memory_capacity_gb: float
    tdp_w: float
    price_estimate_usd: float
    is_taalas: bool = False
    mask_rom_tokens_per_sec: float = 0.0
    chip_count: int = 1
    system_power_w: float = 0.0

class InferenceBenchmark:
    def __init__(self):
        self.hardware_list: List[HardwareSpec] = []
        self.results: Dict[str, Dict] = {}
    
    def register_hardware(self, hw: HardwareSpec):
        self.hardware_list.append(hw)
    
    def _estimate_gpu_throughput(self, hw: HardwareSpec, 
                                 config: InferenceConfig) -> float:
        """Estimate GPU inference throughput using Roofline model"""
        bytes_per_param = 2 if config.precision == 'FP16' else 4
        model_size_bytes = config.model_params_b * 1e9 * bytes_per_param
        flops_per_token = 2 * config.model_params_b * 1e9
        
        compute_bound = hw.peak_tflops * 1e12 / flops_per_token
        memory_bound = hw.memory_bandwidth_tbps * 1e12 / model_size_bytes
        
        throughput = min(compute_bound, memory_bound) * config.batch_size * 0.7
        return throughput
    
    def _estimate_taalas_throughput(self, hw: HardwareSpec, 
                                     config: InferenceConfig) -> float:
        """Estimate Taalas inference throughput"""
        base_tokens_per_sec = hw.mask_rom_tokens_per_sec
        scale_factor = max(1.0, config.model_params_b / 8.0)
        chip_scaling = hw.chip_count
        pipeline_efficiency = 0.85 if hw.chip_count > 1 else 1.0
        
        throughput = base_tokens_per_sec / scale_factor * chip_scaling * pipeline_efficiency
        return throughput
    
    def run_benchmark(self, configs: List[InferenceConfig]):
        """Run benchmark for all hardware/config combinations"""
        for config in configs:
            print(f"\n{'='*70}")
            print(f" Model: {config.model_name} ({config.model_params_b}B)")
            print(f" Config: batch={config.batch_size}")
            print(f"{'='*70}")
            
            for hw in self.hardware_list:
                if hw.is_taalas:
                    throughput = self._estimate_taalas_throughput(hw, config)
                else:
                    throughput = self._estimate_gpu_throughput(hw, config)
                
                total_tokens = config.input_length + config.output_length
                latency_ms = (total_tokens / throughput) * 1000
                
                power_w = hw.system_power_w if hw.system_power_w > 0 else hw.tdp_w
                tokens_per_watt = throughput / power_w
                
                result = {
                    'throughput_tok_s': throughput,
                    'latency_ms': latency_ms,
                    'tokens_per_watt': tokens_per_watt,
                }
                self.results[f"{hw.name}_{config.model_name}"] = result
                
                print(f"\n [{hw.name}]")
                print(f"  Throughput: {throughput:>10,.0f} tok/s")
                print(f"  Latency:   {latency_ms:>10.1f} ms")
                print(f"  Efficiency: {tokens_per_watt:>10,.0f} tok/W")
    
    def print_summary(self):
        """Print summary comparison table"""
        print("\n" + "=" * 100)
        print(" Inference Throughput Comparison Summary")
        print("=" * 100)
        print(f"{'Hardware':>20s} | {'Model':>15s} | {'Throughput':>12s} | "
              f"{'Latency':>10s} | {'Efficiency':>12s}")
        print("-" * 100)
        
        for key, result in sorted(self.results.items()):
            hw_name, model_name = key.split('_', 1)
            print(f"{hw_name:>20s} | {model_name:>15s} | "
                  f"{result['throughput_tok_s']:>12,.0f} | "
                  f"{result['latency_ms']:>10.1f} | "
                  f"{result['tokens_per_watt']:>12,.0f}")
        
        print("=" * 100)


def main():
    benchmark = InferenceBenchmark()
    
    # Register hardware platforms
    benchmark.register_hardware(HardwareSpec(
        "NVIDIA B200", 4500, 8.0, 192, 700, 35000, system_power_w=1000))
    benchmark.register_hardware(HardwareSpec(
        "NVIDIA H200", 1000, 4.8, 141, 700, 30000, system_power_w=900))
    benchmark.register_hardware(HardwareSpec(
        "Cerebras WSE-3", 125000, 20.0, 44000, 15000, 2000000, system_power_w=18000))
    benchmark.register_hardware(HardwareSpec(
        "Taalas HC1", 0, 0, 0, 200, 15000, 
        is_taalas=True, mask_rom_tokens_per_sec=17000, chip_count=1, system_power_w=250))
    benchmark.register_hardware(HardwareSpec(
        "Taalas HC2×50", 0, 0, 0, 200, 750000,
        is_taalas=True, mask_rom_tokens_per_sec=17000, chip_count=50, system_power_w=12500))
    
    configs = [
        InferenceConfig("Llama 3.1 8B", 8, 1, 1024, 128, "FP16"),
        InferenceConfig("Llama 3.1 70B", 70, 1, 1024, 128, "FP16"),
        InferenceConfig("DeepSeek-R1", 671, 1, 1024, 128, "FP8"),
    ]
    
    benchmark.run_benchmark(configs)
    benchmark.print_summary()


if __name__ == "__main__":
    main()