DSP技术架构深度拆解

DSP技术架构深度拆解

概述

DSP（Demand-Side Platform，需求方平台）是程序化广告生态中的核心技术系统，负责代表广告主在实时竞价（RTB）环境中对广告展示机会进行出价决策。典型的DSP需要在100ms内处理海量Bid Request，做出精准的竞价决策并返回Bid Response。本章将从架构层面深度拆解高性能DSP系统的核心技术实现。

典型DSP架构全景图

graph TB subgraph "流量接入层 Traffic Ingestion Layer" LB[负载均衡器
L4/L7 Load Balancer] GW[API网关
Kong/AWS API Gateway] ADP[适配器集群
Adapters for SSP/Exchange] end subgraph "消息队列层 Message Queue Layer" KAFKA[Kafka集群
Bid Request Buffer] end subgraph "实时竞价决策层 Real-time Bidding Layer" BD[Bid Decision Workers
水平扩展集群] subgraph "Filter Engine" BF[Budget Filter] PF[Pacing Filter] TF[Targeting Filter] FF[Frequency Cap Filter] end subgraph "Bidding Logic" VAL[竞价价值评估
Value Estimation] PRED[CTR/CVR预测
ML Prediction] OPT[出价优化
Bid Optimization] end end subgraph "数据服务层 Data Service Layer" REDIS[(Redis Cluster
热数据缓存)] ROCKS[(RocksDB/LevelDB
本地嵌入存储)] HBASE[(HBase
用户画像存储)] end subgraph "模型服务层 ML Model Serving" TFS[TensorFlow Serving
/Triton] FM[Feature Store
Feast/Tecton] end subgraph "离线计算层 Offline Processing" SPARK[Spark/Flink
日志处理] HIVE[(Hive/ClickHouse
数据分析)] end subgraph "控制面 Control Plane" CAMPAIGN[Campaign管理
预算/定向设置] MONITOR[监控系统
Prometheus/Grafana] end SSP[SSP/Ad Exchange] -->|HTTPS POST
Bid Request| LB LB --> GW GW --> ADP ADP -->|解析标准化| KAFKA KAFKA -->|消费| BD BD --> BF --> PF --> TF --> FF FF --> VAL --> PRED --> OPT BD -->|查询| REDIS BD -->|本地读取| ROCKS BD -->|特征获取| FM PRED -->|调用|TFS BD -->|返回| ADP ADP -->|HTTPS POST
Bid Response| SSP CAMPAIGN -->|配置同步| REDIS SPARK -->|聚合写入| REDIS SPARK -->|用户画像| HBASE MONITOR -.->|指标采集| BD

海量Bid Request处理：百万级QPS的架构设计

1. 流量接入与协议适配

DSP需要对接多个SSP/Ad Exchange，每个平台的协议格式可能不同（OpenRTB 2.x、自定义Protobuf、JSON等）。

多协议适配器设计：

from abc import ABC, abstractmethod
from typing import Dict, Any, Optional
import asyncio

class BidRequestAdapter(ABC):
    """Bid Request适配器基类"""
    
    @abstractmethod
    async def parse(self, raw_request: bytes) -> Dict[str, Any]:
        """将原始请求解析为标准化格式"""
        pass
    
    @abstractmethod
    async def build_response(self, bid_result: Dict) -> bytes:
        """构建平台特定的Bid Response"""
        pass
    
    @abstractmethod
    def get_timeout_ms(self) -> int:
        """获取平台要求的超时时间（通常80-100ms）"""
        pass

class OpenRTBAdapter(BidRequestAdapter):
    """OpenRTB 2.5标准适配器"""
    
    async def parse(self, raw_request: bytes) -> Dict[str, Any]:
        # 解析OpenRTB JSON请求
        request = json.loads(raw_request)
        return {
            'request_id': request['id'],
            'impression': self._extract_impression(request),
            'user': self._extract_user(request),
            'device': self._extract_device(request),
            'context': self._extract_context(request),
            'bcat': request.get('bcat', []),  # 屏蔽广告类别
            'badv': request.get('badv', []),  # 屏蔽广告主域名
        }
    
    def get_timeout_ms(self) -> int:
        return 100  # OpenRTB标准100ms

异步IO高并发接入：

import asyncio
from aiohttp import web
import uvloop

# 使用uvloop替代默认事件循环
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())

