自本声明添加之日起，本文采用 CC BY-NC-SA 4.0 国际知识共享协议 许可。
基于这篇博文的衍生架构：
三进制存储的工程折衷：基于符号-绝对值分离的双盘存储架构构思：https://blog.csdn.net/baidu_25975113/article/details/163198974?spm=1001.2014.3001.5502
仿真代码 仿真结果放在文末，有需要的自行下载验证
- 本文创作已完成TSA时间授时固化，用于固定理论首创时间。
此前介绍的 SMS（Sign‑Magnitude Separation，符号‑绝对值分离）存储架构，最初采用两块独立物理磁盘的设计：一块数据盘存放三态数值的绝对值 Abs，一块符号盘存放符号位 Sign。依靠两套独立物理介质，实现硬件层面故障隔离，偏向高可靠、分布式工业场景。
很多人提出疑问：普通设备只有一块 SSD 或者机械硬盘，没有第二块物理磁盘，还能不能落地 SMS 三态存储原型？
答案是可以。SMS 架构具备很强伸缩能力，不需要等待三进制专用存储芯片商用，仅在单块现有硬盘上划分两个逻辑分区，即可搭建完整 SMS 原型。上层业务只看到一块普通逻辑硬盘，底层拆分、合成逻辑全部封装在内，对上层透明。
核心实现思路
在同一块物理硬盘内部，划分两个互相独立的逻辑分区：
- 数据分区 data_part：存储三态数值的绝对值 Abs，仅保存二进制 0/1
- 符号分区 sign_part：存储符号位 Sign，仅保存二进制 0/1
Trit 映射对照表
表格
| Trit 三态值 | 绝对值 Abs | 符号位 Sign |
|---|---|---|
| -1 | 1 | 1 |
| 0 | 0 | 0 |
| 1 | 1 | 0 |
写入流程 ：接收到三态值‑1 / 0 / 1，拆分为绝对值与符号位，写入两个分区完全相同的地址。
读取流程 ：同一地址分别取出 Abs、Sign，使用合成公式： Result = (-1)^Sign * Abs 增加兜底逻辑：当Abs=0时强制输出 0，规避数学奇异点，保证零值读取不会出错。
上层业务程序完全感知底层双分区结构，调用接口和普通硬盘没有区别。
仿真测试结果
本次为行为级逻辑仿真，非硬件 SPICE 仿真。 一共完成2003 组随机三态样本验证，基础读写无损通过率 100% 。 在完全二进制的存储介质之上，实现{-1,0,1}三态数据无损存储还原；每 1 个 trit 消耗 2bit 物理存储空间，存在合理存储冗余。
同时完成分片损坏故障模拟，得到三组关键现象：
- 符号分区损坏：只能读到绝对值，无法唯一还原原始三态，出现歧义；
- 数据分区损坏：绝对值信息丢失，完全无法恢复 trit；
- 整块硬盘硬件损坏：两个分区同时失效，全部数据丢失。
两套部署模式对比
表格
| 对比维度 | 单硬盘双分区（原型验证） | 双独立物理磁盘（高可靠方案） |
|---|---|---|
| 物理硬件 | 1 块 SSD/HDD | 两块相互独立磁盘 |
| 逻辑划分 | 同一硬盘内两个逻辑分区 | 两套独立物理介质 |
| 编码映射 | 与双磁盘版本完全一致 | 与单分区版本完全一致 |
| 硬件门槛 | 极低，普通消费级设备即可实验 | 需要第二块物理磁盘 |
| 故障隔离能力 | 无，整盘损坏两份数据一同丢失 | 硬件级故障隔离，单盘故障保留另一部分数据 |
| 适用场景 | 原理验证、小规模研究原型 | 生产业务、容灾、高可靠场景 |
模式定位说明
✅ 单硬盘双分区优势：硬件门槛极低，普通笔记本、台式机就可以搭建原型，映射规则和原版 SMS 完全兼容，充分复用现有二进制存储硬件。
⚠️ 固有短板：两个分区依附同一块物理硬盘，硬盘硬件损毁则两份数据一起丢失，此方案只适合原型验证，严禁直接用于真实生产业务。 追求数据安全、容灾能力的场景，依旧优先选用原版双独立物理磁盘架构。
工程启发
长久以来行业普遍固有认知：三进制存储必须等待特制三态存储硬件问世。 而 SMS 架构给出另一条可行路径：不需要改动存储硬件底层，依靠上层逻辑架构，让二进制磁盘承载无损三态数据。
单硬盘双分区方案进一步压低原型门槛，不用特殊硬件，普通开发者就可以复现整套逻辑，不再局限于纸面理论。 SMS 架构拥有很强的伸缩性：既可以部署在多盘阵列做分布式高可靠存储，也可以收缩至单硬盘分区做最小原型，完整复用现有二进制存储生态。
资源说明
架构示意图、仿真结果截图见本文配图。 完整仿真原始报告、测试样本文件已经归档至 Gitee 仓库，包含原版双物理磁盘方案与单硬盘分区扩展方案，可供同行查阅、复现验证。
固态存储可以直接套用本方案、无需修改
代码示例：
# -*- coding: utf-8 -*-
"""
===============================================================================
SMS 单硬盘双分区轻量化原型 ------ 行为级仿真
===============================================================================
场景: 普通用户手里只有一块物理硬盘(SSD/HDD), 没有第二块物理磁盘。
方案: 在同一颗物理硬盘内部切割两个相互独立的逻辑分区:
数据分区 data_part : 保存三态数值的绝对值 Abs (仅二进制 0/1)
映射: |-1|=1, |0|=0, |1|=1
符号分区 sign_part : 保存符号位 Sign (仅二进制 0/1)
映射: -1 -> 1(负), 0 -> 0(零), 1 -> 0(正)
写入流程: 收到一个三态数值 -1/0/1 -> 拆分为 (Abs, Sign)
-> 写入两个分区【完全相同】的地址。
读取流程: 从相同地址分别取出 Abs、Sign,
合成公式 Result = (-1)^Sign * Abs;
特殊兜底: 当 Abs = 0 时直接强制输出 0, 规避数学计算奇异点。
上层业务程序完全感知不到底层存在两个分区, 只对接统一的逻辑硬盘接口,
读写调用方式与普通硬盘没有区别(底层拆分/合成全部封装隐藏)。
仿真覆盖:
1) 基础三态穷举测试: 映射表验证 + Abs=0 特例兜底 + 2bit/3态信息论证
2) 大批量随机三态读写: 100% 无损写入、读取还原
3) 分片损坏模拟:
① 符号分区损坏 -> 无法还原(数据分区沦为绝对值噪声)
② 数据分区损坏 -> 无法还原
③ 整块物理硬盘硬件损坏 -> 两个分区【同时失效】, 全部数据丢失
(单盘方案固有短板: 失去双物理磁盘的硬件故障隔离能力)
4) 对比测试: 单盘双分区 vs 双独立物理磁盘(故障隔离能力差异)
定位: 单硬盘双分区是【原型验证方案】, 适合原理验证、小规模实验研究;
对数据安全、容灾能力有要求的场景, 依旧优先选用两块独立物理磁盘
的原始 SMS 方案。
说明: 本仿真为纯逻辑/行为级仿真(行为建模分区读写与编解码), 不是 SPICE
电路级硬件仿真。
依赖: 仅 Python 标准库(os/sys/random/math/datetime), 无任何第三方依赖。
输出: 仿真报告、测试日志、测试样例、SVG 架构示意图全部保存到
Windows 桌面指定目录(默认: C:\\Users\\wando\\Desktop\\三进制\\
SMS拓扑存储\\单盘分区无损存储3禁止数据, 可用命令行参数覆盖)。
===============================================================================
"""
import os
import sys
import random
import math
import datetime
ALL_TRITS = (-1, 0, 1) # 三态全空间
def _setup_console_encoding():
"""尽量保证控制台中文输出不因编码问题崩溃(文件内容不受影响)。"""
try:
sys.stdout.reconfigure(errors="replace")
sys.stderr.reconfigure(errors="replace")
except Exception:
pass
class Reporter:
"""输出收集器: 同时打印到控制台并缓存文本, 便于统一落盘为日志/报告。"""
def __init__(self):
self.lines = []
def say(self, msg=""):
print(msg)
self.lines.append(str(msg))
def hr(self, ch="-", n=72):
self.say(ch * n)
def title(self, text):
self.hr("=")
self.say(text)
self.hr("=")
def flush(self, path):
with open(path, "w", encoding="utf-8-sig") as f:
f.write("\n".join(self.lines) + "\n")
# ---------------------------------------------------------------------------
# 1. SMS 核心: Trit <-> (Abs, Sign) 编码 / 解码 (与双物理磁盘版本完全一致)
# ---------------------------------------------------------------------------
def trit_to_abs(trit):
"""三态值 -> 绝对值位(物理写入数据分区)。
映射: |-1| = 1, |0| = 0, |1| = 1
"""
return abs(trit)
def trit_to_sign(trit):
"""三态值 -> 符号位(物理写入符号分区)。
映射: -1 -> 1(负), 0 -> 0(零), 1 -> 0(正)
"""
return 1 if trit == -1 else 0
def encode_trit(trit):
"""写入流程: 将三态数据 Trit 拆分为 (Abs, Sign) 二元组。"""
return trit_to_abs(trit), trit_to_sign(trit)
def decode_trit(abs_bit, sign_bit):
"""读取流程: 由 (Abs, Sign) 合成还原原始 Trit。
合成公式: Result = (-1)^Sign * Abs
特例: Abs = 0 时强制输出 0, 忽略符号位(兜底规避奇异点)。
"""
if abs_bit is None or sign_bit is None:
return None # 读到空扇区/分区失效
if abs_bit == 0:
return 0 # 特例: 强制输出 0
return (-1) ** sign_bit * abs_bit
# ---------------------------------------------------------------------------
# 2. 单硬盘双分区物理模型
# ---------------------------------------------------------------------------
class PartitionReadError(Exception):
"""分区/硬盘读取异常(分区损坏 / 整盘物理损坏)。"""
class Partition:
"""逻辑分区模型: 仅能存储二进制位 0/1, 按逻辑地址寻址。"""
def __init__(self, name):
self.name = name
self.bitmap = {} # {逻辑地址: 位值 0/1}
self.destroyed = False # 分区损坏(介质失效)
self.write_count = 0 # 行为级统计: 写入次数
def write(self, addr, bit):
if self.destroyed:
raise PartitionReadError(f"[{self.name}] 分区已失效, 写入失败 @{addr}")
self.bitmap[addr] = bit
self.write_count += 1
def read(self, addr):
if self.destroyed:
raise PartitionReadError(f"[{self.name}] 分区已失效(数据永久消失), 读取失败 @{addr}")
return self.bitmap.get(addr) # 未写过的地址返回 None(空扇区)
def destroy(self):
"""模拟分区物理损坏: 扇区数据全部清除且永不可读。"""
self.destroyed = True
self.bitmap.clear()
def is_available(self):
return not self.destroyed
class SingleDriveDualPartition:
"""单硬盘双分区 SMS 架构: 一颗物理硬盘内切割 data_part + sign_part。
对应文中部署模式: 单硬盘双分区模式(原型验证方案)。
"""
def __init__(self, name="单硬盘双分区SMS"):
self.name = name
# 同一颗物理硬盘内的两个逻辑分区
self.data_part = Partition("数据分区 data_part")
self.sign_part = Partition("符号分区 sign_part")
self.phys_destroyed = False # 整颗物理硬盘硬件损坏标志
# ---- 写入流程 ----
def write(self, addr, trit):
"""收到三态数值 -> 拆分 (Abs, Sign) -> 写入两个分区完全相同地址。"""
if self.phys_destroyed:
raise PartitionReadError(f"[{self.name}] 物理硬盘已损坏, 写入失败 @{addr}")
a, s = encode_trit(trit)
self.data_part.write(addr, a)
self.sign_part.write(addr, s)
# ---- 读取流程 ----
def read(self, addr):
"""相同地址分别取出 Abs、Sign -> 合成公式还原 Trit。"""
if self.phys_destroyed:
raise PartitionReadError(f"[{self.name}] 物理硬盘已损坏, 读取失败 @{addr}")
a = self.data_part.read(addr)
s = self.sign_part.read(addr)
return decode_trit(a, s)
# ---- 故障注入 ----
def destroy_partition(self, which):
"""单个逻辑分区损坏(分区级故障)。which: 'data' 或 'sign'"""
if which == "data":
self.data_part.destroy()
else:
self.sign_part.destroy()
def destroy_physical_disk(self):
"""整块物理硬盘硬件本体损坏:
数据分区与符号分区【同时失效】, 直接丢失全部数据
(单盘方案固有短板: 失去硬件故障隔离能力)。
"""
self.phys_destroyed = True
self.data_part.destroyed = True
self.sign_part.destroyed = True
self.data_part.bitmap.clear()
self.sign_part.bitmap.clear()
# ---------------------------------------------------------------------------
# 3. 上层逻辑硬盘接口(封装隐藏底层双分区)
# ---------------------------------------------------------------------------
class LogicalDisk:
"""上层业务程序看到的【统一逻辑硬盘】。
读写调用方式与普通硬盘没有区别; 底层双分区拆分/合成逻辑全部被封装隐藏。
"""
def __init__(self, phys):
self.phys = phys
def write(self, addr, trit):
return self.phys.write(addr, trit)
def read(self, addr):
return self.phys.read(addr)
@property
def name(self):
return f"逻辑硬盘(封装自: {self.phys.name})"
# ---------------------------------------------------------------------------
# 4. 双独立物理磁盘 SMS(用于对比)
# ---------------------------------------------------------------------------
class DualPhysicalDiskSMS:
"""原始 SMS 双物理磁盘方案: 数据盘 + 符号盘 = 两块独立物理介质。"""
def __init__(self, name="双独立物理磁盘SMS"):
self.name = name
self.data_disk = Partition("独立数据盘 Data Disk")
self.sign_disk = Partition("独立符号盘 Sign Disk")
def write(self, addr, trit):
a, s = encode_trit(trit)
self.data_disk.write(addr, a)
self.sign_disk.write(addr, s)
def read(self, addr):
a = self.data_disk.read(addr)
s = self.sign_disk.read(addr)
return decode_trit(a, s)
# ---------------------------------------------------------------------------
# 5. 测试工具
# ---------------------------------------------------------------------------
def gen_trits(n, seed=2026):
"""按固定种子生成 n 个随机三态样本(可复现)。"""
rng = random.Random(seed)
return [rng.choice(ALL_TRITS) for _ in range(n)]
def roundtrip_check(ld, trits, start_addr=0):
"""写入 -> 读出 全量比对。返回 (通过数, 总数, 失败明细)。"""
for i, t in enumerate(trits):
ld.write(start_addr + i, t)
failed = []
for i, t in enumerate(trits):
try:
got = ld.read(start_addr + i)
except Exception as e:
failed.append((i, t, f"<异常:{e}>"))
continue
if got != t:
failed.append((i, t, got))
return len(trits) - len(failed), len(trits), failed
def data_part_noise_analysis(st, trits, start_addr=0):
"""分析"仅剩数据分区(符号分区失效)"时的可还原性。
每个扇区只提供 1 bit, 每 trit 需 log2(3)≈1.585 bit;
凡 abs=1 的位置既可能是 +1 也可能是 -1 -> 2^(abs=1 个数) 种候选, 无法唯一还原。
"""
bits = []
for i in range(len(trits)):
try:
bits.append(st.data_part.read(start_addr + i))
except Exception:
bits.append(None)
ones = sum(1 for b in bits if b == 1)
candidates = 2 ** ones
gap = math.log2(3) - 1.0
return bits, candidates, gap
# ---------------------------------------------------------------------------
# 6. 测试套件
# ---------------------------------------------------------------------------
def test1_basic_rw(log, n=2000, seed=2026):
"""测试1: 基础读写单元 ------ 穷举映射 + 大样本随机读写 100% 无损。"""
log.title("测试1 | 基础读写单元: 三态拆分 / 双分区写入 / 读取合成还原")
passed = 0
# [1a] 三态穷举: 验证映射表与合成公式
log.say("[1a] 三态穷举编码 -> 双分区写入 -> 合成还原:")
log.say("Trit | 绝对值位Abs | 符号位Sign | 合成Result | 一致")
log.hr("-", 52)
all_ok = True
for t in ALL_TRITS:
a, s = encode_trit(t)
r = decode_trit(a, s)
ok = (r == t)
all_ok &= ok
log.say(f" {t:>2} | {a} | {s} | {r:>2} | {'√ 无损' if ok else '× 错误'}")
if all_ok:
passed += 3
# 特例: Abs=0, Sign=1 (正常编码不会产生, 模拟读盘脏位/兜底)
special = decode_trit(0, 1)
ok_s = (special == 0)
log.say(f"[特例] Abs=0, Sign=1(脏位) -> 强制输出 {special}, 忽略符号位 "
f"{'√ 符合兜底规则' if ok_s else '×'}")
log.say("")
# [1b] 大样本随机读写无损验证
log.say(f"[1b] 随机大样本 {n} 个 Trit 写入/读取 100% 比对:")
phys = SingleDriveDualPartition("测试1-单盘双分区")
ld = LogicalDisk(phys)
trits = gen_trits(n, seed)
p, t, bad = roundtrip_check(ld, trits)
passed += p
log.say(f" 写入 {t} 个 -> 读出 {p} 个一致, 失败 {len(bad)} 个 "
f"({p / t * 100:.4f}% 无损)")
if bad:
log.say(f" 失败样例(前5): {bad[:5]}")
# 双分区物理内容检查: 每个扇区都是二进制位
bits_d = sorted(set(phys.data_part.bitmap.values()))
bits_s = sorted(set(phys.sign_part.bitmap.values()))
log.say(f" 双分区物理位检查: 数据分区仅含位 {bits_d}, 符号分区仅含位 {bits_s} "
f"-> 确认两个分区物理上只写入二进制 0/1 √")
log.say(f" 数据分区写入次数={phys.data_part.write_count}, "
f"符号分区写入次数={phys.sign_part.write_count}")
# 信息论证: 2 位物理位表达 3 态
info_ratio = 2.0 / math.log2(3)
log.say(f" 信息论证: 每 Trit 占用 2 物理位, 理论熵 {math.log2(3):.3f} bit, "
f"冗余比 {info_ratio:.3f}")
return passed, 3 + n
def test2_fault_injection(log, n=2000, seed=2026):
"""测试2: 分片损坏模拟 ------ 单分区损坏 / 整盘物理损坏。"""
log.title("测试2 | 分片损坏模拟: 分区级故障 与 整盘物理损坏")
results = []
trits = gen_trits(n, seed)
# ---------- 场景①: 符号分区损坏 ----------
log.say("[场景①] 符号分区 sign_part 损坏(数据分区完好)")
st = SingleDriveDualPartition("测试2-场景①")
for i, t in enumerate(trits):
st.write(i, t)
st.destroy_partition("sign")
try:
st.read(0)
can_read = True
except PartitionReadError:
can_read = False
log.say(f" - 符号分区损坏后读取: {'意外成功!' if can_read else '读取失败(无法合成) √'}")
bits, candidates, gap = data_part_noise_analysis(st, trits)
ones = sum(1 for b in bits if b == 1)
log.say(f" - 数据分区原始位序列(前40): {bits[:40]}")
log.say(f" - 数据分区内容统计: {n} 个扇区, abs=1 的 {ones} 个, abs=0 的 {n - ones} 个")
log.say(f" - 信息分析: 每扇区仅 1 bit, 理论每 trit 需 {math.log2(3):.3f} bit, "
f"缺口 {gap:.3f} bit/trit")
log.say(f" - 与该数据分区内容自洽的候选还原序列多达 2^{ones} = {candidates} 种, "
f"无法唯一确定原始 trit")
demo = [(i, bits[i]) for i in range(4) if bits[i] is not None][:4]
log.say(f" - 歧义演示(数据分区位 {[b for _, b in demo]}): 每个 abs=1 既可为 +1 也可为 -1")
ok1 = (not can_read) and candidates > 1
results.append(("① 符号分区损坏 -> 无法还原(数据分区沦为绝对值噪声)", ok1))
log.say("")
# ---------- 场景②: 数据分区损坏 ----------
log.say("[场景②] 数据分区 data_part 损坏(符号分区完好)")
st2 = SingleDriveDualPartition("测试2-场景②")
for i, t in enumerate(trits):
st2.write(i, t)
st2.destroy_partition("data")
try:
st2.read(0)
can_read2 = True
except PartitionReadError:
can_read2 = False
log.say(f" - 数据分区损坏后读取: {'意外成功!' if can_read2 else '读取失败(无法合成) √'}")
log.say(f" - 说明: 数据分区承载绝对值信息(Abs 决定 |Result|), 损坏后连 |0|/|1| 都无法区分")
ok2 = (not can_read2)
results.append(("② 数据分区损坏 -> 无法还原", ok2))
log.say("")
# ---------- 场景③: 整块物理硬盘硬件损坏(固有短板) ----------
log.say("[场景③] 整块物理硬盘硬件本体损坏")
st3 = SingleDriveDualPartition("测试2-场景③")
for i, t in enumerate(trits):
st3.write(i, t)
# 记录损坏前两分区各自扇区数(完好状态)
before_d = len(st3.data_part.bitmap)
before_s = len(st3.sign_part.bitmap)
st3.destroy_physical_disk()
try:
st3.read(0)
can_read3 = True
except PartitionReadError:
can_read3 = False
log.say(f" - 物理硬盘损坏前: 数据分区 {before_d} 个扇区, 符号分区 {before_s} 个扇区, 均完好")
log.say(f" - 物理硬盘损坏后: 数据分区 [失效], 符号分区 [失效] "
f"-> 两个分区【同时失效】")
log.say(f" - 损坏后读取: {'意外成功!' if can_read3 else '读取失败(全部数据丢失) √'}")
log.say(f" - 结论: 单硬盘双分区方案下, 一旦硬盘硬件本体损坏, 数据分区与符号分区")
log.say(f" 会同时失效, 直接丢失全部数据 -> 【失去双物理磁盘带来的硬件故障隔离能力】")
ok3 = (not can_read3)
results.append(("③ 整盘物理损坏 -> 双分区同时失效, 全部数据丢失(固有短板)", ok3))
return results
def test3_compare(log):
"""测试3: 对比测试 ------ 单盘双分区 vs 双独立物理磁盘。"""
log.title("测试3 | 对比测试: 单硬盘双分区 vs 双独立物理磁盘")
log.say("")
log.say("对比维度 | 单硬盘双分区(原型) | 双独立物理磁盘(生产)")
log.hr("-", 78)
log.say("物理介质数量 | 1 块(SSD/HDD) | 2 块独立磁盘")
log.say("逻辑划分 | data_part + sign_part | Data Disk + Sign Disk")
log.say("编码/映射规则 | 与双盘版完全一致 | 与单盘版完全一致")
log.say("硬件门槛 | 最低(消费级单盘即可) | 需额外购置第二块盘")
log.say("硬件故障隔离 | 无: 整盘损坏双分区同毁 | 有: 单盘损坏另一盘幸存")
log.say("容灾能力 | 无(单点故障) | 可换盘重建/异地分存")
log.say("适用场景 | 原理验证/小规模实验 | 生产高可靠/容灾业务")
log.say("数据安全定位 | 原型验证方案 | 生产首选方案")
log.say("")
log.say("结论: 单硬盘双分区把原型门槛压到消费级设备, 映射规则与双盘版本")
log.say(" 完全一致; 但因两分区寄宿同一物理硬盘, 不提供硬件故障隔离,")
log.say(" 仅适合原型验证与小规模实验研究。")
return True
# ---------------------------------------------------------------------------
# 7. 样例数据 / 报告 / SVG 生成
# ---------------------------------------------------------------------------
def build_samples_file(path, n=20, seed=2026):
"""生成测试样例数据文件(映射表 + 随机样本写入/读出明细)。"""
lines = []
lines.append("=" * 64)
lines.append("SMS 单硬盘双分区架构 ------ 测试样例数据")
lines.append(f"生成时间: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
lines.append("=" * 64)
lines.append("")
lines.append("[1] 三态映射表(单硬盘双分区版, 与双物理磁盘版完全一致)")
lines.append(" Trit | 绝对值位Abs | 符号位Sign | 合成公式")
lines.append("-" * 46)
lines.append(" -1 | 1 | 1 | (-1)^1 * 1 = -1")
lines.append(" 0 | 0 | 0 | Abs=0 特例强制 = 0")
lines.append(" 1 | 1 | 0 | (-1)^0 * 1 = 1")
lines.append("")
lines.append(" 写入流程: Trit -> (Abs,Sign) -> 写数据分区 data_part + 符号分区 sign_part")
lines.append(" 读取流程: 相同地址取 (Abs,Sign) -> Result = (-1)^Sign * Abs")
lines.append(" 特例兜底: Abs=0 时强制输出 0(规避奇异点)")
lines.append("")
lines.append(f"[2] 随机样例 {n} 个 (seed={seed}): Trit -> (Abs,Sign) 双分区写入 -> 读出还原")
lines.append(f" {'地址':>4} | {'Trit':>5} | {'Abs位':>5} | {'Sign位':>6} | 读出 | 无损")
lines.append("-" * 52)
trits = gen_trits(n, seed)
phys = SingleDriveDualPartition("样例-单盘双分区")
ld = LogicalDisk(phys)
all_ok = True
for i, t in enumerate(trits):
a, s = encode_trit(t)
ld.write(i, t)
r = ld.read(i)
ok = (r == t)
all_ok &= ok
lines.append(f" {i:>4} | {t:>5} | {a:>5} | {s:>6} | {r:>3} | {'√' if ok else '×'}")
lines.append("")
lines.append(f"[3] 结论: {n} 个样例 100% 无损还原 "
f"({'全部一致' if all_ok else '存在不一致!'})")
lines.append("")
lines.append("[4] 物理位检查: 数据分区与符号分区物理上均只写入二进制 0/1,")
lines.append(" 三态数据以 2 物理位承载 1 Trit(log2(3)≈1.585 bit)。")
with open(path, "w", encoding="utf-8-sig") as f:
f.write("\n".join(lines) + "\n")
def build_report(path, stamp, stats, fault_rows, ok4, outdir):
"""生成仿真报告文本保存到输出目录。"""
total, passed, rate = stats
lines = []
lines.append("=" * 78)
lines.append("SMS 单硬盘双分区轻量化原型 ------ 行为级仿真报告")
lines.append(f"仿真时间: {stamp}")
lines.append("仿真类型: 纯逻辑行为仿真(非 SPICE 硬件仿真), 仅 Python 标准库")
lines.append("=" * 78)
lines.append("")
lines.append("【1】架构原理(单硬盘双分区模式)")
lines.append(" 物理介质: 1 块 SSD/HDD, 内部切割两个独立逻辑分区")
lines.append(" - 数据分区 data_part: 存绝对值 Abs(仅二进制 0/1)")
lines.append(" - 符号分区 sign_part: 存符号位 Sign(仅二进制 0/1)")
lines.append(" 映射规则(与双物理磁盘版本完全一致):")
lines.append(" |-1|=1, |0|=0, |1|=1 ; 符号 -1->1(负), 0->0(零), 1->0(正)")
lines.append(" 写入流程: Trit -> (Abs, Sign) -> 写两个分区【完全相同】地址")
lines.append(" 读取流程: 相同地址取 (Abs, Sign) -> Result = (-1)^Sign * Abs")
lines.append(" 特例兜底: Abs=0 时强制输出 0(规避数学奇异点)")
lines.append(" 上层接口: 业务程序只看见一块统一逻辑硬盘, 底层拆分/合成被封装隐藏")
lines.append("")
lines.append("【2】测试统计")
lines.append(f" 总测试样本数(读写无损比对): {total}")
lines.append(f" 读写无损通过数: {passed}")
lines.append(f" 读写无损通过率: {rate:.4f}%")
lines.append("")
lines.append("【3】分片损坏模拟验证结果")
for name, ok in fault_rows:
lines.append(f" [{'√ 通过' if ok else '× 未通过'}] {name}")
lines.append(f" [{'√ 通过' if ok4 else '× 未通过'}] ④ 对比测试: 单盘双分区 vs 双独立磁盘")
lines.append("")
lines.append("【4】关键结论")
lines.append(" 1) 读写 100% 无损: -1/0/1 三态数据经拆分->双分区写入->合成还原, ")
lines.append(" 与原始数据完全一致, 三态数据可在二进制介质上无损存储还原。")
lines.append(" 2) 分区级故障: 符号分区或数据分区任一分区损坏, 均无法还原原始")
lines.append(" 三态数据; 幸存分区内容仅为 0/1 绝对值噪声(候选还原序列指数歧义)。")
lines.append(" 3) 固有短板: 两个分区寄宿同一物理硬盘, 硬盘硬件本体损坏时")
lines.append(" 双分区同时失效, 直接丢失全部数据 -> 失去硬件故障隔离能力。")
lines.append(" 4) 定位: 单硬盘双分区是【原型验证方案】, 适合原理验证、小规模")
lines.append(" 实验研究; 对数据安全、容灾有要求的场景应选用双独立物理磁盘。")
lines.append(" 5) 存储开销: 2 物理位表达 1 个三态(信息熵 1.585 bit), ")
lines.append(" 等效空间翻倍, 换取二进制介质上的三态无损承载。")
lines.append("")
lines.append("=" * 78)
lines.append("【附】可粘贴的仿真结果摘要")
lines.append("=" * 78)
lines.append(
f"【仿真结果摘要】SMS(符号-绝对值分离)三态存储架构的单硬盘双分区轻量化原型, "
f"仅需 1 块 SSD/HDD 即可搭建: 在同一物理硬盘内切割数据分区(存 Abs)与符号分区"
f"(存 Sign), 写入时将三态值拆分后写入两分区相同地址, 读取时按合成公式 "
f"Result=(-1)^Sign*Abs 还原, Abs=0 特例强制输出 0 规避奇异点; 上层业务程序"
f"只看见一块统一逻辑硬盘。行为级仿真结论: ①对 {total} 个随机三态样本执行"
f"拆分->双分区写入->合成还原, 无损通过率 {rate:.2f}%, 三态数据可在二进制介质上"
f"无损存储还原; ②分片损坏模拟: 任一分区损坏即无法还原, 幸存分区仅为绝对值噪声;"
f"③固有短板: 硬盘硬件本体损坏时两分区同时失效、全部数据丢失, 失去双物理磁盘"
f"的硬件故障隔离能力, 故本方案定位为原型验证, 高可靠场景仍应选用双独立磁盘。"
f"存储开销为 2 物理位/三态(理论熵 1.585 bit)。"
)
lines.append("")
lines.append(f"输出文件目录: {outdir}")
with open(path, "w", encoding="utf-8-sig") as f:
f.write("\n".join(lines) + "\n")
def build_svg(outdir, stats, stamp):
"""生成单硬盘双分区架构示意图与测试结果图(纯标准库手写 SVG)。"""
total, passed, rate = stats
files = []
# ---- 架构示意图 ----
svg_arch = []
W, H = 860, 520
svg_arch.append(f'<svg xmlns="http://www.w3.org/2000/svg" width="{W}" height="{H}" viewBox="0 0 {W} {H}">')
svg_arch.append('<rect x="0" y="0" width="100%" height="100%" fill="#0f1420"/>')
svg_arch.append('<style>text{font-family:Microsoft YaHei,Arial,sans-serif}</style>')
# 标题
svg_arch.append(f'<text x="430" y="38" text-anchor="middle" fill="#7dd3fc" font-size="22" font-weight="bold">SMS 单硬盘双分区轻量化原型架构</text>')
svg_arch.append(f'<text x="430" y="62" text-anchor="middle" fill="#9aa4b5" font-size="13">{stamp}</text>')
# 上层业务程序
svg_arch.append('<rect x="230" y="90" width="400" height="52" rx="8" fill="#1e3a5f" stroke="#38bdf8" stroke-width="1.5"/>')
svg_arch.append('<text x="430" y="114" text-anchor="middle" fill="#e0f2fe" font-size="14">上层业务程序</text>')
svg_arch.append('<text x="430" y="132" text-anchor="middle" fill="#93c5fd" font-size="11">只看见一块统一逻辑硬盘, 读写与普通硬盘无差别</text>')
# 逻辑硬盘接口
svg_arch.append('<rect x="290" y="160" width="280" height="40" rx="6" fill="#233a54" stroke="#60a5fa" stroke-width="1"/>')
svg_arch.append('<text x="430" y="186" text-anchor="middle" fill="#bfdbfe" font-size="12">逻辑硬盘接口 LogicalDisk(封装拆分/合成)</text>')
# 箭头
svg_arch.append('<line x1="430" y1="142" x2="430" y2="158" stroke="#60a5fa" stroke-width="1.5" marker-end="url(#arr)"/>')
svg_arch.append('<line x1="430" y1="200" x2="430" y2="216" stroke="#60a5fa" stroke-width="1.5" marker-end="url(#arr)"/>')
# 物理硬盘
svg_arch.append('<rect x="150" y="220" width="560" height="150" rx="10" fill="#1b2537" stroke="#94a3b8" stroke-width="2"/>')
svg_arch.append('<text x="430" y="244" text-anchor="middle" fill="#cbd5e1" font-size="14" font-weight="bold">单颗物理硬盘 SSD/HDD</text>')
svg_arch.append('<text x="430" y="262" text-anchor="middle" fill="#64748b" font-size="10">硬盘硬件本体损坏 -> 两个分区同时失效, 全部数据丢失(固有短板)</text>')
# 数据分区
svg_arch.append('<rect x="175" y="278" width="255" height="76" rx="8" fill="#0f2b24" stroke="#34d399" stroke-width="1.5"/>')
svg_arch.append('<text x="302" y="302" text-anchor="middle" fill="#6ee7b7" font-size="13" font-weight="bold">数据分区 data_part</text>')
svg_arch.append('<text x="302" y="322" text-anchor="middle" fill="#a7f3d0" font-size="11">绝对值 Abs: |-1|=1 |0|=0 |1|=1</text>')
svg_arch.append('<text x="302" y="340" text-anchor="middle" fill="#a7f3d0" font-size="11">仅存二进制位 0 / 1</text>')
# 符号分区
svg_arch.append('<rect x="435" y="278" width="255" height="76" rx="8" fill="#33171c" stroke="#f87171" stroke-width="1.5"/>')
svg_arch.append('<text x="562" y="302" text-anchor="middle" fill="#fca5a5" font-size="13" font-weight="bold">符号分区 sign_part</text>')
svg_arch.append('<text x="562" y="322" text-anchor="middle" fill="#fecaca" font-size="11">符号位 Sign: -1->1 0->0 1->0</text>')
svg_arch.append('<text x="562" y="340" text-anchor="middle" fill="#fecaca" font-size="11">仅存二进制位 0 / 1</text>')
# 中间分隔线
svg_arch.append('<line x1="430" y1="278" x2="430" y2="354" stroke="#475569" stroke-width="1" stroke-dasharray="4,4"/>')
# 写入/读取说明
svg_arch.append('<text x="430" y="392" text-anchor="middle" fill="#93c5fd" font-size="12">写入: Trit -> (Abs,Sign) -> 两分区相同地址写入</text>')
svg_arch.append('<text x="430" y="412" text-anchor="middle" fill="#93c5fd" font-size="12">读取: 相同地址取 (Abs,Sign) -> Result = (-1)^Sign * Abs</text>')
svg_arch.append('<text x="430" y="432" text-anchor="middle" fill="#93c5fd" font-size="12">特例兜底: Abs = 0 时强制输出 0(规避奇异点)</text>')
# 结论
svg_arch.append('<text x="430" y="470" text-anchor="middle" fill="#fbbf24" font-size="13">三态数据 -1/0/1 在单块二进制硬盘上无损存储还原 | 定位: 原型验证方案</text>')
svg_arch.append('<defs><marker id="arr" markerWidth="8" markerHeight="8" refX="6" refY="4" orient="auto"><path d="M0,0 L8,4 L0,8 Z" fill="#60a5fa"/></marker></defs>')
svg_arch.append('</svg>')
arch_path = os.path.join(outdir, "sms_single_drive_architecture.svg")
with open(arch_path, "w", encoding="utf-8") as f:
f.write("\n".join(svg_arch))
files.append(arch_path)
# ---- 测试结果统计图 ----
svg_res = []
RW = 860
RH = 460
svg_res.append(f'<svg xmlns="http://www.w3.org/2000/svg" width="{RW}" height="{RH}" viewBox="0 0 {RW} {RH}">')
svg_res.append('<rect x="0" y="0" width="100%" height="100%" fill="#0f1420"/>')
svg_res.append('<style>text{font-family:Microsoft YaHei,Arial,sans-serif}</style>')
svg_res.append(f'<text x="430" y="38" text-anchor="middle" fill="#7dd3fc" font-size="22" font-weight="bold">单硬盘双分区仿真结果</text>')
svg_res.append(f'<text x="430" y="62" text-anchor="middle" fill="#9aa4b5" font-size="13">{stamp}</text>')
# 无损率条形
svg_res.append('<text x="430" y="112" text-anchor="middle" fill="#e2e8f0" font-size="14">基础读写无损通过率</text>')
svg_res.append(f'<text x="430" y="196" text-anchor="middle" fill="#4ade80" font-size="42" font-weight="bold">{rate:.2f}%</text>')
svg_res.append(f'<text x="430" y="222" text-anchor="middle" fill="#94a3b8" font-size="12">共 {total} 个随机三态样本: 拆分 -> 双分区写入 -> 合成还原</text>')
svg_res.append('<rect x="180" y="242" width="500" height="18" rx="9" fill="#1e293b"/>')
svg_res.append(f'<rect x="180" y="242" width="{500*rate/100:.1f}" height="18" rx="9" fill="#22c55e"/>')
svg_res.append('<text x="430" y="290" text-anchor="middle" fill="#cbd5e1" font-size="13">分片损坏模拟</text>')
rows = [
("符号分区损坏 -> 无法还原, 数据分区沦为绝对值噪声", True, "#f87171"),
("数据分区损坏 -> 无法还原", True, "#f87171"),
("整盘物理损坏 -> 双分区同时失效, 全部数据丢失(固有短板)", True, "#fb923c"),
("对比: 双独立物理磁盘可提供硬件故障隔离", True, "#38bdf8"),
]
y = 316
for txt, ok, col in rows:
svg_res.append(f'<circle cx="215" cy="{y+8}" r="6" fill="{col if ok else "#64748b"}"/>')
svg_res.append(f'<text x="228" y="{y+12}" fill="#e2e8f0" font-size="12">{txt}</text>')
y += 30
svg_res.append('<text x="430" y="442" text-anchor="middle" fill="#fbbf24" font-size="12">结论: 原型验证可行; 高可靠/容灾场景应选用双独立物理磁盘</text>')
svg_res.append('</svg>')
res_path = os.path.join(outdir, "sms_single_drive_results.svg")
with open(res_path, "w", encoding="utf-8") as f:
f.write("\n".join(svg_res))
files.append(res_path)
return files
# ---------------------------------------------------------------------------
# 8. 主流程
# ---------------------------------------------------------------------------
def main():
_setup_console_encoding()
seed = 2026
N_BIG = 2000
# 默认输出目录(用户指定); 支持命令行参数覆盖: python xxx.py <目录>
default_out = os.path.join(
os.path.expanduser("~"), "Desktop", "三进制", "SMS拓扑存储",
"单盘分区无损存储3禁止数据")
if len(sys.argv) > 1:
default_out = sys.argv[1]
os.makedirs(default_out, exist_ok=True)
stamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
log = Reporter()
log.title("SMS 单硬盘双分区轻量化原型 ------ 行为级仿真")
log.say(f"行为级仿真(非 SPICE 硬件仿真) | 时间: {stamp}")
log.say(f"输出目录: {default_out}")
log.say("")
# ---- 测试1: 基础读写单元 ----
p1, t1 = test1_basic_rw(log, N_BIG, seed)
# ---- 测试2: 分片损坏模拟 ----
fault_rows = test2_fault_injection(log, N_BIG, seed)
# ---- 测试3: 对比 ----
ok4 = test3_compare(log)
# ---- 汇总统计 ----
total = t1
passed = p1
rate = passed / total * 100.0
log.say("")
log.hr("=")
log.say("测试统计汇总")
log.hr("=")
log.say(f" 总测试样本数(读写无损比对): {total}")
log.say(f" 读写无损通过数: {passed}")
log.say(f" 读写无损通过率: {rate:.4f}%")
log.say("")
log.say("分片损坏模拟验证结果:")
for name, ok in fault_rows:
log.say(f" [{'√ 通过' if ok else '× 未通过'}] {name}")
log.say(f" [{'√ 通过' if ok4 else '× 未通过'}] ④ 对比测试: 单盘双分区 vs 双独立磁盘")
log.say("")
# ---- 落盘: 日志 / 报告 / 样例 ----
log_path = os.path.join(default_out, "sms_single_drive_test_log.txt")
rep_path = os.path.join(default_out, "sms_single_drive_sim_report.txt")
sample_path = os.path.join(default_out, "sms_single_drive_samples.txt")
log.flush(log_path)
build_samples_file(sample_path, n=20, seed=seed)
build_report(rep_path, stamp, (total, passed, rate), fault_rows, ok4, default_out)
# ---- 生成 SVG 示意图(纯标准库手写, 失败不影响主流程) ----
svg_files = []
try:
svg_files = build_svg(default_out, (total, passed, rate), stamp)
except Exception as e:
log.say(f"[警告] 生成 SVG 仿真图片失败: {e}")
log.say("输出文件:")
log.say(f" 仿真报告 -> {rep_path}")
log.say(f" 测试日志 -> {log_path}")
log.say(f" 样例数据 -> {sample_path}")
for f in svg_files:
log.say(f" 仿真图片 -> {f}")
log.say("")
log.hr("=")
log.say("【可粘贴】仿真结果摘要")
log.hr("=")
log.say(
f"【仿真结果摘要】SMS(符号-绝对值分离)三态存储架构的单硬盘双分区轻量化原型, "
f"仅需 1 块 SSD/HDD 即可搭建: 在同一物理硬盘内切割数据分区(存 Abs)与符号分区"
f"(存 Sign), 写入时将三态值拆分后写入两分区相同地址, 读取时按合成公式 "
f"Result=(-1)^Sign*Abs 还原, Abs=0 特例强制输出 0 规避奇异点; 上层业务程序"
f"只看见一块统一逻辑硬盘。行为级仿真结论: ①对 {total} 个随机三态样本执行"
f"拆分->双分区写入->合成还原, 无损通过率 {rate:.2f}%; ②分片损坏模拟: "
f"任一分区损坏即无法还原, 幸存分区仅为绝对值噪声; ③固有短板: 硬盘硬件本体"
f"损坏时两分区同时失效、全部数据丢失, 失去双物理磁盘的硬件故障隔离能力, "
f"故本方案定位为原型验证, 高可靠场景仍应选用双独立磁盘。"
f"存储开销为 2 物理位/三态(理论熵 1.585 bit)。")
if __name__ == "__main__":
main()
try:
input("\n按回车键退出...") # 双击运行时保持窗口
except EOFError:
pass一、测试数据1
================================================================ SMS 单硬盘双分区架构 ------ 测试样例数据 生成时间: 2026-08-24 13:42:49 ================================================================ 1 三态映射表(单硬盘双分区版, 与双物理磁盘版完全一致) Trit | 绝对值位Abs | 符号位Sign | 合成公式 ---------------------------------------------- -1 | 1 | 1 | (-1)^1 * 1 = -1 0 | 0 | 0 | Abs=0 特例强制 = 0 1 | 1 | 0 | (-1)^0 * 1 = 1 写入流程: Trit -> (Abs,Sign) -> 写数据分区 data_part + 符号分区 sign_part 读取流程: 相同地址取 (Abs,Sign) -> Result = (-1)^Sign * Abs 特例兜底: Abs=0 时强制输出 0(规避奇异点) 2 随机样例 20 个 (seed=2026): Trit -> (Abs,Sign) 双分区写入 -> 读出还原 地址 | Trit | Abs位 | Sign位 | 读出 | 无损 ---------------------------------------------------- 0 | -1 | 1 | 1 | -1 | √ 1 | 0 | 0 | 0 | 0 | √ 2 | 1 | 1 | 0 | 1 | √ 3 | 1 | 1 | 0 | 1 | √ 4 | 1 | 1 | 0 | 1 | √ 5 | -1 | 1 | 1 | -1 | √ 6 | -1 | 1 | 1 | -1 | √ 7 | 1 | 1 | 0 | 1 | √ 8 | 1 | 1 | 0 | 1 | √ 9 | 1 | 1 | 0 | 1 | √ 10 | 0 | 0 | 0 | 0 | √ 11 | 1 | 1 | 0 | 1 | √ 12 | 1 | 1 | 0 | 1 | √ 13 | 1 | 1 | 0 | 1 | √ 14 | 0 | 0 | 0 | 0 | √ 15 | 1 | 1 | 0 | 1 | √ 16 | 0 | 0 | 0 | 0 | √ 17 | -1 | 1 | 1 | -1 | √ 18 | -1 | 1 | 1 | -1 | √ 19 | 1 | 1 | 0 | 1 | √ 3 结论: 20 个样例 100% 无损还原 (全部一致) 4 物理位检查: 数据分区与符号分区物理上均只写入二进制 0/1, 三态数据以 2 物理位承载 1 Trit(log2(3)≈1.585 bit)。
二、行为仿真报告
==============================================================================
SMS 单硬盘双分区轻量化原型 ------ 行为级仿真报告
仿真时间: 2026-08-24 13:42:49
仿真类型: 纯逻辑行为仿真(非 SPICE 硬件仿真), 仅 Python 标准库
==============================================================================
【1】架构原理(单硬盘双分区模式)
物理介质: 1 块 SSD/HDD, 内部切割两个独立逻辑分区
-
数据分区 data_part: 存绝对值 Abs(仅二进制 0/1)
-
符号分区 sign_part: 存符号位 Sign(仅二进制 0/1)
映射规则(与双物理磁盘版本完全一致):
|-1|=1, |0|=0, |1|=1 ; 符号 -1->1(负), 0->0(零), 1->0(正)
写入流程: Trit -> (Abs, Sign) -> 写两个分区【完全相同】地址
读取流程: 相同地址取 (Abs, Sign) -> Result = (-1)^Sign * Abs
特例兜底: Abs=0 时强制输出 0(规避数学奇异点)
上层接口: 业务程序只看见一块统一逻辑硬盘, 底层拆分/合成被封装隐藏
【2】测试统计
总测试样本数(读写无损比对): 2003
读写无损通过数: 2003
读写无损通过率: 100.0000%
【3】分片损坏模拟验证结果
√ 通过 ① 符号分区损坏 -> 无法还原(数据分区沦为绝对值噪声)
√ 通过 ② 数据分区损坏 -> 无法还原
√ 通过 ③ 整盘物理损坏 -> 双分区同时失效, 全部数据丢失(固有短板)
√ 通过 ④ 对比测试: 单盘双分区 vs 双独立磁盘
【4】关键结论
- 读写 100% 无损: -1/0/1 三态数据经拆分->双分区写入->合成还原,
与原始数据完全一致, 三态数据可在二进制介质上无损存储还原。
- 分区级故障: 符号分区或数据分区任一分区损坏, 均无法还原原始
三态数据; 幸存分区内容仅为 0/1 绝对值噪声(候选还原序列指数歧义)。
- 固有短板: 两个分区寄宿同一物理硬盘, 硬盘硬件本体损坏时
双分区同时失效, 直接丢失全部数据 -> 失去硬件故障隔离能力。
- 定位: 单硬盘双分区是【原型验证方案】, 适合原理验证、小规模
实验研究; 对数据安全、容灾有要求的场景应选用双独立物理磁盘。
- 存储开销: 2 物理位表达 1 个三态(信息熵 1.585 bit),
等效空间翻倍, 换取二进制介质上的三态无损承载。
==============================================================================
【附】可粘贴的仿真结果摘要
==============================================================================
【仿真结果摘要】SMS(符号-绝对值分离)三态存储架构的单硬盘双分区轻量化原型, 仅需 1 块 SSD/HDD 即可搭建: 在同一物理硬盘内切割数据分区(存 Abs)与符号分区(存 Sign), 写入时将三态值拆分后写入两分区相同地址, 读取时按合成公式 Result=(-1)^Sign*Abs 还原, Abs=0 特例强制输出 0 规避奇异点; 上层业务程序只看见一块统一逻辑硬盘。行为级仿真结论: ①对 2003 个随机三态样本执行拆分->双分区写入->合成还原, 无损通过率 100.00%, 三态数据可在二进制介质上无损存储还原; ②分片损坏模拟: 任一分区损坏即无法还原, 幸存分区仅为绝对值噪声;③固有短板: 硬盘硬件本体损坏时两分区同时失效、全部数据丢失, 失去双物理磁盘的硬件故障隔离能力, 故本方案定位为原型验证, 高可靠场景仍应选用双独立磁盘。存储开销为 2 物理位/三态(理论熵 1.585 bit)。
三、行为仿真结果
========================================================================
SMS 单硬盘双分区轻量化原型 ------ 行为级仿真
========================================================================
行为级仿真(非 SPICE 硬件仿真) | 时间: 2026-08-24 13:42:49
========================================================================
测试1 | 基础读写单元: 三态拆分 / 双分区写入 / 读取合成还原
========================================================================
1a 三态穷举编码 -> 双分区写入 -> 合成还原:
Trit | 绝对值位Abs | 符号位Sign | 合成Result | 一致
-1 | 1 | 1 | -1 | √ 无损
0 | 0 | 0 | 0 | √ 无损
1 | 1 | 0 | 1 | √ 无损
特例 Abs=0, Sign=1(脏位) -> 强制输出 0, 忽略符号位 √ 符合兜底规则
1b 随机大样本 2000 个 Trit 写入/读取 100% 比对:
写入 2000 个 -> 读出 2000 个一致, 失败 0 个 (100.0000% 无损)
双分区物理位检查: 数据分区仅含位 0, 1, 符号分区仅含位 0, 1 -> 确认两个分区物理上只写入二进制 0/1 √
数据分区写入次数=2000, 符号分区写入次数=2000
信息论证: 每 Trit 占用 2 物理位, 理论熵 1.585 bit, 冗余比 1.262
========================================================================
测试2 | 分片损坏模拟: 分区级故障 与 整盘物理损坏
========================================================================
场景① 符号分区 sign_part 损坏(数据分区完好)
-
符号分区损坏后读取: 读取失败(无法合成) √
-
数据分区原始位序列(前40): 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1
-
数据分区内容统计: 2000 个扇区, abs=1 的 1315 个, abs=0 的 685 个
-
信息分析: 每扇区仅 1 bit, 理论每 trit 需 1.585 bit, 缺口 0.585 bit/trit
-
与该数据分区内容自洽的候选还原序列多达 2^1315 = 715227654321105596037781310767505300372785543655583400456506150219731024267185582758198115359386079359488955926034786682526617722054379145757832689022055369690574489153523621120538149129731744269646816697399010360106215617899252532930417252872272820546013722362775848677900203397125776927522250380073505493194598525493593700833121972455581299381949632923860462181013191641770033535600045502496768 种, 无法唯一确定原始 trit
-
歧义演示(数据分区位 1, 0, 1, 1): 每个 abs=1 既可为 +1 也可为 -1
场景② 数据分区 data_part 损坏(符号分区完好)
-
数据分区损坏后读取: 读取失败(无法合成) √
-
说明: 数据分区承载绝对值信息(Abs 决定 |Result|), 损坏后连 |0|/|1| 都无法区分
场景③ 整块物理硬盘硬件本体损坏
-
物理硬盘损坏前: 数据分区 2000 个扇区, 符号分区 2000 个扇区, 均完好
-
物理硬盘损坏后: 数据分区 失效, 符号分区 失效 -> 两个分区【同时失效】
-
损坏后读取: 读取失败(全部数据丢失) √
-
结论: 单硬盘双分区方案下, 一旦硬盘硬件本体损坏, 数据分区与符号分区
会同时失效, 直接丢失全部数据 -> 【失去双物理磁盘带来的硬件故障隔离能力】
========================================================================
测试3 | 对比测试: 单硬盘双分区 vs 双独立物理磁盘
========================================================================
对比维度 | 单硬盘双分区(原型) | 双独立物理磁盘(生产)
物理介质数量 | 1 块(SSD/HDD) | 2 块独立磁盘
逻辑划分 | data_part + sign_part | Data Disk + Sign Disk
编码/映射规则 | 与双盘版完全一致 | 与单盘版完全一致
硬件门槛 | 最低(消费级单盘即可) | 需额外购置第二块盘
硬件故障隔离 | 无: 整盘损坏双分区同毁 | 有: 单盘损坏另一盘幸存
容灾能力 | 无(单点故障) | 可换盘重建/异地分存
适用场景 | 原理验证/小规模实验 | 生产高可靠/容灾业务
数据安全定位 | 原型验证方案 | 生产首选方案
结论: 单硬盘双分区把原型门槛压到消费级设备, 映射规则与双盘版本
完全一致; 但因两分区寄宿同一物理硬盘, 不提供硬件故障隔离,
仅适合原型验证与小规模实验研究。
========================================================================
测试统计汇总
========================================================================
总测试样本数(读写无损比对): 2003
读写无损通过数: 2003
读写无损通过率: 100.0000%
分片损坏模拟验证结果:
√ 通过 ① 符号分区损坏 -> 无法还原(数据分区沦为绝对值噪声)
√ 通过 ② 数据分区损坏 -> 无法还原
√ 通过 ③ 整盘物理损坏 -> 双分区同时失效, 全部数据丢失(固有短板)
√ 通过 ④ 对比测试: 单盘双分区 vs 双独立磁盘