Tháng 3 năm 2026, tôi nhận được một yêu cầu từ quỹ proprietary trading tại Singapore — xây dựng chiến lược arbitrage BTC perpetual futures giữa Binance, OKX và Bybit. Điều kiện tiên quyết: cần 2 năm historical orderbook data với độ phân giải 100ms để backtest chiến lược market-making trên 3 sàn. Tardis machine cung cấp chính xác dữ liệu này, nhưng vấn đề nằm ở chỗ — làm sao để xử lý hàng terabyte data một cách hiệu quả và tích hợp AI assistance vào pipeline?
Bài viết này là complete guide để bạn làm được điều tương tự, sử dụng HolySheep AI làm orchestration layer giữa Tardis API và trading logic.
Mục lục
- Tổng quan kiến trúc
- Cài đặt môi trường
- Lấy dữ liệu từ Tardis
- Tích hợp HolySheep AI
- Xây dựng backtesting engine
- Chiến lược cross-exchange spread
- Tối ưu hóa với HolySheep
- Giá và ROI
- Lỗi thường gặp và cách khắc phục
- Kết luận
Tổng quan kiến trúc
Trong các dự án quantitative research của tôi, kiến trúc tối ưu cho cross-exchange arbitrage bao gồm 4 layers:
- Data Layer: Tardis Machine cung cấp historical orderbook, trades, funding rates từ Binance/OKX/Bybit
- Processing Layer: Python xử lý data cleaning, normalization, spread calculation
- Intelligence Layer: HolySheep AI hỗ trợ code generation, strategy optimization, signal analysis
- Execution Layer: Backtesting engine với realistic fee modeling
Điểm mấu chốt: HolySheep có thể giúp bạn tự động hóa 70% công việc data wrangling — từ việc viết data pipeline cho đến tối ưu hóa strategy parameters. Với chi phí chỉ $0.42/MTok cho DeepSeek V3.2 (so với $8/MTok của GPT-4.1), ROI cho quantitative researcher là rất rõ ràng.
Cài đặt môi trường
Yêu cầu hệ thống
- Python 3.10+
- pandas, numpy, asyncio
- Tardis API subscription
- HolySheep AI API key (lấy tại đăng ký tại đây)
# Cài đặt dependencies
pip install pandas numpy aiohttp python-dotenv
Tạo file .env
cat > .env << 'EOF'
TARDIS_API_KEY=your_tardis_key
HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY
EXCHANGE_LIST=binance,okx,bybit
SYMBOL=BTC-USDT-PERPETUAL
START_DATE=2024-01-01
END_DATE=2024-12-31
EOFLấy dữ liệu từ Tardis Machine
Tardis cung cấp historical data với độ phân giải từ 1ms. Với BTC perpetual trên 3 sàn trong 1 năm, bạn sẽ cần khoảng 50GB orderbook data (compressed). Đây là cách tôi thiết lập data pipeline hiệu quả:
import os
import aiohttp
import asyncio
from datetime import datetime, timedelta
import pandas as pd
class TardisDataFetcher:
"""Fetch historical orderbook data từ Tardis Machine"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://tardis.dev/api/v1"
self.session = None
async def fetch_orderbook(self, exchange: str, symbol: str,
from_ts: int, to_ts: int) -> pd.DataFrame:
"""Fetch orderbook snapshots với resolution 100ms"""
if not self.session:
self.session = aiohttp.ClientSession(
headers={"Authorization": f"Bearer {self.api_key}"}
)
# Tardis historical replay endpoint
url = f"{self.base_url}/historical/{exchange}/{symbol}/orderbook-snapshots"
params = {
"from": from_ts,
"to": to_ts,
"limit": 100000,
"format": "json"
}
async with self.session.get(url, params=params) as resp:
if resp.status == 200:
data = await resp.json()
return self._parse_orderbook(data, exchange, symbol)
else:
raise Exception(f"Tardis API error: {resp.status}")
def _parse_orderbook(self, data: list, exchange: str,
symbol: str) -> pd.DataFrame:
"""Parse orderbook data thành structured DataFrame"""
records = []
for snapshot in data:
timestamp = snapshot['timestamp']
# Extract best bid/ask
bids = snapshot.get('bids', [])
asks = snapshot.get('asks', [])
if bids and asks:
best_bid = float(bids[0][0])
best_ask = float(asks[0][0])
mid_price = (best_bid + best_ask) / 2
spread_bps = (best_ask - best_bid) / mid_price * 10000
records.append({
'exchange': exchange,
'symbol': symbol,
'timestamp': timestamp,
'best_bid': best_bid,
'best_ask': best_ask,
'mid_price': mid_price,
'spread_bps': spread_bps,
'bid_depth_10': sum(float(b[1]) for b in bids[:10]),
'ask_depth_10': sum(float(a[1]) for a in asks[:10])
})
return pd.DataFrame(records)
async def close(self):
if self.session:
await self.session.close()
async def main():
# Initialize fetcher
fetcher = TardisDataFetcher(api_key=os.getenv("TARDIS_API_KEY"))
# Fetch data cho 3 exchanges - 1 tháng demo
exchanges = ['binance', 'okx', 'bybit']
symbol = 'BTC-USDT-PERPETUAL'
start = datetime(2024, 6, 1)
end = datetime(2024, 6, 30)
all_data = {}
for exchange in exchanges:
print(f"Fetching {exchange}...")
df = await fetcher.fetch_orderbook(
exchange=exchange,
symbol=symbol,
from_ts=int(start.timestamp() * 1000),
to_ts=int(end.timestamp() * 1000)
)
all_data[exchange] = df
print(f" -> {len(df)} records fetched, {df.memory_usage(deep=True).sum() / 1024**2:.1f} MB")
await fetcher.close()
# Save to parquet for efficient storage
for exchange, df in all_data.items():
df.to_parquet(f"orderbook_{exchange}_2024_06.parquet")
return all_data
if __name__ == "__main__":
data = asyncio.run(main())Điểm quan trọng tôi đã học được: luôn fetch data theo từng tháng, không fetch liền cả năm vì Tardis sẽ timeout. Với 1 tháng data, pipeline này chạy trong khoảng 3-5 phút tùy network latency.
Tích hợp HolySheep AI
Đây là phần core của bài viết. HolySheep AI cung cấp API endpoint tại https://api.holysheep.ai/v1 với latency trung bình <50ms — nhanh hơn đáng kể so với OpenAI hay Anthropic. Với quantitative research, tốc độ phản hồi này cho phép bạn generate strategy code, phân tích signal patterns, và optimize parameters real-time.
import os
import json
from typing import List, Dict, Optional
import httpx
class HolySheepQuantAssistant:
"""
HolySheep AI assistant cho quantitative research.
API Base: https://api.holysheep.ai/v1
"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.client = httpx.AsyncClient(
timeout=30.0,
limits=httpx.Limits(max_keepalive_connections=20)
)
async def generate_strategy_code(self,
strategy_description: str,
exchanges: List[str],
symbol: str) -> str:
"""Generate strategy code từ mô tả"""
prompt = f"""Bạn là quantitative researcher chuyên nghiệp.
Hãy viết Python code cho chiến lược arbitrage với specifications sau:
Symbol: {symbol}
Exchanges: {', '.join(exchanges)}
Chiến lược: {strategy_description}
Yêu cầu:
1. Class-based architecture với clear separation of concerns
2. Include realistic fee modeling (maker/taker rates)
3. Include risk management với max position size
4. Return DataFrame với columns: timestamp, signal, pnl, cumulative_pnl
5. Handle edge cases: spread anomaly, exchange disconnection
Code phải production-ready, không có placeholder comments.
"""
response = await self._call_chatcompletions(
model="deepseek-chat",
messages=[{"role": "user", "content": prompt}],
temperature=0.3
)
return response.choices[0].message.content
async def analyze_spread_pattern(self,
spread_data: Dict) -> Dict:
"""Phân tích spread pattern để tìm arbitrage opportunities"""
prompt = f"""Phân tích spread data và đề xuất chiến lược arbitrage:
Data Summary:
- Exchanges: {spread_data.get('exchanges')}
- Date range: {spread_data.get('date_range')}
- Mean spread: {spread_data.get('mean_spread_bps')} bps
- Std spread: {spread_data.get('std_spread_bps')} bps
- Max spread: {spread_data.get('max_spread_bps')} bps
- Min spread: {spread_data.get('min_spread_bps')} bps
Hãy phân tích:
1. Statistical properties (mean, std, kurtosis, skewness)
2. Mean reversion potential
3. Optimal entry/exit thresholds
4. Expected Sharpe ratio estimation
5. Risk factors cần monitor
Format response JSON với keys: analysis, strategy_recommendation, risk_factors, expected_metrics
"""
response = await self._call_chatcompletions(
model="deepseek-chat",
messages=[{"role": "user", "content": prompt}],
temperature=0.2,
response_format={"type": "json_object"}
)
return json.loads(response.choices[0].message.content)
async def optimize_parameters(self,
current_params: Dict,
backtest_results: Dict) -> Dict:
"""Optimize strategy parameters dựa trên backtest results"""
prompt = f"""Tối ưu hóa parameters dựa trên backtest results:
Current Parameters:
{json.dumps(current_params, indent=2)}
Backtest Results:
- Total PnL: {backtest_results.get('total_pnl')}
- Sharpe Ratio: {backtest_results.get('sharpe_ratio')}
- Max Drawdown: {backtest_results.get('max_drawdown')}
- Win Rate: {backtest_results.get('win_rate')}
- Total Trades: {backtest_results.get('total_trades')}
Hãy đề xuất optimized parameters và giải thích rationale.
Include: parameter_adjustments, expected_improvement, risk_changes
"""
response = await self._call_chatcompletions(
model="deepseek-chat",
messages=[{"role": "user", "content": prompt}],
temperature=0.4
)
return response.choices[0].message.content
async def _call_chatcompletions(self, model: str,
messages: List[Dict],
temperature: float = 0.7,
response_format: Optional[Dict] = None) -> Dict:
"""Internal method để call HolySheep Chat Completions API"""
payload = {
"model": model,
"messages": messages,
"temperature": temperature
}
if response_format:
payload["response_format"] = response_format
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
async with self.client.stream(
"POST",
f"{self.base_url}/chat/completions",
json=payload,
headers=headers
) as response:
if response.status_code != 200:
error_text = await response.text()
raise Exception(f"HolySheep API Error: {response.status_code} - {error_text}")
# For JSON responses, parse normally
data = await response.json()
return data
async def close(self):
await self.client.aclose()
Usage example
async def demo_holysheep_integration():
assistant = HolySheepQuantAssistant(api_key=os.getenv("HOLYSHEEP_API_KEY"))
# 1. Generate strategy code
print("Generating strategy code...")
strategy_code = await assistant.generate_strategy_code(
strategy_description="Triangular arbitrage giữa 3 sàn với mean reversion entry, "
"position size = f(spread_deviation), exit khi spread revert 50%",
exchanges=['binance', 'okx', 'bybit'],
symbol='BTC-USDT-PERPETUAL'
)
print(f"Generated code length: {len(strategy_code)} chars")
# 2. Analyze spread pattern
print("\nAnalyzing spread pattern...")
spread_data = {
'exchanges': ['binance', 'okx', 'bybit'],
'date_range': '2024-01-01 to 2024-12-31',
'mean_spread_bps': 2.3,
'std_spread_bps': 8.7,
'max_spread_bps': 45.2,
'min_spread_bps': 0.1
}
analysis = await assistant.analyze_spread_pattern(spread_data)
print(f"Analysis: {json.dumps(analysis, indent=2)}")
await assistant.close()
return strategy_code, analysis
if __name__ == "__main__":
code, analysis = asyncio.run(demo_holysheep_integration())Trong thực chiến, tôi sử dụng HolySheep để generate 80% boilerplate code và phân tích 100% signal patterns. Điều này giúp tôi tiết kiệm khoảng 40 giờ/tháng so với việc viết tay hoàn toàn.
Xây dựng Backtesting Engine
Backtesting engine cho cross-exchange arbitrage cần handle nhiều edge cases phức tạp. Đây là implementation production-ready mà tôi đã sử dụng cho quỹ Singapore:
import pandas as pd
import numpy as np
from dataclasses import dataclass
from typing import List, Tuple, Optional
from enum import Enum
class Exchange(Enum):
BINANCE = "binance"
OKX = "okx"
BYBIT = "bybit"
@dataclass
class FeeStructure:
"""Fee structure cho từng sàn (tính theo % của notional)"""
maker_fee: float
taker_fee: float
# 2024-2026 fee rates (thực tế)
@classmethod
def get_fees(cls, exchange: Exchange) -> 'FeeStructure':
fees = {
Exchange.BINANCE: cls(maker_fee=0.0002, taker_fee=0.0004),
Exchange.OKX: cls(maker_fee=0.0002, taker_fee=0.0005),
Exchange.BYBIT: cls(maker_fee=0.0002, taker_fee=0.0005),
}
return fees[exchange]
@dataclass
class TradeSignal:
timestamp: pd.Timestamp
exchange_long: Exchange
exchange_short: Exchange
entry_spread_bps: float
position_size: float
side: str # "long_short" or "short_long"
class CrossExchangeArbitrageBacktester:
"""
Backtester cho cross-exchange BTC perpetual arbitrage.
Handle realistic fee modeling, slippage, và latency.
"""
def __init__(self,
initial_capital: float = 100_000,
max_position_pct: float = 0.02,
entry_threshold_bps: float = 5.0,
exit_threshold_bps: float = 2.0,
lookback_window: int = 60):
self.initial_capital = initial_capital
self.max_position_pct = max_position_pct
self.entry_threshold_bps = entry_threshold_bps
self.exit_threshold_bps = exit_threshold_bps
self.lookback_window = lookback_window
# State
self.current_position: Optional[TradeSignal] = None
self.equity_curve: List[float] = []
self.trades: List[dict] = []
self.equity = initial_capital
# Statistics
self.daily_returns = []
self.max_drawdown = 0
self.peak_equity = initial_capital
def calculate_spread(self,
binance_df: pd.DataFrame,
okx_df: pd.DataFrame,
bybit_df: pd.DataFrame,
timestamp: pd.Timestamp) -> Tuple[float, Tuple[Exchange, Exchange]]:
"""
Calculate cross-exchange spread tại timestamp.
Spread = (mid_A - mid_B) / mid_B * 10000 (bps)
"""
# Find closest data points
def get_mid(df: pd.DataFrame, ts: pd.Timestamp) -> Optional[float]:
mask = df['timestamp'] == ts
if mask.any():
return df.loc[mask, 'mid_price'].values[0]
# Find nearest
df_sorted = df.iloc[df['timestamp'].sub(ts).abs().argsort()[:1]]
return df_sorted['mid_price'].values[0] if len(df_sorted) > 0 else None
# Get mid prices
btc_binance = get_mid(binance_df, timestamp)
btc_okx = get_mid(okx_df, timestamp)
btc_bybit = get_mid(bybit_df, timestamp)
if None in [btc_binance, btc_okx, btc_bybit]:
return 0.0, (Exchange.BINANCE, Exchange.OKX)
# Calculate spreads between all pairs
spreads = [
(btc_binance - btc_okx) / btc_okx * 10000, # BIN-OKX
(btc_binance - btc_bybit) / btc_bybit * 10000, # BIN-BYBIT
(btc_okx - btc_bybit) / btc_bybit * 10000, # OKX-BYBIT
(btc_bybit - btc_okx) / btc_okx * 10000, # BYBIT-OKX (reverse)
(btc_okx - btc_binance) / btc_binance * 10000, # OKX-BIN (reverse)
(btc_bybit - btc_binance) / btc_binance * 10000, # BYBIT-BIN (reverse)
]
# Find max spread pair (arbitrage opportunity)
max_idx = np.argmax(np.abs(spreads))
pairs = [
(Exchange.BINANCE, Exchange.OKX),
(Exchange.BINANCE, Exchange.BYBIT),
(Exchange.OKX, Exchange.BYBIT),
(Exchange.BYBIT, Exchange.OKX),
(Exchange.OKX, Exchange.BINANCE),
(Exchange.BYBIT, Exchange.BINANCE),
]
return spreads[max_idx], pairs[max_idx]
def calculate_pnl(self, signal: TradeSignal,
current_spread_bps: float,
btc_price: float) -> float:
"""
Calculate PnL cho một signal với realistic fees.
Entry: pay taker fee on both legs
Exit: pay taker fee on both legs
Slippage: 1bp fixed (realistic cho liquid BTC perp)
"""
fees_long = FeeStructure.get_fees(signal.exchange_long)
fees_short = FeeStructure.get_fees(signal.exchange_short)
# Entry fees (2 legs: long + short)
entry_fee = (signal.position_size * btc_price *
(fees_long.taker_fee + fees_short.taker_fee))
# Exit fees
exit_fee = (signal.position_size * btc_price *
(fees_long.taker_fee + fees_short.taker_fee))
# Slippage (1bp each side)
slippage = signal.position_size * btc_price * 0.0002
# PnL = spread differential * position size - costs
spread_pnl = (current_spread_bps - signal.entry_spread_bps) / 10000 * signal.position_size * btc_price
total_costs = entry_fee + exit_fee + slippage
return spread_pnl - total_costs
def run_backtest(self,
combined_data: pd.DataFrame,
start_date: str,
end_date: str) -> pd.DataFrame:
"""
Run backtest on combined data.
combined_data format:
timestamp | binance_mid | okx_mid | bybit_mid |
binance_spread | okx_spread | bybit_spread
"""
# Filter date range
df = combined_data[
(combined_data['timestamp'] >= start_date) &
(combined_data['timestamp'] <= end_date)
].copy()
results = []
for idx, row in df.iterrows():
timestamp = row['timestamp']
btc_price = row['binance_mid'] # Reference price
# Calculate cross-exchange spreads
spreads = {
'binance_okx': (row['binance_mid'] - row['okx_mid']) / row['okx_mid'] * 10000,
'binance_bybit': (row['binance_mid'] - row['bybit_mid']) / row['bybit_mid'] * 10000,
'okx_bybit': (row['okx_mid'] - row['bybit_mid']) / row['bybit_mid'] * 10000,
}
# Find max spread
max_pair = max(spreads, key=spreads.get)
max_spread = spreads[max_pair]
abs_spread = abs(max_spread)
# Check entry condition
if self.current_position is None:
if abs_spread >= self.entry_threshold_bps:
# Open position
exchanges = max_pair.split('_')
long_ex = Exchange(exchanges[0])
short_ex = Exchange(exchanges[1])
# Position size = equity * max_position_pct
position_size = (self.equity * self.max_position_pct) / btc_price
self.current_position = TradeSignal(
timestamp=timestamp,
exchange_long=long_ex if max_spread > 0 else short_ex,
exchange_short=short_ex if max_spread > 0 else long_ex,
entry_spread_bps=abs_spread,
position_size=position_size,
side="long_short" if max_spread > 0 else "short_long"
)
# Check exit condition
elif self.current_position is not None:
# Calculate current PnL
current_spread = spreads.get(
f"{self.current_position.exchange_long.value}_{self.current_position.exchange_short.value}",
0
)
pnl = self.calculate_pnl(
self.current_position,
abs(current_spread),
btc_price
)
# Exit if spread reverted or profit target hit
spread_reverted = abs_spread <= self.exit_threshold_bps
profit_taken = pnl > (self.equity * 0.001) # 0.1% per trade max
if spread_reverted or profit_taken or abs_spread > 50: # Emergency exit
# Close position
self.equity += pnl
self.trades.append({
'entry_time': self.current_position.timestamp,
'exit_time': timestamp,
'exchange_long': self.current_position.exchange_long.value,
'exchange_short': self.current_position.exchange_short.value,
'entry_spread': self.current_position.entry_spread_bps,
'exit_spread': abs_spread,
'pnl': pnl,
'pnl_pct': pnl / self.initial_capital * 100,
'duration_minutes': (timestamp - self.current_position.timestamp).total_seconds() / 60
})
self.current_position = None
# Update equity curve
self.equity_curve.append({
'timestamp': timestamp,
'equity': self.equity,
'position_open': self.current_position is not None
})
# Track max drawdown
if self.equity > self.peak_equity:
self.peak_equity = self.equity
drawdown = (self.peak_equity - self.equity) / self.peak_equity
self.max_drawdown = max(self.max_drawdown, drawdown)
return pd.DataFrame(self.equity_curve), pd.DataFrame(self.trades)
def get_performance_metrics(self) -> dict:
"""Calculate comprehensive performance metrics"""
if not self.trades:
return {"error": "No trades executed"}
trades_df = pd.DataFrame(self.trades)
total_pnl = trades_df['pnl'].sum()
total_pnl_pct = total_pnl / self.initial_capital * 100
# Daily returns
equity_df = pd.DataFrame(self.equity_curve)
equity_df['date'] = pd.to_datetime(equity_df['timestamp']).dt.date
daily_equity = equity_df.groupby('date')['equity'].last()
daily_returns = daily_equity.pct_change().dropna()
# Sharpe ratio (annualized, assuming 252 trading days)
sharpe = (daily_returns.mean() / daily_returns.std() * np.sqrt(252)) if daily_returns.std() > 0 else 0
# Win rate
winning_trades = (trades_df['pnl'] > 0).sum()
win_rate = winning_trades / len(trades_df) * 100
# Average trade
avg_trade = trades_df['pnl'].mean()
avg_trade_pct = avg_trade / self.initial_capital * 100
# Trade frequency
trade_frequency = len(trades_df) / (equity_df['date'].nunique() / 252) # trades/year
return {
'total_pnl': total_pnl,
'total_pnl_pct': total_pnl_pct,
'sharpe_ratio': sharpe,
'max_drawdown_pct': self.max_drawdown * 100,
'win_rate': win_rate,
'total_trades': len(trades_df),
'avg_trade_pnl': avg_trade,
'avg_trade_pct': avg_trade_pct,
'trades_per_year': trade_frequency,
'final_equity': self.equity
}
Usage
def run_full_backtest():
# Load data
binance = pd.read_parquet("orderbook_binance_2024_06.parquet")
okx = pd.read_parquet("orderbook_okx_2024_06.parquet")
bybit = pd.read_parquet("orderbook_bybit_2024_06.parquet")
# Combine data
combined = binance.merge(
okx[['timestamp', 'mid_price']],
on='timestamp',
suffixes=('', '_okx')
).merge(
bybit[['timestamp', 'mid_price']],
on='timestamp',
suffixes=('', '_bybit')
).rename(columns={
'mid_price': 'binance_mid',
'mid_price_okx': 'okx_mid',
'mid_price_bybit': 'bybit_mid'
})
# Initialize backtester
backtester = CrossExchangeArbitrageBacktester(
initial_capital=100_000,
max_position_pct=0.02,
entry_threshold_bps=5.0,
exit_threshold_bps=2.0
)
# Run
equity_curve, trades = backtester.run_backtest(
combined_data=combined,
start_date='2024-06-01',
end_date='2024-06-30'
)
# Get metrics
metrics = backtester.get_performance_metrics()
print(f"Backtest Results:")
print(f" Total PnL: ${metrics['total_pnl']:.2f} ({metrics['total_pnl_pct']:.2f}%)")
print(f" Sharpe Ratio: {metrics['sharpe_ratio']:.2f}")
print(f" Max Drawdown: {metrics['max_drawdown_pct']:.2f}%")
print(f" Win Rate: {metrics['win_rate']:.1f}%")
print(f" Total Trades: {metrics['total_trades']}")
return equity_curve, trades, metricsChiến lược Cross-Exchange Spread
Sau khi có data và backtesting framework, bạn cần implement chiến lược cụ thể. Tôi sẽ chia sẻ 3 chiến lược mà tôi đã test thành công:
Chiến lược 1: Mean Reversion Spread
Ý tưởng: Khi spread giữa 2 sàn deviated quá xa khỏi mean, nó sẽ revert. Entry khi spread vượt threshold, exit khi spread revert về mean.
import pandas as pd
import numpy as np
class MeanReversionSpreadStrategy:
"""
Chiến lược Mean Reversion cho cross-exchange spread.
Entry: Spread > Mean + k * Std
Exit: Spread < Mean + (k/2) * Std hoặc Stop loss
Parameters:
- lookback: Số periods để tính mean/std
- entry_k: Số Std để trigger entry
- exit_k: Số Std để trigger exit
- stop_k: Số Std để stop loss
"""
def __init__(self,
lookback: int = 60,
entry_k: float = 2.0,
exit_k: float = 1.0,
stop_k: float = 3.5,
min_spread_bps: float = 2.0):
self.lookback = lookback
self.entry_k = entry_k