class BidRequestHandler:
    def __init__(self, kafka_producer, adapter_registry):
        self.producer = kafka_producer
        self.adapters = adapter_registry
        self.timeout_ms = 100
    
    async def handle_bid_request(self, request: web.Request) -> web.Response:
        """处理单个Bid Request"""
        start_time = time.monotonic()
        
        # 1. 识别流量来源平台
        exchange = request.headers.get('X-Ad-Exchange')
        adapter = self.adapters.get(exchange)
        
        # 2. 读取并解析请求体
        body = await request.read()
        parsed_req = await adapter.parse(body)
        
        # 3. 生成唯一追踪ID
        trace_id = f"{exchange}-{uuid.uuid4().hex[:16]}"
        parsed_req['trace_id'] = trace_id
        parsed_req['received_at'] = start_time
        
        # 4. 写入Kafka缓冲（异步非阻塞）
        await self.producer.send(
            topic='bid-requests',
            key=parsed_req['request_id'],
            value=parsed_req
        )
        
        # 5. 等待竞价结果（使用Future机制）
        try:
            bid_response = await asyncio.wait_for(
                self.wait_for_decision(trace_id),
                timeout=self.timeout_ms / 1000
            )
            raw_response = await adapter.build_response(bid_response)
            return web.Response(body=raw_response, status=200)
        except asyncio.TimeoutError:
            # 超时返回空响应（No-Bid）
            return web.Response(status=204)

2. 流量削峰：Kafka作为缓冲层

sequenceDiagram participant SSP as SSP/Exchange participant LB as Load Balancer participant GW as API Gateway participant KP as Kafka Producer partition Kafka { KP->>Topic: bid-requests (Partition 0..N) } participant BC as Bid Consumer participant Redis as Redis Cluster participant ML as ML Model participant Cache as Local Cache SSP->>LB: HTTPS Bid Request (100ms timeout) LB->>GW: 转发请求 GW->>GW: 解析&验证请求 GW->>KP: 异步写入Kafka (5ms) KP-->>GW: ACK GW->>SSP: 立即返回或保持连接 Note over Kafka: 流量削峰
处理延迟容忍 BC->>Topic: 批量消费(100-500 req/batch) BC->>Redis: MGET获取Campaign BC->>Cache: 读取用户画像 BC->>ML: 预测CTR/CVR BC->>BC: 竞价决策 BC->>Redis: 更新预算/频次

Kafka分区策略：

class BidRequestPartitioner:
    """确保相同用户/设备的请求进入同一分区，利用本地缓存"""
    
    def partition(self, request: Dict, num_partitions: int) -> int:
        # 优先按User ID分区，没有则按Device ID
        user_key = request.get('user', {}).get('id') or \
                   request.get('device', {}).get('ifa')
        
        if user_key:
            return hash(user_key) % num_partitions
        
        # 回退到请求ID哈希
        return hash(request['request_id']) % num_partitions

3. 水平扩展：无状态Worker设计

竞价决策Worker设计为完全无状态，任何请求可以在任何节点处理：

class BidDecisionWorker:
    """无状态竞价决策Worker"""
    
    def __init__(self, redis_client, model_client, config):
        self.redis = redis_client
        self.model = model_client
        self.config = config
        self.local_cache = LRUCache(maxsize=100000)  # 本地热数据缓存
    
    async def process_bid_request(self, request: Dict) -> Optional[Dict]:
        """处理单个竞价请求"""
        
        # 1. 快速过滤阶段（< 5ms）
        campaigns = await self.filter_engine.apply(request)
        if not campaigns:
            return None  # No-Bid
        
        # 2. 竞价价值评估（5-30ms）
        bid_candidates = []
        for campaign in campaigns:
            bid_price = await self.calculate_bid_price(campaign, request)
            if bid_price > 0:
                bid_candidates.append((campaign, bid_price))
        
        # 3. 选择最高出价
        if bid_candidates:
            winner = max(bid_candidates, key=lambda x: x[1])
            return self.build_bid_response(winner[0], winner[1], request)
        
        return None

<100ms超低延迟响应技术

1. 延迟预算分配

总预算: 100ms
├── 网络传输 (RTT): ~20-30ms
├── 请求解析: ~2-5ms
├── Kafka写入: ~3-5ms
├── 缓存查询: ~2-5ms (Redis 99th < 1ms)
├── Filter Engine: ~5-15ms
├── ML预测: ~10-30ms
├── 出价计算: ~2-5ms
└── 响应构建: ~2-3ms

2. 多级缓存策略

flowchart LR subgraph "L1: 本地内存" L1CACHE[LRU Cache
命中率: 70%
延迟: ~100ns] end subgraph "L2: 本地RocksDB" L2CACHE[Embedded RocksDB
命中率: 20%
延迟: ~1ms] end subgraph "L3: Redis Cluster" L3CACHE[Redis
命中率: 9%
延迟: ~2-5ms] end subgraph "L4: 远程服务" L4SOURCE[HBase/Feature Store
延迟: ~20-50ms] end Query --> L1CACHE -->|Miss| L2CACHE -->|Miss| L3CACHE -->|Miss| L4SOURCE L1CACHE --> Hit1[返回数据] L2CACHE --> Hit2[返回数据
回填L1] L3CACHE --> Hit3[返回数据
回填L1/L2] L4SOURCE --> Miss[返回数据
回填L1/L2/L3]

本地嵌入存储（RocksDB）配置：

import rocksdb

class LocalProfileStore:
    """本地用户画像存储，避免跨网络访问"""
    
    def __init__(self, db_path: str):
        opts = rocksdb.Options()
        opts.create_if_missing = True
        opts.max_open_files = 100000
        opts.write_buffer_size = 67108864  # 64MB
        opts.max_write_buffer_number = 3
        opts.target_file_size_base = 67108864
        
        # 使用布隆过滤器加速不存在key的查询
        opts.table_factory = rocksdb.BlockBasedTableFactory(
            filter_policy=rocksdb.BloomFilterPolicy(10),
            block_cache=rocksdb.LRUCache(512 * 1024 * 1024)  # 512MB
        )
        
        self.db = rocksdb.DB(db_path, opts)
    
    def get_user_profile(self, user_id: str) -> Optional[bytes]:
        return self.db.get(user_id.encode())
    
    def batch_update(self, profiles: Dict[str, bytes]):
        """批量更新（用于离线数据同步）"""
        batch = rocksdb.WriteBatch()
        for user_id, data in profiles.items():
            batch.put(user_id.encode(), data)
        self.db.write(batch)

3. 异步并行化

import asyncio
from typing import List, Dict

class ParallelBidProcessor:
    """并行化处理减少延迟"""
    
    async def evaluate_campaigns_parallel(
        self, 
        campaigns: List[Dict], 
        request: Dict
    ) -> List[Dict]:
        """并行评估多个Campaign"""
        
        async def evaluate_single(campaign: Dict) -> Dict:
            # 并行获取所需数据
            user_profile, model_score, budget_left = await asyncio.gather(
                self.get_user_profile(request['user']['id']),
                self.predict_ctr(campaign, request),
                self.check_budget(campaign['id'])
            )
            
            return {
                'campaign': campaign,
                'user_profile': user_profile,
                'ctr': model_score,
                'budget': budget_left,
                'bid_price': self.calculate_bid(
                    campaign, model_score, budget_left
                )
            }
        
        # 并发执行所有Campaign评估（控制并发度）
        semaphore = asyncio.Semaphore(50)  # 限制并发数
        
        async def bounded_evaluate(campaign):
            async with semaphore:
                return await evaluate_single(campaign)
        
        results = await asyncio.gather(*[
            bounded_evaluate(c) for c in campaigns
        ])
        
        return [r for r in results if r['bid_price'] > 0]

4. 模型推理优化

import tensorflow as tf
from functools import lru_cache

class OptimizedModelServer:
    """优化的模型推理服务"""
    
    def __init__(self, model_path: str):
        # 使用TensorRT或ONNX Runtime加速
        self.interpreter = tf.lite.Interpreter(model_path=model_path)
        self.interpreter.allocate_tensors()
        
        self.input_details = self.interpreter.get_input_details()
        self.output_details = self.interpreter.get_output_details()
        
        # 预分配输入张量
        self.input_shape = self.input_details[0]['shape']
    
    @lru_cache(maxsize=10000)
    def extract_features_cached(self, user_id: str, campaign_id: str):
        """特征提取结果缓存"""
        return self.extract_features(user_id, campaign_id)
    
    def predict_batch(self, features_batch: np.ndarray) -> np.ndarray:
        """批量推理提高吞吐量"""
        self.interpreter.set_tensor(
            self.input_details[0]['index'], 
            features_batch.astype(np.float32)
        )
        self.interpreter.invoke()
        return self.interpreter.get_tensor(self.output_details[0]['index'])

Redis缓存使用深度分析

1. 数据分层存储策略

数据类型	Redis结构	TTL	使用场景
Campaign配置	Hash	300s	预算、出价策略、定向条件
实时预算	String (DECR)	无	剩余预算原子扣减
频次控制	HyperLogLog + Bitmap	86400s	UV统计、频次限制
用户标签	String (Protobuf)	3600s	人群定向匹配
热数据索引	Set/ZSet	60s	候选Campaign快速筛选
竞价结果	Stream	3600s	日志追踪、归因分析

2. 原子操作保证数据一致性

-- budget_deduct.lua
-- 原子扣减Campaign预算并检查
local campaign_id = KEYS[1]
local deduct_amount = tonumber(ARGV[1])
local budget_key = "camp:budget:" .. campaign_id

-- 获取当前预算
local current = redis.call('GET', budget_key)
if not current then
    return {-1, "BUDGET_NOT_FOUND"}
end

current = tonumber(current)
if current < deduct_amount then
    return {0, "INSUFFICIENT_BUDGET"}
end

-- 原子扣减
local new_budget = redis.call('DECRBY', budget_key, deduct_amount)
return {new_budget, "SUCCESS"}

class BudgetManager:
    """基于Redis的预算管理"""
    
    def __init__(self, redis_client):
        self.redis = redis_client
        self.lua_deduct = self.redis.register_script(
            open('budget_deduct.lua').read()
        )
    
    async def deduct_budget(self, campaign_id: str, amount: float) -> bool:
        """原子扣减预算"""
        result = await self.lua_deduct(
            keys=[campaign_id],
            args=[str(amount)]
        )
        return result[1] == "SUCCESS"

3. 高频写入优化

import redis.asyncio as redis

class RedisPipelineManager:
    """管道批量操作减少RTT"""
    
    def __init__(self):
        self.redis = redis.Redis(
            host='redis-cluster',
            port=6379,
            decode_responses=True,
            max_connections=1000
        )
    
    async def batch_update_impressions(self, updates: List[Dict]):
        """批量更新曝光数据"""
        pipe = self.redis.pipeline(transaction=False)
        
        for update in updates:
            # 增加Campaign曝光计数
            pipe.hincrby(
                f"camp:stats:{update['campaign_id']}",
                'impressions',
                update['count']
            )
            
            # 更新频次计数
            pipe.pfadd(
                f"freq:uv:{update['campaign_id']}",
                update['user_id']
            )
            
            # 记录用户曝光时间戳
            pipe.zadd(
                f"freq:user:{update['user_id']}",
                {update['campaign_id']: time.time()}
            )
        
        await pipe.execute()

Filter引擎原理与设计

1. 多级漏斗过滤架构

flowchart TD Request[Bid Request] --> F1[Level 1: 基础过滤] F1 -->|快速排除90%| E1[排除: 地区/时间/IP] F1 --> F2[Level 2: 预算过滤] F2 -->|排除剩余5%| E2[排除: 预算耗尽] F2 --> F3[Level 3: 频次控制] F3 -->|排除剩余3%| E3[排除: 频次超限] F3 --> F4[Level 4: 定向匹配] F4 -->|排除剩余1.5%| E4[排除: 定向不符] F4 --> F5[Level 5: Pacing控制] F5 -->|排除剩余0.4%| E5[排除: 投放 pacing] F5 --> Remain[剩余0.1% 进入竞价] style E1 fill:#ff9999 style E2 fill:#ff9999 style E3 fill:#ff9999 style E4 fill:#ff9999 style E5 fill:#ff9999 style Remain fill:#99ff99

2. 倒排索引加速定向匹配

from typing import Set, Dict, List
import mmh3  # MurmurHash

class CampaignIndex:
    """Campaign倒排索引"""
    
    def __init__(self):
        # 各维度的倒排索引
        self.geo_index: Dict[str, Set[str]] = {}      # 地域 -> Campaign IDs
        self.os_index: Dict[str, Set[str]] = {}       # OS -> Campaign IDs
        self.slot_index: Dict[str, Set[str]] = {}     # 广告位 -> Campaign IDs
        self.category_index: Dict[str, Set[str]] = {} # 媒体分类 -> Campaign IDs
        
        # 布隆过滤器快速排除
        self.bloom_filters: Dict[str, object] = {}
    
    def add_campaign(self, campaign: Dict):
        """添加Campaign到索引"""
        cid = campaign['id']
        
        # 地域索引
        for geo in campaign.get('targeting', {}).get('geo', []):
            self.geo_index.setdefault(geo, set()).add(cid)
        
        # OS索引
        for os in campaign.get('targeting', {}).get('os', []):
            self.os_index.setdefault(os, set()).add(cid)
    
    def query(self, request: Dict) -> Set[str]:
        """根据请求查询匹配的Campaign"""
        # 快速交集计算
        geo_match = self.geo_index.get(request['device']['geo']['country'], set())
        os_match = self.os_index.get(request['device']['os'], set())
        
        # 交集运算
        candidates = geo_match & os_match
        
        # 进一步过滤...
        return candidates

3. 预算与Pacing过滤器

import time
from dataclasses import dataclass

@dataclass
class PacingState:
    """Pacing状态"""
    campaign_id: str
    daily_budget: float
    spent_today: float
    start_hour: int
    end_hour: int
    target_spend_rate: float  # 目标每小时消耗
    
class PacingFilter:
    """预算平滑投放过滤器"""
    
    def __init__(self, redis_client):
        self.redis = redis_client
    
    def should_bid(self, campaign_id: str, current_time: float) -> bool:
        """根据pacing策略判断是否出价"""
        
        # 获取Campaign pacing状态
        state_key = f"pacing:state:{campaign_id}"
        state_data = self.redis.hgetall(state_key)
        
        if not state_data:
            return True
        
        state = PacingState(**state_data)
        hour = time.localtime(current_time).tm_hour
        
        # 检查投放时段
        if hour < state.start_hour or hour >= state.end_hour:
            return False
        
        # 检查预算消耗进度
        progress = state.spent_today / state.daily_budget
        time_progress = (hour - state.start_hour) / (state.end_hour - state.start_hour)
        
        # 如果消耗过快，降低出价概率
        if progress > time_progress * 1.2:  # 20%缓冲
            return random.random() < 0.3  # 30%概率继续出价
        
        return True

Bidding Logic分层设计

1. 四层竞价逻辑架构

graph TB subgraph "Layer 1: Value Estimation 价值评估" V1[Base Value
基础价值] V2[User Value
用户价值] V3[Context Value
上下文价值] end subgraph "Layer 2: Prediction 预测层" P1[CTR Model
点击率预测] P2[CVR Model
转化率预测] P3[Viewability
可见率预测] end subgraph "Layer 3: Optimization 优化层" O1[Bid Shading
出价调整] O2[Win Rate Opt
胜率优化] O3[ROAS Target
ROAS目标] end subgraph "Layer 4: Constraint 约束层" C1[Budget Constraint
预算约束] C2[Pacing Constraint
pacing约束] C3[Min/Max Bid
出价边界] end V1 --> P1 V2 --> P1 V3 --> P2 P1 --> O1 P2 --> O2 P3 --> O3 O1 --> C1 O2 --> C2 O3 --> C3 C1 --> Final[最终出价] C2 --> Final C3 --> Final

2. 出价计算公式

from typing import Dict
import numpy as np

class BidCalculator:
    """竞价计算器"""
    
    def __init__(self, config: Dict):
        self.min_bid = config.get('min_bid', 0.01)
        self.max_bid = config.get('max_bid', 100.0)
        self.target_cpa = config.get('target_cpa', 10.0)
    
    def calculate_bid(
        self,
        campaign: Dict,
        request: Dict,
        prediction: Dict
    ) -> float:
        """计算竞价出价"""
        
        # Layer 1: 基础价值评估
        base_value = campaign.get('avg_cpm', 1.0)
        
        # Layer 2: 预测层
        ctr = prediction.get('ctr', 0.001)
        cvr = prediction.get('cvr', 0.01)
        
        # Layer 3: 出价优化
        # 基于目标CPA计算
        if campaign['goal'] == 'CONVERSION':
            bid = self.target_cpa * cvr * 1000  # 转CPM
        elif campaign['goal'] == 'CLICK':
            bid = campaign['target_cpc'] * ctr * 1000
        else:
            bid = base_value * (ctr / campaign.get('avg_ctr', 0.001))
        
        # 应用上下文调整系数
        bid *= self.get_context_factor(request)
        bid *= self.get_user_quality_factor(request['user'])
        
        # Layer 4: 约束层
        bid = self.apply_constraints(bid, campaign)
        
        return round(bid, 4)
    
    def apply_constraints(self, bid: float, campaign: Dict) -> float:
        """应用约束条件"""
        
        # 预算约束：预算紧张时降低出价
        budget_factor = self.get_budget_factor(campaign['id'])
        bid *= budget_factor
        
        # Pacing约束
        pacing_factor = self.get_pacing_factor(campaign['id'])
        bid *= pacing_factor
        
        # 边界约束
        bid = max(self.min_bid, min(bid, self.max_bid))
        
        return bid
    
    def get_context_factor(self, request: Dict) -> float:
        """上下文价值系数"""
        factors = {
            'wifi': 1.1,
            '4g': 1.0,
            '3g': 0.9,
        }
        connection = request.get('device', {}).get('connectiontype', 'unknown')
        return factors.get(connection, 1.0)

3. A/B测试框架

from enum import Enum
import hashlib

class BidStrategy(Enum):
    """竞价策略枚举"""
    BASELINE = "baseline"
    AGGRESSIVE = "aggressive"
    CONSERVATIVE = "conservative"
    ML_OPTIMIZED = "ml_optimized"

class BidStrategyManager:
    """竞价策略管理器"""
    
    def __init__(self):
        self.strategies = {
            BidStrategy.BASELINE: BaselineBidStrategy(),
            BidStrategy.AGGRESSIVE: AggressiveBidStrategy(),
            BidStrategy.ML_OPTIMIZED: MLOptimizedStrategy(),
        }
        self.experiments = {}  # 实验配置
    
    def get_strategy_for_request(
        self, 
        campaign: Dict, 
        request: Dict
    ) -> BidStrategy:
        """根据实验配置选择策略"""
        
        exp_config = self.experiments.get(campaign['id'])
        if not exp_config:
            return BidStrategy.BASELINE
        
        # 基于用户ID进行流量分桶
        user_id = request['user']['id']
        bucket = int(hashlib.md5(user_id.encode()).hexdigest(), 16) % 100
        
        # 根据分桶选择策略
        if bucket < exp_config['traffic_split']['control']:
            return BidStrategy.BASELINE
        elif bucket < exp_config['traffic_split']['treatment']:
            return BidStrategy(exp_config['treatment_strategy'])
        
        return BidStrategy.BASELINE

监控与运维

关键指标监控

from prometheus_client import Counter, Histogram, Gauge

# 定义监控指标
bid_requests_total = Counter('dsp_bid_requests_total', 'Total bid requests', ['exchange'])
bid_response_latency = Histogram('dsp_bid_latency_seconds', 'Bid response latency')
bid_rate = Gauge('dsp_bid_rate', 'Current bid rate', ['campaign_id'])
win_rate = Gauge('dsp_win_rate', 'Win rate by campaign', ['campaign_id'])

class BidMetrics:
    """竞价指标收集"""
    
    @staticmethod
    def record_bid_request(exchange: str):
        bid_requests_total.labels(exchange=exchange).inc()
    
    @staticmethod
    def record_latency(start_time: float):
        bid_response_latency.observe(time.time() - start_time)

总结

高性能DSP架构的核心设计原则：

1. 分层解耦：流量接入、消息缓冲、决策计算、数据存储分层，每层可独立扩展
2. 多级缓存：本地内存 + 嵌入存储 + 分布式缓存，最大化命中热数据
3. 异步并行：IO操作全部异步化，计算密集型任务并行执行
4. 预计算与索引：倒排索引、布隆过滤器加速匹配，预加载热数据到本地
5. 流式处理：Kafka缓冲削峰，支持流量突增场景
6. 算法优化：量化模型、批量推理、特征缓存降低ML延迟

这些技术组合使得DSP能够在100ms内完成从请求解析到出价决策的全流程，支撑百万级QPS的高并发场景。